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

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

@@ -0,0 +1,45 @@
+// org.languagetool.rules.en.MorfologikSouthAfricanSpellerRule
+import { AbstractEnglishSpellerRule } from './AbstractEnglishSpellerRule.js';
+import { VariantInfo } from './VariantInfo.js';
+import { registerComponent } from '@valueerror/ltjs-core/src/core/language/components.js';
+import { toLowerCase } from '@valueerror/ltjs-core/src/lib/java/strings.js';
+
+const RESOURCE_FILENAME = '/en/hunspell/en_ZA.dict';
+const LANGUAGE_SPECIFIC_PLAIN_TEXT_DICT = 'en/hunspell/spelling_en-ZA.txt';
+let US_ENGLISH = null; // Java: static final Map US_ENGLISH = loadWordlist("en/en-US-GB.txt", 0), initialised with the class
+
+// Java: MorfologikSouthAfricanSpellerRule
+export class MorfologikSouthAfricanSpellerRule extends AbstractEnglishSpellerRule {
+  static FQCN = 'org.languagetool.rules.en.MorfologikSouthAfricanSpellerRule';
+
+  // Java: MorfologikSouthAfricanSpellerRule(ResourceBundle,Language,UserConfig,List) / (ResourceBundle,Language,GlobalConfig,UserConfig,List,LanguageModel,Language)
+  constructor(messages, language, ...rest) {
+    if (US_ENGLISH === null) US_ENGLISH = AbstractEnglishSpellerRule.loadWordlist('en/en-US-GB.txt', 0);
+    super(messages, language, ...rest);
+  }
+
+  // Java: MorfologikSouthAfricanSpellerRule#isValidInOtherVariant(String)
+  isValidInOtherVariant(word) {
+    const otherVariant = US_ENGLISH.get(toLowerCase(word));
+    if (otherVariant !== undefined) {
+      return new VariantInfo('American English', otherVariant);
+    }
+    return null;
+  }
+
+  // Java: MorfologikSouthAfricanSpellerRule#getFileName()
+  getFileName() {
+    return RESOURCE_FILENAME;
+  }
+
+  // Java: MorfologikSouthAfricanSpellerRule#getId()
+  getId() {
+    return 'MORFOLOGIK_RULE_EN_ZA';
+  }
+
+  // Java: MorfologikSouthAfricanSpellerRule#getLanguageVariantSpellingFileName()
+  getLanguageVariantSpellingFileName() {
+    return LANGUAGE_SPECIFIC_PLAIN_TEXT_DICT;
+  }
+}
+registerComponent(MorfologikSouthAfricanSpellerRule.FQCN, (...args) => new MorfologikSouthAfricanSpellerRule(...args));

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

@@ -0,0 +1,25 @@
+// org.languagetool.rules.en.NewYearDateFilter
+import { registerClass } from '@valueerror/ltjs-core/src/core/resources/ClassBroker.js';
+import { AbstractNewYearDateFilter } from '@valueerror/ltjs-core/src/core/rules/AbstractNewYearDateFilter.js';
+import { DateFilterHelper } from './DateFilterHelper.js';
+
+// Java: NewYearDateFilter
+export class NewYearDateFilter extends AbstractNewYearDateFilter {
+  static FQCN = 'org.languagetool.rules.en.NewYearDateFilter';
+  static JAVA_ABSTRACT = false;
+  static JAVA_CONSTRUCTORS = [{ params: [], text: 'public org.languagetool.rules.en.NewYearDateFilter()' }];
+
+  dateFilterHelper = new DateFilterHelper();
+
+  // Java: NewYearDateFilter#getMonth(String)
+  getMonth(localizedMonth) {
+    return this.dateFilterHelper.getMonth(localizedMonth);
+  }
+
+  // Java: NewYearDateFilter#getCalendar()
+  getCalendar() {
+    return this.dateFilterHelper.getCalendar();
+  }
+}
+
+registerClass(NewYearDateFilter.FQCN, NewYearDateFilter);

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

