henkan 2.1.0 → 2.2.1

package/dist/index.mjs

@@ -1576,6 +1576,133 @@ function convertKradFile(kradBuffer, kanjiDic, katakanaList) {
   }
   return kanjiWithRadicals;
 }
+function createEntryMaps(jmDict, kanjiDic, tanakaExamples, wordDefinitionPairs, svgList) {
+  var _a;
+  const kanjiEntryMap = /* @__PURE__ */ new Map();
+  const wordIDEntryMap = /* @__PURE__ */ new Map();
+  const kanjiWordsMap = /* @__PURE__ */ new Map();
+  const wordExamplesMap = /* @__PURE__ */ new Map();
+  const wordDefinitionsMap = /* @__PURE__ */ new Map();
+  const kanjiSVGMap = /* @__PURE__ */ new Map();
+  const wordPartsMap = /* @__PURE__ */ new Map();
+  const partExamplesMap = /* @__PURE__ */ new Map();
+  const entryParts = /* @__PURE__ */ new Set();
+  if (kanjiDic)
+    for (const kanji of kanjiDic) kanjiEntryMap.set(kanji.kanji, kanji);
+  if (wordDefinitionPairs)
+    for (const pair of wordDefinitionPairs)
+      wordDefinitionsMap.set(pair.wordID, pair.definitions);
+  if (kanjiDic && svgList)
+    for (const kanji of kanjiDic) {
+      const codePoint = kanji.kanji.codePointAt(0).toString(16).toLowerCase();
+      const svg = svgList.find((file) => {
+        const baseName = file.split(".")[0].toLowerCase();
+        return baseName === codePoint || baseName === `0${codePoint}`;
+      });
+      if (svg) kanjiSVGMap.set(kanji.kanji, svg);
+    }
+  if (jmDict) {
+    for (const word of jmDict) {
+      wordIDEntryMap.set(word.id, word);
+      if (word.kanjiForms)
+        for (const kf of word.kanjiForms)
+          for (const char of kf.form.split("").filter((c) => regexps.kanji.test(c))) {
+            if (!kanjiWordsMap.has(char)) kanjiWordsMap.set(char, [word]);
+            else kanjiWordsMap.get(char).push(word);
+          }
+      if (tanakaExamples) {
+        const rkf = getValidForms(
+          word.readings,
+          word.kanjiForms,
+          word.isCommon
+        );
+        const localPartParts = /* @__PURE__ */ new Set();
+        if (rkf.readings.length > 0)
+          for (const reading of rkf.readings) {
+            entryParts.add(reading.reading);
+            localPartParts.add(reading.reading);
+          }
+        if (rkf.kanjiForms && rkf.kanjiForms.length > 0)
+          for (const kanjiForm of rkf.kanjiForms) {
+            entryParts.add(kanjiForm.form);
+            localPartParts.add(kanjiForm.form);
+          }
+        entryParts.add(word.id);
+        localPartParts.add(word.id);
+        wordPartsMap.set(word.id, localPartParts);
+      }
+    }
+    if (tanakaExamples) {
+      for (const ex of tanakaExamples) {
+        for (const part of ex.parts) {
+          if (entryParts.has(part.baseForm)) {
+            let exList = partExamplesMap.get(
+              part.baseForm
+            );
+            if (!exList) {
+              exList = [];
+              partExamplesMap.set(part.baseForm, exList);
+            }
+            exList.push(ex);
+          }
+          if (part.reading && entryParts.has(part.reading)) {
+            let exList = partExamplesMap.get(
+              part.reading
+            );
+            if (!exList) {
+              exList = [];
+              partExamplesMap.set(part.reading, exList);
+            }
+            exList.push(ex);
+          }
+          if (part.inflectedForm && entryParts.has(part.inflectedForm)) {
+            let exList = partExamplesMap.get(
+              part.inflectedForm
+            );
+            if (!exList) {
+              exList = [];
+              partExamplesMap.set(part.inflectedForm, exList);
+            }
+            exList.push(ex);
+          }
+          if (part.referenceID && entryParts.has(part.referenceID)) {
+            let exList = partExamplesMap.get(
+              part.referenceID
+            );
+            if (!exList) {
+              exList = [];
+              partExamplesMap.set(part.referenceID, exList);
+            }
+            exList.push(ex);
+          }
+        }
+      }
+      for (const word of jmDict) {
+        const entryParts2 = wordPartsMap.get(word.id);
+        const seenEx = /* @__PURE__ */ new Set();
+        const validExamples = [];
+        for (const p of entryParts2) {
+          const examplesForPart = (_a = partExamplesMap.get(p)) == null ? void 0 : _a.filter((ex) => !seenEx.has(ex.id));
+          if (!examplesForPart) continue;
+          for (const ex of examplesForPart) {
+            seenEx.add(ex.id);
+            validExamples.push(ex);
+          }
+        }
+        if (validExamples.length > 0)
+          wordExamplesMap.set(word.id, validExamples);
+      }
+    }
+  }
+  return {
+    ...wordIDEntryMap.size > 0 ? { wordIDEntryMap } : {},
+    ...kanjiWordsMap.size > 0 ? { kanjiWordsMap } : {},
+    ...kanjiEntryMap.size > 0 ? { kanjiEntryMap } : {},
+    ...wordExamplesMap.size > 0 ? { wordExamplesMap } : {},
+    ...wordDefinitionsMap.size > 0 ? { wordDefinitionsMap } : {},
+    ...kanjiSVGMap.size > 0 ? { kanjiSVGMap } : {}
+  };
+}
 function mapEntry(entry) {
   return {
     word: entry.word,
@@ -1600,7 +1727,7 @@ function convertJawiktionarySync(buffer) {
     const line = lines[i];
     if (!line) continue;
     const obj = JSON.parse(line);
-    if (obj && typeof obj === "object" && obj.lang_code === "ja" && obj.lang === "\u65E5\u672C\u8A9E")
+    if (obj && typeof obj === "object" && typeof obj.lang === "string" && (obj.lang === "\u65E5\u672C\u8A9E" || obj.lang === "\u53E4\u5178\u65E5\u672C\u8A9E"))
       entries.push(mapEntry(obj));
   }
   return entries;
@@ -1615,7 +1742,7 @@ async function convertJawiktionaryAsync(stream) {
       const entries = [];
       for await (const line of rl) {
         const obj = JSON.parse(line.trim());
-        if (obj && typeof obj === "object" && obj.lang_code === "ja" && obj.lang === "\u65E5\u672C\u8A9E")
+        if (obj && typeof obj === "object" && typeof obj.lang === "string" && (obj.lang === "\u65E5\u672C\u8A9E" || obj.lang === "\u53E4\u5178\u65E5\u672C\u8A9E"))
           entries.push(mapEntry(obj));
       }
       rl.close();
@@ -1646,20 +1773,34 @@ function getWordDefinitions(entryList, jmDict) {
   }
   const japaneseDefinitions = [];
   const definitionMap = /* @__PURE__ */ new Map();
-  const validWords = [];
+  const wordFormsMap = /* @__PURE__ */ new Map();
   const validReadings = /* @__PURE__ */ new Set();
   const validKanjiForms = /* @__PURE__ */ new Set();
+  const validForms = /* @__PURE__ */ new Set();
   for (const word of jmDict) {
+    const wordReadings = /* @__PURE__ */ new Set();
+    const wordKanjiForms = /* @__PURE__ */ new Set();
     const rkf = getValidForms(
       word.readings,
       word.kanjiForms,
       word.isCommon
     );
     if (rkf.readings.length > 0)
-      for (const r of rkf.readings) validReadings.add(r.reading);
+      for (const r of rkf.readings) {
+        validReadings.add(r.reading);
+        wordReadings.add(r.reading);
+        validForms.add(r.reading);
+      }
     if (rkf.kanjiForms && rkf.kanjiForms.length > 0)
-      for (const kf of rkf.kanjiForms) validKanjiForms.add(kf.form);
-    validWords.push(word);
+      for (const kf of rkf.kanjiForms) {
+        validKanjiForms.add(kf.form);
+        wordKanjiForms.add(kf.form);
+        validForms.add(kf.form);
+      }
+    wordFormsMap.set(word.id, {
+      readings: wordReadings,
+      ...wordKanjiForms.size > 0 ? { kanjiForms: wordKanjiForms } : {}
+    });
   }
   const validTitleEntries = /* @__PURE__ */ new Map();
   const entriesWithFormTitlesGlobal = /* @__PURE__ */ new Map();
@@ -1676,15 +1817,15 @@ function getWordDefinitions(entryList, jmDict) {
         if (sense.form_of && sense.form_of.some((form) => validReadings.has(form)))
           validFormOfEntries.add(entry.word);
         for (const gloss of sense.glosses) {
-          let reading = void 0;
-          if (gloss.trim().includes("\u6F22\u5B57\u8868\u8A18") || gloss.trim().includes("\u53C2\u7167")) {
-            for (const r of validReadings)
-              if (gloss.trim().includes(r)) {
-                reading = r;
+          let hasForm = false;
+          if (gloss.includes("\u8868\u8A18") || gloss.includes("\u53C2\u7167")) {
+            for (const r of validForms)
+              if (gloss.includes(r)) {
+                hasForm = true;
                 break;
               }
           }
-          if (reading) validGlossesEntries.add(entry.word);
+          if (hasForm) validGlossesEntries.add(entry.word);
         }
       }
       if (entry.forms) {
@@ -1796,7 +1937,7 @@ function getWordDefinitions(entryList, jmDict) {
   fge.length = 0;
   wfe.length = 0;
   const wordEntriesPairs = [];
-  for (const word of validWords) {
+  for (const word of jmDict) {
     const poses = /* @__PURE__ */ new Set();
     for (const m of word.meanings)
       for (const note of m.partOfSpeech) {
@@ -1811,23 +1952,15 @@ function getWordDefinitions(entryList, jmDict) {
             poses.add(notePos);
         }
       }
-    const rkf = getValidForms(
-      word.readings,
-      word.kanjiForms,
-      word.isCommon
-    );
-    const validWordReadings = new Set(
-      rkf.readings.map((r) => r.reading)
-    );
-    const validWordKanjiForms = rkf.kanjiForms ? new Set(rkf.kanjiForms.map((kf) => kf.form)) : void 0;
+    const rkf = wordFormsMap.get(word.id);
     const entriesWithTitles = [];
     const entriesWithFormTitles = [];
     const entriesWithForms = [];
     if (poses.size > 0)
       for (const pos of poses) {
         const posEntries = posMap.get(pos);
-        if (validWordKanjiForms)
-          for (const kf of validWordKanjiForms) {
+        if (rkf.kanjiForms)
+          for (const kf of rkf.kanjiForms) {
             const te = (_a = posEntries.title) == null ? void 0 : _a.get(kf);
             const fe = (_b = posEntries.form) == null ? void 0 : _b.get(kf);
             if (te)
@@ -1840,28 +1973,28 @@ function getWordDefinitions(entryList, jmDict) {
               entriesWithForms.push(
                 ...fe.filter(
                   (ent) => ent.forms && ent.forms.some(
-                    (form) => validWordKanjiForms.has(form) || validWordReadings.has(form)
+                    (form) => rkf.kanjiForms.has(form) || rkf.readings.has(form)
                   )
                 )
               );
           }
-        for (const r of validWordReadings) {
+        for (const r of rkf.readings) {
           const te = (_c = posEntries.title) == null ? void 0 : _c.get(r);
           const fe = (_d = posEntries.form) == null ? void 0 : _d.get(r);
           const fte = (_e = posEntries.formTitle) == null ? void 0 : _e.get(r);
           if (te)
             entriesWithTitles.push(
               ...te.filter(
-                (ent) => ent.forms && validWordKanjiForms && ent.forms.some(
-                  (form) => validWordKanjiForms.has(form)
-                ) || validWordKanjiForms === void 0
+                (ent) => ent.forms && rkf.kanjiForms && ent.forms.some(
+                  (form) => rkf.kanjiForms.has(form)
+                ) || rkf.kanjiForms === void 0
               )
             );
           if (fe)
             entriesWithForms.push(
               ...fe.filter(
                 (ent) => ent.forms && ent.forms.some(
-                  (form) => validWordKanjiForms && validWordKanjiForms.has(form) || validWordReadings.has(form)
+                  (form) => rkf.kanjiForms && rkf.kanjiForms.has(form) || rkf.readings.has(form)
                 )
               )
             );
@@ -1869,8 +2002,8 @@ function getWordDefinitions(entryList, jmDict) {
         }
       }
     if (entriesWithTitles.length === 0 && entriesWithFormTitles.length === 0 && entriesWithForms.length === 0) {
-      if (validWordKanjiForms)
-        for (const kf of validWordKanjiForms) {
+      if (rkf.kanjiForms)
+        for (const kf of rkf.kanjiForms) {
           const te = validTitleEntries.get(kf);
           const fe = entriesWithFormsGlobal.get(kf);
           if (te)
@@ -1883,28 +2016,28 @@ function getWordDefinitions(entryList, jmDict) {
             entriesWithForms.push(
               ...fe.filter(
                 (ent) => ent.forms && ent.forms.some(
-                  (form) => validWordKanjiForms.has(form) || validWordReadings.has(form)
+                  (form) => rkf.kanjiForms.has(form) || rkf.readings.has(form)
                 )
               )
             );
         }
-      for (const r of validWordReadings) {
+      for (const r of rkf.readings) {
         const te = validTitleEntries.get(r);
         const fe = entriesWithFormsGlobal.get(r);
         const fte = entriesWithFormTitlesGlobal.get(r);
         if (te)
           entriesWithTitles.push(
             ...te.filter(
-              (ent) => ent.forms && validWordKanjiForms && ent.forms.some(
-                (form) => validWordKanjiForms.has(form)
-              ) || validWordKanjiForms === void 0
+              (ent) => ent.forms && rkf.kanjiForms && ent.forms.some(
+                (form) => rkf.kanjiForms.has(form)
+              ) || rkf.kanjiForms === void 0
             )
           );
         if (fe)
           entriesWithForms.push(
             ...fe.filter(
               (ent) => ent.forms && ent.forms.some(
-                (form) => validWordKanjiForms && validWordKanjiForms.has(form) || validWordReadings.has(form)
+                (form) => rkf.kanjiForms && rkf.kanjiForms.has(form) || rkf.readings.has(form)
               )
             )
           );
@@ -1914,8 +2047,9 @@ function getWordDefinitions(entryList, jmDict) {
     if (entriesWithTitles.length > 0 && (entriesWithFormTitles.length > 0 || entriesWithForms.length > 0))
       wordEntriesPairs.push({
         word,
-        readings: validWordReadings,
-        ...validWordKanjiForms ? { kanjiForms: validWordKanjiForms } : {},
+        readings: rkf.readings,
+        ...rkf.kanjiForms ? { kanjiForms: rkf.kanjiForms } : {},
+        forms: rkf.kanjiForms ? rkf.readings.union(rkf.kanjiForms) : rkf.readings,
         entriesWithTitles,
         entriesWithFormTitles,
         entriesWithForms
@@ -1924,7 +2058,7 @@ function getWordDefinitions(entryList, jmDict) {
   for (const pair of wordEntriesPairs) {
     const definitions = [];
     const kanjiFormEntries = [];
-    const readingWithFormsEntries = [];
+    const entriesWithForms = [];
     const readingEntries = [];
     const titleFormMap = /* @__PURE__ */ new Map();
     const refsMap = /* @__PURE__ */ new Map();
@@ -1932,9 +2066,9 @@ function getWordDefinitions(entryList, jmDict) {
     for (const ent of pair.entriesWithTitles) {
       const validFormOf = validFormOfEntries.has(ent.word);
       const validGlosses = validGlossesEntries.has(ent.word);
-      const validForms = validFormsEntries.has(ent.word);
+      const validForms2 = validFormsEntries.has(ent.word);
       const hasKanjiForms = ent.forms !== void 0 && pair.kanjiForms !== void 0 && ent.forms.some((form) => pair.kanjiForms.has(form));
-      if (pair.kanjiForms && pair.kanjiForms.has(ent.word) && (validFormOf || validGlosses || validForms)) {
+      if (pair.kanjiForms && pair.kanjiForms.has(ent.word) && (validFormOf || validGlosses || validForms2)) {
         kanjiFormEntries.push(ent);
         if ((validFormOf || validGlosses) && ent.senses)
           for (const sense of ent.senses) {
@@ -1948,62 +2082,48 @@ function getWordDefinitions(entryList, jmDict) {
                 }
             }
             if (validGlosses) {
-              for (const gloss of sense.glosses) {
-                let reading = void 0;
-                if (gloss.trim().includes("\u6F22\u5B57\u8868\u8A18") || gloss.trim().includes("\u53C2\u7167")) {
-                  for (const r of pair.readings)
-                    if (gloss.trim().includes(r)) {
-                      reading = r;
-                      break;
+              for (const gloss of sense.glosses)
+                if (gloss.includes("\u8868\u8A18") || gloss.includes("\u53C2\u7167")) {
+                  for (const f of pair.forms)
+                    if (gloss.includes(f)) {
+                      const elem = refsMap.get(f);
+                      if (!elem) refsMap.set(f, /* @__PURE__ */ new Set([ent.word]));
+                      else elem.add(ent.word);
                     }
                 }
-                if (reading) {
-                  const elem = refsMap.get(reading);
-                  if (!elem) refsMap.set(reading, /* @__PURE__ */ new Set([ent.word]));
-                  else elem.add(ent.word);
-                }
-              }
             }
           }
-        if (validForms && ent.forms) {
+        if (validForms2 && ent.forms) {
           for (const form of ent.forms)
             if (pair.readings.has(form)) readingForms.add(form);
         }
       }
       if (pair.readings.has(ent.word) && hasKanjiForms)
-        readingWithFormsEntries.push(ent);
+        entriesWithForms.push(ent);
       if (pair.kanjiForms === void 0 && pair.readings.has(ent.word))
         readingEntries.push(ent);
     }
     for (const entry of pair.entriesWithForms) {
       const elem = titleFormMap.get(entry.word);
       if (elem && entry.forms && entry.forms.some((form) => elem.has(form)))
-        readingWithFormsEntries.push(entry);
+        entriesWithForms.push(entry);
     }
     for (const entry of pair.entriesWithFormTitles) {
       if (readingForms.has(entry.word)) {
-        readingWithFormsEntries.push(entry);
+        entriesWithForms.push(entry);
         continue;
       }
-      if (pair.kanjiForms) {
-        const ft = refsMap.get(entry.word);
-        if (ft && !ft.isDisjointFrom(pair.kanjiForms))
-          readingWithFormsEntries.push(entry);
-      }
+      const ft = refsMap.get(entry.word);
+      if (ft && !ft.isDisjointFrom(pair.forms)) entriesWithForms.push(entry);
     }
-    let parsedReadingWithFormsEntries = false;
-    for (const entry of kanjiFormEntries)
-      if (entry.pos_title === "\u548C\u8A9E\u306E\u6F22\u5B57\u8868\u8A18" && readingWithFormsEntries.length > 0) {
-        if (!parsedReadingWithFormsEntries)
-          parsedReadingWithFormsEntries = true;
-        for (const ref of readingWithFormsEntries)
-          parseEntry(ref, definitions, definitionMap);
-      } else parseEntry(entry, definitions, definitionMap);
-    if (!parsedReadingWithFormsEntries && readingWithFormsEntries.length > 0) {
-      parsedReadingWithFormsEntries = true;
-      for (const ref of readingWithFormsEntries)
-        parseEntry(ref, definitions, definitionMap);
+    if (kanjiFormEntries.length > 0) {
+      for (const entry of kanjiFormEntries)
+        if (entry.pos_title !== "\u548C\u8A9E\u306E\u6F22\u5B57\u8868\u8A18")
+          parseEntry(entry, definitions, definitionMap);
     }
+    if (entriesWithForms.length > 0)
+      for (const ref of entriesWithForms)
+        parseEntry(ref, definitions, definitionMap);
     if (readingEntries.length > 0)
       for (const readingEntry of readingEntries)
         parseEntry(readingEntry, definitions, definitionMap);
@@ -2019,7 +2139,7 @@ function getWordDefinitions(entryList, jmDict) {
       const defCount = definitionMap.get(
         pair.definitions[j].definition
       );
-      if (defCount && defCount.count > 1)
+      if (defCount && defCount.count > 0)
         pair.definitions[j].mayNotBeAccurate = true;
     }
     japaneseDefinitions[i] = pair;
@@ -2194,13 +2314,15 @@ function getWord(word, dict, kanjiDic, examples, definitions, noteTypeName, deck
     }
     if (kanjiDic && word2.kanjiForms) {
       const kanji = [];
+      const seenChars = /* @__PURE__ */ new Set();
       for (const kanjiForm of word2.kanjiForms)
-        for (const char of kanjiForm.kanjiForm) {
-          if (!regexps.kanji.test(char) || kanji.some((kanji2) => kanji2.kanji === char))
-            continue;
+        for (const char of kanjiForm.kanjiForm.split("").filter((c) => regexps.kanji.test(c))) {
+          if (seenChars.has(char)) continue;
+          seenChars.add(char);
+          const kanjiEntry = kanjiDic instanceof Map ? kanjiDic.get(char) : void 0;
           const kanjiObj = getKanji(
-            char,
-            Array.isArray(kanjiDic) ? kanjiDic : kanjiDic.get(char)
+            kanjiEntry ?? char,
+            Array.isArray(kanjiDic) ? kanjiDic : void 0
           );
           if (kanjiObj)
             kanji.push({
@@ -2211,9 +2333,7 @@ function getWord(word, dict, kanjiDic, examples, definitions, noteTypeName, deck
       if (kanji.length > 0) word2.kanji = kanji;
     }
     if (dictWord.hasPhrases !== void 0 && examples) {
-      const exampleList = Array.isArray(examples) ? examples : examples.get(
-        dictWord.id
-      ) ?? [];
+      const exampleList = Array.isArray(examples) ? examples : examples.get(dictWord.id) ?? [];
       const rkf = getValidForms(
         dictWord.readings,
         dictWord.kanjiForms,
@@ -2281,17 +2401,23 @@ function getWord(word, dict, kanjiDic, examples, definitions, noteTypeName, deck
             }
           }
         }
-        if (glossSpecificExamples.length === 5) break;
       }
-      if (glossSpecificExamples.length === 5)
-        wordExamples = [...glossSpecificExamples];
-      else if (glossSpecificExamples.length > 0)
-        wordExamples = [
-          ...glossSpecificExamples,
-          ...wordExamples.filter(
+      if (glossSpecificExamples.length === word2.translations.length)
+        wordExamples = glossSpecificExamples;
+      else if (glossSpecificExamples.length > 0) {
+        const exes = glossSpecificExamples;
+        if (exes.length < 5) {
+          wordExamples = wordExamples.filter(
             (ex) => !seenPhrases.has(ex.ex.phrase)
-          ).slice(0, 5 - glossSpecificExamples.length)
-        ];
+          );
+          if (wordExamples.length > 0)
+            for (const ex of wordExamples) {
+              exes.push(ex);
+              if (exes.length === 5) break;
+            }
+        }
+        wordExamples = exes;
+      }
       if (wordExamples.length > 0) {
         word2.phrases = (wordExamples.length > 5 ? wordExamples.slice(0, 5) : wordExamples).map((ex) => ({
           phrase: ex.ex.furigana ?? ex.ex.phrase,
@@ -2305,9 +2431,7 @@ function getWord(word, dict, kanjiDic, examples, definitions, noteTypeName, deck
       }
     }
     if (definitions) {
-      const defs = Array.isArray(definitions) ? (_a = definitions.find((wdp) => wdp.wordID === word2.id)) == null ? void 0 : _a.definitions : definitions.get(
-        word2.id
-      );
+      const defs = Array.isArray(definitions) ? (_a = definitions.find((wdp) => wdp.wordID === word2.id)) == null ? void 0 : _a.definitions : definitions.get(word2.id);
       if (defs) word2.definitions = [...defs];
     }
     return word2;
@@ -2751,6 +2875,7 @@ export {
   convertRadkFile,
   convertTanakaCorpus,
   convertTanakaCorpusWithFurigana,
+  createEntryMaps,
   generateAnkiNote,
   generateAnkiNotesFile,
   getKanji,