henkan 0.9.2 → 1.0.0

package/dist/index.mjs

@@ -1085,6 +1085,7 @@ import iconv from "iconv-lite";
 import {
   SynthesizeSpeechCommand
 } from "@aws-sdk/client-polly";
+import { createInterface } from "readline";
 var Kuroshiro = __require("kuroshiro");
 var KuromojiAnalyzer = __require("kuroshiro-analyzer-kuromoji");
 function capitalizeString(value) {
@@ -1100,6 +1101,7 @@ 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));
@@ -1215,7 +1217,7 @@ function convertJMdict(xmlString, examples) {
               }
               if (isStringArray(meaning.dial))
                 meaningObj.dialects = meaning.dial;
-              if (meaningObj.partOfSpeech && meaningObj.partOfSpeech.length > 0 || meaningObj.translations && meaningObj.translations.length > 0)
+              if (meaningObj.partOfSpeech && meaningObj.partOfSpeech.length > 0 || meaningObj.translations)
                 entryObj.meanings.push(meaningObj);
             }
             if (entryObj.meanings.length === usuallyInKanaMeanings)
@@ -1224,9 +1226,9 @@ function convertJMdict(xmlString, examples) {
           if (examples) {
             const readings2 = new Set(
               entryObj.readings.filter(
-                (reading) => (!reading.notes || !reading.notes.some(
+                (reading) => reading.notes === void 0 || !reading.notes.some(
                   (note) => notSearchedForms.has(note)
-                )) && (entryObj.isCommon === void 0 || reading.commonness && reading.commonness.length > 0)
+                ) || reading.commonness
               ).map((reading) => reading.reading)
             );
             const kanjiForms2 = entryObj.kanjiForms ? new Set(
@@ -1327,9 +1329,13 @@ function convertKanjiDic(xmlString) {
                     rmObj.groups.push(groupObj);
                 }
               if (isStringArray(rm.nanori)) rmObj.nanori = rm.nanori;
-              if (rmObj.groups.length > 0) kanjiObj.readingMeaning.push(rmObj);
+              if (rmObj.groups.length > 0 && kanjiObj.readingMeaning)
+                kanjiObj.readingMeaning.push(rmObj);
             }
-          if (kanjiObj.kanji.length > 0) dict.push(kanjiObj);
+          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;
@@ -1433,7 +1439,7 @@ function convertRadkFile(radkBuffer, kanjiDic) {
               (dictKanji) => dictKanji.kanji === kanji
             );
             if (foundKanji) kanjiList.push(foundKanji);
-            else kanjiList.push({ kanji, readingMeaning: [] });
+            else kanjiList.push({ kanji });
           }
           j++;
           kanjiLine = fileParsed[j];
@@ -1441,7 +1447,7 @@ function convertRadkFile(radkBuffer, kanjiDic) {
           if (kanjiLine.startsWith("$ ")) i = j - 1;
         }
         if (kanjiList.length > 0) radical.kanji = kanjiList;
-        if (radical.radical.length > 0 && radical.strokes.length > 0)
+        if (radical.radical.length === 1 && radical.strokes.length > 0)
           radicals.push(radical);
       }
     }
@@ -1502,6 +1508,265 @@ function convertKradFile(kradBuffer, kanjiDic, katakanaList) {
     throw err;
   }
 }