@@ -0,0 +1,56 @@
+// org.languagetool.rules.en.NewZealandReplaceRule
+import { AbstractSimpleReplaceRule2 } from '@valueerror/ltjs-core/src/core/rules/AbstractSimpleReplaceRule2.js';
+import { Categories } from '@valueerror/ltjs-core/src/core/rules/model/Category.js';
+import { ITSIssueType } from '@valueerror/ltjs-core/src/core/rules/model/ITSIssueType.js';
+import { Example } from '@valueerror/ltjs-core/src/core/rules/model/Examples.js';
+import { Objects } from '@valueerror/ltjs-core/src/lib/java/Objects.js';
+import { Locale } from '@valueerror/ltjs-core/src/lib/java/Locale.js';
+import { NewZealandEnglish } from '../language/NewZealandEnglish.js';
+
+const EN_NZ_LOCALE = new Locale('en-NZ');
+
+// Java: NewZealandReplaceRule
+export class NewZealandReplaceRule extends AbstractSimpleReplaceRule2 {
+  static FQCN = 'org.languagetool.rules.en.NewZealandReplaceRule';
+  static NEW_ZEALAND_SIMPLE_REPLACE_RULE = 'EN_NZ_SIMPLE_REPLACE';
+
+  // Java: NewZealandReplaceRule#getFileNames()
+  getFileNames() {
+    return [this.path];
+  }
+
+  // Java: NewZealandReplaceRule(ResourceBundle,String)
+  constructor(messages, path) {
+    super(messages, new NewZealandEnglish());
+    this.path = Objects.requireNonNull(path);
+    this.setCategory(Categories.STYLE.getCategory(messages));
+    this.setLocQualityIssueType(ITSIssueType.LocaleViolation);
+    this.addExamplePair(Example.wrong('A <marker>sidewalk</marker> is a path along the side of a road.'),
+      Example.fixed('A <marker>footpath</marker> is a path along the side of a road.'));
+  }
+
+  // Java: NewZealandReplaceRule#getId()
+  getId() {
+    return NewZealandReplaceRule.NEW_ZEALAND_SIMPLE_REPLACE_RULE;
+  }
+
+  // Java: NewZealandReplaceRule#getDescription()
+  getDescription() {
+    return 'English words easily confused in New Zealand English';
+  }
+
+  // Java: NewZealandReplaceRule#getShort()
+  getShort() {
+    return 'Not a New Zealand English word';
+  }
+
+  // Java: NewZealandReplaceRule#getMessage()
+  getMessage() {
+    return "'$match' is a non-standard expression. Consider using expressions more common to New Zealand English.";
+  }
+
+  // Java: NewZealandReplaceRule#getLocale()
+  getLocale() {
+    return EN_NZ_LOCALE;
+  }
+}

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

@@ -0,0 +1,24 @@
+// org.languagetool.rules.en.NoDisambiguationEnglishPartialPosTagFilter (pulled forward from F49 for the English disambiguation.xml)
+import { Languages } from '@valueerror/ltjs-core/src/core/Languages.js';
+import { registerClass } from '@valueerror/ltjs-core/src/core/resources/ClassBroker.js';
+import { PartialPosTagFilter } from '@valueerror/ltjs-core/src/core/rules/PartialPosTagFilter.js';
+
+// Java: NoDisambiguationEnglishPartialPosTagFilter
+export class NoDisambiguationEnglishPartialPosTagFilter extends PartialPosTagFilter {
+  static FQCN = 'org.languagetool.rules.en.NoDisambiguationEnglishPartialPosTagFilter';
+  static JAVA_ABSTRACT = false;
+  static JAVA_CONSTRUCTORS = [{ params: [], text: 'public org.languagetool.rules.en.NoDisambiguationEnglishPartialPosTagFilter()' }];
+
+  // Java: NoDisambiguationEnglishPartialPosTagFilter field initializer (tagger of "en")
+  constructor() {
+    super();
+    this.tagger = Languages.getLanguageForShortCode('en').getTagger();
+  }
+
+  // Java: NoDisambiguationEnglishPartialPosTagFilter#tag(String)
+  tag(token) {
+    return [...this.tagger.tag([token])];
+  }
+}
+
+registerClass(NoDisambiguationEnglishPartialPosTagFilter.FQCN, NoDisambiguationEnglishPartialPosTagFilter);

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

