henkan 2.0.4 → 2.2.0

package/dist/index.mjs

@@ -55,6 +55,9 @@ var noteMap = /* @__PURE__ */ new Map([
   ["tsugaru-ben", ["dialect::tsugaru-ben", "Dialect: Tsugaru-ben"]],
   ["aichi dialect", ["dialect::aichi", "Dialect: Aichi"]],
   ["tochigi dialect", ["dialect::tochigi", "Dialect: Tochigi"]],
+  ["lit", ["literal_meaning", "Literal meaning"]],
+  ["expl", ["explanation", "Explanation"]],
+  ["tm", ["trademark", "Trademark"]],
   ["adjective (keiyoushi)", ["adjective::i", "\u3044-adjective", "\u5F62\u5BB9\u8A5E"]],
   ["'taru' adjective", ["adjective::taru", "\u305F\u308B-adjective", "\u5F62\u5BB9\u52D5\u8A5E"]],
   [
@@ -1189,14 +1192,14 @@ var KuromojiAnalyzer = __require("kuroshiro-analyzer-kuromoji");
 function capitalizeString(value) {
   return value.charAt(0).toUpperCase() + value.slice(1);
 }
-function isValidArray(arg) {
-  return arg !== null && arg !== void 0 && Array.isArray(arg);
-}
 function isValidArrayWithFirstElement(arg) {
-  return arg !== null && arg !== void 0 && Array.isArray(arg) && arg[0] !== null && arg[0] !== void 0;
+  return Array.isArray(arg) && arg.length > 0;
 }
 function isStringArray(arg) {
-  return arg !== null && arg !== void 0 && Array.isArray(arg) && arg.every((element) => typeof element === "string");
+  return isValidArrayWithFirstElement(arg) && arg.every((element) => typeof element === "string");
+}
+function isObjectArray(arg) {
+  return isValidArrayWithFirstElement(arg) && arg.every((element) => typeof element === "object");
 }
 function shuffleArray(arr) {
   const a = arr.slice();
@@ -1208,6 +1211,37 @@ function shuffleArray(arr) {
   }
   return a;
 }
+function getValidForms(readings, kanjiForms, wordIsCommon) {
+  const kanjiFormRestrictions = /* @__PURE__ */ new Set();
+  const validReadings = readings.filter(
+    (reading) => {
+      if (reading.notes === void 0 || !reading.notes.some((note) => notSearchedForms.has(note))) {
+        if (reading.kanjiFormRestrictions) {
+          for (const kfr of reading.kanjiFormRestrictions)
+            kanjiFormRestrictions.add(kfr);
+          return true;
+        }
+        if (wordIsCommon === void 0 || reading.commonness !== void 0)
+          return true;
+      }
+      return false;
+    }
+  );
+  const existValidKf = kanjiForms ? kanjiForms.some(
+    (kf) => (kf.notes === void 0 || !kf.notes.some((note) => notSearchedForms.has(note))) && (wordIsCommon === void 0 || kf.commonness !== void 0) || kanjiFormRestrictions.has(kf.form)
+  ) : void 0;
+  const validKanjiForms = kanjiForms ? kanjiForms.filter((kanjiForm) => {
+    if (existValidKf === true)
+      return (kanjiForm.notes === void 0 || !kanjiForm.notes.some(
+        (note) => notSearchedForms.has(note)
+      )) && (wordIsCommon === void 0 || kanjiForm.commonness !== void 0) || kanjiFormRestrictions.has(kanjiForm.form);
+    else return true;
+  }) : void 0;
+  return {
+    readings: validReadings,
+    ...validKanjiForms ? { kanjiForms: validKanjiForms } : {}
+  };
+}
 function convertJMdict(xmlString, examples) {
   const dictParsed = libxml.parseXml(xmlString, {
     dtdvalid: true,
@@ -1216,144 +1250,116 @@ function convertJMdict(xmlString, examples) {
     recover: false
   });
   const dict = [];
-  xml.parseString(dictParsed, (err, result) => {
-    if (err === null) {
-      const tanakaParts = examples && examples.length > 0 ? new Set(
-        examples.map(
-          (example) => example.parts.map((part) => [
-            part.baseForm,
-            ...part.reading ? [part.reading] : [],
-            ...part.referenceID ? [part.referenceID] : []
-          ])
-        ).flat(2)
-      ) : void 0;
-      if (result.JMdict && typeof result.JMdict === "object" && isValidArray(result.JMdict.entry))
-        for (const entry of result.JMdict.entry) {
-          const entryObj = {
-            id: entry.ent_seq[0],
-            readings: [],
-            meanings: []
+  xml.parseString(dictParsed, (_err, result) => {
+    const tanakaParts = examples && examples.length > 0 ? new Set(
+      examples.flatMap(
+        (example) => example.parts.flatMap((part) => [
+          part.baseForm,
+          ...part.reading ? [part.reading] : [],
+          ...part.inflectedForm ? [part.inflectedForm] : [],
+          ...part.referenceID ? [part.referenceID] : []
+        ])
+      )
+    ) : void 0;
+    for (const entry of result.JMdict.entry) {
+      const entryObj = {
+        id: entry.ent_seq[0],
+        readings: [],
+        meanings: []
+      };
+      const kanjiForms = entry.k_ele;
+      const readings = entry.r_ele;
+      const meanings = entry.sense;
+      if (isObjectArray(kanjiForms)) {
+        entryObj.kanjiForms = [];
+        for (const kanjiForm of kanjiForms) {
+          const form = {
+            form: kanjiForm.keb[0]
           };
-          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 (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 (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 (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);
+        }
+      }
+      for (const reading of readings) {
+        const readingObj = {
+          reading: reading.reb[0]
+        };
+        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);
+      }
+      let usuallyInKanaMeanings = 0;
+      for (const meaning of meanings) {
+        const meaningObj = { partOfSpeech: [], translations: [] };
+        meaningObj.partOfSpeech = meaning.pos;
+        meaningObj.translations = [];
+        for (const gloss of meaning.gloss)
+          if (typeof gloss === "string") meaningObj.translations.push(gloss);
+          else if (typeof gloss === "object" && 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;
+        entryObj.meanings.push(meaningObj);
+      }
+      if (entryObj.meanings.length === usuallyInKanaMeanings)
+        entryObj.usuallyInKana = true;
+      if (examples) {
+        let existsExample = false;
+        if (tanakaParts && tanakaParts.has(entryObj.id)) existsExample = true;
+        if (!existsExample) {
+          const rkf = getValidForms(
+            entryObj.readings,
+            entryObj.kanjiForms,
+            entryObj.isCommon
+          );
+          const readings2 = new Set(
+            rkf.readings.map((r) => r.reading)
+          );
+          const kanjiForms2 = rkf.kanjiForms ? new Set(
+            rkf.kanjiForms.map((kf) => kf.form)
+          ) : void 0;
+          if (kanjiForms2 && kanjiForms2.size > 0 && tanakaParts) {
+            for (const kf of kanjiForms2)
+              if (tanakaParts.has(kf)) {
+                existsExample = true;
+                break;
               }
-              if (tanakaParts && tanakaParts.has(entryObj.id))
+          }
+          if (entryObj.kanjiForms === void 0 && readings2.size > 0 && tanakaParts) {
+            for (const r of readings2)
+              if (tanakaParts.has(r)) {
                 existsExample = true;
-              if (existsExample) entryObj.hasPhrases = true;
-            }
-            if (entryObj.id.length > 0 && entryObj.readings.length > 0 && entryObj.meanings.length > 0)
-              dict.push(entryObj);
+                break;
+              }
           }
         }
+        if (existsExample) entryObj.hasPhrases = true;
+      }
+      dict.push(entryObj);
     }
   });
   return dict;
@@ -1366,75 +1372,64 @@ function convertKanjiDic(xmlString) {
     recover: false
   });
   const dict = [];
-  xml.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 = {
-            kanji: entry.literal[0]
-          };
-          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);
+  xml.parseString(dictParsed, (_err, result) => {
+    for (const entry of result.kanjidic2.character) {
+      const kanjiObj = {
+        kanji: entry.literal[0],
+        readingMeaning: []
+      };
+      if (typeof kanjiObj.kanji === "string" && kanjiObj.kanji.length === 1) {
+        const misc = entry.misc[0];
+        kanjiObj.misc = { strokeNumber: misc.stroke_count[0] };
+        if (isStringArray(misc.grade)) kanjiObj.misc.grade = misc.grade[0];
+        if (isStringArray(misc.freq)) kanjiObj.misc.frequency = misc.freq[0];
+        if (isStringArray(misc.jlpt) && ["5", "4", "3", "2", "1"].includes(misc.jlpt[0]))
+          kanjiObj.misc.jlpt = `N${misc.jlpt[0]}`;
+        if (isObjectArray(entry.reading_meaning))
+          for (const rm of entry.reading_meaning) {
+            const rmObj = { groups: [] };
+            for (const group of rm.rmgroup) {
+              const groupObj = {
+                readings: [],
+                meanings: []
+              };
+              if (isObjectArray(group.reading)) {
+                for (const reading of group.reading)
+                  if (reading._ && typeof reading._ === "string" && reading.$ && typeof reading.$ === "object" && reading.$.r_type && (reading.$.r_type === "ja_on" || reading.$.r_type === "ja_kun"))
+                    groupObj.readings.push({
+                      reading: reading._,
+                      type: reading.$.r_type
+                    });
+              }
+              if (Array.isArray(group.meaning)) {
+                for (const meaning of group.meaning)
+                  if (typeof meaning === "string") {
+                    if (kanjiObj.isKokuji === void 0 && meaning === "(kokuji)") {
+                      kanjiObj.isKokuji = true;
+                      continue;
                     }
+                    groupObj.meanings.push(meaning);
                   }
-                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);
-                }
               }
-            dict.push(kanjiObj);
+              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 (isStringArray(rm.nanori) && rm.nanori.length > 0)
+              rmObj.nanori = rm.nanori;
+            if (rmObj.groups.length > 0 || rmObj.nanori)
+              kanjiObj.readingMeaning.push(rmObj);
           }
-        }
+        dict.push(kanjiObj);
+      }
     }
   });
   return dict;
 }
 function convertTanakaCorpus(tanakaString) {
+  var _a;
   const tanakaArray = [];
   const tanakaParsed = tanakaString.split("\n");
   for (let i = 0; i <= tanakaParsed.length; i += 2) {
@@ -1444,46 +1439,38 @@ function convertTanakaCorpus(tanakaString) {
       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"];
-              const inflectedForm = partMatches.groups["inflection"];
-              if (reading)
-                if (regexps.tanakaReferenceID.test(reading)) {
-                  const referenceID = regexps.tanakaReferenceID.exec(reading);
-                  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);
-              if (inflectedForm) examplePart.inflectedForm = inflectedForm;
-              if (baseForm.endsWith("~")) {
-                examplePart.edited = true;
-                examplePart.baseForm = examplePart.baseForm.replace("~", "");
-              }
-              bParts.push(examplePart);
-            }
-          }
+      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);
+        const baseForm = partMatches == null ? void 0 : partMatches.groups["base"];
+        const examplePart = { baseForm };
+        const reading = partMatches == null ? void 0 : partMatches.groups["reading"];
+        const glossNumber = partMatches == null ? void 0 : partMatches.groups["glossnum"];
+        const inflectedForm = partMatches == null ? void 0 : partMatches.groups["inflection"];
+        if (reading)
+          if (regexps.tanakaReferenceID.test(reading)) {
+            const referenceID = regexps.tanakaReferenceID.exec(reading);
+            examplePart.referenceID = referenceID == null ? void 0 : referenceID.groups["entryid"];
+          } else examplePart.reading = reading;
+        if (glossNumber)
+          examplePart.glossNumber = glossNumber.startsWith("0") ? Number.parseInt(glossNumber.substring(1)) : Number.parseInt(glossNumber);
+        if (inflectedForm) examplePart.inflectedForm = inflectedForm;
+        if (baseForm.endsWith("~")) {
+          examplePart.edited = true;
+          examplePart.baseForm = examplePart.baseForm.replace("~", "");
         }
-        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
-          });
+        bParts.push(examplePart);
       }
+      const phrase = aParts[0];
+      const translation = aParts[1];
+      tanakaArray.push({
+        id: (_a = idMatch == null ? void 0 : idMatch.groups["id"]) == null ? void 0 : _a.trim(),
+        phrase: phrase.trim(),
+        translation: translation.trim(),
+        parts: bParts
+      });
     }
   }
   return tanakaArray;
@@ -1523,27 +1510,23 @@ function convertRadkFile(radkBuffer, kanjiDic) {
       };
       let j = i + 1;
       let kanjiLine = fileParsed[j];
-      if (kanjiLine) {
-        const kanjiList = [];
-        while (kanjiLine && !kanjiLine.startsWith("$ ")) {
-          const kanjis = kanjiLine.split("");
-          for (const kanji of kanjis) {
-            const foundKanji = kanjiDic.find(
-              (dictKanji) => dictKanji.kanji === kanji
-            );
-            let kanjiObj = { kanji };
-            if (foundKanji) kanjiObj = foundKanji;
-            kanjiList.push(kanjiObj);
-          }
-          j++;
-          kanjiLine = fileParsed[j];
-          if (!kanjiLine) continue;
-          if (kanjiLine.startsWith("$ ")) i = j - 1;
+      const kanjiList = [];
+      while (kanjiLine && !kanjiLine.startsWith("$ ")) {
+        const kanjis = kanjiLine.split("");
+        for (const kanji of kanjis) {
+          const foundKanji = kanjiDic.find(
+            (dictKanji) => dictKanji.kanji === kanji
+          );
+          let kanjiObj = { kanji };
+          kanjiObj = foundKanji;
+          kanjiList.push(kanjiObj);
         }
-        if (kanjiList.length > 0) radical.kanji = kanjiList;
-        if (radical.radical.length === 1 && radical.strokes.length > 0)
-          radicals.push(radical);
+        kanjiLine = fileParsed[++j];
+        if (!kanjiLine) continue;
+        if (kanjiLine.startsWith("$ ")) i = j - 1;
       }
+      if (kanjiList.length > 0) radical.kanji = kanjiList;
+      radicals.push(radical);
     }
   }
   return radicals;
@@ -1556,66 +1539,185 @@ function convertKradFile(kradBuffer, kanjiDic, katakanaList) {
       const split = line.split(" : ");
       const kanjiChar = split[0];
       const radicalsRow = split[1];
-      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
-            );
-            let radicalObj = foundRadical ?? { kanji: radical };
-            if (!foundRadical) {
-              const katakanaChar = katakanaList.find(
-                (kana) => kana.kana === radical
-              );
-              if (!katakanaChar) continue;
-              radicalObj = {
-                kanji: katakanaChar.kana,
-                readingMeaning: [
+      const kanji = {
+        kanji: kanjiChar,
+        radicals: []
+      };
+      const radicals = radicalsRow.split(" ");
+      for (const radical of radicals) {
+        const foundRadical = kanjiDic.find(
+          (dictKanji) => dictKanji.kanji === radical
+        );
+        let radicalObj = foundRadical ?? { kanji: radical };
+        if (!foundRadical) {
+          const katakanaChar = katakanaList.find(
+            (kana) => kana.kana === radical
+          );
+          if (!katakanaChar) continue;
+          radicalObj = {
+            kanji: katakanaChar.kana,
+            readingMeaning: [
+              {
+                groups: [
                   {
-                    groups: [
-                      {
-                        readings: [
-                          { reading: katakanaChar.kana, type: "ja_on" }
-                        ],
-                        meanings: [katakanaChar.reading]
-                      }
-                    ]
+                    readings: [{ reading: katakanaChar.kana, type: "ja_on" }],
+                    meanings: [katakanaChar.reading]
                   }
                 ]
-              };
+              }
+            ]
+          };
+        }
+        kanji.radicals.push(radicalObj);
+      }
+      if (kanji.kanji.length === 1 && kanji.radicals.length > 0)
+        kanjiWithRadicals.push(kanji);
+    }
+  }
+  return kanjiWithRadicals;
+}
+function createEntryMaps(jmDict, kanjiDic, tanakaExamples, wordDefinitionPairs, svgList) {
+  var _a;
+  const kanjiEntryMap = /* @__PURE__ */ new Map();
+  const wordIDEntryMap = /* @__PURE__ */ new Map();
+  const kanjiWordsMap = /* @__PURE__ */ new Map();
+  const wordExamplesMap = /* @__PURE__ */ new Map();
+  const wordDefinitionsMap = /* @__PURE__ */ new Map();
+  const kanjiSVGMap = /* @__PURE__ */ new Map();
+  const wordPartsMap = /* @__PURE__ */ new Map();
+  const partExamplesMap = /* @__PURE__ */ new Map();
+  const entryParts = /* @__PURE__ */ new Set();
+  if (kanjiDic)
+    for (const kanji of kanjiDic) kanjiEntryMap.set(kanji.kanji, kanji);
+  if (wordDefinitionPairs)
+    for (const pair of wordDefinitionPairs)
+      wordDefinitionsMap.set(pair.wordID, pair.definitions);
+  if (kanjiDic && svgList)
+    for (const kanji of kanjiDic) {
+      const codePoint = kanji.kanji.codePointAt(0).toString(16).toLowerCase();
+      const svg = svgList.find((file) => {
+        const baseName = file.split(".")[0].toLowerCase();
+        return baseName === codePoint || baseName === `0${codePoint}`;
+      });
+      if (svg) kanjiSVGMap.set(kanji.kanji, svg);
+    }
+  if (jmDict) {
+    for (const word of jmDict) {
+      wordIDEntryMap.set(word.id, word);
+      if (word.kanjiForms)
+        for (const kf of word.kanjiForms)
+          for (const char of kf.form.split("").filter((c) => regexps.kanji.test(c))) {
+            if (!kanjiWordsMap.has(char)) kanjiWordsMap.set(char, [word]);
+            else kanjiWordsMap.get(char).push(word);
+          }
+      if (tanakaExamples) {
+        const rkf = getValidForms(
+          word.readings,
+          word.kanjiForms,
+          word.isCommon
+        );
+        const localPartParts = /* @__PURE__ */ new Set();
+        if (rkf.readings.length > 0)
+          for (const reading of rkf.readings) {
+            entryParts.add(reading.reading);
+            localPartParts.add(reading.reading);
+          }
+        if (rkf.kanjiForms && rkf.kanjiForms.length > 0)
+          for (const kanjiForm of rkf.kanjiForms) {
+            entryParts.add(kanjiForm.form);
+            localPartParts.add(kanjiForm.form);
+          }
+        entryParts.add(word.id);
+        localPartParts.add(word.id);
+        wordPartsMap.set(word.id, localPartParts);
+      }
+    }
+    if (tanakaExamples) {
+      for (const ex of tanakaExamples) {
+        for (const part of ex.parts) {
+          if (entryParts.has(part.baseForm)) {
+            let exList = partExamplesMap.get(
+              part.baseForm
+            );
+            if (!exList) {
+              exList = [];
+              partExamplesMap.set(part.baseForm, exList);
+            }
+            exList.push(ex);
+          }
+          if (part.reading && entryParts.has(part.reading)) {
+            let exList = partExamplesMap.get(
+              part.reading
+            );
+            if (!exList) {
+              exList = [];
+              partExamplesMap.set(part.reading, exList);
+            }
+            exList.push(ex);
+          }
+          if (part.inflectedForm && entryParts.has(part.inflectedForm)) {
+            let exList = partExamplesMap.get(
+              part.inflectedForm
+            );
+            if (!exList) {
+              exList = [];
+              partExamplesMap.set(part.inflectedForm, exList);
+            }
+            exList.push(ex);
+          }
+          if (part.referenceID && entryParts.has(part.referenceID)) {
+            let exList = partExamplesMap.get(
+              part.referenceID
+            );
+            if (!exList) {
+              exList = [];
+              partExamplesMap.set(part.referenceID, exList);
             }
-            kanji.radicals.push(radicalObj);
+            exList.push(ex);
+          }
+        }
+      }
+      for (const word of jmDict) {
+        const entryParts2 = wordPartsMap.get(word.id);
+        const seenEx = /* @__PURE__ */ new Set();
+        const validExamples = [];
+        for (const p of entryParts2) {
+          const examplesForPart = (_a = partExamplesMap.get(p)) == null ? void 0 : _a.filter((ex) => !seenEx.has(ex.id));
+          if (!examplesForPart) continue;
+          for (const ex of examplesForPart) {
+            seenEx.add(ex.id);
+            validExamples.push(ex);
           }
         }
-        if (kanji.kanji.length === 1 && kanji.radicals.length > 0)
-          kanjiWithRadicals.push(kanji);
+        if (validExamples.length > 0)
+          wordExamplesMap.set(word.id, validExamples);
       }
     }
   }
-  return kanjiWithRadicals;
+  return {
+    ...wordIDEntryMap.size > 0 ? { wordIDEntryMap } : {},
+    ...kanjiWordsMap.size > 0 ? { kanjiWordsMap } : {},
+    ...kanjiEntryMap.size > 0 ? { kanjiEntryMap } : {},
+    ...wordExamplesMap.size > 0 ? { wordExamplesMap } : {},
+    ...wordDefinitionsMap.size > 0 ? { wordDefinitionsMap } : {},
+    ...kanjiSVGMap.size > 0 ? { kanjiSVGMap } : {}
+  };
 }
 function mapEntry(entry) {
   return {
     word: entry.word,
     pos_title: entry.pos_title,
     senses: entry.senses.filter(
-      (sense) => isValidArray(sense.form_of) && sense.form_of.every(
+      (sense) => isObjectArray(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
-        }))
+        form_of: sense.form_of.map((form) => form.word)
       } : {},
       glosses: sense.glosses
     })),
