ja-compromise 0.0.1 → 0.1.0

package/package.json

@@ -2,13 +2,19 @@
   "author": "Spencer Kelly <spencermountain@gmail.com> (http://spencermounta.in)",
   "name": "ja-compromise",
   "description": "日本語の控えめな自然言語処理",
-  "version": "0.0.1",
-  "main": "./src/index.js",
+  "version": "0.1.0",
+  "engines": {
+    "node": "^22.13.0 || ^24.0.0 || ^26.0.0",
+    "pnpm": "^11.5.0"
+  },
+  "main": "./builds/ja-compromise.mjs",
+  "browser": "./builds/ja-compromise.min.js",
   "unpkg": "./builds/ja-compromise.min.js",
   "type": "module",
   "sideEffects": false,
   "exports": {
     ".": {
+      "types": "./types/index.d.ts",
       "import": "./builds/ja-compromise.mjs",
       "require": "./builds/ja-compromise.cjs"
     }
@@ -18,34 +24,41 @@
     "type": "git",
     "url": "git://github.com/nlp-compromise/ja-compromise.git"
   },
-  "scripts": {
-    "test": "tape \"./tests/**/*.test.js\" | tap-dancer",
-    "testb": "TESTENV=prod npm run test",
-    "build": "npm run version && rollup -c --silent",
-    "version": "node ./scripts/version.js",
-    "pack": "node ./scripts/pack.js",
-    "score": " node ./learn/test/index.js",
-    "watch": "amble ./scratch.js",
-    "stress": "node scripts/stress.js"
-  },
   "files": [
     "builds/",
+    "types/",
+    "src/",
     "docs/"
   ],
   "dependencies": {
-    "compromise": "14.8.2",
+    "compromise": "^14.17.0",
     "efrt": "2.7.0",
-    "suffix-thumb": "4.0.2"
+    "suffix-thumb": "5.0.3"
   },
   "devDependencies": {
-    "@rollup/plugin-alias": "3.1.9",
-    "@rollup/plugin-node-resolve": "13.3.0",
-    "amble": "1.3.0",
-    "rollup": "2.75.7",
-    "rollup-plugin-terser": "7.0.2",
+    "@eslint/js": "^10.0.1",
+    "@rollup/plugin-node-resolve": "16.0.3",
+    "@rollup/plugin-terser": "1.0.0",
+    "cross-env": "10.1.0",
+    "eslint": "10.10.0",
+    "eslint-plugin-regexp": "3.3.0",
+    "rollup": "4.63.1",
     "tap-dancer": "0.3.4",
-    "tape": "5.6.3",
-    "xml-stream": "^0.4.5"
+    "tape": "5.10.2",
+    "typescript": "7.0.2"
   },
-  "license": "MIT"
-}
+  "license": "MIT",
+  "scripts": {
+    "typecheck": "tsc -p tsconfig.json",
+    "test": "tsc -p tsconfig.json && tape \"./tests/**/*.test.js\" | tap-dancer",
+    "testb": "TESTENV=prod pnpm run test",
+    "build": "pnpm run version && rollup -c --silent",
+    "version": "node ./scripts/version.js",
+    "pack": "node ./scripts/pack.js",
+    "score": "node ./learn/test/index.js",
+    "audit": "node ./learn/verbs/audit.js",
+    "lint": "eslint ./src/**/*",
+    "watch": "amble ./scratch.js",
+    "stress": "node scripts/stress.js"
+  }
+}

package/src/01-one/conjugate/conjugate-adj.js