@@ -0,0 +1,33 @@
+// org.languagetool.rules.en.OrdinalSuffixFilter
+import { registerClass } from '@valueerror/ltjs-core/src/core/resources/ClassBroker.js';
+import { Pattern } from '@valueerror/ltjs-core/src/lib/java/regex/index.js';
+import { listGet } from '@valueerror/ltjs-core/src/lib/java/arrays.js';
+import { RuleFilter } from '@valueerror/ltjs-core/src/core/patterns/RuleFilter.js';
+
+// Java: OrdinalSuffixFilter
+export class OrdinalSuffixFilter extends RuleFilter {
+  static FQCN = 'org.languagetool.rules.en.OrdinalSuffixFilter';
+  static JAVA_ABSTRACT = false;
+  static JAVA_CONSTRUCTORS = [{ params: [], text: 'public org.languagetool.rules.en.OrdinalSuffixFilter()' }];
+  static PATTERN = Pattern.compile('.*(11|12|13)');
+  static NON_DIGITS = Pattern.compile('[^0-9]');
+
+  // Java: OrdinalSuffixFilter#acceptRuleMatch(RuleMatch,Map,int,AnalyzedTokenReadings[],List)
+  acceptRuleMatch(match) {
+    const ordinal = OrdinalSuffixFilter.NON_DIGITS.matcher(listGet(match.getSuggestedReplacements(), 0)).replaceAll('');
+    if (OrdinalSuffixFilter.PATTERN.matcher(ordinal).matches()) {
+      match.setSuggestedReplacement(ordinal + 'th');
+    } else if (ordinal.endsWith('1')) {
+      match.setSuggestedReplacement(ordinal + 'st');
+    } else if (ordinal.endsWith('2')) {
+      match.setSuggestedReplacement(ordinal + 'nd');
+    } else if (ordinal.endsWith('3')) {
+      match.setSuggestedReplacement(ordinal + 'rd');
+    } else {
+      match.setSuggestedReplacement(ordinal + 'th');
+    }
+    return match;
+  }
+}
+
+registerClass(OrdinalSuffixFilter.FQCN, OrdinalSuffixFilter);

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

@@ -0,0 +1,55 @@
+// org.languagetool.rules.en.SimpleReplaceProfanityRule
+import { AbstractSimpleReplaceRule2 } from '@valueerror/ltjs-core/src/core/rules/AbstractSimpleReplaceRule2.js';
+import { Categories } from '@valueerror/ltjs-core/src/core/rules/model/Category.js';
+import { ITSIssueType } from '@valueerror/ltjs-core/src/core/rules/model/ITSIssueType.js';
+import { Tag } from '@valueerror/ltjs-core/src/core/rules/model/Tag.js';
+import { Locale } from '@valueerror/ltjs-core/src/lib/java/Locale.js';
+import { getUrl } from '@valueerror/ltjs-core/src/core/Tools.js';
+
+const EN_LOCALE = new Locale('EN');
+
+// Java: SimpleReplaceProfanityRule
+export class SimpleReplaceProfanityRule extends AbstractSimpleReplaceRule2 {
+  static FQCN = 'org.languagetool.rules.en.SimpleReplaceProfanityRule';
+
+  // Java: SimpleReplaceProfanityRule(ResourceBundle,Language)
+  constructor(messages, language) {
+    super(messages, language);
+    // useSubRuleSpecificIds();
+    this.setLocQualityIssueType(ITSIssueType.Style); // needs ITS issue to be 'Style' in order to get purple underline + lower prio
+    this.setCategory(Categories.STYLE.getCategory(messages));
+    this.setUrl(getUrl('https://en.wiktionary.org/wiki/Category:English_offensive_terms'));
+    this.setTags([Tag.picky]);
+    this.setRuleHasSuggestions(false);
+  }
+
+  // Java: SimpleReplaceProfanityRule#getFileNames()
+  getFileNames() {
+    return ['/en/replace_profanity.txt'];
+  }
+
+  // Java: SimpleReplaceProfanityRule#getId()
+  getId() {
+    return 'PROFANITY';
+  }
+
+  // Java: SimpleReplaceProfanityRule#getDescription()
+  getDescription() {
+    return 'Profanity';
+  }
+
+  // Java: SimpleReplaceProfanityRule#getShort()
+  getShort() {
+    return 'Profanity';
+  }
+
+  // Java: SimpleReplaceProfanityRule#getMessage()
+  getMessage() {
+    return 'This expression can be considered offensive.';
+  }
+
+  // Java: SimpleReplaceProfanityRule#getLocale()
+  getLocale() {
+    return EN_LOCALE;
+  }
+}

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

@@ -0,0 +1,46 @@
+// org.languagetool.rules.en.SimpleReplaceRule
+import { AbstractSimpleReplaceRule2 } from '@valueerror/ltjs-core/src/core/rules/AbstractSimpleReplaceRule2.js';
+import { Locale } from '@valueerror/ltjs-core/src/lib/java/Locale.js';
+
+const EN_LOCALE = new Locale('EN');
+
+// Java: SimpleReplaceRule (en)
+export class SimpleReplaceRule extends AbstractSimpleReplaceRule2 {
+  static FQCN = 'org.languagetool.rules.en.SimpleReplaceRule';
+
+  // Java: SimpleReplaceRule(ResourceBundle,Language)
+  constructor(messages, language) {
+    super(messages, language);
+    this.useSubRuleSpecificIds();
+  }
+
+  // Java: SimpleReplaceRule#getFileNames()
+  getFileNames() {
+    return ['/en/replace.txt', '/en/replace_custom.txt'];
+  }
+
+  // Java: SimpleReplaceRule#getId()
+  getId() {
+    return 'EN_SIMPLE_REPLACE';
+  }
+
+  // Java: SimpleReplaceRule#getDescription()
+  getDescription() {
+    return 'Check for wrong words/phrases: $match';
+  }
+
+  // Java: SimpleReplaceRule#getShort()
+  getShort() {
+    return 'Wrong word';
+  }
+
+  // Java: SimpleReplaceRule#getMessage()
+  getMessage() {
+    return 'Did you mean $suggestions?';
+  }
+
+  // Java: SimpleReplaceRule#getLocale()
+  getLocale() {
+    return EN_LOCALE;
+  }
+}

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