-    ...isValidArray(entry.forms) && entry.forms.every((form) => typeof form.form === "string") ? { forms: entry.forms.map((form) => ({ form: form.form })) } : {}
+    ...isObjectArray(entry.forms) && entry.forms.every((form) => typeof form.form === "string") ? { forms: entry.forms.map((form) => form.form) } : {}
   };
 }
 function convertJawiktionarySync(buffer) {
@@ -1625,7 +1727,7 @@ function convertJawiktionarySync(buffer) {
     const line = lines[i];
     if (!line) continue;
     const obj = JSON.parse(line);
-    if (obj && typeof obj === "object" && obj.lang_code === "ja" && obj.lang === "\u65E5\u672C\u8A9E")
+    if (obj && typeof obj === "object" && typeof obj.lang === "string" && (obj.lang === "\u65E5\u672C\u8A9E" || obj.lang === "\u53E4\u5178\u65E5\u672C\u8A9E"))
       entries.push(mapEntry(obj));
   }
   return entries;
@@ -1640,7 +1742,7 @@ async function convertJawiktionaryAsync(stream) {
       const entries = [];
       for await (const line of rl) {
         const obj = JSON.parse(line.trim());
-        if (obj && typeof obj === "object" && obj.lang_code === "ja" && obj.lang === "\u65E5\u672C\u8A9E")
+        if (obj && typeof obj === "object" && typeof obj.lang === "string" && (obj.lang === "\u65E5\u672C\u8A9E" || obj.lang === "\u53E4\u5178\u65E5\u672C\u8A9E"))
           entries.push(mapEntry(obj));
       }
       rl.close();
@@ -1651,17 +1753,14 @@ async function convertJawiktionaryAsync(stream) {
   );
 }
 function parseEntry(entry, definitions, definitionMap) {
-  if (isValidArray(entry.senses)) {
-    for (const sense of entry.senses)
-      if (isStringArray(sense.glosses)) {
-        const definition = sense.glosses.join("");
-        if (!definitions.some((def) => def.definition === definition)) {
-          if (!definitionMap.has(definition))
-            definitionMap.set(definition, { count: 1 });
-          else definitionMap.get(definition).count++;
-          definitions.push({ definition });
-        }
-      }
+  for (const sense of entry.senses) {
+    const definition = sense.glosses.join("");
+    if (!definitions.some((def) => def.definition === definition)) {
+      if (!definitionMap.has(definition))
+        definitionMap.set(definition, { count: 1 });
+      else definitionMap.get(definition).count++;
+      definitions.push({ definition });
+    }
   }
 }
 function getWordDefinitions(entryList, jmDict) {
@@ -1669,31 +1768,40 @@ function getWordDefinitions(entryList, jmDict) {
   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)]);
+    if (ent) ent.push(entry);
+    else entries.set(entry.word, [entry]);
   }
   const japaneseDefinitions = [];
   const definitionMap = /* @__PURE__ */ new Map();