@@ -0,0 +1,53 @@
+// い-adjectives inflect for tense and polarity - they are not 'just adjectives'.
+// 高い → 高くない → 高かった → 高くなかった.  the copula does not carry that tense.
+
+// いい/良い is the one truly irregular い-adjective - it inflects as よい
+const irregularStem = { 'いい': 'よ', '良い': '良', 'よい': 'よ' }
+
+const conjugateAdjective = function (word) {
+  if (!word || !word.endsWith('い') || word.length < 2) {
+    return null
+  }
+  let stem = irregularStem[word] !== undefined ? irregularStem[word] : word.slice(0, -1)
+  return {
+    Infinitive: word,               // 高い
+    PresentTense: word,
+    Negative: stem + 'くない',       // 高くない
+    PastTense: stem + 'かった',      // 高かった
+    PastNegative: stem + 'くなかった', // 高くなかった
+    Gerund: stem + 'くて',           // 高くて
+    Adverb: stem + 'く',             // 高く
+    Provisional: stem + 'ければ',     // 高ければ
+    Presumptive: stem + 'かろう',
+    Polite: word + 'です',
+    PolitePast: stem + 'かったです',
+    PoliteNegative: stem + 'くないです',
+    Superlative: stem + 'すぎる',     // 高すぎる
+    Impression: stem + 'そう',        // 高そう
+    Nominal: stem + 'さ',             // 高さ
+  }
+}
+
+// な-adjectives (形容動詞) are stored bare - 静か - and inflect with the copula
+const conjugateNaAdjective = function (word) {
+  if (!word) {
+    return null
+  }
+  return {
+    Infinitive: word,
+    Adnominal: word + 'な',           // 静かな
+    PresentTense: word + 'だ',        // 静かだ
+    Negative: word + 'じゃない',       // 静かじゃない
+    PastTense: word + 'だった',        // 静かだった
+    PastNegative: word + 'じゃなかった',
+    Gerund: word + 'で',              // 静かで
+    Adverb: word + 'に',              // 静かに
+    Polite: word + 'です',
+    PolitePast: word + 'でした',
+    PoliteNegative: word + 'じゃありません',
+    Provisional: word + 'なら',
+  }
+}
+
+export default conjugateAdjective
+export { conjugateNaAdjective }

package/src/01-one/conjugate/conjugate-verb.js