@@ -0,0 +1,58 @@
+// org.languagetool.rules.en.StyleTooOftenUsedAdjectiveRule
+import { AbstractStyleTooOftenUsedWordRule } from '@valueerror/ltjs-core/src/core/rules/AbstractStyleTooOftenUsedWordRule.js';
+
+const DEFAULT_MIN_PERCENT = 5;
+
+// Java: StyleTooOftenUsedAdjectiveRule
+export class StyleTooOftenUsedAdjectiveRule extends AbstractStyleTooOftenUsedWordRule {
+  static FQCN = 'org.languagetool.rules.en.StyleTooOftenUsedAdjectiveRule';
+
+  // Java: StyleTooOftenUsedAdjectiveRule(ResourceBundle,Language,UserConfig)
+  constructor(messages, lang, userConfig) {
+    super(messages, lang, userConfig, DEFAULT_MIN_PERCENT);
+    this.sentenceMessage = null;
+    if (userConfig !== null && userConfig !== undefined) {
+      const linguServices = userConfig.getLinguServices();
+      if (linguServices !== null && linguServices !== undefined) {
+        linguServices.setThesaurusRelevantRule(this);
+      }
+    }
+  }
+
+  // Java: StyleTooOftenUsedAdjectiveRule#getLimitMessage(int)
+  getLimitMessage(limit) {
+    return 'The adjective is used more than ' + limit + '% times of all adjectives. '
+      + 'It may be better to replace it with a synonym.';
+  }
+
+  // Java: StyleTooOftenUsedAdjectiveRule#getId()
+  getId() {
+    return 'TOO_OFTEN_USED_ADJECTIVE_EN';
+  }
+
+  // Java: StyleTooOftenUsedAdjectiveRule#getDescription()
+  getDescription() {
+    return 'Statistical Style Analysis: Overused Adjective';
+  }
+
+  // Java: StyleTooOftenUsedAdjectiveRule#getConfigureText()
+  getConfigureText() {
+    return 'Show when a adjective is used more often than ...% of all adjectives:';
+  }
+
+  // Java: StyleTooOftenUsedAdjectiveRule#isToCountedWord(AnalyzedTokenReadings)
+  isToCountedWord(token) {
+    return token.hasPosTagStartingWith('JJ');
+  }
+
+  // Java: StyleTooOftenUsedAdjectiveRule#isException(AnalyzedTokenReadings[],int)
+  isException(tokens, n) {
+    const token = tokens[n];
+    return token.hasPosTagStartingWith('RB') || token.hasPosTagStartingWith('IN') || token.hasPosTagStartingWith('CD') || token.hasPosTagStartingWith('DT') || token.hasPosTagStartingWith('NN');
+  }
+
+  // Java: StyleTooOftenUsedAdjectiveRule#toAddedLemma(AnalyzedTokenReadings)
+  toAddedLemma(token) {
+    return this.getLemmaForPosTagStartsWith('JJ', token);
+  }
+}

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

