henkan 2.2.4 → 2.3.0

package/dist/index.mjs

@@ -40,6 +40,43 @@ var notSearchedForms = /* @__PURE__ */ new Set([
   "word containing out-dated kanji or kanji usage",
   "Out-dated kanji or kanji usage"
 ]);
+var posList = [
+  "\u540D\u8A5E",
+  "\u52D5\u8A5E",
+  "\u6210\u53E5",
+  "\u526F\u8A5E",
+  "\u5F62\u5BB9\u52D5\u8A5E",
+  "\u52A9\u8A5E",
+  "\u611F\u52D5\u8A5E",
+  "\u4EE3\u540D\u8A5E",
+  "\u63A5\u5C3E\u8F9E",
+  "\u63A5\u982D\u8A9E",
+  "\u9020\u8A9E\u6210\u5206",
+  "\u7565\u8A9E",
+  "\u56FA\u6709\u540D\u8A5E",
+  "\u4EBA\u79F0\u4EE3\u540D\u8A5E",
+  "\u63A5\u982D\u8F9E",
+  "\u63A5\u7D9A\u52A9\u8A5E",
+  "\u9593\u6295\u8A5E",
+  "\u52A9\u52D5\u8A5E",
+  "\u5F62\u5BB9\u8A5E",
+  "\u7E2E\u7D04\u5F62",
+  "\u63A5\u8F9E",
+  "\u63A5\u7D9A\u8A5E",
+  "\u9023\u4F53\u8A5E",
+  "\u4EBA\u540D",
+  "\u8A18\u53F7",
+  "\u6570\u8A5E",
+  "\u6163\u7528\u53E5",
+  "\u3053\u3068\u308F\u3056",
+  "\u52A9\u6570\u8A5E",
+  "\u82F1\u6570\u5B57\u6DF7\u5408\u8868\u8A18",
+  "\u52D5\u8A5E\u53E5",
+  "\u6210\u8A9E",
+  "\u610F\u7FA9",
+  "\u982D\u5B57\u8A9E",
+  "\u63A5\u5C3E\u8A9E"
+];
 var noteMap = /* @__PURE__ */ new Map([
   ["brazilian", ["dialect::brazilian", "Dialect: Brazilian"]],
   ["hokkaido-ben", ["dialect::hokkaido-ben", "Dialect: Hokkaid\u014D-ben"]],
@@ -1183,10 +1220,10 @@ var noteMap = /* @__PURE__ */ new Map([
 ]);
 
 // src/utils.ts
+import { createInterface } from "readline";
 import libxml from "libxmljs2";
 import xml from "xml2js";
 import iconv from "iconv-lite";
-import { createInterface } from "readline";
 var Kuroshiro = __require("kuroshiro");
 var KuromojiAnalyzer = __require("kuroshiro-analyzer-kuromoji");
 function capitalizeString(value) {
@@ -1202,7 +1239,7 @@ function isObjectArray(arg) {
   return isValidArrayWithFirstElement(arg) && arg.every((element) => typeof element === "object");
 }
 function shuffleArray(arr) {
-  const a = arr.slice();
+  const a = Array.from(arr);
   for (let i = a.length - 1; i > 0; i--) {
     const j = Math.floor(Math.random() * (i + 1));
     const tmp = a[i];
@@ -1211,13 +1248,43 @@ function shuffleArray(arr) {
   }
   return a;
 }
+function hiraganaToKatakana(input) {
+  const decomposed = input.normalize("NFD");
+  const output = [];
+  for (const ch of decomposed.split("")) {
+    const cp = ch.codePointAt(0);
+    if (cp === 12441 || cp === 12442) {
+      output.push(ch);
+      continue;
+    }
+    if (cp >= 12352 && cp <= 12447)
+      output.push(String.fromCodePoint(cp + 96));
+    else output.push(ch);
+  }
+  return output.join("").normalize("NFC");
+}
+function katakanaToHiragana(input) {
+  const decomposed = input.normalize("NFD");
+  const output = [];
+  for (const ch of decomposed.split("")) {
+    const cp = ch.codePointAt(0);
+    if (cp === 12441 || cp === 12442) {
+      output.push(ch);
+      continue;
+    }
+    if (cp >= 12448 && cp <= 12543)
+      output.push(String.fromCodePoint(cp - 96));
+    else output.push(ch);
+  }
+  return output.join("").normalize("NFC");
+}
 function getValidForms(readings, kanjiForms, wordIsCommon) {
   const kanjiFormRestrictions = /* @__PURE__ */ new Set();
   const validReadings = readings.filter(
     (reading, index) => {
       if (index === 0) return true;
       if (reading.notes === void 0 || !reading.notes.some((note) => notSearchedForms.has(note))) {
-        if (reading.kanjiFormRestrictions) {
+        if (reading.kanjiFormRestrictions !== void 0) {
           for (const kfr of reading.kanjiFormRestrictions)
             kanjiFormRestrictions.add(kfr);
           return true;
@@ -1228,20 +1295,22 @@ function getValidForms(readings, kanjiForms, wordIsCommon) {
       return false;
     }
   );
-  const existValidKf = kanjiForms !== void 0 ? kanjiForms.some(
-    (kf, index) => index !== 0 && ((kf.notes === void 0 || !kf.notes.some((note) => notSearchedForms.has(note))) && (wordIsCommon === void 0 || kf.commonness !== void 0) || kanjiFormRestrictions.has(kf.form))
-  ) : void 0;
-  const validKanjiForms = kanjiForms !== void 0 ? kanjiForms.filter((kanjiForm, index) => {
-    if (index === 0) return true;
-    if (existValidKf === true)
-      return (kanjiForm.notes === void 0 || !kanjiForm.notes.some(
-        (note) => notSearchedForms.has(note)
-      )) && (wordIsCommon === void 0 || kanjiForm.commonness !== void 0) || kanjiFormRestrictions.has(kanjiForm.form);
-    else return true;
-  }) : void 0;
+  const existValidKf = kanjiForms == null ? void 0 : kanjiForms.some(
+    (kf, index) => index !== 0 && (kf.notes === void 0 || !kf.notes.some((note) => notSearchedForms.has(note)) && (wordIsCommon === void 0 || kf.commonness !== void 0) || kanjiFormRestrictions.has(kf.form))
+  );
+  const validKanjiForms = kanjiForms == null ? void 0 : kanjiForms.filter(
+    (kanjiForm, index) => {
+      if (index === 0) return true;
+      if (existValidKf === true)
+        return kanjiForm.notes === void 0 || !kanjiForm.notes.some(
+          (note) => notSearchedForms.has(note)
+        ) && (wordIsCommon === void 0 || kanjiForm.commonness !== void 0) || kanjiFormRestrictions.has(kanjiForm.form);
+      else return true;
+    }
+  );
   return {
     readings: validReadings,
-    ...validKanjiForms ? { kanjiForms: validKanjiForms } : {}
+    ...validKanjiForms !== void 0 ? { kanjiForms: validKanjiForms } : {}
   };
 }
 function convertJMdict(xmlString, examples) {
@@ -1253,13 +1322,13 @@ function convertJMdict(xmlString, examples) {
   });
   const dict = [];
   xml.parseString(dictParsed, (_err, result) => {
-    const tanakaParts = examples && examples.length > 0 ? new Set(
+    const tanakaParts = examples !== void 0 && examples.length > 0 ? new Set(
       examples.flatMap(
         (example) => example.parts.flatMap((part) => [
           part.baseForm,
-          ...part.reading ? [part.reading] : [],
-          ...part.inflectedForm ? [part.inflectedForm] : [],
-          ...part.referenceID ? [part.referenceID] : []
+          ...part.reading !== void 0 ? [part.reading] : [],
+          ...part.inflectedForm !== void 0 ? [part.inflectedForm] : [],
+          ...part.referenceID !== void 0 ? [part.referenceID] : []
         ])
       )
     ) : void 0;
@@ -1306,7 +1375,7 @@ function convertJMdict(xmlString, examples) {
         meaningObj.translations = [];
         for (const gloss of meaning.gloss)
           if (typeof gloss === "string") meaningObj.translations.push(gloss);
-          else if (typeof gloss === "object" && gloss._ && typeof gloss._ === "string" && gloss.$ && typeof gloss.$ === "object" && gloss.$.g_type && (gloss.$.g_type === "lit" || gloss.$.g_type === "expl" || gloss.$.g_type === "tm"))
+          else if (typeof gloss === "object" && typeof gloss._ === "string" && typeof gloss.$ === "object" && (gloss.$.g_type === "lit" || gloss.$.g_type === "expl" || gloss.$.g_type === "tm"))
             meaningObj.translations.push({
               translation: gloss._,
               type: gloss.$.g_type
@@ -1321,7 +1390,7 @@ function convertJMdict(xmlString, examples) {
         if (isStringArray(meaning.s_inf)) meaningObj.info = meaning.s_inf;
         if (isStringArray(meaning.misc)) {
           meaningObj.misc = meaning.misc;
-          if (meaningObj.misc && meaningObj.misc.includes("word usually written using kana alone"))
+          if (meaningObj.misc !== void 0 && meaningObj.misc.includes("word usually written using kana alone"))
             usuallyInKanaMeanings++;
         }
         if (isStringArray(meaning.dial)) meaningObj.dialects = meaning.dial;
@@ -1329,30 +1398,31 @@ function convertJMdict(xmlString, examples) {
       }
       if (entryObj.meanings.length === usuallyInKanaMeanings)
         entryObj.usuallyInKana = true;
-      if (examples) {
+      if (examples !== void 0) {
         let existsExample = false;
-        if (tanakaParts && tanakaParts.has(entryObj.id)) existsExample = true;
+        if (tanakaParts !== void 0 && tanakaParts.has(entryObj.id))
+          existsExample = true;
         if (!existsExample) {
           const rkf = getValidForms(
             entryObj.readings,
             entryObj.kanjiForms,
             entryObj.isCommon
           );
-          const readings2 = new Set(
+          const validReadings = new Set(
             rkf.readings.map((r) => r.reading)
           );
-          const kanjiForms2 = rkf.kanjiForms ? new Set(
+          const validKanjiForms = rkf.kanjiForms !== void 0 ? new Set(
             rkf.kanjiForms.map((kf) => kf.form)
           ) : void 0;
-          if (kanjiForms2 && kanjiForms2.size > 0 && tanakaParts) {
-            for (const kf of kanjiForms2)
+          if (validKanjiForms !== void 0 && validKanjiForms.size > 0 && tanakaParts !== void 0) {
+            for (const kf of validKanjiForms)
               if (tanakaParts.has(kf)) {
                 existsExample = true;
                 break;
               }
           }
-          if (entryObj.kanjiForms === void 0 && readings2.size > 0 && tanakaParts) {
-            for (const r of readings2)
+          if (entryObj.kanjiForms === void 0 && validReadings.size > 0 && tanakaParts !== void 0) {
+            for (const r of validReadings)
               if (tanakaParts.has(r)) {
                 existsExample = true;
                 break;
@@ -1386,7 +1456,7 @@ function convertKanjiDic(xmlString) {
         if (isStringArray(misc.grade)) kanjiObj.misc.grade = misc.grade[0];
         if (isStringArray(misc.freq)) kanjiObj.misc.frequency = misc.freq[0];
         if (isStringArray(misc.jlpt) && ["5", "4", "3", "2", "1"].includes(misc.jlpt[0]))
-          kanjiObj.misc.jlpt = `N${misc.jlpt[0]}`;
+          kanjiObj.misc.jlpt = `N${Number(String(misc.jlpt[0]))}`;
         if (isObjectArray(entry.reading_meaning))
           for (const rm of entry.reading_meaning) {
             const rmObj = { groups: [] };
@@ -1397,7 +1467,7 @@ function convertKanjiDic(xmlString) {
               };
               if (isObjectArray(group.reading)) {
                 for (const reading of group.reading)
-                  if (reading._ && typeof reading._ === "string" && reading.$ && typeof reading.$ === "object" && reading.$.r_type && (reading.$.r_type === "ja_on" || reading.$.r_type === "ja_kun"))
+                  if (typeof reading._ === "string" && typeof reading.$ === "object" && (reading.$.r_type === "ja_on" || reading.$.r_type === "ja_kun"))
                     groupObj.readings.push({
                       reading: reading._,
                       type: reading.$.r_type
@@ -1421,7 +1491,7 @@ function convertKanjiDic(xmlString) {
             }
             if (isStringArray(rm.nanori) && rm.nanori.length > 0)
               rmObj.nanori = rm.nanori;
-            if (rmObj.groups.length > 0 || rmObj.nanori)
+            if (rmObj.groups.length > 0 || rmObj.nanori !== void 0)
               kanjiObj.readingMeaning.push(rmObj);
           }
         dict.push(kanjiObj);
@@ -1431,16 +1501,18 @@ function convertKanjiDic(xmlString) {
   return dict;
 }
 function convertTanakaCorpus(tanakaString) {
-  var _a;
+  var _a, _b;
   const tanakaArray = [];
   const tanakaParsed = tanakaString.split("\n");
   for (let i = 0; i <= tanakaParsed.length; i += 2) {
     let a = tanakaParsed[i];
     let b = tanakaParsed[i + 1];
-    if (a && b && a.startsWith("A: ") && b.startsWith("B: ")) {
+    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);
+      const idMatch = (_b = (_a = regexps.tanakaID.exec(a)) == null ? void 0 : _a.groups["id"]) == null ? void 0 : _b.trim();
+      const idParts = String(idMatch).split("_");
+      const id = `${Number(idParts[0])}_${Number(idParts[1])}`;
       const aParts = a.replace(regexps.tanakaID, "").split("	");
       const bRawParts = b.split(" ").filter((part) => part.trim().length !== 0);
       const bParts = [];
@@ -1451,14 +1523,17 @@ function convertTanakaCorpus(tanakaString) {
         const reading = partMatches == null ? void 0 : partMatches.groups["reading"];
         const glossNumber = partMatches == null ? void 0 : partMatches.groups["glossnum"];
         const inflectedForm = partMatches == null ? void 0 : partMatches.groups["inflection"];
-        if (reading)
+        if (reading !== void 0)
           if (regexps.tanakaReferenceID.test(reading)) {
             const referenceID = regexps.tanakaReferenceID.exec(reading);
-            examplePart.referenceID = referenceID == null ? void 0 : referenceID.groups["entryid"];
+            examplePart.referenceID = `${Number(
+              referenceID == null ? void 0 : referenceID.groups["entryid"]
+            )}`;
           } else examplePart.reading = reading;
-        if (glossNumber)
+        if (glossNumber !== void 0)
           examplePart.glossNumber = glossNumber.startsWith("0") ? Number.parseInt(glossNumber.substring(1)) : Number.parseInt(glossNumber);
-        if (inflectedForm) examplePart.inflectedForm = inflectedForm;
+        if (inflectedForm !== void 0)
+          examplePart.inflectedForm = inflectedForm;
         if (baseForm.endsWith("~")) {
           examplePart.edited = true;
           examplePart.baseForm = examplePart.baseForm.replace("~", "");
@@ -1468,7 +1543,7 @@ function convertTanakaCorpus(tanakaString) {
       const phrase = aParts[0];
       const translation = aParts[1];
       tanakaArray.push({
-        id: (_a = idMatch == null ? void 0 : idMatch.groups["id"]) == null ? void 0 : _a.trim(),
+        id,
         phrase: phrase.trim(),
         translation: translation.trim(),
         parts: bParts
@@ -1478,34 +1553,26 @@ function convertTanakaCorpus(tanakaString) {
   return tanakaArray;
 }
 async function convertTanakaCorpusWithFurigana(tanakaString) {
-  return new Promise(
-    async (resolve) => {
-      let tanakaArray = convertTanakaCorpus(tanakaString);
-      const kuroshiro = new Kuroshiro.default();
-      await kuroshiro.init(new KuromojiAnalyzer());
-      const convert = kuroshiro.convert.bind(kuroshiro);
-      tanakaArray = await Promise.all(
-        tanakaArray.map(async (ex) => {
-          let furigana = void 0;
-          if (convert !== null && !ex.phrase.includes("\u30FB"))
-            furigana = await convert(ex.phrase, {
-              to: "hiragana",
-              mode: "furigana"
-            });
-          if (furigana) ex.furigana = furigana;
-          return ex;
+  const tanakaArray = convertTanakaCorpus(tanakaString);
+  const kuroshiro = new Kuroshiro.default();
+  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"
         })
       );
-      resolve(tanakaArray);
-    }
-  );
+  return tanakaArray;
 }
 function convertRadkFile(radkBuffer, kanjiDic) {
   const fileParsed = iconv.decode(radkBuffer, "euc-jp").split("\n").filter((line) => !line.startsWith("#"));
   const radicals = [];
   for (let i = 0; i < fileParsed.length; i++) {
     const line = fileParsed[i];
-    if (line && line.startsWith("$ ")) {
+    if (line !== void 0 && line.startsWith("$ ")) {
       const radical = {
         radical: line.charAt(2).trim(),
         strokes: line.substring(4).trim()
@@ -1513,7 +1580,7 @@ function convertRadkFile(radkBuffer, kanjiDic) {
       let j = i + 1;
       let kanjiLine = fileParsed[j];
       const kanjiList = [];
-      while (kanjiLine && !kanjiLine.startsWith("$ ")) {
+      while (kanjiLine !== void 0 && !kanjiLine.startsWith("$ ")) {
         const kanjis = kanjiLine.split("");
         for (const kanji of kanjis) {
           const foundKanji = kanjiDic.find(
@@ -1524,7 +1591,7 @@ function convertRadkFile(radkBuffer, kanjiDic) {
           kanjiList.push(kanjiObj);
         }
         kanjiLine = fileParsed[++j];
-        if (!kanjiLine) continue;
+        if (kanjiLine === void 0) continue;
         if (kanjiLine.startsWith("$ ")) i = j - 1;
       }
       if (kanjiList.length > 0) radical.kanji = kanjiList;
@@ -1536,7 +1603,7 @@ function convertRadkFile(radkBuffer, kanjiDic) {
 function convertKradFile(kradBuffer, kanjiDic, katakanaList) {
   const fileParsed = iconv.decode(kradBuffer, "euc-jp").split("\n").filter((line) => !line.startsWith("#"));
   const kanjiWithRadicals = [];
-  for (const line of fileParsed) {
+  for (const line of fileParsed)
     if (line.length > 0) {
       const split = line.split(" : ");
       const kanjiChar = split[0];
@@ -1551,11 +1618,11 @@ function convertKradFile(kradBuffer, kanjiDic, katakanaList) {
           (dictKanji) => dictKanji.kanji === radical
         );
         let radicalObj = foundRadical ?? { kanji: radical };
-        if (!foundRadical) {
+        if (foundRadical === void 0) {
           const katakanaChar = katakanaList.find(
             (kana) => kana.kana === radical
           );
-          if (!katakanaChar) continue;
+          if (katakanaChar === void 0) continue;
           radicalObj = {
             kanji: katakanaChar.kana,
             readingMeaning: [
@@ -1575,7 +1642,6 @@ function convertKradFile(kradBuffer, kanjiDic, katakanaList) {
       if (kanji.kanji.length === 1 && kanji.radicals.length > 0)
         kanjiWithRadicals.push(kanji);
     }
-  }
   return kanjiWithRadicals;
 }
 function createEntryMaps(jmDict, kanjiDic, tanakaExamples, wordDefinitionPairs, svgList) {
@@ -1589,42 +1655,40 @@ function createEntryMaps(jmDict, kanjiDic, tanakaExamples, wordDefinitionPairs,
   const wordPartsMap = /* @__PURE__ */ new Map();
   const partExamplesMap = /* @__PURE__ */ new Map();
   const entryParts = /* @__PURE__ */ new Set();
-  if (kanjiDic)
+  if (kanjiDic !== void 0)
     for (const kanji of kanjiDic) kanjiEntryMap.set(kanji.kanji, kanji);
-  if (wordDefinitionPairs)
+  if (wordDefinitionPairs !== void 0)
     for (const pair of wordDefinitionPairs)
       wordDefinitionsMap.set(pair.wordID, pair.definitions);
-  if (kanjiDic && svgList)
+  if (kanjiDic !== void 0 && svgList !== void 0)
     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 (svg !== void 0) kanjiSVGMap.set(kanji.kanji, svg);
     }
-  if (jmDict) {
+  if (jmDict !== void 0) {
     for (const word of jmDict) {
       wordIDEntryMap.set(word.id, word);
-      if (word.kanjiForms)
+      if (word.kanjiForms !== void 0)
         for (const kf of word.kanjiForms)
-          for (const char of kf.form.split("").filter((c) => regexps.kanji.test(c))) {
+          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) {
+      if (tanakaExamples !== void 0) {
         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 reading of rkf.readings) {
+          entryParts.add(reading.reading);
+          localPartParts.add(reading.reading);
+        }
+        if (rkf.kanjiForms !== void 0 && rkf.kanjiForms.length > 0)
           for (const kanjiForm of rkf.kanjiForms) {
             entryParts.add(kanjiForm.form);
             localPartParts.add(kanjiForm.form);
@@ -1634,58 +1698,56 @@ function createEntryMaps(jmDict, kanjiDic, tanakaExamples, wordDefinitionPairs,
         wordPartsMap.set(word.id, localPartParts);
       }
     }
-    if (tanakaExamples) {
-      for (const ex of tanakaExamples) {
+    if (tanakaExamples !== void 0) {
+      for (const ex of tanakaExamples)
         for (const part of ex.parts) {
           if (entryParts.has(part.baseForm)) {
             let exList = partExamplesMap.get(
               part.baseForm
             );
-            if (!exList) {
+            if (exList === void 0) {
               exList = [];
               partExamplesMap.set(part.baseForm, exList);
             }
             exList.push(ex);
           }
-          if (part.reading && entryParts.has(part.reading)) {
+          if (part.reading !== void 0 && entryParts.has(part.reading)) {
             let exList = partExamplesMap.get(
               part.reading
             );
-            if (!exList) {
+            if (exList === void 0) {
               exList = [];
               partExamplesMap.set(part.reading, exList);
             }
             exList.push(ex);
           }
-          if (part.inflectedForm && entryParts.has(part.inflectedForm)) {
+          if (part.inflectedForm !== void 0 && entryParts.has(part.inflectedForm)) {
             let exList = partExamplesMap.get(
               part.inflectedForm
             );
-            if (!exList) {
+            if (exList === void 0) {
               exList = [];
               partExamplesMap.set(part.inflectedForm, exList);
             }
             exList.push(ex);
           }
-          if (part.referenceID && entryParts.has(part.referenceID)) {
+          if (part.referenceID !== void 0 && entryParts.has(part.referenceID)) {
             let exList = partExamplesMap.get(
               part.referenceID
             );
-            if (!exList) {
+            if (exList === void 0) {
               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) {
+        for (const p of wordPartsMap.get(word.id)) {
           const examplesForPart = (_a = partExamplesMap.get(p)) == null ? void 0 : _a.filter((ex) => !seenEx.has(ex.id));
-          if (!examplesForPart) continue;
+          if (examplesForPart === void 0) continue;
           for (const ex of examplesForPart) {
             seenEx.add(ex.id);
             validExamples.push(ex);
@@ -1710,49 +1772,44 @@ function mapEntry(entry) {
     word: entry.word,
     pos_title: entry.pos_title,
     senses: entry.senses.filter(
-      (sense) => isObjectArray(sense.form_of) && sense.form_of.every(
-        (form) => form.word && typeof form.word === "string"
-      ) || isStringArray(sense.glosses)
+      (sense) => (isObjectArray(sense.form_of) ? sense.form_of.every((form) => typeof form.word === "string") : isStringArray(sense.glosses)) === true || isStringArray(sense.glosses)
     ).map((sense) => ({
-      ...sense.form_of ? {
-        form_of: sense.form_of.map((form) => form.word)
+      ...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") ? { forms: entry.forms.map((form) => form.form) } : {}
+    ...isObjectArray(entry.forms) && entry.forms.every((form) => typeof form.form === "string") === true ? { forms: entry.forms.map((form) => String(form.form)) } : {}
   };
 }
 function convertJawiktionarySync(buffer) {
+  var _a;
   const lines = buffer.toString("utf-8").split("\n");
   const entries = [];
   for (let i = 0; i < lines.length; i++) {
-    const line = lines[i];
-    if (!line) continue;
+    const line = (_a = lines[i]) == null ? void 0 : _a.trim();
+    if (line === void 0 || line.length === 0) continue;
     const obj = JSON.parse(line);
-    if (obj && typeof obj === "object" && typeof obj.lang === "string" && (obj.lang === "\u65E5\u672C\u8A9E" || obj.lang === "\u53E4\u5178\u65E5\u672C\u8A9E"))
+    if (typeof obj === "object" && (obj.lang === "\u65E5\u672C\u8A9E" || obj.lang === "\u53E4\u5178\u65E5\u672C\u8A9E"))
       entries.push(mapEntry(obj));
   }
   return entries;
 }
 async function convertJawiktionaryAsync(stream) {
-  return new Promise(
-    async (resolve) => {
-      const rl = createInterface({
-        input: stream,
-        crlfDelay: Infinity
-      });
-      const entries = [];
-      for await (const line of rl) {
-        const obj = JSON.parse(line.trim());
-        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();
-      stream.close();
-      stream.destroy();
-      resolve(entries);
-    }
-  );
+  const rl = createInterface({
+    input: stream,
+    crlfDelay: Infinity
+  });
+  const entries = [];
+  for await (const line of rl) {
+    const obj = JSON.parse(line.trim());
+    if (typeof obj === "object" && (obj.lang === "\u65E5\u672C\u8A9E" || obj.lang === "\u53E4\u5178\u65E5\u672C\u8A9E"))
+      entries.push(mapEntry(obj));
+  }
+  rl.close();
+  stream.close();
+  stream.destroy();
+  return entries;
 }
 function parseEntry(entry, definitions, definitionMap) {
   for (const sense of entry.senses) {
@@ -1765,12 +1822,12 @@ function parseEntry(entry, definitions, definitionMap) {
     }
   }
 }
-function getWordDefinitions(entryList, jmDict) {
+function getWordDefinitions(wiktionaryEntries, jmDict) {
   var _a, _b, _c, _d, _e;
   const entries = /* @__PURE__ */ new Map();
-  for (const entry of entryList) {
+  for (const entry of wiktionaryEntries) {
     const ent = entries.get(entry.word);
-    if (ent) ent.push(entry);
+    if (ent !== void 0) ent.push(entry);
     else entries.set(entry.word, [entry]);
   }
   const japaneseDefinitions = [];
@@ -1784,16 +1841,14 @@ function getWordDefinitions(entryList, jmDict) {
     const wordKanjiForms = /* @__PURE__ */ new Set();
     const rkf = getValidForms(
       word.readings,
-      word.kanjiForms,
-      word.isCommon
+      word.kanjiForms
     );
-    if (rkf.readings.length > 0)
-      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 r of rkf.readings) {
+      validReadings.add(r.reading);
+      wordReadings.add(r.reading);
+      validForms.add(r.reading);
+    }
+    if (rkf.kanjiForms !== void 0 && rkf.kanjiForms.length > 0)
       for (const kf of rkf.kanjiForms) {
         validKanjiForms.add(kf.form);
         wordKanjiForms.add(kf.form);
@@ -1813,44 +1868,42 @@ function getWordDefinitions(entryList, jmDict) {
   const ents = Array.from(entries.values()).flat();
   for (const entry of ents) {
     let valid = false;
-    if (validKanjiForms && validKanjiForms.has(entry.word)) {
+    if (validKanjiForms.has(entry.word)) {
       valid = true;
       for (const sense of entry.senses) {
-        if (sense.form_of && sense.form_of.some((form) => validReadings.has(form)))
+        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;
-          if (gloss.includes("\u8868\u8A18") || gloss.includes("\u53C2\u7167")) {
-            for (const r of validForms)
-              if (gloss.includes(r)) {
-                hasForm = true;
-                break;
-              }
-          }
+          for (const r of validForms)
+            if (gloss.includes(r)) {
+              hasForm = true;
+              break;
+            }
           if (hasForm) validGlossesEntries.add(entry.word);
         }
       }
-      if (entry.forms) {
+      if (entry.forms !== void 0) {
         for (const form of entry.forms)
-          if (validReadings.has(form)) validFormsEntries.add(entry.word);
+          if (validForms.has(form)) validFormsEntries.add(entry.word);
       }
     }
-    if (validReadings.has(entry.word)) {
+    if (validForms.has(entry.word)) {
       valid = true;
       const ftEntry = entriesWithFormTitlesGlobal.get(entry.word);
-      if (ftEntry) ftEntry.push(entry);
+      if (ftEntry !== void 0) ftEntry.push(entry);
       else entriesWithFormTitlesGlobal.set(entry.word, [entry]);
     }
     if (valid) {
-      const tEntry = validTitleEntries.get(entry.word);
-      if (tEntry) tEntry.push(entry);
+      const tEntry = validTitleEntries.get(
+        entry.word
+      );
+      if (tEntry !== void 0) tEntry.push(entry);
       else validTitleEntries.set(entry.word, [entry]);
     }
-    if (entry.forms && (validKanjiForms.has(entry.word) || validReadings.has(entry.word)) && entry.forms.some(
-      (form) => validKanjiForms.has(form) || validReadings.has(form)
-    )) {
+    if (entry.forms !== void 0 && validForms.has(entry.word) && entry.forms.some((form) => validForms.has(form))) {
       const wfEntry = entriesWithFormsGlobal.get(entry.word);
-      if (wfEntry) wfEntry.push(entry);
+      if (wfEntry !== void 0) wfEntry.push(entry);
       else entriesWithFormsGlobal.set(entry.word, [entry]);
     }
   }
@@ -1865,53 +1918,17 @@ function getWordDefinitions(entryList, jmDict) {
   const wfe = Array.from(
     entriesWithFormsGlobal.values()
   ).flat();
-  for (const pos of [
-    "\u540D\u8A5E",
-    "\u52D5\u8A5E",
-    "\u6210\u53E5",
-    "\u526F\u8A5E",
-    "\u5F62\u5BB9\u52D5\u8A5E",
-    "\u52A9\u8A5E",
-    "\u611F\u52D5\u8A5E",
-    "\u4EE3\u540D\u8A5E",
-    "\u63A5\u5C3E\u8F9E",
-    "\u63A5\u982D\u8A9E",
-    "\u9020\u8A9E\u6210\u5206",
-    "\u7565\u8A9E",
-    "\u56FA\u6709\u540D\u8A5E",
-    "\u4EBA\u79F0\u4EE3\u540D\u8A5E",
-    "\u63A5\u982D\u8F9E",
-    "\u63A5\u7D9A\u52A9\u8A5E",
-    "\u9593\u6295\u8A5E",
-    "\u52A9\u52D5\u8A5E",
-    "\u5F62\u5BB9\u8A5E",
-    "\u7E2E\u7D04\u5F62",
-    "\u63A5\u8F9E",
-    "\u63A5\u7D9A\u8A5E",
-    "\u9023\u4F53\u8A5E",
-    "\u4EBA\u540D",
-    "\u8A18\u53F7",
-    "\u6570\u8A5E",
-    "\u6163\u7528\u53E5",
-    "\u3053\u3068\u308F\u3056",
-    "\u52A9\u6570\u8A5E",
-    "\u82F1\u6570\u5B57\u6DF7\u5408\u8868\u8A18",
-    "\u52D5\u8A5E\u53E5",
-    "\u6210\u8A9E",
-    "\u610F\u7FA9",
-    "\u982D\u5B57\u8A9E",
-    "\u63A5\u5C3E\u8A9E"
-  ]) {
+  for (const pos of posList) {
     posMap.set(pos, {});
     for (const te of vte)
       if (te.pos_title === pos || te.pos_title === "\u548C\u8A9E\u306E\u6F22\u5B57\u8868\u8A18") {
         const posEntries = posMap.get(pos);
         if (posEntries.title === void 0)
           posEntries.title = /* @__PURE__ */ new Map();
-        const entryList2 = posEntries.title.get(
+        const entryList = posEntries.title.get(
           te.word
         );
-        if (entryList2) entryList2.push(te);
+        if (entryList !== void 0) entryList.push(te);
         else posEntries.title.set(te.word, [te]);
       }
     for (const ft of fge)
@@ -1919,8 +1936,8 @@ function getWordDefinitions(entryList, jmDict) {
         const posEntries = posMap.get(pos);
         if (posEntries.formTitle === void 0)
           posEntries.formTitle = /* @__PURE__ */ new Map();
-        const entryList2 = posEntries.formTitle.get(ft.word);
-        if (entryList2) entryList2.push(ft);
+        const entryList = posEntries.formTitle.get(ft.word);
+        if (entryList !== void 0) entryList.push(ft);
         else posEntries.formTitle.set(ft.word, [ft]);
       }
     for (const wf of wfe)
@@ -1928,10 +1945,10 @@ function getWordDefinitions(entryList, jmDict) {
         const posEntries = posMap.get(pos);
         if (posEntries.form === void 0)
           posEntries.form = /* @__PURE__ */ new Map();
-        const entryList2 = posEntries.form.get(
+        const entryList = posEntries.form.get(
           wf.word
         );
-        if (entryList2) entryList2.push(wf);
+        if (entryList !== void 0) entryList.push(wf);
         else posEntries.form.set(wf.word, [wf]);
       }
   }
@@ -1944,7 +1961,7 @@ function getWordDefinitions(entryList, jmDict) {
     for (const m of word.meanings)
       for (const note of m.partOfSpeech) {
         const noteEntry = noteMap.get(note);
-        if (noteEntry && noteEntry.length === 3) {
+        if ((noteEntry == null ? void 0 : noteEntry.length) === 3) {
           const notePos = noteEntry[2];
           if (Array.isArray(notePos))
             for (const pos of notePos) {
@@ -1961,21 +1978,21 @@ function getWordDefinitions(entryList, jmDict) {
     if (poses.size > 0)
       for (const pos of poses) {
         const posEntries = posMap.get(pos);
-        if (rkf.kanjiForms)
+        if (rkf.kanjiForms !== void 0)
           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)
+            if (te !== void 0)
               entriesWithTitles.push(
                 ...te.filter(
                   (ent) => validFormOfEntries.has(ent.word) || validGlossesEntries.has(ent.word) || validFormsEntries.has(ent.word)
                 )
               );
-            if (fe)
+            if (fe !== void 0)
               entriesWithForms.push(
                 ...fe.filter(
-                  (ent) => ent.forms && ent.forms.some(
-                    (form) => rkf.kanjiForms.has(form) || rkf.readings.has(form)
+                  (ent) => ent.forms !== void 0 && ent.forms.some(
+                    (form) => rkf.kanjiForms !== void 0 && rkf.kanjiForms.has(form) || rkf.readings.has(form)
                   )
                 )
               );
@@ -1984,41 +2001,41 @@ function getWordDefinitions(entryList, jmDict) {
           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)
+          if (te !== void 0)
             entriesWithTitles.push(
               ...te.filter(
-                (ent) => ent.forms && rkf.kanjiForms && ent.forms.some(
-                  (form) => rkf.kanjiForms.has(form)
-                ) || rkf.kanjiForms === void 0
+                (ent) => ent.forms !== void 0 && ent.forms.some(
+                  (form) => rkf.kanjiForms !== void 0 && rkf.kanjiForms.has(form) || rkf.readings.has(form)
+                )
               )
             );
-          if (fe)
+          if (fe !== void 0)
             entriesWithForms.push(
               ...fe.filter(
-                (ent) => ent.forms && ent.forms.some(
-                  (form) => rkf.kanjiForms && rkf.kanjiForms.has(form) || rkf.readings.has(form)
+                (ent) => ent.forms !== void 0 && ent.forms.some(
+                  (form) => rkf.kanjiForms !== void 0 && rkf.kanjiForms.has(form) || rkf.readings.has(form)
                 )
               )
             );
-          if (fte) entriesWithFormTitles.push(...fte);
+          if (fte !== void 0) entriesWithFormTitles.push(...fte);
         }
       }
     if (entriesWithTitles.length === 0 && entriesWithFormTitles.length === 0 && entriesWithForms.length === 0) {
-      if (rkf.kanjiForms)
+      if (rkf.kanjiForms !== void 0)
         for (const kf of rkf.kanjiForms) {
           const te = validTitleEntries.get(kf);
           const fe = entriesWithFormsGlobal.get(kf);
-          if (te)
+          if (te !== void 0)
             entriesWithTitles.push(
               ...te.filter(
                 (ent) => validFormOfEntries.has(ent.word) || validGlossesEntries.has(ent.word) || validFormsEntries.has(ent.word)
               )
             );
-          if (fe)
+          if (fe !== void 0)
             entriesWithForms.push(
               ...fe.filter(
-                (ent) => ent.forms && ent.forms.some(
-                  (form) => rkf.kanjiForms.has(form) || rkf.readings.has(form)
+                (ent) => ent.forms !== void 0 && ent.forms.some(
+                  (form) => rkf.kanjiForms !== void 0 && rkf.kanjiForms.has(form) || rkf.readings.has(form)
                 )
               )
             );
@@ -2027,31 +2044,31 @@ function getWordDefinitions(entryList, jmDict) {
         const te = validTitleEntries.get(r);
         const fe = entriesWithFormsGlobal.get(r);
         const fte = entriesWithFormTitlesGlobal.get(r);
-        if (te)
+        if (te !== void 0)
           entriesWithTitles.push(
             ...te.filter(
-              (ent) => ent.forms && rkf.kanjiForms && ent.forms.some(
-                (form) => rkf.kanjiForms.has(form)
-              ) || rkf.kanjiForms === void 0
+              (ent) => ent.forms !== void 0 && ent.forms.some(
+                (form) => rkf.kanjiForms !== void 0 && rkf.kanjiForms.has(form) || rkf.readings.has(form)
+              )
             )
           );
-        if (fe)
+        if (fe !== void 0)
           entriesWithForms.push(
             ...fe.filter(
-              (ent) => ent.forms && ent.forms.some(
-                (form) => rkf.kanjiForms && rkf.kanjiForms.has(form) || rkf.readings.has(form)
+              (ent) => ent.forms !== void 0 && ent.forms.some(
+                (form) => rkf.kanjiForms !== void 0 && rkf.kanjiForms.has(form) || rkf.readings.has(form)
               )
             )
           );
-        if (fte) entriesWithFormTitles.push(...fte);
+        if (fte !== void 0) entriesWithFormTitles.push(...fte);
       }
     }
     if (entriesWithTitles.length > 0 && (entriesWithFormTitles.length > 0 || entriesWithForms.length > 0))
       wordEntriesPairs.push({
         word,
         readings: rkf.readings,
-        ...rkf.kanjiForms ? { kanjiForms: rkf.kanjiForms } : {},
-        forms: rkf.kanjiForms ? rkf.readings.union(rkf.kanjiForms) : rkf.readings,
+        ...rkf.kanjiForms !== void 0 ? { kanjiForms: rkf.kanjiForms } : {},
+        forms: rkf.kanjiForms !== void 0 ? rkf.readings.union(rkf.kanjiForms) : rkf.readings,
         entriesWithTitles,
         entriesWithFormTitles,
         entriesWithForms
@@ -2064,59 +2081,54 @@ function getWordDefinitions(entryList, jmDict) {
     const readingEntries = [];
     const titleFormMap = /* @__PURE__ */ new Map();
     const refsMap = /* @__PURE__ */ new Map();
-    const readingForms = /* @__PURE__ */ new Set();
+    const forms = /* @__PURE__ */ new Set();
     for (const ent of pair.entriesWithTitles) {
-      const validFormOf = validFormOfEntries.has(ent.word);
-      const validGlosses = validGlossesEntries.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 || validForms2)) {
+      const hasValidFormOf = validFormOfEntries.has(ent.word);
+      const hasValidForms = validFormsEntries.has(ent.word);
+      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);
-        if ((validFormOf || validGlosses) && ent.senses)
-          for (const sense of ent.senses) {
-            if (validFormOf && sense.form_of) {
-              for (const form of sense.form_of)
-                if (pair.readings.has(form)) {
-                  const elem = titleFormMap.get(form);
-                  if (!elem)
-                    titleFormMap.set(form, /* @__PURE__ */ new Set([ent.word]));
-                  else elem.add(ent.word);
-                }
-            }
-            if (validGlosses) {
-              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);
-                    }
-                }
-            }
+        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 (validForms2 && ent.forms) {
+          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.readings.has(form)) readingForms.add(form);
+            if (pair.forms.has(form)) forms.add(form);
         }
       }
-      if (pair.readings.has(ent.word) && hasKanjiForms)
-        entriesWithForms.push(ent);
+      if (pair.readings.has(ent.word) && hasForms) 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)))
+      if (elem !== void 0 && entry.forms !== void 0 && entry.forms.some((form) => elem.has(form)))
         entriesWithForms.push(entry);
     }
     for (const entry of pair.entriesWithFormTitles) {
-      if (readingForms.has(entry.word)) {
+      if (forms.has(entry.word)) {
         entriesWithForms.push(entry);
         continue;
       }
       const ft = refsMap.get(entry.word);
-      if (ft && !ft.isDisjointFrom(pair.forms)) entriesWithForms.push(entry);
+      if (ft !== void 0 && !ft.isDisjointFrom(pair.forms))
+        entriesWithForms.push(entry);
     }
     if (kanjiFormEntries.length > 0) {
       for (const entry of kanjiFormEntries)
@@ -2132,7 +2144,15 @@ function getWordDefinitions(entryList, jmDict) {
     if (definitions.length > 0)
       japaneseDefinitions.push({
         wordID: pair.word.id,
-        definitions
+        definitions,
+        wordForms: pair.forms.union(
+          new Set(
+            pair.forms.values().toArray().flatMap((form) => [
+              hiraganaToKatakana(form),
+              katakanaToHiragana(form)
+            ])
+          )
+        )
       });
   }
   for (let i = 0; i < japaneseDefinitions.length; i++) {
@@ -2141,41 +2161,46 @@ function getWordDefinitions(entryList, jmDict) {
       const defCount = definitionMap.get(
         pair.definitions[j].definition
       );
-      if (defCount && defCount.count > 1)
-        pair.definitions[j].mayNotBeAccurate = true;
+      if (defCount !== void 0 && defCount.count > 1) {
+        let mnba = true;
+        for (const f of pair.wordForms)
+          if (pair.definitions[j].definition.includes(f)) {
+            mnba = false;
+            break;
+          }
+        pair.definitions[j].mayNotBeAccurate = mnba ? 2 : 1;
+      }
     }
+    delete pair.wordForms;
     japaneseDefinitions[i] = pair;
   }
   return japaneseDefinitions;
 }
 async function getWordDefinitionsWithFurigana(entryList, jmDict) {
-  return new Promise(async (resolve) => {
-    const japaneseDefinitions = getWordDefinitions(
-      entryList,
-      jmDict
-    );
-    const kuroshiro = new Kuroshiro.default();
-    await kuroshiro.init(new KuromojiAnalyzer());
-    const convert = kuroshiro.convert.bind(kuroshiro);
-    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 = await convert(
-            pair.definitions[j].definition,
-            {
-              to: "hiragana",
-              mode: "furigana"
-            }
-          );
-      japaneseDefinitions[i] = pair;
-    }
-    resolve(japaneseDefinitions);
-  });
+  const japaneseDefinitions = getWordDefinitions(
+    entryList,
+    jmDict
+  );
+  const kuroshiro = new Kuroshiro.default();
+  await kuroshiro.init(new KuromojiAnalyzer());
+  const convert = kuroshiro.convert.bind(kuroshiro);
+  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"
+          })
+        );
+    japaneseDefinitions[i] = pair;
+  }
+  return japaneseDefinitions;
 }
 function lookupWordNote(key, notes, tags) {
   const info = noteMap.get(key.toLowerCase());
-  if (!info) {
+  if (info === void 0) {
     notes.push(key);
     return { note: key };
   }
@@ -2185,22 +2210,172 @@ function lookupWordNote(key, notes, tags) {
   return { note: info[1], tag };
 }
 var wordAddNoteArray = (arr, cb) => {
-  if (!arr) return;
+  if (arr === void 0) return;
   for (const v of arr) cb(v);
 };
-function getWord(word, dict, kanjiDic, examples, definitions, noteTypeName, deckPath) {
+function getKanji(searchedKanji, dict, jmDict, svgList, noteTypeName, deckPath) {
+  var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j;
+  let dictKanji = void 0;
+  if (typeof searchedKanji === "string" && dict !== void 0)
+    dictKanji = dict instanceof Map ? dict.get(searchedKanji) : dict.find((entry) => entry.kanji === searchedKanji);
+  else if (typeof searchedKanji === "object") dictKanji = searchedKanji;
+  if (dictKanji !== void 0) {
+    const kanji = {
+      kanji: dictKanji.kanji,
+      strokes: dictKanji.misc.strokeNumber,
+      ...((_a = dictKanji.misc) == null ? void 0 : _a.grade) !== void 0 ? { grade: dictKanji.misc.grade } : {},
+      ...((_b = dictKanji.misc) == null ? void 0 : _b.frequency) !== void 0 ? { frequency: dictKanji.misc.frequency } : {},
+      ...((_c = dictKanji.misc) == null ? void 0 : _c.jlpt) !== void 0 ? { jlpt: dictKanji.misc.jlpt } : {},
+      noteID: `kanji_${dictKanji.kanji}`,
+      ...noteTypeName !== void 0 ? { noteTypeName } : {},
+      ...deckPath !== void 0 ? { deckPath } : {},
+      tags: []
+    };
+    if (dictKanji.readingMeaning !== void 0 && dictKanji.readingMeaning.length > 0) {
+      const meanings = [];
+      const nanori = [];
+      const onyomi = [];
+      const kunyomi = [];
+      for (const rm of dictKanji.readingMeaning) {
+        if (rm.nanori !== void 0 && rm.nanori.length > 0)
+          nanori.push(...rm.nanori);
+        for (const group of rm.groups) {
+          if (group.readings !== void 0) {
+            onyomi.push(
+              ...group.readings.filter((reading) => reading.type === "ja_on").map((reading) => reading.reading)
+            );
+            kunyomi.push(
+              ...group.readings.filter(
+                (reading) => reading.type === "ja_kun"
+              ).map((reading) => reading.reading)
+            );
+          }
+          if (group.meanings !== void 0 && group.meanings.length > 0)
+            meanings.push(...group.meanings);
+        }
+      }
+      if (meanings.length > 0) kanji.meanings = meanings;
+      if (nanori.length > 0) kanji.nanori = nanori;
+      if (onyomi.length > 0) kanji.onyomi = onyomi;
+      if (kunyomi.length > 0) kanji.kunyomi = kunyomi;
+    }
+    if (jmDict !== void 0) {
+      let kanjiWords = jmDict instanceof Map ? jmDict.get(kanji.kanji) : jmDict;
+      const firstKfWords = kanjiWords == null ? void 0 : kanjiWords.filter(
+        (word) => word.kanjiForms !== void 0 && word.kanjiForms[0].form.includes(kanji.kanji)
+      );
+      if (firstKfWords !== void 0 && firstKfWords.length > 0)
+        kanjiWords = firstKfWords;
+      if (kanjiWords !== void 0) {
+        const validWords = [];
+        for (const word of kanjiWords) {
+          const kanjiForm = (_d = firstKfWords !== void 0 && firstKfWords.length > 0 ? word.kanjiForms[0] : word.kanjiForms.find(
+            (kf) => kf.form.includes(kanji.kanji)
+          )) == null ? void 0 : _d.form;
+          if (kanjiForm !== void 0) {
+            const reading = (_e = firstKfWords !== void 0 && firstKfWords.length > 0 ? word.readings[0] : word.readings.find(
+              (r) => r.kanjiFormRestrictions !== void 0 && r.kanjiFormRestrictions.includes(kanjiForm)
+            )) == null ? void 0 : _e.reading;
+            if (reading === void 0) continue;
+            const translation = (_f = firstKfWords !== void 0 && firstKfWords.length > 0 ? word.meanings[0] : word.meanings.find(
+              (m) => m.kanjiFormRestrictions !== void 0 && m.kanjiFormRestrictions.includes(kanjiForm)
+            )) == null ? void 0 : _f.translations.map(
+              (t) => typeof t === "string" ? t : t.translation
+            )[0];
+            if (translation === void 0) continue;
+            validWords.push({
+              kanjiForms: [{ kanjiForm }],
+              readings: [{ reading }],
+              translations: [
+                {
+                  translation
+                }
+              ]
+            });
+          }
+          if (validWords.length === 3) break;
+        }
+        if (validWords.length > 0) kanji.words = validWords;
+      }
+    }
+    if (svgList !== void 0) {
+      const codePoint = kanji.kanji.codePointAt(0).toString(16).toLowerCase();
+      const svg = svgList instanceof Map ? svgList.get(kanji.kanji) : svgList.find(
+        (svgFile) => [`${codePoint}.svg`, `0${codePoint}.svg`].includes(
+          svgFile.toLowerCase()
+        )
+      );
+      if (svg !== void 0) kanji.svg = svg;
+    }
+    if (dictKanji.isKokuji === true) {
+      kanji.kokuji = true;
+      kanji.tags.push("kanji::kokuji");
+    }
+    kanji.tags.push(
+      `kanji::strokes::${kanji.strokes}`,
+      ...kanji.frequency !== void 0 ? [`kanji::frequency::${kanji.frequency}`] : [],
+      ...kanji.grade !== void 0 ? [`kanji::grade::${kanji.grade}`] : [],
+      ...kanji.jlpt !== void 0 ? [`kanji::pre-2010_jlpt::${kanji.jlpt.toLowerCase()}`] : [],
+      `kanji::onyomi::${((_g = kanji.onyomi) == null ? void 0 : _g.length) ?? 0}`,
+      `kanji::kunyomi::${((_h = kanji.kunyomi) == null ? void 0 : _h.length) ?? 0}`,
+      `kanji::nanori::${((_i = kanji.nanori) == null ? void 0 : _i.length) ?? 0}`,
+      `kanji::words::${((_j = kanji.words) == null ? void 0 : _j.length) ?? 0}`,
+      ...kanji.svg !== void 0 ? ["kanji::has_svg"] : []
+    );
+    return kanji;
+  } else return void 0;
+}
+function getKanjiExtended(info, kanji, dict, useWords, jmDict, svgList, noteTypeName, deckPath, sourceURL) {
+  const kanjiObj = getKanji(
+    kanji,
+    dict,
+    jmDict,
+    svgList,
+    noteTypeName,
+    deckPath
+  );
+  if (kanjiObj !== void 0) {
+    let usedInfo = false;
+    if (info.components !== void 0) {
+      kanjiObj.components = info.components;
+      kanjiObj.tags.push(`kanji::components::${kanjiObj.components.length}`);
+      usedInfo = true;
+    }
+    if (info.mnemonic !== void 0 && info.mnemonic.length > 0) {
+      kanjiObj.mnemonic = info.mnemonic;
+      kanjiObj.tags.push("kanji::has_mnemonic");
+      usedInfo = true;
+    }
+    if (useWords === true && info.words !== void 0 && info.words.length > 0) {
+      kanjiObj.words = info.words;
+      kanjiObj.tags.forEach((tag, index) => {
+        if (tag.startsWith("kanji::words::") && kanjiObj.words !== void 0)
+          kanjiObj.tags.splice(
+            index,
+            1,
+            `kanji::words::${kanjiObj.words.length}`
+          );
+      });
+      usedInfo = true;
+    }
+    if (sourceURL !== void 0 && info.externalInfo === true && usedInfo)
+      kanjiObj.source = sourceURL;
+    return kanjiObj;
+  } else return void 0;
+}
+function getWord(searchedWord, dict, kanjiDic, examples, definitions, noteTypeName, deckPath) {
   var _a;
   let dictWord = void 0;
-  if (typeof word === "string" && dict) {
+  if (typeof searchedWord === "string" && dict !== void 0) {
     if (Array.isArray(dict))
       dictWord = dict.find(
-        (entry) => entry.id === word
+        (entry) => entry.id === searchedWord
       );
-    if (dict instanceof Map) dictWord = dict.get(word);
+    if (dict instanceof Map) dictWord = dict.get(searchedWord);
   }
-  if (typeof word === "object") dictWord = word;
-  if (dictWord) {
-    const word2 = {
+  if (typeof searchedWord === "object") dictWord = searchedWord;
+  if (dictWord !== void 0) {
+    const word = {
       id: dictWord.id,
       readings: [],
       translations: [],
@@ -2210,46 +2385,46 @@ function getWord(word, dict, kanjiDic, examples, definitions, noteTypeName, deck
       tags: []
     };
     if (dictWord.isCommon === true) {
-      word2.common = true;
-      word2.tags.push("word::common");
+      word.common = true;
+      word.tags.push("word::common");
     }
-    if (dictWord.kanjiForms)
-      word2.kanjiForms = dictWord.kanjiForms.map(
+    if (dictWord.kanjiForms !== void 0)
+      word.kanjiForms = dictWord.kanjiForms.map(
         (dictKanjiForm) => ({
           kanjiForm: dictKanjiForm.form,
-          ...dictKanjiForm.notes ? {
+          ...dictKanjiForm.notes !== void 0 ? {
             notes: dictKanjiForm.notes.map((note) => {
               const noteAndTag = lookupWordNote(
                 note,
                 [],
-                word2.tags
+                word.tags
               );
               return capitalizeString(noteAndTag.note);
             })
           } : {},
-          ...dictKanjiForm.commonness && dictKanjiForm.commonness.length > 0 ? { common: true } : {}
+          ...dictKanjiForm.commonness !== void 0 && dictKanjiForm.commonness.length > 0 ? { common: true } : {}
         })
       );
-    word2.readings = dictWord.readings.map((dictReading) => ({
+    word.readings = dictWord.readings.map((dictReading) => ({
       reading: dictReading.reading,
-      ...dictReading.kanjiFormRestrictions || dictReading.notes ? {
+      ...dictReading.kanjiFormRestrictions !== void 0 || dictReading.notes !== void 0 ? {
         notes: [
-          ...dictReading.kanjiFormRestrictions ? dictReading.kanjiFormRestrictions.map(
+          ...dictReading.kanjiFormRestrictions !== void 0 ? dictReading.kanjiFormRestrictions.map(
             (restriction) => `Reading restricted to ${restriction}`
           ) : [],
-          ...dictReading.notes ? dictReading.notes.map((note) => {
+          ...dictReading.notes !== void 0 ? dictReading.notes.map((note) => {
             const noteAndTag = lookupWordNote(
               note,
               [],
-              word2.tags
+              word.tags
             );
             return capitalizeString(noteAndTag.note);
           }) : []
         ]
       } : {},
-      ...dictReading.commonness && dictReading.commonness.length > 0 ? { common: true } : {}
+      ...dictReading.commonness !== void 0 && dictReading.commonness.length > 0 ? { common: true } : {}
     }));
-    word2.translations = [];
+    word.translations = [];
     for (const dictMeaning of dictWord.meanings) {
       const translationTypes = [];
       const translations = dictMeaning.translations.map(
@@ -2260,7 +2435,7 @@ function getWord(word, dict, kanjiDic, examples, definitions, noteTypeName, deck
               translation.type
             );
             translationTypes.push(translationNoteAndTag[1]);
-            word2.tags.push(`word::${translationNoteAndTag[0]}`);
+            word.tags.push(`word::${translationNoteAndTag[0]}`);
             return translation.translation;
           }
         }
@@ -2277,15 +2452,15 @@ function getWord(word, dict, kanjiDic, examples, definitions, noteTypeName, deck
       for (const t of translationTypes) notes.push(t);
       wordAddNoteArray(
         dictMeaning.partOfSpeech,
-        (pos) => lookupWordNote(pos, notes, word2.tags)
+        (pos) => lookupWordNote(pos, notes, word.tags)
       );
       wordAddNoteArray(
         dictMeaning.fields,
-        (field) => lookupWordNote(field, notes, word2.tags)
+        (field) => lookupWordNote(field, notes, word.tags)
       );
       wordAddNoteArray(
         dictMeaning.dialects,
-        (dialect) => lookupWordNote(dialect, notes, word2.tags)
+        (dialect) => lookupWordNote(dialect, notes, word.tags)
       );
       wordAddNoteArray(
         dictMeaning.antonyms,
@@ -2297,45 +2472,45 @@ function getWord(word, dict, kanjiDic, examples, definitions, noteTypeName, deck
       );
       wordAddNoteArray(
         dictMeaning.info,
-        (info) => lookupWordNote(info, notes, word2.tags)
+        (info) => lookupWordNote(info, notes, word.tags)
       );
       wordAddNoteArray(
         dictMeaning.misc,
-        (misc) => lookupWordNote(misc, notes, word2.tags)
+        (misc) => lookupWordNote(misc, notes, word.tags)
       );
       for (let i = 0; i < notes.length; i++)
         notes[i] = capitalizeString(notes[i]);
-      word2.translations.push({
+      word.translations.push({
         translation: translations.join("; "),
         notes
       });
     }
     if (dictWord.usuallyInKana === true) {
-      word2.usuallyInKana = true;
-      word2.tags.push("word::usually_in_kana_for_all_senses");
+      word.usuallyInKana = true;
+      word.tags.push("word::usually_in_kana_for_all_senses");
     }
-    if (kanjiDic && word2.kanjiForms) {
+    if (kanjiDic !== void 0 && word.kanjiForms !== void 0) {
       const kanji = [];
       const seenChars = /* @__PURE__ */ new Set();
-      for (const kanjiForm of word2.kanjiForms)
+      for (const kanjiForm of word.kanjiForms)
         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(
             kanjiEntry ?? char,
-            Array.isArray(kanjiDic) ? kanjiDic : void 0
+            !(kanjiDic instanceof Map) ? kanjiDic : void 0
           );
-          if (kanjiObj)
+          if (kanjiObj !== void 0)
             kanji.push({
               kanji: kanjiObj.kanji,
-              ...kanjiObj.meanings && kanjiObj.meanings.length > 0 ? { meanings: kanjiObj.meanings } : {}
+              ...kanjiObj.meanings !== void 0 && kanjiObj.meanings.length > 0 ? { meanings: kanjiObj.meanings } : {}
             });
         }
-      if (kanji.length > 0) word2.kanji = kanji;
+      if (kanji.length > 0) word.kanji = kanji;
     }
-    if (dictWord.hasPhrases !== void 0 && examples) {
-      const exampleList = Array.isArray(examples) ? examples : examples.get(dictWord.id) ?? [];
+    if (dictWord.hasPhrases === true && examples !== void 0) {
+      const exampleList = examples instanceof Map ? examples.get(dictWord.id) ?? [] : examples;
       const rkf = getValidForms(
         dictWord.readings,
         dictWord.kanjiForms,
@@ -2344,7 +2519,7 @@ function getWord(word, dict, kanjiDic, examples, definitions, noteTypeName, deck
       const readings = new Set(
         rkf.readings.map((r) => r.reading)
       );
-      const kanjiForms = rkf.kanjiForms ? new Set(rkf.kanjiForms.map((kf) => kf.form)) : void 0;
+      const kanjiForms = rkf.kanjiForms !== void 0 ? new Set(rkf.kanjiForms.map((kf) => kf.form)) : void 0;
       let kanjiFormExamples = [];
       const readingMatchingKanjiFormExamples = [];
       const readingExamples = [];
@@ -2355,7 +2530,7 @@ function getWord(word, dict, kanjiDic, examples, definitions, noteTypeName, deck
           const readingAsReadingMatch = part.reading !== void 0 && readings.has(part.reading);
           const readingAsInflectedFormMatch = part.inflectedForm !== void 0 && readings.has(part.inflectedForm);
           const referenceIDMatch = part.referenceID === dictWord.id;
-          if (kanjiForms && kanjiForms.has(part.baseForm) || referenceIDMatch) {
+          if (kanjiForms !== void 0 && kanjiForms.has(part.baseForm) || referenceIDMatch) {
             if (readingAsReadingMatch || readingAsInflectedFormMatch) {
               readingMatchingKanjiFormExamples.push({
                 ex: example,
@@ -2371,30 +2546,33 @@ function getWord(word, dict, kanjiDic, examples, definitions, noteTypeName, deck
             break;
           }
           const readingAsBaseFormMatch = readings.has(part.baseForm);
-          if ((readingAsBaseFormMatch || referenceIDMatch) && kanjiForms === void 0) {
+          if (readingAsBaseFormMatch && kanjiForms === void 0) {
             readingExamples.push({ ex: example, partIndex: i });
             break;
           }
         }
       if (readingMatchingKanjiForms.size > 0)
         kanjiFormExamples = kanjiFormExamples.filter(
-          (ex) => ex.form && readingMatchingKanjiForms.has(ex.form)
+          (ex) => ex.form !== void 0 && readingMatchingKanjiForms.has(ex.form)
         );
-      const includeKanjiFormExamples = word2.kanjiForms !== void 0;
+      const includeKanjiFormExamples = word.kanjiForms !== void 0;
       let wordExamples = [
         ...includeKanjiFormExamples ? [...readingMatchingKanjiFormExamples, ...kanjiFormExamples] : readingExamples
       ];
+      wordExamples.sort(
+        (a, b) => a.ex.phrase.length - b.ex.phrase.length
+      );
       readingMatchingKanjiForms.clear();
       const glossSpecificExamples = [];
       const seenPhrases = /* @__PURE__ */ new Set();
-      for (let i = 0; i < word2.translations.length; i++) {
+      for (let i = 0; i < word.translations.length; i++)
         outer: for (const example of wordExamples) {
           if (seenPhrases.has(example.ex.phrase)) continue;
           for (let j = 0; j < example.ex.parts.length; j++) {
             const part = example.ex.parts[j];
             if (j === example.partIndex && part.glossNumber === i + 1) {
               example.ex.glossNumber = {
-                wordId: word2.id,
+                wordId: word.id,
                 glossNumber: i + 1
               };
               glossSpecificExamples.push(example);
@@ -2403,213 +2581,69 @@ function getWord(word, dict, kanjiDic, examples, definitions, noteTypeName, deck
             }
           }
         }
-      }
       if (glossSpecificExamples.length > 0) {
-        const exes = glossSpecificExamples;
-        if (exes.length < 5) {
+        if (glossSpecificExamples.length < 5) {
           wordExamples = wordExamples.filter(
             (ex) => !seenPhrases.has(ex.ex.phrase)
           );
           if (wordExamples.length > 0)
             for (const ex of wordExamples) {
-              exes.push(ex);
-              if (exes.length === 5) break;
+              glossSpecificExamples.push(ex);
+              if (glossSpecificExamples.length === 5) break;
             }
         }
-        wordExamples = exes;
+        wordExamples = glossSpecificExamples;
       }
       if (wordExamples.length > 0) {
-        word2.phrases = (glossSpecificExamples.length === 0 ? wordExamples.slice(0, 5) : wordExamples).map((ex) => ({
+        word.phrases = (glossSpecificExamples.length === 0 ? wordExamples.slice(0, 5) : wordExamples).map((ex) => ({
           phrase: ex.ex.furigana ?? ex.ex.phrase,
           translation: ex.ex.translation,
           originalPhrase: ex.ex.phrase,
-          ...ex.ex.glossNumber ? { glossNumber: ex.ex.glossNumber } : {}
+          ...ex.ex.glossNumber !== void 0 ? { glossNumber: ex.ex.glossNumber } : {}
         }));
-        word2.tags.push("word::has_phrases");
+        word.tags.push("word::has_phrases");
         if (glossSpecificExamples.length > 0)
-          word2.tags.push("word::has_meaning-specific_phrases");
+          word.tags.push("word::has_meaning-specific_phrases");
       }
     }
-    if (definitions) {
-      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];
+    if (definitions !== void 0) {
+      const defs = definitions instanceof Map ? definitions.get(word.id) : (_a = definitions.find(
+        (wdp) => wdp.wordID === word.id
+      )) == null ? void 0 : _a.definitions;
+      if (defs !== void 0)
+        word.definitions = [
+          ...defs.toSorted(
+            (a, b) => (a.mayNotBeAccurate ?? 0) - (b.mayNotBeAccurate ?? 0)
+          )
+        ];
     }
-    return word2;
-  } else return void 0;
-}
-function getKanji(kanji, dict, jmDict, svgList, noteTypeName, deckPath) {
-  var _a, _b, _c, _d, _e, _f, _g;
-  let dictKanji = void 0;
-  if (typeof kanji === "string" && dict)
-    dictKanji = Array.isArray(dict) ? dict.find((entry) => entry.kanji === kanji) : dict.get(kanji);
-  else if (typeof kanji === "object") dictKanji = kanji;
-  if (dictKanji) {
-    const kanji2 = {
-      kanji: dictKanji.kanji,
-      strokes: dictKanji.misc.strokeNumber,
-      ...dictKanji.misc && dictKanji.misc.grade ? { grade: dictKanji.misc.grade } : {},
-      ...dictKanji.misc && dictKanji.misc.frequency ? { frequency: dictKanji.misc.frequency } : {},
-      ...dictKanji.misc && dictKanji.misc.jlpt ? { jlpt: dictKanji.misc.jlpt } : {},
-      noteID: `kanji_${dictKanji.kanji}`,
-      ...noteTypeName ? { noteTypeName } : {},
-      ...deckPath ? { deckPath } : {},
-      tags: []
-    };
-    if (dictKanji.readingMeaning && dictKanji.readingMeaning.length > 0) {
-      const meanings = [];
-      const nanori = [];
-      const onyomi = [];
-      const kunyomi = [];
-      for (const rm of dictKanji.readingMeaning) {
-        if (rm.nanori && rm.nanori.length > 0) nanori.push(...rm.nanori);
-        for (const group of rm.groups) {
-          if (group.readings) {
-            onyomi.push(
-              ...group.readings.filter((reading) => reading.type === "ja_on").map((reading) => reading.reading)
-            );
-            kunyomi.push(
-              ...group.readings.filter(
-                (reading) => reading.type === "ja_kun"
-              ).map((reading) => reading.reading)
-            );
-          }
-          if (group.meanings && group.meanings.length > 0)
-            meanings.push(...group.meanings);
-        }
-      }
-      if (meanings.length > 0) kanji2.meanings = meanings;
-      if (nanori.length > 0) kanji2.nanori = nanori;
-      if (onyomi.length > 0) kanji2.onyomi = onyomi;
-      if (kunyomi.length > 0) kanji2.kunyomi = kunyomi;
-    }
-    if (jmDict) {
-      let kanjiWords = Array.isArray(
-        jmDict
-      ) ? jmDict : jmDict.get(kanji2.kanji);
-      const firstKfWords = kanjiWords == null ? void 0 : kanjiWords.filter(
-        (word) => word.kanjiForms && word.kanjiForms[0].form.includes(kanji2.kanji)
-      );
-      if (firstKfWords && firstKfWords.length > 0) kanjiWords = firstKfWords;
-      if (kanjiWords) {
-        const validWords = [];
-        for (const word of kanjiWords) {
-          const kanjiForm = (_a = firstKfWords && firstKfWords.length > 0 ? word.kanjiForms[0] : word.kanjiForms.find(
-            (kf) => kf.form.includes(kanji2.kanji)
-          )) == null ? void 0 : _a.form;
-          if (kanjiForm) {
-            const reading = (_b = firstKfWords && firstKfWords.length > 0 ? word.readings[0] : word.readings.find(
-              (reading2) => reading2.kanjiFormRestrictions && reading2.kanjiFormRestrictions.includes(kanjiForm)
-            )) == null ? void 0 : _b.reading;
-            if (!reading) continue;
-            const translation = (_c = firstKfWords && firstKfWords.length > 0 ? word.meanings[0] : word.meanings.find(
-              (m) => m.translations && m.kanjiFormRestrictions && m.kanjiFormRestrictions.includes(kanjiForm)
-            )) == null ? void 0 : _c.translations.map(
-              (t) => typeof t === "string" ? t : t.translation
-            )[0];
-            if (!translation) continue;
-            validWords.push({
-              kanjiForms: [{ kanjiForm }],
-              readings: [{ reading }],
-              translations: [
-                {
-                  translation
-                }
-              ]
-            });
-          }
-          if (validWords.length === 3) break;
-        }
-        if (validWords.length > 0) kanji2.words = validWords;
-      }
-    }
-    if (svgList) {
-      const codePoint = kanji2.kanji.codePointAt(0).toString(16).toLowerCase();
-      const svg = Array.isArray(svgList) ? svgList.find(
-        (svgFile) => [`${codePoint}.svg`, `0${codePoint}.svg`].includes(
-          svgFile.toLowerCase()
-        )
-      ) : svgList.get(kanji2.kanji);
-      if (svg) kanji2.svg = svg;
-    }
-    if (kanji2.tags && dictKanji.isKokuji === true) {
-      kanji2.kokuji = true;
-      kanji2.tags.push("kanji::kokuji");
-    }
-    kanji2.tags.push(
-      `kanji::strokes::${kanji2.strokes}`,
-      ...kanji2.frequency ? [`kanji::frequency::${kanji2.frequency}`] : [],
-      ...kanji2.grade ? [`kanji::grade::${kanji2.grade}`] : [],
-      ...kanji2.jlpt ? [`kanji::pre-2010_jlpt::${kanji2.jlpt.toLowerCase()}`] : [],
-      `kanji::onyomi::${((_d = kanji2.onyomi) == null ? void 0 : _d.length) ?? 0}`,
-      `kanji::kunyomi::${((_e = kanji2.kunyomi) == null ? void 0 : _e.length) ?? 0}`,
-      `kanji::nanori::${((_f = kanji2.nanori) == null ? void 0 : _f.length) ?? 0}`,
-      `kanji::words::${((_g = kanji2.words) == null ? void 0 : _g.length) ?? 0}`,
-      ...kanji2.svg ? ["kanji::has_svg"] : []
-    );
-    return kanji2;
-  } else return void 0;
-}
-function getKanjiExtended(info, kanji, dict, useWords, jmDict, svgList, noteTypeName, deckPath, sourceURL) {
-  const kanjiObj = getKanji(
-    kanji,
-    dict,
-    jmDict,
-    svgList,
-    noteTypeName,
-    deckPath
-  );
-  if (kanjiObj) {
-    let usedInfo = false;
-    if (info.components) {
-      kanjiObj.components = info.components;
-      usedInfo = true;
-    }
-    if (info.mnemonic && info.mnemonic.length > 0) {
-      kanjiObj.mnemonic = info.mnemonic;
-      usedInfo = true;
-    }
-    if (useWords === true && info.words && info.words.length > 0) {
-      kanjiObj.words = info.words;
-      usedInfo = true;
-    }
-    if (kanjiObj.components)
-      kanjiObj.tags.push(`kanji::components::${kanjiObj.components.length}`);
-    if (kanjiObj.mnemonic && kanjiObj.mnemonic.length > 0)
-      kanjiObj.tags.push("kanji::has_mnemonic");
-    if (useWords === true && kanjiObj.words && info.words)
-      kanjiObj.tags.forEach((tag, index) => {
-        if (tag.startsWith("kanji::words::") && kanjiObj.words) {
-          kanjiObj.tags.splice(
-            index,
-            1,
-            `kanji::words::${kanjiObj.words.length}`
-          );
-        }
-      });
-    if (sourceURL && info.externalInfo === true && usedInfo)
-      kanjiObj.source = sourceURL;
-    return kanjiObj;
+    return word;
   } else return void 0;
 }
 function isWord(entry) {
-  return entry.translations !== void 0 && entry.readings !== void 0;
+  var _a, _b;
+  return isObjectArray((_a = Object.getOwnPropertyDescriptor(entry, "readings")) == null ? void 0 : _a.value) && isObjectArray((_b = Object.getOwnPropertyDescriptor(entry, "translations")) == null ? void 0 : _b.value);
 }
 function isRadical(entry) {
-  return entry.radical !== void 0;
+  var _a;
+  return typeof ((_a = Object.getOwnPropertyDescriptor(entry, "radical")) == null ? void 0 : _a.value) === "string";
 }
 function isKanji(entry) {
-  return entry.translations === void 0 && entry.readings === void 0 && entry.radical === void 0 && entry.kanji !== void 0;
+  var _a;
+  return !Object.hasOwn(entry, "translations") && !Object.hasOwn(entry, "readings") && !Object.hasOwn(entry, "radical") && typeof ((_a = Object.getOwnPropertyDescriptor(entry, "kanji")) == null ? void 0 : _a.value) === "string";
 }
 function isKana(entry) {
-  return entry.kana !== void 0;
+  var _a;
+  return typeof ((_a = Object.getOwnPropertyDescriptor(entry, "kana")) == null ? void 0 : _a.value) === "string";
 }
 function isGrammar(entry) {
-  return entry.point !== void 0;
+  var _a;
+  return typeof ((_a = Object.getOwnPropertyDescriptor(entry, "point")) == null ? void 0 : _a.value) === "string";
 }
 var createNotes = (notes, phrase) => `${phrase === true ? "<details><summary>Show translation</summary>" : ""}<ul class="note-list">${notes.map((note) => `<li class="note">${note}</li>`).join("")}</ul>${phrase === true ? "</details>" : ""}`;
-var createEntry = (entry, notes, phrase, glossSpecific) => `<div class="entry${glossSpecific ? " gloss-specific" : ""}">${entry}${notes && notes.length > 0 ? createNotes(notes, phrase) : ""}</div>`;
-var noKanjiForms = '<span class="word word-kanjiform">(no kanji forms)</span>';
+var createEntry = (entry, notes, phrase, glossSpecific) => `<div class="entry${glossSpecific === true ? " gloss-specific" : ""}">${entry}${notes !== void 0 && notes.length > 0 ? createNotes(notes, phrase) : ""}</div>`;
 function generateAnkiNote(entry) {
+  var _a, _b;
   const fields = [];
   if (isWord(entry)) {
     const firstReading = createEntry(
@@ -2621,61 +2655,91 @@ function generateAnkiNote(entry) {
         `<span class="word word-reading">${readingEntry.reading}${readingEntry.audio !== void 0 ? `<br>[sound:${readingEntry.audio}]` : ""}</span>`,
         readingEntry.notes
       )
-    ).join("")}</details>` : void 0;
-    const readingsField = [firstReading, ...otherReadings ?? []].join(
-      ""
-    );
-    const firstKanjiForm = entry.kanjiForms ? createEntry(
+    ).join("")}</details>` : "";
+    const readingsField = `${firstReading}${otherReadings}`;
+    const firstKanjiForm = entry.kanjiForms !== void 0 ? createEntry(
       `<span class="word word-kanjiform"><ruby><rb>${entry.kanjiForms[0].kanjiForm}</rb><rt>${entry.readings[0].reading}</rt></ruby></span>`,
       entry.kanjiForms[0].notes
     ) : void 0;
-    const otherKanjiForms = entry.kanjiForms && entry.kanjiForms.length > 1 ? `<details><summary>Show other kanji forms</summary>${entry.kanjiForms.slice(1).map((kanjiFormEntry) => {
+    const otherKanjiForms = entry.kanjiForms !== void 0 && entry.kanjiForms.length > 1 ? `<details><summary>Show other kanji forms</summary>${entry.kanjiForms.slice(1).map((kanjiFormEntry) => {
       const restrictedReading = entry.readings.find(
-        (r) => r.notes && r.notes.includes(
+        (r) => r.notes !== void 0 && r.notes.includes(
           `Reading restricted to ${kanjiFormEntry.kanjiForm}`
         )
       );
-      return `${createEntry(`<span class="word word-kanjiform">${restrictedReading ? "<ruby><rb>" : ""}${kanjiFormEntry.kanjiForm}${restrictedReading ? `</rb><rt>${restrictedReading.reading}</rt></ruby>` : ""}</span>`, kanjiFormEntry.notes)}`;
-    }).join("")}</details>` : void 0;
-    const kanjiFormsField = firstKanjiForm ? [firstKanjiForm, ...otherKanjiForms ?? []].join("") : void 0;
+      return createEntry(
+        `<span class="word word-kanjiform">${restrictedReading !== void 0 ? "<ruby><rb>" : ""}${kanjiFormEntry.kanjiForm}${restrictedReading !== void 0 ? `</rb><rt>${restrictedReading.reading}</rt></ruby>` : ""}</span>`,
+        kanjiFormEntry.notes
+      );
+    }).join("")}</details>` : "";
+    const kanjiFormsField = firstKanjiForm !== void 0 ? `${firstKanjiForm}${otherKanjiForms}` : '<span class="word word-kanjiform">(no kanji forms)</span>';
     const firstThreeTranslations = entry.translations.slice(0, 3).map(
-      (translationEntry, index) => `${createEntry(`<span class="word word-translation">${translationEntry.translation}</span>`, translationEntry.notes, void 0, entry.phrases && entry.phrases.some((phrase, index2) => index === index2 && phrase.glossNumber && phrase.glossNumber.wordId === entry.id && phrase.glossNumber.glossNumber === index + 1) ? true : void 0)}`
+      (translationEntry, index) => createEntry(
+        `<span class="word word-translation">${translationEntry.translation}</span>`,
+        translationEntry.notes,
+        void 0,
+        entry.phrases !== void 0 ? entry.phrases.some(
+          (phrase, index2) => index === index2 && phrase.glossNumber !== void 0 && phrase.glossNumber.wordId === entry.id && phrase.glossNumber.glossNumber === index + 1
+        ) ? true : void 0 : void 0
+      )
+    ).join("");
+    const otherTranslations = entry.translations.length > 3 ? `<details><summary>Show other translations</summary>${entry.translations.map((translationEntry, index) => {
+      if (index < 3) return "null";
+      return createEntry(
+        `<span class="word word-translation">${translationEntry.translation}</span>`,
+        translationEntry.notes,
+        void 0,
+        entry.phrases !== void 0 ? entry.phrases.some(
+          (phrase, index2) => index === index2 && phrase.glossNumber !== void 0 && phrase.glossNumber.wordId === entry.id && phrase.glossNumber.glossNumber === index + 1
+        ) ? true : void 0 : void 0
+      );
+    }).filter((translation) => translation !== "null").join("")}</details>` : "";
+    const translationsField = `${firstThreeTranslations}${otherTranslations}`;
+    const firstFivePhrases = (_a = entry.phrases) == null ? void 0 : _a.slice(0, 5).map(
+      (phraseEntry, index) => createEntry(
+        `<span class="word word-phrase"><span class="word word-phrase-original">${phraseEntry.originalPhrase}</span><span class="word word-phrase-furigana">${phraseEntry.phrase}</span></span>`,
+        [phraseEntry.translation],
+        true,
+        entry.translations.some(
+          (_translation, index2) => index === index2 && phraseEntry.glossNumber !== void 0 && phraseEntry.glossNumber.wordId === entry.id && phraseEntry.glossNumber.glossNumber === index2 + 1
+        ) ? true : void 0
+      )
+    ).join("");
+    const otherPhrases = entry.phrases !== void 0 && entry.phrases.length > 5 ? `<details><summary>Show other phrases</summary>${entry.phrases.map((phraseEntry, index) => {
+      if (index < 5) return "null";
+      return createEntry(
+        `<span class="word word-phrase"><span class="word word-phrase-original">${phraseEntry.originalPhrase}</span><span class="word word-phrase-furigana">${phraseEntry.phrase}</span></span>`,
+        [phraseEntry.translation],
+        true,
+        entry.translations.some(
+          (_translation, index2) => index === index2 && phraseEntry.glossNumber !== void 0 && phraseEntry.glossNumber.wordId === entry.id && phraseEntry.glossNumber.glossNumber === index2 + 1
+        ) ? true : void 0
+      );
+    }).filter((phrase) => phrase !== "null").join("")}</details>` : "";
+    const phrasesField = firstFivePhrases !== void 0 ? `${firstFivePhrases}${otherPhrases}` : '<span class="word word-phrase">(no phrases) (Search on dictionaries!)</span>';
+    const firstThreeDefinitions = (_b = entry.definitions) == null ? void 0 : _b.slice(0, 3).map(
+      (definitionEntry) => createEntry(
+        `<span class="word word-definition${definitionEntry.mayNotBeAccurate === 2 ? " mnba2" : definitionEntry.mayNotBeAccurate === 1 ? " mnba1" : ""}"><span class="word word-definition-original">${definitionEntry.definition}</span><span class="word word-definition-furigana">${definitionEntry.furigana ?? definitionEntry.definition}</span></span>`
+      )
     ).join("");
-    const otherTranslations = entry.translations.length > 3 ? `<details><summary>Show other translations</summary>${entry.translations.map(
-      (translationEntry, index) => index > 2 ? `${createEntry(`<span class="word word-translation">${translationEntry.translation}</span>`, translationEntry.notes, void 0, entry.phrases && entry.phrases.some((phrase, index2) => index === index2 && phrase.glossNumber && phrase.glossNumber.wordId === entry.id && phrase.glossNumber.glossNumber === index + 1) ? true : void 0)}` : "null"
-    ).filter((translation) => translation !== "null").join("")}</details>` : void 0;
-    const translationsField = [
-      firstThreeTranslations,
-      ...otherTranslations ?? []
-    ].join("");
+    const otherDefinitions = entry.definitions !== void 0 && entry.definitions.length > 3 ? `<details><summary>Show other definitions</summary>${entry.definitions.map(
+      (definitionEntry, index) => index > 2 ? createEntry(
+        `<span class="word word-definition${definitionEntry.mayNotBeAccurate === 2 ? " mnba2" : definitionEntry.mayNotBeAccurate === 1 ? " mnba1" : ""}"><span class="word word-definition-original">${definitionEntry.definition}</span><span class="word word-definition-furigana">${definitionEntry.furigana ?? definitionEntry.definition}</span></span>`
+      ) : "null"
+    ).filter((definition) => definition !== "null").join("")}</details>` : "";
+    const definitionsField = firstThreeDefinitions !== void 0 ? `${firstThreeDefinitions}${otherDefinitions}` : '<span class="word word-definition">(no definitions)</span>';
     fields.push(
-      ...entry.kanjiForms && kanjiFormsField && !entry.usuallyInKana ? [kanjiFormsField, readingsField] : [
-        readingsField,
-        entry.kanjiForms && kanjiFormsField ? kanjiFormsField : noKanjiForms
-      ],
+      ...entry.kanjiForms !== void 0 && !entry.usuallyInKana ? [kanjiFormsField, readingsField] : [readingsField, kanjiFormsField],
       translationsField,
-      entry.phrases ? entry.phrases.map(
-        (phraseEntry, index) => createEntry(
-          `<span class="word word-phrase"><span class="word word-phrase-original">${phraseEntry.originalPhrase}</span><span class="word word-phrase-furigana">${phraseEntry.phrase}</span></span>`,
-          [phraseEntry.translation],
-          true,
-          entry.translations.some(
-            (_translation, index2) => index === index2 && phraseEntry.glossNumber && phraseEntry.glossNumber.wordId === entry.id && phraseEntry.glossNumber.glossNumber === index2 + 1
-          ) ? true : void 0
-        )
-      ).join("") : '<span class="word word-phrase">(no phrases) (Search on dictionaries!)</span>',
-      entry.definitions ? entry.definitions.map(
-        (definitionEntry) => createEntry(
-          `<span class="word word-definition${definitionEntry.mayNotBeAccurate === true ? " mnba" : ""}"><span class="word word-definition-original">${definitionEntry.definition}</span><span class="word word-definition-furigana">${definitionEntry.furigana ?? definitionEntry.definition}</span></span>`
-        )
-      ).join("") : '<span class="word word-definition">(no definitions)</span>',
-      entry.kanji ? entry.kanji.map(
+      phrasesField,
+      definitionsField,
+      entry.kanji !== void 0 ? entry.kanji.map(
         (kanjiEntry) => createEntry(
           `<span class="word word-kanji">${kanjiEntry.kanji}${kanjiEntry.meanings === void 0 ? " (no meanings)" : ""}</span>`,
           kanjiEntry.meanings
         )
       ).join("") : '<span class="word word-kanji">(no kanji)</span>',
-      ...entry.tags && entry.tags.length > 0 ? [
+      ...entry.tags !== void 0 && entry.tags.length > 0 ? [
         entry.tags.map(
           (tag) => tag.trim().toLowerCase().replaceAll(" ", "::")
         ).join(" ")
@@ -2695,19 +2759,19 @@ function generateAnkiNote(entry) {
           `<span class="radical radical-meaning">${meaningEntry}</span>`
         )
       ).join(""),
-      entry.mnemonic ? createEntry(
+      entry.mnemonic !== void 0 ? createEntry(
         `<span class="radical radical-mnemonic">${entry.mnemonic}</span>`
       ) : '<span class="radical radical-mnemonic">(no mnemonic) (Come up with your own!)</span>',
-      entry.kanji ? entry.kanji.map(
+      entry.kanji !== void 0 ? entry.kanji.map(
         (kanji) => createEntry(
-          `<span class="radical radical-kanji">${kanji.kanji}${kanji.meanings && kanji.meanings.length === 1 ? ` - ${kanji.meanings[0]}` : ""}</span>`
+          `<span class="radical radical-kanji">${kanji.kanji}${kanji.meanings !== void 0 && kanji.meanings.length > 0 ? ` - ${kanji.meanings[0]}` : ""}</span>`
         )
       ).join("") : '<span class="radical radical-kanji">(no "used-in" kanji)</span>',
-      entry.strokes ? createEntry(
-        `<span class="radical radical-strokes">${entry.strokes}<br>${entry.svg ? `<img class="radical radical-stroke-order" src="${entry.svg}" alt="${entry.radical} stroke order SVG">` : "(no stroke order SVG available)"}</span>`
+      entry.strokes !== void 0 ? createEntry(
+        `<span class="radical radical-strokes">${entry.strokes}<br>${entry.svg !== void 0 ? `<img class="radical radical-stroke-order" src="${entry.svg}" alt="${entry.radical} stroke order SVG">` : "(no stroke order SVG available)"}</span>`
       ) : '<span class="radical radical-strokes">(no stroke number)</span>',
-      entry.sources ? `<span class="radical radical-source">${entry.sources.map((source, index) => `<a href="${source}" target="_blank">Source ${index + 1}</a>`).join("<br>")}</span>` : '<span class="radical radical-source">(no sources)</span>',
-      ...entry.tags && entry.tags.length > 0 ? [
+      entry.sources !== void 0 ? `<span class="radical radical-source">${entry.sources.map((source, index) => `<a href="${source}" target="_blank">Source ${index + 1}</a>`).join("<br>")}</span>` : '<span class="radical radical-source">(no sources)</span>',
+      ...entry.tags !== void 0 && entry.tags.length > 0 ? [
         entry.tags.map(
           (tag) => tag.trim().toLowerCase().replaceAll(" ", "::")
         ).join(" ")
@@ -2716,44 +2780,44 @@ function generateAnkiNote(entry) {
   if (isKanji(entry))
     fields.push(
       createEntry(`<span class="kanji kanji-character">${entry.kanji}</span>`),
-      entry.meanings ? entry.meanings.map(
+      entry.meanings !== void 0 ? entry.meanings.map(
         (meaningEntry) => createEntry(
           `<span class="kanji kanji-meaning">${meaningEntry}</span>`
         )
       ).join("") : '<span class="kanji kanji-meaning">(no meanings)</span>',
-      entry.onyomi ? entry.onyomi.map(
+      entry.onyomi !== void 0 ? entry.onyomi.map(
         (onyomiEntry) => createEntry(
           `<span class="kanji kanji-onyomi">${onyomiEntry}</span>`
         )
-      ).join("") : `<span class="kanji kanji-onyomi">(no onyomi) ${entry.kokuji === true ? "(kokuji)" : ""}</span`,
-      entry.kunyomi ? entry.kunyomi.map(
+      ).join("") : `<span class="kanji kanji-onyomi">(no onyomi) ${entry.kokuji === true ? "(kokuji)" : ""}</span>`,
+      entry.kunyomi !== void 0 ? entry.kunyomi.map(
         (kunyomiEntry) => createEntry(
           `<span class="kanji kanji-kunyomi">${kunyomiEntry}</span>`
         )
       ).join("") : `<span class="kanji kanji-kunyomi">(no kunyomi) ${entry.kokuji === true ? "(kokuji)" : ""}</span>`,
-      entry.nanori ? entry.nanori.map(
+      entry.nanori !== void 0 ? entry.nanori.map(
         (nanoriEntry) => createEntry(
           `<span class="kanji kanji-nanori">${nanoriEntry}</span>`
         )
       ).join("") : '<span class="kanji kanji-nanori">(no nanori)</span>',
-      entry.components ? entry.components.map(
+      entry.components !== void 0 ? entry.components.map(
         (componentEntry) => createEntry(
-          `<span class="kanji kanji-component">${componentEntry.component}${componentEntry.meaning ? ` - ${componentEntry.meaning}` : ""}</span>`
+          `<span class="kanji kanji-component">${componentEntry.component}${componentEntry.meaning !== void 0 ? ` - ${componentEntry.meaning}` : ""}</span>`
         )
       ).join("") : '<span class="kanji kanji-component">(no components)</span>',
-      entry.mnemonic ? createEntry(
+      entry.mnemonic !== void 0 ? createEntry(
         `<span class="kanji kanji-mnemonic">${entry.mnemonic}</span>`
       ) : '<span class="kanji kanji-mnemonic">(no mnemonic) (Come up with your own!)</span>',
-      entry.words ? entry.words.map(
+      entry.words !== void 0 ? entry.words.map(
         (word) => createEntry(
-          `<span class="kanji kanji-words">${word.kanjiForms[0].kanjiForm} / ${word.readings[0].reading} - ${word.translations[0].translation}</span>`
+          `<span class="kanji kanji-words">${word.kanjiForms.find((kf) => kf.kanjiForm.includes(entry.kanji)).kanjiForm} / ${word.readings[0].reading} - ${word.translations[0].translation}</span>`
         )
       ).join("") : '<span class="kanji kanji-words">(no words) (Search on dictionaries!)</span>',
-      entry.strokes ? createEntry(
-        `<span class="kanji kanji-strokes">${entry.strokes}<br>${entry.svg ? `<img class="kanji kanji-stroke-order" src="${entry.svg}" alt="${entry.kanji} stroke order SVG">` : "(no stroke order SVG available)"}</span>`
+      entry.strokes !== void 0 ? createEntry(
+        `<span class="kanji kanji-strokes">${entry.strokes}<br>${entry.svg !== void 0 ? `<img class="kanji kanji-stroke-order" src="${entry.svg}" alt="${entry.kanji} stroke order SVG">` : "(no stroke order SVG available)"}</span>`
       ) : '<span class="kanji kanji-strokes">(no stroke number)</span>',
-      entry.source ? `<span class="kanji kanji-source"><a href="${entry.source}" target="_blank">Source</a></span>` : '<span class="kanji kanji-source">(no components/mnemonic source)</span>',
-      ...entry.tags && entry.tags.length > 0 ? [
+      entry.source !== void 0 ? `<span class="kanji kanji-source"><a href="${entry.source}" target="_blank">Source</a></span>` : '<span class="kanji kanji-source">(no components/mnemonic source)</span>',
+      ...entry.tags !== void 0 && entry.tags.length > 0 ? [
         entry.tags.map(
           (tag) => tag.trim().toLowerCase().replaceAll(" ", "::")
         ).join(" ")
@@ -2765,10 +2829,10 @@ function generateAnkiNote(entry) {
       createEntry(
         `<span class="kana kana-reading">${entry.reading}${entry.audio !== void 0 ? `<br>[sound:${entry.audio}]` : ""}</span>`
       ),
-      entry.svg ? createEntry(
+      entry.svg !== void 0 ? createEntry(
         `<img class="kana kana-stroke-order" src="${entry.svg}" alt="${entry.kana} stroke order SVG">`
       ) : "(no stroke order SVG available)",
-      ...entry.tags && entry.tags.length > 0 ? [
+      ...entry.tags !== void 0 && entry.tags.length > 0 ? [
         entry.tags.map(
           (tag) => tag.trim().toLowerCase().replaceAll(" ", "::")
         ).join(" ")
@@ -2777,28 +2841,28 @@ function generateAnkiNote(entry) {
   if (isGrammar(entry))
     fields.push(
       createEntry(`<span class="grammar grammar-point">${entry.point}</span>`),
-      entry.readings ? entry.readings.map(
+      entry.readings !== void 0 ? entry.readings.map(
         (readingEntry) => createEntry(
           `<span class="grammar grammar-reading">${readingEntry.reading}</span>`
         )
       ).join("") : '<span class="grammar grammar-reading">(no additional readings)</span>',
       createEntry(
-        `<span class="grammar grammar-meaning">${entry.meaning.meaning}${entry.meaning.example && entry.meaning.example.length > 0 ? `<br><span class="grammar grammar-meaning-example">${entry.meaning.example}</span>` : ""}</span>`
+        `<span class="grammar grammar-meaning">${entry.meaning.meaning}${entry.meaning.example !== void 0 && entry.meaning.example.length > 0 ? `<br><span class="grammar grammar-meaning-example">${entry.meaning.example}</span>` : ""}</span>`
       ),
-      entry.usages ? entry.usages.map(
+      entry.usages !== void 0 ? entry.usages.map(
         (usage) => createEntry(
           `<span class="grammar grammar-usage">${usage}</span>`
         )
       ).join("") : '<span class="grammar grammar-usage">(no usages)</span>',
-      entry.phrases ? entry.phrases.map(
+      entry.phrases !== void 0 ? entry.phrases.map(
         (phraseEntry) => createEntry(
           `<span class="grammar grammar-phrase"><span class="grammar grammar-phrase-original">${phraseEntry.originalPhrase}</span><span class="grammar grammar-phrase-furigana">${phraseEntry.phrase}</span></span>`,
           [phraseEntry.translation],
           true
         )
       ).join("") : '<span class="grammar grammar-phrase">(no phrases) (Search on dictionaries!)</span>',
-      entry.source ? `<span class="grammar grammar-source"><a href="${entry.source}" target="_blank">Source</a></span>` : '<span class="grammar grammar-source">(no source)</span>',
-      ...entry.tags && entry.tags.length > 0 ? [
+      entry.source !== void 0 ? `<span class="grammar grammar-source"><a href="${entry.source}" target="_blank">Source</a></span>` : '<span class="grammar grammar-source">(no source)</span>',
+      ...entry.tags !== void 0 && entry.tags.length > 0 ? [
         entry.tags.map(
           (tag) => tag.trim().toLowerCase().replaceAll(" ", "::")
         ).join(" ")
@@ -2810,8 +2874,9 @@ function generateAnkiNotesFile(list, defaultNoteInfo) {
   const headers = [noteHeaderKeys.separator, noteHeaderKeys.html];
   let ankiNotes = "";
   if (list.length > 0) {
-    if (defaultNoteInfo === void 0) defaultNoteInfo = {};
-    const infoValues = Object.values(defaultNoteInfo);
+    let noteInfo = {};
+    if (defaultNoteInfo !== void 0) noteInfo = { ...defaultNoteInfo };
+    const infoValues = Object.values(noteInfo);
     let invalidList = false;
     const firstEntry = list[0];
     const firstEntryInfo = {
@@ -2821,7 +2886,7 @@ function generateAnkiNotesFile(list, defaultNoteInfo) {
     };
     if (infoValues.length === 0 || infoValues.some((value) => value === true || value === void 0)) {
       for (const res of list)
-        if (defaultNoteInfo.guid === true && res.noteID === void 0 || defaultNoteInfo.noteType === true && res.noteTypeName === void 0 || defaultNoteInfo.deckPath === true && res.deckPath === void 0 || defaultNoteInfo.guid === void 0 && typeof res.noteID !== firstEntryInfo.guid || defaultNoteInfo.noteType === void 0 && typeof res.noteTypeName !== firstEntryInfo.noteType || defaultNoteInfo.deckPath === void 0 && typeof res.deckPath !== firstEntryInfo.deckPath) {
+        if (noteInfo.guid === true && res.noteID === void 0 || noteInfo.noteType === true && res.noteTypeName === void 0 || noteInfo.deckPath === true && res.deckPath === void 0 || noteInfo.guid === void 0 && typeof res.noteID !== firstEntryInfo.guid || noteInfo.noteType === void 0 && typeof res.noteTypeName !== firstEntryInfo.noteType || noteInfo.deckPath === void 0 && typeof res.deckPath !== firstEntryInfo.deckPath) {
           invalidList = true;
           break;
         }
@@ -2830,26 +2895,28 @@ function generateAnkiNotesFile(list, defaultNoteInfo) {
     const hasHeader = { guid: false, noteType: false, deckPath: false, tags: false };
     let headerCount = 0;
     ankiNotes = list.filter((result) => result.doNotCreateNote === void 0).map((result) => {
-      if (typeof defaultNoteInfo.guid === "string" && result.noteID === void 0) {
-        if (isWord(result) && result.id) result.noteID = result.id;
+      if (typeof noteInfo.guid === "string" && result.noteID === void 0) {
+        if (isWord(result) && result.id !== void 0)
+          result.noteID = result.id;
         if (isKanji(result)) result.noteID = result.kanji;
         if (isRadical(result)) result.noteID = result.radical;
         if (isKana(result)) result.noteID = result.kana;
-        if (isGrammar(result) && result.id) result.noteID = result.id;
+        if (isGrammar(result) && result.id !== void 0)
+          result.noteID = result.id;
       }
-      if (typeof defaultNoteInfo.noteType === "string" && result.noteTypeName === void 0)
-        result.noteTypeName = defaultNoteInfo.noteType;
-      if (typeof defaultNoteInfo.deckPath === "string" && result.deckPath === void 0)
-        result.deckPath = defaultNoteInfo.deckPath;
-      if (!hasHeader.guid && result.noteID) {
+      if (typeof noteInfo.noteType === "string" && result.noteTypeName === void 0)
+        result.noteTypeName = noteInfo.noteType;
+      if (typeof noteInfo.deckPath === "string" && result.deckPath === void 0)
+        result.deckPath = noteInfo.deckPath;
+      if (!hasHeader.guid && result.noteID !== void 0) {
         headers.push(`${noteHeaderKeys.guid}${++headerCount}`);
         hasHeader.guid = true;
       }
-      if (!hasHeader.noteType && result.noteTypeName) {
+      if (!hasHeader.noteType && result.noteTypeName !== void 0) {
         headers.push(`${noteHeaderKeys.notetype}${++headerCount}`);
         hasHeader.noteType = true;
       }
-      if (!hasHeader.deckPath && result.deckPath) {
+      if (!hasHeader.deckPath && result.deckPath !== void 0) {
         headers.push(`${noteHeaderKeys.deck}${++headerCount}`);
         hasHeader.deckPath = true;
       }
@@ -2858,7 +2925,7 @@ function generateAnkiNotesFile(list, defaultNoteInfo) {
         headers.push(`${noteHeaderKeys.tags}${note.length + headerCount}`);
         hasHeader.tags = true;
       }
-      return `${result.noteID ? `${result.noteID}	` : ""}${result.noteTypeName ? `${result.noteTypeName}	` : ""}${result.deckPath ? `${result.deckPath}	` : ""}${note.join("	")}`;
+      return `${result.noteID !== void 0 ? `${result.noteID}	` : ""}${result.noteTypeName !== void 0 ? `${result.noteTypeName}	` : ""}${result.deckPath !== void 0 ? `${result.deckPath}	` : ""}${note.join("	")}`;
     }).join("\n").trim();
   }
   return `${headers.join("\n")}
@@ -2884,6 +2951,7 @@ export {
   getWord,
   getWordDefinitions,
   getWordDefinitionsWithFurigana,
+  hiraganaToKatakana,
   isGrammar,
   isKana,
   isKanji,
@@ -2892,9 +2960,11 @@ export {
   isStringArray,
   isValidArrayWithFirstElement,
   isWord,
+  katakanaToHiragana,
   notSearchedForms,
   noteHeaderKeys,
   noteMap,
+  posList,
   regexps,
   shuffleArray
 };