-  const validWords = [];
+  const wordFormsMap = /* @__PURE__ */ new Map();
   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;
-          }
+  const validForms = /* @__PURE__ */ new Set();
+  for (const word of jmDict) {
+    const wordReadings = /* @__PURE__ */ new Set();
+    const wordKanjiForms = /* @__PURE__ */ new Set();
+    const rkf = getValidForms(
+      word.readings,
+      word.kanjiForms,
+      word.isCommon
+    );
+    if (rkf.readings.length > 0)
+      for (const r of rkf.readings) {
+        validReadings.add(r.reading);
+        wordReadings.add(r.reading);
+        validForms.add(r.reading);
       }
-      if (valid) validWords.push(word);
-    }
+    if (rkf.kanjiForms && rkf.kanjiForms.length > 0)
+      for (const kf of rkf.kanjiForms) {
+        validKanjiForms.add(kf.form);
+        wordKanjiForms.add(kf.form);
+        validForms.add(kf.form);
+      }
+    wordFormsMap.set(word.id, {
+      readings: wordReadings,
+      ...wordKanjiForms.size > 0 ? { kanjiForms: wordKanjiForms } : {}
+    });
+  }
   const validTitleEntries = /* @__PURE__ */ new Map();
   const entriesWithFormTitlesGlobal = /* @__PURE__ */ new Map();
   const entriesWithFormsGlobal = /* @__PURE__ */ new Map();
