henkan 2.3.1 → 2.4.0

package/dist/index.mjs

@@ -92,8 +92,9 @@ var noteMap = /* @__PURE__ */ new Map([
   ["tsugaru-ben", ["dialect::tsugaru-ben", "Dialect: Tsugaru-ben"]],
   ["aichi dialect", ["dialect::aichi", "Dialect: Aichi"]],
   ["tochigi dialect", ["dialect::tochigi", "Dialect: Tochigi"]],
-  ["lit", ["literal_meaning", "Literal meaning"]],
   ["expl", ["explanation", "Explanation"]],
+  ["fig", ["figurative", "Figurative"]],
+  ["lit", ["literal_meaning", "Literal meaning"]],
   ["tm", ["trademark", "Trademark"]],
   ["adjective (keiyoushi)", ["adjective::i", "\u3044-adjective", "\u5F62\u5BB9\u8A5E"]],
   ["'taru' adjective", ["adjective::taru", "\u305F\u308B-adjective", "\u5F62\u5BB9\u52D5\u8A5E"]],
@@ -1278,6 +1279,22 @@ function katakanaToHiragana(input) {
   }
   return output.join("").normalize("NFC");
 }
+async function generateFurigana(text, bindedFunction) {
+  if (!text.includes("\u30FB"))
+    return String(
+      await bindedFunction(text, {
+        to: "hiragana",
+        mode: "furigana"
+      })
+    );
+  else
+    return (await Promise.all(
+      text.split("\u30FB").map(async (t) => {
+        const tFurigana = await generateFurigana(t, bindedFunction);
+        return tFurigana;
+      })
+    )).join("");
+}
 function getValidForms(readings, kanjiForms, wordIsCommon) {
   const kanjiFormRestrictions = /* @__PURE__ */ new Set();
   const validReadings = readings.filter(
@@ -1373,13 +1390,16 @@ function convertJMdict(xmlString, examples) {
         const meaningObj = { partOfSpeech: [], translations: [] };
         meaningObj.partOfSpeech = meaning.pos;
         meaningObj.translations = [];
-        for (const gloss of meaning.gloss)
-          if (typeof gloss === "string") meaningObj.translations.push(gloss);
-          else if (typeof gloss === "object" && typeof gloss._ === "string" && typeof gloss.$ === "object" && (gloss.$.g_type === "lit" || gloss.$.g_type === "expl" || gloss.$.g_type === "tm"))
+        for (const gloss of meaning.gloss) {
+          const translation = String(gloss._ ?? gloss).trim();
+          const type = typeof gloss.$ === "object" && typeof gloss.$.g_type === "string" ? gloss.$.g_type : void 0;
+          if (translation.length > 0 && type !== void 0 && type.length > 0)
             meaningObj.translations.push({
-              translation: gloss._,
-              type: gloss.$.g_type
+              translation,
+              type
             });
+          else meaningObj.translations.push(translation);
+        }
         if (isStringArray(meaning.xref)) meaningObj.references = meaning.xref;
         if (isStringArray(meaning.stagk))
           meaningObj.kanjiFormRestrictions = meaning.stagk;
@@ -1509,7 +1529,7 @@ function convertTanakaCorpus(tanakaString) {
     if (a !== void 0 && b !== void 0 && a.startsWith("A: ") && b.startsWith("B: ")) {
       a = a.replace("A: ", "");
       b = b.replace("B: ", "");
-      const idMatch = regexps.tanakaID.exec(a)?.groups["id"]?.trim();
+      const idMatch = regexps.tanakaID.exec(a)?.groups.id?.trim();
       const idParts = String(idMatch).split("_");
       const id = `${Number(idParts[0])}_${Number(idParts[1])}`;
       const aParts = a.replace(regexps.tanakaID, "").split("	");
@@ -1517,17 +1537,15 @@ function convertTanakaCorpus(tanakaString) {
       const bParts = [];
       for (const part of bRawParts) {
         const partMatches = regexps.tanakaPart.exec(part);
-        const baseForm = partMatches?.groups["base"];
+        const baseForm = partMatches?.groups.base;
         const examplePart = { baseForm };
-        const reading = partMatches?.groups["reading"];
-        const glossNumber = partMatches?.groups["glossnum"];
-        const inflectedForm = partMatches?.groups["inflection"];
+        const reading = partMatches?.groups.reading;
+        const glossNumber = partMatches?.groups.glossnum;
+        const inflectedForm = partMatches?.groups.inflection;
         if (reading !== void 0)
           if (regexps.tanakaReferenceID.test(reading)) {
             const referenceID = regexps.tanakaReferenceID.exec(reading);
-            examplePart.referenceID = `${Number(
-              referenceID?.groups["entryid"]
-            )}`;
+            examplePart.referenceID = `${Number(referenceID?.groups.entryid)}`;
           } else examplePart.reading = reading;
         if (glossNumber !== void 0)
           examplePart.glossNumber = glossNumber.startsWith("0") ? Number.parseInt(glossNumber.substring(1)) : Number.parseInt(glossNumber);
@@ -1557,13 +1575,10 @@ async function convertTanakaCorpusWithFurigana(tanakaString) {
   await kuroshiro.init(new KuromojiAnalyzer());
   const convert = kuroshiro.convert.bind(kuroshiro);
   for (let i = 0; i < tanakaArray.length; i++)
-    if (!tanakaArray[i].phrase.includes("\u30FB"))
-      tanakaArray[i].furigana = String(
-        await convert(tanakaArray[i].phrase, {
-          to: "hiragana",
-          mode: "furigana"
-        })
-      );
+    tanakaArray[i].furigana = await generateFurigana(
+      tanakaArray[i].phrase,
+      convert
+    );
   return tanakaArray;
 }
 function convertRadkFile(radkBuffer, kanjiDic) {
@@ -1766,17 +1781,22 @@ function createEntryMaps(jmDict, kanjiDic, tanakaExamples, wordDefinitionPairs,
   };
 }
 function mapEntry(entry) {
+  const senses = Array.from(
+    entry.senses.filter(
+      (sense) => isObjectArray(sense.form_of) && sense.form_of.every((form) => typeof form.word === "string") === true || isStringArray(sense.glosses)
+    )
+  );
   return {
     word: entry.word,
     pos_title: entry.pos_title,
-    senses: entry.senses.filter(
-      (sense) => (isObjectArray(sense.form_of) ? sense.form_of.every((form) => typeof form.word === "string") : isStringArray(sense.glosses)) === true || isStringArray(sense.glosses)
-    ).map((sense) => ({
-      ...isObjectArray(sense.form_of) ? {
-        form_of: sense.form_of.map((form) => String(form.word))
-      } : {},
-      glosses: sense.glosses
-    })),
+    ...senses.length > 0 ? {
+      senses: entry.senses.map((sense) => ({
+        ...isObjectArray(sense.form_of) ? {
+          form_of: sense.form_of.map((form) => String(form.word))
+        } : {},
+        glosses: sense.glosses
+      }))
+    } : {},
     ...isObjectArray(entry.forms) && entry.forms.every((form) => typeof form.form === "string") === true ? { forms: entry.forms.map((form) => String(form.form)) } : {}
   };
 }
@@ -1809,15 +1829,16 @@ async function convertJawiktionaryAsync(stream) {
   return entries;
 }
 function parseEntry(entry, definitions, definitionMap) {
-  for (const sense of entry.senses) {
-    const definition = sense.glosses.join("");
-    if (!definitions.some((def) => def.definition === definition)) {
-      if (!definitionMap.has(definition))
-        definitionMap.set(definition, { count: 1 });
-      else definitionMap.get(definition).count++;
-      definitions.push({ definition });
+  if (entry.senses !== void 0)
+    for (const sense of entry.senses) {
+      const definition = sense.glosses.join("");
+      if (!definitions.some((def) => def.definition === definition)) {
+        if (!definitionMap.has(definition))
+          definitionMap.set(definition, { count: 1 });
+        else definitionMap.get(definition).count++;
+        definitions.push({ definition });
+      }
     }
-  }
 }
 function getWordDefinitions(wiktionaryEntries, jmDict) {
   const entries = /* @__PURE__ */ new Map();
@@ -1866,19 +1887,20 @@ function getWordDefinitions(wiktionaryEntries, jmDict) {
     let valid = false;
     if (validKanjiForms.has(entry.word)) {
       valid = true;
-      for (const sense of entry.senses) {
-        if (sense.form_of !== void 0 && sense.form_of.some((form) => validForms.has(form)))
-          validFormOfEntries.add(entry.word);
-        for (const gloss of sense.glosses) {
-          let hasForm = false;
-          for (const r of validForms)
-            if (gloss.includes(r)) {
-              hasForm = true;
-              break;
-            }
-          if (hasForm) validGlossesEntries.add(entry.word);
+      if (entry.senses !== void 0)
+        for (const sense of entry.senses) {
+          if (sense.form_of !== void 0 && sense.form_of.some((form) => validForms.has(form)))
+            validFormOfEntries.add(entry.word);
+          for (const gloss of sense.glosses) {
+            let hasForm = false;
+            for (const r of validForms)
+              if (gloss.includes(r)) {
+                hasForm = true;
+                break;
+              }
+            if (hasForm) validGlossesEntries.add(entry.word);
+          }
         }
-      }
       if (entry.forms !== void 0) {
         for (const form of entry.forms)
           if (validForms.has(form)) validFormsEntries.add(entry.word);
@@ -2084,25 +2106,26 @@ function getWordDefinitions(wiktionaryEntries, jmDict) {
       const hasForms = ent.forms !== void 0 && ent.forms.some((form) => pair.forms.has(form));
       if (pair.kanjiForms !== void 0 && pair.kanjiForms.has(ent.word)) {
         kanjiFormEntries.push(ent);
-        for (const sense of ent.senses) {
-          if (hasValidFormOf && sense.form_of !== void 0) {
-            for (const form of sense.form_of)
-              if (pair.forms.has(form)) {
-                const elem = titleFormMap.get(form);
-                if (elem === void 0)
-                  titleFormMap.set(form, /* @__PURE__ */ new Set([ent.word]));
-                else elem.add(ent.word);
-              }
+        if (ent.senses !== void 0)
+          for (const sense of ent.senses) {
+            if (hasValidFormOf && sense.form_of !== void 0) {
+              for (const form of sense.form_of)
+                if (pair.forms.has(form)) {
+                  const elem = titleFormMap.get(form);
+                  if (elem === void 0)
+                    titleFormMap.set(form, /* @__PURE__ */ new Set([ent.word]));
+                  else elem.add(ent.word);
+                }
+            }
+            for (const gloss of sense.glosses)
+              for (const f of pair.forms)
+                if (gloss.includes(f)) {
+                  const elem = refsMap.get(f);
+                  if (elem === void 0)
+                    refsMap.set(f, /* @__PURE__ */ new Set([ent.word]));
+                  else elem.add(ent.word);
+                }
           }
-          for (const gloss of sense.glosses)
-            for (const f of pair.forms)
-              if (gloss.includes(f)) {
-                const elem = refsMap.get(f);
-                if (elem === void 0)
-                  refsMap.set(f, /* @__PURE__ */ new Set([ent.word]));
-                else elem.add(ent.word);
-              }
-        }
         if (hasValidForms && ent.forms !== void 0) {
           for (const form of ent.forms)
             if (pair.forms.has(form)) forms.add(form);
@@ -2183,13 +2206,10 @@ async function getWordDefinitionsWithFurigana(entryList, jmDict) {
   for (let i = 0; i < japaneseDefinitions.length; i++) {
     const pair = japaneseDefinitions[i];
     for (let j = 0; j < pair.definitions.length; j++)
-      if (!pair.definitions[j].definition.includes("\u30FB"))
-        pair.definitions[j].furigana = String(
-          await convert(pair.definitions[j].definition, {
-            to: "hiragana",
-            mode: "furigana"
-          })
-        );
+      pair.definitions[j].furigana = await generateFurigana(
+        pair.definitions[j].definition,
+        convert
+      );
     japaneseDefinitions[i] = pair;
   }
   return japaneseDefinitions;
@@ -2933,6 +2953,7 @@ export {
   createEntryMaps,
   generateAnkiNote,
   generateAnkiNotesFile,
+  generateFurigana,
   getKanji,
   getKanjiExtended,
   getValidForms,