@@ -0,0 +1,58 @@
+// org.languagetool.rules.en.StyleTooOftenUsedNounRule
+import { AbstractStyleTooOftenUsedWordRule } from '@valueerror/ltjs-core/src/core/rules/AbstractStyleTooOftenUsedWordRule.js';
+
+const DEFAULT_MIN_PERCENT = 5;
+
+// Java: StyleTooOftenUsedNounRule
+export class StyleTooOftenUsedNounRule extends AbstractStyleTooOftenUsedWordRule {
+  static FQCN = 'org.languagetool.rules.en.StyleTooOftenUsedNounRule';
+
+  // Java: StyleTooOftenUsedNounRule(ResourceBundle,Language,UserConfig)
+  constructor(messages, lang, userConfig) {
+    super(messages, lang, userConfig, DEFAULT_MIN_PERCENT);
+    this.sentenceMessage = null;
+    if (userConfig !== null && userConfig !== undefined) {
+      const linguServices = userConfig.getLinguServices();
+      if (linguServices !== null && linguServices !== undefined) {
+        linguServices.setThesaurusRelevantRule(this);
+      }
+    }
+  }
+
+  // Java: StyleTooOftenUsedNounRule#getLimitMessage(int)
+  getLimitMessage(limit) {
+    return 'The noun is used more than ' + limit + '% times of all nouns. '
+      + 'It may be better to replace it with a synonym.';
+  }
+
+  // Java: StyleTooOftenUsedNounRule#getId()
+  getId() {
+    return 'TOO_OFTEN_USED_NOUN_EN';
+  }
+
+  // Java: StyleTooOftenUsedNounRule#getDescription()
+  getDescription() {
+    return 'Statistical Style Analysis: Overused Noun';
+  }
+
+  // Java: StyleTooOftenUsedNounRule#getConfigureText()
+  getConfigureText() {
+    return 'Show when a noun is used more often than ...% of all nouns:';
+  }
+
+  // Java: StyleTooOftenUsedNounRule#isToCountedWord(AnalyzedTokenReadings)
+  isToCountedWord(token) {
+    return token.hasPosTagStartingWith('NN');
+  }
+
+  // Java: StyleTooOftenUsedNounRule#isException(AnalyzedTokenReadings[],int)
+  isException(tokens, n) {
+    const token = tokens[n];
+    return token.hasPosTagStartingWith('NNP') || token.hasPosTagStartingWith('IN') || token.hasPosTagStartingWith('JJ') || token.hasPosTagStartingWith('RB') || token.hasPosTagStartingWith('VB');
+  }
+
+  // Java: StyleTooOftenUsedNounRule#toAddedLemma(AnalyzedTokenReadings)
+  toAddedLemma(token) {
+    return this.getLemmaForPosTagStartsWith('NN', token);
+  }
+}

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

@@ -0,0 +1,58 @@
+// org.languagetool.rules.en.StyleTooOftenUsedVerbRule
+import { AbstractStyleTooOftenUsedWordRule } from '@valueerror/ltjs-core/src/core/rules/AbstractStyleTooOftenUsedWordRule.js';
+
+const DEFAULT_MIN_PERCENT = 5;
+
+// Java: StyleTooOftenUsedVerbRule
+export class StyleTooOftenUsedVerbRule extends AbstractStyleTooOftenUsedWordRule {
+  static FQCN = 'org.languagetool.rules.en.StyleTooOftenUsedVerbRule';
+
+  // Java: StyleTooOftenUsedVerbRule(ResourceBundle,Language,UserConfig)
+  constructor(messages, lang, userConfig) {
+    super(messages, lang, userConfig, DEFAULT_MIN_PERCENT);
+    this.sentenceMessage = null;
+    if (userConfig !== null && userConfig !== undefined) {
+      const linguServices = userConfig.getLinguServices();
+      if (linguServices !== null && linguServices !== undefined) {
+        linguServices.setThesaurusRelevantRule(this);
+      }
+    }
+  }
+
+  // Java: StyleTooOftenUsedVerbRule#getLimitMessage(int)
+  getLimitMessage(limit) {
+    return 'The verb is used more than ' + limit + '% times of all verbs. '
+      + 'It may be better to replace it with a synonym.';
+  }
+
+  // Java: StyleTooOftenUsedVerbRule#getId()
+  getId() {
+    return 'TOO_OFTEN_USED_VERB_EN';
+  }
+
+  // Java: StyleTooOftenUsedVerbRule#getDescription()
+  getDescription() {
+    return 'Statistical Style Analysis: Overused Verb';
+  }
+
+  // Java: StyleTooOftenUsedVerbRule#getConfigureText()
+  getConfigureText() {
+    return 'Show when a verb is used more often than ...% of all verbs:';
+  }
+
+  // Java: StyleTooOftenUsedVerbRule#isToCountedWord(AnalyzedTokenReadings)
+  isToCountedWord(token) {
+    return token.hasPosTagStartingWith('VB');
+  }
+
+  // Java: StyleTooOftenUsedVerbRule#isException(AnalyzedTokenReadings[],int)
+  isException(tokens, n) {
+    const token = tokens[n];
+    return token.hasAnyLemma('be', 'have', 'do') || token.hasPosTagStartingWith('IN') || token.hasPosTagStartingWith('NN');
+  }
+
+  // Java: StyleTooOftenUsedVerbRule#toAddedLemma(AnalyzedTokenReadings)
+  toAddedLemma(token) {
+    return this.getLemmaForPosTagStartsWith('VB', token);
+  }
+}

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