@@ -0,0 +1,145 @@
+import { aRow, iRow, eRow, oRow, teRow } from './kana.js'
+import verbClass from './verb-class.js'
+
+// the five 'bases' every japanese verb form is built out of.
+// get these right and every suffix falls out of them.
+const toBases = function (dict, cls) {
+  let stem = dict.slice(0, -1)
+  let last = dict[dict.length - 1]
+  switch (cls) {
+    case 'godan':
+      return {
+        negStem: stem + aRow[last],   // 未然形 - 書か
+        stem: stem + iRow[last],      // 連用形 - 書き
+        cond: stem + eRow[last],      // 仮定形 - 書け
+        imper: stem + eRow[last],     // 命令形 - 書け
+        volit: stem + oRow[last] + 'う', // 意向形 - 書こう
+        te: stem + teRow[last],       // て形   - 書いて
+        potential: stem + eRow[last] + 'る',
+        passive: stem + aRow[last] + 'れる',
+        causative: stem + aRow[last] + 'せる',
+      }
+    case 'ichidan': {
+      let s = dict.slice(0, -1) // 食べ
+      // くれる is the one ichidan verb with a bare imperative - くれ, not くれろ
+      let imper = /(呉れる|くれる)$/.test(dict) ? s : s + 'ろ'
+      return {
+        negStem: s, stem: s, cond: s + 'れ', imper: imper,
+        volit: s + 'よう', te: s + 'て',
+        potential: s + 'られる', passive: s + 'られる', causative: s + 'させる',
+      }
+    }
+    case 'suru': {
+      let pre = dict.slice(0, -2) // 勉強
+      return {
+        negStem: pre + 'し', stem: pre + 'し', cond: pre + 'すれ', imper: pre + 'しろ',
+        volit: pre + 'しよう', te: pre + 'して',
+        potential: pre === '' ? 'できる' : pre + 'できる',
+        passive: pre + 'される', causative: pre + 'させる',
+      }
+    }
+    case 'kuru': {
+      let pre = dict.slice(0, -2)
+      let kana = dict.endsWith('くる')
+      let ko = kana ? 'こ' : '来'
+      let ki = kana ? 'き' : '来'
+      let ku = kana ? 'く' : '来'
+      return {
+        negStem: pre + ko, stem: pre + ki, cond: pre + ku + 'れ', imper: pre + ko + 'い',
+        volit: pre + ko + 'よう', te: pre + ki + 'て',
+        potential: pre + ko + 'られる', passive: pre + ko + 'られる', causative: pre + ko + 'させる',
+      }
+    }
+    case 'aru': {
+      let s = dict.slice(0, -1) // あ / 有 / 在
+      return {
+        negStem: null, // ある has no 未然形 - its negative is just ない
+        stem: s + 'り', cond: s + 'れ', imper: s + 'れ', volit: s + 'ろう', te: s + 'って',
+        potential: s + 'れる', passive: s + 'られる', causative: s + 'らせる',
+      }
+    }
+    case 'iku': { // 行く takes って, not the regular いて
+      let s = dict.slice(0, -1)
+      return {
+        negStem: s + 'か', stem: s + 'き', cond: s + 'け', imper: s + 'け', volit: s + 'こう',
+        te: s + 'って',
+        potential: s + 'ける', passive: s + 'かれる', causative: s + 'かせる',
+      }
+    }
+    case 'ou': { // 問う/請う keep うて rather than って
+      let s = dict.slice(0, -1)
+      return {
+        negStem: s + 'わ', stem: s + 'い', cond: s + 'え', imper: s + 'え', volit: s + 'おう',
+        te: s + 'うて',
+        potential: s + 'える', passive: s + 'われる', causative: s + 'わせる',
+      }
+    }
+    case 'aru5': { // くださる/なさる - godan, but the masu-stem drops the り
+      let s = dict.slice(0, -1)
+      return {
+        negStem: s + 'ら', stem: s + 'い', cond: s + 'れ', imper: s + 'い', volit: s + 'ろう',
+        te: s + 'って',
+        potential: s + 'れる', passive: s + 'られる', causative: s + 'らせる',
+      }
+    }
+    default:
+      return null
+  }
+}
+
+// て → た,  で → だ
+const teToTa = (te) => te.replace(/て$/, 'た').replace(/で$/, 'だ')
+
+/** produce the full paradigm of a dictionary-form verb */
+const conjugate = function (dict, hint) {
+  let cls = verbClass(dict, hint)
+  if (!cls) {
+    return null
+  }
+  let b = toBases(dict, cls)
+  if (!b) {
+    return null
+  }
+  // ある is the one verb whose plain negative isn't built on a 未然形
+  let negative = b.negStem === null ? 'ない' : b.negStem + 'ない'
+  let pastNegative = b.negStem === null ? 'なかった' : b.negStem + 'なかった'
+  let te = b.te
+  let past = teToTa(te)
+
+  return {
+    class: cls,
+    Infinitive: dict,               // 辞書形 - 書く
+    Stem: b.stem,                   // 連用形 - 書き
+    PresentTense: dict,
+    PastTense: past,                // 書いた
+    Negative: negative,             // 書かない
+    PastNegative: pastNegative,     // 書かなかった
+    Gerund: te,                     // 書いて  (て形)
+    NegativeGerund: b.negStem === null ? 'なくて' : b.negStem + 'なくて',
+    Polite: b.stem + 'ます',         // 書きます
+    PolitePast: b.stem + 'ました',    // 書きました
+    PoliteNegative: b.stem + 'ません', // 書きません
+    PolitePastNegative: b.stem + 'ませんでした',
+    PoliteVolitional: b.stem + 'ましょう',
+    Imperative: b.imper,            // 書け
+    NegativeImperative: dict + 'な', // 書くな
+    PoliteImperative: te + 'ください',
+    Volitional: b.volit,            // 書こう
+    Potential: b.potential,         // 書ける
+    Passive: b.passive,             // 書かれる
+    Causative: b.causative,         // 書かせる
+    CausativePassive: b.causative.replace(/せる$/, 'せられる'),
+    Conditional: past + 'ら',        // 書いたら (たら)
+    Provisional: b.cond + 'ば',      // 書けば  (ば)
+    Progressive: te + 'いる',        // 書いている
+    ProgressivePolite: te + 'います',
+    PastProgressive: te + 'いた',
+    Desire: b.stem + 'たい',          // 書きたい
+    Representative: past + 'り',      // 書いたり
+    Presumptive: dict + 'だろう',
+    Continuative: b.stem + 'ながら',   // 書きながら
+  }
+}
+
+export default conjugate
+export { toBases, teToTa }

package/src/01-one/conjugate/deconjugate.js