@@ -1705,34 +1813,27 @@ function getWordDefinitions(entryList, jmDict) {
     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("\u6F22\u5B57\u8868\u8A18") || gloss.trim().includes("\u53C2\u7167")) {
-                  for (const r of validReadings)
-                    if (gloss.trim().includes(r)) {
-                      reading = r;
-                      break;
-                    }
-                }
+      for (const sense of entry.senses) {
+        if (sense.form_of && sense.form_of.some((form) => validReadings.has(form)))
+          validFormOfEntries.add(entry.word);
+        for (const gloss of sense.glosses) {
+          let hasForm = false;
+          if (gloss.includes("\u8868\u8A18") || gloss.includes("\u53C2\u7167")) {
+            for (const r of validForms)
+              if (gloss.includes(r)) {
+                hasForm = true;
+                break;
               }
-              if (reading) validGlossesEntries.add(entry.word);
-            }
           }
+          if (hasForm) validGlossesEntries.add(entry.word);
         }
-      if (isValidArray(entry.forms)) {
+      }
+      if (entry.forms) {
         for (const form of entry.forms)
-          if (form.form && typeof form.form === "string" && validReadings.has(form.form))
-            validFormsEntries.add(entry.word);
+          if (validReadings.has(form)) validFormsEntries.add(entry.word);
       }
-    } else if (validReadings.has(entry.word)) {
+    }
+    if (validReadings.has(entry.word)) {
       valid = true;
       const ftEntry = entriesWithFormTitlesGlobal.get(entry.word);
       if (ftEntry) ftEntry.push(entry);
@@ -1743,8 +1844,8 @@ function getWordDefinitions(entryList, jmDict) {
       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)
+    if (entry.forms && (validKanjiForms.has(entry.word) || validReadings.has(entry.word)) && entry.forms.some(
+      (form) => validKanjiForms.has(form) || validReadings.has(form)
     )) {
       const wfEntry = entriesWithFormsGlobal.get(entry.word);
       if (wfEntry) wfEntry.push(entry);
@@ -1799,7 +1900,7 @@ function getWordDefinitions(entryList, jmDict) {
     "\u982D\u5B57\u8A9E",
     "\u63A5\u5C3E\u8A9E"
   ]) {
-    if (!posMap.has(pos)) posMap.set(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);
@@ -1836,86 +1937,73 @@ function getWordDefinitions(entryList, jmDict) {
   fge.length = 0;
   wfe.length = 0;
   const wordEntriesPairs = [];
-  for (const word of validWords) {
+  for (const word of jmDict) {
     const poses = /* @__PURE__ */ new Set();
-    for (const m of word.meanings) {
-      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);
-          }
+    for (const m of word.meanings)
+      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)
-    );
-    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 rkf = wordFormsMap.get(word.id);
     const entriesWithTitles = [];
     const entriesWithFormTitles = [];
     const entriesWithForms = [];
     if (poses.size > 0)
       for (const pos of poses) {
         const posEntries = posMap.get(pos);
-        if (posEntries) {
-          if (validWordKanjiForms)
-            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)
-                    )
-                  )
-                );
-            }
-          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 (rkf.kanjiForms)
+          for (const kf of rkf.kanjiForms) {
+            const te = (_a = posEntries.title) == null ? void 0 : _a.get(kf);
+            const fe = (_b = posEntries.form) == null ? void 0 : _b.get(kf);
             if (te)
               entriesWithTitles.push(
                 ...te.filter(
-                  (ent) => ent.forms && validWordKanjiForms && ent.forms.some(
-                    (form) => validWordKanjiForms.has(form.form)
-                  ) || validWordKanjiForms === void 0
+                  (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 && validWordKanjiForms.has(form.form) || validWordReadings.has(form.form)
+                    (form) => rkf.kanjiForms.has(form) || rkf.readings.has(form)
                   )
                 )
               );
-            if (fte) entriesWithFormTitles.push(...fte);
           }