@@ -0,0 +1,47 @@
+// org.languagetool.rules.en.UnitConversionRule
+import { AbstractUnitConversionRule, MILE, FEET, YARD, INCH, POUND, OUNCE, FAHRENHEIT } from '@valueerror/ltjs-core/src/core/rules/AbstractUnitConversionRule.js';
+import { Tag } from '@valueerror/ltjs-core/src/core/rules/model/Tag.js';
+import { DecimalFormat } from '@valueerror/ltjs-core/src/lib/java/DecimalFormat.js';
+import { Locale } from '@valueerror/ltjs-core/src/lib/java/Locale.js';
+import { KILOGRAM, METRE, CELSIUS, HOUR } from '@valueerror/ltjs-core/src/lib/units/units.js';
+
+// Java: UnitConversionRule
+export class UnitConversionRule extends AbstractUnitConversionRule {
+  static FQCN = 'org.languagetool.rules.en.UnitConversionRule';
+
+  // Java: UnitConversionRule(ResourceBundle)
+  constructor(messages) {
+    super(messages);
+    this.setTags([Tag.picky]);
+    this.format = DecimalFormat.getNumberInstance(Locale.ENGLISH);
+    this.format.setMaximumFractionDigits(2);
+    this.format.setRoundingMode('HALF_UP');
+    this.addUnit("miles per hour", MILE.divideUnit(HOUR), "miles per hour", 1, false);
+    this.addUnit("kilograms?", KILOGRAM, "kilogram", 1e0, true);
+    this.addUnit("grams?", KILOGRAM, "gram", 1e-3, true);
+    this.addUnit("tons?", KILOGRAM, "ton", 1e3, true);
+    this.addUnit("pounds?", POUND, "pounds", 1, false);
+    this.addUnit("ounces?", OUNCE, "ounces", 1, false);
+    this.addUnit("feet", FEET, "feet", 1, false);
+    this.addUnit("miles?", MILE, "miles", 1, false);
+    this.addUnit("yards?", YARD, "yards", 1, false);
+    this.addUnit("inch(es)?", INCH, "inches", 1, false);
+    this.addUnit("(?:degrees?)? Fahrenheit", FAHRENHEIT, "degree Fahrenheit", 1, false);
+    this.addUnit("(?:degrees?)? Celsius", CELSIUS, "degree Celsius", 1, true);
+  }
+
+  // Java: UnitConversionRule#getId()
+  getId() {
+    return 'METRIC_UNITS_EN_GENERAL';
+  }
+
+  // Java: UnitConversionRule#getDescription()
+  getDescription() {
+    return 'Suggests or checks conversion of units to their metric equivalents.';
+  }
+
+  // Java: UnitConversionRule#getNumberFormat()
+  getNumberFormat() {
+    return this.format;
+  }
+}

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

