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

package/resources/org/languagetool/rules/en/wrongWordInContext.txt

@@ -0,0 +1,14 @@
+#word1	word2	match1	match2	context1	context2	[explanation1	explanation2]
+#do not forget to add tests to EnglishWrongWordInContextRuleTest.java
+# proscribe/prescribe
+prescribe[ds]?	proscribe[sd]?	prescr	proscr	medication|medicine|antibiotics|doctors?	theft|murder	to recommend or authorize	to forbid, to limit or to banish
+heroin	heroine	oin	oine	addict.*|morphine|drug|narcotics?|withdrawal	literature|novels?|author|story|poems?|play|female|dramatic|statue|heroes?	highly addictive narcotic	the chief female character; a woman admired for great deeds
+bazaar	bizarre	azaar	izarre	oriental|marketplace|rummage|goods|buy|bought|sell|sold	moment|odd|unusual|incident|behaviou?r|situations?|stor(y|ies)|reasons?|moments?	a marketplace (noun)	unusual, odd, or whimsically strange (adjective)
+bridal	bridle	ridal	ridle	weddings?|brides?|boutique|gowns?|church|party|shower|shop|jewellery|dress|fashion	horses?|cavalier|harness|headgear|headstall|rider?s?	related to a bride	a part of a horse's harness
+desserts?	deserts?	esse	ese	chocolate|menu|wait(ers?|ress)|cookies|cakes?	bec[ao]me|dry|arid|vegetation|camels?|precipitation|rain	a confectionery course that concludes a main meal	a barren area of landscape with little precipitation
+statutes?	statues?	ute	ue	government|legislat(ure|ive)|laws?|senators?|regulat(ions?|ed?|ing)|Republicans?|Democrats?|limitations	life-size|figur(ative|ine)|sculptur(ing|ed?)|modeling|art(ist)|temples?|marble|bronze|Gree(k|ce)	a formal written enactment of a legislative authority	a sculpture; a carved or shaped imitation of an object
+gorilla	guerilla	o	ue	apes?|chimpanzees?|bonobos?|[Ss]ilverback|zoos?	marketing|war(fares?)?|insurgents?|soldiers?|army|(para)?military|ambush(ed)?	animal in ape family	soldier specializing surprise attacks
+massage	message	ma	me	Thai|relaxing|naked|therap(eutic|y|ist)|prostate|erotic|tantric|lymphatic|muscles?	error|send(ing)?|sent|receive[dr]?|important|take|writ(e|ten)	action of rubbing, kneading or hitting someone's body	communication, or what is communicated
+sing	sign	ing	ign	songs?|music|choirs?	contracts?	to produce musical or harmonious sounds with one’s voice	to write one's signature
+neutrons?	neurons?	utr	ur	[fF]ermion(ic)?|[pP]rotons?|[Aa]tom(s?|ic)|[Ee]lectrons?|[nN]uclear|[Ss]pins?|hadron(ic)?|[tT]hermal|bound	ganglia|axons?|dendrits?|nervous|synapses?|stimul(i|us)|nerves?|neurotransmitters?|cerebral|(bi|uni)polar	subatomic particle	nerve cell
+hangars?	hangers?	gar	ger	air(craft|plain)s?|aeroplains?|planes?	cloth(es?|ing)|coats?|garments?	shed or shelter	a frame for hanging clothes

package/src/lang/en/chunking/EnglishChunkFilter.js