+        for (const r of rkf.readings) {
+          const te = (_c = posEntries.title) == null ? void 0 : _c.get(r);
+          const fe = (_d = posEntries.form) == null ? void 0 : _d.get(r);
+          const fte = (_e = posEntries.formTitle) == null ? void 0 : _e.get(r);
+          if (te)
+            entriesWithTitles.push(
+              ...te.filter(
+                (ent) => ent.forms && rkf.kanjiForms && ent.forms.some(
+                  (form) => rkf.kanjiForms.has(form)
+                ) || rkf.kanjiForms === void 0
+              )
+            );
+          if (fe)
+            entriesWithForms.push(
+              ...fe.filter(
+                (ent) => ent.forms && ent.forms.some(
+                  (form) => rkf.kanjiForms && rkf.kanjiForms.has(form) || rkf.readings.has(form)
+                )
+              )
+            );
+          if (fte) entriesWithFormTitles.push(...fte);
         }
       }
     if (entriesWithTitles.length === 0 && entriesWithFormTitles.length === 0 && entriesWithForms.length === 0) {
-      if (validWordKanjiForms)
-        for (const kf of validWordKanjiForms) {
+      if (rkf.kanjiForms)
+        for (const kf of rkf.kanjiForms) {
           const te = validTitleEntries.get(kf);
           const fe = entriesWithFormsGlobal.get(kf);
           if (te)
@@ -1928,28 +2016,28 @@ function getWordDefinitions(entryList, jmDict) {
             entriesWithForms.push(
               ...fe.filter(
                 (ent) => ent.forms && ent.forms.some(
-                  (form) => validWordKanjiForms.has(form.form) || validWordReadings.has(form.form)
+                  (form) => rkf.kanjiForms.has(form) || rkf.readings.has(form)
                 )
               )
             );
         }
-      for (const r of validWordReadings) {
+      for (const r of rkf.readings) {
         const te = validTitleEntries.get(r);
         const fe = entriesWithFormsGlobal.get(r);
         const fte = entriesWithFormTitlesGlobal.get(r);
         if (te)
           entriesWithTitles.push(
             ...te.filter(
-              (ent) => ent.forms && validWordKanjiForms && ent.forms.some(
-                (form) => validWordKanjiForms.has(form.form)
-              ) || validWordKanjiForms === void 0
+              (ent) => ent.forms && rkf.kanjiForms && ent.forms.some(
+                (form) => rkf.kanjiForms.has(form)
+              ) || rkf.kanjiForms === void 0
             )
           );
         if (fe)
           entriesWithForms.push(
             ...fe.filter(
               (ent) => ent.forms && ent.forms.some(
-                (form) => validWordKanjiForms && validWordKanjiForms.has(form.form) || validWordReadings.has(form.form)
+                (form) => rkf.kanjiForms && rkf.kanjiForms.has(form) || rkf.readings.has(form)
               )
             )
           );
@@ -1959,8 +2047,9 @@ function getWordDefinitions(entryList, jmDict) {
     if (entriesWithTitles.length > 0 && (entriesWithFormTitles.length > 0 || entriesWithForms.length > 0))
       wordEntriesPairs.push({
         word,
-        readings: validWordReadings,
-        ...validWordKanjiForms ? { kanjiForms: validWordKanjiForms } : {},
+        readings: rkf.readings,
+        ...rkf.kanjiForms ? { kanjiForms: rkf.kanjiForms } : {},
+        forms: rkf.kanjiForms ? rkf.readings.union(rkf.kanjiForms) : rkf.readings,
         entriesWithTitles,
         entriesWithFormTitles,
         entriesWithForms
@@ -1969,7 +2058,7 @@ function getWordDefinitions(entryList, jmDict) {
   for (const pair of wordEntriesPairs) {
     const definitions = [];
     const kanjiFormEntries = [];
-    const readingWithFormsEntries = [];
+    const entriesWithForms = [];
     const readingEntries = [];
     const titleFormMap = /* @__PURE__ */ new Map();
     const refsMap = /* @__PURE__ */ new Map();
@@ -1977,80 +2066,64 @@ function getWordDefinitions(entryList, jmDict) {
     for (const ent of pair.entriesWithTitles) {
       const validFormOf = validFormOfEntries.has(ent.word);
       const validGlosses = validGlossesEntries.has(ent.word);
-      const validForms = validFormsEntries.has(ent.word);
-      if (pair.kanjiForms && pair.kanjiForms.has(ent.word) && (validFormOf || validGlosses || validForms)) {
+      const validForms2 = validFormsEntries.has(ent.word);
+      const hasKanjiForms = ent.forms !== void 0 && pair.kanjiForms !== void 0 && ent.forms.some((form) => pair.kanjiForms.has(form));
+      if (pair.kanjiForms && pair.kanjiForms.has(ent.word) && (validFormOf || validGlosses || validForms2)) {
         kanjiFormEntries.push(ent);
-        if ((validFormOf || validGlosses) && isValidArray(ent.senses))
+        if ((validFormOf || validGlosses) && ent.senses)
           for (const sense of ent.senses) {
-            if (validFormOf && isValidArray(sense.form_of)) {
+            if (validFormOf && 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 (pair.readings.has(form)) {
+                  const elem = titleFormMap.get(form);
                   if (!elem)
-                    titleFormMap.set(form.word, /* @__PURE__ */ new Set([ent.word]));
+                    titleFormMap.set(form, /* @__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("\u6F22\u5B57\u8868\u8A18") || gloss.trim().includes("\u53C2\u7167")) {
-                    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 (validGlosses) {
+              for (const gloss of sense.glosses)
+                if (gloss.includes("\u8868\u8A18") || gloss.includes("\u53C2\u7167")) {
+                  for (const f of pair.forms)
+                    if (gloss.includes(f)) {
+                      const elem = refsMap.get(f);
+                      if (!elem) refsMap.set(f, /* @__PURE__ */ new Set([ent.word]));
+                      else elem.add(ent.word);
+                    }
                 }
-              }
             }
           }
-        if (validForms && isValidArray(ent.forms)) {
+        if (validForms2 && 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 (pair.readings.has(form)) readingForms.add(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))
+      }
+      if (pair.readings.has(ent.word) && hasKanjiForms)
+        entriesWithForms.push(ent);
+      if (pair.kanjiForms === void 0 && pair.readings.has(ent.word))
         readingEntries.push(ent);
     }
     for (const entry of pair.entriesWithForms) {
       const elem = titleFormMap.get(entry.word);
-      if (elem && entry.forms.some((form) => elem.has(form.form)))
-        readingWithFormsEntries.push(entry);
+      if (elem && entry.forms && entry.forms.some((form) => elem.has(form)))
+        entriesWithForms.push(entry);
     }
     for (const entry of pair.entriesWithFormTitles) {
       if (readingForms.has(entry.word)) {
-        readingWithFormsEntries.push(entry);
+        entriesWithForms.push(entry);
         continue;
       }
-      if (pair.kanjiForms) {
-        const ft = refsMap.get(entry.word);
-        if (ft && !ft.isDisjointFrom(pair.kanjiForms))
-          readingWithFormsEntries.push(entry);
-      }
+      const ft = refsMap.get(entry.word);
+      if (ft && !ft.isDisjointFrom(pair.forms)) entriesWithForms.push(entry);
     }
-    let parsedReadingWithFormsEntries = false;
-    for (const entry of kanjiFormEntries)
-      if (entry.pos_title === "\u548C\u8A9E\u306E\u6F22\u5B57\u8868\u8A18" && readingWithFormsEntries.length > 0) {
-        if (!parsedReadingWithFormsEntries)
-          parsedReadingWithFormsEntries = true;
-        for (const ref of readingWithFormsEntries)
-          parseEntry(ref, definitions, definitionMap);
-      } else parseEntry(entry, definitions, definitionMap);
-    if (!parsedReadingWithFormsEntries && readingWithFormsEntries.length > 0) {
-      parsedReadingWithFormsEntries = true;
-      for (const ref of readingWithFormsEntries)
-        parseEntry(ref, definitions, definitionMap);
+    if (kanjiFormEntries.length > 0) {
+      for (const entry of kanjiFormEntries)
+        if (entry.pos_title !== "\u548C\u8A9E\u306E\u6F22\u5B57\u8868\u8A18")
+          parseEntry(entry, definitions, definitionMap);
     }
+    if (entriesWithForms.length > 0)
+      for (const ref of entriesWithForms)
+        parseEntry(ref, definitions, definitionMap);
     if (readingEntries.length > 0)
       for (const readingEntry of readingEntries)
         parseEntry(readingEntry, definitions, definitionMap);
@@ -2101,12 +2174,12 @@ async function getWordDefinitionsWithFurigana(entryList, jmDict) {
 function lookupWordNote(key, notes, tags) {
   const info = noteMap.get(key.toLowerCase());
   if (!info) {
-    if (notes) notes.push(key);
+    notes.push(key);
     return { note: key };
   }
   const tag = `word::${info[0]}`;
-  if (tags && !tags.includes(tag)) tags.push(tag);
-  if (notes) notes.push(info[1]);
+  if (!tags.includes(tag)) tags.push(tag);
+  notes.push(info[1]);
   return { note: info[1], tag };
 }
 var wordAddNoteArray = (arr, cb) => {
@@ -2116,9 +2189,14 @@ var wordAddNoteArray = (arr, cb) => {
 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 (typeof word === "string" && dict) {
+    if (Array.isArray(dict))
+      dictWord = dict.find(
+        (entry) => entry.id === word
+      );
+    if (dict instanceof Map) dictWord = dict.get(word);
+  }
+  if (typeof word === "object") dictWord = word;
   if (dictWord) {
     const word2 = {
       id: dictWord.id,
@@ -2141,7 +2219,7 @@ function getWord(word, dict, kanjiDic, examples, definitions, noteTypeName, deck
             notes: dictKanjiForm.notes.map((note) => {
               const noteAndTag = lookupWordNote(
                 note,
-                void 0,
+                [],
                 word2.tags
               );
               return capitalizeString(noteAndTag.note);
@@ -2160,7 +2238,7 @@ function getWord(word, dict, kanjiDic, examples, definitions, noteTypeName, deck
           ...dictReading.notes ? dictReading.notes.map((note) => {
             const noteAndTag = lookupWordNote(
               note,
-              void 0,
+              [],
               word2.tags
             );
             return capitalizeString(noteAndTag.note);
@@ -2170,85 +2248,81 @@ function getWord(word, dict, kanjiDic, examples, definitions, noteTypeName, deck
       ...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) => {
-            if (typeof translation === "string") return translation;
-            else {
-              if (translation.type === "lit") {
-                translationTypes.push("Literal meaning");
-                word2.tags.push("word::literal_meaning");
-              } else if (translation.type === "expl") {
-                translationTypes.push("Explanation");
-                word2.tags.push("word::explanation");
-              } else if (translation.type === "tm") {
-                translationTypes.push("Trademark");
-                word2.tags.push("word::trademark");
-              }
-              return translation.translation;
-            }
+    for (const dictMeaning of dictWord.meanings) {
+      const translationTypes = [];
+      const translations = dictMeaning.translations.map(
+        (translation) => {
+          if (typeof translation === "string") return translation;
+          else {
+            const translationNoteAndTag = noteMap.get(
+              translation.type
+            );
+            translationTypes.push(translationNoteAndTag[1]);
+            word2.tags.push(`word::${translationNoteAndTag[0]}`);
+            return translation.translation;
           }
-        );
-        const notes = [];
-        wordAddNoteArray(
-          dictMeaning.kanjiFormRestrictions,
-          (restriction) => notes.push(`Meaning restricted to ${restriction}`)
-        );
-        wordAddNoteArray(
-          dictMeaning.readingRestrictions,
-          (restriction) => notes.push(`Meaning restricted to ${restriction}`)
-        );
-        for (const t of translationTypes) notes.push(t);
-        wordAddNoteArray(
-          dictMeaning.partOfSpeech,
-          (pos) => lookupWordNote(pos, notes, word2.tags)
-        );
-        wordAddNoteArray(
-          dictMeaning.fields,
-          (field) => lookupWordNote(field, notes, word2.tags)
-        );
-        wordAddNoteArray(
-          dictMeaning.dialects,
-          (dialect) => lookupWordNote(dialect, notes, word2.tags)
-        );
-        wordAddNoteArray(
-          dictMeaning.antonyms,
-          (antonym) => notes.push(`Antonym: ${antonym}`)
-        );
-        wordAddNoteArray(
-          dictMeaning.references,
-          (reference) => notes.push(`Related: ${reference}`)
-        );
-        wordAddNoteArray(
-          dictMeaning.info,
-          (info) => lookupWordNote(info, notes, word2.tags)
-        );
-        wordAddNoteArray(
-          dictMeaning.misc,
-          (misc) => lookupWordNote(misc, notes, word2.tags)
-        );
-        for (let i = 0; i < notes.length; i++)
-          notes[i] = capitalizeString(notes[i]);
-        word2.translations.push({
-          translation: translations.join("; "),
-          notes
-        });
-      }
+        }
+      );
+      const notes = [];
+      wordAddNoteArray(
+        dictMeaning.kanjiFormRestrictions,
+        (restriction) => notes.push(`Meaning restricted to ${restriction}`)
+      );
+      wordAddNoteArray(
+        dictMeaning.readingRestrictions,
+        (restriction) => notes.push(`Meaning restricted to ${restriction}`)
+      );
+      for (const t of translationTypes) notes.push(t);
+      wordAddNoteArray(
+        dictMeaning.partOfSpeech,
+        (pos) => lookupWordNote(pos, notes, word2.tags)
+      );
+      wordAddNoteArray(
+        dictMeaning.fields,
+        (field) => lookupWordNote(field, notes, word2.tags)
+      );
+      wordAddNoteArray(
+        dictMeaning.dialects,
+        (dialect) => lookupWordNote(dialect, notes, word2.tags)
+      );
+      wordAddNoteArray(
+        dictMeaning.antonyms,
+        (antonym) => notes.push(`Antonym: ${antonym}`)
+      );
+      wordAddNoteArray(
+        dictMeaning.references,
+        (reference) => notes.push(`Related: ${reference}`)
+      );
+      wordAddNoteArray(
+        dictMeaning.info,
+        (info) => lookupWordNote(info, notes, word2.tags)
+      );
+      wordAddNoteArray(
+        dictMeaning.misc,
+        (misc) => lookupWordNote(misc, notes, word2.tags)
+      );
+      for (let i = 0; i < notes.length; i++)
+        notes[i] = capitalizeString(notes[i]);
+      word2.translations.push({
+        translation: translations.join("; "),
+        notes
+      });
+    }
     if (dictWord.usuallyInKana === true) {
       word2.usuallyInKana = true;
       word2.tags.push("word::usually_in_kana_for_all_senses");
     }
     if (kanjiDic && word2.kanjiForms) {
       const kanji = [];
+      const seenChars = /* @__PURE__ */ new Set();
       for (const kanjiForm of word2.kanjiForms)
-        for (const char of kanjiForm.kanjiForm) {
-          if (!regexps.kanji.test(char) || kanji.some((kanji2) => kanji2.kanji === char))
-            continue;
+        for (const char of kanjiForm.kanjiForm.split("").filter((c) => regexps.kanji.test(c))) {
+          if (seenChars.has(char)) continue;
+          seenChars.add(char);
+          const kanjiEntry = kanjiDic instanceof Map ? kanjiDic.get(char) : void 0;
           const kanjiObj = getKanji(
-            char,
-            Array.isArray(kanjiDic) ? kanjiDic : kanjiDic.get(char)
+            kanjiEntry ?? char,
+            Array.isArray(kanjiDic) ? kanjiDic : void 0
           );
           if (kanjiObj)
             kanji.push({
@@ -2258,113 +2332,102 @@ function getWord(word, dict, kanjiDic, examples, definitions, noteTypeName, deck
         }
       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(
-          word2.readings.filter(
-            (reading) => (reading.notes === void 0 || !reading.notes.some(
-              (note) => notSearchedForms.has(note)
-            )) && (word2.common === void 0 || reading.common === true)
-          ).map((reading) => reading.reading)
+    if (dictWord.hasPhrases !== void 0 && examples) {
+      const exampleList = Array.isArray(examples) ? examples : examples.get(dictWord.id) ?? [];
+      const rkf = getValidForms(
+        dictWord.readings,
+        dictWord.kanjiForms,
+        dictWord.isCommon
+      );
+      const readings = new Set(
+        rkf.readings.map((r) => r.reading)
+      );
+      const kanjiForms = rkf.kanjiForms ? new Set(rkf.kanjiForms.map((kf) => kf.form)) : void 0;
+      let kanjiFormExamples = [];
+      const readingMatchingKanjiFormExamples = [];
+      const readingExamples = [];
+      const readingMatchingKanjiForms = /* @__PURE__ */ new Set();
+      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 === dictWord.id;
+          if (kanjiForms && kanjiForms.has(part.baseForm) || referenceIDMatch) {
+            if (readingAsReadingMatch || readingAsInflectedFormMatch) {
+              readingMatchingKanjiFormExamples.push({
+                ex: example,
+                partIndex: i
+              });
+              readingMatchingKanjiForms.add(part.baseForm);
+            } else
+              kanjiFormExamples.push({
+                ex: example,
+                partIndex: i,
+                form: part.baseForm
+              });
+            break;
+          }
+          const readingAsBaseFormMatch = readings.has(part.baseForm);
+          if ((readingAsBaseFormMatch || referenceIDMatch) && kanjiForms === void 0) {
+            readingExamples.push({ ex: example, partIndex: i });
+            break;
+          }
+        }
+      if (readingMatchingKanjiForms.size > 0)
+        kanjiFormExamples = kanjiFormExamples.filter(
+          (ex) => ex.form && readingMatchingKanjiForms.has(ex.form)
         );
-        const existValidKf = word2.kanjiForms && word2.kanjiForms.length > 0 ? word2.kanjiForms.some(
-          (kf) => (kf.notes === void 0 || !kf.notes.some(
-            (note) => notSearchedForms.has(note)
-          )) && (word2.common === void 0 || kf.common === true)
-        ) : void 0;
-        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)
-              )) && (word2.common === void 0 || kanjiForm.common === true);
-            else return true;
-          }).map((kanjiForm) => kanjiForm.kanjiForm)
-        ) : void 0;
-        let kanjiFormExamples = [];
-        const readingMatchingKanjiFormExamples = [];
-        const readingExamples = [];
-        const readingMatchingKanjiForms = /* @__PURE__ */ new Set();
-        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 && word2.id !== void 0 && part.referenceID === word2.id;
-            if (kanjiForms && kanjiForms.has(part.baseForm) || referenceIDMatch) {
-              if (readingAsReadingMatch || readingAsInflectedFormMatch) {
-                readingMatchingKanjiFormExamples.push({
-                  ex: example,
-                  partIndex: i
-                });
-                readingMatchingKanjiForms.add(part.baseForm);
-              } else
-                kanjiFormExamples.push({
-                  ex: example,
-                  partIndex: i,
-                  form: part.baseForm
-                });
-              break;
-            }
-            const readingAsBaseFormMatch = readings.has(part.baseForm);
-            if ((readingAsBaseFormMatch || referenceIDMatch) && kanjiForms === void 0) {
-              readingExamples.push({ ex: example, partIndex: i });
-              break;
+      const includeKanjiFormExamples = word2.kanjiForms !== void 0;
+      let wordExamples = [
+        ...includeKanjiFormExamples ? [...readingMatchingKanjiFormExamples, ...kanjiFormExamples] : readingExamples
+      ];
+      readingMatchingKanjiForms.clear();
+      const glossSpecificExamples = [];
+      const seenPhrases = /* @__PURE__ */ new Set();
+      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: word2.id,
+                glossNumber: i + 1
+              };
+              glossSpecificExamples.push(example);
+              seenPhrases.add(example.ex.phrase);
+              break outer;
             }
           }
-        if (readingMatchingKanjiForms.size > 0)
-          kanjiFormExamples = kanjiFormExamples.filter(
-            (ex) => ex.form && readingMatchingKanjiForms.has(ex.form)
+        }
+      }
+      if (glossSpecificExamples.length === word2.translations.length)
+        wordExamples = glossSpecificExamples;
+      else if (glossSpecificExamples.length > 0) {
+        const exes = glossSpecificExamples;
+        if (exes.length < 5) {
+          wordExamples = wordExamples.filter(
+            (ex) => !seenPhrases.has(ex.ex.phrase)
           );
-        const includeKanjiFormExamples = word2.kanjiForms !== void 0;
-        let wordExamples = [
-          ...includeKanjiFormExamples ? [...readingMatchingKanjiFormExamples, ...kanjiFormExamples] : [],
-          ...!includeKanjiFormExamples ? readingExamples : []
-        ];
-        readingMatchingKanjiForms.clear();
-        const glossSpecificExamples = [];
-        const seenPhrases = /* @__PURE__ */ new Set();
-        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: word2.id,
-                  glossNumber: i + 1
-                };
-                glossSpecificExamples.push(example);
-                seenPhrases.add(example.ex.phrase);
-                break outer;
-              }
+          if (wordExamples.length > 0)
+            for (const ex of wordExamples) {
+              exes.push(ex);
+              if (exes.length === 5) break;
             }
-          }
-          if (glossSpecificExamples.length === 5) break;
-        }
-        if (glossSpecificExamples.length === 5)
-          wordExamples = [...glossSpecificExamples];
-        else if (glossSpecificExamples.length > 0)
-          wordExamples = [
-            ...glossSpecificExamples,
-            ...wordExamples.filter(
-              (ex) => !seenPhrases.has(ex.ex.phrase)
-            ).slice(0, 5 - glossSpecificExamples.length)
-          ];
-        if (wordExamples.length > 0) {
-          word2.phrases = (wordExamples.length > 5 ? wordExamples.slice(0, 5) : wordExamples).map((ex) => ({
-            phrase: ex.ex.furigana ?? ex.ex.phrase,
-            translation: ex.ex.translation,
-            originalPhrase: ex.ex.phrase,
-            ...ex.ex.glossNumber ? { glossNumber: ex.ex.glossNumber } : {}
-          }));
-          word2.tags.push("word::has_phrases");
-          if (glossSpecificExamples.length > 0)
-            word2.tags.push("word::has_meaning-specific_phrases");
         }
+        wordExamples = exes;
+      }
+      if (wordExamples.length > 0) {
+        word2.phrases = (wordExamples.length > 5 ? wordExamples.slice(0, 5) : wordExamples).map((ex) => ({
+          phrase: ex.ex.furigana ?? ex.ex.phrase,
+          translation: ex.ex.translation,
+          originalPhrase: ex.ex.phrase,
+          ...ex.ex.glossNumber ? { glossNumber: ex.ex.glossNumber } : {}
+        }));
+        word2.tags.push("word::has_phrases");
+        if (glossSpecificExamples.length > 0)
+          word2.tags.push("word::has_meaning-specific_phrases");
       }
     }
     if (definitions) {
@@ -2375,10 +2438,10 @@ function getWord(word, dict, kanjiDic, examples, definitions, noteTypeName, deck
   } else return void 0;
 }
 function getKanji(kanji, dict, jmDict, svgList, noteTypeName, deckPath) {
-  var _a, _b, _c, _d, _e, _f, _g, _h;
+  var _a, _b, _c, _d, _e, _f, _g;
   let dictKanji = void 0;
   if (typeof kanji === "string" && dict)
-    dictKanji = dict.find((entry) => entry.kanji === kanji);
+    dictKanji = Array.isArray(dict) ? dict.find((entry) => entry.kanji === kanji) : dict.get(kanji);
   else if (typeof kanji === "object") dictKanji = kanji;
   if (dictKanji) {
     const kanji2 = {
@@ -2399,23 +2462,20 @@ function getKanji(kanji, dict, jmDict, svgList, noteTypeName, deckPath) {
       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) {
-            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);
+        for (const group of rm.groups) {
+          if (group.readings) {
+            onyomi.push(
+              ...group.readings.filter((reading) => reading.type === "ja_on").map((reading) => reading.reading)
+            );
+            kunyomi.push(
+              ...group.readings.filter(
+                (reading) => reading.type === "ja_kun"
+              ).map((reading) => reading.reading)
+            );
           }
+          if (group.meanings && group.meanings.length > 0)
+            meanings.push(...group.meanings);
+        }
       }
       if (meanings.length > 0) kanji2.meanings = meanings;
       if (nanori.length > 0) kanji2.nanori = nanori;
@@ -2430,71 +2490,62 @@ function getKanji(kanji, dict, jmDict, svgList, noteTypeName, deckPath) {
         (word) => word.kanjiForms && word.kanjiForms[0].form.includes(kanji2.kanji)
       );
       if (firstKfWords && firstKfWords.length > 0) kanjiWords = firstKfWords;
-      else if (kanjiWords) kanjiWords = kanjiWords;
       if (kanjiWords) {
         const validWords = [];
         for (const word of kanjiWords) {
           const kanjiForm = (_a = firstKfWords && firstKfWords.length > 0 ? word.kanjiForms[0] : word.kanjiForms.find(
             (kf) => kf.form.includes(kanji2.kanji)
           )) == null ? void 0 : _a.form;
-          if (!kanjiForm) continue;
-          const reading = (_b = firstKfWords && firstKfWords.length > 0 ? word.readings[0] : word.readings.find(
-            (reading2) => reading2.kanjiFormRestrictions && reading2.kanjiFormRestrictions.includes(kanjiForm)
-          )) == null ? void 0 : _b.reading;
-          if (!reading) continue;
-          const meaning = firstKfWords && firstKfWords.length > 0 ? (_c = word.meanings[0]) == null ? void 0 : _c.translations[0] : (_d = word.meanings.find(
-            (m) => m.translations && m.kanjiFormRestrictions && m.kanjiFormRestrictions.includes(kanjiForm)
-          )) == null ? void 0 : _d.translations[0];
-          if (!meaning) continue;
-          validWords.push({
-            kanjiForms: [{ kanjiForm }],
-            readings: [{ reading }],
-            translations: [
-              {
-                translation: typeof meaning === "string" ? meaning : meaning.translation
-              }
-            ]
-          });
+          if (kanjiForm) {
+            const reading = (_b = firstKfWords && firstKfWords.length > 0 ? word.readings[0] : word.readings.find(
+              (reading2) => reading2.kanjiFormRestrictions && reading2.kanjiFormRestrictions.includes(kanjiForm)
+            )) == null ? void 0 : _b.reading;
+            if (!reading) continue;
+            const translation = (_c = firstKfWords && firstKfWords.length > 0 ? word.meanings[0] : word.meanings.find(
+              (m) => m.translations && m.kanjiFormRestrictions && m.kanjiFormRestrictions.includes(kanjiForm)
+            )) == null ? void 0 : _c.translations.map(
+              (t) => typeof t === "string" ? t : t.translation
+            )[0];
+            if (!translation) continue;
+            validWords.push({
+              kanjiForms: [{ kanjiForm }],
+              readings: [{ reading }],
+              translations: [
+                {
+                  translation
+                }
+              ]
+            });
+          }
           if (validWords.length === 3) break;
         }
         if (validWords.length > 0) kanji2.words = validWords;
       }
     }
     if (svgList) {
-      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;
-      }
+      const codePoint = kanji2.kanji.codePointAt(0).toString(16).toLowerCase();
+      const svg = Array.isArray(svgList) ? svgList.find(
+        (svgFile) => [`${codePoint}.svg`, `0${codePoint}.svg`].includes(
+          svgFile.toLowerCase()
+        )
+      ) : svgList.get(kanji2.kanji);
+      if (svg) kanji2.svg = svg;
     }
     if (kanji2.tags && dictKanji.isKokuji === true) {
       kanji2.kokuji = true;
       kanji2.tags.push("kanji::kokuji");
-      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::${((_e = kanji2.onyomi) == null ? void 0 : _e.length) ?? 0}`,
-        `kanji::kunyomi::${((_f = kanji2.kunyomi) == null ? void 0 : _f.length) ?? 0}`,
-        `kanji::nanori::${((_g = kanji2.nanori) == null ? void 0 : _g.length) ?? 0}`,
-        `kanji::words::${((_h = kanji2.words) == null ? void 0 : _h.length) ?? 0}`,
-        ...kanji2.svg ? ["kanji::has_svg"] : []
-      );
+    kanji2.tags.push(
+      `kanji::strokes::${kanji2.strokes}`,
+      ...kanji2.frequency ? [`kanji::frequency::${kanji2.frequency}`] : [],
+      ...kanji2.grade ? [`kanji::grade::${kanji2.grade}`] : [],
+      ...kanji2.jlpt ? [`kanji::pre-2010_jlpt::${kanji2.jlpt.toLowerCase()}`] : [],
+      `kanji::onyomi::${((_d = kanji2.onyomi) == null ? void 0 : _d.length) ?? 0}`,
+      `kanji::kunyomi::${((_e = kanji2.kunyomi) == null ? void 0 : _e.length) ?? 0}`,
+      `kanji::nanori::${((_f = kanji2.nanori) == null ? void 0 : _f.length) ?? 0}`,
+      `kanji::words::${((_g = kanji2.words) == null ? void 0 : _g.length) ?? 0}`,
+      ...kanji2.svg ? ["kanji::has_svg"] : []
+    );
     return kanji2;
   } else return void 0;
 }
@@ -2521,22 +2572,20 @@ function getKanjiExtended(info, kanji, dict, useWords, jmDict, svgList, noteType
       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::${kanjiObj.words.length}`
-            );
-          }
-        });
-    }
+    if (kanjiObj.components)
+      kanjiObj.tags.push(`kanji::components::${kanjiObj.components.length}`);
+    if (kanjiObj.mnemonic && kanjiObj.mnemonic.length > 0)
+      kanjiObj.tags.push("kanji::has_mnemonic");
+    if (useWords === true && kanjiObj.words && info.words)
+      kanjiObj.tags.forEach((tag, index) => {
+        if (tag.startsWith("kanji::words::") && kanjiObj.words) {
+          kanjiObj.tags.splice(
+            index,
+            1,
+            `kanji::words::${kanjiObj.words.length}`
+          );
+        }
+      });
     if (sourceURL && info.externalInfo === true && usedInfo)
       kanjiObj.source = sourceURL;
     return kanjiObj;
@@ -2826,19 +2875,21 @@ export {
   convertRadkFile,
   convertTanakaCorpus,
   convertTanakaCorpusWithFurigana,
+  createEntryMaps,
   generateAnkiNote,
   generateAnkiNotesFile,
   getKanji,
   getKanjiExtended,
+  getValidForms,
   getWord,
   getWordDefinitions,
   getWordDefinitionsWithFurigana,
   isGrammar,
   isKana,
   isKanji,
+  isObjectArray,
   isRadical,
   isStringArray,
-  isValidArray,
   isValidArrayWithFirstElement,
   isWord,
   notSearchedForms,