@@ -0,0 +1,57 @@
+// org.languagetool.rules.en.UnitConversionRuleImperial
+import { UnitConversionRule } from './UnitConversionRule.js';
+import { DecimalFormat } from '@valueerror/ltjs-core/src/lib/java/DecimalFormat.js';
+import { Locale } from '@valueerror/ltjs-core/src/lib/java/Locale.js';
+import { METRE, SQUARE_METRE, CUBIC_METRE, LITRE, KILOMETRE_PER_HOUR } from '@valueerror/ltjs-core/src/lib/units/units.js';
+import { IMP_QUART, IMP_GALLON, IMP_PINT, IMP_FL_OUNCE } from '@valueerror/ltjs-core/src/core/rules/AbstractUnitConversionRule.js';
+
+// Java: UnitConversionRuleImperial
+export class UnitConversionRuleImperial extends UnitConversionRule {
+  static FQCN = 'org.languagetool.rules.en.UnitConversionRuleImperial';
+
+  // Java: UnitConversionRuleImperial(ResourceBundle)
+  constructor(messages) {
+    super(messages);
+    this.format = DecimalFormat.getNumberInstance(Locale.UK);
+    this.format.setMaximumFractionDigits(2);
+    this.format.setRoundingMode('HALF_UP');
+
+    this.addUnit("(kilometre|kilometer)s? per hour", KILOMETRE_PER_HOUR, "kilometres per hour", 1, true);
+    this.addUnit("kilomet(re|er)s?", METRE, "kilometres", 1e3, true);
+    this.addUnit("met(re|er)s?", METRE, "metres", 1e0, true);
+    this.addUnit("decimet(re|er)s?", METRE, "decimetres", 1e-1, false); // Metric, but not commonly used
+    this.addUnit("centimet(re|er)s?", METRE, "centimetres", 1e-2, true);
+    this.addUnit("millimet(re|er)s?", METRE, "micrometres", 1e-3, true);
+    this.addUnit("micromet(re|er)s?", METRE, "micrometres", 1e-6, true);
+    this.addUnit("nanomet(re|er)s?", METRE, "nanometres", 1e-9, true);
+    this.addUnit("square met(re|er)s?", SQUARE_METRE, "square metres", 1, true);
+    this.addUnit("square kilomet(re|er)s?", SQUARE_METRE, "square kilometres", 1e6, true);
+    this.addUnit("square decimet(re|er)s?", SQUARE_METRE, "square decimetres", 1e-2, false); // Metric, but not commonly used
+    this.addUnit("square centimet(re|er)s?", SQUARE_METRE, "square centimetres", 1e-4, true);
+    this.addUnit("square millimet(re|er)s?", SQUARE_METRE, "square millimetres", 1e-6, true);
+    this.addUnit("square micromet(re|er)s?", SQUARE_METRE, "square micrometres", 1e-12, true);
+    this.addUnit("square nanomet(re|er)s?", SQUARE_METRE, "square nanometres", 1e-18, true);
+    this.addUnit("cubic met(re|er)s?", CUBIC_METRE, "cubic metres", 1, true);
+    this.addUnit("cubic kilomet(re|er)s?", CUBIC_METRE, "cubic kilometres", 1e9, true);
+    this.addUnit("cubic decimet(re|er)s?", CUBIC_METRE, "cubic decimetres", 1e-3, false); // Metric, but not commonly used
+    this.addUnit("cubic centimet(re|er)s?", CUBIC_METRE, "cubic centimetres", 1e-6, true);
+    this.addUnit("cubic millimet(re|er)s?", CUBIC_METRE, "cubic millimetres", 1e-9, true);
+    this.addUnit("cubic micromet(re|er)s?", CUBIC_METRE, "cubic micrometres", 1e-18, true);
+    this.addUnit("cubic nanomet(re|er)s?", CUBIC_METRE, "cubic nanometres", 1e-27, true);
+    this.addUnit("lit(re|er)s?", LITRE, "litres", 1, true);
+    this.addUnit("millilit(re|er)s?", LITRE, "millilitres", 1e-3, true);
+    this.addUnit("qt\\.", IMP_QUART, "qt.", 1, false);
+    this.addUnit("gal", IMP_GALLON, "gal", 1, false);
+    this.addUnit("pt", IMP_PINT, "pt", 1, false);
+    this.addUnit("(?:fl.? oz.?|oz. fl.)", IMP_FL_OUNCE, "fl oz", 1, false);
+    this.addUnit("quarts?", IMP_QUART, "quarts", 1, false);
+    this.addUnit("gallons?", IMP_GALLON, "gallons", 1, false);
+    this.addUnit("pints?", IMP_PINT, "pints", 1, false);
+    this.addUnit("(fluid )?ounces?", IMP_FL_OUNCE, "fluid ounces", 1, false);
+  }
+
+  // Java: UnitConversionRuleImperial#getId()
+  getId() {
+    return 'METRIC_UNITS_EN_IMPERIAL';
+  }
+}

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