@@ -0,0 +1,108 @@
+// org.languagetool.chunking.EnglishChunkFilter (adds singular/plural to OpenNLP noun phrase chunks)
+import { IllegalStateException } from '@valueerror/ltjs-core/src/lib/java/errors.js';
+import { ChunkTag } from '@valueerror/ltjs-core/src/core/chunking/ChunkTag.js';
+import { ChunkTaggedToken } from '@valueerror/ltjs-core/src/core/chunking/ChunkTaggedToken.js';
+
+const BEGIN_NOUN_PHRASE_TAG = new ChunkTag('B-NP');
+const IN_NOUN_PHRASE_TAG = new ChunkTag('I-NP');
+
+const ChunkType = Object.freeze({ SINGULAR: 'SINGULAR', PLURAL: 'PLURAL' });
+
+// Java: EnglishChunkFilter
+export class EnglishChunkFilter {
+  static FQCN = 'org.languagetool.chunking.EnglishChunkFilter';
+
+  // Java: EnglishChunkFilter#filter(List)
+  filter(tokens) {
+    const result = [];
+    let newChunkTag = null;
+    let i = 0;
+    for (const taggedToken of tokens) {
+      const chunkTags = [];
+      if (this.isBeginningOfNounPhrase(taggedToken)) {
+        const chunkType = this.getChunkType(tokens, i);
+        if (chunkType === ChunkType.SINGULAR || this.endOfNounPhraseIsSingular(tokens, i)) {
+          chunkTags.push(new ChunkTag('B-NP-singular'));
+          newChunkTag = 'NP-singular';
+        } else if (chunkType === ChunkType.PLURAL) {
+          chunkTags.push(new ChunkTag('B-NP-plural'));
+          newChunkTag = 'NP-plural';
+        } else {
+          throw new IllegalStateException(`Unknown chunk type: ${chunkType}`);
+        }
+      }
+      if (newChunkTag !== null && this.isEndOfNounPhrase(tokens, i)) {
+        chunkTags.push(new ChunkTag(`E-${newChunkTag}`));
+        newChunkTag = null;
+      }
+      if (newChunkTag !== null && this.isContinuationOfNounPhrase(taggedToken)) {
+        chunkTags.push(new ChunkTag(`I-${newChunkTag}`));
+      }
+      if (chunkTags.length > 0) {
+        result.push(new ChunkTaggedToken(taggedToken.getToken(), chunkTags, taggedToken.getReadings()));
+      } else {
+        result.push(taggedToken);
+      }
+      i++;
+    }
+    return result;
+  }
+
+  // Java: EnglishChunkFilter#endOfNounPhraseIsSingular(List,int)
+  endOfNounPhraseIsSingular(tokens, i) {
+    for (let j = i; j < tokens.length; j++) {
+      if (this.isEndOfNounPhrase(tokens, j)) {
+        return this.getChunkType(tokens, j) === ChunkType.SINGULAR;
+      }
+    }
+    return false;
+  }
+
+  // Java: EnglishChunkFilter#isBeginningOfNounPhrase(ChunkTaggedToken)
+  isBeginningOfNounPhrase(taggedToken) {
+    return taggedToken.getChunkTags().some((t) => t.equals(BEGIN_NOUN_PHRASE_TAG));
+  }
+
+  // Java: EnglishChunkFilter#isEndOfNounPhrase(List,int)
+  isEndOfNounPhrase(tokens, i) {
+    if (i > tokens.length - 2) {
+      return true;
+    }
+    if (!this.isContinuationOfNounPhrase(tokens[i + 1])) {
+      return true;
+    }
+    return false;
+  }
+
+  // Java: EnglishChunkFilter#isContinuationOfNounPhrase(ChunkTaggedToken)
+  isContinuationOfNounPhrase(taggedToken) {
+    return taggedToken.getChunkTags().some((t) => t.equals(IN_NOUN_PHRASE_TAG));
+  }
+
+  // Java: EnglishChunkFilter#getChunkType(List,int)
+  getChunkType(tokens, chunkStartPos) {
+    let isPlural = false;
+    for (let i = chunkStartPos; i < tokens.length; i++) {
+      const token = tokens[i];
+      if (!this.isBeginningOfNounPhrase(token) && !this.isContinuationOfNounPhrase(token)) {
+        break;
+      }
+      if (this.hasNounWithPluralReading(token)) {
+        isPlural = true;
+      }
+    }
+    return isPlural ? ChunkType.PLURAL : ChunkType.SINGULAR;
+  }
+
+  // Java: EnglishChunkFilter#hasNounWithPluralReading(ChunkTaggedToken)
+  hasNounWithPluralReading(token) {
+    if (token.getReadings() !== null && token.getReadings() !== undefined) {
+      for (const analyzedToken of token.getReadings().getReadings()) {
+        if (analyzedToken.getPOSTag() === 'NNS') {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+}

package/src/lang/en/chunking/EnglishChunker.js

@@ -0,0 +1,135 @@
+// org.languagetool.chunking.EnglishChunker (OpenNLP tokenizer, POS tagger and chunker mapped to LT tokens)
+import { RuntimeException } from '@valueerror/ltjs-core/src/lib/java/errors.js';
+import { javaSplit, javaTrim } from '@valueerror/ltjs-core/src/lib/java/strings.js';
+import { isSpaceChar } from '@valueerror/ltjs-core/src/lib/java/Character.js';
+import { registerComponent } from '@valueerror/ltjs-core/src/core/language/components.js';
+import { ChunkTag } from '@valueerror/ltjs-core/src/core/chunking/ChunkTag.js';
+import { ChunkTaggedToken } from '@valueerror/ltjs-core/src/core/chunking/ChunkTaggedToken.js';
+import { loadModels } from '@valueerror/ltjs-core/src/lib/opennlp/Models.js';
+import { TokenizerME } from '@valueerror/ltjs-core/src/lib/opennlp/TokenizerME.js';
+import { POSTaggerME } from '@valueerror/ltjs-core/src/lib/opennlp/POSTaggerME.js';
+import { ChunkerME } from '@valueerror/ltjs-core/src/lib/opennlp/ChunkerME.js';
+import { EnglishChunkFilter } from './EnglishChunkFilter.js';
+
+// Java: EnglishChunker
+export class EnglishChunker {
+  static FQCN = 'org.languagetool.chunking.EnglishChunker';
+
+  // Java: EnglishChunker#EnglishChunker() (models are static, loaded once)
+  constructor() {
+    try {
+      this.models = loadModels();
+      this.chunkFilter = new EnglishChunkFilter();
+    } catch (e) {
+      if (e.notPorted === true) throw e;
+      throw new RuntimeException('Could not initialize English chunker', e);
+    }
+  }
+
+  // Java: EnglishChunker#addChunkTags(List)
+  addChunkTags(tokenReadings) {
+    const origChunkTags = this.getChunkTagsForReadings(tokenReadings);
+    const chunkTags = this.chunkFilter.filter(origChunkTags);
+    this.assignChunksToReadings(chunkTags);
+  }
+
+  // Java: EnglishChunker#getChunkTagsForReadings(List)
+  getChunkTagsForReadings(tokenReadings) {
+    const sentence = this.getSentence(tokenReadings);
+    const tokens = this.cleanZeroWidthWhitespaces(this.tokenize(sentence));
+    const posTags = this.posTag(tokens);
+    const chunkTags = this.chunk(tokens, posTags);
+    if (tokens.length !== posTags.length || tokens.length !== chunkTags.length) {
+      throw new RuntimeException(`Length of results must be the same: ${tokens.length}, ${posTags.length}, ${chunkTags.length}`);
+    }
+    return this.getTokensWithTokenReadings(tokenReadings, tokens, chunkTags);
+  }
+
+  // Java: EnglishChunker#cleanZeroWidthWhitespaces(String[])
+  cleanZeroWidthWhitespaces(tokens) {
+    const cleanTokens = [];
+    for (const token of tokens) {
+      const splits = javaSplit(token, '');
+      for (const split of splits) {
+        if (split.length === 0) {
+          cleanTokens.push('');
+        } else {
+          cleanTokens.push(token);
+        }
+      }
+    }
+    return cleanTokens;
+  }
+
+  // Java: EnglishChunker#tokenize(String)
+  tokenize(sentence) {
+    const tokenizer = new TokenizerME(this.models.tm);
+    const cleanString = sentence.replaceAll('’', "'");
+    return tokenizer.tokenize(cleanString);
+  }
+
+  // Java: EnglishChunker#posTag(String[])
+  posTag(tokens) {
+    return new POSTaggerME(this.models.pm).tag(tokens);
+  }
+
+  // Java: EnglishChunker#chunk(String[],String[])
+  chunk(tokens, posTags) {
+    return new ChunkerME(this.models.cm).chunk(tokens, posTags);
+  }
+
+  // Java: EnglishChunker#getTokensWithTokenReadings(List,String[],String[])
+  getTokensWithTokenReadings(tokenReadings, tokens, chunkTags) {
+    const result = [];
+    let i = 0;
+    let pos = 0;
+    for (const chunkTag of chunkTags) {
+      const startPos = pos;
+      const endPos = startPos + tokens[i].length;
+      const readings = this.getAnalyzedTokenReadingsFor(startPos, endPos, tokenReadings);
+      result.push(new ChunkTaggedToken(tokens[i], [new ChunkTag(chunkTag)], readings));
+      pos = endPos;
+      i++;
+    }
+    return result;
+  }
+
+  // Java: EnglishChunker#assignChunksToReadings(List)
+  assignChunksToReadings(chunkTaggedTokens) {
+    for (const taggedToken of chunkTaggedTokens) {
+      const readings = taggedToken.getReadings();
+      if (readings !== null && readings !== undefined) {
+        readings.setChunkTags(taggedToken.getChunkTags());
+      }
+    }
+  }
+
+  // Java: EnglishChunker#getSentence(List)
+  getSentence(sentenceTokens) {
+    let sb = '';
+    for (const token of sentenceTokens) {
+      sb += token.getToken();
+    }
+    return sb;
+  }
+
+  // Java: EnglishChunker#getAnalyzedTokenReadingsFor(int,int,List)
+  getAnalyzedTokenReadingsFor(startPos, endPos, tokenReadings) {
+    let pos = 0;
+    for (const tokenReading of tokenReadings) {
+      const token = tokenReading.getToken();
+      if (javaTrim(token).length === 0 || (token.length === 1 && isSpaceChar(token.charCodeAt(0)))) {
+        continue;
+      }
+      const tokenStart = pos;
+      const tokenEnd = pos + token.length;
+      if (tokenStart === startPos && tokenEnd === endPos) {
+        return tokenReading;
+      }
+      pos = tokenEnd;
+    }
+    return null;
+  }
+}
+
+registerComponent(EnglishChunker.FQCN, () => new EnglishChunker());

package/src/lang/en/language/AmericanEnglish.js

@@ -0,0 +1,73 @@
+// Java: org.languagetool.language.AmericanEnglish
+import { RuntimeException, Throwable } from '@valueerror/ltjs-core/src/lib/java/errors.js';
+import { Objects } from '@valueerror/ltjs-core/src/lib/java/Objects.js';
+import { Languages } from '@valueerror/ltjs-core/src/core/Languages.js';
+import { createComponent } from '@valueerror/ltjs-core/src/core/language/components.js';
+import { registerClass } from '@valueerror/ltjs-core/src/core/resources/ClassBroker.js';
+import { English } from './English.js';
+import { MorfologikAmericanSpellerRule } from '../rules/MorfologikAmericanSpellerRule.js';
+import { AmericanReplaceRule } from '../rules/AmericanReplaceRule.js';
+import { UnitConversionRuleUS } from '../rules/UnitConversionRuleUS.js';
+
+const LANGUAGE_SHORT_CODE = 'en-US';
+
+let instantiationTrace = null; // Java: AmericanEnglish#instantiationTrace
+
+// Java: AmericanEnglish
+export class AmericanEnglish extends English {
+  static FQCN = 'org.languagetool.language.AmericanEnglish';
+
+  // Java: AmericanEnglish#AmericanEnglish() / protected AmericanEnglish(boolean) (fake constructor overload for subclasses)
+  constructor(fakeValue) {
+    super();
+    if (fakeValue === undefined) {
+      const trace = instantiationTrace;
+      if (trace !== null) {
+        throw new RuntimeException('Language was already instantiated, see the cause stacktrace below.', trace);
+      }
+      instantiationTrace = new Throwable();
+    }
+  }
+
+  // Java: AmericanEnglish#getCountries()
+  getCountries() {
+    return ['US'];
+  }
+
+  // Java: AmericanEnglish#getName()
+  getName() {
+    return 'English (US)';
+  }
+
+  // Java: AmericanEnglish#getRelevantRules(ResourceBundle,UserConfig,Language,List)
+  getRelevantRules(messages, userConfig, motherTongue, altLanguages) {
+    const rules = [...super.getRelevantRules(messages, userConfig, motherTongue, altLanguages)];
+    rules.push(new AmericanReplaceRule(messages, '/en/en-US/replace.txt'));
+    rules.push(new UnitConversionRuleUS(messages));
+    return rules;
+  }
+
+  // Java: AmericanEnglish#createDefaultSpellingRule(ResourceBundle)
+  createDefaultSpellingRule(messages) {
+    return createComponent('org.languagetool.rules.en.MorfologikAmericanSpellerRule', messages, this, null, []);
+  }
+
+  // Java: AmericanEnglish#getRelevantLanguageModelCapableRules(ResourceBundle,LanguageModel,GlobalConfig,UserConfig,Language,List)
+  getRelevantLanguageModelCapableRules(messages, lm, globalConfig, userConfig, motherTongue, altLanguages) {
+    const rules = [...super.getRelevantLanguageModelCapableRules(messages, lm, globalConfig, userConfig, motherTongue, altLanguages)];
+    // SuggestionsChanges.isRunningExperiment(SymSpell) is never true (experiments are not configured)
+    rules.push(new MorfologikAmericanSpellerRule(messages, this, globalConfig, userConfig, altLanguages, lm, motherTongue));
+    return rules;
+  }
+
+  // Java: AmericanEnglish#getInstance()
+  static getInstance() {
+    const language = Objects.requireNonNull(Languages.getLanguageForShortCode(LANGUAGE_SHORT_CODE));
+    if (language instanceof English) {
+      return language;
+    }
+    throw new RuntimeException(`AmericanEnglish language expected, got ${language}`);
+  }
+}
+
+registerClass(AmericanEnglish.FQCN, AmericanEnglish);

package/src/lang/en/language/AustralianEnglish.js

@@ -0,0 +1,42 @@
+// Java: org.languagetool.language.AustralianEnglish
+import { createComponent } from '@valueerror/ltjs-core/src/core/language/components.js';
+import { registerClass } from '@valueerror/ltjs-core/src/core/resources/ClassBroker.js';
+import { English } from './English.js';
+import { MorfologikAustralianSpellerRule } from '../rules/MorfologikAustralianSpellerRule.js';
+import { UnitConversionRuleImperial } from '../rules/UnitConversionRuleImperial.js';
+
+// Java: AustralianEnglish
+export class AustralianEnglish extends English {
+  static FQCN = 'org.languagetool.language.AustralianEnglish';
+
+  // Java: AustralianEnglish#getCountries()
+  getCountries() {
+    return ['AU'];
+  }
+
+  // Java: AustralianEnglish#getName()
+  getName() {
+    return 'English (Australian)';
+  }
+
+  // Java: AustralianEnglish#createDefaultSpellingRule(ResourceBundle)
+  createDefaultSpellingRule(messages) {
+    return createComponent('org.languagetool.rules.en.MorfologikAustralianSpellerRule', messages, this, null, []);
+  }
+
+  // Java: AustralianEnglish#getRelevantRules(ResourceBundle,UserConfig,Language,List)
+  getRelevantRules(messages, userConfig, motherTongue, altLanguages) {
+    const rules = [...super.getRelevantRules(messages, userConfig, motherTongue, altLanguages)];
+    rules.push(new UnitConversionRuleImperial(messages));
+    return rules;
+  }
+
+  // Java: AustralianEnglish#getRelevantLanguageModelCapableRules(ResourceBundle,LanguageModel,GlobalConfig,UserConfig,Language,List)
+  getRelevantLanguageModelCapableRules(messages, lm, globalConfig, userConfig, motherTongue, altLanguages) {
+    const rules = [...super.getRelevantLanguageModelCapableRules(messages, lm, globalConfig, userConfig, motherTongue, altLanguages)];
+    rules.push(new MorfologikAustralianSpellerRule(messages, this, globalConfig, userConfig, altLanguages, lm, motherTongue));
+    return rules;
+  }
+}
+
+registerClass(AustralianEnglish.FQCN, AustralianEnglish);

package/src/lang/en/language/BritishEnglish.js

@@ -0,0 +1,91 @@
+// Java: org.languagetool.language.BritishEnglish
+import { RuntimeException, Throwable } from '@valueerror/ltjs-core/src/lib/java/errors.js';
+import { Objects } from '@valueerror/ltjs-core/src/lib/java/Objects.js';
+import { JavaHashMap } from '@valueerror/ltjs-core/src/lib/java/collections/JavaHashMap.js';
+import { Languages } from '@valueerror/ltjs-core/src/core/Languages.js';
+import { createComponent } from '@valueerror/ltjs-core/src/core/language/components.js';
+import { registerClass } from '@valueerror/ltjs-core/src/core/resources/ClassBroker.js';
+import { English } from './English.js';
+import { MorfologikBritishSpellerRule } from '../rules/MorfologikBritishSpellerRule.js';
+import { BritishReplaceRule } from '../rules/BritishReplaceRule.js';
+import { UnitConversionRuleImperial } from '../rules/UnitConversionRuleImperial.js';
+import { ID2PRIO_ENTRIES } from './id2prioBritishEnglish.js';
+
+const LANGUAGE_SHORT_CODE = 'en-GB';
+
+let instantiationTrace = null; // Java: BritishEnglish#instantiationTrace
+
+const id2prio = new JavaHashMap(); // Java: BritishEnglish#id2prio
+for (const [k, v] of ID2PRIO_ENTRIES) id2prio.put(k, v);
+
+// Java: BritishEnglish
+export class BritishEnglish extends English {
+  static FQCN = 'org.languagetool.language.BritishEnglish';
+
+  // Java: BritishEnglish#BritishEnglish() / protected BritishEnglish(boolean) (fake constructor overload for subclasses)
+  constructor(fakeValue) {
+    super();
+    if (fakeValue === undefined) {
+      const trace = instantiationTrace;
+      if (trace !== null) {
+        throw new RuntimeException('Language was already instantiated, see the cause stacktrace below.', trace);
+      }
+      instantiationTrace = new Throwable();
+    }
+  }
+
+  // Java: BritishEnglish#getCountries()
+  getCountries() {
+    return ['GB'];
+  }
+
+  // Java: BritishEnglish#getName()
+  getName() {
+    return 'English (GB)';
+  }
+
+  // Java: BritishEnglish#getRelevantRules(ResourceBundle,UserConfig,Language,List)
+  getRelevantRules(messages, userConfig, motherTongue, altLanguages) {
+    const rules = [...super.getRelevantRules(messages, userConfig, motherTongue, altLanguages)];
+    rules.push(new BritishReplaceRule(messages, '/en/en-GB/replace.txt'));
+    rules.push(new UnitConversionRuleImperial(messages));
+    return rules;
+  }
+
+  // Java: BritishEnglish#createDefaultSpellingRule(ResourceBundle)
+  createDefaultSpellingRule(messages) {
+    return createComponent('org.languagetool.rules.en.MorfologikBritishSpellerRule', messages, this, null, []);
+  }
+
+  // Java: BritishEnglish#getRelevantLanguageModelCapableRules(ResourceBundle,LanguageModel,GlobalConfig,UserConfig,Language,List)
+  getRelevantLanguageModelCapableRules(messages, lm, globalConfig, userConfig, motherTongue, altLanguages) {
+    const rules = [...super.getRelevantLanguageModelCapableRules(messages, lm, globalConfig, userConfig, motherTongue, altLanguages)];
+    rules.push(new MorfologikBritishSpellerRule(messages, this, globalConfig, userConfig, altLanguages, lm, motherTongue));
+    return rules;
+  }
+
+  // Java: BritishEnglish#getPriorityMap()
+  getPriorityMap() {
+    return id2prio;
+  }
+
+  // Java: BritishEnglish#getPriorityForId(String)
+  getPriorityForId(id) {
+    const prio = id2prio.get(id);
+    if (prio !== null) {
+      return prio;
+    }
+    return super.getPriorityForId(id);
+  }
+
+  // Java: BritishEnglish#getInstance()
+  static getInstance() {
+    const language = Objects.requireNonNull(Languages.getLanguageForShortCode(LANGUAGE_SHORT_CODE));
+    if (language instanceof English) {
+      return language;
+    }
+    throw new RuntimeException(`BritishEnglish language expected, got ${language}`);
+  }
+}
+
+registerClass(BritishEnglish.FQCN, BritishEnglish);

package/src/lang/en/language/CanadianEnglish.js

@@ -0,0 +1,70 @@
+// Java: org.languagetool.language.CanadianEnglish
+import { RuntimeException, Throwable } from '@valueerror/ltjs-core/src/lib/java/errors.js';
+import { Objects } from '@valueerror/ltjs-core/src/lib/java/Objects.js';
+import { Languages } from '@valueerror/ltjs-core/src/core/Languages.js';
+import { createComponent } from '@valueerror/ltjs-core/src/core/language/components.js';
+import { registerClass } from '@valueerror/ltjs-core/src/core/resources/ClassBroker.js';
+import { English } from './English.js';
+import { MorfologikCanadianSpellerRule } from '../rules/MorfologikCanadianSpellerRule.js';
+import { UnitConversionRuleImperial } from '../rules/UnitConversionRuleImperial.js';
+
+const LANGUAGE_SHORT_CODE = 'en-CA';
+
+let instantiationTrace = null; // Java: CanadianEnglish#instantiationTrace
+
+// Java: CanadianEnglish
+export class CanadianEnglish extends English {
+  static FQCN = 'org.languagetool.language.CanadianEnglish';
+
+  // Java: CanadianEnglish#CanadianEnglish() / protected CanadianEnglish(boolean) (fake constructor overload for subclasses)
+  constructor(fakeValue) {
+    super();
+    if (fakeValue === undefined) {
+      const trace = instantiationTrace;
+      if (trace !== null) {
+        throw new RuntimeException('Language was already instantiated, see the cause stacktrace below.', trace);
+      }
+      instantiationTrace = new Throwable();
+    }
+  }
+
+  // Java: CanadianEnglish#getCountries()
+  getCountries() {
+    return ['CA'];
+  }
+
+  // Java: CanadianEnglish#getName()
+  getName() {
+    return 'English (Canadian)';
+  }
+
+  // Java: CanadianEnglish#createDefaultSpellingRule(ResourceBundle)
+  createDefaultSpellingRule(messages) {
+    return createComponent('org.languagetool.rules.en.MorfologikCanadianSpellerRule', messages, this, null, []);
+  }
+
+  // Java: CanadianEnglish#getRelevantRules(ResourceBundle,UserConfig,Language,List)
+  getRelevantRules(messages, userConfig, motherTongue, altLanguages) {
+    const rules = [...super.getRelevantRules(messages, userConfig, motherTongue, altLanguages)];
+    rules.push(new UnitConversionRuleImperial(messages));
+    return rules;
+  }
+
+  // Java: CanadianEnglish#getRelevantLanguageModelCapableRules(ResourceBundle,LanguageModel,GlobalConfig,UserConfig,Language,List)
+  getRelevantLanguageModelCapableRules(messages, lm, globalConfig, userConfig, motherTongue, altLanguages) {
+    const rules = [...super.getRelevantLanguageModelCapableRules(messages, lm, globalConfig, userConfig, motherTongue, altLanguages)];
+    rules.push(new MorfologikCanadianSpellerRule(messages, this, globalConfig, userConfig, altLanguages, lm, motherTongue));
+    return rules;
+  }
+
+  // Java: CanadianEnglish#getInstance()
+  static getInstance() {
+    const language = Objects.requireNonNull(Languages.getLanguageForShortCode(LANGUAGE_SHORT_CODE));
+    if (language instanceof English) {
+      return language;
+    }
+    throw new RuntimeException(`CanadianEnglish language expected, got ${language}`);
+  }
+}
+
+registerClass(CanadianEnglish.FQCN, CanadianEnglish);