konglish 0.2.0 → 0.3.0

package/dist/index.cjs

@@ -1,5 +1,9 @@
 'use strict';
 
+var cmuPronouncingDictionary = require('cmu-pronouncing-dictionary');
+
+// src/pron/latinTokorea.ts
+
 // src/pron/dictionary.ts
 var customDictionary = {
   "a": ["\uC5B4"],
@@ -24161,7 +24165,20 @@ var customDictionary = {
 };
 
 // src/pron/latinTokorea.ts
-var normalize = (s) => s.trim().toLowerCase();
+var DEFAULT_BEAM_WIDTH = 8;
+function latinToHangul(input, options) {
+  const fullKey = input.trim().toLowerCase();
+  const userFullHit = options?.dictionary?.[fullKey];
+  if (userFullHit && userFullHit.length > 0)
+    return userFullHit[0];
+  const builtInFullHit = customDictionary[fullKey];
+  if (builtInFullHit && builtInFullHit.length > 0)
+    return builtInFullHit[0];
+  const resolved = resolveOptions(options, 1);
+  const tokens = tokenizePreservingSpecialChars(input);
+  const [best] = transliterateTokens(tokens, resolved);
+  return best ?? input;
+}
 function tokenizePreservingSpecialChars(input) {
   const tokens = [];
   const regex = /([a-zA-Z]+)|([^a-zA-Z]+)/g;
@@ -24176,47 +24193,521 @@ function tokenizePreservingSpecialChars(input) {
   }
   return tokens;
 }
-function mergeDict(user) {
-  const out = { ...customDictionary };
-  if (!user)
-    return out;
-  for (const [k, v] of Object.entries(user)) {
-    const key = normalize(k);
-    if (!key)
-      continue;
-    if (!Array.isArray(v) || v.length === 0)
+function resolveOptions(options, limit) {
+  const desiredBeam = options?.beamWidth ?? DEFAULT_BEAM_WIDTH;
+  return {
+    limit,
+    beamWidth: Math.max(desiredBeam, limit, DEFAULT_BEAM_WIDTH),
+    enableFallbackPhones: options?.enableFallbackPhones ?? true,
+    dictionaryOverride: options?.dictionary
+  };
+}
+function transliterateTokens(tokens, options) {
+  const wordTokens = tokens.filter((t) => t.type === "word");
+  if (wordTokens.length === 0)
+    return [];
+  const combinedWords = wordTokens.map((t) => t.text).join(" ");
+  const candidates = buildWordCandidates(combinedWords, options);
+  if (candidates.length === 0)
+    return [];
+  return candidates.map((cand) => applyCandidateToTokens(tokens, cand));
+}
+function applyCandidateToTokens(tokens, candidate) {
+  const candWords = candidate.split(" ");
+  let candIdx = 0;
+  return tokens.map((token) => {
+    if (token.type === "word") {
+      const next = candWords[candIdx];
+      candIdx += 1;
+      return next ?? token.text;
+    }
+    return token.text;
+  }).join("");
+}
+function buildWordCandidates(input, options) {
+  const text = normalizeInput(input);
+  if (!text)
+    return [];
+  const words = text.split(/\s+/).filter(Boolean);
+  const { beamWidth, limit } = options;
+  let beam = [{ text: "", score: 0 }];
+  for (let wi = 0; wi < words.length; wi++) {
+    const w = words[wi];
+    const override = overrideCandidates(w, options.dictionaryOverride).map(
+      (s, i) => ({ text: s, score: i })
+    );
+    const phones = cmuLookupPhones(w);
+    const dictCands = phones ? arpabetToKoCandidates(phones, beamWidth).map((s, i) => ({
+      text: s,
+      score: 100 + i
+    })) : [];
+    const fb = phones || !options.enableFallbackPhones ? null : fallbackPhones(w);
+    const fbCands = fb ? arpabetToKoCandidates(fb, beamWidth).map((s, i) => ({
+      text: s,
+      score: 200 + i
+    })) : [];
+    const wordBeam = takeTopK(
+      dedupeByText([...override, ...dictCands, ...fbCands]),
+      beamWidth
+    );
+    beam = combineBeams(beam, wordBeam, beamWidth);
+    if (wi !== words.length - 1)
+      beam = beam.map((x) => ({ text: `${x.text} `, score: x.score }));
+  }
+  beam.sort((a, b) => a.score - b.score);
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const x of beam) {
+    const s = x.text.trim();
+    if (!s || seen.has(s))
       continue;
-    out[key] = v;
+    seen.add(s);
+    out.push(s);
+    if (out.length >= limit)
+      break;
   }
   return out;
 }
-function dictLookup(dict, keyLike) {
-  const key = normalize(keyLike);
-  const v = dict[key];
-  return v && v.length > 0 ? v[0] : null;
+function overrideCandidates(word, overrides) {
+  const key = word.toLowerCase();
+  const userHit = overrides?.[key];
+  if (userHit && userHit.length > 0)
+    return userHit.map(String);
+  const builtIn = customDictionary[key];
+  if (!builtIn || builtIn.length === 0)
+    return [];
+  return builtIn.map(String);
 }
-function fullInputLookup(dict, input) {
-  return dictLookup(dict, input);
+function cmuLookupPhones(word) {
+  if (!cmuPronouncingDictionary.dictionary)
+    return null;
+  const key = word.toUpperCase();
+  const raw = cmuPronouncingDictionary.dictionary[key] ?? cmuPronouncingDictionary.dictionary[`${key}(1)`] ?? cmuPronouncingDictionary.dictionary[`${key}(2)`];
+  if (!raw || typeof raw !== "string")
+    return null;
+  return raw.trim().split(/\s+/).map((p) => p.replace(/[0-9]/g, "")).filter(Boolean);
 }
-function latinToHangul(input, options) {
-  const dict = mergeDict(options?.dictionary);
-  const fullHit = fullInputLookup(dict, input);
-  if (fullHit)
-    return fullHit;
-  const tokens = tokenizePreservingSpecialChars(input);
-  let out = "";
-  for (const t of tokens) {
-    if (t.type === "other") {
-      out += t.text;
+function fallbackPhones(word) {
+  const w = word.toLowerCase();
+  const phones = [];
+  let i = 0;
+  if (/^pre[bcdfghjklmnpqrstvwxyz]/.test(w)) {
+    phones.push("P", "R", "IY");
+    i = 3;
+  }
+  while (i < w.length) {
+    const rest = w.slice(i);
+    if (rest.startsWith("er")) {
+      phones.push("ER");
+      i += 2;
+      continue;
+    }
+    if (rest.startsWith("ir")) {
+      phones.push("ER");
+      i += 2;
+      continue;
+    }
+    if (rest.startsWith("ur")) {
+      phones.push("ER");
+      i += 2;
+      continue;
+    }
+    if (rest.startsWith("ch")) {
+      phones.push("CH");
+      i += 2;
       continue;
     }
-    const hit = dictLookup(dict, t.text);
-    out += hit ?? t.text;
+    if (rest.startsWith("sh")) {
+      phones.push("SH");
+      i += 2;
+      continue;
+    }
+    if (rest.startsWith("th")) {
+      phones.push("TH");
+      i += 2;
+      continue;
+    }
+    if (rest.startsWith("ng")) {
+      phones.push("NG");
+      i += 2;
+      continue;
+    }
+    if (rest.startsWith("qu")) {
+      phones.push("K", "W");
+      i += 2;
+      continue;
+    }
+    const c = rest[0];
+    if ("aeiouy".includes(c))
+      phones.push(vowelToArpabet(c));
+    else if (/[a-z]/.test(c))
+      phones.push(consToArpabet(c));
+    i += 1;
+  }
+  return phones.length ? phones : null;
+}
+function vowelToArpabet(ch) {
+  switch (ch) {
+    case "a":
+      return "AE";
+    case "e":
+      return "EH";
+    case "i":
+      return "IY";
+    case "o":
+      return "OW";
+    case "u":
+      return "UW";
+    case "y":
+      return "IY";
+    default:
+      return "AH";
+  }
+}
+function consToArpabet(ch) {
+  switch (ch) {
+    case "b":
+      return "B";
+    case "c":
+      return "K";
+    case "d":
+      return "D";
+    case "f":
+      return "F";
+    case "g":
+      return "G";
+    case "h":
+      return "HH";
+    case "j":
+      return "JH";
+    case "k":
+      return "K";
+    case "l":
+      return "L";
+    case "m":
+      return "M";
+    case "n":
+      return "N";
+    case "p":
+      return "P";
+    case "q":
+      return "K";
+    case "r":
+      return "R";
+    case "s":
+      return "S";
+    case "t":
+      return "T";
+    case "v":
+      return "V";
+    case "w":
+      return "W";
+    case "x":
+      return "K";
+    case "z":
+      return "Z";
+    default:
+      return "HH";
+  }
+}
+var VOWELS = /* @__PURE__ */ new Set([
+  "AA",
+  "AE",
+  "AH",
+  "AO",
+  "AW",
+  "AY",
+  "EH",
+  "ER",
+  "EY",
+  "IH",
+  "IY",
+  "OW",
+  "OY",
+  "UH",
+  "UW",
+  "AX"
+]);
+function arpabetToKoCandidates(phones, limit) {
+  if (!phones.length)
+    return [];
+  const syllables = syllabifyArpabet(phones);
+  let beam = [{ text: "", score: 0 }];
+  for (const syl of syllables) {
+    const sylBeam = buildKoSyllableCandidates(syl, limit);
+    beam = combineBeams(beam, sylBeam, limit);
+  }
+  beam.sort((a, b) => a.score - b.score);
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const x of beam) {
+    if (seen.has(x.text))
+      continue;
+    seen.add(x.text);
+    out.push(x.text);
+    if (out.length >= limit)
+      break;
+  }
+  return out;
+}
+function syllabifyArpabet(phones) {
+  const out = [];
+  let onset = [];
+  let vowel = null;
+  let coda = [];
+  const flush = () => {
+    if (vowel)
+      out.push({ onset, vowel, coda });
+    onset = [];
+    vowel = null;
+    coda = [];
+  };
+  for (const p of phones) {
+    if (VOWELS.has(p)) {
+      if (vowel)
+        flush();
+      vowel = p;
+    } else {
+      if (!vowel)
+        onset.push(p);
+      else
+        coda.push(p);
+    }
+  }
+  flush();
+  for (let i = 0; i < out.length - 1; i++) {
+    const cur = out[i];
+    const nxt = out[i + 1];
+    if (cur.coda.length > 0 && nxt.onset.length === 0) {
+      const moved = cur.coda.pop();
+      if (moved)
+        nxt.onset.unshift(moved);
+    }
   }
   return out;
 }
-async function latinToHangulAsync(input, options) {
-  return latinToHangul(input, options);
+function buildKoSyllableCandidates({ onset, vowel, coda }, limit) {
+  let beam = [{ text: "", score: 0 }];
+  if (onset.length > 1) {
+    const prefix = onset.slice(0, onset.length - 1);
+    for (const p of prefix) {
+      const prefixBeam = consMap(p).map((x) => ({
+        text: composeHangul(x.cho, "\u3161", ""),
+        score: x.score + 3
+      }));
+      beam = combineBeams(beam, prefixBeam, limit);
+    }
+  }
+  const mainOnset = onset.length === 0 ? null : onset[onset.length - 1];
+  const onsetCands = mainOnset ? consMap(mainOnset) : [{ cho: "\u3147", score: 0 }];
+  const vowelCands = vowelMap(vowel);
+  const codaFirst = coda.length ? coda[0] : null;
+  const codaCands = codaFirst ? consToJongMap(codaFirst) : [{ jong: "", score: 0 }];
+  const main = [];
+  for (const o of onsetCands) {
+    for (const v of vowelCands) {
+      for (const cd of codaCands) {
+        const jong = pickJong(cd.jong, v.addJong);
+        main.push({
+          text: composeHangul(o.cho, v.jung, jong),
+          score: o.score + v.score + cd.score + (v.addJong ? 1 : 0)
+        });
+      }
+    }
+  }
+  beam = combineBeams(beam, takeTopK(main, limit), limit);
+  if (coda.length > 1) {
+    for (const extra of coda.slice(1)) {
+      const extraBeam = consMap(extra).map((x) => ({
+        text: composeHangul(x.cho, "\u3161", ""),
+        score: 4 + x.score
+      }));
+      beam = combineBeams(beam, extraBeam, limit);
+    }
+  }
+  return takeTopK(beam, limit);
+}
+function consMap(p) {
+  switch (p) {
+    case "P":
+      return [{ cho: "\u314D", score: 0 }];
+    case "B":
+      return [{ cho: "\u3142", score: 0 }];
+    case "T":
+      return [{ cho: "\u314C", score: 0 }];
+    case "D":
+      return [{ cho: "\u3137", score: 0 }];
+    case "K":
+      return [{ cho: "\u314B", score: 0 }, { cho: "\u3131", score: 1 }];
+    case "G":
+      return [{ cho: "\u3131", score: 0 }, { cho: "\u314B", score: 1 }];
+    case "F":
+      return [{ cho: "\u314D", score: 0 }];
+    case "V":
+      return [{ cho: "\u3142", score: 0 }];
+    case "S":
+      return [{ cho: "\u3145", score: 0 }];
+    case "Z":
+      return [{ cho: "\u3148", score: 0 }];
+    case "JH":
+      return [{ cho: "\u3148", score: 0 }];
+    case "CH":
+      return [{ cho: "\u314A", score: 0 }];
+    case "SH":
+      return [{ cho: "\u3145", score: 0 }];
+    case "HH":
+      return [{ cho: "\u314E", score: 0 }];
+    case "M":
+      return [{ cho: "\u3141", score: 0 }];
+    case "N":
+      return [{ cho: "\u3134", score: 0 }];
+    case "NG":
+      return [{ cho: "\u3147", score: 0 }];
+    case "L":
+    case "R":
+      return [{ cho: "\u3139", score: 0 }];
+    case "W":
+    case "Y":
+      return [{ cho: "\u3147", score: 2 }];
+    case "TH":
+      return [{ cho: "\u3145", score: 0 }, { cho: "\u3137", score: 2 }];
+    case "DH":
+      return [{ cho: "\u3137", score: 0 }];
+    default:
+      return [{ cho: "\u3147", score: 5 }];
+  }
+}
+function consToJongMap(p) {
+  const mk = (jong, score = 0) => ({ jong, score });
+  switch (p) {
+    case "P":
+    case "B":
+    case "F":
+    case "V":
+      return [mk("\u3142")];
+    case "T":
+    case "D":
+    case "S":
+    case "Z":
+    case "JH":
+    case "CH":
+      return [mk("\u3137")];
+    case "K":
+    case "G":
+      return [mk("\u3131")];
+    case "M":
+      return [mk("\u3141")];
+    case "N":
+      return [mk("\u3134")];
+    case "NG":
+      return [mk("\u3147")];
+    case "L":
+    case "R":
+      return [mk("\u3139")];
+    case "HH":
+      return [mk("\u314E")];
+    default:
+      return [mk("")];
+  }
+}
+function vowelMap(v) {
+  switch (v) {
+    case "IY":
+      return [{ jung: "\u3163", score: 0 }];
+    case "IH":
+      return [{ jung: "\u3163", score: 0 }];
+    case "EH":
+      return [{ jung: "\u3154", score: 0 }];
+    case "AE":
+      return [{ jung: "\u3150", score: 0 }];
+    case "AA":
+      return [{ jung: "\u314F", score: 0 }];
+    case "AH":
+      return [{ jung: "\u3153", score: 0 }];
+    case "AO":
+      return [{ jung: "\u3157", score: 0 }, { jung: "\u3153", score: 1 }];
+    case "OW":
+      return [{ jung: "\u3157", score: 0 }];
+    case "UH":
+      return [{ jung: "\u315C", score: 0 }, { jung: "\u3153", score: 2 }];
+    case "UW":
+      return [{ jung: "\u315C", score: 0 }];
+    case "ER":
+      return [{ jung: "\u3153", score: 0 }, { jung: "\u3153", addJong: "\u3139", score: 1 }];
+    case "EY":
+      return [{ jung: "\u3154", score: 0 }];
+    case "AY":
+      return [{ jung: "\u314F", score: 0 }, { jung: "\u3150", score: 2 }];
+    case "AW":
+      return [{ jung: "\u314F", score: 0 }, { jung: "\u3157", score: 2 }];
+    case "OY":
+      return [{ jung: "\u3157", score: 0 }];
+    default:
+      return [{ jung: "\u3161", score: 5 }];
+  }
+}
+var CHO = ["\u3131", "\u3132", "\u3134", "\u3137", "\u3138", "\u3139", "\u3141", "\u3142", "\u3143", "\u3145", "\u3146", "\u3147", "\u3148", "\u3149", "\u314A", "\u314B", "\u314C", "\u314D", "\u314E"];
+var JUNG = ["\u314F", "\u3150", "\u3151", "\u3152", "\u3153", "\u3154", "\u3155", "\u3156", "\u3157", "\u3158", "\u3159", "\u315A", "\u315B", "\u315C", "\u315D", "\u315E", "\u315F", "\u3160", "\u3161", "\u3162", "\u3163"];
+var JONG = ["", "\u3131", "\u3132", "\u3133", "\u3134", "\u3135", "\u3136", "\u3137", "\u3139", "\u313A", "\u313B", "\u313C", "\u313D", "\u313E", "\u313F", "\u3140", "\u3141", "\u3142", "\u3144", "\u3145", "\u3146", "\u3147", "\u3148", "\u314A", "\u314B", "\u314C", "\u314D", "\u314E"];
+var choIndex = new Map(CHO.map((c, i) => [c, i]));
+var jungIndex = new Map(JUNG.map((c, i) => [c, i]));
+var jongIndex = new Map(JONG.map((c, i) => [c, i]));
+function composeHangul(cho, jung, jong = "") {
+  const ci = choIndex.get(cho) ?? choIndex.get("\u3147") ?? 11;
+  const ji = jungIndex.get(jung) ?? jungIndex.get("\u3161") ?? 18;
+  const gi = jongIndex.get(normalizeJong(jong)) ?? 0;
+  return String.fromCharCode(44032 + (ci * 21 + ji) * 28 + gi);
+}
+function normalizeJong(j) {
+  if (!j)
+    return "";
+  if (jongIndex.has(j))
+    return j;
+  if (j === "\u314B")
+    return "\u3131";
+  if (j === "\u314C")
+    return "\u3137";
+  if (j === "\u314D")
+    return "\u3142";
+  return "";
+}
+function pickJong(j1, j2) {
+  return normalizeJong(j1 || j2 || "");
+}
+function normalizeInput(s) {
+  return String(s).toLowerCase().replace(/([a-z])[-]+([a-z])/g, "$1$2").replace(/[^a-z0-9\s\-_'']/g, " ").replace(/[_'']/g, "").replace(/-/g, " ").trim().replace(/\s+/g, " ");
+}
+function dedupeByText(arr) {
+  const best = /* @__PURE__ */ new Map();
+  for (const x of arr) {
+    const prev = best.get(x.text);
+    if (!prev || x.score < prev.score)
+      best.set(x.text, x);
+  }
+  return [...best.values()];
+}
+function combineBeams(left, right, limit) {
+  const combined = [];
+  for (const a of left) {
+    for (const b of right) {
+      combined.push({ text: a.text + b.text, score: a.score + b.score });
+    }
+  }
+  return takeTopK(combined, limit);
+}
+function takeTopK(arr, k) {
+  arr.sort((a, b) => a.score - b.score);
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const x of arr) {
+    if (seen.has(x.text))
+      continue;
+    seen.add(x.text);
+    out.push(x);
+    if (out.length >= k)
+      break;
+  }
+  return out;
 }
 
 // src/konglish.ts
@@ -24234,12 +24725,6 @@ var Konglish = class {
   latinToHangul(input, options) {
     return latinToHangul(input, mergeOptions(this.defaultOptions, options));
   }
-  latinToHangulAsync(input, options) {
-    return latinToHangulAsync(
-      input,
-      mergeOptions(this.defaultOptions, options)
-    );
-  }
 };
 
 exports.Konglish = Konglish;