@@ -0,0 +1,62 @@
+// org.languagetool.rules.en.UnitConversionRuleUS
+import { UnitConversionRule } from './UnitConversionRule.js';
+import { getUrl } from '@valueerror/ltjs-core/src/core/Tools.js';
+import { DecimalFormat } from '@valueerror/ltjs-core/src/lib/java/DecimalFormat.js';
+import { Locale } from '@valueerror/ltjs-core/src/lib/java/Locale.js';
+import { METRE, SQUARE_METRE, CUBIC_METRE, LITRE, KILOMETRE_PER_HOUR } from '@valueerror/ltjs-core/src/lib/units/units.js';
+import { US_QUART, US_GALLON, US_PINT, US_CUP, US_FL_OUNCE } from '@valueerror/ltjs-core/src/core/rules/AbstractUnitConversionRule.js';
+
+// Java: UnitConversionRuleUS
+export class UnitConversionRuleUS extends UnitConversionRule {
+  static FQCN = 'org.languagetool.rules.en.UnitConversionRuleUS';
+
+  // Java: UnitConversionRuleUS(ResourceBundle)
+  constructor(messages) {
+    super(messages);
+    this.setUrl(getUrl('https://languagetool.org/insights/post/imperial-metric-system/'));
+
+    this.format = DecimalFormat.getNumberInstance(Locale.US);
+    this.format.setMaximumFractionDigits(2);
+    this.format.setRoundingMode('HALF_UP');
+
+    this.addUnit("(kilometre|kilometer)s? per hour", KILOMETRE_PER_HOUR, "kilometers per hour", 1, true);
+    this.addUnit("kilomet(re|er)s?", METRE, "kilometers", 1e3, true);
+    this.addUnit("met(re|er)s?", METRE, "meters", 1e0, true);
+    this.addUnit("decimet(re|er)s?", METRE, "decimeters", 1e-1, false); // Metric, but not commonly used
+    this.addUnit("centimet(re|er)s?", METRE, "centimeters", 1e-2, true);
+    this.addUnit("millimet(re|er)s?", METRE, "micrometers", 1e-3, true);
+    this.addUnit("micromet(re|er)s?", METRE, "micrometers", 1e-6, true);
+    this.addUnit("nanomet(re|er)s?", METRE, "nanometers", 1e-9, true);
+    this.addUnit("square met(re|er)s?", SQUARE_METRE, "square meters", 1, true);
+    this.addUnit("square kilomet(re|er)s?", SQUARE_METRE, "square kilometers", 1e6, true);
+    this.addUnit("square decimet(re|er)s?", SQUARE_METRE, "square decimeters", 1e-2, false); // Metric, but not commonly used
+    this.addUnit("square centimet(re|er)s?", SQUARE_METRE, "square centimeters", 1e-4, true);
+    this.addUnit("square millimet(re|er)s?", SQUARE_METRE, "square millimeters", 1e-6, true);
+    this.addUnit("square micromet(re|er)s?", SQUARE_METRE, "square micrometers", 1e-12, true);
+    this.addUnit("square nanomet(re|er)s?", SQUARE_METRE, "square nanometers", 1e-18, true);
+    this.addUnit("cubic met(re|er)s?", CUBIC_METRE, "cubic meters", 1, true);
+    this.addUnit("cubic kilomet(re|er)s?", CUBIC_METRE, "cubic kilometers", 1e9, true);
+    this.addUnit("cubic decimet(re|er)s?", CUBIC_METRE, "cubic decimeters", 1e-3, false); // Metric, but not commonly used
+    this.addUnit("cubic centimet(re|er)s?", CUBIC_METRE, "cubic centimeters", 1e-6, true);
+    this.addUnit("cubic millimet(re|er)s?", CUBIC_METRE, "cubic millimeters", 1e-9, true);
+    this.addUnit("cubic micromet(re|er)s?", CUBIC_METRE, "cubic micrometers", 1e-18, true);
+    this.addUnit("cubic nanomet(re|er)s?", CUBIC_METRE, "cubic nanometers", 1e-27, true);
+    this.addUnit("lit(re|er)s?", LITRE, "liters", 1, true);
+    this.addUnit("millilit(re|er)s?", LITRE, "milliliters", 1e-3, true);
+    this.addUnit("qt\\.", US_QUART, "qt.", 1, false);
+    this.addUnit("gal", US_GALLON, "gal", 1, false);
+    this.addUnit("pt", US_PINT, "pt", 1, false);
+    this.addUnit("cup", US_CUP, "cups", 1, false);
+    this.addUnit("(?:fl.? oz.?|oz. fl.)", US_FL_OUNCE, "fl oz", 1, false);
+    this.addUnit("quarts?", US_QUART, "quarts", 1, false);
+    this.addUnit("gallons?", US_GALLON, "gallons", 1, false);
+    this.addUnit("pints?", US_PINT, "pints", 1, false);
+    this.addUnit("cups?", US_CUP, "cups", 1, false);
+    this.addUnit("(fluid )?ounces?", US_FL_OUNCE, "fluid ounces", 1, false);
+  }
+
+  // Java: UnitConversionRuleUS#getId()
+  getId() {
+    return 'METRIC_UNITS_EN_US';
+  }
+}

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

@@ -0,0 +1,23 @@
+// org.languagetool.rules.en.VariantInfo
+import { Objects } from '@valueerror/ltjs-core/src/lib/java/Objects.js';
+
+// Java: VariantInfo (package-private value object)
+export class VariantInfo {
+  static FQCN = 'org.languagetool.rules.en.VariantInfo';
+
+  // Java: VariantInfo(String,String)
+  constructor(variantName, otherVariant) {
+    this.variantName = Objects.requireNonNull(variantName);
+    this.otherVariantValue = Objects.requireNonNull(otherVariant);
+  }
+
+  // Java: VariantInfo#getVariantName()
+  getVariantName() {
+    return this.variantName;
+  }
+
+  // Java: VariantInfo#otherVariant()
+  otherVariant() {
+    return this.otherVariantValue;
+  }
+}