@@ -0,0 +1,178 @@
+import { aRow, iRow, eRow, oRow } from './kana.js'
+import conjugateVerb from './conjugate-verb.js'
+
+// reverse the vowel-row tables, so we can walk a conjugated form back to its dictionary-form
+const invert = (obj) => Object.keys(obj).reduce((h, k) => { h[obj[k]] = k; return h }, {})
+const fromA = invert(aRow)
+const fromI = invert(iRow)
+const fromE = invert(eRow)
+const fromO = invert(oRow)
+
+// which 音便 endings can come from which dictionary-endings
+// ordered by how common the dictionary-ending is, since 走って could in
+// principle come from 走う/走つ/走る - only one of which is a real word
+const fromTe = {
+  'って': ['る', 'う', 'つ'],
+  'んで': ['む', 'ぶ', 'ぬ'],
+  'いて': ['く'],
+  'いで': ['ぐ'],
+  'して': ['す'],
+  'て': [], // bare て means an ichidan stem
+}
+
+const defaultDict = function (stem, base) {
+  let last = stem[stem.length - 1]
+  let head = stem.slice(0, -1)
+  let out = []
+  if (base === 'neg') {
+    if (fromA[last]) out.push(head + fromA[last]) // 書か → 書く
+    out.push(stem + 'る') // 食べ → 食べる
+  } else if (base === 'masu') {
+    if (fromI[last]) out.push(head + fromI[last]) // 書き → 書く
+    out.push(stem + 'る') // 食べ → 食べる
+  } else if (base === 'cond') {
+    if (fromE[last]) out.push(head + fromE[last]) // 書け → 書く
+    out.push(head + fromE[last] + 'る') // 食べれ → 食べる (via れ)
+  } else if (base === 'volit') {
+    if (fromO[last]) out.push(head + fromO[last]) // 書こ → 書く
+  } else if (base === 'te' || base === 'ta') {
+    if (stem === 'し' || stem === 'き' || stem === '来') {
+      return [stem === 'し' ? 'する' : '来る']
+    }
+    // the ending was already consumed, so `stem` still carries the 音便 kana
+    let two = stem.slice(-1) // っ or ん or い
+    if (two === 'っ') {
+      fromTe['って'].forEach((c) => out.push(stem.slice(0, -1) + c))
+      // 行く is the one く-verb that takes って - 行った, not 行いた
+      out.push(stem.slice(0, -1) + 'く')
+    } else if (two === 'ん') {
+      fromTe['んで'].forEach((c) => out.push(stem.slice(0, -1) + c))
+    } else if (two === 'い') {
+      out.push(stem.slice(0, -1) + 'く', stem.slice(0, -1) + 'ぐ')
+    } else if (two === 'し') {
+      out.push(stem.slice(0, -1) + 'す')
+    }
+    out.push(stem + 'る') // ichidan: 食べ + た
+  }
+  return out.filter((s) => s && s.length > 1)
+}
+
+
+// the suffixes we know how to strip, longest-first.
+// `base` says which of the five 活用形 the remaining stem is.
+let suffixes = [
+  ['ませんでした', ['Verb', 'PastTense', 'Polite', 'Negative'], 'masu'],
+  ['なかったら', ['Verb', 'ConditionalVerb', 'Negative'], 'neg'],
+  ['なければ', ['Verb', 'ConditionalVerb', 'Negative'], 'neg'],
+  ['ましょう', ['Verb', 'Volitional', 'Polite'], 'masu'],
+  ['なかった', ['Verb', 'PastTense', 'Negative'], 'neg'],
+  ['ないで', ['Verb', 'Gerund', 'Negative'], 'neg'],
+  ['なくて', ['Verb', 'Gerund', 'Negative'], 'neg'],
+  ['ません', ['Verb', 'PresentTense', 'Polite', 'Negative'], 'masu'],
+  ['ました', ['Verb', 'PastTense', 'Polite'], 'masu'],
+  ['ながら', ['Verb', 'Continuative'], 'masu'],
+  ['させる', ['Verb', 'Causative', 'PresentTense'], 'neg'],
+  ['させられる', ['Verb', 'Causative', 'Passive', 'PresentTense'], 'neg'],
+  ['られる', ['Verb', 'Passive', 'PresentTense'], 'neg'],
+  ['たがる', ['Verb', 'Desire', 'PresentTense'], 'masu'],
+  ['ます', ['Verb', 'PresentTense', 'Polite'], 'masu'],
+  ['ない', ['Verb', 'PresentTense', 'Negative'], 'neg'],
+  ['れる', ['Verb', 'Passive', 'PresentTense'], 'neg'],
+  ['せる', ['Verb', 'Causative', 'PresentTense'], 'neg'],
+  ['たい', ['Verb', 'Desire'], 'masu'],
+  ['そう', ['Verb', 'Presumptive'], 'masu'],
+  ['すぎる', ['Verb', 'PresentTense'], 'masu'],
+  ['たら', ['Verb', 'ConditionalVerb'], 'ta'],
+  ['だら', ['Verb', 'ConditionalVerb'], 'ta'],
+  ['たり', ['Verb', 'Representative'], 'ta'],
+  ['だり', ['Verb', 'Representative'], 'ta'],
+  ['ている', ['Verb', 'Progressive', 'PresentTense'], 'te'],
+  ['でいる', ['Verb', 'Progressive', 'PresentTense'], 'te'],
+  ['ています', ['Verb', 'Progressive', 'PresentTense', 'Polite'], 'te'],
+  ['でいます', ['Verb', 'Progressive', 'PresentTense', 'Polite'], 'te'],
+  ['ていた', ['Verb', 'Progressive', 'PastTense'], 'te'],
+  ['でいた', ['Verb', 'Progressive', 'PastTense'], 'te'],
+  ['てる', ['Verb', 'Progressive', 'PresentTense'], 'te'],
+  ['でる', ['Verb', 'Progressive', 'PresentTense'], 'te'],
+  ['た', ['Verb', 'PastTense'], 'ta'],
+  ['だ', ['Verb', 'PastTense'], 'ta'],
+  ['て', ['Verb', 'Gerund'], 'te'],
+  ['で', ['Verb', 'Gerund'], 'te'],
+  ['ば', ['Verb', 'ConditionalVerb'], 'cond'],
+  ['よう', ['Verb', 'Volitional'], 'neg', 'strict'],
+  ['う', ['Verb', 'Volitional'], 'volit', 'strict'],
+]
+// always try the longest ending first - ています must win over ます
+suffixes.sort((a, b) => b[0].length - a[0].length)
+
+// walk a stem in a given 活用形 back to candidate dictionary-forms
+// する and 来る don't decompose like anything else - their stem changes shape
+const suruStem = new Set(['し', 'さ', 'せ', 'す'])
+const kuruStem = new Set(['き', 'こ', 'く', '来'])
+
+const toDict = function (stem, base) {
+  if (!stem) {
+    return []
+  }
+  let last = stem[stem.length - 1]
+  let pre = stem.slice(0, -1)
+  // a bare し/き is する/来る
+  if (stem.length === 1) {
+    if (suruStem.has(last)) return ['する']
+    if (kuruStem.has(last)) return ['来る']
+  }
+  // 勉強し could be 勉強する or a godan 勉強す - a two-character head is
+  // almost always a する-noun (勉強する), a one-character head almost always
+  // a godan verb (話す, 出す, 貸す).
+  if (suruStem.has(last)) {
+    let rest = defaultDict(stem, base)
+    return pre.length >= 2 ? [pre + 'する'].concat(rest) : rest.concat([pre + 'する'])
+  }
+  return defaultDict(stem, base)
+}
+
+/**
+ * take a conjugated verb and work backwards to its dictionary-form.
+ * `isKnown` lets the caller disambiguate 書いた (書く) from a hypothetical 書いる.
+ */
+const deconjugate = function (str, isKnown) {
+  if (!str || str.length < 2) {
+    return null
+  }
+  for (let i = 0; i < suffixes.length; i += 1) {
+    let [suffix, tags, base, strict] = suffixes[i]
+    if (!str.endsWith(suffix) || str.length <= suffix.length) {
+      continue
+    }
+    let stem = str.slice(0, -suffix.length)
+    // 'た'/'だ'/'て'/'で' hang off the 音便 kana, which belongs to the stem
+    let candidates = toDict(stem, base)
+    if (candidates.length === 0) {
+      continue
+    }
+    let hit = isKnown ? candidates.find(isKnown) : null
+    // a 'strict' suffix is too common a word-ending to trust on its own -
+    // 「たろう」 is a name, not the volitional of 「たる」
+    if (strict && !hit) {
+      continue
+    }
+    let root = hit || candidates[0]
+    // sanity-check: does re-conjugating the root actually produce this string?
+    if (hit) {
+      return { root, tags, candidates }
+    }
+    let verified = candidates.find(c => {
+      let forms = conjugateVerb(c)
+      return forms && Object.keys(forms).some(k => forms[k] === str)
+    })
+    if (verified) {
+      return { root: verified, tags, candidates }
+    }
+    return { root, tags, candidates, guess: true }
+  }
+  return null
+}
+
+export default deconjugate
+// exported so tests/tagset.test.js can check these tags are declared
+export { suffixes }

