henkan 1.1.0 → 1.1.2

package/dist/index.cjs.js

@@ -101,22 +101,25 @@ 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"]],
-  ["adjective (keiyoushi)", ["adjective::i", "\u3044-adjective"]],
-  ["'taru' adjective", ["adjective::taru", "\u305F\u308B-adjective"]],
-  ["noun (common) (futsuumeishi)", ["common_noun", "Common noun"]],
+  ["adjective (keiyoushi)", ["adjective::i", "\u3044-adjective", "\u5F62\u5BB9\u8A5E"]],
+  ["'taru' adjective", ["adjective::taru", "\u305F\u308B-adjective", "\u5F62\u5BB9\u52D5\u8A5E"]],
+  [
+    "noun (common) (futsuumeishi)",
+    ["common_noun", "Common noun", ["\u540D\u8A5E", "\u9020\u8A9E\u6210\u5206"]]
+  ],
   [
     "pre-noun adjectival (rentaishi)",
-    ["pre-noun_adjectival", "Pre-noun adjectival"]
+    ["pre-noun_adjectival", "Pre-noun adjectival", "\u9023\u4F53\u8A5E"]
   ],
   [
     "noun or verb acting prenominally",
     ["noun_or_verb_acting_prenominally", "Noun or verb acting prenominally"]
   ],
