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

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

@@ -0,0 +1,107 @@
+// org.languagetool.rules.en.EnglishWordRepeatBeginningRule
+import { WordRepeatBeginningRule } from '@valueerror/ltjs-core/src/core/rules/WordRepeatBeginningRule.js';
+import { Example } from '@valueerror/ltjs-core/src/core/rules/model/Examples.js';
+import { toLowerCase } from '@valueerror/ltjs-core/src/lib/java/strings.js';
+import { JavaHashSet } from '@valueerror/ltjs-core/src/lib/java/collections/JavaHashSet.js';
+
+// ==================== ADVERBS ======================
+
+// adverbs used to add to what the previous sentence mentioned
+const ADD_ADVERBS = new JavaHashSet();
+
+// adverbs used to express contrast to what the previous sentence mentioned
+const CONTRAST_ADVERBS = new JavaHashSet();
+
+// adverbs used to express emphasis to what the previous sentence mentioned
+const EMPHASIS_ADVERBS = new JavaHashSet();
+
+// adverbs used to explain what the previous sentence mentioned
+const EXPLAIN_ADVERBS = new JavaHashSet();
+
+// ==================== EXPRESSIONS ======================
+// the expressions will be used only as additional suggestions
+
+// linking expressions that can be used instead of the ADD_ADVERBS
+const ADD_EXPRESSIONS = ['In addition', 'As well as'];
+
+// linking expressions that can be used instead of the CONTRAST_ADVERBS
+const CONTRAST_EXPRESSIONS = ['Even so', 'On the other hand'];
+
+// Java: EnglishWordRepeatBeginningRule static initializer
+// based on https://www.pinterest.com/pin/229542912245527548/
+ADD_ADVERBS.add('Additionally');
+ADD_ADVERBS.add('Besides');
+ADD_ADVERBS.add('Furthermore');
+ADD_ADVERBS.add('Moreover');
+ADD_ADVERBS.add('Also');
+CONTRAST_ADVERBS.add('Nevertheless');
+CONTRAST_ADVERBS.add('Nonetheless');
+CONTRAST_ADVERBS.add('Alternatively');
+EMPHASIS_ADVERBS.add('Undoubtedly');
+EMPHASIS_ADVERBS.add('Indeed');
+EMPHASIS_ADVERBS.add('Obviously');
+EMPHASIS_ADVERBS.add('Clearly');
+EMPHASIS_ADVERBS.add('Importantly');
+EMPHASIS_ADVERBS.add('Absolutely');
+EMPHASIS_ADVERBS.add('Definitely');
+EXPLAIN_ADVERBS.add('Particularly');
+EXPLAIN_ADVERBS.add('Especially');
+EXPLAIN_ADVERBS.add('Specifically');
+
+// Java: EnglishWordRepeatBeginningRule
+export class EnglishWordRepeatBeginningRule extends WordRepeatBeginningRule {
+  static FQCN = 'org.languagetool.rules.en.EnglishWordRepeatBeginningRule';
+
+  // Java: EnglishWordRepeatBeginningRule(ResourceBundle,Language)
+  constructor(messages, language) {
+    super(messages, language);
+    this.addExamplePair(Example.wrong('Moreover, the street is almost entirely residential. <marker>Moreover</marker>, it was named after a poet.'),
+      Example.fixed('Moreover, the street is almost entirely residential. <marker>It</marker> was named after a poet.'));
+  }
+
+  // Java: EnglishWordRepeatBeginningRule#getId()
+  getId() {
+    return 'ENGLISH_WORD_REPEAT_BEGINNING_RULE';
+  }
+
+  // Java: EnglishWordRepeatBeginningRule#isException(String)
+  isException(token) {
+    return super.isException(token) || token === 'The' || token === 'A' || token === 'An';
+  }
+
+  // Java: EnglishWordRepeatBeginningRule#isAdverb(AnalyzedTokenReadings)
+  isAdverb(token) {
+    const tok = token.getToken();
+    return ADD_ADVERBS.contains(tok) || CONTRAST_ADVERBS.contains(tok) || EMPHASIS_ADVERBS.contains(tok)
+      || EXPLAIN_ADVERBS.contains(tok);
+  }
+
+  // Java: EnglishWordRepeatBeginningRule#getSuggestions(AnalyzedTokenReadings)
+  getSuggestions(token) {
+    const tok = token.getToken();
+    // the repeated word is a personal pronoun
+    if (token.hasPosTag('PRP')) {
+      const adaptedToken = tok === 'I' ? tok : toLowerCase(tok);
+      return ['Furthermore, ' + adaptedToken, 'Likewise, ' + adaptedToken,
+        'Not only that, but ' + adaptedToken];
+    } else if (ADD_ADVERBS.contains(tok)) {
+      const addSuggestions = this.getDifferentAdverbsOfSameCategory(tok, ADD_ADVERBS);
+      addSuggestions.push(...ADD_EXPRESSIONS);
+      return addSuggestions;
+    } else if (CONTRAST_ADVERBS.contains(tok)) {
+      const contrastSuggestions = this.getDifferentAdverbsOfSameCategory(tok, CONTRAST_ADVERBS);
+      contrastSuggestions.push(...CONTRAST_EXPRESSIONS);
+      return contrastSuggestions;
+    } else if (EMPHASIS_ADVERBS.contains(tok)) {
+      return this.getDifferentAdverbsOfSameCategory(tok, EMPHASIS_ADVERBS);
+    } else if (EXPLAIN_ADVERBS.contains(tok)) {
+      return this.getDifferentAdverbsOfSameCategory(tok, EXPLAIN_ADVERBS);
+    }
+    return [];
+  }
+
+  // Java: EnglishWordRepeatBeginningRule#getDifferentAdverbsOfSameCategory(String,Set)
+  getDifferentAdverbsOfSameCategory(adverb, adverbsOfCategory) {
+    return [...adverbsOfCategory].filter((adv) => adv !== adverb);
+  }
+}

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

