A Text Statistics Tool That Classifies Hiragana, Katakana, and Kanji Separately

Word count tools work fine for English. For Japanese they're mostly useless — there's no space between words, so "word count" doesn't exist in the normal sense. But character count broken down by script (hiragana / katakana / kanji / ASCII) is useful: it tells you the vocabulary mix, the reading difficulty, and the writing style.

Paste a paragraph. Get character counts, word counts (where meaningful), reading time, speaking time, character frequency distribution, social media limit checks, and a Japanese script breakdown. All client-side, all live, zero dependencies.

🔗 Live demo: https://sen.ltd/portfolio/text-count/

📦 GitHub: https://github.com/sen-ltd/text-count

Features:

• Characters (with/without spaces), words, sentences, paragraphs, lines


• Reading time (200 wpm / 400 wpm)


• Speaking time (150 wpm)


• Japanese script breakdown (hiragana / katakana / kanji / ASCII / digit / other)


• Top 10 words by frequency


• Unique word count, average word/sentence length


• Character frequency chart (top 15)


• Platform limits (Twitter 280, SMS 160, Instagram bio 150, etc.)


• Japanese / English UI


• Zero dependencies, 73 tests

Character classification by Unicode range

export function classifyChar(c) {

  const code = c.charCodeAt(0);

  if (code >= 0x3041 && code <= 0x309F) return 'hiragana';  // ぁ-ゟ

  if (code >= 0x30A0 && code <= 0x30FF) return 'katakana';  // ゠-ヿ

  if (code >= 0x4E00 && code <= 0x9FFF) return 'kanji';     // CJK Unified

  if (code >= 0x30 && code <= 0x39) return 'digit';

  if (code >= 0x20 && code <= 0x7E) return 'ascii';

  if (/\s/.test(c)) return 'space';

  return 'other';

}

The Unicode ranges:

• Hiragana: U+3041-U+309F (96 codepoints)


• Katakana: U+30A0-U+30FF (96 codepoints)


• Kanji (CJK Unified Ideographs): U+4E00-U+9FFF (20,992 codepoints)

Everything else is categorized as digit, ASCII, whitespace, or other. This gives you a breakdown like "200 chars total: 120 hiragana, 40 kanji, 30 katakana, 10 ASCII" — which describes Japanese prose more usefully than "200 characters".

The word-count problem

In English, "words" are space-delimited. In Japanese, they aren't:

The quick brown fox   → 4 words

素早い茶色の狐が      → ? words

Japanese word segmentation needs a morphological analyzer (MeCab, Kuromoji) with a dictionary. That's way too heavy for a client-side tool. Instead, I fall back to treating each CJK character as an independent "token":

export function tokenize(text) {

  const tokens = [];

  let buffer = '';

  for (const c of text) {

    const cat = classifyChar(c);

    if (cat === 'hiragana' || cat === 'katakana' || cat === 'kanji') {

      if (buffer) { tokens.push(buffer); buffer = ''; }

      tokens.push(c);

    } else if (cat === 'space') {

      if (buffer) { tokens.push(buffer); buffer = ''; }

    } else {

      buffer += c;

    }

  }

  if (buffer) tokens.push(buffer);

  return tokens;

}

This isn't "correct" Japanese tokenization, but it produces reasonable frequency counts for character-level analysis. The UI is clear that for mixed Japanese text, "word count" approximates character-based tokens.

Social media limits

Every major platform has a character limit, and losing track of them while drafting a post is frustrating. A progress bar per platform:

const LIMITS = {

  twitter: 280,

  sms: 160,

  instagramBio: 150,

  linkedinHeadline: 220,

  youtubeTitle: 100,

};



export function getLimits(text) {

  const len = [...text].length; // code point count, not UTF-16 units

  const result = {};

  for (const [key, max] of Object.entries(LIMITS)) {

    result[key] = { current: len, max, ok: len <= max, percent: (len / max) * 100 };

  }

  return result;

}

[...text].length counts Unicode code points, not UTF-16 code units. For emoji and supplementary plane characters, this matters — "😀".length === 2 but Twitter counts it as 1.

Reading time math

A conventional 200 words per minute for comfortable reading, 400 for skimming, 150 for speaking aloud:

export function readingTime(wordCount, wpm = 200) {

  return Math.ceil((wordCount / wpm) * 60); // seconds

}

For Japanese where "words" are character tokens, the number isn't perfectly accurate, but it's within a factor of 2 — enough for a "this post will take ~3 minutes to read" estimate.

Series

This is entry #76 in my 100+ public portfolio series.

• 📦 Repo: https://github.com/sen-ltd/text-count
  


• 🌐 Live: https://sen.ltd/portfolio/text-count/
  


• 🏢 Company: https://sen.ltd/