@valueerror/ltjs-lang-en 0.0.0-stage → 0.1.1

package/src/lang/en/rules/WordCoherencyRule.js

@@ -0,0 +1,40 @@
+// org.languagetool.rules.en.WordCoherencyRule
+import { AbstractWordCoherencyRule } from '@valueerror/ltjs-core/src/core/rules/AbstractWordCoherencyRule.js';
+import { WordCoherencyDataLoader } from '@valueerror/ltjs-core/src/core/rules/WordCoherencyDataLoader.js';
+import { Example } from '@valueerror/ltjs-core/src/core/rules/model/Examples.js';
+
+let wordMap = null; // Java: static wordMap = new WordCoherencyDataLoader().loadWords("/en/coherency.txt")
+
+// Java: WordCoherencyRule (en)
+export class WordCoherencyRule extends AbstractWordCoherencyRule {
+  static FQCN = 'org.languagetool.rules.en.WordCoherencyRule';
+
+  // Java: WordCoherencyRule(ResourceBundle)
+  constructor(messages) {
+    super(messages);
+    this.getWordMap(); // Java: static initializer runs at class load
+    this.addExamplePair(Example.wrong('He likes archaeology. Really? She likes <marker>archeology</marker>, too.'),
+      Example.fixed('He likes archaeology. Really? She likes <marker>archaeology</marker>, too.'));
+  }
+
+  // Java: WordCoherencyRule#getWordMap()
+  getWordMap() {
+    if (wordMap === null) wordMap = new WordCoherencyDataLoader().loadWords('/en/coherency.txt');
+    return wordMap;
+  }
+
+  // Java: WordCoherencyRule#getMessage(String,String)
+  getMessage(word1, word2) {
+    return "Do not mix variants of the same word ('" + word1 + "' and '" + word2 + "') within a single text.";
+  }
+
+  // Java: WordCoherencyRule#getId()
+  getId() {
+    return 'EN_WORD_COHERENCY';
+  }
+
+  // Java: WordCoherencyRule#getDescription()
+  getDescription() {
+    return 'Coherent spelling of words with two admitted variants.';
+  }
+}

package/src/lang/en/rules/YMDDateCheckFilter.js

@@ -0,0 +1,25 @@
+// org.languagetool.rules.en.YMDDateCheckFilter
+import { registerClass } from '@valueerror/ltjs-core/src/core/resources/ClassBroker.js';
+import { RuntimeException } from '@valueerror/ltjs-core/src/lib/java/errors.js';
+import { YMDDateHelper } from '@valueerror/ltjs-core/src/core/rules/YMDDateHelper.js';
+import { DateCheckFilter } from './DateCheckFilter.js';
+
+// Java: YMDDateCheckFilter
+export class YMDDateCheckFilter extends DateCheckFilter {
+  static FQCN = 'org.languagetool.rules.en.YMDDateCheckFilter';
+  static JAVA_ABSTRACT = false;
+  static JAVA_CONSTRUCTORS = [{ params: [], text: 'public org.languagetool.rules.en.YMDDateCheckFilter()' }];
+
+  ymdDateHelper = new YMDDateHelper();
+
+  // Java: YMDDateCheckFilter#acceptRuleMatch(RuleMatch,Map,int,AnalyzedTokenReadings[],List)
+  acceptRuleMatch(match, args, patternTokenPos, patternTokens, tokenPositions) {
+    if (args.containsKey('year') || args.containsKey('month') || args.containsKey('day')) {
+      throw new RuntimeException("Set only 'weekDay' and 'date' for " + 'YMDDateCheckFilter');
+    }
+    // DEV-017: parent expects token indexes; the wrapper's text values are checked as weekday vs. date text
+    return this.acceptRuleMatchFromText(match, this.ymdDateHelper.parseDate(args));
+  }
+}
+
+registerClass(YMDDateCheckFilter.FQCN, YMDDateCheckFilter);

package/src/lang/en/rules/YMDNewYearDateFilter.js