package/src/01-one/conjugate/index.js

@@ -0,0 +1,13 @@
+import conjugateVerb from './conjugate-verb.js'
+import conjugateAdjective, { conjugateNaAdjective } from './conjugate-adj.js'
+import verbClass from './verb-class.js'
+import deconjugate from './deconjugate.js'
+
+export default {
+  verb: conjugateVerb,
+  adjective: conjugateAdjective,
+  naAdjective: conjugateNaAdjective,
+  verbClass,
+  deconjugate,
+}
+export { conjugateVerb, conjugateAdjective, conjugateNaAdjective, verbClass, deconjugate }

package/src/01-one/conjugate/kana.js

@@ -0,0 +1,38 @@
+// vowel-row transforms for godan (五段) verbs
+// the dictionary-form's final kana tells us the row, and each
+// grammatical 'base' (活用形) shifts it to a different vowel
+
+// 未然形 - the 'a' row (takes ない, れる, せる)
+const aRow = {
+  'う': 'わ', 'く': 'か', 'ぐ': 'が', 'す': 'さ', 'つ': 'た',
+  'ぬ': 'な', 'ぶ': 'ば', 'む': 'ま', 'る': 'ら',
+}
+// 連用形 - the 'i' row (takes ます, たい, ながら) - also the 'masu-stem'
+const iRow = {
+  'う': 'い', 'く': 'き', 'ぐ': 'ぎ', 'す': 'し', 'つ': 'ち',
+  'ぬ': 'に', 'ぶ': 'び', 'む': 'み', 'る': 'り',
+}
+// 仮定形/命令形 - the 'e' row (takes ば, る for potential)
+const eRow = {
+  'う': 'え', 'く': 'け', 'ぐ': 'げ', 'す': 'せ', 'つ': 'て',
+  'ぬ': 'ね', 'ぶ': 'べ', 'む': 'め', 'る': 'れ',
+}
+// 意向形 - the 'o' row (takes う for volitional)
+const oRow = {
+  'う': 'お', 'く': 'こ', 'ぐ': 'ご', 'す': 'そ', 'つ': 'と',
+  'ぬ': 'の', 'ぶ': 'ぼ', 'む': 'も', 'る': 'ろ',
+}
+// 音便 - the sound-change used by the て/た forms
+const teRow = {
+  'う': 'って', 'つ': 'って', 'る': 'って',
+  'ぬ': 'んで', 'ぶ': 'んで', 'む': 'んで',
+  'く': 'いて', 'ぐ': 'いで', 'す': 'して',
+}
+
+// kana that can precede る in an ichidan verb (the i-row and e-row)
+const iRowKana = new Set('いきしちにひみりぎじぢびぴ'.split(''))
+const eRowKana = new Set('えけせてねへめれげぜでべぺ'.split(''))
+
+const godanEnding = new Set('うくぐすつぬぶむる'.split(''))
+
+export { aRow, iRow, eRow, oRow, teRow, iRowKana, eRowKana, godanEnding }