+async function convertJawiktionary(stream) {
+  const rl = 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);
+      }
+    }
+  );
+}
+function parseEntry(entry, definitions, definitionMap) {
+  if (isValidArray(entry.senses)) {
+    for (const sense of entry.senses)
+      if (isStringArray(sense.glosses)) {
+        const definition = sense.glosses.join("<br>");
+        if (!definitions.some((def) => def.definition === definition)) {
+          if (!definitionMap.has(definition))
+            definitionMap.set(definition, { count: 1 });
+          else definitionMap.get(definition).count++;
+          definitions.push({ definition });
+        }
+      }
+  }
+}
+async function getWordDefinitions(entries, jmDict, kanjiDic, generateFurigana) {
+  return await new Promise(async (resolve, reject) => {
+    try {
+      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);
+            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(
+            getWord(void 0, void 0, kanjiDic, void 0, void 0, word)
+          );
+      }
+      const validTitleEntries = [];
+      const entriesWithFormTitlesGlobal = [];
+      const entriesWithFormsGlobal = [];
+      const validFormOfEntries = /* @__PURE__ */ new Set();
+      const validGlossesEntries = /* @__PURE__ */ new Set();
+      const validFormsEntries = /* @__PURE__ */ new Set();
+      for (const entry of entries) {
+        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 (isValidArray(sense.glosses) && sense.glosses.length === 1) {
+                const gloss = sense.glosses[0];
+                let reading = void 0;
+                if (gloss !== void 0) {
+                  if (gloss.trim().includes("\u6F22\u5B57\u8868\u8A18\u3002") || gloss.trim().includes("\u53C2\u7167\u3002")) {
+                    for (const r of validReadings)
+                      if (gloss.trim().includes(r)) {
+                        reading = r;
+                        break;
+                      }
+                  }
+                }
+                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) && isValidArray(entry.forms) && entry.forms.some((form) => validKanjiForms.has(form.form))) {
+          valid = true;
+          entriesWithFormTitlesGlobal.push(entry);
+        } else if (validReadings.has(entry.word)) {
+          valid = true;
+          entriesWithFormTitlesGlobal.push(entry);
+        }
+        if (valid) validTitleEntries.push(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)
+        ))
+          entriesWithFormsGlobal.push(entry);
+      }
+      for (const word of validWords) {
+        const definitions = [];
+        const kanjiFormEntries = [];
+        const readingWithFormsEntries = [];
+        const readingEntries = [];
+        const titleFormMap = /* @__PURE__ */ new Map();
+        const readingForms = /* @__PURE__ */ new Set();
+        const validWordReadings = new Set(
+          word.readings.filter(
+            (r) => r.notes === void 0 || !r.notes.some((note) => notSearchedForms.has(note)) || r.common === true
+          ).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.common === true
+          ).map((kf) => kf.kanjiForm)
+        ) : void 0;
+        const entriesWithFormTitles = entriesWithFormTitlesGlobal.filter(
+          (entry) => validWordReadings.has(entry.word)
+        );
+        const entriesWithForms = entriesWithFormsGlobal.filter(
+          (entry) => isValidArray(entry.forms) && (validWordKanjiForms && validWordKanjiForms.has(entry.word) || validWordReadings.has(entry.word)) && entry.forms.some(
+            (form) => validWordKanjiForms && validWordKanjiForms.has(form.form) || validWordReadings.has(form.form)
+          )
+        );
+        for (const ent of validTitleEntries) {
+          const validFormOf = validFormOfEntries.has(ent.word);
+          const validGlosses = validGlossesEntries.has(ent.word);
+          const validForms = validFormsEntries.has(ent.word);
+          if (word.kanjiForms && validWordKanjiForms && validWordKanjiForms.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" && validWordReadings.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) && sense.glosses.length === 1) {
+                  const gloss = sense.glosses[0];
+                  let reading = void 0;
+                  if (gloss !== void 0) {
+                    if (gloss.trim().includes("\u6F22\u5B57\u8868\u8A18\u3002") || gloss.trim().includes("\u53C2\u7167\u3002")) {
+                      for (const r of validWordReadings)
+                        if (gloss.trim().includes(r)) {
+                          reading = r;
+                          break;
+                        }
+                    }
+                  }
+                  if (reading) {
+                    const elem = titleFormMap.get(reading);
+                    if (!elem)
+                      titleFormMap.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" && validWordReadings.has(form.form))
+                  readingForms.add(form.form);
+            }
+          } else if (validWordReadings.has(ent.word) && isValidArray(ent.forms) && word.kanjiForms && validWordKanjiForms && ent.forms.some((form) => validWordKanjiForms.has(form.form)))
+            readingWithFormsEntries.push(ent);
+          else if (word.kanjiForms === void 0 && validWordReadings.has(ent.word))
+            readingEntries.push(ent);
+        }
+        for (const entry of entriesWithForms) {
+          const elem = titleFormMap.get(entry.word);
+          if (elem && entry.forms.some((form) => elem.has(form.form)))
+            readingWithFormsEntries.push(entry);
+        }
+        for (const entry of entriesWithFormTitles)
+          if (readingForms.has(entry.word)) 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 (readingEntries.length > 0)
+          for (const readingEntry of readingEntries)
+            parseEntry(readingEntry, definitions, definitionMap);
+        if (definitions.length > 0)
+          japaneseDefinitions.push({
+            wordID: word.id,
+            definitions
+          });
+      }
+      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;
+      }
+      resolve(japaneseDefinitions);
+    } catch (err) {
+      reject(err);
+    }
+  });
+}
 function lookupWordNote(key, notes, tags, required, fallback) {
   const info = noteMap.get(
     key.toLowerCase()
@@ -1520,7 +1785,7 @@ var wordAddNoteArray = (arr, cb) => {
   if (!arr) return;
   for (const v of arr) cb(v);
 };
-function getWord(dict, id, kanjiDic, examples, dictWord, noteTypeName, deckPath) {
+function getWord(dict, id, kanjiDic, examples, definitions, dictWord, noteTypeName, deckPath) {
   try {
     if (!dictWord && id && dict)
       dictWord = dict.find((entry) => entry.id === id);
@@ -1534,7 +1799,10 @@ function getWord(dict, id, kanjiDic, examples, dictWord, noteTypeName, deckPath)
         ...deckPath ? { deckPath } : {},
         tags: []
       };
-      if (dictWord.isCommon === true) word.common = true;
+      if (dictWord.isCommon === true) {
+        word.common = true;
+        word.tags.push("word::common");
+      }
       if (dictWord.kanjiForms)
         word.kanjiForms = dictWord.kanjiForms.map(
           (dictKanjiForm) => ({
@@ -1583,12 +1851,16 @@ function getWord(dict, id, kanjiDic, examples, dictWord, noteTypeName, deckPath)
           (translation) => {
             if (typeof translation === "string") return translation;
             else {
-              if (translation.type === "lit")
+              if (translation.type === "lit") {
                 translationTypes.push("Literal meaning");
-              else if (translation.type === "expl")
+                word.tags.push("word::literal_meaning");
+              } else if (translation.type === "expl") {
                 translationTypes.push("Explanation");
-              else if (translation.type === "tm")
+                word.tags.push("word::explanation");
+              } else if (translation.type === "tm") {
                 translationTypes.push("Trademark");
+                word.tags.push("word::trademark");
+              }
               return translation.translation;
             }
           }
@@ -1638,7 +1910,10 @@ function getWord(dict, id, kanjiDic, examples, dictWord, noteTypeName, deckPath)
           notes
         };
       });
-      if (dictWord.usuallyInKana === true) word.usuallyInKana = true;
+      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)
@@ -1649,35 +1924,44 @@ function getWord(dict, id, kanjiDic, examples, dictWord, noteTypeName, deckPath)
               (kanji) => kanji.kanji === char
             );
             if (dictKanji) {
-              const kanjiObj = getKanji(
-                dictKanji.kanji,
-                kanjiDic,
-                void 0
-              );
+              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;
+        if (word.kanji.length === 0) {
+          delete word.kanji;
+          word.tags.push("word::no_kanji");
+        }
       }
       if (dictWord.hasPhrases === true && examples) {
         const readings = new Set(
           word.readings.filter(
-            (reading) => (!reading.notes || !reading.notes.some(
+            (reading) => (reading.notes === void 0 || !reading.notes.some(
               (note) => notSearchedForms.has(note)
             )) && (word.common === void 0 || reading.common === true)
           ).map((reading) => reading.reading)
         );
+        const existValidKf = word.kanjiForms && word.kanjiForms.length > 0 ? word.kanjiForms.some(
+          (kf) => (kf.notes === void 0 || !kf.notes.some(
+            (note) => notSearchedForms.has(note)
+          )) && (word.common === void 0 || kf.common === true)
+        ) : void 0;
         const kanjiForms = word.kanjiForms && word.kanjiForms.length > 0 ? new Set(
-          word.kanjiForms.map(
-            (kanjiForm) => kanjiForm.kanjiForm
-          )
+          word.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);
+            else return true;
+          }).map((kanjiForm) => kanjiForm.kanjiForm)
         ) : void 0;
-        const kanjiFormExamples = [];
+        let kanjiFormExamples = [];
         const readingMatchingKanjiFormExamples = [];
         const readingExamples = [];
+        const readingMatchingKanjiForms = /* @__PURE__ */ new Set();
         for (const example of examples)
           for (let i = 0; i < example.parts.length; i++) {
             const part = example.parts[i];
@@ -1685,12 +1969,18 @@ function getWord(dict, id, kanjiDic, examples, dictWord, noteTypeName, deckPath)
             const readingAsInflectedFormMatch = part.inflectedForm !== void 0 && readings.has(part.inflectedForm);
             const referenceIDMatch = part.referenceID !== void 0 && word.id !== void 0 && part.referenceID === word.id;
             if (kanjiForms && kanjiForms.has(part.baseForm) || referenceIDMatch) {
-              if (readingAsReadingMatch || readingAsInflectedFormMatch)
+              if (readingAsReadingMatch || readingAsInflectedFormMatch) {
                 readingMatchingKanjiFormExamples.push({
                   ex: example,
                   partIndex: i
                 });
-              else kanjiFormExamples.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);
@@ -1699,11 +1989,16 @@ function getWord(dict, id, kanjiDic, examples, dictWord, noteTypeName, deckPath)
               break;
             }
           }
+        if (readingMatchingKanjiForms.size > 0)
+          kanjiFormExamples = kanjiFormExamples.filter(
+            (ex) => ex.form && readingMatchingKanjiForms.has(ex.form)
+          );
         const includeKanjiFormExamples = word.kanjiForms !== void 0;
         let wordExamples = [
           ...includeKanjiFormExamples ? [...readingMatchingKanjiFormExamples, ...kanjiFormExamples] : [],
           ...!includeKanjiFormExamples ? readingExamples : []
         ];
+        readingMatchingKanjiForms.clear();
         const glossSpecificExamples = [];
         const seenPhrases = /* @__PURE__ */ new Set();
         for (let i = 0; i < word.translations.length; i++) {
@@ -1733,13 +2028,23 @@ function getWord(dict, id, kanjiDic, examples, dictWord, noteTypeName, deckPath)
               (ex) => !seenPhrases.has(ex.ex.phrase)
             ).slice(0, 5 - glossSpecificExamples.length)
           ];
-        if (wordExamples.length > 0)
+        if (wordExamples.length > 0) {
           word.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 } : {}
           }));