-  ["pronoun", ["pronoun", "Pronoun"]],
-  ["adverb (fukushi)", ["adverb", "Adverb"]],
+  ["pronoun", ["pronoun", "Pronoun", ["\u4EE3\u540D\u8A5E", "\u4EBA\u79F0\u4EE3\u540D\u8A5E"]]],
+  ["adverb (fukushi)", ["adverb", "Adverb", "\u526F\u8A5E"]],
   [
     "adverb taking the 'to' particle",
-    ["takes::to", "Adverb taking the '\u3068' particle"]
+    ["takes::to", "Adverb taking the '\u3068' particle", "\u526F\u8A5E"]
   ],
   [
     "onomatopoeic or mimetic word",
@@ -124,80 +127,100 @@ var noteMap = /* @__PURE__ */ new Map([
   ],
   [
     "nouns which may take the genitive case particle 'no'",
-    ["takes::no", "May take the '\u306E' particle"]
+    ["takes::no", "May take the '\u306E' particle", ["\u540D\u8A5E", "\u9020\u8A9E\u6210\u5206"]]
   ],
   [
     "noun or participle which takes the aux. verb suru",
-    ["takes::suru", "Takes the aux. verb '\u3059\u308B'"]
+    ["takes::suru", "Takes the aux. verb '\u3059\u308B'", "\u52D5\u8A5E"]
   ],
-  ["suru verb - irregular", ["suru_verb", "Irregular \u3059\u308B-verb"]],
-  ["suru verb - special class", ["suru_verb", "Special \u3059\u308B-verb"]],
-  ["ichidan verb", ["ichidan_verb", "Ichidan verb"]],
+  ["suru verb - irregular", ["suru_verb", "Irregular \u3059\u308B-verb", "\u52D5\u8A5E"]],
+  ["suru verb - special class", ["suru_verb", "Special \u3059\u308B-verb", "\u52D5\u8A5E"]],
+  ["ichidan verb", ["ichidan_verb", "Ichidan verb", "\u52D5\u8A5E"]],
   [
     "godan verb with 'ku' ending",
-    ["godan::ku::verb", "Godan verb with '\u304F' ending"]
+    ["godan::ku::verb", "Godan verb with '\u304F' ending", "\u52D5\u8A5E"]
   ],
   [
     "godan verb with 'gu' ending",
-    ["godan::gu::verb", "Godan verb with '\u3050' ending"]
+    ["godan::gu::verb", "Godan verb with '\u3050' ending", "\u52D5\u8A5E"]
   ],
   [
     "godan verb with 'u' ending",
-    ["godan::u::verb", "Godan verb with '\u3046' ending"]
+    ["godan::u::verb", "Godan verb with '\u3046' ending", "\u52D5\u8A5E"]
   ],
   [
     "godan verb with 'tsu' ending",
-    ["godan::tsu::verb", "Godan verb with '\u3064' ending"]
+    ["godan::tsu::verb", "Godan verb with '\u3064' ending", "\u52D5\u8A5E"]
   ],
   [
     "godan verb with 'ru' ending",
-    ["godan::ru::verb", "Godan verb with '\u308B' ending"]
+    ["godan::ru::verb", "Godan verb with '\u308B' ending", "\u52D5\u8A5E"]
   ],
   [
     "godan verb with 'nu' ending",
-    ["godan::nu::verb", "Godan verb with '\u306C' ending"]
+    ["godan::nu::verb", "Godan verb with '\u306C' ending", "\u52D5\u8A5E"]
   ],
   [
     "godan verb with 'mu' ending",
-    ["godan::mu::verb", "Godan verb with '\u3080' ending"]
+    ["godan::mu::verb", "Godan verb with '\u3080' ending", "\u52D5\u8A5E"]
   ],
   [
     "godan verb with 'bu' ending",
-    ["godan::bu::verb", "Godan verb with '\u3076' ending"]
+    ["godan::bu::verb", "Godan verb with '\u3076' ending", "\u52D5\u8A5E"]
   ],
   [
     "godan verb with 'su' ending",
-    ["godan::su::verb", "Godan verb with '\u3059' ending"]
+    ["godan::su::verb", "Godan verb with '\u3059' ending", "\u52D5\u8A5E"]
   ],
   [
     "godan verb with 'u' ending (special class)",
-    ["godan::u::irregular_verb", "Irregular godan verb with '\u3046' ending"]
+    [
+      "godan::u::irregular_verb",
+      "Irregular godan verb with '\u3046' ending",
+      "\u52D5\u8A5E"
+    ]
   ],
   [
     "godan verb with 'ru' ending (irregular verb)",
-    ["godan::ru::irregular_verb", "Irregular godan verb with '\u308B' ending"]
+    [
+      "godan::ru::irregular_verb",
+      "Irregular godan verb with '\u308B' ending",
+      "\u52D5\u8A5E"
+    ]
   ],
   [
     "godan verb - -aru special class",
-    ["godan::aru::irregular_verb", "Irregular godan verb with '-\u3042\u308B' ending"]
+    [
+      "godan::aru::irregular_verb",
+      "Irregular godan verb with '-\u3042\u308B' ending",
+      "\u52D5\u8A5E"
+    ]
   ],
   [
     "godan verb - iku/yuku special class",
     [
       "godan::iku_yuku::irregular_verb",
-      "Irregular godan verb with '\u3044\u304F' or '\u3086\u304F' ending"
+      "Irregular godan verb with '\u3044\u304F' or '\u3086\u304F' ending",
+      "\u52D5\u8A5E"
     ]
   ],
   [
     "irregular nu verb",
-    ["godan::nu::irregular_verb", "Irregular godan verb with '\u306C' ending"]
-  ],
-  ["kuru verb - special class", ["kuru_verb", "Special '\u304F\u308B' verb"]],
-  ["transitive verb", ["transitive_verb", "Transitive verb"]],
-  ["intransitive verb", ["intransitive_verb", "Intransitive verb"]],
-  ["auxiliary verb", ["auxiliary_verb", "Auxiliary verb"]],
-  ["auxiliary adjective", ["adjective::auxiliary", "Auxiliary adjective"]],
-  ["auxiliary", ["auxiliary", "Auxiliary"]],
+    [
+      "godan::nu::irregular_verb",
+      "Irregular godan verb with '\u306C' ending",
+      "\u52D5\u8A5E"
+    ]
+  ],
+  ["kuru verb - special class", ["kuru_verb", "Special '\u304F\u308B' verb", "\u52D5\u8A5E"]],
+  ["transitive verb", ["transitive_verb", "Transitive verb", "\u52D5\u8A5E"]],
+  ["intransitive verb", ["intransitive_verb", "Intransitive verb", "\u52D5\u8A5E"]],
+  ["auxiliary verb", ["auxiliary_verb", "Auxiliary verb", ["\u52D5\u8A5E", "\u52A9\u52D5\u8A5E"]]],
+  [
+    "auxiliary adjective",
+    ["adjective::auxiliary", "Auxiliary adjective", ["\u52A9\u8A5E", "\u52A9\u52D5\u8A5E"]]
+  ],
+  ["auxiliary", ["auxiliary", "Auxiliary", ["\u52A9\u8A5E", "\u52A9\u52D5\u8A5E"]]],
   ["after a verb", ["after::verb", "After a verb"]],
   [
     "after the -te form of a verb",
@@ -293,19 +316,52 @@ var noteMap = /* @__PURE__ */ new Map([
   ],
   ["before an adjective", ["before::adjective", "Before an adjective"]],
   ["after a noun", ["after::noun", "After a noun"]],
-  ["prefix", ["prefix", "Prefix"]],
-  ["noun, used as a prefix", ["prefix_noun", "Noun, used as a prefix"]],
-  ["suffix", ["suffix", "Suffix"]],
-  ["noun, used as a suffix", ["suffix_noun", "Noun, used as a suffix"]],
-  ["counter", ["counter", "Counter"]],
-  ["numeric", ["numeric", "Numeric"]],
-  ["particle", ["particle", "Particle"]],
-  ["conjunction", ["conjunction", "Conjunction"]],
-  ["expression", ["expression", "Expression"]],
-  ["idiomatic expression", ["idiomatic_expression", "Idiomatic expression"]],
-  ["interjection (kandoushi)", ["interjection", "Interjection"]],
-  ["proverb", ["proverb", "Proverb"]],
-  ["yojijukugo", ["yojijukugo", "Yojijukugo"]],
+  ["prefix", ["prefix", "Prefix", ["\u63A5\u982D\u8A9E", "\u63A5\u982D\u8F9E"]]],
+  [
+    "noun, used as a prefix",
+    [
+      "prefix_noun",
+      "Noun, used as a prefix",
+      ["\u540D\u8A5E", "\u9020\u8A9E\u6210\u5206", "\u63A5\u982D\u8A9E", "\u63A5\u982D\u8F9E"]
+    ]
+  ],
+  ["suffix", ["suffix", "Suffix", ["\u63A5\u5C3E\u8A9E", "\u63A5\u5C3E\u8F9E"]]],
+  [
+    "noun, used as a suffix",
+    [
+      "suffix_noun",
+      "Noun, used as a suffix",
+      ["\u540D\u8A5E", "\u9020\u8A9E\u6210\u5206", "\u63A5\u5C3E\u8A9E", "\u63A5\u5C3E\u8F9E"]
+    ]
+  ],
+  ["counter", ["counter", "Counter", "\u52A9\u6570\u8A5E"]],
+  ["numeric", ["numeric", "Numeric", "\u6570\u8A5E"]],
+  ["particle", ["particle", "Particle", ["\u52A9\u8A5E", "\u63A5\u7D9A\u52A9\u8A5E"]]],
+  ["conjunction", ["conjunction", "Conjunction", "\u63A5\u7D9A\u8A5E"]],
+  [
+    "expression",
+    ["expression", "Expression", ["\u6210\u8A9E", "\u6210\u53E5", "\u6163\u7528\u53E5", "\u52D5\u8A5E\u53E5"]]
+  ],
+  [
+    "idiomatic expression",
+    [
+      "idiomatic_expression",
+      "Idiomatic expression",
+      ["\u6210\u8A9E", "\u6210\u53E5", "\u6163\u7528\u53E5", "\u52D5\u8A5E\u53E5"]
+    ]
+  ],
+  [
+    "interjection (kandoushi)",
+    ["interjection", "Interjection", ["\u611F\u52D5\u8A5E", "\u9593\u6295\u8A5E"]]
+  ],
+  [
+    "proverb",
+    ["proverb", "Proverb", ["\u6210\u8A9E", "\u6210\u53E5", "\u6163\u7528\u53E5", "\u52D5\u8A5E\u53E5", "\u3053\u3068\u308F\u3056"]]
+  ],
+  [
+    "yojijukugo",
+    ["yojijukugo", "Yojijukugo", ["\u6210\u8A9E", "\u6210\u53E5", "\u6163\u7528\u53E5", "\u52D5\u8A5E\u53E5"]]
+  ],
   ["archaism", ["archaism", "Archaism"]],
   ["obsolete term", ["obsolete", "Obsolete"]],
   ["dated term", ["dated", "Dated"]],
@@ -318,7 +374,7 @@ var noteMap = /* @__PURE__ */ new Map([
   ["derogatory", ["derogatory", "Derogatory"]],
   ["sensitive", ["sensitive", "Sensitive"]],
   ["euphemistic", ["euphemistic", "Euphemistic"]],
-  ["abbreviation", ["abbreviation", "Abbreviation"]],
+  ["abbreviation", ["abbreviation", "Abbreviation", ["\u7565\u8A9E", "\u982D\u5B57\u8A9E"]]],
   ["male term or language", ["male_language", "Male language"]],
   ["female term or language", ["female_language", "Female language"]],
   [
@@ -502,7 +558,7 @@ var noteMap = /* @__PURE__ */ new Map([
   ],
   [
     "adjective (keiyoushi) - yoi/ii class",
-    ["adjective::yoi/ii", "\u3044-adjective - \u3088\u3044/\u3044\u3044 class"]
+    ["adjective::yoi/ii", "\u3044-adjective - \u3088\u3044/\u3044\u3044 class", "\u5F62\u5BB9\u8A5E"]
   ],
   [
     "'kari' adjective (archaic)",
@@ -511,11 +567,15 @@ var noteMap = /* @__PURE__ */ new Map([
   ["'ku' adjective (archaic)", ["adjective::ku", "'\u304F' adjective (archaic)"]],
   [
     "adjectival nouns or quasi-adjectives (keiyodoshi)",
-    ["na-adjective", "\u306A-adjective"]
+    ["na-adjective", "\u306A-adjective", "\u5F62\u5BB9\u52D5\u8A5E"]
   ],
   [
     "archaic/formal form of na-adjective",
-    ["na-adjective_archaic_or_formal", "archaic/formal form of \u306A-adjective"]
+    [
+      "na-adjective_archaic_or_formal",
+      "archaic/formal form of \u306A-adjective",
+      "\u5F62\u5BB9\u52D5\u8A5E"
+    ]
   ],
   [
     "'shiku' adjective (archaic)",
@@ -524,235 +584,264 @@ var noteMap = /* @__PURE__ */ new Map([
   ["copula", ["copula", "Copula"]],
   [
     "expressions (phrases, clauses, etc.)",
-    ["expression", "Expression (phrase, clause, etc.)"]
+    [
+      "expression",
+      "Expression (phrase, clause, etc.)",
+      ["\u6210\u8A9E", "\u6210\u53E5", "\u6163\u7528\u53E5", "\u52D5\u8A5E\u53E5"]
+    ]
   ],
   ["adverbial noun (fukushitekimeishi)", ["adverbial_noun", "Adverbial noun"]],
   ["proper noun", ["proper_noun", "Proper noun"]],
   ["noun (temporal) (jisoumeishi)", ["temporal_noun", "Temporal noun"]],
   ["unclassified", ["unclassified", "Unclassified"]],
-  ["verb unspecified", ["unspecified_verb", "Unspecified verb"]],
+  ["verb unspecified", ["unspecified_verb", "Unspecified verb", "\u52D5\u8A5E"]],
   [
     "ichidan verb - kureru special class",
-    ["ichidan_verb::kureru", "Ichidan verb - \u304F\u308C\u308B special class"]
+    ["ichidan_verb::kureru", "Ichidan verb - \u304F\u308C\u308B special class", "\u52D5\u8A5E"]
   ],
   [
     "nidan verb with 'u' ending (archaic)",
-    ["nidan_verb::u", "Nidan verb with '\u3046' ending (archaic)"]
+    ["nidan_verb::u", "Nidan verb with '\u3046' ending (archaic)", "\u52D5\u8A5E"]
   ],
   [
     "nidan verb (upper class) with 'bu' ending (archaic)",
     [
       "nidan_verb::bu::upper_class",
-      "Nidan verb (upper class) with '\u3076' ending (archaic)"
+      "Nidan verb (upper class) with '\u3076' ending (archaic)",
+      "\u52D5\u8A5E"
     ]
   ],
   [
     "nidan verb (lower class) with 'bu' ending (archaic)",
     [
       "nidan_verb::bu::lower_class",
-      "Nidan verb (lower class) with '\u3076' ending (archaic)"
+      "Nidan verb (lower class) with '\u3076' ending (archaic)",
+      "\u52D5\u8A5E"
     ]
   ],
   [
     "nidan verb (upper class) with 'dzu' ending (archaic)",
     [
       "nidan_verb::dzu::upper_class",
-      "Nidan verb (upper class) with '\u3065' ending (archaic)"
+      "Nidan verb (upper class) with '\u3065' ending (archaic)",
+      "\u52D5\u8A5E"
     ]
   ],
   [
     "nidan verb (lower class) with 'dzu' ending (archaic)",
     [
       "nidan_verb::dzu::lower_class",
-      "Nidan verb (lower class) with '\u3065' ending (archaic)"
+      "Nidan verb (lower class) with '\u3065' ending (archaic)",
+      "\u52D5\u8A5E"
     ]
   ],
   [
     "nidan verb (upper class) with 'gu' ending (archaic)",
     [
       "nidan_verb::gu::upper_class",
-      "Nidan verb (upper class) with '\u3050' ending (archaic)"
+      "Nidan verb (upper class) with '\u3050' ending (archaic)",
+      "\u52D5\u8A5E"
     ]
   ],
   [
     "nidan verb (lower class) with 'gu' ending (archaic)",
     [
       "nidan_verb::gu::lower_class",
-      "Nidan verb (lower class) with '\u3050' ending (archaic)"
+      "Nidan verb (lower class) with '\u3050' ending (archaic)",
+      "\u52D5\u8A5E"
     ]
   ],
   [
     "nidan verb (upper class) with 'hu/fu' ending (archaic)",
     [
       "nidan_verb::hu/fu::upper_class",
-      "Nidan verb (upper class) with '\u3075' ending (archaic)"
+      "Nidan verb (upper class) with '\u3075' ending (archaic)",
+      "\u52D5\u8A5E"
     ]
   ],
   [
     "nidan verb (lower class) with 'hu/fu' ending (archaic)",
     [
       "nidan_verb::hu/fu::lower_class",
-      "Nidan verb (lower class) with '\u3075' ending (archaic)"
+      "Nidan verb (lower class) with '\u3075' ending (archaic)",
+      "\u52D5\u8A5E"
     ]
   ],
   [
     "nidan verb (upper class) with 'ku' ending (archaic)",
     [
       "nidan_verb::ku::upper_class",
-      "Nidan verb (upper class) with '\u304F' ending (archaic)"
+      "Nidan verb (upper class) with '\u304F' ending (archaic)",
+      "\u52D5\u8A5E"
     ]
   ],
   [
     "nidan verb (lower class) with 'ku' ending (archaic)",
     [
       "nidan_verb::ku::lower_class",
-      "Nidan verb (lower class) with '\u304F' ending (archaic)"
+      "Nidan verb (lower class) with '\u304F' ending (archaic)",
+      "\u52D5\u8A5E"
     ]
   ],
   [
     "nidan verb (upper class) with 'mu' ending (archaic)",
     [
       "nidan_verb::mu::upper_class",
-      "Nidan verb (upper class) with '\u3080' ending (archaic)"
+      "Nidan verb (upper class) with '\u3080' ending (archaic)",
+      "\u52D5\u8A5E"
     ]
   ],
   [
     "nidan verb (lower class) with 'mu' ending (archaic)",
     [
       "nidan_verb::mu::lower_class",
-      "Nidan verb (lower class) with '\u3080' ending (archaic)"
+      "Nidan verb (lower class) with '\u3080' ending (archaic)",
+      "\u52D5\u8A5E"
     ]
   ],
   [
     "nidan verb (lower class) with 'nu' ending (archaic)",
     [
       "nidan_verb::nu::lower_class",
-      "Nidan verb (lower class) with '\u306C' ending (archaic)"
+      "Nidan verb (lower class) with '\u306C' ending (archaic)",
+      "\u52D5\u8A5E"
     ]
   ],
   [
     "nidan verb (upper class) with 'ru' ending (archaic)",
     [
       "nidan_verb::ru::upper_class",
-      "Nidan verb (upper class) with '\u308B' ending (archaic)"
+      "Nidan verb (upper class) with '\u308B' ending (archaic)",
+      "\u52D5\u8A5E"
     ]
   ],
   [
     "nidan verb (lower class) with 'ru' ending (archaic)",
     [
       "nidan_verb::ru::lower_class",
-      "Nidan verb (lower class) with '\u308B' ending (archaic)"
+      "Nidan verb (lower class) with '\u308B' ending (archaic)",
+      "\u52D5\u8A5E"
     ]
   ],
   [
     "nidan verb (lower class) with 'su' ending (archaic)",
     [
       "nidan_verb::su::lower_class",
-      "Nidan verb (lower class) with '\u3059' ending (archaic)"
+      "Nidan verb (lower class) with '\u3059' ending (archaic)",
+      "\u52D5\u8A5E"
     ]
   ],
   [
     "nidan verb (upper class) with 'tsu' ending (archaic)",
     [
       "nidan_verb::tsu::upper_class",
-      "Nidan verb (upper class) with '\u3064' ending (archaic)"
+      "Nidan verb (upper class) with '\u3064' ending (archaic)",
+      "\u52D5\u8A5E"
     ]
   ],
   [
     "nidan verb (lower class) with 'tsu' ending (archaic)",
     [
       "nidan_verb::tsu::lower_class",
-      "Nidan verb (lower class) with '\u3064' ending (archaic)"
+      "Nidan verb (lower class) with '\u3064' ending (archaic)",
+      "\u52D5\u8A5E"
     ]
   ],
   [
     "nidan verb (lower class) with 'u' ending and 'we' conjugation (archaic)",
     [
       "nidan_verb::u_with_we_conjugation::lower_class",
-      "Nidan verb (lower class) with '\u3046' ending and '\u3091' conjugation (archaic)"
+      "Nidan verb (lower class) with '\u3046' ending and '\u3091' conjugation (archaic)",
+      "\u52D5\u8A5E"
     ]
   ],
   [
     "nidan verb (upper class) with 'yu' ending (archaic)",
     [
       "nidan_verb::yu::upper_class",
-      "Nidan verb (upper class) with '\u3086' ending (archaic)"
+      "Nidan verb (upper class) with '\u3086' ending (archaic)",
+      "\u52D5\u8A5E"
     ]
   ],
   [
     "nidan verb (lower class) with 'yu' ending (archaic)",
     [
       "nidan_verb::yu::lower_class",
-      "Nidan verb (lower class) with '\u3086' ending (archaic)"
+      "Nidan verb (lower class) with '\u3086' ending (archaic)",
+      "\u52D5\u8A5E"
     ]
   ],
   [
     "nidan verb (lower class) with 'zu' ending (archaic)",
     [
       "nidan_verb::zu::lower_class",
-      "Nidan verb (lower class) with '\u305A' ending (archaic)"
+      "Nidan verb (lower class) with '\u305A' ending (archaic)",
+      "\u52D5\u8A5E"
     ]
   ],
   [
     "yodan verb with 'bu' ending (archaic)",
-    ["yodan_verb::bu", "Yodan verb with '\u3076' ending (archaic)"]
+    ["yodan_verb::bu", "Yodan verb with '\u3076' ending (archaic)", "\u52D5\u8A5E"]
   ],
   [
     "yodan verb with 'gu' ending (archaic)",
-    ["yodan_verb::gu", "Yodan verb with '\u3050' ending (archaic)"]
+    ["yodan_verb::gu", "Yodan verb with '\u3050' ending (archaic)", "\u52D5\u8A5E"]
   ],
   [
     "yodan verb with 'hu/fu' ending (archaic)",
-    ["yodan_verb::hu/fu", "Yodan verb with '\u3075' ending (archaic)"]
+    ["yodan_verb::hu/fu", "Yodan verb with '\u3075' ending (archaic)", "\u52D5\u8A5E"]
   ],
   [
     "yodan verb with 'ku' ending (archaic)",
-    ["yodan_verb::ku", "Yodan verb with '\u304F' ending (archaic)"]
+    ["yodan_verb::ku", "Yodan verb with '\u304F' ending (archaic)", "\u52D5\u8A5E"]
   ],
   [
     "yodan verb with 'mu' ending (archaic)",
-    ["yodan_verb::mu", "Yodan verb with '\u3080' ending (archaic)"]
+    ["yodan_verb::mu", "Yodan verb with '\u3080' ending (archaic)", "\u52D5\u8A5E"]
   ],
   [
     "yodan verb with 'nu' ending (archaic)",
-    ["yodan_verb::nu", "Yodan verb with '\u306C' ending (archaic)"]
+    ["yodan_verb::nu", "Yodan verb with '\u306C' ending (archaic)", "\u52D5\u8A5E"]
   ],
   [
     "yodan verb with 'ru' ending (archaic)",
-    ["yodan_verb::ru", "Yodan verb with '\u308B' ending (archaic)"]
+    ["yodan_verb::ru", "Yodan verb with '\u308B' ending (archaic)", "\u52D5\u8A5E"]
   ],
   [
     "yodan verb with 'su' ending (archaic)",
-    ["yodan_verb::su", "Yodan verb with '\u3059' ending (archaic)"]
+    ["yodan_verb::su", "Yodan verb with '\u3059' ending (archaic)", "\u52D5\u8A5E"]
   ],
   [
     "yodan verb with 'tsu' ending (archaic)",
-    ["yodan_verb::tsu", "Yodan verb with '\u3064' ending (archaic)"]
+    ["yodan_verb::tsu", "Yodan verb with '\u3064' ending (archaic)", "\u52D5\u8A5E"]
   ],
   [
     "godan verb - uru old class verb (old form of eru)",
     [
       "godan::uru::irregular_verb",
-      "Godan verb - '\u3046\u308B' old class verb (old form of \u3048\u308B)"
+      "Godan verb - '\u3046\u308B' old class verb (old form of \u3048\u308B)",
+      "\u52D5\u8A5E"
     ]
   ],
   [
     "irregular ru verb, plain form ends with -ri",
     [
       "irregular_ru_verb_plain_form_ending_with_ri",
-      "irregular '\u308B' verb, plain form ends with '-\u308A'"
+      "irregular '\u308B' verb, plain form ends with '-\u308A'",
+      "\u52D5\u8A5E"
     ]
   ],
   [
     "su verb - precursor to the modern suru",
-    ["su_verb", "'\u3059' verb - precursor to the modern \u3059\u308B"]
+    ["su_verb", "'\u3059' verb - precursor to the modern \u3059\u308B", "\u52D5\u8A5E"]
   ],
-  ["suru verb - included", ["suru_verb", "'\u3059\u308B' verb - included"]],
+  ["suru verb - included", ["suru_verb", "'\u3059\u308B' verb - included", "\u52D5\u8A5E"]],
   [
     "ichidan verb - zuru verb (alternative form of -jiru verbs)",
     [
       "ichidan_verb::zuru",
-      "Ichidan verb - '\u305A\u308B' verb (alternative form of '-\u3058\u308B' verbs)"
+      "Ichidan verb - '\u305A\u308B' verb (alternative form of '-\u3058\u308B' verbs)",
+      "\u52D5\u8A5E"
     ]
   ],
   ["agriculture", ["agriculture", "Agriculture term"]],
@@ -1594,11 +1683,42 @@ async function convertJawiktionary(stream) {
     }
   );
 }
+function mapEntry(entry) {
+  if (entry.word === void 0 || typeof entry.word !== "string")
+    throw new Error("Invalid ja.wiktionary entry");
+  return {
+    word: entry.word,
+    ...entry.pos_title && typeof entry.pos_title === "string" ? { pos_title: entry.pos_title } : {},
+    ...isValidArray(entry.senses) ? {
+      senses: entry.senses.filter(
+        (sense) => isValidArray(sense.form_of) && sense.form_of.every(
+          (form) => form.word && typeof form.word === "string"
+        ) || isStringArray(sense.glosses)
+      ).map((sense) => ({
+        ...sense.form_of ? {
+          form_of: sense.form_of.map((form) => ({
+            word: form.word
+          }))
+        } : {},
+        ...sense.glosses ? { glosses: sense.glosses } : {}
+      }))
+    } : {},
+    ...isValidArray(entry.forms) && entry.forms.every((form) => typeof form.form === "string") ? { forms: entry.forms.map((form) => ({ form: form.form })) } : {}
+  };
+}
 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>");
+        let definition = "";
+        for (let i = 0; i < sense.glosses.length; i += 2) {
+          if (i !== 0) {
+            let prev = sense.glosses[i - 1];
+            let cur = sense.glosses[i];
+            if (prev && cur)
+              definition += `${prev}${!prev.endsWith("\u3002") ? "\u3002" : ""}${cur}`;
+          } else definition += sense.glosses[i];
+        }
         if (!definitions.some((def) => def.definition === definition)) {
           if (!definitionMap.has(definition))
             definitionMap.set(definition, { count: 1 });
@@ -1608,9 +1728,16 @@ function parseEntry(entry, definitions, definitionMap) {
       }
   }
 }
-async function getWordDefinitions(entries, jmDict, kanjiDic, generateFurigana) {
+async function getWordDefinitions(entryList, jmDict, generateFurigana) {
   return await new Promise(async (resolve, reject) => {
+    var _a, _b, _c, _d, _e;
     try {
+      const entries = /* @__PURE__ */ new Map();
+      for (const entry of entryList) {
+        const ent = entries.get(entry.word);
+        if (ent) ent.push(mapEntry(entry));
+        else entries.set(entry.word, [mapEntry(entry)]);
+      }
       const japaneseDefinitions = [];
       const definitionMap = /* @__PURE__ */ new Map();
       const validWords = [];
@@ -1630,18 +1757,16 @@ async function getWordDefinitions(entries, jmDict, kanjiDic, generateFurigana) {
               if (!valid) valid = true;
             }
         }
-        if (valid)
-          validWords.push(
-            getWord(void 0, void 0, kanjiDic, void 0, void 0, word)
-          );
+        if (valid) validWords.push(word);
       }
-      const validTitleEntries = [];
-      const entriesWithFormTitlesGlobal = [];
-      const entriesWithFormsGlobal = [];
+      const validTitleEntries = /* @__PURE__ */ new Map();
+      const entriesWithFormTitlesGlobal = /* @__PURE__ */ new Map();
+      const entriesWithFormsGlobal = /* @__PURE__ */ new Map();
       const validFormOfEntries = /* @__PURE__ */ new Set();
       const validGlossesEntries = /* @__PURE__ */ new Set();
       const validFormsEntries = /* @__PURE__ */ new Set();
-      for (const entry of entries) {
+      const ents = Array.from(entries.values()).flat();
+      for (const entry of ents) {
         let valid = false;
         if (validKanjiForms && validKanjiForms.has(entry.word)) {
           valid = true;
@@ -1651,19 +1776,20 @@ async function getWordDefinitions(entries, jmDict, kanjiDic, generateFurigana) {
                 (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;
-                      }
+              else if (isStringArray(sense.glosses)) {
+                for (const gloss of sense.glosses) {
+                  let reading = void 0;
+                  if (gloss !== void 0) {
+                    if (gloss.trim().includes("\u306E\u6F22\u5B57\u8868\u8A18\u3002") || gloss.trim().includes("\u3092\u53C2\u7167\u3002")) {
+                      for (const r of validReadings)
+                        if (gloss.trim().includes(r)) {
+                          reading = r;
+                          break;
+                        }
+                    }
                   }
+                  if (reading) validGlossesEntries.add(entry.word);
                 }
-                if (reading) validGlossesEntries.add(entry.word);
               }
             }
           if (isValidArray(entry.forms)) {
@@ -1671,57 +1797,260 @@ async function getWordDefinitions(entries, jmDict, kanjiDic, generateFurigana) {
               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);
+          const ftEntry = entriesWithFormTitlesGlobal.get(entry.word);
+          if (ftEntry) ftEntry.push(entry);
+          else entriesWithFormTitlesGlobal.set(entry.word, [entry]);
+        }
+        if (valid) {
+          const tEntry = validTitleEntries.get(entry.word);
+          if (tEntry) tEntry.push(entry);
+          else validTitleEntries.set(entry.word, [entry]);
         }
-        if (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);
+        )) {
+          const wfEntry = entriesWithFormsGlobal.get(entry.word);
+          if (wfEntry) wfEntry.push(entry);
+          else entriesWithFormsGlobal.set(entry.word, [entry]);
+        }
       }
+      ents.length = 0;
+      const posMap = /* @__PURE__ */ new Map();
+      const vte = Array.from(
+        validTitleEntries.values()
+      ).flat();
+      const fge = Array.from(
+        entriesWithFormTitlesGlobal.values()
+      ).flat();
+      const wfe = Array.from(
+        entriesWithFormsGlobal.values()
+      ).flat();
+      for (const pos of [
+        "\u540D\u8A5E",
+        "\u52D5\u8A5E",
+        "\u6210\u53E5",
+        "\u526F\u8A5E",
+        "\u5F62\u5BB9\u52D5\u8A5E",
+        "\u52A9\u8A5E",
+        "\u611F\u52D5\u8A5E",
+        "\u4EE3\u540D\u8A5E",
+        "\u63A5\u5C3E\u8F9E",
+        "\u63A5\u982D\u8A9E",
+        "\u9020\u8A9E\u6210\u5206",
+        "\u7565\u8A9E",
+        "\u56FA\u6709\u540D\u8A5E",
+        "\u4EBA\u79F0\u4EE3\u540D\u8A5E",
+        "\u63A5\u982D\u8F9E",
+        "\u63A5\u7D9A\u52A9\u8A5E",
+        "\u9593\u6295\u8A5E",
+        "\u52A9\u52D5\u8A5E",
+        "\u5F62\u5BB9\u8A5E",
+        "\u7E2E\u7D04\u5F62",
+        "\u63A5\u8F9E",
+        "\u63A5\u7D9A\u8A5E",
+        "\u9023\u4F53\u8A5E",
+        "\u4EBA\u540D",
+        "\u8A18\u53F7",
+        "\u6570\u8A5E",
+        "\u6163\u7528\u53E5",
+        "\u3053\u3068\u308F\u3056",
+        "\u52A9\u6570\u8A5E",
+        "\u82F1\u6570\u5B57\u6DF7\u5408\u8868\u8A18",
+        "\u52D5\u8A5E\u53E5",
+        "\u6210\u8A9E",
+        "\u610F\u7FA9",
+        "\u982D\u5B57\u8A9E",
+        "\u63A5\u5C3E\u8A9E"
+      ]) {
+        for (const te of vte)
+          if (te.pos_title === pos || te.pos_title === "\u548C\u8A9E\u306E\u6F22\u5B57\u8868\u8A18") {
+            if (!posMap.has(pos)) posMap.set(pos, {});
+            const posEntries = posMap.get(pos);
+            if (posEntries.title === void 0)
+              posEntries.title = /* @__PURE__ */ new Map();
+            const entryList2 = posEntries.title.get(te.word);
+            if (entryList2) entryList2.push(te);
+            else posEntries.title.set(te.word, [te]);
+          }
+        for (const ft of fge)
+          if (ft.pos_title === pos) {
+            if (!posMap.has(pos)) posMap.set(pos, {});
+            const posEntries = posMap.get(pos);
+            if (posEntries.formTitle === void 0)
+              posEntries.formTitle = /* @__PURE__ */ new Map();
+            const entryList2 = posEntries.formTitle.get(ft.word);
+            if (entryList2) entryList2.push(ft);
+            else posEntries.formTitle.set(ft.word, [ft]);
+          }
+        for (const wf of wfe)
+          if (wf.pos_title === pos) {
+            if (!posMap.has(pos)) posMap.set(pos, {});
+            const posEntries = posMap.get(pos);
+            if (posEntries.form === void 0)
+              posEntries.form = /* @__PURE__ */ new Map();
+            const entryList2 = posEntries.form.get(wf.word);
+            if (entryList2) entryList2.push(wf);
+            else posEntries.form.set(wf.word, [wf]);
+          }
+      }
+      vte.length = 0;
+      fge.length = 0;
+      wfe.length = 0;
+      const wordEntriesPairs = [];
       for (const word of validWords) {
-        const definitions = [];
-        const kanjiFormEntries = [];
-        const readingWithFormsEntries = [];
-        const readingEntries = [];
-        const titleFormMap = /* @__PURE__ */ new Map();
-        const readingForms = /* @__PURE__ */ new Set();
+        const poses = /* @__PURE__ */ new Set();
+        for (const m of word.meanings) {
+          if (m.partOfSpeech)
+            for (const note of m.partOfSpeech) {
+              const noteEntry = noteMap.get(note);
+              if (noteEntry && noteEntry.length === 3) {
+                const notePos = noteEntry[2];
+                if (Array.isArray(notePos))
+                  for (const pos of notePos) {
+                    if (!poses.has(pos)) poses.add(pos);
+                  }
+                else if (typeof notePos === "string" && !poses.has(notePos))
+                  poses.add(notePos);
+              }
+            }
+        }
         const validWordReadings = new Set(
           word.readings.filter(
-            (r) => r.notes === void 0 || !r.notes.some((note) => notSearchedForms.has(note)) || r.common === true
+            (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.common === true
-          ).map((kf) => kf.kanjiForm)
+            ) || kf.commonness !== void 0
+          ).map((kf) => kf.form)
         ) : 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 entriesWithTitles = [];
+        const entriesWithFormTitles = [];
+        const entriesWithForms = [];
+        if (poses.size > 0)
+          for (const pos of poses) {
+            const posEntries = posMap.get(pos);
+            if (posEntries) {
+              if (validWordKanjiForms && (posEntries.title || posEntries.form))
+                for (const kf of validWordKanjiForms) {
+                  const te = (_a = posEntries.title) == null ? void 0 : _a.get(kf);
+                  const fe = (_b = posEntries.form) == null ? void 0 : _b.get(kf);
+                  if (te)
+                    entriesWithTitles.push(
+                      ...te.filter(
+                        (ent) => validFormOfEntries.has(ent.word) || validGlossesEntries.has(ent.word) || validFormsEntries.has(ent.word)
+                      )
+                    );
+                  if (fe)
+                    entriesWithForms.push(
+                      ...fe.filter(
+                        (ent) => ent.forms && ent.forms.some(
+                          (form) => validWordKanjiForms.has(form.form) || validWordReadings.has(form.form)
+                        )
+                      )
+                    );
+                }
+              if (posEntries.title || posEntries.formTitle || posEntries.form)
+                for (const r of validWordReadings) {
+                  const te = (_c = posEntries.title) == null ? void 0 : _c.get(r);
+                  const fe = (_d = posEntries.form) == null ? void 0 : _d.get(r);
+                  const fte = (_e = posEntries.formTitle) == null ? void 0 : _e.get(r);
+                  if (te)
+                    entriesWithTitles.push(
+                      ...te.filter(
+                        (ent) => ent.forms && validWordKanjiForms && ent.forms.some(
+                          (form) => validWordKanjiForms.has(form.form)
+                        ) || validWordKanjiForms === void 0
+                      )
+                    );
+                  if (fe)
+                    entriesWithForms.push(
+                      ...fe.filter(
+                        (ent) => ent.forms && ent.forms.some(
+                          (form) => validWordKanjiForms && validWordKanjiForms.has(form.form) || validWordReadings.has(form.form)
+                        )
+                      )
+                    );
+                  if (fte) entriesWithFormTitles.push(...fte);
+                }
+            }
+          }
+        if (entriesWithTitles.length === 0 && entriesWithFormTitles.length === 0 && entriesWithForms.length === 0) {
+          if (validWordKanjiForms)
+            for (const kf of validWordKanjiForms) {
+              const te = validTitleEntries.get(kf);
+              const fe = entriesWithFormsGlobal.get(kf);
+              if (te)
+                entriesWithTitles.push(
+                  ...te.filter(
+                    (ent) => validFormOfEntries.has(ent.word) || validGlossesEntries.has(ent.word) || validFormsEntries.has(ent.word)
+                  )
+                );
+              if (fe)
+                entriesWithForms.push(
+                  ...fe.filter(
+                    (ent) => ent.forms && ent.forms.some(
+                      (form) => validWordKanjiForms.has(form.form) || validWordReadings.has(form.form)
+                    )
+                  )
+                );
+            }
+          for (const r of validWordReadings) {
+            const te = validTitleEntries.get(r);
+            const fe = entriesWithFormsGlobal.get(r);
+            const fte = entriesWithFormTitlesGlobal.get(r);
+            if (te)
+              entriesWithTitles.push(
+                ...te.filter(
+                  (ent) => ent.forms && validWordKanjiForms && ent.forms.some(
+                    (form) => validWordKanjiForms.has(form.form)
+                  ) || validWordKanjiForms === void 0
+                )
+              );
+            if (fe)
+              entriesWithForms.push(
+                ...fe.filter(
+                  (ent) => ent.forms && ent.forms.some(
+                    (form) => validWordKanjiForms && validWordKanjiForms.has(form.form) || validWordReadings.has(form.form)
+                  )
+                )
+              );
+            if (fte) entriesWithFormTitles.push(...fte);
+          }
+        }
+        if (entriesWithTitles.length > 0 && (entriesWithFormTitles.length > 0 || entriesWithForms.length > 0))
+          wordEntriesPairs.push({
+            word,
+            readings: validWordReadings,
+            ...validWordKanjiForms ? { kanjiForms: validWordKanjiForms } : {},
+            entriesWithTitles,
+            entriesWithFormTitles,
+            entriesWithForms
+          });
+      }
+      for (const pair of wordEntriesPairs) {
+        const definitions = [];
+        const kanjiFormEntries = [];
+        const readingWithFormsEntries = [];
+        const readingEntries = [];
+        const titleFormMap = /* @__PURE__ */ new Map();
+        const refsMap = /* @__PURE__ */ new Map();
+        const readingForms = /* @__PURE__ */ new Set();
+        for (const ent of pair.entriesWithTitles) {
           const validFormOf = validFormOfEntries.has(ent.word);
           const validGlosses = validGlossesEntries.has(ent.word);
           const validForms = validFormsEntries.has(ent.word);
-          if (word.kanjiForms && validWordKanjiForms && validWordKanjiForms.has(ent.word) && (validFormOf || validGlosses || validForms)) {
+          if (pair.kanjiForms && pair.kanjiForms.has(ent.word) && (validFormOf || validGlosses || validForms)) {
             kanjiFormEntries.push(ent);
             if ((validFormOf || validGlosses) && isValidArray(ent.senses))
               for (const sense of ent.senses) {
                 if (validFormOf && isValidArray(sense.form_of)) {
                   for (const form of sense.form_of)
-                    if (form.word && typeof form.word === "string" && validWordReadings.has(form.word)) {
+                    if (form.word && typeof form.word === "string" && pair.readings.has(form.word)) {
                       const elem = titleFormMap.get(
                         form.word
                       );
@@ -1732,43 +2061,53 @@ async function getWordDefinitions(entries, jmDict, kanjiDic, generateFurigana) {
                         );
                       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;
-                        }
+                } else if (validGlosses && isStringArray(sense.glosses)) {
+                  for (const gloss of sense.glosses) {
+                    let reading = void 0;
+                    if (gloss !== void 0) {
+                      if (gloss.trim().includes("\u306E\u6F22\u5B57\u8868\u8A18\u3002") || gloss.trim().includes("\u3092\u53C2\u7167\u3002")) {
+                        for (const r of pair.readings)
+                          if (gloss.trim().includes(r)) {
+                            reading = r;
+                            break;
+                          }
+                      }
+                    }
+                    if (reading) {
+                      const elem = refsMap.get(reading);
+                      if (!elem)
+                        refsMap.set(reading, /* @__PURE__ */ new Set([ent.word]));
+                      else elem.add(ent.word);
                     }
-                  }
-                  if (reading) {
-                    const elem = 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))
+                if (form.form && typeof form.form === "string" && pair.readings.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)))
+          } 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 (word.kanjiForms === void 0 && validWordReadings.has(ent.word))
+          else if (pair.kanjiForms === void 0 && pair.readings.has(ent.word))
             readingEntries.push(ent);
         }
-        for (const entry of entriesWithForms) {
+        for (const entry of pair.entriesWithForms) {
           const elem = titleFormMap.get(entry.word);
           if (elem && entry.forms.some((form) => elem.has(form.form)))
             readingWithFormsEntries.push(entry);
         }
-        for (const entry of entriesWithFormTitles)
-          if (readingForms.has(entry.word)) readingWithFormsEntries.push(entry);
+        for (const entry of pair.entriesWithFormTitles) {
+          if (readingForms.has(entry.word)) {
+            readingWithFormsEntries.push(entry);
+            continue;
+          }
+          if (pair.kanjiForms) {
+            const ft = refsMap.get(entry.word);
+            if (ft && ft.intersection(pair.kanjiForms).size > 0)
+              readingWithFormsEntries.push(entry);
+          }
+        }
         let parsedReadingWithFormsEntries = false;
         for (const entry of kanjiFormEntries)
           if (entry.pos_title === "\u548C\u8A9E\u306E\u6F22\u5B57\u8868\u8A18" && readingWithFormsEntries.length > 0) {
@@ -1787,7 +2126,7 @@ async function getWordDefinitions(entries, jmDict, kanjiDic, generateFurigana) {
             parseEntry(readingEntry, definitions, definitionMap);
         if (definitions.length > 0)
           japaneseDefinitions.push({
-            wordID: word.id,
+            wordID: pair.word.id,
             definitions
           });
       }
@@ -1820,9 +2159,7 @@ async function getWordDefinitions(entries, jmDict, kanjiDic, generateFurigana) {
   });
 }
 function lookupWordNote(key, notes, tags, required, fallback) {
-  const info = noteMap.get(
-    key.toLowerCase()
-  );
+  const info = noteMap.get(key.toLowerCase());
   if (!info) {
     if (required) throw new Error(`Invalid note info for ${key}`);
     if (notes) notes.push(fallback != null ? fallback : key);
@@ -1838,6 +2175,7 @@ var wordAddNoteArray = (arr, cb) => {
   for (const v of arr) cb(v);
 };
 function getWord(dict, id, kanjiDic, examples, definitions, dictWord, noteTypeName, deckPath) {
+  var _a;
   try {
     if (!dictWord && id && dict)
       dictWord = dict.find((entry) => entry.id === id);
@@ -1861,7 +2199,7 @@ function getWord(dict, id, kanjiDic, examples, definitions, dictWord, noteTypeNa
             kanjiForm: dictKanjiForm.form,
             ...dictKanjiForm.notes ? {
               notes: dictKanjiForm.notes.map((note) => {
-                var _a;
+                var _a2;
                 const noteAndTag = lookupWordNote(
                   note,
                   void 0,
@@ -1869,7 +2207,7 @@ function getWord(dict, id, kanjiDic, examples, definitions, dictWord, noteTypeNa
                   false,
                   note
                 );
-                return capitalizeString((_a = noteAndTag.note) != null ? _a : note);
+                return capitalizeString((_a2 = noteAndTag.note) != null ? _a2 : note);
               })
             } : {},
             ...dictKanjiForm.commonness && dictKanjiForm.commonness.length > 0 ? { common: true } : {}
@@ -1883,7 +2221,7 @@ function getWord(dict, id, kanjiDic, examples, definitions, dictWord, noteTypeNa
               (restriction) => `Reading restricted to ${restriction}`
             ) : [],
             ...dictReading.notes ? dictReading.notes.map((note) => {
-              var _a;
+              var _a2;
               const noteAndTag = lookupWordNote(
                 note,
                 void 0,
@@ -1891,7 +2229,7 @@ function getWord(dict, id, kanjiDic, examples, definitions, dictWord, noteTypeNa
                 false,
                 note
               );
-              return capitalizeString((_a = noteAndTag.note) != null ? _a : note);
+              return capitalizeString((_a2 = noteAndTag.note) != null ? _a2 : note);
             }) : []
           ]
         } : {},
@@ -2084,9 +2422,9 @@ function getWord(dict, id, kanjiDic, examples, definitions, dictWord, noteTypeNa
           ];
         if (wordExamples.length > 0) {
           word.phrases = (wordExamples.length > 5 ? wordExamples.slice(0, 5) : wordExamples).map((ex) => {
-            var _a;
+            var _a2;
             return {
-              phrase: (_a = ex.ex.furigana) != null ? _a : ex.ex.phrase,
+              phrase: (_a2 = ex.ex.furigana) != null ? _a2 : ex.ex.phrase,
               translation: ex.ex.translation,
               originalPhrase: ex.ex.phrase,
               ...ex.ex.glossNumber ? { glossNumber: ex.ex.glossNumber } : {}
@@ -2098,10 +2436,10 @@ function getWord(dict, id, kanjiDic, examples, definitions, dictWord, noteTypeNa
         }
       }
       if (definitions) {
-        const pair = definitions.find(
+        const defs = Array.isArray(definitions) ? (_a = definitions.find(
           (wdp) => wdp.wordID === word.id
-        );
-        if (pair) word.definitions = pair.definitions;
+        )) == null ? void 0 : _a.definitions : definitions.get(word.id);
+        if (defs) word.definitions = defs;
       }
       return word;
     } else throw new Error(`Word${id ? ` ${id}` : ""} not found`);
@@ -2420,7 +2758,7 @@ function generateAnkiNote(entry) {
         (definitionEntry) => {
           var _a;
           return createEntry(
-            `<span class="word word-definition${definitionEntry.mayNotBeAccurate === true ? " mnba" : ""}>"<span class="word word-definition-original">${definitionEntry.definition}</span><span class="word word-definition-furigana">${(_a = definitionEntry.furigana) != null ? _a : definitionEntry.definition}</span></span>`
+            `<span class="word word-definition${definitionEntry.mayNotBeAccurate === true ? " mnba" : ""}"><span class="word word-definition-original">${definitionEntry.definition}</span><span class="word word-definition-furigana">${(_a = definitionEntry.furigana) != null ? _a : definitionEntry.definition}</span></span>`
           );
         }
       ).join("") : '<span class="word word-definition">(no definitions)</span>',