package/src/01-one/conjugate/tags.js

@@ -0,0 +1,85 @@
+// which tags each generated verb-form should carry.
+// a form is 'PastTense' *and* 'Polite' *and* 'Negative' all at once - japanese
+// stacks these on one word, so the tag-list has to as well.
+const verbForms = {
+  Infinitive: ['Verb', 'Infinitive', 'PresentTense'],
+  PresentTense: ['Verb', 'PresentTense'],
+  PastTense: ['Verb', 'PastTense'],
+  Negative: ['Verb', 'PresentTense', 'Negative'],
+  PastNegative: ['Verb', 'PastTense', 'Negative'],
+  Gerund: ['Verb', 'Gerund'],
+  NegativeGerund: ['Verb', 'Gerund', 'Negative'],
+  Polite: ['Verb', 'PresentTense', 'Polite'],
+  PolitePast: ['Verb', 'PastTense', 'Polite'],
+  PoliteNegative: ['Verb', 'PresentTense', 'Polite', 'Negative'],
+  PolitePastNegative: ['Verb', 'PastTense', 'Polite', 'Negative'],
+  PoliteVolitional: ['Verb', 'Volitional', 'Polite'],
+  Imperative: ['Verb', 'Imperative'],
+  NegativeImperative: ['Verb', 'Imperative', 'Negative'],
+  Volitional: ['Verb', 'Volitional'],
+  Potential: ['Verb', 'Potential', 'PresentTense'],
+  Passive: ['Verb', 'Passive', 'PresentTense'],
+  Causative: ['Verb', 'Causative', 'PresentTense'],
+  CausativePassive: ['Verb', 'Causative', 'Passive', 'PresentTense'],
+  Conditional: ['Verb', 'ConditionalVerb'],
+  Provisional: ['Verb', 'ConditionalVerb'],
+  Progressive: ['Verb', 'Progressive', 'PresentTense'],
+  ProgressivePolite: ['Verb', 'Progressive', 'PresentTense', 'Polite'],
+  PastProgressive: ['Verb', 'Progressive', 'PastTense'],
+  Desire: ['Verb', 'Desire'],
+  Representative: ['Verb', 'Representative'],
+  Presumptive: ['Verb', 'Presumptive'],
+  Continuative: ['Verb', 'Continuative'],
+  Stem: ['Verb', 'VerbStem'],
+}
+
+const adjForms = {
+  Infinitive: ['Adjective', 'IAdjective', 'PresentTense'],
+  PresentTense: ['Adjective', 'IAdjective', 'PresentTense'],
+  Negative: ['Adjective', 'IAdjective', 'PresentTense', 'Negative'],
+  PastTense: ['Adjective', 'IAdjective', 'PastTense'],
+  PastNegative: ['Adjective', 'IAdjective', 'PastTense', 'Negative'],
+  Gerund: ['Adjective', 'IAdjective', 'Gerund'],
+  Adverb: ['Adverb'],
+  Provisional: ['Adjective', 'IAdjective', 'ConditionalVerb'],
+  Presumptive: ['Adjective', 'IAdjective', 'Presumptive'],
+  Superlative: ['Verb', 'PresentTense'],
+  Impression: ['Adjective', 'Presumptive'],
+  Nominal: ['Noun'],
+}
+
+// 食べたい inflects like an い-adjective - 食べたくない, 食べたかった
+const desireForms = {
+  Infinitive: ['Verb', 'Desire', 'PresentTense'],
+  PresentTense: ['Verb', 'Desire', 'PresentTense'],
+  Negative: ['Verb', 'Desire', 'PresentTense', 'Negative'],
+  PastTense: ['Verb', 'Desire', 'PastTense'],
+  PastNegative: ['Verb', 'Desire', 'PastTense', 'Negative'],
+  Gerund: ['Verb', 'Desire', 'Gerund'],
+  Provisional: ['Verb', 'Desire', 'ConditionalVerb'],
+}
+
+// the passive/potential/causative stems are themselves ichidan verbs, so
+// 褒められる has a past (褒められた) and a polite past (褒められました) of its own
+const derivedForms = {
+  PastTense: ['PastTense'],
+  Negative: ['PresentTense', 'Negative'],
+  PastNegative: ['PastTense', 'Negative'],
+  Gerund: ['Gerund'],
+  Polite: ['PresentTense', 'Polite'],
+  PolitePast: ['PastTense', 'Polite'],
+  PoliteNegative: ['PresentTense', 'Polite', 'Negative'],
+  PolitePastNegative: ['PastTense', 'Polite', 'Negative'],
+  Progressive: ['Progressive', 'PresentTense'],
+  Conditional: ['ConditionalVerb'],
+  Provisional: ['ConditionalVerb'],
+}
+
+// な-adjectives inflect *with the copula* - 静か + でした - and the copula is
+// its own token.  only 静かに is a word in its own right.
+const naAdjForms = {
+  Infinitive: ['Adjective', 'NaAdjective'],
+  Adverb: ['Adverb'],
+}
+
+export { verbForms, adjForms, naAdjForms, desireForms, derivedForms }