henkan 1.1.1 → 2.0.0

package/dist/index.cjs.js

@@ -32,17 +32,20 @@ var index_exports = {};
 __export(index_exports, {
   capitalizeString: () => capitalizeString,
   convertJMdict: () => convertJMdict,
-  convertJawiktionary: () => convertJawiktionary,
+  convertJawiktionaryAsync: () => convertJawiktionaryAsync,
+  convertJawiktionarySync: () => convertJawiktionarySync,
   convertKanjiDic: () => convertKanjiDic,
   convertKradFile: () => convertKradFile,
   convertRadkFile: () => convertRadkFile,
   convertTanakaCorpus: () => convertTanakaCorpus,
+  convertTanakaCorpusWithFurigana: () => convertTanakaCorpusWithFurigana,
   generateAnkiNote: () => generateAnkiNote,
   generateAnkiNotesFile: () => generateAnkiNotesFile,
   getKanji: () => getKanji,
   getKanjiExtended: () => getKanjiExtended,
   getWord: () => getWord,
   getWordDefinitions: () => getWordDefinitions,
+  getWordDefinitionsWithFurigana: () => getWordDefinitionsWithFurigana,
   isGrammar: () => isGrammar,
   isKana: () => isKana,
   isKanji: () => isKanji,
@@ -52,10 +55,10 @@ __export(index_exports, {
   isValidArrayWithFirstElement: () => isValidArrayWithFirstElement,
   isWord: () => isWord,
   notSearchedForms: () => notSearchedForms,
+  noteHeaderKeys: () => noteHeaderKeys,
   noteMap: () => noteMap,
   regexps: () => regexps,
-  shuffleArray: () => shuffleArray,
-  synthesizeSpeech: () => synthesizeSpeech
+  shuffleArray: () => shuffleArray
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -69,6 +72,14 @@ var regexps = {
   tanakaPart: /(?<base>[^()\[\]\{\}\s]+)(?:\((?<reading>[\S]+)\))?(?:\[(?<glossnum>[\S]+)\])?(?:\{(?<inflection>[\S]+)\})?/,
   tanakaReferenceID: /#(?<entryid>[\d]+)/
 };
+var noteHeaderKeys = {
+  separator: "#separator:tab",
+  html: "#html:true",
+  guid: "#guid column:",
+  notetype: "#notetype column:",
+  deck: "#deck column:",
+  tags: "#tags column:"
+};
 var notSearchedForms = /* @__PURE__ */ new Set([
   "search-only kana form",
   "Search-only kana form",
@@ -1225,7 +1236,6 @@ var noteMap = /* @__PURE__ */ new Map([
 var import_libxmljs2 = __toESM(require("libxmljs2"));
 var import_xml2js = __toESM(require("xml2js"));
 var import_iconv_lite = __toESM(require("iconv-lite"));
-var import_client_polly = require("@aws-sdk/client-polly");
 var import_readline = require("readline");
 var Kuroshiro = require("kuroshiro");
 var KuromojiAnalyzer = require("kuroshiro-analyzer-kuromoji");
@@ -1242,29 +1252,25 @@ function isStringArray(arg) {
   return arg !== null && arg !== void 0 && Array.isArray(arg) && arg.every((element) => typeof element === "string");
 }
 function shuffleArray(arr) {
-  if (arr.length < 2) return arr;
   const a = arr.slice();
   for (let i = a.length - 1; i > 0; i--) {
     const j = Math.floor(Math.random() * (i + 1));
     const tmp = a[i];
-    const tmp2 = a[j];
-    if (!tmp || !tmp2) throw new Error("Invalid array");
-    a[i] = tmp2;
+    a[i] = a[j];
     a[j] = tmp;
   }
   return a;
 }
 function convertJMdict(xmlString, examples) {
-  try {
-    const dictParsed = import_libxmljs2.default.parseXml(xmlString, {
-      dtdvalid: true,
-      nonet: false,
-      noent: true,
-      recover: false
-    });
-    const dict = [];
-    import_xml2js.default.parseString(dictParsed, (err, result) => {
-      if (err) throw err;
+  const dictParsed = import_libxmljs2.default.parseXml(xmlString, {
+    dtdvalid: true,
+    nonet: false,
+    noent: true,
+    recover: false
+  });
+  const dict = [];
+  import_xml2js.default.parseString(dictParsed, (err, result) => {
+    if (err === null) {
       const tanakaParts = examples && examples.length > 0 ? new Set(
         examples.map(
           (example) => example.parts.map((part) => [
@@ -1277,239 +1283,229 @@ function convertJMdict(xmlString, examples) {
       if (result.JMdict && typeof result.JMdict === "object" && isValidArray(result.JMdict.entry))
         for (const entry of result.JMdict.entry) {
           const entryObj = {
-            ...isValidArray(entry.ent_seq) && entry.ent_seq[0] && typeof entry.ent_seq[0] === "string" ? { id: entry.ent_seq[0] } : { id: "" },
+            id: entry.ent_seq[0],
             readings: [],
             meanings: []
           };
-          if (entryObj.id.length === 0) throw new Error("Invalid JMdict entry");
-          const kanjiForms = entry.k_ele;
-          const readings = entry.r_ele;
-          const meanings = entry.sense;
-          if (isValidArray(kanjiForms)) {
-            entryObj.kanjiForms = [];
-            for (const kanjiForm of kanjiForms) {
-              const form = {
-                ...isValidArrayWithFirstElement(kanjiForm.keb) && typeof kanjiForm.keb[0] === "string" ? { form: kanjiForm.keb[0] } : { form: "" }
-              };
-              if (form.form.length === 0)
-                throw new Error(
-                  `Invalid JMdict entry kanji form: ${entryObj.id}`
-                );
-              if (isStringArray(kanjiForm.ke_inf))
-                form.notes = kanjiForm.ke_inf;
-              if (isStringArray(kanjiForm.ke_pri)) {
-                form.commonness = kanjiForm.ke_pri;
-                if (entryObj.isCommon === void 0) entryObj.isCommon = true;
+          if (typeof entryObj.id === "string") {
+            const kanjiForms = entry.k_ele;
+            const readings = entry.r_ele;
+            const meanings = entry.sense;
+            if (isValidArray(kanjiForms)) {
+              entryObj.kanjiForms = [];
+              for (const kanjiForm of kanjiForms) {
+                const form = {
+                  form: kanjiForm.keb[0]
+                };
+                if (typeof form.form === "string") {
+                  if (isStringArray(kanjiForm.ke_inf))
+                    form.notes = kanjiForm.ke_inf;
+                  if (isStringArray(kanjiForm.ke_pri)) {
+                    form.commonness = kanjiForm.ke_pri;
+                    if (entryObj.isCommon === void 0)
+                      entryObj.isCommon = true;
+                  }
+                  entryObj.kanjiForms.push(form);
+                }
               }
-              if (form.form.length > 0) entryObj.kanjiForms.push(form);
             }
-          }
-          if (isValidArray(readings))
-            for (const reading of readings) {
-              const readingObj = {
-                ...isValidArrayWithFirstElement(reading.reb) && typeof reading.reb[0] === "string" ? { reading: reading.reb[0] } : { reading: "" }
-              };
-              if (readingObj.reading.length === 0)
-                throw new Error(`Invalid JMdict entry reading: ${entryObj.id}`);
-              if (isStringArray(reading.re_inf))
-                readingObj.notes = reading.re_inf;
-              if (isStringArray(reading.re_restr))
-                readingObj.kanjiFormRestrictions = reading.re_restr;
-              if (isStringArray(reading.re_pri)) {
-                readingObj.commonness = reading.re_pri;
-                if (entryObj.isCommon === void 0) entryObj.isCommon = true;
+            if (isValidArray(readings))
+              for (const reading of readings) {
+                const readingObj = {
+                  reading: reading.reb[0]
+                };
+                if (typeof readingObj.reading === "string") {
+                  if (isStringArray(reading.re_inf))
+                    readingObj.notes = reading.re_inf;
+                  if (isStringArray(reading.re_restr))
+                    readingObj.kanjiFormRestrictions = reading.re_restr;
+                  if (isStringArray(reading.re_pri)) {
+                    readingObj.commonness = reading.re_pri;
+                    if (entryObj.isCommon === void 0)
+                      entryObj.isCommon = true;
+                  }
+                  entryObj.readings.push(readingObj);
+                }
+              }
+            if (isValidArray(meanings)) {
+              let usuallyInKanaMeanings = 0;
+              for (const meaning of meanings) {
+                const meaningObj = {};
+                if (isStringArray(meaning.pos))
+                  meaningObj.partOfSpeech = meaning.pos;
+                if (isValidArray(meaning.gloss)) {
+                  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"))
+                      meaningObj.translations.push({
+                        translation: gloss._,
+                        type: gloss.$.g_type
+                      });
+                }
+                if (isStringArray(meaning.xref))
+                  meaningObj.references = meaning.xref;
+                if (isStringArray(meaning.stagk))
+                  meaningObj.kanjiFormRestrictions = meaning.stagk;
+                if (isStringArray(meaning.stagr))
+                  meaningObj.readingRestrictions = meaning.stagr;
+                if (isStringArray(meaning.ant))
+                  meaningObj.antonyms = meaning.ant;
+                if (isStringArray(meaning.field))
+                  meaningObj.fields = meaning.field;
+                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"
+                  ))
+                    usuallyInKanaMeanings++;
+                }
+                if (isStringArray(meaning.dial))
+                  meaningObj.dialects = meaning.dial;
+                if (meaningObj.partOfSpeech && meaningObj.partOfSpeech.length > 0)
+                  entryObj.meanings.push(meaningObj);
               }
-              if (readingObj.reading.length > 0)
-                entryObj.readings.push(readingObj);
+              if (entryObj.meanings.length === usuallyInKanaMeanings)
+                entryObj.usuallyInKana = true;
             }
-          if (isValidArray(meanings)) {
-            let usuallyInKanaMeanings = 0;
-            for (const meaning of meanings) {
-              const meaningObj = {};
-              if (isStringArray(meaning.pos))
-                meaningObj.partOfSpeech = meaning.pos;
-              if (isValidArray(meaning.gloss)) {
-                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"))
-                    meaningObj.translations.push({
-                      translation: gloss._,
-                      type: gloss.$.g_type
-                    });
+            if (examples) {
+              const readings2 = new Set(
+                entryObj.readings.filter(
+                  (reading) => reading.notes === void 0 || !reading.notes.some(
+                    (note) => notSearchedForms.has(note)
+                  ) || reading.commonness
+                ).map((reading) => reading.reading)
+              );
+              const kanjiForms2 = entryObj.kanjiForms ? new Set(
+                entryObj.kanjiForms.map(
+                  (kanjiForm) => kanjiForm.form
+                )
+              ) : void 0;
+              let existsExample = false;
+              if (kanjiForms2 && kanjiForms2.size > 0 && tanakaParts) {
+                for (const kf of kanjiForms2)
+                  if (tanakaParts.has(kf)) {
+                    existsExample = true;
+                    break;
+                  }
               }
-              if (isStringArray(meaning.xref))
-                meaningObj.references = meaning.xref;
-              if (isStringArray(meaning.stagk))
-                meaningObj.kanjiFormRestrictions = meaning.stagk;
-              if (isStringArray(meaning.stagr))
-                meaningObj.readingRestrictions = meaning.stagr;
-              if (isStringArray(meaning.ant)) meaningObj.antonyms = meaning.ant;
-              if (isStringArray(meaning.field))
-                meaningObj.fields = meaning.field;
-              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"
-                ))
-                  usuallyInKanaMeanings++;
+              if (!existsExample && readings2.size > 0 && tanakaParts) {
+                for (const r of readings2)
+                  if (tanakaParts.has(r)) {
+                    existsExample = true;
+                    break;
+                  }
               }
-              if (isStringArray(meaning.dial))
-                meaningObj.dialects = meaning.dial;
-              if (meaningObj.partOfSpeech && meaningObj.partOfSpeech.length > 0 || meaningObj.translations)
-                entryObj.meanings.push(meaningObj);
-            }
-            if (entryObj.meanings.length === usuallyInKanaMeanings)
-              entryObj.usuallyInKana = true;
-          }
-          if (examples) {
-            const readings2 = new Set(
-              entryObj.readings.filter(
-                (reading) => reading.notes === void 0 || !reading.notes.some(
-                  (note) => notSearchedForms.has(note)
-                ) || reading.commonness
-              ).map((reading) => reading.reading)
-            );
-            const kanjiForms2 = entryObj.kanjiForms ? new Set(
-              entryObj.kanjiForms.map(
-                (kanjiForm) => kanjiForm.form
-              )
-            ) : void 0;
-            let existsExample = false;
-            if (kanjiForms2 && kanjiForms2.size > 0 && tanakaParts) {
-              for (const kf of kanjiForms2)
-                if (tanakaParts.has(kf)) {
-                  existsExample = true;
-                  break;
-                }
-            }
-            if (!existsExample && readings2.size > 0 && tanakaParts) {
-              for (const r of readings2)
-                if (tanakaParts.has(r)) {
-                  existsExample = true;
-                  break;
-                }
+              if (tanakaParts && tanakaParts.has(entryObj.id))
+                existsExample = true;
+              if (existsExample) entryObj.hasPhrases = true;
             }
-            if (!existsExample && tanakaParts && tanakaParts.has(entryObj.id))
-              existsExample = true;
-            if (existsExample) entryObj.hasPhrases = true;
+            if (entryObj.id.length > 0 && entryObj.readings.length > 0 && entryObj.meanings.length > 0)
+              dict.push(entryObj);
           }
-          if (entryObj.id.length > 0 && entryObj.readings.length > 0 && entryObj.meanings.length > 0)
-            dict.push(entryObj);
         }
-    });
-    return dict;
-  } catch (err) {
-    throw err;
-  }
+    }
+  });
+  return dict;
 }
 function convertKanjiDic(xmlString) {
-  try {
-    const dictParsed = import_libxmljs2.default.parseXml(xmlString, {
-      dtdvalid: true,
-      nonet: false,
-      noent: true,
-      recover: false
-    });
-    const dict = [];
-    import_xml2js.default.parseString(dictParsed, (err, result) => {
-      if (err) throw err;
+  const dictParsed = import_libxmljs2.default.parseXml(xmlString, {
+    dtdvalid: true,
+    nonet: false,
+    noent: true,
+    recover: false
+  });
+  const dict = [];
+  import_xml2js.default.parseString(dictParsed, (err, result) => {
+    if (err === null) {
       if (result.kanjidic2 && typeof result.kanjidic2 === "object" && isValidArray(result.kanjidic2.character))
         for (const entry of result.kanjidic2.character) {
           const kanjiObj = {
-            ...isValidArrayWithFirstElement(entry.literal) && typeof entry.literal[0] === "string" ? { kanji: entry.literal[0] } : { kanji: "" },
-            misc: {
-              strokeNumber: ""
-            },
-            readingMeaning: []
+            kanji: entry.literal[0]
           };
-          if (kanjiObj.kanji.length === 0)
-            throw new Error("Invalid KANJIDIC entry");
-          if (isValidArrayWithFirstElement(entry.misc) && typeof entry.misc[0] === "object") {
-            const misc = entry.misc[0];
-            kanjiObj.misc = {
-              ...isValidArrayWithFirstElement(misc.stroke_count) && typeof misc.stroke_count[0] === "string" ? { strokeNumber: misc.stroke_count[0] } : { strokeNumber: "" }
-            };
-            if (kanjiObj.misc.strokeNumber.length === 0)
-              throw new Error(`Invalid KANJIDIC entry: ${kanjiObj.kanji}`);
-            if (isValidArrayWithFirstElement(misc.grade) && typeof misc.grade[0] === "string")
-              kanjiObj.misc.grade = misc.grade[0];
-            if (isValidArrayWithFirstElement(misc.freq) && typeof misc.freq[0] === "string")
-              kanjiObj.misc.frequency = misc.freq[0];
-            if (isValidArrayWithFirstElement(misc.jlpt) && typeof misc.jlpt[0] === "string" && ["5", "4", "3", "2", "1"].includes(misc.jlpt[0]))
-              kanjiObj.misc.jlpt = `N${misc.jlpt[0]}`;
-          }
-          if (isValidArray(entry.reading_meaning))
-            for (const rm of entry.reading_meaning) {
-              const rmObj = { groups: [] };
-              if (isValidArray(rm.rmgroup))
-                for (const group of rm.rmgroup) {
-                  const groupObj = {
-                    readings: [],
-                    meanings: []
-                  };
-                  if (isValidArray(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"))
-                        groupObj.readings.push({
-                          reading: reading._,
-                          type: reading.$.r_type
-                        });
-                  }
-                  if (isValidArray(group.meaning)) {
-                    for (const meaning of group.meaning)
-                      if (typeof meaning === "string") {
-                        if (kanjiObj.isKokuji === void 0 && meaning === "(kokuji)")
-                          kanjiObj.isKokuji = true;
-                        groupObj.meanings.push(meaning);
-                      }
+          if (typeof kanjiObj.kanji === "string" && kanjiObj.kanji.length === 1) {
+            if (isValidArrayWithFirstElement(entry.misc) && typeof entry.misc[0] === "object") {
+              const misc = entry.misc[0];
+              kanjiObj.misc = {};
+              if (isValidArrayWithFirstElement(misc.stroke_count) && typeof misc.stroke_count[0] === "string")
+                kanjiObj.misc.strokeNumber = misc.stroke_count[0];
+              if (isValidArrayWithFirstElement(misc.grade) && typeof misc.grade[0] === "string")
+                kanjiObj.misc.grade = misc.grade[0];
+              if (isValidArrayWithFirstElement(misc.freq) && typeof misc.freq[0] === "string")
+                kanjiObj.misc.frequency = misc.freq[0];
+              if (isValidArrayWithFirstElement(misc.jlpt) && typeof misc.jlpt[0] === "string" && ["5", "4", "3", "2", "1"].includes(misc.jlpt[0]))
+                kanjiObj.misc.jlpt = `N${misc.jlpt[0]}`;
+            }
+            if (isValidArray(entry.reading_meaning))
+              for (const rm of entry.reading_meaning) {
+                const rmObj = { groups: [] };
+                if (isValidArray(rm.rmgroup))
+                  for (const group of rm.rmgroup) {
+                    const groupObj = {
+                      readings: [],
+                      meanings: []
+                    };
+                    if (isValidArray(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"))
+                          groupObj.readings.push({
+                            reading: reading._,
+                            type: reading.$.r_type
+                          });
+                    }
+                    if (isValidArray(group.meaning)) {
+                      for (const meaning of group.meaning)
+                        if (typeof meaning === "string") {
+                          if (kanjiObj.isKokuji === void 0 && meaning === "(kokuji)")
+                            kanjiObj.isKokuji = true;
+                          groupObj.meanings.push(meaning);
+                        }
+                    }
+                    if (groupObj.readings.length > 0 || groupObj.meanings.length > 0) {
+                      if (groupObj.readings.length === 0)
+                        delete groupObj.readings;
+                      if (groupObj.meanings.length === 0)
+                        delete groupObj.meanings;
+                      rmObj.groups.push(groupObj);
+                    }
                   }
-                  if (groupObj.readings.length > 0 || groupObj.meanings.length > 0)
-                    rmObj.groups.push(groupObj);
+                if (isStringArray(rm.nanori) && rm.nanori.length > 0)
+                  rmObj.nanori = rm.nanori;
+                if (rmObj.groups.length > 0 || rmObj.nanori) {
+                  if (kanjiObj.readingMeaning === void 0)
+                    kanjiObj.readingMeaning = [];
+                  kanjiObj.readingMeaning.push(rmObj);
                 }
-              if (isStringArray(rm.nanori)) rmObj.nanori = rm.nanori;
-              if (rmObj.groups.length > 0 && kanjiObj.readingMeaning)
-                kanjiObj.readingMeaning.push(rmObj);
-            }
-          if (kanjiObj.readingMeaning && kanjiObj.readingMeaning.length === 0)
-            delete kanjiObj.readingMeaning;
-          if (kanjiObj.kanji.length === 1 && kanjiObj.misc && kanjiObj.misc.strokeNumber.length > 0)
+              }
             dict.push(kanjiObj);
+          }
         }
-    });
-    return dict;
-  } catch (err) {
-    throw err;
-  }
+    }
+  });
+  return dict;
 }
-async function convertTanakaCorpus(tanakaString, generateFurigana) {
-  return await new Promise(
-    async (resolve, reject) => {
-      try {
-        const tanakaArray = [];
-        const tanakaParsed = tanakaString.split("\n");
-        const kuroshiro = generateFurigana === true ? new Kuroshiro.default() : null;
-        if (kuroshiro !== null) await kuroshiro.init(new KuromojiAnalyzer());
-        const convert = kuroshiro !== null ? kuroshiro.convert.bind(kuroshiro) : null;
-        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: ")) {
-            a = a.replace("A: ", "");
-            b = b.replace("B: ", "");
-            const idMatch = regexps.tanakaID.exec(a);
-            if (!idMatch || !idMatch.groups || !idMatch.groups["id"])
-              throw new Error(`Invalid phrase ID for ${a}`);
-            const aParts = a.replace(regexps.tanakaID, "").split("	");
-            const bParts = b.split(" ").filter((part) => part.trim().length !== 0).map((part) => {
-              const partMatches = regexps.tanakaPart.exec(part);
-              if (!partMatches || !partMatches.groups || partMatches.length === 0)
-                throw new Error(`Invalid B part: ${part}`);
-              const baseForm = partMatches.groups["base"];
-              if (!baseForm)
-                throw new Error(`Invalid base form of B part: ${part}`);
+function convertTanakaCorpus(tanakaString) {
+  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: ")) {
+      a = a.replace("A: ", "");
+      b = b.replace("B: ", "");
+      const idMatch = regexps.tanakaID.exec(a);
+      if (idMatch && idMatch.groups && idMatch.groups["id"]) {
+        const aParts = a.replace(regexps.tanakaID, "").split("	");
+        const bRawParts = b.split(" ").filter((part) => part.trim().length !== 0);
+        const bParts = [];
+        for (const part of bRawParts) {
+          const partMatches = regexps.tanakaPart.exec(part);
+          if (partMatches && partMatches.groups && partMatches.length > 0) {
+            const baseForm = partMatches.groups["base"];
+            if (baseForm) {
               const examplePart = { baseForm };
               const reading = partMatches.groups["reading"];
               const glossNumber = partMatches.groups["glossnum"];
@@ -1517,9 +1513,8 @@ async function convertTanakaCorpus(tanakaString, generateFurigana) {
               if (reading)
                 if (regexps.tanakaReferenceID.test(reading)) {
                   const referenceID = regexps.tanakaReferenceID.exec(reading);
-                  if (!referenceID || !referenceID.groups || !referenceID.groups["entryid"])
-                    throw new Error(`Invalid reference ID: ${reading}`);
-                  examplePart.referenceID = referenceID.groups["entryid"];
+                  if (referenceID && referenceID.groups && referenceID.groups["entryid"])
+                    examplePart.referenceID = referenceID.groups["entryid"];
                 } else examplePart.reading = reading;
               if (glossNumber)
                 examplePart.glossNumber = glossNumber.startsWith("0") ? Number.parseInt(glossNumber.substring(1)) : Number.parseInt(glossNumber);
@@ -1528,50 +1523,60 @@ async function convertTanakaCorpus(tanakaString, generateFurigana) {
                 examplePart.edited = true;
                 examplePart.baseForm = examplePart.baseForm.replace("~", "");
               }
-              return examplePart;
-            });
-            const phrase = aParts[0];
-            const translation = aParts[1];
-            if (phrase && translation) {
-              let furigana = void 0;
-              if (convert !== null && !phrase.includes("\u30FB"))
-                furigana = await convert(phrase, {
-                  to: "hiragana",
-                  mode: "furigana"
-                });
-              tanakaArray.push({
-                id: idMatch.groups["id"].trim(),
-                phrase: phrase.trim(),
-                translation: translation.trim(),
-                parts: bParts,
-                ...furigana ? { furigana } : {}
-              });
+              bParts.push(examplePart);
             }
           }
         }
-        tanakaParsed.length = 0;
-        resolve(tanakaArray);
-      } catch (err) {
-        reject(err);
+        const phrase = aParts[0];
+        const translation = aParts[1];
+        if (phrase && translation)
+          tanakaArray.push({
+            id: idMatch.groups["id"].trim(),
+            phrase: phrase.trim(),
+            translation: translation.trim(),
+            parts: bParts
+          });
       }
     }
+  }
+  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;
+        })
+      );
+      resolve(tanakaArray);
+    }
   );
 }
 function convertRadkFile(radkBuffer, kanjiDic) {
-  try {
-    const fileParsed = import_iconv_lite.default.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) continue;
-      if (line.startsWith("$ ")) {
-        const radical = {
-          radical: line.charAt(2).trim(),
-          strokes: line.substring(4).trim()
-        };
-        let j = i + 1;
-        let kanjiLine = fileParsed[j];
-        if (!kanjiLine) continue;
+  const fileParsed = import_iconv_lite.default.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("$ ")) {
+      const radical = {
+        radical: line.charAt(2).trim(),
+        strokes: line.substring(4).trim()
+      };
+      let j = i + 1;
+      let kanjiLine = fileParsed[j];
+      if (kanjiLine) {
         const kanjiList = [];
         while (kanjiLine && !kanjiLine.startsWith("$ ")) {
           const kanjis = kanjiLine.split("");
@@ -1579,8 +1584,9 @@ function convertRadkFile(radkBuffer, kanjiDic) {
             const foundKanji = kanjiDic.find(
               (dictKanji) => dictKanji.kanji === kanji
             );
-            if (foundKanji) kanjiList.push(foundKanji);
-            else kanjiList.push({ kanji });
+            let kanjiObj = { kanji };
+            if (foundKanji) kanjiObj = foundKanji;
+            kanjiList.push(kanjiObj);
           }
           j++;
           kanjiLine = fileParsed[j];
@@ -1592,133 +1598,116 @@ function convertRadkFile(radkBuffer, kanjiDic) {
           radicals.push(radical);
       }
     }
-    fileParsed.length = 0;
-    return radicals;
-  } catch (err) {
-    throw err;
   }
+  return radicals;
 }
 function convertKradFile(kradBuffer, kanjiDic, katakanaList) {
-  try {
-    const fileParsed = import_iconv_lite.default.decode(kradBuffer, "euc-jp").split("\n").filter((line) => !line.startsWith("#"));
-    const kanjiWithRadicals = [];
-    for (const line of fileParsed) {
-      if (line.length === 0) continue;
+  const fileParsed = import_iconv_lite.default.decode(kradBuffer, "euc-jp").split("\n").filter((line) => !line.startsWith("#"));
+  const kanjiWithRadicals = [];
+  for (const line of fileParsed) {
+    if (line.length > 0) {
       const split = line.split(" : ");
       const kanjiChar = split[0];
       const radicalsRow = split[1];
-      if (!kanjiChar || !radicalsRow) continue;
-      const kanji = {
-        ...kanjiChar && radicalsRow && kanjiChar.length === 1 && radicalsRow.length > 0 ? { kanji: kanjiChar } : { kanji: "" },
-        radicals: []
-      };
-      if (kanji.kanji.length === 1) {
-        const radicals = radicalsRow.split(" ");
-        for (const radical of radicals) {
-          let foundRadical = kanjiDic.find(
-            (dictKanji) => dictKanji.kanji === radical
-          );
-          if (!foundRadical) {
-            const katakanaChar = katakanaList.find(
-              (kana) => kana.kana === radical
+      if (kanjiChar && radicalsRow) {
+        const kanji = {
+          kanji: kanjiChar,
+          radicals: []
+        };
+        if (kanji.kanji.length === 1) {
+          const radicals = radicalsRow.split(" ");
+          for (const radical of radicals) {
+            const foundRadical = kanjiDic.find(
+              (dictKanji) => dictKanji.kanji === radical
             );
-            if (!katakanaChar) continue;
-            foundRadical = {
-              kanji: katakanaChar.kana,
-              readingMeaning: [
-                {
-                  groups: [
-                    {
-                      readings: [{ reading: katakanaChar.kana, type: "ja_on" }],
-                      meanings: [katakanaChar.reading]
-                    }
-                  ]
-                }
-              ]
-            };
+            let radicalObj = foundRadical != null ? foundRadical : { kanji: radical };
+            if (!foundRadical) {
+              const katakanaChar = katakanaList.find(
+                (kana) => kana.kana === radical
+              );
+              if (!katakanaChar) continue;
+              radicalObj = {
+                kanji: katakanaChar.kana,
+                readingMeaning: [
+                  {
+                    groups: [
+                      {
+                        readings: [
+                          { reading: katakanaChar.kana, type: "ja_on" }
+                        ],
+                        meanings: [katakanaChar.reading]
+                      }
+                    ]
+                  }
+                ]
+              };
+            }
+            kanji.radicals.push(radicalObj);
           }
-          kanji.radicals.push(foundRadical ? foundRadical : radical);
         }
+        if (kanji.kanji.length === 1 && kanji.radicals.length > 0)
+          kanjiWithRadicals.push(kanji);
       }
-      if (kanji.kanji.length === 1 && kanji.radicals.length > 0)
-        kanjiWithRadicals.push(kanji);
     }
-    fileParsed.length = 0;
-    return kanjiWithRadicals;
-  } catch (err) {
-    throw err;
   }
-}
-async function convertJawiktionary(stream) {
-  const rl = (0, import_readline.createInterface)({
-    input: stream,
-    crlfDelay: Infinity
-  });
-  let lineNumber = 0;
-  return await new Promise(
-    async (resolve, reject) => {
-      try {
-        const entries = [];
-        for await (const line of rl) {
-          lineNumber++;
-          let obj = void 0;
-          try {
-            obj = JSON.parse(line.trim());
-          } catch (err) {
-            rl.close();
-            throw new Error(
-              `Invalid JSONL at line ${lineNumber}: ${err.message}`
-            );
-          }
-          if (obj !== void 0 && obj !== null && typeof obj === "object" && obj.lang_code === "ja" && obj.lang === "\u65E5\u672C\u8A9E")
-            entries.push(obj);
-        }
-        rl.close();
-        stream.close();
-        stream.destroy();
-        resolve(entries);
-      } catch (err) {
-        reject(err);
-      }
-    }
-  );
+  return kanjiWithRadicals;
 }
 function mapEntry(entry) {
-  if (entry.word === void 0 || typeof entry.word !== "string")
-    throw new Error("Invalid ja.wiktionary entry");
   return {
     word: entry.word,
-    ...entry.pos_title && typeof entry.pos_title === "string" ? { pos_title: entry.pos_title } : {},
-    ...isValidArray(entry.senses) ? {
-      senses: entry.senses.filter(
-        (sense) => isValidArray(sense.form_of) && sense.form_of.every(
-          (form) => form.word && typeof form.word === "string"
-        ) || isStringArray(sense.glosses)
-      ).map((sense) => ({
-        ...sense.form_of ? {
-          form_of: sense.form_of.map((form) => ({
-            word: form.word
-          }))
-        } : {},
-        ...sense.glosses ? { glosses: sense.glosses } : {}
-      }))
-    } : {},
+    pos_title: entry.pos_title,
+    senses: entry.senses.filter(
+      (sense) => isValidArray(sense.form_of) && sense.form_of.every(
+        (form) => form.word && typeof form.word === "string"
+      ) || isStringArray(sense.glosses)
+    ).map((sense) => ({
+      ...sense.form_of ? {
+        form_of: sense.form_of.map((form) => ({
+          word: form.word
+        }))
+      } : {},
+      glosses: sense.glosses
+    })),
     ...isValidArray(entry.forms) && entry.forms.every((form) => typeof form.form === "string") ? { forms: entry.forms.map((form) => ({ form: form.form })) } : {}
   };
 }
+function convertJawiktionarySync(buffer) {
+  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 obj = JSON.parse(line);
+    if (obj && typeof obj === "object" && obj.lang_code === "ja" && obj.lang === "\u65E5\u672C\u8A9E")
+      entries.push(mapEntry(obj));
+  }
+  return entries;
+}
+async function convertJawiktionaryAsync(stream) {
+  return new Promise(
+    async (resolve) => {
+      const rl = (0, import_readline.createInterface)({
+        input: stream,
+        crlfDelay: Infinity
+      });
+      const entries = [];
+      for await (const line of rl) {
+        const obj = JSON.parse(line.trim());
+        if (obj && typeof obj === "object" && obj.lang_code === "ja" && obj.lang === "\u65E5\u672C\u8A9E")
+          entries.push(mapEntry(obj));
+      }
+      rl.close();
+      stream.close();
+      stream.destroy();
+      resolve(entries);
+    }
+  );
+}
 function parseEntry(entry, definitions, definitionMap) {
   if (isValidArray(entry.senses)) {
     for (const sense of entry.senses)
       if (isStringArray(sense.glosses)) {
-        let definition = "";
-        for (let i = 0; i < sense.glosses.length; i += 2) {
-          if (i !== 0) {
-            let prev = sense.glosses[i - 1];
-            let cur = sense.glosses[i];
-            if (prev && cur)
-              definition += `${prev}${!prev.endsWith("\u3002") ? "\u3002" : ""}${cur}`;
-          } else definition += sense.glosses[i];
-        }
+        const definition = sense.glosses.join("");
         if (!definitions.some((def) => def.definition === definition)) {
           if (!definitionMap.has(definition))
             definitionMap.set(definition, { count: 1 });
@@ -1728,262 +1717,216 @@ function parseEntry(entry, definitions, definitionMap) {
       }
   }
 }
-async function getWordDefinitions(entryList, jmDict, generateFurigana) {
-  return await new Promise(async (resolve, reject) => {
-    var _a, _b, _c, _d, _e;
-    try {
-      const entries = /* @__PURE__ */ new Map();
-      for (const entry of entryList) {
-        const ent = entries.get(entry.word);
-        if (ent) ent.push(mapEntry(entry));
-        else entries.set(entry.word, [mapEntry(entry)]);
-      }
-      const japaneseDefinitions = [];
-      const definitionMap = /* @__PURE__ */ new Map();
-      const validWords = [];
-      const validReadings = /* @__PURE__ */ new Set();
-      const validKanjiForms = /* @__PURE__ */ new Set();
-      for (const word of jmDict) {
-        let valid = false;
-        for (const r of word.readings)
-          if ((r.notes === void 0 || !r.notes.some((note) => notSearchedForms.has(note)) || r.commonness !== void 0) && !validReadings.has(r.reading)) {
-            validReadings.add(r.reading);
+function getWordDefinitions(entryList, jmDict) {
+  var _a, _b, _c, _d, _e;
+  const entries = /* @__PURE__ */ new Map();
+  for (const entry of entryList) {
+    const ent = entries.get(entry.word);
+    if (ent) ent.push(mapEntry(entry));
+    else entries.set(entry.word, [mapEntry(entry)]);
+  }
+  const japaneseDefinitions = [];
+  const definitionMap = /* @__PURE__ */ new Map();
+  const validWords = [];
+  const validReadings = /* @__PURE__ */ new Set();
+  const validKanjiForms = /* @__PURE__ */ new Set();
+  if (jmDict.length > 0)
+    for (const word of jmDict) {
+      let valid = false;
+      for (const r of word.readings)
+        if ((r.notes === void 0 || !r.notes.some((note) => notSearchedForms.has(note)) || r.commonness !== void 0) && !validReadings.has(r.reading)) {
+          validReadings.add(r.reading);
+          if (!valid) valid = true;
+        }
+      if (word.kanjiForms) {
+        for (const kf of word.kanjiForms)
+          if ((kf.notes === void 0 || !kf.notes.some((note) => notSearchedForms.has(note)) || kf.commonness !== void 0) && !validKanjiForms.has(kf.form)) {
+            validKanjiForms.add(kf.form);
             if (!valid) valid = true;
           }
-        if (word.kanjiForms) {
-          for (const kf of word.kanjiForms)
-            if ((kf.notes === void 0 || !kf.notes.some((note) => notSearchedForms.has(note)) || kf.commonness !== void 0) && !validKanjiForms.has(kf.form)) {
-              validKanjiForms.add(kf.form);
-              if (!valid) valid = true;
-            }
-        }
-        if (valid) validWords.push(word);
       }
-      const validTitleEntries = /* @__PURE__ */ new Map();
-      const entriesWithFormTitlesGlobal = /* @__PURE__ */ new Map();
-      const entriesWithFormsGlobal = /* @__PURE__ */ new Map();
-      const validFormOfEntries = /* @__PURE__ */ new Set();
-      const validGlossesEntries = /* @__PURE__ */ new Set();
-      const validFormsEntries = /* @__PURE__ */ new Set();
-      const ents = Array.from(entries.values()).flat();
-      for (const entry of ents) {
-        let valid = false;
-        if (validKanjiForms && validKanjiForms.has(entry.word)) {
-          valid = true;
-          if (isValidArray(entry.senses))
-            for (const sense of entry.senses) {
-              if (isValidArray(sense.form_of) && sense.form_of.some(
-                (form) => form.word && typeof form.word === "string" && validReadings.has(form.word)
-              ))
-                validFormOfEntries.add(entry.word);
-              else if (isStringArray(sense.glosses)) {
-                for (const gloss of sense.glosses) {
-                  let reading = void 0;
-                  if (gloss !== void 0) {
-                    if (gloss.trim().includes("\u306E\u6F22\u5B57\u8868\u8A18\u3002") || gloss.trim().includes("\u3092\u53C2\u7167\u3002")) {
-                      for (const r of validReadings)
-                        if (gloss.trim().includes(r)) {
-                          reading = r;
-                          break;
-                        }
+      if (valid) validWords.push(word);
+    }
+  const validTitleEntries = /* @__PURE__ */ new Map();
+  const entriesWithFormTitlesGlobal = /* @__PURE__ */ new Map();
+  const entriesWithFormsGlobal = /* @__PURE__ */ new Map();
+  const validFormOfEntries = /* @__PURE__ */ new Set();
+  const validGlossesEntries = /* @__PURE__ */ new Set();
+  const validFormsEntries = /* @__PURE__ */ new Set();
+  const ents = Array.from(entries.values()).flat();
+  for (const entry of ents) {
+    let valid = false;
+    if (validKanjiForms && validKanjiForms.has(entry.word)) {
+      valid = true;
+      if (isValidArray(entry.senses))
+        for (const sense of entry.senses) {
+          if (isValidArray(sense.form_of) && sense.form_of.some(
+            (form) => form.word && typeof form.word === "string" && validReadings.has(form.word)
+          ))
+            validFormOfEntries.add(entry.word);
+          else if (isStringArray(sense.glosses)) {
+            for (const gloss of sense.glosses) {
+              let reading = void 0;
+              if (gloss !== void 0) {
+                if (gloss.trim().includes("\u306E\u6F22\u5B57\u8868\u8A18\u3002") || gloss.trim().includes("\u3092\u53C2\u7167\u3002")) {
+                  for (const r of validReadings)
+                    if (gloss.trim().includes(r)) {
+                      reading = r;
+                      break;
                     }
-                  }
-                  if (reading) validGlossesEntries.add(entry.word);
                 }
               }
+              if (reading) validGlossesEntries.add(entry.word);
             }
-          if (isValidArray(entry.forms)) {
-            for (const form of entry.forms)
-              if (form.form && typeof form.form === "string" && validReadings.has(form.form))
-                validFormsEntries.add(entry.word);
           }
-        } else if (validReadings.has(entry.word)) {
-          valid = true;
-          const ftEntry = entriesWithFormTitlesGlobal.get(entry.word);
-          if (ftEntry) ftEntry.push(entry);
-          else entriesWithFormTitlesGlobal.set(entry.word, [entry]);
-        }
-        if (valid) {
-          const tEntry = validTitleEntries.get(entry.word);
-          if (tEntry) tEntry.push(entry);
-          else validTitleEntries.set(entry.word, [entry]);
-        }
-        if (isValidArray(entry.forms) && (validKanjiForms.has(entry.word) || validReadings.has(entry.word)) && entry.forms.some(
-          (form) => validKanjiForms.has(form.form) || validReadings.has(form.form)
-        )) {
-          const wfEntry = entriesWithFormsGlobal.get(entry.word);
-          if (wfEntry) wfEntry.push(entry);
-          else entriesWithFormsGlobal.set(entry.word, [entry]);
         }
+      if (isValidArray(entry.forms)) {
+        for (const form of entry.forms)
+          if (form.form && typeof form.form === "string" && validReadings.has(form.form))
+            validFormsEntries.add(entry.word);
       }
-      ents.length = 0;
-      const posMap = /* @__PURE__ */ new Map();
-      const vte = Array.from(
-        validTitleEntries.values()
-      ).flat();
-      const fge = Array.from(
-        entriesWithFormTitlesGlobal.values()
-      ).flat();
-      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 te of vte)
-          if (te.pos_title === pos || te.pos_title === "\u548C\u8A9E\u306E\u6F22\u5B57\u8868\u8A18") {
-            if (!posMap.has(pos)) posMap.set(pos, {});
-            const posEntries = posMap.get(pos);
-            if (posEntries.title === void 0)
-              posEntries.title = /* @__PURE__ */ new Map();
-            const entryList2 = posEntries.title.get(te.word);
-            if (entryList2) entryList2.push(te);
-            else posEntries.title.set(te.word, [te]);
-          }
-        for (const ft of fge)
-          if (ft.pos_title === pos) {
-            if (!posMap.has(pos)) posMap.set(pos, {});
-            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);
-            else posEntries.formTitle.set(ft.word, [ft]);
-          }
-        for (const wf of wfe)
-          if (wf.pos_title === pos) {
-            if (!posMap.has(pos)) posMap.set(pos, {});
-            const posEntries = posMap.get(pos);
-            if (posEntries.form === void 0)
-              posEntries.form = /* @__PURE__ */ new Map();
-            const entryList2 = posEntries.form.get(wf.word);
-            if (entryList2) entryList2.push(wf);
-            else posEntries.form.set(wf.word, [wf]);
-          }
+    } else if (validReadings.has(entry.word)) {
+      valid = true;
+      const ftEntry = entriesWithFormTitlesGlobal.get(entry.word);
+      if (ftEntry) ftEntry.push(entry);
+      else entriesWithFormTitlesGlobal.set(entry.word, [entry]);
+    }
+    if (valid) {
+      const tEntry = validTitleEntries.get(entry.word);
+      if (tEntry) tEntry.push(entry);
+      else validTitleEntries.set(entry.word, [entry]);
+    }
+    if (isValidArray(entry.forms) && (validKanjiForms.has(entry.word) || validReadings.has(entry.word)) && entry.forms.some(
+      (form) => validKanjiForms.has(form.form) || validReadings.has(form.form)
+    )) {
+      const wfEntry = entriesWithFormsGlobal.get(entry.word);
+      if (wfEntry) wfEntry.push(entry);
+      else entriesWithFormsGlobal.set(entry.word, [entry]);
+    }
+  }
+  ents.length = 0;
+  const posMap = /* @__PURE__ */ new Map();
+  const vte = Array.from(
+    validTitleEntries.values()
+  ).flat();
+  const fge = Array.from(
+    entriesWithFormTitlesGlobal.values()
+  ).flat();
+  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"
+  ]) {
+    if (!posMap.has(pos)) 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(
+          te.word
+        );
+        if (entryList2) entryList2.push(te);
+        else posEntries.title.set(te.word, [te]);
       }
-      vte.length = 0;
-      fge.length = 0;
-      wfe.length = 0;
-      const wordEntriesPairs = [];
-      for (const word of validWords) {
-        const poses = /* @__PURE__ */ new Set();
-        for (const m of word.meanings) {
-          if (m.partOfSpeech)
-            for (const note of m.partOfSpeech) {
-              const noteEntry = noteMap.get(note);
-              if (noteEntry && noteEntry.length === 3) {
-                const notePos = noteEntry[2];
-                if (Array.isArray(notePos))
-                  for (const pos of notePos) {
-                    if (!poses.has(pos)) poses.add(pos);
-                  }
-                else if (typeof notePos === "string" && !poses.has(notePos))
-                  poses.add(notePos);
-              }
-            }
-        }
-        const validWordReadings = new Set(
-          word.readings.filter(
-            (r) => r.notes === void 0 || !r.notes.some((note) => notSearchedForms.has(note)) || r.commonness !== void 0
-          ).map((r) => r.reading)
+    for (const ft of fge)
+      if (ft.pos_title === pos) {
+        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);
+        else posEntries.formTitle.set(ft.word, [ft]);
+      }
+    for (const wf of wfe)
+      if (wf.pos_title === pos) {
+        const posEntries = posMap.get(pos);
+        if (posEntries.form === void 0)
+          posEntries.form = /* @__PURE__ */ new Map();
+        const entryList2 = posEntries.form.get(
+          wf.word
         );
-        const validWordKanjiForms = word.kanjiForms ? new Set(
-          word.kanjiForms.filter(
-            (kf) => kf.notes === void 0 || !kf.notes.some(
-              (note) => notSearchedForms.has(note)
-            ) || kf.commonness !== void 0
-          ).map((kf) => kf.form)
-        ) : void 0;
-        const entriesWithTitles = [];
-        const entriesWithFormTitles = [];
-        const entriesWithForms = [];
-        if (poses.size > 0)
-          for (const pos of poses) {
-            const posEntries = posMap.get(pos);
-            if (posEntries) {
-              if (validWordKanjiForms && (posEntries.title || posEntries.form))
-                for (const kf of validWordKanjiForms) {
-                  const te = (_a = posEntries.title) == null ? void 0 : _a.get(kf);
-                  const fe = (_b = posEntries.form) == null ? void 0 : _b.get(kf);
-                  if (te)
-                    entriesWithTitles.push(
-                      ...te.filter(
-                        (ent) => validFormOfEntries.has(ent.word) || validGlossesEntries.has(ent.word) || validFormsEntries.has(ent.word)
-                      )
-                    );
-                  if (fe)
-                    entriesWithForms.push(
-                      ...fe.filter(
-                        (ent) => ent.forms && ent.forms.some(
-                          (form) => validWordKanjiForms.has(form.form) || validWordReadings.has(form.form)
-                        )
-                      )
-                    );
-                }
-              if (posEntries.title || posEntries.formTitle || posEntries.form)
-                for (const r of validWordReadings) {
-                  const te = (_c = posEntries.title) == null ? void 0 : _c.get(r);
-                  const fe = (_d = posEntries.form) == null ? void 0 : _d.get(r);
-                  const fte = (_e = posEntries.formTitle) == null ? void 0 : _e.get(r);
-                  if (te)
-                    entriesWithTitles.push(
-                      ...te.filter(
-                        (ent) => ent.forms && validWordKanjiForms && ent.forms.some(
-                          (form) => validWordKanjiForms.has(form.form)
-                        ) || validWordKanjiForms === void 0
-                      )
-                    );
-                  if (fe)
-                    entriesWithForms.push(
-                      ...fe.filter(
-                        (ent) => ent.forms && ent.forms.some(
-                          (form) => validWordKanjiForms && validWordKanjiForms.has(form.form) || validWordReadings.has(form.form)
-                        )
-                      )
-                    );
-                  if (fte) entriesWithFormTitles.push(...fte);
-                }
-            }
+        if (entryList2) entryList2.push(wf);
+        else posEntries.form.set(wf.word, [wf]);
+      }
+  }
+  vte.length = 0;
+  fge.length = 0;
+  wfe.length = 0;
+  const wordEntriesPairs = [];
+  for (const word of validWords) {
+    const poses = /* @__PURE__ */ new Set();
+    for (const m of word.meanings) {
+      if (m.partOfSpeech)
+        for (const note of m.partOfSpeech) {
+          const noteEntry = noteMap.get(note);
+          if (noteEntry && noteEntry.length === 3) {
+            const notePos = noteEntry[2];
+            if (Array.isArray(notePos))
+              for (const pos of notePos) {
+                if (!poses.has(pos)) poses.add(pos);
+              }
+            else if (typeof notePos === "string" && !poses.has(notePos))
+              poses.add(notePos);
           }
-        if (entriesWithTitles.length === 0 && entriesWithFormTitles.length === 0 && entriesWithForms.length === 0) {
+        }
+    }
+    const validWordReadings = new Set(
+      word.readings.filter(
+        (r) => r.notes === void 0 || !r.notes.some((note) => notSearchedForms.has(note)) || r.commonness !== void 0
+      ).map((r) => r.reading)
+    );
+    const validWordKanjiForms = word.kanjiForms ? new Set(
+      word.kanjiForms.filter(
+        (kf) => kf.notes === void 0 || !kf.notes.some((note) => notSearchedForms.has(note)) || kf.commonness !== void 0
+      ).map((kf) => kf.form)
+    ) : void 0;
+    const entriesWithTitles = [];
+    const entriesWithFormTitles = [];
+    const entriesWithForms = [];
+    if (poses.size > 0)
+      for (const pos of poses) {
+        const posEntries = posMap.get(pos);
+        if (posEntries) {
           if (validWordKanjiForms)
             for (const kf of validWordKanjiForms) {
-              const te = validTitleEntries.get(kf);
-              const fe = entriesWithFormsGlobal.get(kf);
+              const te = (_a = posEntries.title) == null ? void 0 : _a.get(kf);
+              const fe = (_b = posEntries.form) == null ? void 0 : _b.get(kf);
               if (te)
                 entriesWithTitles.push(
                   ...te.filter(
@@ -2000,9 +1943,9 @@ async function getWordDefinitions(entryList, jmDict, generateFurigana) {
                 );
             }
           for (const r of validWordReadings) {
-            const te = validTitleEntries.get(r);
-            const fe = entriesWithFormsGlobal.get(r);
-            const fte = entriesWithFormTitlesGlobal.get(r);
+            const te = (_c = posEntries.title) == null ? void 0 : _c.get(r);
+            const fe = (_d = posEntries.form) == null ? void 0 : _d.get(r);
+            const fte = (_e = posEntries.formTitle) == null ? void 0 : _e.get(r);
             if (te)
               entriesWithTitles.push(
                 ...te.filter(
@@ -2022,148 +1965,197 @@ async function getWordDefinitions(entryList, jmDict, generateFurigana) {
             if (fte) entriesWithFormTitles.push(...fte);
           }
         }
-        if (entriesWithTitles.length > 0 && (entriesWithFormTitles.length > 0 || entriesWithForms.length > 0))
-          wordEntriesPairs.push({
-            word,
-            readings: validWordReadings,
-            ...validWordKanjiForms ? { kanjiForms: validWordKanjiForms } : {},
-            entriesWithTitles,
-            entriesWithFormTitles,
-            entriesWithForms
-          });
       }
-      for (const pair of wordEntriesPairs) {
-        const definitions = [];
-        const kanjiFormEntries = [];
-        const readingWithFormsEntries = [];
-        const readingEntries = [];
-        const titleFormMap = /* @__PURE__ */ new Map();
-        const refsMap = /* @__PURE__ */ new Map();
-        const readingForms = /* @__PURE__ */ new Set();
-        for (const ent of pair.entriesWithTitles) {
-          const validFormOf = validFormOfEntries.has(ent.word);
-          const validGlosses = validGlossesEntries.has(ent.word);
-          const validForms = validFormsEntries.has(ent.word);
-          if (pair.kanjiForms && pair.kanjiForms.has(ent.word) && (validFormOf || validGlosses || validForms)) {
-            kanjiFormEntries.push(ent);
-            if ((validFormOf || validGlosses) && isValidArray(ent.senses))
-              for (const sense of ent.senses) {
-                if (validFormOf && isValidArray(sense.form_of)) {
-                  for (const form of sense.form_of)
-                    if (form.word && typeof form.word === "string" && pair.readings.has(form.word)) {
-                      const elem = titleFormMap.get(
-                        form.word
-                      );
-                      if (!elem)
-                        titleFormMap.set(
-                          form.word,
-                          /* @__PURE__ */ new Set([ent.word])
-                        );
-                      else elem.add(ent.word);
-                    }
-                } else if (validGlosses && isStringArray(sense.glosses)) {
-                  for (const gloss of sense.glosses) {
-                    let reading = void 0;
-                    if (gloss !== void 0) {
-                      if (gloss.trim().includes("\u306E\u6F22\u5B57\u8868\u8A18\u3002") || gloss.trim().includes("\u3092\u53C2\u7167\u3002")) {
-                        for (const r of pair.readings)
-                          if (gloss.trim().includes(r)) {
-                            reading = r;
-                            break;
-                          }
+    if (entriesWithTitles.length === 0 && entriesWithFormTitles.length === 0 && entriesWithForms.length === 0) {
+      if (validWordKanjiForms)
+        for (const kf of validWordKanjiForms) {
+          const te = validTitleEntries.get(kf);
+          const fe = entriesWithFormsGlobal.get(kf);
+          if (te)
+            entriesWithTitles.push(
+              ...te.filter(
+                (ent) => validFormOfEntries.has(ent.word) || validGlossesEntries.has(ent.word) || validFormsEntries.has(ent.word)
+              )
+            );
+          if (fe)
+            entriesWithForms.push(
+              ...fe.filter(
+                (ent) => ent.forms && ent.forms.some(
+                  (form) => validWordKanjiForms.has(form.form) || validWordReadings.has(form.form)
+                )
+              )
+            );
+        }
+      for (const r of validWordReadings) {
+        const te = validTitleEntries.get(r);
+        const fe = entriesWithFormsGlobal.get(r);
+        const fte = entriesWithFormTitlesGlobal.get(r);
+        if (te)
+          entriesWithTitles.push(
+            ...te.filter(
+              (ent) => ent.forms && validWordKanjiForms && ent.forms.some(
+                (form) => validWordKanjiForms.has(form.form)
+              ) || validWordKanjiForms === void 0
+            )
+          );
+        if (fe)
+          entriesWithForms.push(
+            ...fe.filter(
+              (ent) => ent.forms && ent.forms.some(
+                (form) => validWordKanjiForms && validWordKanjiForms.has(form.form) || validWordReadings.has(form.form)
+              )
+            )
+          );
+        if (fte) entriesWithFormTitles.push(...fte);
+      }
+    }
+    if (entriesWithTitles.length > 0 && (entriesWithFormTitles.length > 0 || entriesWithForms.length > 0))
+      wordEntriesPairs.push({
+        word,
+        readings: validWordReadings,
+        ...validWordKanjiForms ? { kanjiForms: validWordKanjiForms } : {},
+        entriesWithTitles,
+        entriesWithFormTitles,
+        entriesWithForms
+      });
+  }
+  for (const pair of wordEntriesPairs) {
+    const definitions = [];
+    const kanjiFormEntries = [];
+    const readingWithFormsEntries = [];
+    const readingEntries = [];
+    const titleFormMap = /* @__PURE__ */ new Map();
+    const refsMap = /* @__PURE__ */ new Map();
+    const readingForms = /* @__PURE__ */ new Set();
+    for (const ent of pair.entriesWithTitles) {
+      const validFormOf = validFormOfEntries.has(ent.word);
+      const validGlosses = validGlossesEntries.has(ent.word);
+      const validForms = validFormsEntries.has(ent.word);
+      if (pair.kanjiForms && pair.kanjiForms.has(ent.word) && (validFormOf || validGlosses || validForms)) {
+        kanjiFormEntries.push(ent);
+        if ((validFormOf || validGlosses) && isValidArray(ent.senses))
+          for (const sense of ent.senses) {
+            if (validFormOf && isValidArray(sense.form_of)) {
+              for (const form of sense.form_of)
+                if (form.word && typeof form.word === "string" && pair.readings.has(form.word)) {
+                  const elem = titleFormMap.get(
+                    form.word
+                  );
+                  if (!elem)
+                    titleFormMap.set(form.word, /* @__PURE__ */ new Set([ent.word]));
+                  else elem.add(ent.word);
+                }
+            } else if (validGlosses && isStringArray(sense.glosses)) {
+              for (const gloss of sense.glosses) {
+                let reading = void 0;
+                if (gloss !== void 0) {
+                  if (gloss.trim().includes("\u306E\u6F22\u5B57\u8868\u8A18\u3002") || gloss.trim().includes("\u3092\u53C2\u7167\u3002")) {
+                    for (const r of pair.readings)
+                      if (gloss.trim().includes(r)) {
+                        reading = r;
+                        break;
                       }
-                    }
-                    if (reading) {
-                      const elem = refsMap.get(reading);
-                      if (!elem)
-                        refsMap.set(reading, /* @__PURE__ */ new Set([ent.word]));
-                      else elem.add(ent.word);
-                    }
                   }
                 }
+                if (reading) {
+                  const elem = refsMap.get(reading);
+                  if (!elem) refsMap.set(reading, /* @__PURE__ */ new Set([ent.word]));
+                  else elem.add(ent.word);
+                }
               }
-            if (validForms && isValidArray(ent.forms)) {
-              for (const form of ent.forms)
-                if (form.form && typeof form.form === "string" && pair.readings.has(form.form))
-                  readingForms.add(form.form);
             }
-          } else if (pair.readings.has(ent.word) && isValidArray(ent.forms) && pair.kanjiForms && ent.forms.some((form) => pair.kanjiForms.has(form.form)))
-            readingWithFormsEntries.push(ent);
-          else 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.some((form) => elem.has(form.form)))
-            readingWithFormsEntries.push(entry);
-        }
-        for (const entry of pair.entriesWithFormTitles) {
-          if (readingForms.has(entry.word)) {
-            readingWithFormsEntries.push(entry);
-            continue;
           }
-          if (pair.kanjiForms) {
-            const ft = refsMap.get(entry.word);
-            if (ft && ft.intersection(pair.kanjiForms).size > 0)
-              readingWithFormsEntries.push(entry);
-          }
-        }
-        let parsedReadingWithFormsEntries = false;
-        for (const entry of kanjiFormEntries)
-          if (entry.pos_title === "\u548C\u8A9E\u306E\u6F22\u5B57\u8868\u8A18" && readingWithFormsEntries.length > 0) {
-            if (!parsedReadingWithFormsEntries)
-              parsedReadingWithFormsEntries = true;
-            for (const ref of readingWithFormsEntries)
-              parseEntry(ref, definitions, definitionMap);
-          } else parseEntry(entry, definitions, definitionMap);
-        if (!parsedReadingWithFormsEntries && readingWithFormsEntries.length > 0) {
-          parsedReadingWithFormsEntries = true;
-          for (const ref of readingWithFormsEntries)
-            parseEntry(ref, definitions, definitionMap);
+        if (validForms && isValidArray(ent.forms)) {
+          for (const form of ent.forms)
+            if (form.form && typeof form.form === "string" && pair.readings.has(form.form))
+              readingForms.add(form.form);
         }
-        if (readingEntries.length > 0)
-          for (const readingEntry of readingEntries)
-            parseEntry(readingEntry, definitions, definitionMap);
-        if (definitions.length > 0)
-          japaneseDefinitions.push({
-            wordID: pair.word.id,
-            definitions
-          });
+      } else if (pair.readings.has(ent.word) && isValidArray(ent.forms) && pair.kanjiForms && ent.forms.some((form) => pair.kanjiForms.has(form.form)))
+        readingWithFormsEntries.push(ent);
+      else 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.some((form) => elem.has(form.form)))
+        readingWithFormsEntries.push(entry);
+    }
+    for (const entry of pair.entriesWithFormTitles) {
+      if (readingForms.has(entry.word)) {
+        readingWithFormsEntries.push(entry);
+        continue;
       }
-      const kuroshiro = generateFurigana === true ? new Kuroshiro.default() : null;
-      if (kuroshiro !== null) await kuroshiro.init(new KuromojiAnalyzer());
-      const convert = kuroshiro !== null ? kuroshiro.convert.bind(kuroshiro) : null;
-      for (let i = 0; i < japaneseDefinitions.length; i++) {
-        const pair = japaneseDefinitions[i];
-        for (let j = 0; j < pair.definitions.length; j++) {
-          const defCount = definitionMap.get(
-            pair.definitions[j].definition
-          );
-          if (defCount && defCount.count > 1)
-            pair.definitions[j].mayNotBeAccurate = true;
-          if (convert !== null && !pair.definitions[j].definition.includes("\u30FB"))
-            pair.definitions[j].furigana = await convert(
-              pair.definitions[j].definition,
-              {
-                to: "hiragana",
-                mode: "furigana"
-              }
-            );
-        }
-        japaneseDefinitions[i] = pair;
+      if (pair.kanjiForms) {
+        const ft = refsMap.get(entry.word);
+        if (ft && !ft.isDisjointFrom(pair.kanjiForms))
+          readingWithFormsEntries.push(entry);
       }
-      resolve(japaneseDefinitions);
-    } catch (err) {
-      reject(err);
     }
+    let parsedReadingWithFormsEntries = false;
+    for (const entry of kanjiFormEntries)
+      if (entry.pos_title === "\u548C\u8A9E\u306E\u6F22\u5B57\u8868\u8A18" && readingWithFormsEntries.length > 0) {
+        if (!parsedReadingWithFormsEntries)
+          parsedReadingWithFormsEntries = true;
+        for (const ref of readingWithFormsEntries)
+          parseEntry(ref, definitions, definitionMap);
+      } else parseEntry(entry, definitions, definitionMap);
+    if (!parsedReadingWithFormsEntries && readingWithFormsEntries.length > 0) {
+      parsedReadingWithFormsEntries = true;
+      for (const ref of readingWithFormsEntries)
+        parseEntry(ref, definitions, definitionMap);
+    }
+    if (readingEntries.length > 0)
+      for (const readingEntry of readingEntries)
+        parseEntry(readingEntry, definitions, definitionMap);
+    if (definitions.length > 0)
+      japaneseDefinitions.push({
+        wordID: pair.word.id,
+        definitions
+      });
+  }
+  for (let i = 0; i < japaneseDefinitions.length; i++) {
+    const pair = japaneseDefinitions[i];
+    for (let j = 0; j < pair.definitions.length; j++) {
+      const defCount = definitionMap.get(
+        pair.definitions[j].definition
+      );
+      if (defCount && defCount.count > 1)
+        pair.definitions[j].mayNotBeAccurate = true;
+    }
+    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);
   });
 }
-function lookupWordNote(key, notes, tags, required, fallback) {
+function lookupWordNote(key, notes, tags) {
   const info = noteMap.get(key.toLowerCase());
   if (!info) {
-    if (required) throw new Error(`Invalid note info for ${key}`);
-    if (notes) notes.push(fallback != null ? fallback : key);
-    return { note: fallback != null ? fallback : key };
+    if (notes) notes.push(key);
+    return { note: key };
   }
   const tag = `word::${info[0]}`;
   if (tags && !tags.includes(tag)) tags.push(tag);
@@ -2174,69 +2166,65 @@ var wordAddNoteArray = (arr, cb) => {
   if (!arr) return;
   for (const v of arr) cb(v);
 };
-function getWord(dict, id, kanjiDic, examples, definitions, dictWord, noteTypeName, deckPath) {
-  try {
-    if (!dictWord && id && dict)
-      dictWord = dict.find((entry) => entry.id === id);
-    if (dictWord) {
-      const word = {
-        id: dictWord.id,
-        readings: [],
-        translations: [],
-        noteID: `word_${dictWord.id}`,
-        ...noteTypeName ? { noteTypeName } : {},
-        ...deckPath ? { deckPath } : {},
-        tags: []
-      };
-      if (dictWord.isCommon === true) {
-        word.common = true;
-        word.tags.push("word::common");
-      }
-      if (dictWord.kanjiForms)
-        word.kanjiForms = dictWord.kanjiForms.map(
-          (dictKanjiForm) => ({
-            kanjiForm: dictKanjiForm.form,
-            ...dictKanjiForm.notes ? {
-              notes: dictKanjiForm.notes.map((note) => {
-                var _a;
-                const noteAndTag = lookupWordNote(
-                  note,
-                  void 0,
-                  word.tags,
-                  false,
-                  note
-                );
-                return capitalizeString((_a = noteAndTag.note) != null ? _a : note);
-              })
-            } : {},
-            ...dictKanjiForm.commonness && dictKanjiForm.commonness.length > 0 ? { common: true } : {}
-          })
-        );
-      word.readings = dictWord.readings.map((dictReading) => ({
-        reading: dictReading.reading,
-        ...dictReading.kanjiFormRestrictions || dictReading.notes ? {
-          notes: [
-            ...dictReading.kanjiFormRestrictions ? dictReading.kanjiFormRestrictions.map(
-              (restriction) => `Reading restricted to ${restriction}`
-            ) : [],
-            ...dictReading.notes ? dictReading.notes.map((note) => {
-              var _a;
+function getWord(word, dict, kanjiDic, examples, definitions, noteTypeName, deckPath) {
+  var _a;
+  let dictWord = void 0;
+  if (typeof word === "string" && dict)
+    dictWord = dict.find((entry) => entry.id === word);
+  else if (typeof word === "object") dictWord = word;
+  if (dictWord) {
+    const word2 = {
+      id: dictWord.id,
+      readings: [],
+      translations: [],
+      noteID: `word_${dictWord.id}`,
+      noteTypeName,
+      deckPath,
+      tags: []
+    };
+    if (dictWord.isCommon === true) {
+      word2.common = true;
+      word2.tags.push("word::common");
+    }
+    if (dictWord.kanjiForms)
+      word2.kanjiForms = dictWord.kanjiForms.map(
+        (dictKanjiForm) => ({
+          kanjiForm: dictKanjiForm.form,
+          ...dictKanjiForm.notes ? {
+            notes: dictKanjiForm.notes.map((note) => {
               const noteAndTag = lookupWordNote(
                 note,
                 void 0,
-                word.tags,
-                false,
-                note
+                word2.tags
               );
-              return capitalizeString((_a = noteAndTag.note) != null ? _a : note);
-            }) : []
-          ]
-        } : {},
-        ...dictReading.commonness && dictReading.commonness.length > 0 ? { common: true } : {}
-      }));
-      word.translations = dictWord.meanings.map((dictMeaning) => {
-        if (!dictMeaning.translations)
-          throw new Error(`No translations for ${dictWord.id}`);
+              return capitalizeString(noteAndTag.note);
+            })
+          } : {},
+          ...dictKanjiForm.commonness && dictKanjiForm.commonness.length > 0 ? { common: true } : {}
+        })
+      );
+    word2.readings = dictWord.readings.map((dictReading) => ({
+      reading: dictReading.reading,
+      ...dictReading.kanjiFormRestrictions || dictReading.notes ? {
+        notes: [
+          ...dictReading.kanjiFormRestrictions ? dictReading.kanjiFormRestrictions.map(
+            (restriction) => `Reading restricted to ${restriction}`
+          ) : [],
+          ...dictReading.notes ? dictReading.notes.map((note) => {
+            const noteAndTag = lookupWordNote(
+              note,
+              void 0,
+              word2.tags
+            );
+            return capitalizeString(noteAndTag.note);
+          }) : []
+        ]
+      } : {},
+      ...dictReading.commonness && dictReading.commonness.length > 0 ? { common: true } : {}
+    }));
+    word2.translations = [];
+    for (const dictMeaning of dictWord.meanings)
+      if (dictMeaning.translations) {
         const translationTypes = [];
         const translations = dictMeaning.translations.map(
           (translation) => {
@@ -2244,13 +2232,13 @@ function getWord(dict, id, kanjiDic, examples, definitions, dictWord, noteTypeNa
             else {
               if (translation.type === "lit") {
                 translationTypes.push("Literal meaning");
-                word.tags.push("word::literal_meaning");
+                word2.tags.push("word::literal_meaning");
               } else if (translation.type === "expl") {
                 translationTypes.push("Explanation");
-                word.tags.push("word::explanation");
+                word2.tags.push("word::explanation");
               } else if (translation.type === "tm") {
                 translationTypes.push("Trademark");
-                word.tags.push("word::trademark");
+                word2.tags.push("word::trademark");
               }
               return translation.translation;
             }
@@ -2268,15 +2256,15 @@ function getWord(dict, id, kanjiDic, examples, definitions, dictWord, noteTypeNa
         for (const t of translationTypes) notes.push(t);
         wordAddNoteArray(
           dictMeaning.partOfSpeech,
-          (pos) => lookupWordNote(pos, notes, word.tags, true)
+          (pos) => lookupWordNote(pos, notes, word2.tags)
         );
         wordAddNoteArray(
           dictMeaning.fields,
-          (field) => lookupWordNote(field, notes, word.tags, false, field)
+          (field) => lookupWordNote(field, notes, word2.tags)
         );
         wordAddNoteArray(
           dictMeaning.dialects,
-          (dialect) => lookupWordNote(dialect, notes, word.tags, true)
+          (dialect) => lookupWordNote(dialect, notes, word2.tags)
         );
         wordAddNoteArray(
           dictMeaning.antonyms,
@@ -2288,64 +2276,64 @@ function getWord(dict, id, kanjiDic, examples, definitions, dictWord, noteTypeNa
         );
         wordAddNoteArray(
           dictMeaning.info,
-          (info) => lookupWordNote(info, notes, word.tags, false, info)
+          (info) => lookupWordNote(info, notes, word2.tags)
         );
         wordAddNoteArray(
           dictMeaning.misc,
-          (misc) => lookupWordNote(misc, notes, word.tags, false, misc)
+          (misc) => lookupWordNote(misc, notes, word2.tags)
         );
         for (let i = 0; i < notes.length; i++)
           notes[i] = capitalizeString(notes[i]);
-        return {
+        word2.translations.push({
           translation: translations.join("; "),
           notes
-        };
-      });
-      if (dictWord.usuallyInKana === true) {
-        word.usuallyInKana = true;
-        word.tags.push("word::usually_in_kana_for_all_senses");
+        });
       }
-      if (kanjiDic && word.kanjiForms) {
-        word.kanji = [];
-        for (const kanjiForm of word.kanjiForms)
-          for (const char of kanjiForm.kanjiForm) {
-            if (word.kanji.some((kanji) => kanji.kanji === char))
-              continue;
-            const dictKanji = kanjiDic.find(
-              (kanji) => kanji.kanji === char
-            );
-            if (dictKanji) {
-              const kanjiObj = getKanji(kanjiDic, void 0, dictKanji);
-              word.kanji.push({
-                kanji: kanjiObj.kanji,
-                ...kanjiObj.meanings ? { meanings: kanjiObj.meanings } : {}
-              });
-            }
-          }
-        if (word.kanji.length === 0) {
-          delete word.kanji;
-          word.tags.push("word::no_kanji");
+    if (dictWord.usuallyInKana === true) {
+      word2.usuallyInKana = true;
+      word2.tags.push("word::usually_in_kana_for_all_senses");
+    }
+    if (kanjiDic && word2.kanjiForms) {
+      const kanji = [];
+      for (const kanjiForm of word2.kanjiForms)
+        for (const char of kanjiForm.kanjiForm) {
+          if (!regexps.kanji.test(char) || kanji.some((kanji2) => kanji2.kanji === char))
+            continue;
+          const kanjiObj = getKanji(
+            char,
+            Array.isArray(kanjiDic) ? kanjiDic : kanjiDic.get(char)
+          );
+          if (kanjiObj)
+            kanji.push({
+              kanji: kanjiObj.kanji,
+              ...kanjiObj.meanings && kanjiObj.meanings.length > 0 ? { meanings: kanjiObj.meanings } : {}
+            });
         }
-      }
-      if (dictWord.hasPhrases === true && examples) {
+      if (kanji.length > 0) word2.kanji = kanji;
+    }
+    if (dictWord.hasPhrases === true && examples) {
+      const exampleList = Array.isArray(
+        examples
+      ) ? examples : examples.get(word2.id);
+      if (exampleList) {
         const readings = new Set(
-          word.readings.filter(
+          word2.readings.filter(
             (reading) => (reading.notes === void 0 || !reading.notes.some(
               (note) => notSearchedForms.has(note)
-            )) && (word.common === void 0 || reading.common === true)
+            )) && (word2.common === void 0 || reading.common === true)
           ).map((reading) => reading.reading)
         );
-        const existValidKf = word.kanjiForms && word.kanjiForms.length > 0 ? word.kanjiForms.some(
+        const existValidKf = word2.kanjiForms && word2.kanjiForms.length > 0 ? word2.kanjiForms.some(
           (kf) => (kf.notes === void 0 || !kf.notes.some(
             (note) => notSearchedForms.has(note)
-          )) && (word.common === void 0 || kf.common === true)
+          )) && (word2.common === void 0 || kf.common === true)
         ) : void 0;
-        const kanjiForms = word.kanjiForms && word.kanjiForms.length > 0 ? new Set(
-          word.kanjiForms.filter((kanjiForm) => {
+        const kanjiForms = word2.kanjiForms && word2.kanjiForms.length > 0 ? new Set(
+          word2.kanjiForms.filter((kanjiForm) => {
             if (existValidKf === true)
               return (kanjiForm.notes === void 0 || !kanjiForm.notes.some(
                 (note) => notSearchedForms.has(note)
-              )) && (word.common === void 0 || kanjiForm.common === true);
+              )) && (word2.common === void 0 || kanjiForm.common === true);
             else return true;
           }).map((kanjiForm) => kanjiForm.kanjiForm)
         ) : void 0;
@@ -2353,12 +2341,12 @@ function getWord(dict, id, kanjiDic, examples, definitions, dictWord, noteTypeNa
         const readingMatchingKanjiFormExamples = [];
         const readingExamples = [];
         const readingMatchingKanjiForms = /* @__PURE__ */ new Set();
-        for (const example of examples)
+        for (const example of exampleList)
           for (let i = 0; i < example.parts.length; i++) {
             const part = example.parts[i];
             const readingAsReadingMatch = part.reading !== void 0 && readings.has(part.reading);
             const readingAsInflectedFormMatch = part.inflectedForm !== void 0 && readings.has(part.inflectedForm);
-            const referenceIDMatch = part.referenceID !== void 0 && word.id !== void 0 && part.referenceID === word.id;
+            const referenceIDMatch = part.referenceID !== void 0 && word2.id !== void 0 && part.referenceID === word2.id;
             if (kanjiForms && kanjiForms.has(part.baseForm) || referenceIDMatch) {
               if (readingAsReadingMatch || readingAsInflectedFormMatch) {
                 readingMatchingKanjiFormExamples.push({
@@ -2384,7 +2372,7 @@ function getWord(dict, id, kanjiDic, examples, definitions, dictWord, noteTypeNa
           kanjiFormExamples = kanjiFormExamples.filter(
             (ex) => ex.form && readingMatchingKanjiForms.has(ex.form)
           );
-        const includeKanjiFormExamples = word.kanjiForms !== void 0;
+        const includeKanjiFormExamples = word2.kanjiForms !== void 0;
         let wordExamples = [
           ...includeKanjiFormExamples ? [...readingMatchingKanjiFormExamples, ...kanjiFormExamples] : [],
           ...!includeKanjiFormExamples ? readingExamples : []
@@ -2392,14 +2380,14 @@ function getWord(dict, id, kanjiDic, examples, definitions, dictWord, noteTypeNa
         readingMatchingKanjiForms.clear();
         const glossSpecificExamples = [];
         const seenPhrases = /* @__PURE__ */ new Set();
-        for (let i = 0; i < word.translations.length; i++) {
+        for (let i = 0; i < word2.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: word.id,
+                  wordId: word2.id,
                   glossNumber: i + 1
                 };
                 glossSpecificExamples.push(example);
@@ -2420,287 +2408,197 @@ function getWord(dict, id, kanjiDic, examples, definitions, dictWord, noteTypeNa
             ).slice(0, 5 - glossSpecificExamples.length)
           ];
         if (wordExamples.length > 0) {
-          word.phrases = (wordExamples.length > 5 ? wordExamples.slice(0, 5) : wordExamples).map((ex) => {
-            var _a;
+          word2.phrases = (wordExamples.length > 5 ? wordExamples.slice(0, 5) : wordExamples).map((ex) => {
+            var _a2;
             return {
-              phrase: (_a = ex.ex.furigana) != null ? _a : ex.ex.phrase,
+              phrase: (_a2 = ex.ex.furigana) != null ? _a2 : ex.ex.phrase,
               translation: ex.ex.translation,
               originalPhrase: ex.ex.phrase,
               ...ex.ex.glossNumber ? { glossNumber: ex.ex.glossNumber } : {}
             };
           });
-          word.tags.push("word::has_phrases");
+          word2.tags.push("word::has_phrases");
           if (glossSpecificExamples.length > 0)
-            word.tags.push("word::has_meaning-specific_phrases");
+            word2.tags.push("word::has_meaning-specific_phrases");
         }
       }
-      if (definitions) {
-        const pair = definitions.find(
-          (wdp) => wdp.wordID === word.id
-        );
-        if (pair) word.definitions = pair.definitions;
-      }
-      return word;
-    } else throw new Error(`Word${id ? ` ${id}` : ""} not found`);
-  } catch (err) {
-    throw err;
-  }
+    }
+    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];
+    }
+    return word2;
+  } else return void 0;
 }
-function getKanji(dict, kanjiChar, dictKanji, jmDict, svgList, noteTypeName, deckPath) {
+function getKanji(kanji, dict, jmDict, svgList, noteTypeName, deckPath) {
   var _a, _b, _c, _d, _e, _f, _g, _h, _i;
-  try {
-    if (!dictKanji && kanjiChar)
-      dictKanji = dict.find((entry) => entry.kanji === kanjiChar);
-    if (dictKanji) {
-      const kanji = {
-        kanji: dictKanji.kanji,
-        ...dictKanji.misc ? { 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 } : {}
-      };
-      if (dictKanji.readingMeaning) {
-        kanji.meanings = [];
-        kanji.nanori = [];
-        kanji.onyomi = [];
-        kanji.kunyomi = [];
-        for (const rm of dictKanji.readingMeaning) {
-          if (rm.nanori && rm.nanori.length > 0)
-            kanji.nanori.push(...rm.nanori);
+  let dictKanji = void 0;
+  if (typeof kanji === "string" && dict)
+    dictKanji = dict.find((entry) => entry.kanji === 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);
+        if (rm.groups)
           for (const group of rm.groups) {
-            kanji.onyomi.push(
-              ...group.readings.filter((reading) => reading.type === "ja_on").map((reading) => reading.reading)
-            );
-            kanji.kunyomi.push(
-              ...group.readings.filter(
-                (reading) => reading.type === "ja_kun"
-              ).map((reading) => reading.reading)
-            );
-            kanji.meanings.push(...group.meanings);
+            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 (kanji.meanings && kanji.meanings.length === 0)
-          delete kanji.meanings;
-        if (kanji.nanori && kanji.nanori.length === 0) delete kanji.nanori;
-        if (kanji.onyomi && kanji.onyomi.length === 0) delete kanji.onyomi;
-        if (kanji.kunyomi && kanji.kunyomi.length === 0) delete kanji.kunyomi;
       }
-      if (jmDict) {
-        let kanjiWords = jmDict.filter(
-          (word) => word.kanjiForms && word.kanjiForms[0].form.includes(kanji.kanji)
-        );
-        if (kanjiWords.length > 3) kanjiWords = kanjiWords.slice(0, 2);
-        if (kanjiWords.length > 0)
-          kanji.words = kanjiWords.map((word) => {
-            const wordObj = getWord(
-              void 0,
-              void 0,
-              void 0,
-              void 0,
-              void 0,
-              word,
-              void 0
-            );
-            if (!wordObj.translations)
-              throw new Error(`Invalid word: ${word.id}`);
-            const kanjiForm = wordObj.kanjiForms[0];
-            let reading = wordObj.readings.find(
-              (reading2) => reading2.notes && reading2.notes.some(
-                (note) => note.toLowerCase().startsWith("reading restricted to ") && note.endsWith(kanjiForm.kanjiForm)
-              )
-            );
-            let translation = wordObj.translations.find(
-              (translation2) => translation2.notes && translation2.notes.some(
-                (note) => note.toLowerCase().startsWith("meaning restricted to ") && (note.endsWith(kanjiForm.kanjiForm) || reading && note.endsWith(reading.reading))
-              )
-            );
-            if (!reading) reading = wordObj.readings[0];
-            if (!translation) translation = wordObj.translations[0];
-            return {
-              kanjiForms: [kanjiForm],
-              readings: [reading],
-              translations: [translation]
-            };
-          });
-        if (kanjiWords.length !== 3) {
-          const wordNumber = 3 - kanjiWords.length;
-          kanjiWords = jmDict.filter(
-            (word) => word.kanjiForms && word.kanjiForms.some(
-              (kanjiForm) => kanjiForm.form.includes(kanji.kanji)
-            )
-          ).map((word) => {
-            const wordObj = getWord(
-              void 0,
-              void 0,
-              void 0,
-              void 0,
-              void 0,
-              word,
-              void 0
-            );
-            if (!wordObj.translations)
-              throw new Error(`Invalid word: ${word.id}`);
-            const kanjiForm = wordObj.kanjiForms.find(
-              (kanjiForm2) => kanjiForm2.kanjiForm.includes(kanji.kanji)
-            );
-            if (!kanjiForm) throw new Error("Invalid kanji form");
-            let reading = wordObj.readings.find(
-              (reading2) => reading2.notes && reading2.notes.some(
-                (note) => note.toLowerCase().startsWith("reading restricted to ") && note.endsWith(kanjiForm.kanjiForm)
-              )
-            );
-            let translation = wordObj.translations.find(
-              (translation2) => translation2.notes && translation2.notes.some(
-                (note) => note.toLowerCase().startsWith("meaning restricted to ") && (note.endsWith(kanjiForm.kanjiForm) || reading && note.endsWith(reading.reading))
-              )
-            );
-            if (!reading) reading = wordObj.readings[0];
-            if (!translation) translation = wordObj.translations[0];
-            return {
-              kanjiForms: [kanjiForm],
-              readings: [reading],
-              translations: [translation]
-            };
+      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) {
+      const kanjiWords = (_a = Array.isArray(jmDict) ? jmDict : jmDict.get(kanji2.kanji)) == null ? void 0 : _a.filter(
+        (word) => word.kanjiForms && word.kanjiForms[0].form.includes(kanji2.kanji)
+      ).slice(0, 3);
+      if (kanjiWords) {
+        const validWords = [];
+        for (const word of kanjiWords) {
+          const translation = word.meanings[0].translations[0];
+          const translationText = typeof translation === "object" ? translation.translation : translation;
+          validWords.push({
+            kanjiForms: [{ kanjiForm: word.kanjiForms[0].form }],
+            readings: [{ reading: word.readings[0].reading }],
+            translations: [{ translation: translationText }]
           });
-          if (kanjiWords.length > wordNumber)
-            kanjiWords = kanjiWords.slice(0, wordNumber - 1);
-          if (kanjiWords.length > 0)
-            if (kanji.words) kanji.words.push(...kanjiWords);
-            else kanji.words = kanjiWords;
         }
+        if (validWords.length > 0) kanji2.words = validWords;
       }
-      if (svgList) {
-        let codePoint = kanji.kanji.codePointAt(0);
-        if (codePoint !== void 0) {
-          codePoint = codePoint.toString(16);
-          const fileNames = [
-            `0${codePoint}.svg`,
-            `${codePoint}.svg`
-          ];
-          const svg = svgList.find(
-            (svgFile) => fileNames.includes(svgFile.toLowerCase())
-          );
-          if (svg) kanji.svg = svg;
-        }
-      }
-      kanji.tags = [];
-      if (dictKanji.isKokuji === true) {
-        kanji.kokuji = true;
-        kanji.tags.push("kanji::kokuji");
-        if (kanji.meanings)
-          kanji.meanings.splice(
-            kanji.meanings.findIndex(
-              (meaning) => meaning === "(kokuji)"
-            ),
-            1
-          );
+    }
+    if (svgList) {
+      let codePoint = kanji2.kanji.codePointAt(0);
+      if (codePoint !== void 0) {
+        codePoint = codePoint.toString(16);
+        const fileNames = [
+          `0${codePoint}.svg`,
+          `${codePoint}.svg`
+        ];
+        const svg = svgList.find(
+          (svgFile) => fileNames.includes(svgFile.toLowerCase())
+        );
+        if (svg) kanji2.svg = svg;
       }
-      kanji.tags.push(
-        `kanji::strokes::${(_a = kanji.strokes) != null ? _a : "unknown"}`,
-        ...kanji.frequency ? [`kanji::frequency::${kanji.frequency}`] : [],
-        ...kanji.grade ? [`kanji::grade::${kanji.grade}`] : [],
-        ...kanji.jlpt ? [`kanji::pre-2010_jlpt::${kanji.jlpt.toLowerCase()}`] : [],
-        `kanji::onyomi::${(_c = (_b = kanji.onyomi) == null ? void 0 : _b.length) != null ? _c : 0}`,
-        `kanji::kunyomi::${(_e = (_d = kanji.kunyomi) == null ? void 0 : _d.length) != null ? _e : 0}`,
-        `kanji::nanori::${(_g = (_f = kanji.nanori) == null ? void 0 : _f.length) != null ? _g : 0}`,
-        `kanji::words::${(_i = (_h = kanji.words) == null ? void 0 : _h.length) != null ? _i : 0}`,
-        ...kanji.svg ? ["kanji::has_svg"] : []
+    }
+    if (kanji2.tags && dictKanji.isKokuji === true) {
+      kanji2.kokuji = true;
+      kanji2.tags.push("kanji::kokuji");
+      if (kanji2.meanings)
+        kanji2.meanings.splice(
+          kanji2.meanings.findIndex((meaning) => meaning === "(kokuji)"),
+          1
+        );
+    }
+    if (kanji2.tags)
+      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::${(_c = (_b = kanji2.onyomi) == null ? void 0 : _b.length) != null ? _c : 0}`,
+        `kanji::kunyomi::${(_e = (_d = kanji2.kunyomi) == null ? void 0 : _d.length) != null ? _e : 0}`,
+        `kanji::nanori::${(_g = (_f = kanji2.nanori) == null ? void 0 : _f.length) != null ? _g : 0}`,
+        `kanji::words::${(_i = (_h = kanji2.words) == null ? void 0 : _h.length) != null ? _i : 0}`,
+        ...kanji2.svg ? ["kanji::has_svg"] : []
       );
-      return kanji;
-    } else
-      throw new Error(`Kanji not found${kanjiChar ? `: ${kanjiChar}` : ""}`);
-  } catch (err) {
-    throw err;
-  }
+    return kanji2;
+  } else return void 0;
 }
-function getKanjiExtended(info, dict, kanjiChar, dictKanji, useWords, jmDict, svgList, noteTypeName, deckPath) {
-  var _a, _b, _c, _d;
-  try {
-    const kanji = getKanji(
-      dict,
-      kanjiChar,
-      dictKanji,
-      jmDict,
-      svgList,
-      noteTypeName,
-      deckPath
-    );
-    if (info.components && info.components.length > 0)
-      kanji.components = info.components;
-    if (info.mnemonic && info.mnemonic.length > 0)
-      kanji.mnemonic = info.mnemonic;
-    if (useWords === true && info.words && info.words.length > 0)
-      kanji.words = info.words;
-    if (kanji.tags) {
-      kanji.tags.push(`kanji::components::${(_b = (_a = kanji.components) == null ? void 0 : _a.length) != null ? _b : 0}`);
-      if (kanji.mnemonic && kanji.mnemonic.length > 0)
-        kanji.tags.push("kanji::has_mnemonic");
-      if (useWords === true && kanji.words) {
-        if (!kanji.tags.some((tag, index) => {
-          var _a2, _b2;
-          if (tag.startsWith("kanji::words::")) {
-            kanji.tags.splice(
+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.tags) {
+      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) {
+            kanjiObj.tags.splice(
               index,
               1,
-              `kanji::words::${(_b2 = (_a2 = kanji.words) == null ? void 0 : _a2.length) != null ? _b2 : 0}`
+              `kanji::words::${kanjiObj.words.length}`
             );
-            return true;
-          } else return false;
-        }))
-          kanji.tags.push(`kanji::words::${(_d = (_c = kanji.words) == null ? void 0 : _c.length) != null ? _d : 0}`);
-      }
-    }
-    if (info.fromJpdb === true && (kanji.mnemonic || kanji.components || kanji.words && useWords === true))
-      kanji.source = `https://jpdb.io/kanji/${kanji.kanji}`;
-    return kanji;
-  } catch (err) {
-    throw err;
-  }
-}
-async function synthesizeSpeech(client, input, options) {
-  return await new Promise(
-    async (resolve, reject) => {
-      try {
-        const command = new import_client_polly.SynthesizeSpeechCommand({
-          Text: input,
-          ...options
+          }
         });
-        const response = await client.send(command);
-        const stream = response.AudioStream ? Buffer.from(await response.AudioStream.transformToByteArray()) : null;
-        resolve(stream);
-      } catch (err) {
-        reject(err);
-      }
     }
-  );
+    if (sourceURL && info.externalInfo === true && usedInfo)
+      kanjiObj.source = sourceURL;
+    return kanjiObj;
+  } else return void 0;
 }
 function isWord(entry) {
   return entry.translations !== void 0 && entry.readings !== void 0;
 }
 function isRadical(entry) {
-  return entry.radical !== void 0 && entry.reading !== void 0 && entry.meanings !== void 0;
+  return entry.radical !== void 0;
 }
 function isKanji(entry) {
   return entry.translations === void 0 && entry.readings === void 0 && entry.radical === void 0 && entry.kanji !== void 0;
 }
 function isKana(entry) {
-  return entry.kana !== void 0 && entry.reading !== void 0;
+  return entry.kana !== void 0;
 }
 function isGrammar(entry) {
-  return entry.point !== void 0 && entry.meaning !== void 0;
+  return entry.point !== void 0;
 }
 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>';
 function generateAnkiNote(entry) {
-  if (!entry.noteID) throw new Error("Invalid note ID");
   const fields = [];
   if (isWord(entry)) {
-    if (!entry.translations || entry.readings.length === 0)
-      throw new Error(`Invalid word: ${entry.noteID}`);
     const firstReading = createEntry(
       `<span class="word word-reading">${entry.readings[0].reading}${entry.readings[0].audio !== void 0 ? `<br>[sound:${entry.readings[0].audio}]` : ""}</span>`,
       entry.readings[0].notes
@@ -2757,7 +2655,7 @@ function generateAnkiNote(entry) {
         (definitionEntry) => {
           var _a;
           return 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">${(_a = definitionEntry.furigana) != null ? _a : definitionEntry.definition}</span></span>`
+            `<span class="word word-definition${definitionEntry.mayNotBeAccurate === true ? " mnba" : ""}"><span class="word word-definition-original">${definitionEntry.definition}</span><span class="word word-definition-furigana">${(_a = definitionEntry.furigana) != null ? _a : definitionEntry.definition}</span></span>`
           );
         }
       ).join("") : '<span class="word word-definition">(no definitions)</span>',
@@ -2798,7 +2696,7 @@ function generateAnkiNote(entry) {
       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>`
       ) : '<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="kanji kanji-source">(no sources)</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.tags.map(
           (tag) => tag.trim().toLowerCase().replaceAll(" ", "::")
@@ -2836,11 +2734,9 @@ function generateAnkiNote(entry) {
       entry.mnemonic ? 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.filter(
-        (word) => word.translations && word.translations.length > 0
-      ).map(
+      entry.words ? entry.words.map(
         (word) => createEntry(
-          `<span class="kanji kanji-words">${word.kanjiForms && word.kanjiForms.length > 0 ? word.kanjiForms[0].kanjiForm : "(no kanji form)"} / ${word.readings[0].reading} - ${word.translations[0].translation}</span>`
+          `<span class="kanji kanji-words">${word.kanjiForms[0].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(
@@ -2898,48 +2794,85 @@ function generateAnkiNote(entry) {
         ).join(" ")
       ] : []
     );
-  if (fields.length > 0)
-    return fields.map((field) => field.replaceAll("\n", "<br>"));
-  else throw new Error("Invalid entry");
+  return fields.map((field) => field.replaceAll("\n", "<br>"));
 }
-function generateAnkiNotesFile(list) {
+function generateAnkiNotesFile(list, defaultNoteInfo) {
+  const headers = [noteHeaderKeys.separator, noteHeaderKeys.html];
+  let ankiNotes = "";
   if (list.length > 0) {
-    const headers = [
-      "#separator:tab",
-      "#html:true",
-      "#guid column:1",
-      "#notetype column:2",
-      "#deck column:3"
-    ];
-    const ankiNotes = list.filter((result) => result.doNotCreateNote === void 0).map((result) => {
-      if (!result.noteID || !result.noteTypeName || !result.deckPath)
-        throw new Error("Invalid result");
+    if (defaultNoteInfo === void 0) defaultNoteInfo = {};
+    const infoValues = Object.values(defaultNoteInfo);
+    let invalidList = false;
+    const firstEntry = list[0];
+    const firstEntryInfo = {
+      guid: typeof firstEntry.noteID,
+      noteType: typeof firstEntry.noteTypeName,
+      deckPath: typeof firstEntry.deckPath
+    };
+    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) {
+          invalidList = true;
+          break;
+        }
+    }
+    if (invalidList) throw new Error("Invalid result list");
+    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 (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 (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) {
+        headers.push(`${noteHeaderKeys.guid}:${++headerCount}`);
+        hasHeader.guid = true;
+      }
+      if (!hasHeader.noteType && result.noteTypeName) {
+        headers.push(`${noteHeaderKeys.notetype}:${++headerCount}`);
+        hasHeader.noteType = true;
+      }
+      if (!hasHeader.deckPath && result.deckPath) {
+        headers.push(`${noteHeaderKeys.deck}:${++headerCount}`);
+        hasHeader.deckPath = true;
+      }
       const note = generateAnkiNote(result);
-      if (headers.length === 5)
-        headers.push(`#tags column:${note.length + 3}
-`);
-      return `${result.noteID}	${result.noteTypeName}	${result.deckPath}	${note.join("	")}`;
+      if (!hasHeader.tags) {
+        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("	")}`;
     }).join("\n").trim();
-    if (ankiNotes.length === 0) throw new Error("Invalid list");
-    return `${headers.join("\n")}
+  }
+  return `${headers.join("\n")}
+
 ${ankiNotes}`;
-  } else throw new Error("No entries available for Anki notes creation");
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   capitalizeString,
   convertJMdict,
-  convertJawiktionary,
+  convertJawiktionaryAsync,
+  convertJawiktionarySync,
   convertKanjiDic,
   convertKradFile,
   convertRadkFile,
   convertTanakaCorpus,
+  convertTanakaCorpusWithFurigana,
   generateAnkiNote,
   generateAnkiNotesFile,
   getKanji,
   getKanjiExtended,
   getWord,
   getWordDefinitions,
+  getWordDefinitionsWithFurigana,
   isGrammar,
   isKana,
   isKanji,
@@ -2949,9 +2882,9 @@ ${ankiNotes}`;
   isValidArrayWithFirstElement,
   isWord,
   notSearchedForms,
+  noteHeaderKeys,
   noteMap,
   regexps,
-  shuffleArray,
-  synthesizeSpeech
+  shuffleArray
 });
 //# sourceMappingURL=index.cjs.js.map