@@ -0,0 +1,126 @@
+// org.languagetool.rules.en.EnglishWordRepeatRule
+import { Pattern } from '@valueerror/ltjs-core/src/lib/java/regex/index.js';
+import { javaMatches, equalsIgnoreCase } from '@valueerror/ltjs-core/src/lib/java/strings.js';
+import { WordRepeatRule } from '@valueerror/ltjs-core/src/core/rules/WordRepeatRule.js';
+import { Example } from '@valueerror/ltjs-core/src/core/rules/model/Examples.js';
+
+const SINGLE_CHAR = Pattern.compile('(?i)^[a-z]$');
+
+// plain "repetitionOf(word)" branches of the Java else-if chain, in source order ("wait" only at position 2)
+const REPETITION_WORDS = [
+  'aye', 'blah', 'mau', 'uh', 'paw', 'cha', 'yum', 'wop', 'woop', 'fnarr', 'fnar', 'ha', 'omg', 'boo', 'tick', 'twinkle', 'ta', 'la', 'x',
+  'hi', 'ho', 'heh', 'jay', 'walla', 'sri', 'hey', 'hah', 'heh', 'oh', 'ouh', 'chop', 'ring', 'beep', 'bleep', 'yeah', 'gout', 'wait',
+  'quack', 'meow', 'squawk', 'whoa', 'si', 'honk', 'brum', 'chi', 'santorio', 'lapu', 'chow', 'beep', 'shh', 'yummy', 'boom', 'bye', 'ah',
+  'aah', 'bang', 'woof', 'wink', 'yes', 'tsk', 'hush', 'ding', 'choo', 'miu', 'tuk', 'yadda', 'walla', 'doo', 'sapiens', 'tse', 'no', 'Bora',
+];
+
+// Java: EnglishWordRepeatRule
+export class EnglishWordRepeatRule extends WordRepeatRule {
+  static FQCN = 'org.languagetool.rules.en.EnglishWordRepeatRule';
+
+  // Java: EnglishWordRepeatRule(ResourceBundle,Language)
+  constructor(messages, language) {
+    super(messages, language);
+    this.addExamplePair(Example.wrong('This <marker>is is</marker> just an example sentence.'),
+      Example.fixed('This <marker>is</marker> just an example sentence.'));
+  }
+
+  // Java: EnglishWordRepeatRule#getId()
+  getId() {
+    return 'ENGLISH_WORD_REPEAT_RULE';
+  }
+
+  // Java: EnglishWordRepeatRule#ignore(AnalyzedTokenReadings[],int)
+  ignore(tokens, position) {
+    if (position === 0) {
+      return false;
+    }
+    // TODO:
+    // What that is is a ...
+    // but you you're my best friend ...
+    // I'm so so happy
+    // I'm very very happy
+    const word = tokens[position].getToken();
+    if ((this.repetitionOf('did', tokens, position) || this.repetitionOf('do', tokens, position)
+        || this.repetitionOf('does', tokens, position)) && (position + 1 < tokens.length)
+        && equalsIgnoreCase(tokens[position + 1].getToken(), "n't")) {
+      return true;
+    } else if (this.repetitionOf('her', tokens, position) && this.posIsIn(tokens, position - 2, 'VB', 'VBP', 'VBZ', 'VBG', 'VBD', 'VBN') && this.posIsIn(tokens, position + 1, 'NN', 'NNS', 'NN:U', 'NN:UN', 'NNP')) {
+      return true; // "Please pass her her phone."
+    } else if (this.repetitionOf('had', tokens, position) && this.posIsIn(tokens, position - 2, 'PRP', 'NN')) {
+      return true; // "If I had had time, I would have gone to see him."
+    } else if (this.repetitionOf('that', tokens, position) && this.posIsIn(tokens, position + 1, 'MD', 'NN', 'PRP$', 'JJ', 'VBZ', 'VBD')) {
+      return true; // "I don't think that that is a problem."
+    } else if (this.repetitionOf('can', tokens, position) && this.posIsIn(tokens, position - 1, 'NN')) {
+      return true; // "The can can hold the water."
+    } else if (this.repetitionOf('hip', tokens, position) && (position + 1 < tokens.length) && equalsIgnoreCase(tokens[position + 1].getToken(), 'hooray')) {
+      return true;
+    } else if (this.repetitionOf('bam', tokens, position) && (position + 1 < tokens.length) && equalsIgnoreCase(tokens[position + 1].getToken(), 'bigelow')) {
+      return true;
+    } else if (this.repetitionOf('wild', tokens, position) && (position + 1 < tokens.length) && equalsIgnoreCase(tokens[position + 1].getToken(), 'west')) {
+      return true; // In the wild wild west (https://en.wikipedia.org/wiki/Wild_Wild_West)
+    } else if (this.repetitionOf('far', tokens, position) && (position + 1 < tokens.length) && equalsIgnoreCase(tokens[position + 1].getToken(), 'away')) {
+      return true;
+    } else if (this.repetitionOf('so', tokens, position) && (position + 1 < tokens.length) && equalsIgnoreCase(tokens[position + 1].getToken(), 'much')) {
+      return true;
+    } else if (this.repetitionOf('so', tokens, position) && (position + 1 < tokens.length) && equalsIgnoreCase(tokens[position + 1].getToken(), 'many')) {
+      return true;
+    } else if (this.repetitionOf('s', tokens, position) && position > 1 && javaMatches(tokens[position - 2].getToken(), "['’`´‘]")) {
+      return true; // It's S.T.E.A.M.
+    } else if (this.repetitionOf('in', tokens, position) && position > 2 && javaMatches(tokens[position - 3].getToken(), 'log(ged|s)?|sign(ed|s)?')) {
+      return true; // log them in in the
+    } else if (this.repetitionOf('in', tokens, position) && position > 1 && javaMatches(tokens[position - 2].getToken(), 'log(ged|s)?|sign(ed|s)?')) {
+      return true; // log in in the
+    } else if (this.repetitionOf('a', tokens, position) && position > 1 && tokens[position - 2].getToken() === '.') {
+      return true; // "a.k.a a"
+    } else if (this.repetitionOf('on', tokens, position) && position > 1 && tokens[position - 2].getToken() === '.') {
+      return true; // "You can contact E.ON on Instagram"
+    } else if (equalsIgnoreCase(tokens[position - 1].getToken(), word) && (((position + 1 < tokens.length) && equalsIgnoreCase(tokens[position + 1].getToken(), word)) || (position > 1 && equalsIgnoreCase(tokens[position - 2].getToken(), word)))) {
+      // three time word repetition
+      return true;
+    } else if (SINGLE_CHAR.matcher(tokens[position].getToken()).matches() && position > 1
+        && SINGLE_CHAR.matcher(tokens[position - 2].getToken()).matches()
+        && (position + 1 < tokens.length) && SINGLE_CHAR.matcher(tokens[position + 1].getToken()).matches()) {
+      // spelling with spaces in between: "b a s i c a l l y"
+      return true;
+    }
+    for (const w of REPETITION_WORDS) {
+      if (this.repetitionOf(w, tokens, position) && (w !== 'wait' || position === 2)) {
+        return true;
+      }
+    }
+    if (tokens[position].getToken().endsWith('ay')) {
+      if (tokens[position - 1].getToken() === 'may' && tokens[position].getToken() === 'May') {
+        return true; // "may May"
+      }
+      if (tokens[position - 1].getToken() === 'May' && tokens[position].getToken() === 'may') {
+        return true; // "May may"
+      }
+      if (tokens[1].getToken() === 'May' && tokens[2].getToken() === 'May') {
+        return true; // "May May" SENT_START
+      }
+    } else if (tokens[position].getToken().endsWith('ill')) {
+      return (position > 0 && tokens[position - 1].getToken() === 'will' && tokens[position].getToken() === 'Will') // will Wills
+        || (tokens[position - 1].getToken() === 'Will' && tokens[position].getToken() === 'will') // Will will ...
+        || (tokens[1].getToken() === 'Will' && tokens[2].getToken() === 'Will'); // "Will Will" SENT_START
+    }
+    return super.ignore(tokens, position);
+  }
+
+  // Java: EnglishWordRepeatRule#posIsIn(AnalyzedTokenReadings[],int,String...)
+  posIsIn(tokens, position, ...posTags) {
+    if (position >= 0 && position < tokens.length) {
+      for (const posTag of posTags) {
+        if (tokens[position].hasPartialPosTag(posTag)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  // Java: EnglishWordRepeatRule#repetitionOf(String,AnalyzedTokenReadings[],int)
+  repetitionOf(word, tokens, position) {
+    return position > 0 && equalsIgnoreCase(tokens[position - 1].getToken(), word) && equalsIgnoreCase(tokens[position].getToken(), word);
+  }
+}

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

@@ -0,0 +1,50 @@
+// org.languagetool.rules.en.EnglishWrongWordInContextRule
+import { WrongWordInContextRule } from '@valueerror/ltjs-core/src/core/rules/WrongWordInContextRule.js';
+import { Example } from '@valueerror/ltjs-core/src/core/rules/model/Examples.js';
+
+// Java: EnglishWrongWordInContextRule
+export class EnglishWrongWordInContextRule extends WrongWordInContextRule {
+  static FQCN = 'org.languagetool.rules.en.EnglishWrongWordInContextRule';
+
+  // Java: EnglishWrongWordInContextRule(ResourceBundle,Language)
+  constructor(messages, lang) {
+    super(messages, lang);
+    this.addExamplePair(Example.wrong('I have <marker>proscribed</marker> you a course of antibiotics.'),
+      Example.fixed('I have <marker>prescribed</marker> you a course of antibiotics.'));
+  }
+
+  // Java: EnglishWrongWordInContextRule#getCategoryString()
+  getCategoryString() {
+    return 'Commonly Confused Words';
+  }
+
+  // Java: EnglishWrongWordInContextRule#getId()
+  getId() {
+    return 'ENGLISH_WRONG_WORD_IN_CONTEXT';
+  }
+
+  // Java: EnglishWrongWordInContextRule#getDescription()
+  getDescription() {
+    return 'commonly confused words: $match';
+  }
+
+  // Java: EnglishWrongWordInContextRule#getFilename()
+  getFilename() {
+    return '/en/wrongWordInContext.txt';
+  }
+
+  // Java: EnglishWrongWordInContextRule#getMessageString()
+  getMessageString() {
+    return "Possibly confused word: Did you mean <suggestion>$SUGGESTION</suggestion> instead of '$WRONGWORD'?";
+  }
+
+  // Java: EnglishWrongWordInContextRule#getShortMessageString()
+  getShortMessageString() {
+    return 'Possibly confused word';
+  }
+
+  // Java: EnglishWrongWordInContextRule#getLongMessageString()
+  getLongMessageString() {
+    return "Possibly confused word: Did you mean <suggestion>$SUGGESTION</suggestion> (= $EXPLANATION_SUGGESTION) instead of '$WRONGWORD' (= $EXPLANATION_WRONGWORD)?";
+  }
+}

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

@@ -0,0 +1,41 @@
+// org.languagetool.rules.en.FindSuggestionsFilter
+import { registerClass } from '@valueerror/ltjs-core/src/core/resources/ClassBroker.js';
+import { NullPointerException } from '@valueerror/ltjs-core/src/lib/java/errors.js';
+import { getDataBroker } from '@valueerror/ltjs-core/src/core/resources/LtStatics.js';
+import { AbstractFindSuggestionsFilter } from '@valueerror/ltjs-core/src/core/rules/AbstractFindSuggestionsFilter.js';
+import { MorfologikSpeller } from '@valueerror/ltjs-core/src/core/rules/spelling/morfologik/MorfologikSpeller.js';
+import { EnglishTagger } from '../tagging/EnglishTagger.js';
+
+const DICT_FILENAME = '/en/english.dict';
+let speller = null; // Java: FindSuggestionsFilter#speller (static)
+
+// Java: FindSuggestionsFilter
+export class FindSuggestionsFilter extends AbstractFindSuggestionsFilter {
+  static FQCN = 'org.languagetool.rules.en.FindSuggestionsFilter';
+  static JAVA_ABSTRACT = false;
+  static JAVA_CONSTRUCTORS = [{ params: [], text: 'public org.languagetool.rules.en.FindSuggestionsFilter() throws java.io.IOException' }];
+
+  // Java: FindSuggestionsFilter#FindSuggestionsFilter()
+  constructor() {
+    super();
+    // lazy init
+    if (speller === null) {
+      if (getDataBroker().resourceExists(DICT_FILENAME)) {
+        speller = new MorfologikSpeller(DICT_FILENAME);
+      }
+    }
+  }
+
+  // Java: FindSuggestionsFilter#getTagger()
+  getTagger() {
+    return EnglishTagger.INSTANCE;
+  }
+
+  // Java: FindSuggestionsFilter#getSpellingSuggestions(AnalyzedTokenReadings)
+  getSpellingSuggestions(atr) {
+    if (speller === null) throw new NullPointerException();
+    return speller.findSimilarWords(atr.getToken());
+  }
+}
+
+registerClass(FindSuggestionsFilter.FQCN, FindSuggestionsFilter);

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

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

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

@@ -0,0 +1,19 @@
+// org.languagetool.rules.en.LongSentenceRule
+import { LongSentenceRule as CoreLongSentenceRule } from '@valueerror/ltjs-core/src/core/rules/LongSentenceRule.js';
+import { getUrl } from '@valueerror/ltjs-core/src/core/Tools.js';
+
+// Java: LongSentenceRule (en)
+export class LongSentenceRule extends CoreLongSentenceRule {
+  static FQCN = 'org.languagetool.rules.en.LongSentenceRule';
+
+  // Java: LongSentenceRule(ResourceBundle,UserConfig,int)
+  constructor(messages, userConfig, defaultWords) {
+    super(messages, userConfig, defaultWords);
+    this.setUrl(getUrl('https://languagetool.org/insights/post/splitting-long-sentences/'));
+  }
+
+  // Java: LongSentenceRule#getShortMessage()
+  getShortMessage() {
+    return 'Long sentence';
+  }
+}

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

@@ -0,0 +1,69 @@
+// org.languagetool.rules.en.MorfologikAmericanSpellerRule
+import { AbstractEnglishSpellerRule } from './AbstractEnglishSpellerRule.js';
+import { VariantInfo } from './VariantInfo.js';
+import { SuggestedReplacement } from '@valueerror/ltjs-core/src/core/rules/model/SuggestedReplacement.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_US.dict';
+const LANGUAGE_SPECIFIC_PLAIN_TEXT_DICT = 'en/hunspell/spelling_en-US.txt';
+let BRITISH_ENGLISH = null; // Java: static final Map BRITISH_ENGLISH = loadWordlist("en/en-US-GB.txt", 1), initialised with the class
+
+// Java: MorfologikAmericanSpellerRule
+export class MorfologikAmericanSpellerRule extends AbstractEnglishSpellerRule {
+  static FQCN = 'org.languagetool.rules.en.MorfologikAmericanSpellerRule';
+  static RULE_ID = 'MORFOLOGIK_RULE_EN_US';
+
+  // Java: MorfologikAmericanSpellerRule(ResourceBundle,Language) / (..., UserConfig, List) / (..., GlobalConfig, UserConfig, List, LanguageModel, Language)
+  constructor(messages, language, ...rest) {
+    if (BRITISH_ENGLISH === null) BRITISH_ENGLISH = AbstractEnglishSpellerRule.loadWordlist('en/en-US-GB.txt', 1);
+    if (rest.length === 0) {
+      super(messages, language, null, null, [], null, null);
+    } else {
+      super(messages, language, ...rest);
+    }
+  }
+
+  // Java: MorfologikAmericanSpellerRule#isValidInOtherVariant(String)
+  isValidInOtherVariant(word) {
+    const otherVariant = BRITISH_ENGLISH.get(toLowerCase(word));
+    if (otherVariant !== undefined) {
+      return new VariantInfo('British English', otherVariant);
+    }
+    return null;
+  }
+
+  // Java: MorfologikAmericanSpellerRule#getFileName()
+  getFileName() {
+    return RESOURCE_FILENAME;
+  }
+
+  // Java: MorfologikAmericanSpellerRule#getId()
+  getId() {
+    return MorfologikAmericanSpellerRule.RULE_ID;
+  }
+
+  // Java: MorfologikAmericanSpellerRule#getLanguageVariantSpellingFileName()
+  getLanguageVariantSpellingFileName() {
+    return LANGUAGE_SPECIFIC_PLAIN_TEXT_DICT;
+  }
+
+  // Java: MorfologikAmericanSpellerRule#getAdditionalTopSuggestions(List,String)
+  getAdditionalTopSuggestions(suggestions, word) {
+    let s = null;
+    if ('automize' === word) {
+      s = ['automate'];
+    } else if ('automized' === word) {
+      s = ['automated'];
+    } else if ('automizing' === word) {
+      s = ['automating'];
+    } else if ('automizes' === word) {
+      s = ['automates'];
+    }
+    if (s !== null) {
+      return SuggestedReplacement.convert(s);
+    }
+    return super.getAdditionalTopSuggestions(suggestions, word);
+  }
+}
+registerComponent(MorfologikAmericanSpellerRule.FQCN, (...args) => new MorfologikAmericanSpellerRule(...args));

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

@@ -0,0 +1,45 @@
+// org.languagetool.rules.en.MorfologikAustralianSpellerRule
+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_AU.dict';
+const LANGUAGE_SPECIFIC_PLAIN_TEXT_DICT = 'en/hunspell/spelling_en-AU.txt';
+let US_ENGLISH = null; // Java: static final Map US_ENGLISH = loadWordlist("en/en-US-GB.txt", 0), initialised with the class
+
+// Java: MorfologikAustralianSpellerRule
+export class MorfologikAustralianSpellerRule extends AbstractEnglishSpellerRule {
+  static FQCN = 'org.languagetool.rules.en.MorfologikAustralianSpellerRule';
+
+  // Java: MorfologikAustralianSpellerRule(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: MorfologikAustralianSpellerRule#isValidInOtherVariant(String)
+  isValidInOtherVariant(word) {
+    const otherVariant = US_ENGLISH.get(toLowerCase(word));
+    if (otherVariant !== undefined) {
+      return new VariantInfo('American English', otherVariant);
+    }
+    return null;
+  }
+
+  // Java: MorfologikAustralianSpellerRule#getFileName()
+  getFileName() {
+    return RESOURCE_FILENAME;
+  }
+
+  // Java: MorfologikAustralianSpellerRule#getId()
+  getId() {
+    return 'MORFOLOGIK_RULE_EN_AU';
+  }
+
+  // Java: MorfologikAustralianSpellerRule#getLanguageVariantSpellingFileName()
+  getLanguageVariantSpellingFileName() {
+    return LANGUAGE_SPECIFIC_PLAIN_TEXT_DICT;
+  }
+}
+registerComponent(MorfologikAustralianSpellerRule.FQCN, (...args) => new MorfologikAustralianSpellerRule(...args));

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

@@ -0,0 +1,47 @@
+// org.languagetool.rules.en.MorfologikBritishSpellerRule
+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_GB.dict';
+const LANGUAGE_SPECIFIC_PLAIN_TEXT_DICT = 'en/hunspell/spelling_en-GB.txt';
+let US_ENGLISH = null; // Java: static final Map US_ENGLISH = loadWordlist("en/en-US-GB.txt", 0), initialised with the class
+
+// Java: MorfologikBritishSpellerRule
+export class MorfologikBritishSpellerRule extends AbstractEnglishSpellerRule {
+  static FQCN = 'org.languagetool.rules.en.MorfologikBritishSpellerRule';
+
+  static RULE_ID = 'MORFOLOGIK_RULE_EN_GB';
+
+  // Java: MorfologikBritishSpellerRule(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: MorfologikBritishSpellerRule#isValidInOtherVariant(String)
+  isValidInOtherVariant(word) {
+    const otherVariant = US_ENGLISH.get(toLowerCase(word));
+    if (otherVariant !== undefined) {
+      return new VariantInfo('American English', otherVariant);
+    }
+    return null;
+  }
+
+  // Java: MorfologikBritishSpellerRule#getFileName()
+  getFileName() {
+    return RESOURCE_FILENAME;
+  }
+
+  // Java: MorfologikBritishSpellerRule#getId()
+  getId() {
+    return MorfologikBritishSpellerRule.RULE_ID;
+  }
+
+  // Java: MorfologikBritishSpellerRule#getLanguageVariantSpellingFileName()
+  getLanguageVariantSpellingFileName() {
+    return LANGUAGE_SPECIFIC_PLAIN_TEXT_DICT;
+  }
+}
+registerComponent(MorfologikBritishSpellerRule.FQCN, (...args) => new MorfologikBritishSpellerRule(...args));

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

@@ -0,0 +1,45 @@
+// org.languagetool.rules.en.MorfologikCanadianSpellerRule
+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_CA.dict';
+const LANGUAGE_SPECIFIC_PLAIN_TEXT_DICT = 'en/hunspell/spelling_en-CA.txt';
+let US_ENGLISH = null; // Java: static final Map US_ENGLISH = loadWordlist("en/en-US-GB.txt", 0), initialised with the class
+
+// Java: MorfologikCanadianSpellerRule
+export class MorfologikCanadianSpellerRule extends AbstractEnglishSpellerRule {
+  static FQCN = 'org.languagetool.rules.en.MorfologikCanadianSpellerRule';
+
+  // Java: MorfologikCanadianSpellerRule(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: MorfologikCanadianSpellerRule#isValidInOtherVariant(String)
+  isValidInOtherVariant(word) {
+    const otherVariant = US_ENGLISH.get(toLowerCase(word));
+    if (otherVariant !== undefined) {
+      return new VariantInfo('American English', otherVariant);
+    }
+    return null;
+  }
+
+  // Java: MorfologikCanadianSpellerRule#getFileName()
+  getFileName() {
+    return RESOURCE_FILENAME;
+  }
+
+  // Java: MorfologikCanadianSpellerRule#getId()
+  getId() {
+    return 'MORFOLOGIK_RULE_EN_CA';
+  }
+
+  // Java: MorfologikCanadianSpellerRule#getLanguageVariantSpellingFileName()
+  getLanguageVariantSpellingFileName() {
+    return LANGUAGE_SPECIFIC_PLAIN_TEXT_DICT;
+  }
+}
+registerComponent(MorfologikCanadianSpellerRule.FQCN, (...args) => new MorfologikCanadianSpellerRule(...args));

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

@@ -0,0 +1,45 @@
+// org.languagetool.rules.en.MorfologikNewZealandSpellerRule
+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_NZ.dict';
+const LANGUAGE_SPECIFIC_PLAIN_TEXT_DICT = 'en/hunspell/spelling_en-NZ.txt';
+let US_ENGLISH = null; // Java: static final Map US_ENGLISH = loadWordlist("en/en-US-GB.txt", 0), initialised with the class
+
+// Java: MorfologikNewZealandSpellerRule
+export class MorfologikNewZealandSpellerRule extends AbstractEnglishSpellerRule {
+  static FQCN = 'org.languagetool.rules.en.MorfologikNewZealandSpellerRule';
+
+  // Java: MorfologikNewZealandSpellerRule(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: MorfologikNewZealandSpellerRule#isValidInOtherVariant(String)
+  isValidInOtherVariant(word) {
+    const otherVariant = US_ENGLISH.get(toLowerCase(word));
+    if (otherVariant !== undefined) {
+      return new VariantInfo('American English', otherVariant);
+    }
+    return null;
+  }
+
+  // Java: MorfologikNewZealandSpellerRule#getFileName()
+  getFileName() {
+    return RESOURCE_FILENAME;
+  }
+
+  // Java: MorfologikNewZealandSpellerRule#getId()
+  getId() {
+    return 'MORFOLOGIK_RULE_EN_NZ';
+  }
+
+  // Java: MorfologikNewZealandSpellerRule#getLanguageVariantSpellingFileName()
+  getLanguageVariantSpellingFileName() {
+    return LANGUAGE_SPECIFIC_PLAIN_TEXT_DICT;
+  }
+}
+registerComponent(MorfologikNewZealandSpellerRule.FQCN, (...args) => new MorfologikNewZealandSpellerRule(...args));