@@ -0,0 +1,25 @@
+// org.languagetool.rules.en.YMDNewYearDateFilter
+import { registerClass } from '@valueerror/ltjs-core/src/core/resources/ClassBroker.js';
+import { RuntimeException } from '@valueerror/ltjs-core/src/lib/java/errors.js';
+import { YMDDateHelper } from '@valueerror/ltjs-core/src/core/rules/YMDDateHelper.js';
+import { NewYearDateFilter } from './NewYearDateFilter.js';
+
+// Java: YMDNewYearDateFilter
+export class YMDNewYearDateFilter extends NewYearDateFilter {
+  static FQCN = 'org.languagetool.rules.en.YMDNewYearDateFilter';
+  static JAVA_ABSTRACT = false;
+  static JAVA_CONSTRUCTORS = [{ params: [], text: 'public org.languagetool.rules.en.YMDNewYearDateFilter()' }];
+
+  ymdDateHelper = new YMDDateHelper();
+
+  // Java: YMDNewYearDateFilter#acceptRuleMatch(RuleMatch,Map,int,AnalyzedTokenReadings[],List)
+  acceptRuleMatch(match, args, patternTokenPos, patternTokens, tokenPositions) {
+    if (args.containsKey('year') || args.containsKey('month') || args.containsKey('day')) {
+      throw new RuntimeException("Set only 'weekDay' and 'date' for " + 'YMDDateCheckFilter');
+    }
+    args = this.ymdDateHelper.parseDate(args);
+    return super.acceptRuleMatch(this.ymdDateHelper.correctDate(match, args), args, patternTokenPos, patternTokens, tokenPositions);
+  }
+}
+
+registerClass(YMDNewYearDateFilter.FQCN, YMDNewYearDateFilter);

package/src/lang/en/rules/translation/BeoLingusTranslator.js