+          word.tags.push("word::has_phrases");
+          if (glossSpecificExamples.length > 0)
+            word.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`);
@@ -1747,35 +2052,46 @@ function getWord(dict, id, kanjiDic, examples, dictWord, noteTypeName, deckPath)
     throw err;
   }
 }
-function getKanji(kanjiChar, dict, jmDict, svgList, noteTypeName, deckPath) {
+function getKanji(dict, kanjiChar, dictKanji, jmDict, svgList, noteTypeName, deckPath) {
   var _a, _b, _c, _d;
   try {
-    const dictKanji = dict.find(
-      (entry) => entry.kanji === kanjiChar
-    );
+    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 ? { grade: dictKanji.misc.frequency } : {},
+        ...dictKanji.misc && dictKanji.misc.frequency ? { frequency: dictKanji.misc.frequency } : {},
         noteID: `kanji_${dictKanji.kanji}`,
         ...noteTypeName ? { noteTypeName } : {},
         ...deckPath ? { deckPath } : {}
       };
-      for (const rm of dictKanji.readingMeaning) {
-        if (rm.nanori && rm.nanori.length > 0) {
-          if (kanji.nanori === void 0) kanji.nanori = [];
-          kanji.nanori.push(...rm.nanori);
-        }
-        for (const group of rm.groups) {
-          kanji.onyomi = group.readings.filter((reading) => reading.type === "ja_on").map((reading) => reading.reading);
-          kanji.kunyomi = group.readings.filter((reading) => reading.type === "ja_kun").map((reading) => reading.reading);
-          if (kanji.onyomi.length === 0) delete kanji.onyomi;
-          if (kanji.kunyomi.length === 0) delete kanji.kunyomi;
-          kanji.meanings = group.meanings;
-          if (kanji.meanings.length === 0) delete kanji.meanings;
+      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);
+          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 (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(
@@ -1789,6 +2105,7 @@ function getKanji(kanjiChar, dict, jmDict, svgList, noteTypeName, deckPath) {
               void 0,
               void 0,
               void 0,
+              void 0,
               word,
               void 0
             );
@@ -1825,6 +2142,7 @@ function getKanji(kanjiChar, dict, jmDict, svgList, noteTypeName, deckPath) {
               void 0,
               void 0,
               void 0,
+              void 0,
               word,
               void 0
             );
@@ -1894,17 +2212,19 @@ function getKanji(kanjiChar, dict, jmDict, svgList, noteTypeName, deckPath) {
         ...kanji.svg ? ["kanji::has_svg"] : []
       );
       return kanji;
-    } else throw new Error(`Kanji ${kanjiChar} not found`);
+    } else
+      throw new Error(`Kanji not found${kanjiChar ? `: ${kanjiChar}` : ""}`);
   } catch (err) {
     throw err;
   }
 }
-function getKanjiExtended(kanjiChar, info, dict, useJpdbWords, jmDict, svgList, noteTypeName, deckPath) {
+function getKanjiExtended(info, dict, kanjiChar, dictKanji, useWords, jmDict, svgList, noteTypeName, deckPath) {
   var _a, _b;
   try {
     const kanji = getKanji(
-      kanjiChar,
       dict,
+      kanjiChar,
+      dictKanji,
       jmDict,
       svgList,
       noteTypeName,
@@ -1914,13 +2234,13 @@ function getKanjiExtended(kanjiChar, info, dict, useJpdbWords, jmDict, svgList,
       kanji.components = info.components;
     if (info.mnemonic && info.mnemonic.length > 0)
       kanji.mnemonic = info.mnemonic;
-    if (useJpdbWords === true && info.words && info.words.length > 0)
+    if (useWords === true && info.words && info.words.length > 0)
       kanji.words = info.words;
     if (kanji.tags) {
       kanji.tags.push(`kanji::components::${((_a = kanji.components) == null ? void 0 : _a.length) ?? 0}`);
       if (kanji.mnemonic && kanji.mnemonic.length > 0)
         kanji.tags.push("kanji::has_mnemonic");
-      if (useJpdbWords === true && kanji.words) {
+      if (useWords === true && kanji.words) {
         if (!kanji.tags.some((tag, index) => {
           var _a2;
           if (tag.startsWith("kanji::words::")) {
@@ -1935,8 +2255,8 @@ function getKanjiExtended(kanjiChar, info, dict, useJpdbWords, jmDict, svgList,
           kanji.tags.push(`kanji::words::${((_b = kanji.words) == null ? void 0 : _b.length) ?? 0}`);
       }
     }
-    if (kanji.fromJpdb === true && (kanji.mnemonic || kanji.components && kanji.components.length > 0 || kanji.words))
-      kanji.source = `https://jpdb.io/kanji/${kanji.kanji}#a`;
+    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;
@@ -1981,32 +2301,50 @@ function generateAnkiNote(entry) {
   if (!entry.noteID) throw new Error("Invalid note ID");
   const fields = [];
   if (isWord(entry)) {
-    if (!entry.translations) throw new Error(`Invalid word: ${entry.noteID}`);
+    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
+    );
+    const otherReadings = entry.readings.length > 1 ? `<details><summary>Show other readings</summary>${entry.readings.slice(1).map(
+      (readingEntry) => createEntry(
+        `<span class="word word-reading">${readingEntry.reading}${readingEntry.audio !== void 0 ? `<br>[sound:${readingEntry.audio}]` : ""}</span>`,
+        readingEntry.notes
+      )
+    ).join("")}</details>` : void 0;
+    const readingsField = [firstReading, ...otherReadings ?? []].join(
+      ""
+    );
+    const firstKanjiForm = entry.kanjiForms ? createEntry(
+      `<span class="word word-kanjiform"><ruby><rb>${entry.kanjiForms[0].kanjiForm}</rb><rt>${entry.readings[0].reading}</rt></ruby></span>`,
+      entry.kanjiForms[0].notes
+    ) : void 0;
+    const otherKanjiForms = entry.kanjiForms && entry.kanjiForms.length > 1 ? `<details><summary>Show other kanji forms</summary>${entry.kanjiForms.slice(1).map((kanjiFormEntry) => {
+      const restrictedReading = entry.readings.find(
+        (r) => r.notes && r.notes.includes(
+          `Reading restricted to ${kanjiFormEntry.kanjiForm}`
+        )
+      );
+      return `${createEntry(`<span class="word word-kanjiform">${restrictedReading ? "<ruby><rb>" : ""}${kanjiFormEntry.kanjiForm}${restrictedReading ? `</rb><rt>${restrictedReading.reading}</rt></ruby>` : ""}</span>`, kanjiFormEntry.notes)}`;
+    }).join("")}</details>` : void 0;
+    const kanjiFormsField = firstKanjiForm ? [firstKanjiForm, ...otherKanjiForms ?? []].join("") : void 0;
+    const firstThreeTranslations = entry.translations.slice(0, 3).map(
+      (translationEntry, index) => `${createEntry(`<span class="word word-translation">${translationEntry.translation}</span>`, translationEntry.notes, void 0, entry.phrases && entry.phrases.some((phrase, index2) => index === index2 && phrase.glossNumber && phrase.glossNumber.wordId === entry.id && phrase.glossNumber.glossNumber === index + 1) ? true : void 0)}`
+    ).join("");
+    const otherTranslations = entry.translations.length > 3 ? `<details><summary>Show other translations</summary>${entry.translations.map(
+      (translationEntry, index) => index > 2 ? `${createEntry(`<span class="word word-translation">${translationEntry.translation}</span>`, translationEntry.notes, void 0, entry.phrases && entry.phrases.some((phrase, index2) => index === index2 && phrase.glossNumber && phrase.glossNumber.wordId === entry.id && phrase.glossNumber.glossNumber === index + 1) ? true : void 0)}` : "null"
+    ).filter((translation) => translation !== "null").join("")}</details>` : void 0;
+    const translationsField = [
+      firstThreeTranslations,
+      ...otherTranslations ?? []
+    ].join("");
     fields.push(
-      ...entry.kanjiForms && !entry.usuallyInKana ? [
-        entry.kanjiForms.map(
-          (kanjiFormEntry, index) => `${index > 0 ? "<details><summary>Show kanji form</summary>" : ""}${createEntry(`<span class="word word-kanjiform">${index === 0 ? "<ruby><rb>" : ""}${kanjiFormEntry.kanjiForm}${index === 0 ? `</rb><rt>${entry.readings[0].reading}</rt></ruby>` : ""}</span>`, kanjiFormEntry.notes)}${index > 0 ? "</details>" : ""}`
-        ).join(""),
-        entry.readings.map(
-          (readingEntry, index) => `${index > 0 ? "<details><summary>Show reading</summary>" : ""}${createEntry(`<span class="word word-reading">${readingEntry.reading}${readingEntry.audio !== void 0 ? `<br>[sound:${readingEntry.audio}]` : ""}</span>`, readingEntry.notes)}${index > 0 ? "</details>" : ""}`
-        ).join("")
-      ] : [
-        entry.readings.map(
-          (readingEntry, index) => `${index > 0 ? "<details><summary>Show reading</summary>" : ""}${createEntry(`<span class="word word-reading">${readingEntry.reading}${readingEntry.audio !== void 0 ? `<br>[sound:${readingEntry.audio}]` : ""}</span>`, readingEntry.notes)}${index > 0 ? "</details>" : ""}`
-        ).join(""),
-        entry.kanjiForms ? entry.kanjiForms.map(
-          (kanjiFormEntry, index) => `${index > 0 ? "<details><summary>Show kanji form</summary>" : ""}${createEntry(`<span class="word word-kanjiform">${index === 0 ? "<ruby><rb>" : ""}${kanjiFormEntry.kanjiForm}${index === 0 ? `</rb><rt>${entry.readings[0].reading}</rt></ruby>` : ""}</span>`, kanjiFormEntry.notes)}${index > 0 ? "</details>" : ""}`
-        ).join("") : noKanjiForms
+      ...entry.kanjiForms && kanjiFormsField && !entry.usuallyInKana ? [kanjiFormsField, readingsField] : [
+        readingsField,
+        entry.kanjiForms && kanjiFormsField ? kanjiFormsField : noKanjiForms
       ],
-      entry.translations.map(
-        (translationEntry, index) => `${index > 2 ? "<details><summary>Show translation</summary>" : ""}${createEntry(`<span class="word word-translation">${translationEntry.translation}</span>`, translationEntry.notes, void 0, entry.phrases && entry.phrases.some((phrase, index2) => index === index2 && phrase.glossNumber && phrase.glossNumber.wordId === entry.id && phrase.glossNumber.glossNumber === index + 1) ? true : void 0)}${index > 2 ? "</details>" : ""}`
-      ).join(""),
-      entry.kanji ? entry.kanji.map(
-        (kanjiEntry) => createEntry(
-          `<span class="word word-kanji">${kanjiEntry.kanji}${kanjiEntry.meanings === void 0 ? " (no meanings)" : ""}</span>`,
-          kanjiEntry.meanings
-        )
-      ).join("") : '<span class="word word-kanji">(no kanji)</span>',
+      translationsField,
       entry.phrases ? entry.phrases.map(
         (phraseEntry, index) => createEntry(
           `<span class="word word-phrase"><span class="word word-phrase-original">${phraseEntry.originalPhrase}</span><span class="word word-phrase-furigana">${phraseEntry.phrase}</span></span>`,
@@ -2017,6 +2355,17 @@ function generateAnkiNote(entry) {
           ) ? true : void 0
         )
       ).join("") : '<span class="word word-phrase">(no phrases) (Search on dictionaries!)</span>',
+      entry.definitions ? entry.definitions.map(
+        (definitionEntry) => createEntry(
+          `<span class="word word-definition>"<span class="word word-definition-original">${definitionEntry.definition}</span><span class="word word-definition-furigana">${definitionEntry.furigana ?? definitionEntry.definition}</span></span>`
+        )
+      ).join("") : '<span class="word word-definition">(no definitions) (Search on ja.wiktionary.org)</span>',
+      entry.kanji ? entry.kanji.map(
+        (kanjiEntry) => createEntry(
+          `<span class="word word-kanji">${kanjiEntry.kanji}${kanjiEntry.meanings === void 0 ? " (no meanings)" : ""}</span>`,
+          kanjiEntry.meanings
+        )
+      ).join("") : '<span class="word word-kanji">(no kanji)</span>',
       ...entry.tags && entry.tags.length > 0 ? [
         entry.tags.map(
           (tag) => tag.trim().toLowerCase().replaceAll(" ", "::")
@@ -2173,12 +2522,12 @@ function generateAnkiNotesFile(list) {
     if (ankiNotes.length === 0) throw new Error("Invalid list");
     return `${headers.join("\n")}
 ${ankiNotes}`;
-  } else console.log("No entries available for Anki notes creation");
-  return void 0;
+  } else throw new Error("No entries available for Anki notes creation");
 }
 export {
   capitalizeString,
   convertJMdict,
+  convertJawiktionary,
   convertKanjiDic,
   convertKradFile,
   convertRadkFile,
@@ -2188,6 +2537,7 @@ export {
   getKanji,
   getKanjiExtended,
   getWord,
+  getWordDefinitions,
   isGrammar,
   isKana,
   isKanji,