kanabarum 0.2.0 → 0.2.2

package/dist/index.cjs

@@ -0,0 +1,940 @@
+'use strict';
+
+var kuromoji = require('kuromoji');
+var path = require('path');
+var module$1 = require('module');
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var kuromoji__default = /*#__PURE__*/_interopDefault(kuromoji);
+var path__default = /*#__PURE__*/_interopDefault(path);
+
+// src/normalizer.ts
+function normalizeInputText(input) {
+  let normalized = input.normalize("NFC");
+  normalized = normalizeHalfwidthKatakanaOnly(normalized);
+  normalized = normalized.replace(/[\u2015\u2500]/g, "\u30FC");
+  normalized = normalized.replace(/(?<=([\u30A0-\u30FF]))-/g, "\u30FC").replace(/-(?=[\u30A0-\u30FF])/g, "\u30FC");
+  return normalized;
+}
+function normalizeHalfwidthKatakanaOnly(s) {
+  return s.replace(
+    /[\uFF66-\uFF9F\uFF70]+/g,
+    (chunk) => chunk.normalize("NFKC")
+  );
+}
+function toHiragana(input) {
+  let out = "";
+  for (const ch of input) {
+    const code = ch.codePointAt(0);
+    if (code >= 12449 && code <= 12534) {
+      out += String.fromCodePoint(code - 96);
+      continue;
+    }
+    if (ch === "\u30FC") {
+      out += ch;
+      continue;
+    }
+    out += ch;
+  }
+  return out;
+}
+
+// src/dictionary.ts
+var SpecialDictionary = [
+  // ["とうきょう", "도쿄"],
+  { word: "\u3053\u3093\u306B\u3061\u306F", answer: "\uACE4\uB2C8\uCE58\uC640", hira: true, kata: true },
+  { word: "\u3053\u3093\u3070\u3093\u306F", answer: "\uACF0\uBC29\uC640" },
+  { word: "\u3059\u307F\u307E\u305B\u3093", answer: "\uC2A4\uBBF8\uB9C8\uC14D" },
+  { word: "\u306F\u3072\u3075\u3078\u307B", answer: "\uD558\uD788\uD6C4\uD5E4\uD638" },
+  { word: "\u304B\u308F\u3044\u3044", answer: "\uCE74\uC640\uC774" },
+  { word: "\u3064\u306A\u307F", answer: "\uC4F0\uB098\uBBF8" },
+  { word: "\u3086\u3046\u308A", answer: "\uC720\uC6B0\uB9AC" },
+  { word: "\u30DF\u30E5\u30FC\u30B8\u30C3\u30AF", answer: "\uBBA4\uC9C0\uCFE0" },
+  { word: "\u3061\u3083\u3093", answer: "\uCA29" }
+];
+
+// src/particleRewriter.ts
+function isKatakanaChar(ch) {
+  const c = ch.codePointAt(0);
+  return c >= 12448 && c <= 12543;
+}
+function containsKanji(s) {
+  for (const ch of s) {
+    const c = ch.codePointAt(0);
+    if (c >= 19968 && c <= 40959 || c >= 13312 && c <= 19903) {
+      return true;
+    }
+  }
+  return false;
+}
+function toHiragana2(s) {
+  const n = s.normalize("NFKC");
+  return Array.from(n).map((ch) => {
+    if (ch === "\u30FC")
+      return "";
+    if (!isKatakanaChar(ch))
+      return ch;
+    const code = ch.codePointAt(0);
+    if (code >= 12449 && code <= 12534) {
+      return String.fromCodePoint(code - 96);
+    }
+    return ch;
+  }).join("");
+}
+function dictKeysForHiraganaText(dict) {
+  const keys = [];
+  for (const e of dict) {
+    keys.push(e.word);
+    if (e.hira)
+      keys.push(toHiragana2(e.word));
+  }
+  return [...new Set(keys)].filter(Boolean);
+}
+function rangesOverlap(a, b) {
+  return a.start < b.end && b.start < a.end;
+}
+function buildProtectedRanges(text, keys) {
+  const sorted = [...new Set(keys)].sort((a, b) => b.length - a.length);
+  const ranges = [];
+  for (const key of sorted) {
+    if (!key)
+      continue;
+    let from = 0;
+    while (true) {
+      const idx = text.indexOf(key, from);
+      if (idx === -1)
+        break;
+      const cand = { start: idx, end: idx + key.length };
+      if (!ranges.some((r) => rangesOverlap(r, cand))) {
+        ranges.push(cand);
+      }
+      from = idx + 1;
+    }
+  }
+  ranges.sort((a, b) => a.start - b.start);
+  return ranges;
+}
+function isProtectedSpan(protectedRanges, start, end) {
+  for (const r of protectedRanges) {
+    if (start < r.end && end > r.start)
+      return true;
+  }
+  return false;
+}
+var HARD_BOUNDARY_SURF = /* @__PURE__ */ new Set([
+  "\u3002",
+  "\u3001",
+  "\uFF01",
+  "\uFF1F",
+  "!",
+  "?",
+  " ",
+  "\u3000"
+]);
+var HARD_BOUNDARY_DETAIL1 = /* @__PURE__ */ new Set([
+  "\u53E5\u70B9",
+  "\u8AAD\u70B9",
+  "\u62EC\u5F27\u958B",
+  "\u62EC\u5F27\u9589",
+  "\u7A7A\u767D"
+]);
+var LEXICAL_HE_ENDINGS = [
+  "\u3044\u306B\u3057\u3078",
+  "\u304A\u304D\u3078",
+  "\u3082\u3068\u3078",
+  "\u3059\u3048\u3078",
+  "\u3059\u3091\u3078",
+  "\u304B\u307F\u3078",
+  "\u304F\u306B\u3078",
+  "\u304D\u3057\u3078"
+];
+function isHardBoundaryToken(t) {
+  if (t.pos !== "\u8A18\u53F7")
+    return false;
+  if (HARD_BOUNDARY_SURF.has(t.surface_form))
+    return true;
+  return HARD_BOUNDARY_DETAIL1.has(t.pos_detail_1 ?? "");
+}
+function isContentToken(t) {
+  if (t.pos === "\u8A18\u53F7")
+    return !isHardBoundaryToken(t);
+  return true;
+}
+function prevContentIdx(tokens, i) {
+  for (let j = i - 1; j >= 0; j -= 1)
+    if (isContentToken(tokens[j]))
+      return j;
+  return -1;
+}
+function nextContentIdx(tokens, i) {
+  for (let j = i + 1; j < tokens.length; j += 1)
+    if (isContentToken(tokens[j]))
+      return j;
+  return -1;
+}
+function nextBoundaryOrEnd(tokens, i) {
+  for (let j = i + 1; j < tokens.length; j += 1) {
+    if (isHardBoundaryToken(tokens[j]))
+      continue;
+    return false;
+  }
+  return true;
+}
+function rewriteParticlesFromTokenization(originalText, hiraganaText, tokenizerTokens) {
+  const hiraChars = Array.from(hiraganaText);
+  const originChars = Array.from(originalText);
+  const protectedRanges = buildProtectedRanges(
+    hiraganaText,
+    dictKeysForHiraganaText(SpecialDictionary)
+  );
+  let out = "";
+  let origOut = "";
+  const spans = [];
+  let cursorInText = 0;
+  for (let i = 0; i < tokenizerTokens.length; i += 1) {
+    const tok = tokenizerTokens[i];
+    const wp = tok.word_position;
+    const surf = tok.surface_form;
+    const surfCpLen = [...surf].length;
+    const start = typeof wp === "number" ? wp - 1 : cursorInText;
+    const end = start + surfCpLen;
+    cursorInText = end;
+    const hasKanji = containsKanji(surf) && tok.pronunciation;
+    const hiraSurf = hasKanji ? toHiragana2(tok.pronunciation) : hiraChars.slice(start, end).join("");
+    const origSurfForOut = hasKanji ? tok.pronunciation.replace(/ー/g, "") : originChars.slice(start, end).join("");
+    const originSurf = originChars.slice(start, end).join("");
+    const originHadKatakana = /[\u30A0-\u30FF]/.test(originSurf);
+    if (isProtectedSpan(protectedRanges, start, end)) {
+      const outCpStart2 = [...out].length;
+      out += hiraSurf;
+      origOut += origSurfForOut;
+      spans.push({
+        start: outCpStart2,
+        end: [...out].length,
+        surface: hiraSurf,
+        pos: tok.pos,
+        pos1: tok.pos_detail_1 ?? void 0,
+        pos2: tok.pos_detail_2 ?? void 0,
+        pos3: tok.pos_detail_3 ?? void 0,
+        originHadKatakana
+      });
+      continue;
+    }
+    let replaced = hiraSurf;
+    if (tok.pos === "\u52A9\u8A5E" && hiraSurf === "\u306F") {
+      if (i > 0 && tokenizerTokens[i - 1].surface_form === "\u306F") ; else if (i + 1 < tokenizerTokens.length && tokenizerTokens[i + 1].surface_form === "\u306F") ; else {
+        const prevIdx = prevContentIdx(tokenizerTokens, i);
+        if (prevIdx >= 0) {
+          const nextIdx = nextContentIdx(tokenizerTokens, i);
+          const hasNextContent = nextIdx >= 0;
+          const isEndOrPunct = nextBoundaryOrEnd(tokenizerTokens, i);
+          const prevTok = tokenizerTokens[prevIdx];
+          const prevWpHa = prevTok.word_position;
+          const prevStartHa = typeof prevWpHa === "number" ? prevWpHa - 1 : 0;
+          const prevEndHa = prevStartHa + [...prevTok.surface_form].length;
+          const prevHira = hiraChars.slice(prevStartHa, prevEndHa).join("");
+          if (!prevHira.includes("\u3063") && tok.pos_detail_1 === "\u4FC2\u52A9\u8A5E" && (hasNextContent || isEndOrPunct) && prevTok.pos !== "\u52A9\u8A5E") {
+            replaced = "\u308F";
+          }
+        }
+      }
+    }
+    if (tok.pos === "\u52A9\u8A5E" && hiraSurf === "\u3078") {
+      if (start > 0) {
+        const left = hiraChars[start - 1];
+        if (left === " " || left === "\u3000" || left === "	" || left === "\n" || left === "\r") ; else {
+          const prevIdx = prevContentIdx(tokenizerTokens, i);
+          if (prevIdx >= 0) {
+            const prevTok = tokenizerTokens[prevIdx];
+            const prevWp = prevTok.word_position;
+            const prevStart = typeof prevWp === "number" ? prevWp - 1 : 0;
+            const prevEnd = prevStart + [...prevTok.surface_form].length;
+            const prevHiraSurf = hiraChars.slice(prevStart, prevEnd).join("");
+            if (LEXICAL_HE_ENDINGS.some((w) => (prevHiraSurf + "\u3078").endsWith(w))) ; else if (prevHiraSurf.endsWith("\u306E")) ; else if (tok.pos_detail_1 === "\u683C\u52A9\u8A5E") {
+              replaced = "\u3048";
+            }
+          }
+        }
+      }
+    }
+    const outCpStart = [...out].length;
+    out += replaced;
+    origOut += origSurfForOut;
+    spans.push({
+      start: outCpStart,
+      end: [...out].length,
+      surface: replaced,
+      pos: tok.pos,
+      pos1: tok.pos_detail_1 ?? void 0,
+      pos2: tok.pos_detail_2 ?? void 0,
+      pos3: tok.pos_detail_3 ?? void 0,
+      originHadKatakana
+    });
+  }
+  return { rewritten: out, spans, rewrittenOriginal: origOut };
+}
+function tokenizeAndRewriteParticles(originalText, hiraganaText, tokenizer) {
+  const rawTokens = tokenizer.tokenize(originalText);
+  const { rewritten, spans, rewrittenOriginal } = rewriteParticlesFromTokenization(originalText, hiraganaText, rawTokens);
+  return { rewritten, spans, rewrittenOriginal, rawTokens };
+}
+
+// src/mora.ts
+var SINGLE = {
+  \u3042: { out: "\uC544", vowelMain: "a", consClass: "vowel", vowelOnly: true },
+  \u3044: { out: "\uC774", vowelMain: "i", consClass: "vowel", vowelOnly: true },
+  \u3046: { out: "\uC6B0", vowelMain: "u", consClass: "vowel", vowelOnly: true },
+  \u3048: { out: "\uC5D0", vowelMain: "e", consClass: "vowel", vowelOnly: true },
+  \u304A: { out: "\uC624", vowelMain: "o", consClass: "vowel", vowelOnly: true },
+  \u304B: { out: "\uCE74", vowelMain: "a", consClass: "k" },
+  \u304D: { out: "\uD0A4", vowelMain: "i", consClass: "k" },
+  \u304F: { out: "\uCFE0", vowelMain: "u", consClass: "k" },
+  \u3051: { out: "\uCF00", vowelMain: "e", consClass: "k" },
+  \u3053: { out: "\uCF54", vowelMain: "o", consClass: "k" },
+  \u3055: { out: "\uC0AC", vowelMain: "a", consClass: "s" },
+  \u3057: { out: "\uC2DC", vowelMain: "i", consClass: "s" },
+  \u3059: { out: "\uC2A4", vowelMain: "u", consClass: "s" },
+  \u305B: { out: "\uC138", vowelMain: "e", consClass: "s" },
+  \u305D: { out: "\uC18C", vowelMain: "o", consClass: "s" },
+  \u305F: { out: "\uD0C0", vowelMain: "a", consClass: "t" },
+  \u3061: { out: "\uCE58", vowelMain: "i", consClass: "t" },
+  \u3064: { out: "\uCE20", vowelMain: "u", consClass: "t" },
+  \u3066: { out: "\uD14C", vowelMain: "e", consClass: "t" },
+  \u3068: { out: "\uD1A0", vowelMain: "o", consClass: "t" },
+  \u306A: { out: "\uB098", vowelMain: "a", consClass: "n" },
+  \u306B: { out: "\uB2C8", vowelMain: "i", consClass: "n" },
+  \u306C: { out: "\uB204", vowelMain: "u", consClass: "n" },
+  \u306D: { out: "\uB124", vowelMain: "e", consClass: "n" },
+  \u306E: { out: "\uB178", vowelMain: "o", consClass: "n" },
+  \u306F: { out: "\uD558", vowelMain: "a", consClass: "h" },
+  \u3072: { out: "\uD788", vowelMain: "i", consClass: "h" },
+  \u3075: { out: "\uD6C4", vowelMain: "u", consClass: "h" },
+  \u3078: { out: "\uD5E4", vowelMain: "e", consClass: "h" },
+  \u307B: { out: "\uD638", vowelMain: "o", consClass: "h" },
+  \u307E: { out: "\uB9C8", vowelMain: "a", consClass: "m" },
+  \u307F: { out: "\uBBF8", vowelMain: "i", consClass: "m" },
+  \u3080: { out: "\uBB34", vowelMain: "u", consClass: "m" },
+  \u3081: { out: "\uBA54", vowelMain: "e", consClass: "m" },
+  \u3082: { out: "\uBAA8", vowelMain: "o", consClass: "m" },
+  \u3084: { out: "\uC57C", vowelMain: "a", consClass: "y" },
+  \u3086: { out: "\uC720", vowelMain: "u", consClass: "y" },
+  \u3088: { out: "\uC694", vowelMain: "o", consClass: "y" },
+  \u3089: { out: "\uB77C", vowelMain: "a", consClass: "r" },
+  \u308A: { out: "\uB9AC", vowelMain: "i", consClass: "r" },
+  \u308B: { out: "\uB8E8", vowelMain: "u", consClass: "r" },
+  \u308C: { out: "\uB808", vowelMain: "e", consClass: "r" },
+  \u308D: { out: "\uB85C", vowelMain: "o", consClass: "r" },
+  \u308F: { out: "\uC640", vowelMain: "a", consClass: "w" },
+  \u3092: { out: "\uC624", vowelMain: "o", consClass: "w" },
+  \u304C: { out: "\uAC00", vowelMain: "a", consClass: "g" },
+  \u304E: { out: "\uAE30", vowelMain: "i", consClass: "g" },
+  \u3050: { out: "\uAD6C", vowelMain: "u", consClass: "g" },
+  \u3052: { out: "\uAC8C", vowelMain: "e", consClass: "g" },
+  \u3054: { out: "\uACE0", vowelMain: "o", consClass: "g" },
+  \u3056: { out: "\uC790", vowelMain: "a", consClass: "z" },
+  \u3058: { out: "\uC9C0", vowelMain: "i", consClass: "z" },
+  \u305A: { out: "\uC988", vowelMain: "u", consClass: "z" },
+  \u305C: { out: "\uC81C", vowelMain: "e", consClass: "z" },
+  \u305E: { out: "\uC870", vowelMain: "o", consClass: "z" },
+  \u3060: { out: "\uB2E4", vowelMain: "a", consClass: "d" },
+  \u3062: { out: "\uC9C0", vowelMain: "i", consClass: "d" },
+  \u3065: { out: "\uC988", vowelMain: "u", consClass: "d" },
+  \u3067: { out: "\uB370", vowelMain: "e", consClass: "d" },
+  \u3069: { out: "\uB3C4", vowelMain: "o", consClass: "d" },
+  \u3070: { out: "\uBC14", vowelMain: "a", consClass: "b" },
+  \u3073: { out: "\uBE44", vowelMain: "i", consClass: "b" },
+  \u3076: { out: "\uBD80", vowelMain: "u", consClass: "b" },
+  \u3079: { out: "\uBCA0", vowelMain: "e", consClass: "b" },
+  \u307C: { out: "\uBCF4", vowelMain: "o", consClass: "b" },
+  \u3071: { out: "\uD30C", vowelMain: "a", consClass: "p" },
+  \u3074: { out: "\uD53C", vowelMain: "i", consClass: "p" },
+  \u3077: { out: "\uD478", vowelMain: "u", consClass: "p" },
+  \u307A: { out: "\uD398", vowelMain: "e", consClass: "p" },
+  \u307D: { out: "\uD3EC", vowelMain: "o", consClass: "p" },
+  \u3094: { out: "\uBD80", vowelMain: "u", consClass: "b" }
+};
+var YOUON = {
+  \u304D\u3083: { out: "\uCEAC", vowelMain: "a", consClass: "k", wasYouon: true },
+  \u304D\u3085: { out: "\uD050", vowelMain: "u", consClass: "k", wasYouon: true },
+  \u304D\u3087: { out: "\uCFC4", vowelMain: "o", consClass: "k", wasYouon: true },
+  \u3057\u3083: { out: "\uC0E4", vowelMain: "a", consClass: "s", wasYouon: true },
+  \u3057\u3085: { out: "\uC288", vowelMain: "u", consClass: "s", wasYouon: true },
+  \u3057\u3087: { out: "\uC1FC", vowelMain: "o", consClass: "s", wasYouon: true },
+  \u3061\u3083: { out: "\uCC60", vowelMain: "a", consClass: "t", wasYouon: true },
+  \u3061\u3085: { out: "\uCE04", vowelMain: "u", consClass: "t", wasYouon: true },
+  \u3061\u3087: { out: "\uCD78", vowelMain: "o", consClass: "t", wasYouon: true },
+  \u3066\u3085: { out: "\uD29C", vowelMain: "u", consClass: "t", wasYouon: true },
+  \u3067\u3085: { out: "\uB4C0", vowelMain: "u", consClass: "d", wasYouon: true },
+  \u306B\u3083: { out: "\uB0D0", vowelMain: "a", consClass: "n", wasYouon: true },
+  \u306B\u3085: { out: "\uB274", vowelMain: "u", consClass: "n", wasYouon: true },
+  \u306B\u3087: { out: "\uB1E8", vowelMain: "o", consClass: "n", wasYouon: true },
+  \u3072\u3083: { out: "\uD590", vowelMain: "a", consClass: "h", wasYouon: true },
+  \u3072\u3085: { out: "\uD734", vowelMain: "u", consClass: "h", wasYouon: true },
+  \u3072\u3087: { out: "\uD6A8", vowelMain: "o", consClass: "h", wasYouon: true },
+  \u3075\u3083: { out: "\uD344", vowelMain: "a", consClass: "p", wasYouon: true },
+  \u3075\u3085: { out: "\uD4E8", vowelMain: "u", consClass: "p", wasYouon: true },
+  \u3075\u3087: { out: "\uD45C", vowelMain: "o", consClass: "p", wasYouon: true },
+  \u307F\u3083: { out: "\uBA00", vowelMain: "a", consClass: "m", wasYouon: true },
+  \u307F\u3085: { out: "\uBBA4", vowelMain: "u", consClass: "m", wasYouon: true },
+  \u307F\u3087: { out: "\uBB18", vowelMain: "o", consClass: "m", wasYouon: true },
+  \u308A\u3083: { out: "\uB7B4", vowelMain: "a", consClass: "r", wasYouon: true },
+  \u308A\u3085: { out: "\uB958", vowelMain: "u", consClass: "r", wasYouon: true },
+  \u308A\u3087: { out: "\uB8CC", vowelMain: "o", consClass: "r", wasYouon: true },
+  \u304E\u3083: { out: "\uAC38", vowelMain: "a", consClass: "g", wasYouon: true },
+  \u304E\u3085: { out: "\uADDC", vowelMain: "u", consClass: "g", wasYouon: true },
+  \u304E\u3087: { out: "\uAD50", vowelMain: "o", consClass: "g", wasYouon: true },
+  \u3058\u3083: { out: "\uC7C8", vowelMain: "a", consClass: "z", wasYouon: true },
+  \u3058\u3085: { out: "\uC96C", vowelMain: "u", consClass: "z", wasYouon: true },
+  \u3058\u3087: { out: "\uC8E0", vowelMain: "o", consClass: "z", wasYouon: true },
+  \u3073\u3083: { out: "\uBC4C", vowelMain: "a", consClass: "b", wasYouon: true },
+  \u3073\u3085: { out: "\uBDF0", vowelMain: "u", consClass: "b", wasYouon: true },
+  \u3073\u3087: { out: "\uBD64", vowelMain: "o", consClass: "b", wasYouon: true },
+  \u3074\u3083: { out: "\uD344", vowelMain: "a", consClass: "p", wasYouon: true },
+  \u3074\u3085: { out: "\uD4E8", vowelMain: "u", consClass: "p", wasYouon: true },
+  \u3074\u3087: { out: "\uD45C", vowelMain: "o", consClass: "p", wasYouon: true }
+};
+var LOAN = {
+  \u3066\u3043: { out: "\uD2F0", vowelMain: "i", consClass: "t" },
+  \u3067\u3043: { out: "\uB514", vowelMain: "i", consClass: "d" },
+  \u3061\u3047: { out: "\uCCB4", vowelMain: "e", consClass: "t" },
+  \u3057\u3047: { out: "\uC170", vowelMain: "e", consClass: "s" },
+  \u3058\u3047: { out: "\uC81C", vowelMain: "e", consClass: "z" },
+  \u3064\u3041: { out: "\uCC28", vowelMain: "a", consClass: "t" },
+  \u3064\u3043: { out: "\uCE58", vowelMain: "i", consClass: "t" },
+  \u3064\u3047: { out: "\uCCB4", vowelMain: "e", consClass: "t" },
+  \u3064\u3049: { out: "\uCD08", vowelMain: "o", consClass: "t" },
+  \u3075\u3041: { out: "\uD30C", vowelMain: "a", consClass: "p" },
+  \u3075\u3043: { out: "\uD53C", vowelMain: "i", consClass: "p" },
+  \u3075\u3047: { out: "\uD398", vowelMain: "e", consClass: "p" },
+  \u3075\u3049: { out: "\uD3EC", vowelMain: "o", consClass: "p" },
+  \u3050\u3041: { out: "\uACFC", vowelMain: "a", consClass: "g" },
+  \u3050\u3043: { out: "\uADC0", vowelMain: "i", consClass: "g" },
+  \u3050\u3047: { out: "\uADA4", vowelMain: "e", consClass: "g" },
+  \u3050\u3049: { out: "\uAD88", vowelMain: "o", consClass: "g" },
+  \u304F\u3041: { out: "\uCF70", vowelMain: "a", consClass: "k" },
+  \u304F\u3043: { out: "\uD034", vowelMain: "i", consClass: "k" },
+  \u304F\u3047: { out: "\uD018", vowelMain: "e", consClass: "k" },
+  \u304F\u3049: { out: "\uCFFC", vowelMain: "o", consClass: "k" },
+  \u3069\u3041: { out: "\uB3E0", vowelMain: "a", consClass: "d" },
+  \u3069\u3045: { out: "\uB450", vowelMain: "u", consClass: "d" },
+  \u3069\u3049: { out: "\uB46C", vowelMain: "o", consClass: "d" },
+  \u3094\u3041: { out: "\uBC14", vowelMain: "a", consClass: "b" },
+  \u3094\u3043: { out: "\uBE44", vowelMain: "i", consClass: "b" },
+  \u3094\u3047: { out: "\uBCA0", vowelMain: "e", consClass: "b" },
+  \u3094\u3049: { out: "\uBCF4", vowelMain: "o", consClass: "b" }
+};
+var SMALL_Y = /* @__PURE__ */ new Set(["\u3083", "\u3085", "\u3087"]);
+var SMALL_V = /* @__PURE__ */ new Set(["\u3041", "\u3043", "\u3045", "\u3047", "\u3049"]);
+var U_DROP_KEYS = /* @__PURE__ */ new Set([
+  "\u3086",
+  "\u304D\u3085",
+  "\u3057\u3085",
+  "\u3061\u3085",
+  "\u306B\u3085",
+  "\u3072\u3085",
+  "\u307F\u3085",
+  "\u308A\u3085",
+  "\u304E\u3085",
+  "\u3058\u3085",
+  "\u3073\u3085",
+  "\u3074\u3085"
+]);
+
+// src/coreConverter.ts
+function isHiraganaChar(ch) {
+  const c = ch.codePointAt(0);
+  return c >= 12352 && c <= 12447;
+}
+function isKatakanaChar2(ch) {
+  const c = ch.codePointAt(0);
+  return c >= 12448 && c <= 12543;
+}
+function toHiraganaKey(s) {
+  const n = s.normalize("NFKC");
+  return Array.from(n).map((ch) => {
+    if (ch === "\u30FC")
+      return ch;
+    if (!isKatakanaChar2(ch))
+      return ch;
+    const code = ch.codePointAt(0);
+    if (code >= 12449 && code <= 12534) {
+      return String.fromCodePoint(code - 96);
+    }
+    return ch;
+  }).join("");
+}
+function toKatakanaKey(s) {
+  const n = s.normalize("NFKC");
+  return Array.from(n).map(
+    (ch) => isHiraganaChar(ch) ? String.fromCodePoint(ch.codePointAt(0) + 96) : ch
+  ).join("");
+}
+function compileSpecialDictionary(dict) {
+  const items = [];
+  for (const e of dict) {
+    items.push({
+      keyChars: Array.from(e.word),
+      answer: e.answer,
+      stream: "orig"
+    });
+    if (e.hira) {
+      const k = toHiraganaKey(e.word);
+      items.push({
+        keyChars: Array.from(k),
+        answer: e.answer,
+        stream: "rewritten"
+      });
+    }
+    if (e.kata) {
+      const k = toKatakanaKey(e.word);
+      items.push({ keyChars: Array.from(k), answer: e.answer, stream: "orig" });
+    }
+  }
+  items.sort((a, b) => b.keyChars.length - a.keyChars.length);
+  return items;
+}
+var COMPILED_SPECIAL_DICT = compileSpecialDictionary(SpecialDictionary);
+function coreKanaToHangulConvert(s, opts) {
+  const chars = Array.from(s);
+  const origChars = Array.from(opts?.original ?? s);
+  const HANGUL_BASE = 44032;
+  const HANGUL_END = 55203;
+  function isHangulSyllable(ch) {
+    const c = ch.codePointAt(0);
+    return c >= HANGUL_BASE && c <= HANGUL_END;
+  }
+  const JONG = {
+    G: 1,
+    // ㄱ
+    N: 4,
+    // ㄴ
+    M: 16,
+    // ㅁ
+    B: 17,
+    // ㅂ
+    S: 19,
+    // ㅅ
+    NG: 21
+    // ㅇ
+  };
+  function addFinal(syl, jong) {
+    if (!isHangulSyllable(syl))
+      return syl;
+    const code = syl.codePointAt(0) - HANGUL_BASE;
+    const cho = Math.floor(code / 588);
+    const jung = Math.floor(code % 588 / 28);
+    return String.fromCodePoint(HANGUL_BASE + cho * 588 + jung * 28 + jong);
+  }
+  function replaceLastHangul(out2, jong) {
+    if (!out2)
+      return out2;
+    const last = out2[out2.length - 1];
+    if (!isHangulSyllable(last))
+      return out2;
+    return out2.slice(0, -1) + addFinal(last, jong);
+  }
+  function isHiragana(ch) {
+    const c = ch.codePointAt(0);
+    return c >= 12352 && c <= 12447;
+  }
+  function isKana(ch) {
+    return isHiragana(ch) || ch === "\u30FC";
+  }
+  function readMoraAt(idx) {
+    if (idx >= chars.length)
+      return null;
+    const c0 = chars[idx];
+    const c1 = chars[idx + 1];
+    if (c1 && SMALL_V.has(c1)) {
+      const key2 = c0 + c1;
+      const info2 = LOAN[key2];
+      if (info2)
+        return { key: key2, len: 2, info: info2 };
+    }
+    if (c1 && SMALL_Y.has(c1)) {
+      const key2 = c0 + c1;
+      const info2 = YOUON[key2];
+      if (info2)
+        return { key: key2, len: 2, info: info2 };
+    }
+    const info = SINGLE[c0];
+    if (info)
+      return { key: c0, len: 1, info };
+    return { key: c0, len: 1, info: void 0 };
+  }
+  function readOriginalMoraAt(idx) {
+    if (idx >= origChars.length)
+      return null;
+    const c0 = origChars[idx];
+    const c1 = origChars[idx + 1];
+    if (c1 && SMALL_V.has(c1)) {
+      const key2 = c0 + c1;
+      const info2 = LOAN[key2];
+      if (info2)
+        return { key: key2, len: 2, info: info2 };
+    }
+    if (c1 && SMALL_Y.has(c1)) {
+      const key2 = c0 + c1;
+      const info2 = YOUON[key2];
+      if (info2)
+        return { key: key2, len: 2, info: info2 };
+    }
+    const info = SINGLE[c0];
+    if (info)
+      return { key: c0, len: 1, info };
+    return { key: c0, len: 1, info: void 0 };
+  }
+  function isLabialStart(cons) {
+    return cons === "m" || cons === "b" || cons === "p";
+  }
+  const tokens = opts?.tokens ?? null;
+  let tokIdx = 0;
+  function syncTokenIndex(charIndex) {
+    if (!tokens)
+      return;
+    while (tokIdx + 1 < tokens.length && tokens[tokIdx].end <= charIndex) {
+      tokIdx++;
+    }
+  }
+  function curToken(charIndex) {
+    if (!tokens)
+      return null;
+    syncTokenIndex(charIndex);
+    const t = tokens[tokIdx];
+    if (t && t.start <= charIndex && charIndex < t.end)
+      return t;
+    return null;
+  }
+  function prevToken() {
+    if (!tokens)
+      return null;
+    return tokIdx - 1 >= 0 ? tokens[tokIdx - 1] : null;
+  }
+  function nextToken() {
+    if (!tokens)
+      return null;
+    return tokIdx + 1 < tokens.length ? tokens[tokIdx + 1] : null;
+  }
+  const INITIAL_VOICING_BLOCK_NEXT = /* @__PURE__ */ new Set(["\u3044", "\u3072", "\u3093", "\u3066"]);
+  function peekNextMoraKeySkippingChoonpu(fromIdx) {
+    let j = fromIdx;
+    while (j < chars.length && chars[j] === "\u30FC")
+      j++;
+    const m = readMoraAt(j);
+    return m?.key ?? null;
+  }
+  const SAN_PARTICLES = /* @__PURE__ */ new Set(["\u306F", "\u308F", "\u3078", "\u3048", "\u3092", "\u304A"]);
+  function isSanHonorificAt(cpIdx) {
+    const t = curToken(cpIdx);
+    if (!t)
+      return false;
+    if (cpIdx < 1 || chars[cpIdx - 1] !== "\u3055")
+      return false;
+    const local = chars.slice(t.start, cpIdx + 1).join("");
+    if (!local.endsWith("\u3055\u3093"))
+      return false;
+    const hasPrefixInsideToken = cpIdx - 1 > t.start;
+    const p = prevToken();
+    const prevIsAttachable = !!p && p.end === t.start && p.surface.length > 0 && !HARD_BOUNDARY_SURF.has(p.surface);
+    if (!hasPrefixInsideToken && !prevIsAttachable)
+      return false;
+    const n = nextToken();
+    if (!n)
+      return true;
+    if (n.pos === "\u8A18\u53F7" && HARD_BOUNDARY_SURF.has(n.surface))
+      return true;
+    if (n.pos === "\u52A9\u8A5E" && SAN_PARTICLES.has(n.surface))
+      return true;
+    return false;
+  }
+  let out = "";
+  let i = 0;
+  let lastMora = null;
+  while (i < chars.length) {
+    let atTokenStart = false;
+    let tokForI = null;
+    if (tokens) {
+      tokForI = curToken(i);
+      atTokenStart = !!tokForI && tokForI.start === i;
+      if (tokForI?.pos === "\u8A18\u53F7")
+        atTokenStart = false;
+    } else {
+      atTokenStart = i === 0;
+    }
+    let matchedSpecial = false;
+    for (const it of COMPILED_SPECIAL_DICT) {
+      const src = it.stream === "orig" ? origChars : chars;
+      const len = it.keyChars.length;
+      if (i + len > src.length)
+        continue;
+      let ok = true;
+      for (let k = 0; k < len; k++) {
+        if (src[i + k] !== it.keyChars[k]) {
+          ok = false;
+          break;
+        }
+      }
+      if (!ok)
+        continue;
+      out += it.answer;
+      i += len;
+      lastMora = null;
+      matchedSpecial = true;
+      break;
+    }
+    if (matchedSpecial)
+      continue;
+    const ch = chars[i];
+    if (ch === "\u30FC") {
+      i += 1;
+      continue;
+    }
+    if (!isKana(ch)) {
+      out += ch;
+      i += 1;
+      lastMora = null;
+      continue;
+    }
+    if (ch === "\u3063") {
+      if (!out || !isHangulSyllable(out[out.length - 1])) {
+        out += "\u30C3";
+        i += 1;
+        lastMora = null;
+        continue;
+      }
+      const next = readMoraAt(i + 1);
+      const prevV = lastMora?.vowelMain ?? "a";
+      const nextInfo = next?.info;
+      const nextCons = nextInfo?.consClass ?? "t";
+      let jong = JONG.S;
+      if (nextCons === "p" || nextCons === "b")
+        jong = JONG.B;
+      else if (nextCons === "k" || nextCons === "g") {
+        jong = prevV === "e" || prevV === "i" ? JONG.S : JONG.G;
+      } else {
+        jong = JONG.S;
+      }
+      out = replaceLastHangul(out, jong);
+      i += 1;
+      continue;
+    }
+    if (ch === "\u304A" && chars[i + 1] === "\u304A") {
+      let j = i;
+      while (chars[j] === "\u304A")
+        j++;
+      out += "\uC624";
+      i = j;
+      lastMora = {
+        out: "\uC624",
+        vowelMain: "o",
+        consClass: "vowel",
+        vowelOnly: true
+      };
+      continue;
+    }
+    const mora = readMoraAt(i);
+    const originalMora = readOriginalMoraAt(i);
+    if (!mora) {
+      out += chars[i];
+      i += 1;
+      lastMora = null;
+      continue;
+    }
+    if (!originalMora) {
+      throw Error("\uC6D0\uBCF8 \uBAA8\uB77C \uC190\uC2E4");
+    }
+    if (mora.key === "\u3093") {
+      const next = readMoraAt(i + 1);
+      const nextInfo = next?.info;
+      const hasPrevHangul = out.length > 0 && isHangulSyllable(out[out.length - 1]);
+      if (!hasPrevHangul) {
+        out += "\u3134";
+        i += 1;
+        lastMora = null;
+        continue;
+      }
+      if (lastMora?.out === "\uC0AC" && isSanHonorificAt(i)) {
+        out = replaceLastHangul(out, JONG.NG);
+        i += 1;
+        continue;
+      }
+      let jong = JONG.N;
+      if (!next || !nextInfo || !isKana(next.key[0])) {
+        jong = lastMora?.wasYouon ? JONG.NG : JONG.N;
+      } else {
+        const nc = nextInfo.consClass;
+        if (nc === "k" || nc === "g") {
+          jong = JONG.NG;
+        } else if (nc === "vowel" || nc === "y" || nc === "w") {
+          jong = JONG.N;
+        } else if (isLabialStart(nc)) {
+          if (lastMora?.vowelOnly)
+            jong = JONG.N;
+          else
+            jong = JONG.M;
+        } else {
+          jong = JONG.N;
+        }
+      }
+      out = replaceLastHangul(out, jong);
+      i += 1;
+      continue;
+    }
+    const info = mora.info;
+    if (!info) {
+      out += mora.key;
+      i += mora.len;
+      lastMora = null;
+      continue;
+    }
+    let outSyl = info.out;
+    if (atTokenStart && (mora.key === "\u3068" || mora.key === "\u3053")) {
+      const prevIsSokuon = i > 0 && chars[i - 1] === "\u3063";
+      const nextKey = peekNextMoraKeySkippingChoonpu(i + mora.len);
+      const blockedByNext = !!nextKey && INITIAL_VOICING_BLOCK_NEXT.has(nextKey);
+      const isKou = mora.key === "\u3053" && chars[i + mora.len] === "\u3046";
+      let blockedByParticleUsage = false;
+      if (tokens && tokForI) {
+        const isSingleCharToken = tokForI.surface.length === 1;
+        const tokenMatchesMora = tokForI.surface === mora.key;
+        if (isSingleCharToken && tokenMatchesMora) {
+          const p = prevToken();
+          const prevLooksLikeContent = !!p && p.pos !== "\u8A18\u53F7" && p.pos !== "\u52A9\u8A5E" && p.pos !== "\u52A9\u52D5\u8A5E" && !HARD_BOUNDARY_SURF.has(p.surface);
+          if (prevLooksLikeContent)
+            blockedByParticleUsage = true;
+        }
+      }
+      const allowVoicing = !prevIsSokuon && !blockedByNext && !isKou && !blockedByParticleUsage;
+      if (allowVoicing) {
+        if (mora.key === "\u3068")
+          outSyl = "\uB3C4";
+        else if (mora.key === "\u3053")
+          outSyl = "\uACE0";
+      }
+    }
+    out += outSyl;
+    lastMora = { ...info, out: outSyl };
+    const next1 = chars[i + mora.len];
+    chars[i + mora.len + 1];
+    if (next1 === "\u3046" && info.vowelMain === "o") {
+      i += mora.len + 1;
+      continue;
+    }
+    if (next1 === "\u3046" && U_DROP_KEYS.has(mora.key)) {
+      i += mora.len + 1;
+      continue;
+    }
+    if (next1 === "\u3044") {
+      if (mora.key === "\u305B") {
+        i += mora.len + 1;
+        continue;
+      } else if (mora.key === "\u3051") {
+        i += mora.len + 1;
+        continue;
+      } else if (mora.key === "\u3048") {
+        if (originalMora.key !== "\u3078") {
+          i += mora.len + 1;
+          continue;
+        }
+      } else if (mora.key === "\u3057") {
+        i += mora.len + 1;
+        continue;
+      }
+    }
+    if (next1 === "\u3048" && mora.key === "\u306D") {
+      i += mora.len + 1;
+      continue;
+    }
+    i += mora.len;
+  }
+  return out;
+}
+
+// src/kanaToHangul.ts
+function createKanaToHangul(tokenizer) {
+  return (input) => convertWithTokenizer(input, tokenizer);
+}
+function convertWithTokenizer(input, tokenizer) {
+  const normalized = normalizeInputText(input);
+  const hiragana = toHiragana(normalized);
+  const { rewritten, spans, rewrittenOriginal } = tokenizeAndRewriteParticles(
+    normalized,
+    hiragana,
+    tokenizer
+  );
+  return coreKanaToHangulConvert(rewritten, {
+    tokens: spans,
+    original: rewrittenOriginal
+  });
+}
+var require2 = module$1.createRequire((typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('out.js', document.baseURI).href)));
+async function buildTokenizer() {
+  return new Promise((resolve, reject) => {
+    const dicPath = path__default.default.join(require2.resolve("kuromoji"), "..", "..", "dict");
+    kuromoji__default.default.builder({ dicPath }).build((err, tk) => {
+      if (err || !tk)
+        reject(err);
+      else
+        resolve(tk);
+    });
+  });
+}
+var tokenizerPromise = null;
+async function getTokenizer() {
+  if (!tokenizerPromise) {
+    tokenizerPromise = buildTokenizer();
+  }
+  return tokenizerPromise;
+}
+
+// src/kanaBarum.ts
+var Kanabarum = class {
+  constructor() {
+    this.converter = null;
+  }
+  /**
+   * 토크나이저를 초기화합니다. 변환 전에 반드시 호출해야 합니다.
+   */
+  async init() {
+    const tokenizer = await getTokenizer();
+    this.converter = createKanaToHangul(tokenizer);
+  }
+  /**
+   * 일본어 가나를 한글로 변환합니다.
+   * @param input 변환할 일본어 문자열
+   * @returns 한글로 변환된 문자열
+   * @throws init()이 호출되지 않은 경우 에러
+   */
+  kanaToHangul(input) {
+    if (!this.converter) {
+      throw new Error("Kanabarum is not initialized. Call init() first.");
+    }
+    return this.converter(input);
+  }
+};
+var cachedConverter = null;
+var pendingInit = null;
+async function initKanaToHangul() {
+  if (cachedConverter)
+    return cachedConverter;
+  if (pendingInit)
+    return pendingInit;
+  pendingInit = (async () => {
+    const tokenizer = await getTokenizer();
+    const converter = createKanaToHangul(tokenizer);
+    cachedConverter = converter;
+    return converter;
+  })();
+  return pendingInit;
+}
+async function kanaToHangul(input) {
+  const converter = await initKanaToHangul();
+  return converter(input);
+}
+
+exports.Kanabarum = Kanabarum;
+exports.kanaToHangul = kanaToHangul;
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.cjs.map