@@ -0,0 +1,357 @@
+// org.languagetool.rules.en.translation.BeoLingusTranslator (German / English translator, D-019)
+import { readFileSync } from 'node:fs';
+import { Languages } from '@valueerror/ltjs-core/src/core/Languages.js';
+import { GlobalConfig } from '@valueerror/ltjs-core/src/core/rules/model/GlobalConfig.js';
+import { DataSource } from '@valueerror/ltjs-core/src/core/rules/translation/DataSource.js';
+import { TranslationEntry } from '@valueerror/ltjs-core/src/core/rules/translation/TranslationEntry.js';
+import { uppercaseFirstChar } from '@valueerror/ltjs-core/src/core/text/StringTools.js';
+import { IOException, MalformedInputException, NoSuchFileException, RuntimeException } from '@valueerror/ltjs-core/src/lib/java/errors.js';
+import { ArrayIndexOutOfBoundsException } from '@valueerror/ltjs-core/src/lib/java/errors.js';
+import { JavaHashSet } from '@valueerror/ltjs-core/src/lib/java/collections/JavaHashSet.js';
+import { readerLines } from '@valueerror/ltjs-core/src/lib/java/io.js';
+import { Pattern, javaReplaceAll, javaReplaceFirst, javaSplit } from '@valueerror/ltjs-core/src/lib/java/regex/index.js';
+import { javaReplace, javaTrim, toLowerCase } from '@valueerror/ltjs-core/src/lib/java/strings.js';
+import { Inflector } from './Inflector.js';
+import { LoggerFactory } from '@valueerror/ltjs-core/src/lib/slf4j/Logger.js';
+import { currentTimeMillis } from '@valueerror/ltjs-core/src/lib/java/clock.js';
+
+const logger = LoggerFactory.getLogger('org.languagetool.rules.en.translation.BeoLingusTranslator');
+
+const enUsPattern = Pattern.compile('.*?\\w+ \\[(Br|Am)\\.\\] ?/ ?\\w+ \\[(Br|Am)\\.\\].*');
+
+let instance = null;
+
+// Source: https://www.cafe-lingua.de/englische-grammatik/verben-mit-to-infinitiv.php
+const verbsWithTo = new Set(['afford', 'agree', 'aim', 'appear', 'arrange',
+  'attempt', 'beg', 'care', 'choose', 'claim', 'condescend', 'consent', 'dare', 'decide', 'demand', 'deserve',
+  'determine', 'endeavour', 'expect', 'fail', 'forget', 'guarantee', 'happen', 'have', 'help', 'hesitate', 'hope',
+  'learn', 'long', 'manage', 'mean', 'need', 'neglect', 'offer', 'plan', 'prepare', 'pretend', 'proceed', 'promise',
+  'refuse', 'resolve', 'seem', 'stop', 'swear', 'tend', 'threaten', 'trouble', 'undertake', 'volunteer', 'vow', 'want', 'wish']);
+
+// Java: Files.readAllLines(Path) (UTF-8, strict)
+function readAllLines(file) {
+  let buf;
+  try {
+    buf = readFileSync(file.getAbsolutePath());
+  } catch (e) {
+    if (e.code === 'ENOENT' || e.code === 'ENOTDIR') throw new NoSuchFileException(file.getPath());
+    if (e.code === 'EISDIR') throw new IOException('Is a directory');
+    throw new IOException(`${file.getPath()}: ${e.message}`);
+  }
+  let text;
+  try {
+    text = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true }).decode(buf);
+  } catch (e) {
+    if (e instanceof TypeError) throw new MalformedInputException('Input length = 1');
+    throw e;
+  }
+  return readerLines(text);
+}
+
+// Java: BeoLingusTranslator (implements Translator)
+export class BeoLingusTranslator {
+  static FQCN = 'org.languagetool.rules.en.translation.BeoLingusTranslator';
+
+  // Java: BeoLingusTranslator#getInstance(File) / getInstance(GlobalConfig)
+  static getInstance(arg) {
+    if (arg instanceof GlobalConfig || arg === null || arg === undefined) return BeoLingusTranslator.getInstanceFromConfig(arg);
+    const config = new GlobalConfig();
+    config.setBeolingusFile(arg);
+    return BeoLingusTranslator.getInstanceFromConfig(config);
+  }
+
+  // Java: BeoLingusTranslator#getInstance(GlobalConfig)
+  static getInstanceFromConfig(globalConfig) {
+    if (instance === null && globalConfig !== null && globalConfig !== undefined && globalConfig.getBeolingusFile() !== null) {
+      const t1 = currentTimeMillis();
+      logger.info(`Init dict from ${globalConfig.getBeolingusFile()}...`);
+      instance = new BeoLingusTranslator(globalConfig.getBeolingusFile());
+      const t2 = currentTimeMillis();
+      logger.info(`Init dict done (${t2 - t1}ms) - loaded ${instance.getDeEnSize()} de -> en items.`);
+    }
+    return instance;
+  }
+
+  // Java: BeoLingusTranslator#BeoLingusTranslator(File)
+  constructor(file) {
+    this.de2en = new Map();
+    this.en2de = new Map();
+    this.inflector = new Inflector();
+    this.tagger = Languages.getLanguageForShortCode('de').getTagger();
+    const lines = readAllLines(file);
+    for (const line of lines) {
+      if (javaTrim(line).length === 0 || line.startsWith('#')) {
+        continue;
+      }
+      const parts = javaSplit(line, ' :: ');
+      if (parts.length < 1) throw new ArrayIndexOutOfBoundsException('Index 0 out of bounds for length 0');
+      const german = parts[0];
+      if (parts.length < 2) throw new ArrayIndexOutOfBoundsException(`Index 1 out of bounds for length ${parts.length}`);
+      const english = parts[1];
+      const germanParts = javaSplit(german, '\\|');
+      const englishParts = javaSplit(english, '\\|');
+      if (germanParts.length !== englishParts.length) {
+        throw new IOException(`Invalid line format (DE item count != EN item count): ${line}`);
+      }
+      let i = 0;
+      for (const germanPart of germanParts) {
+        this.handleItem(this.de2en, germanParts, englishParts, i, germanPart);
+        // handleItem(en2de, englishParts, germanParts, i, englishParts[i]);  -- direction not supported yet
+        i++;
+      }
+    }
+  }
+
+  // Java: BeoLingusTranslator#handleItem(Map,String[],String[],int,String)
+  handleItem(map, germanParts, englishParts, i, germanPart) {
+    germanPart = javaReplaceAll(germanPart, '/.*?/', ''); // e.g. "oder {conj} /o.; od./"
+    const germanSubParts = this.split(germanPart);
+    for (const germanSubPart of germanSubParts) {
+      const key = this.cleanForLookup(germanSubPart);
+      const oldEntries = map.get(key);
+      if (oldEntries !== undefined) {
+        if (javaTrim(englishParts[i]).length !== 0) {
+          oldEntries.push(new TranslationEntry(this.split(germanPart), this.split(javaTrim(englishParts[i])), germanParts.length));
+          map.set(key, oldEntries);
+        }
+      } else {
+        const l = [];
+        if (javaTrim(englishParts[i]).length !== 0) {
+          l.push(new TranslationEntry(this.split(germanPart), this.split(englishParts[i]), germanParts.length));
+          map.set(key, l);
+        }
+      }
+    }
+  }
+
+  // "tyre [Br.]/tire [Am.] pump" -> "tyre pump [Br.]" + "tire pump [Am.]"
+  // Java: BeoLingusTranslator#split(String)
+  split(s) {
+    const parts = this.splitAtSemicolon(s);
+    const newParts = [];
+    for (const part of parts) {
+      if (enUsPattern.matcher(part).matches()) {
+        const variant1 = javaReplaceFirst(part, '^(.*?)(\\w+) (\\[(?:Br|Am)\\.\\]) ?/ ?\\w+ \\[(?:Br|Am)\\.\\](.*)', '$1$2$4 $3');
+        const variant2 = javaReplaceFirst(part, '^(.*?)(\\w+) (\\[(?:Br|Am)\\.\\]) ?/ ?(\\w+) (\\[(?:Br|Am)\\.\\])(.*)', '$1$4$6 $5');
+        newParts.push(variant1);
+        newParts.push(variant2);
+      } else {
+        newParts.push(part);
+      }
+    }
+    return newParts;
+  }
+
+  // Java: BeoLingusTranslator#getDeEnSize()
+  getDeEnSize() {
+    return this.de2en.size;
+  }
+
+  // split input like "family doctors; family physicians" at ";", unless it's in "{...}":
+  // Java: BeoLingusTranslator#splitAtSemicolon(String)
+  splitAtSemicolon(s) {
+    const list = javaSplit(s, ';\\s+').map((k) => javaTrim(k));
+    const mergedList = [];
+    let mergeListPos = 0;
+    let merging = false;
+    for (const item of list) {
+      const openPos = item.indexOf('{');
+      const closePos = item.indexOf('}');
+      if (merging) {
+        mergedList[mergeListPos - 1] = `${mergedList[mergeListPos - 1]}; ${item}`;
+        mergeListPos--;
+        if (closePos >= 0) {
+          merging = false;
+        }
+      } else if (openPos > closePos) {
+        // ";" inside "{...}" - merge those again
+        mergedList.push(item);
+        merging = true;
+      } else {
+        mergedList.push(item);
+      }
+      mergeListPos++;
+    }
+    return mergedList;
+  }
+
+  // Java: BeoLingusTranslator#translate(String,String,String)
+  translate(term, fromLang, toLang) {
+    let map;
+    if (fromLang === 'de' && toLang === 'en') {
+      map = this.de2en;
+    } else if (fromLang === 'en' && toLang === 'de') {
+      map = this.en2de;
+    } else {
+      throw new RuntimeException(`Not supported: ${fromLang} -> ${toLang}`);
+    }
+    const entries = map.get(toLowerCase(term));
+    const entriesSet = new JavaHashSet();
+    if (entries !== undefined) {
+      entriesSet.addAll(entries);
+    }
+    const translationsForBaseforms = this.getTranslationsForBaseforms(term, map);
+    for (const trans of translationsForBaseforms) {
+      if (entries !== undefined) {
+        const first = entries.find((k) => listEquals(k.getL1(), trans.getL1()));
+        if (first !== undefined && listEquals(first.getL1(), trans.getL1())) {
+          // skip duplicates
+        } else {
+          entriesSet.add(trans);
+        }
+      } else {
+        entriesSet.add(trans);
+      }
+    }
+    const sortedList = [...entriesSet];
+    sortedList.sort((t1, t2) => Math.sign(t2.getItemCount() - t1.getItemCount())); // Integer.compare
+    return sortedList;
+  }
+
+  // Java: BeoLingusTranslator#getTranslationsForBaseforms(String,Map)
+  getTranslationsForBaseforms(term, map) {
+    const result = [];
+    try {
+      const readings = this.tagger.tag([term]);
+      readings.push(...this.tagger.tag([uppercaseFirstChar(term)])); // user can spell German noun lowercase here
+      for (const reading of readings) {
+        const aTokens = reading.getReadings();
+        this.addResultsForTokens(map, aTokens, result);
+      }
+      return result;
+    } catch (e) {
+      if (e instanceof IOException) throw new RuntimeException(`Could not tag '${term}'`, e);
+      throw e;
+    }
+  }
+
+  // Java: BeoLingusTranslator#addResultsForTokens(Map,List,List)
+  addResultsForTokens(map, aTokens, result) {
+    for (const aToken of aTokens) {
+      const lemma = aToken.getLemma();
+      if (lemma !== null && lemma !== undefined) {
+        const tmp = map.get(toLowerCase(lemma));
+        if (tmp !== undefined) {
+          for (const tmpEntry of tmp) {
+            if (!result.some((r) => r.equals(tmpEntry))) {
+              const entry = this.cleanTranslationEntry(tmpEntry, aToken);
+              if (entry !== null) {
+                result.push(entry);
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  // Java: BeoLingusTranslator#cleanTranslationEntry(TranslationEntry,AnalyzedToken)
+  cleanTranslationEntry(tmpEntry, aToken) {
+    const l = [];
+    for (const s of tmpEntry.getL2()) {
+      const inflected = this.inflector.inflect(this.cleanTranslationForReplace(s, null), aToken.getPOSTag());
+      for (const inflectedForm of inflected) {
+        const cleanEntry = `${inflectedForm} ${this.getTranslationSuffix(s)}`;
+        l.push(javaTrim(cleanEntry));
+      }
+    }
+    return l.length > 0 ? new TranslationEntry(tmpEntry.getL1(), l, tmpEntry.getItemCount()) : null;
+  }
+
+  // Java: BeoLingusTranslator#cleanForLookup(String)
+  cleanForLookup(s) {
+    let r = javaReplaceAll(s, '\\{.*?\\}', '');
+    r = javaReplaceAll(r, '\\[.*?\\]', '');
+    r = javaReplaceAll(r, '\\(.*?\\)', '');
+    r = javaReplaceAll(r, '/.*?/\\b', ''); // abbreviations, e.g. "oder {conj} /o.; od./"
+    r = javaReplace(r, 'jdn./etw. ', '');
+    r = javaReplace(r, 'jdm./etw. ', '');
+    r = javaReplace(r, 'etw./jdn. ', '');
+    r = javaReplace(r, 'etw./jdm. ', '');
+    r = javaReplace(r, 'etw. ', '');
+    r = javaReplace(r, 'jdn. ', '');
+    r = javaReplace(r, 'jdm. ', '');
+    return toLowerCase(javaTrim(r));
+  }
+
+  // Java: BeoLingusTranslator#cleanTranslationForReplace(String,String)
+  cleanTranslationForReplace(s, prevWord) {
+    let clean = javaReplaceAll(s, '\\[.*?\\]', ''); // e.g. "[coll.]", "[Br.]"
+    clean = javaReplaceAll(clean, '\\{.*?\\}', ''); // e.g. "to go {went; gone}"
+    clean = javaReplaceAll(clean, '\\(.*?\\)', ''); // e.g. "icebox (old-fashioned)"
+    clean = javaReplace(clean, 'sth./sb.', '');
+    clean = javaReplace(clean, 'sb./sth.', '');
+    clean = javaReplace(clean, 'sth.', '');
+    clean = javaReplace(clean, 'sb.', '');
+    clean = javaReplaceAll(clean, '/[A-Z]+/', ''); // e.g. "heavy goods vehicle /HGV/"
+    clean = javaReplaceAll(clean, ' /[A-Z][a-z]+\\.?/', ''); // e.g. "Tuesday /Tue/", "station /Sta./"
+    clean = javaReplace(clean, '<> ', ''); // "to fathom out <> sth."
+    clean = javaReplaceAll(clean, '<(.*)>', ''); // "decease [adm.]; demise [poet.] <death>"
+    clean = javaReplaceAll(clean, '\\s+', ' ');
+    clean = javaTrim(clean);
+    if ('to' === prevWord && clean.startsWith('to ')) {
+      return clean.substring(3);
+    }
+    if ('to' !== prevWord && clean.startsWith('to ') && !verbsWithTo.has(prevWord)) {
+      return clean.substring(3);
+    }
+    return clean;
+  }
+
+  // Java: BeoLingusTranslator#getMessage()
+  getMessage() {
+    return 'Translate to English?';
+  }
+
+  // Java: BeoLingusTranslator#getTranslationSuffix(String)
+  getTranslationSuffix(s) {
+    let sb = '';
+    const lookingFor = [];
+    const remove = (x) => {
+      const idx = lookingFor.indexOf(x);
+      if (idx >= 0) lookingFor.splice(idx, 1);
+    };
+    for (let i = 0; i < s.length; i++) {
+      const c = s.charAt(i);
+      if (c === '[') {
+        lookingFor.push(']');
+      } else if (c === ']' && lookingFor.includes(']')) {
+        sb += c;
+        sb += ' ';
+        remove(']');
+      } else if (c === '<') {
+        lookingFor.push('>');
+      } else if (c === '>' && lookingFor.includes('>')) {
+        sb += c;
+        sb += ' ';
+        remove('>');
+      } else if (c === '(') {
+        lookingFor.push(')');
+      } else if (c === ')') {
+        sb += c;
+        sb += ' ';
+        remove(')');
+      } else if (c === '{') {
+        lookingFor.push('}');
+      } else if (c === '}') {
+        sb += c;
+        sb += ' ';
+        remove('}');
+      }
+      if (lookingFor.length > 0) {
+        sb += c;
+      }
+    }
+    return javaTrim(sb);
+  }
+
+  // Java: BeoLingusTranslator#getDataSource()
+  getDataSource() {
+    return new DataSource('https://www.gnu.org/licenses/old-licenses/gpl-2.0.en.html', 'BEOLINGUS', 'http://dict.tu-chemnitz.de');
+  }
+}
+
+// Java: List#equals(Object) for lists of strings
+function listEquals(a, b) {
+  return a.length === b.length && a.every((x, i) => x === b[i]);
+}

package/src/lang/en/rules/translation/Inflector.js

@@ -0,0 +1,72 @@
+// org.languagetool.rules.en.translation.Inflector (package-private in Java)
+import { AnalyzedToken } from '@valueerror/ltjs-core/src/core/AnalyzedToken.js';
+import { Languages } from '@valueerror/ltjs-core/src/core/Languages.js';
+import { ArrayIndexOutOfBoundsException, IOException, RuntimeException } from '@valueerror/ltjs-core/src/lib/java/errors.js';
+import { replaceOnce } from '@valueerror/ltjs-core/src/lib/java/StringUtils.js';
+import { javaMatches, javaSplit } from '@valueerror/ltjs-core/src/lib/java/regex/index.js';
+
+// Java: Inflector
+export class Inflector {
+  static FQCN = 'org.languagetool.rules.en.translation.Inflector';
+
+  // Java: Inflector#Inflector()
+  constructor() {
+    this.enSynth = Languages.getLanguageForShortCode('en').getSynthesizer();
+  }
+
+  /**
+   * @param enToken base form of English token (from BeoLingus)
+   */
+  // Java: Inflector#inflect(String,String)
+  inflect(enToken, dePosTag) {
+    const parts = javaSplit(replaceOnce(enToken, 'to ', ''), ' ');
+    if (parts.length === 0) {
+      throw new ArrayIndexOutOfBoundsException(`Index ${parts.length - 1} out of bounds for length ${parts.length}`);
+    }
+    const lastPartForms = this.inflectSingleWord(parts[parts.length - 1], dePosTag);
+    const startParts = parts.length > 1 ? parts.slice(0, parts.length - 1).join(' ') : '';
+    const result = [];
+    for (const lastPartForm of lastPartForms) {
+      // only the last part is inflected, e.g. "tire pump" -> "tire pumps"
+      result.push(`${startParts} ${lastPartForm}`.trim());
+    }
+    return result;
+  }
+
+  // Java: Inflector#inflectSingleWord(String,String)
+  inflectSingleWord(enToken, dePosTag) {
+    const forms = [];
+    if (dePosTag === null || dePosTag === undefined) {
+      forms.push(enToken);
+      return forms;
+    }
+    if (javaMatches(dePosTag, 'SUB.*PLU.*')) {
+      forms.push(...this.getForms(enToken, 'NNP?S'));
+    } else if (javaMatches(dePosTag, 'VER:3:SIN:PRÄ.*')) {
+      forms.push(...this.getForms(enToken, 'VBZ'));
+    } else if (javaMatches(dePosTag, 'VER:3:SIN:PRT:.*')) {
+      forms.push(...this.getForms(enToken, 'VBD'));
+    } else if (javaMatches(dePosTag, 'PA1:PRD:GRU:VER')) {
+      forms.push(...this.getForms(enToken, 'VBG'));
+    } else if (javaMatches(dePosTag, 'PA2:PRD:GRU:VER')) {
+      forms.push(...this.getForms(enToken, 'VBN'));
+    } else if (javaMatches(dePosTag, 'ADJ:PRD:KOM|ADJ:.*:KOM.*')) {
+      forms.push(...this.getForms(enToken, 'JJR'));
+    } else if (javaMatches(dePosTag, 'ADJ:.*:SUP.*')) {
+      forms.push(...this.getForms(enToken, 'JJS'));
+    } else {
+      forms.push(enToken);
+    }
+    return forms;
+  }
+
+  // Java: Inflector#getForms(String,String)
+  getForms(enToken, posTagRegex) {
+    try {
+      return [...this.enSynth.synthesize(new AnalyzedToken(enToken, 'fake-value', enToken), posTagRegex, true)];
+    } catch (e) {
+      if (e instanceof IOException) throw new RuntimeException(e);
+      throw e;
+    }
+  }
+}

package/src/lang/en/synthesis/EnglishSynthesizer.js

@@ -0,0 +1,109 @@
+// Java: org.languagetool.synthesis.en.EnglishSynthesizer
+import { getMessageBundleForLanguage } from '@valueerror/ltjs-core/src/core/resources/ResourceBundleTools.js';
+import { Languages } from '@valueerror/ltjs-core/src/core/Languages.js';
+import { registerComponent, sharedComponent } from '@valueerror/ltjs-core/src/core/language/components.js';
+import { BaseSynthesizer } from '@valueerror/ltjs-core/src/core/tagging/synthesis/BaseSynthesizer.js';
+import { lowercaseFirstCharIfCapitalized } from '@valueerror/ltjs-core/src/core/text/StringTools.js';
+import { NullPointerException } from '@valueerror/ltjs-core/src/lib/java/errors.js';
+import { substring } from '@valueerror/ltjs-core/src/lib/java/strings.js';
+import { Pattern } from '@valueerror/ltjs-core/src/lib/java/regex/index.js';
+import { AvsAnRule } from '../rules/AvsAnRule.js';
+
+const RESOURCE_FILENAME = '/en/english_synth.dict';
+const TAGS_FILE_NAME = '/en/english_tags.txt';
+const SOR_FILE_NAME = '/en/en.sor';
+
+const exceptions = ["ne'er", "e'er", "o'er", "ol'", "ma'am", "n't", 'informations'];
+
+// A special tag to add determiners.
+const ADD_DETERMINER = '+DT';
+
+// A special tag to add only indefinite articles.
+const ADD_IND_DETERMINER = '+INDT';
+
+// Java: EnglishSynthesizer
+export class EnglishSynthesizer extends BaseSynthesizer {
+  static FQCN = 'org.languagetool.synthesis.en.EnglishSynthesizer';
+
+  // Java: EnglishSynthesizer#INSTANCE
+  static get INSTANCE() {
+    return sharedComponent(EnglishSynthesizer.FQCN);
+  }
+
+  // Java: EnglishSynthesizer#EnglishSynthesizer() (the deprecated (Language) constructor delegates here)
+  constructor() {
+    super(SOR_FILE_NAME, RESOURCE_FILENAME, TAGS_FILE_NAME, 'en');
+    this.aVsAnRule = new AvsAnRule(getMessageBundleForLanguage(Languages.getLanguageForShortCode('en')));
+  }
+
+  // Java: EnglishSynthesizer#synthesize(AnalyzedToken,String)
+  synthesize2(token, posTag) {
+    if (posTag === null || posTag === undefined) {
+      throw new NullPointerException('Cannot invoke "String.startsWith(String)" because "posTag" is null');
+    }
+    if (posTag.startsWith(this.SPELLNUMBER_TAG)) {
+      return super.synthesize2(token, posTag);
+    }
+    if (token === null || token === undefined) {
+      throw new NullPointerException('Cannot invoke "org.languagetool.AnalyzedToken.getToken()" because "token" is null');
+    }
+    const aOrAn = this.aVsAnRule.suggestAorAn(token.getToken());
+    if (ADD_DETERMINER === posTag) {
+      return [aOrAn, `the ${lowercaseFirstCharIfCapitalized(token.getToken())}`];
+    } else if (ADD_IND_DETERMINER === posTag) {
+      return [aOrAn];
+    }
+    return this.removeExceptions(super.synthesize2(token, posTag));
+  }
+
+  // Java: EnglishSynthesizer#synthesize(AnalyzedToken,String,boolean)
+  synthesize3(token, posTag, posTagRegExp) {
+    if (posTag === null || posTag === undefined) {
+      throw new NullPointerException('Cannot invoke "String.startsWith(String)" because "posTag" is null');
+    }
+    if (posTag.startsWith(this.SPELLNUMBER_TAG)) {
+      return this.synthesize2(token, posTag);
+    }
+    if (posTagRegExp) {
+      let myPosTag = posTag;
+      let det = '';
+      if (posTag.endsWith(ADD_IND_DETERMINER)) {
+        myPosTag = substring(myPosTag, 0, myPosTag.indexOf(ADD_IND_DETERMINER) - '\\'.length);
+        det = this.aVsAnRule.suggestAorAn(token.getLemma());
+        det = det.substring(0, det.indexOf(' ') + ' '.length);
+      } else if (posTag.endsWith(ADD_DETERMINER)) {
+        myPosTag = substring(myPosTag, 0, myPosTag.indexOf(ADD_DETERMINER) - '\\'.length);
+        det = 'the ';
+      }
+
+      this.initPossibleTags();
+      const p = Pattern.compile(myPosTag);
+      const results = [];
+
+      for (const tag of this.possibleTags) {
+        const m = p.matcher(tag);
+        if (m.matches() && token.getLemma() !== null) {
+          this.lookupWithDeterminer(token.getLemma(), tag, results, det);
+        }
+      }
+      return this.removeExceptions(results);
+    }
+    return this.removeExceptions(this.synthesize2(token, posTag));
+  }
+
+  // Java: EnglishSynthesizer#lookup(String,String,List,String)
+  lookupWithDeterminer(lemma, posTag, results, determiner) {
+    const lookup = super.lookup(lemma, posTag);
+    for (const result of lookup) {
+      results.push(determiner + result);
+    }
+  }
+
+  // Java: EnglishSynthesizer#isException(String)
+  isException(w) {
+    // remove: 've, 's, 're...
+    return w.startsWith("'") || exceptions.includes(w);
+  }
+}
+
+registerComponent(EnglishSynthesizer.FQCN, () => new EnglishSynthesizer());

package/src/lang/en/tagging/EnglishHybridDisambiguator.js

@@ -0,0 +1,28 @@
+// org.languagetool.tagging.en.EnglishHybridDisambiguator (spelling_global + multiwords chunkers, then XML rules)
+import { registerComponent } from '@valueerror/ltjs-core/src/core/language/components.js';
+import { AbstractDisambiguator } from '@valueerror/ltjs-core/src/core/tagging/disambiguation/AbstractDisambiguator.js';
+import { MultiWordChunker } from '@valueerror/ltjs-core/src/core/tagging/disambiguation/MultiWordChunker.js';
+import { XmlRuleDisambiguator } from '@valueerror/ltjs-core/src/core/disambiguation/XmlRuleDisambiguator.js';
+
+// Java: EnglishHybridDisambiguator
+export class EnglishHybridDisambiguator extends AbstractDisambiguator {
+  static FQCN = 'org.languagetool.tagging.en.EnglishHybridDisambiguator';
+
+  // Java: EnglishHybridDisambiguator#EnglishHybridDisambiguator(Language)
+  constructor(lang) {
+    super();
+    this.chunker = MultiWordChunker.getInstance('/en/multiwords.txt', true, true, false);
+    this.chunkerGlobal = MultiWordChunker.getInstance('/spelling_global.txt', true, true, false, MultiWordChunker.tagForNotAddingTags);
+    this.disambiguator = new XmlRuleDisambiguator(lang, true);
+    this.chunker.setIgnoreSpelling(true);
+    this.chunker.setRemovePreviousTags(true);
+    this.chunkerGlobal.setIgnoreSpelling(true);
+  }
+
+  // Java: EnglishHybridDisambiguator#disambiguate(AnalyzedSentence) / disambiguate(AnalyzedSentence,CheckCancelledCallback)
+  disambiguate(input, checkCanceled = null) {
+    return this.disambiguator.disambiguate(this.chunker.disambiguate(this.chunkerGlobal.disambiguate(input, checkCanceled), checkCanceled), checkCanceled);
+  }
+}
+
+registerComponent(EnglishHybridDisambiguator.FQCN, (lang) => new EnglishHybridDisambiguator(lang));