henkan 0.9.3 → 1.0.0

package/README.md

@@ -4,7 +4,7 @@ A Node.JS library that helps you convert any dictionary from [EDRDG](https://www
 
 > The library is used for the [Full Japanese Study Deck](https://ankiweb.net/shared/info/1407096987), so some features might be tailored specifically to the deck.
 
-[![npm](https://img.shields.io/npm/v/henkan.svg)](https://www.npmjs.com/package/henkan) [![license](https://img.shields.io/github/license/Ronokof/Henkan)]()
+[![npm](https://img.shields.io/npm/v/henkan.svg)](https://www.npmjs.com/package/henkan) [![license](https://img.shields.io/github/license/Ronokof/Henkan)](https://github.com/Ronokof/Henkan/blob/main/LICENSE.md) ![CI](https://github.com/Ronokof/Henkan/actions/workflows/ci.yml/badge.svg) [![codecov](https://codecov.io/gh/Ronokof/Henkan/branch/main/graph/badge.svg)](https://codecov.io/gh/Ronokof/Henkan)
 
 ---
 

package/dist/index.cjs.js

@@ -32,6 +32,7 @@ var index_exports = {};
 __export(index_exports, {
   capitalizeString: () => capitalizeString,
   convertJMdict: () => convertJMdict,
+  convertJawiktionary: () => convertJawiktionary,
   convertKanjiDic: () => convertKanjiDic,
   convertKradFile: () => convertKradFile,
   convertRadkFile: () => convertRadkFile,
@@ -41,6 +42,7 @@ __export(index_exports, {
   getKanji: () => getKanji,
   getKanjiExtended: () => getKanjiExtended,
   getWord: () => getWord,
+  getWordDefinitions: () => getWordDefinitions,
   isGrammar: () => isGrammar,
   isKana: () => isKana,
   isKanji: () => isKanji,
@@ -1135,6 +1137,7 @@ var import_libxmljs2 = __toESM(require("libxmljs2"));
 var import_xml2js = __toESM(require("xml2js"));
 var import_iconv_lite = __toESM(require("iconv-lite"));
 var import_client_polly = require("@aws-sdk/client-polly");
+var import_readline = require("readline");
 var Kuroshiro = require("kuroshiro");
 var KuromojiAnalyzer = require("kuroshiro-analyzer-kuromoji");
 function capitalizeString(value) {
@@ -1150,6 +1153,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));
@@ -1265,7 +1269,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)
@@ -1276,7 +1280,7 @@ function convertJMdict(xmlString, examples) {
               entryObj.readings.filter(
                 (reading) => reading.notes === void 0 || !reading.notes.some(
                   (note) => notSearchedForms.has(note)
-                ) || reading.commonness && reading.commonness.length > 0
+                ) || reading.commonness
               ).map((reading) => reading.reading)
             );
             const kanjiForms2 = entryObj.kanjiForms ? new Set(
@@ -1377,9 +1381,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;
@@ -1483,7 +1491,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];
@@ -1491,7 +1499,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);
       }
     }
@@ -1552,6 +1560,265 @@ function convertKradFile(kradBuffer, kanjiDic, katakanaList) {
     throw err;
   }
 }
+async function convertJawiktionary(stream) {
+  const rl = (0, import_readline.createInterface)({
+    input: stream,
+    crlfDelay: Infinity
+  });
+  let lineNumber = 0;
+  return await new Promise(
+    async (resolve, reject) => {
+      try {
+        const entries = [];
+        for await (const line of rl) {
+          lineNumber++;
+          let obj = void 0;
+          try {
+            obj = JSON.parse(line.trim());
+          } catch (err) {
+            rl.close();
+            throw new Error(
+              `Invalid JSONL at line ${lineNumber}: ${err.message}`
+            );
+          }
+          if (obj !== void 0 && obj !== null && typeof obj === "object" && obj.lang_code === "ja" && obj.lang === "\u65E5\u672C\u8A9E")
+            entries.push(obj);
+        }
+        rl.close();
+        stream.close();
+        stream.destroy();
+        resolve(entries);
+      } catch (err) {
+        reject(err);
+      }
+    }
+  );
+}
+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()
@@ -1570,7 +1837,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);
@@ -1711,11 +1978,7 @@ 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 } : {}
@@ -1730,28 +1993,29 @@ function getWord(dict, id, kanjiDic, examples, dictWord, noteTypeName, deckPath)
       if (dictWord.hasPhrases === true && examples) {
         const readings = new Set(
           word.readings.filter(
-            (reading) => reading.notes === void 0 || !reading.notes.some(
+            (reading) => (reading.notes === void 0 || !reading.notes.some(
               (note) => notSearchedForms.has(note)
-            ) || reading.common === true
+            )) && (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(
+          (kf) => (kf.notes === void 0 || !kf.notes.some(
             (note) => notSearchedForms.has(note)
-          ) || kf.common === true
+          )) && (word.common === void 0 || kf.common === true)
         ) : void 0;
         const kanjiForms = word.kanjiForms && word.kanjiForms.length > 0 ? new Set(
           word.kanjiForms.filter((kanjiForm) => {
             if (existValidKf === true)
-              return kanjiForm.notes === void 0 || !kanjiForm.notes.some(
+              return (kanjiForm.notes === void 0 || !kanjiForm.notes.some(
                 (note) => notSearchedForms.has(note)
-              ) || kanjiForm.common === true;
+              )) && (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];
@@ -1759,12 +2023,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);
@@ -1773,11 +2043,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++) {
@@ -1822,41 +2097,58 @@ function getWord(dict, id, kanjiDic, examples, dictWord, noteTypeName, deckPath)
             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`);
   } catch (err) {
     throw err;
   }
 }
-function getKanji(kanjiChar, dict, jmDict, svgList, noteTypeName, deckPath) {
+function getKanji(dict, kanjiChar, dictKanji, jmDict, svgList, noteTypeName, deckPath) {
   var _a, _b, _c, _d, _e, _f, _g, _h, _i;
   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(
@@ -1870,6 +2162,7 @@ function getKanji(kanjiChar, dict, jmDict, svgList, noteTypeName, deckPath) {
               void 0,
               void 0,
               void 0,
+              void 0,
               word,
               void 0
             );
@@ -1906,6 +2199,7 @@ function getKanji(kanjiChar, dict, jmDict, svgList, noteTypeName, deckPath) {
               void 0,
               void 0,
               void 0,
+              void 0,
               word,
               void 0
             );
@@ -1975,17 +2269,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, _c, _d;
   try {
     const kanji = getKanji(
-      kanjiChar,
       dict,
+      kanjiChar,
+      dictKanji,
       jmDict,
       svgList,
       noteTypeName,
@@ -1995,13 +2291,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::${(_b = (_a = kanji.components) == null ? void 0 : _a.length) != null ? _b : 0}`);
       if (kanji.mnemonic && kanji.mnemonic.length > 0)
         kanji.tags.push("kanji::has_mnemonic");
-      if (useJpdbWords === true && kanji.words) {
+      if (useWords === true && kanji.words) {
         if (!kanji.tags.some((tag, index) => {
           var _a2, _b2;
           if (tag.startsWith("kanji::words::")) {
@@ -2016,8 +2312,8 @@ function getKanjiExtended(kanjiChar, info, dict, useJpdbWords, jmDict, svgList,
           kanji.tags.push(`kanji::words::${(_d = (_c = kanji.words) == null ? void 0 : _c.length) != null ? _d : 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;
@@ -2106,12 +2402,6 @@ function generateAnkiNote(entry) {
         entry.kanjiForms && kanjiFormsField ? kanjiFormsField : noKanjiForms
       ],
       translationsField,
-      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.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>`,
@@ -2122,6 +2412,20 @@ function generateAnkiNote(entry) {
           ) ? true : void 0
         )
       ).join("") : '<span class="word word-phrase">(no phrases) (Search on dictionaries!)</span>',
+      entry.definitions ? entry.definitions.map(
+        (definitionEntry) => {
+          var _a;
+          return createEntry(
+            `<span class="word word-definition>"<span class="word word-definition-original">${definitionEntry.definition}</span><span class="word word-definition-furigana">${(_a = definitionEntry.furigana) != null ? _a : definitionEntry.definition}</span></span>`
+          );
+        }
+      ).join("") : '<span class="word word-definition">(no definitions) (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(" ", "::")
@@ -2278,13 +2582,13 @@ 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");
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   capitalizeString,
   convertJMdict,
+  convertJawiktionary,
   convertKanjiDic,
   convertKradFile,
   convertRadkFile,
@@ -2294,6 +2598,7 @@ ${ankiNotes}`;
   getKanji,
   getKanjiExtended,
   getWord,
+  getWordDefinitions,
   isGrammar,
   isKana,
   isKanji,