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

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

@@ -0,0 +1,182 @@
+// org.languagetool.rules.en.AvsAnRule
+import { AnalyzedToken } from '@valueerror/ltjs-core/src/core/AnalyzedToken.js';
+import { AnalyzedTokenReadings } from '@valueerror/ltjs-core/src/core/AnalyzedTokenReadings.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 { Rule } from '@valueerror/ltjs-core/src/core/rules/model/Rule.js';
+import { RuleMatch } from '@valueerror/ltjs-core/src/core/rules/model/RuleMatch.js';
+import { getUrl } from '@valueerror/ltjs-core/src/core/Tools.js';
+import { isAllUppercase, isEmpty, isMixedCase, lowercaseFirstCharIfCapitalized, startsWithUppercase } from '@valueerror/ltjs-core/src/core/text/StringTools.js';
+import { Character } from '@valueerror/ltjs-core/src/lib/java/Character.js';
+import { JavaEnum } from '@valueerror/ltjs-core/src/lib/java/JavaEnum.js';
+import { NullPointerException } from '@valueerror/ltjs-core/src/lib/java/errors.js';
+import { Pattern } from '@valueerror/ltjs-core/src/lib/java/regex/index.js';
+import { equalsIgnoreCase, toLowerCase } from '@valueerror/ltjs-core/src/lib/java/strings.js';
+import { getWordsRequiringA, getWordsRequiringAn } from './AvsAnData.js';
+
+const cleanupPattern = Pattern.compile('[^αa-zA-Z0-9.;,:\']');
+const delimPattern = Pattern.compile('[-"“\'‘()\\[\\]]+');
+const dashQuotePattern = Pattern.compile('[-\']');
+const anPrefixes = Pattern.compile('^(unidentif|uni[mn])[a-z]+$', Pattern.CASE_INSENSITIVE);
+const anExceptionPrefixes = Pattern.compile('^(eu|one|uni|u[rst][aeiou])[a-z]*$', Pattern.CASE_INSENSITIVE);
+
+// Java: AvsAnRule.Determiner
+export class Determiner extends JavaEnum {
+  static FQCN = 'org.languagetool.rules.en.AvsAnRule.Determiner';
+  static A = new Determiner('A', 0);
+  static AN = new Determiner('AN', 1);
+  static A_OR_AN = new Determiner('A_OR_AN', 2);
+  static UNKNOWN = new Determiner('UNKNOWN', 3);
+}
+
+// Java: AvsAnRule#isVowel(char)
+function isVowel(c) {
+  const lc = Character.toLowerCase(c);
+  return lc === 0x61 || lc === 0x65 || lc === 0x69 || lc === 0x6f || lc === 0x75;
+}
+
+// Java: AvsAnRule
+export class AvsAnRule extends Rule {
+  static FQCN = 'org.languagetool.rules.en.AvsAnRule';
+  static Determiner = Determiner;
+
+  // Java: AvsAnRule#AvsAnRule(ResourceBundle)
+  constructor(messages) {
+    super();
+    this.setCategory(Categories.MISC.getCategory(messages));
+    this.setLocQualityIssueType(ITSIssueType.Misspelling);
+    this.setUrl(getUrl('https://languagetool.org/insights/post/indefinite-articles/'));
+    this.addExamplePair(Example.wrong('The train arrived <marker>a hour</marker> ago.'),
+      Example.fixed('The train arrived <marker>an hour</marker> ago.'));
+  }
+
+  // Java: AvsAnRule#getId()
+  getId() {
+    return 'EN_A_VS_AN';
+  }
+
+  // Java: AvsAnRule#getDescription()
+  getDescription() {
+    return "Use of 'a' vs. 'an'";
+  }
+
+  // Java: AvsAnRule#estimateContextForSureMatch()
+  estimateContextForSureMatch() {
+    return 1;
+  }
+
+  // Java: AvsAnRule#match(AnalyzedSentence)
+  match(sentence) {
+    const ruleMatches = [];
+    const tokens = sentence.getTokensWithoutWhitespace();
+    let prevTokenIndex = 0;
+    let isSentenceStart;
+    let equalsA;
+    let equalsAn;
+    for (let i = 1; i < tokens.length; i++) { // ignoring token 0, i.e., SENT_START
+      const token = tokens[i];
+      const prevTokenStr = prevTokenIndex > 0 ? tokens[prevTokenIndex].getToken() : null;
+      isSentenceStart = prevTokenIndex === 1;
+      if (!isSentenceStart) {
+        equalsA = prevTokenStr === 'a';
+        equalsAn = prevTokenStr === 'an';
+      } else {
+        equalsA = prevTokenStr !== null && equalsIgnoreCase('a', prevTokenStr);
+        equalsAn = prevTokenStr !== null && equalsIgnoreCase('an', prevTokenStr);
+      }
+      if (equalsA || equalsAn) {
+        const determiner = AvsAnRule.getCorrectDeterminerFor(token);
+        let msg = null;
+        if (equalsA && determiner === Determiner.AN) {
+          const replacement = startsWithUppercase(prevTokenStr) ? 'An' : 'an';
+          msg = `Use <suggestion>${replacement}</suggestion> instead of '${prevTokenStr}' if the following ` +
+            "word starts with a vowel sound, e.g. 'an article', 'an hour'.";
+        } else if (equalsAn && determiner === Determiner.A) {
+          const replacement = startsWithUppercase(prevTokenStr) ? 'A' : 'a';
+          msg = `Use <suggestion>${replacement}</suggestion> instead of '${prevTokenStr}' if the following ` +
+            "word doesn't start with a vowel sound, e.g. 'a sentence', 'a university'.";
+        }
+        if (msg !== null) {
+          const match = new RuleMatch(
+            this, sentence, tokens[prevTokenIndex].getStartPos(), tokens[prevTokenIndex].getEndPos(),
+            tokens[prevTokenIndex].getStartPos(), token.getEndPos(), msg, 'Wrong article');
+          ruleMatches.push(match);
+        }
+      }
+      let nextToken = '';
+      if (i + 1 < tokens.length) {
+        nextToken = tokens[i + 1].getToken();
+      }
+      if (token.hasPosTag('DT')) {
+        prevTokenIndex = i;
+      } else if (nextToken.length > 1 && delimPattern.matcher(token.getToken()).matches()) {
+        // skip e.g. the quote in >>an "industry party"<<
+      } else {
+        prevTokenIndex = 0;
+      }
+    }
+    return this.toRuleMatchArray(ruleMatches);
+  }
+
+  /**
+   * Adds "a" or "an" to the English noun (suggestion of the proper indefinite article).
+   */
+  // Java: AvsAnRule#suggestAorAn(String)
+  suggestAorAn(origWord) {
+    const token = new AnalyzedTokenReadings(new AnalyzedToken(origWord, null, null), 0);
+    const determiner = AvsAnRule.getCorrectDeterminerFor(token);
+    if (determiner === Determiner.A || determiner === Determiner.A_OR_AN) {
+      return `a ${lowercaseFirstCharIfCapitalized(origWord)}`;
+    } else if (determiner === Determiner.AN) {
+      return `an ${lowercaseFirstCharIfCapitalized(origWord)}`;
+    }
+    return origWord;
+  }
+
+  // Java: AvsAnRule#getCorrectDeterminerFor(AnalyzedTokenReadings)
+  static getCorrectDeterminerFor(token) {
+    if (token === null || token === undefined) {
+      throw new NullPointerException('Cannot invoke "org.languagetool.AnalyzedTokenReadings.getToken()" because "token" is null');
+    }
+    let word = token.getToken();
+    let determiner = Determiner.UNKNOWN;
+    const parts = dashQuotePattern.split(word); // for example, in "one-way" only "one" is relevant
+    const anPrefix = anPrefixes.matcher(token.getToken());
+    const anExceptionPrefix = anExceptionPrefixes.matcher(token.getToken());
+    if (parts.length >= 1 && !equalsIgnoreCase(parts[0], 'a')) { // avoid false alarm on "A-levels are..."
+      word = parts[0];
+    }
+    if (token.isWhitespaceBefore() || word !== '-') { // e.g., 'a- or anti- are prefixes'
+      word = cleanupPattern.matcher(word).replaceAll(''); // e.g. >>an "industry party"<<
+      if (isEmpty(word)) {
+        return Determiner.UNKNOWN;
+      }
+    }
+    if (getWordsRequiringA().has(toLowerCase(word)) || getWordsRequiringA().has(word)) {
+      determiner = Determiner.A;
+    }
+    if (getWordsRequiringAn().has(toLowerCase(word)) || getWordsRequiringAn().has(word)) {
+      if (determiner === Determiner.A) {
+        determiner = Determiner.A_OR_AN; // e.g. for 'historical'
+      } else {
+        determiner = Determiner.AN;
+      }
+    }
+    if (determiner === Determiner.UNKNOWN) {
+      const tokenFirstChar = word.charCodeAt(0);
+      if (isAllUppercase(word) || isMixedCase(word)) {
+        // we don't know how all-uppercase words (often abbreviations) are pronounced,
+        // so never complain about these
+        determiner = Determiner.UNKNOWN;
+      } else if (anPrefix.find()) {
+        determiner = Determiner.AN;
+      } else if (isVowel(tokenFirstChar) && !anExceptionPrefix.find()) {
+        determiner = Determiner.AN;
+      } else {
+        determiner = Determiner.A;
+      }
+    }
+    return determiner;
+  }
+}

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

@@ -0,0 +1,57 @@
+// org.languagetool.rules.en.BritishReplaceRule
+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 { BritishEnglish } from '../language/BritishEnglish.js';
+
+const EN_GB_LOCALE = new Locale('en-GB');
+
+// Java: BritishReplaceRule
+export class BritishReplaceRule extends AbstractSimpleReplaceRule2 {
+  static FQCN = 'org.languagetool.rules.en.BritishReplaceRule';
+  static BRITISH_SIMPLE_REPLACE_RULE = 'EN_GB_SIMPLE_REPLACE';
+
+  // Java: BritishReplaceRule#getFileNames()
+  getFileNames() {
+    return [this.path];
+  }
+
+  // Java: BritishReplaceRule(ResourceBundle,String)
+  constructor(messages, path) {
+    super(messages, BritishEnglish.getInstance());
+    this.path = Objects.requireNonNull(path);
+    this.useSubRuleSpecificIds();
+    this.setCategory(Categories.STYLE.getCategory(messages));
+    this.setLocQualityIssueType(ITSIssueType.LocaleViolation);
+    this.addExamplePair(Example.wrong("We can produce <marker>drapes</marker> of any size or shape from a choice of over 500 different fabrics."),
+      Example.fixed("We can produce <marker>curtains</marker> of any size or shape from a choice of over 500 different fabrics."));
+  }
+
+  // Java: BritishReplaceRule#getId()
+  getId() {
+    return BritishReplaceRule.BRITISH_SIMPLE_REPLACE_RULE;
+  }
+
+  // Java: BritishReplaceRule#getDescription()
+  getDescription() {
+    return 'American words easily confused in British English: $match';
+  }
+
+  // Java: BritishReplaceRule#getShort()
+  getShort() {
+    return 'American word';
+  }
+
+  // Java: BritishReplaceRule#getMessage()
+  getMessage() {
+    return "'$match' is a common American expression. Consider using expressions more common to British English.";
+  }
+
+  // Java: BritishReplaceRule#getLocale()
+  getLocale() {
+    return EN_GB_LOCALE;
+  }
+}

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

@@ -0,0 +1,150 @@
+// org.languagetool.rules.en.CompoundRule
+import { AbstractCompoundRule } from '@valueerror/ltjs-core/src/core/rules/AbstractCompoundRule.js';
+import { CompoundRuleData } from '@valueerror/ltjs-core/src/core/rules/CompoundRuleData.js';
+import { Rule } from '@valueerror/ltjs-core/src/core/rules/model/Rule.js';
+import { Example } from '@valueerror/ltjs-core/src/core/rules/model/Examples.js';
+import { PatternTokenBuilder } from '@valueerror/ltjs-core/src/core/patterns/PatternTokenBuilder.js';
+import { token, tokenRegex } from '@valueerror/ltjs-core/src/core/patterns/PatternRuleBuilderHelper.js';
+import { Languages } from '@valueerror/ltjs-core/src/core/Languages.js';
+import '@valueerror/ltjs-core/src/core/disambiguation/DisambiguationPatternRule.js';
+import { Objects } from '@valueerror/ltjs-core/src/lib/java/Objects.js';
+import { getUrl } from '@valueerror/ltjs-core/src/core/Tools.js';
+
+let compoundData = null; // Java: static to make sure this gets loaded only once
+let antiPatterns = null; // Java: static ANTI_PATTERNS (built at class load, here on first use)
+
+// Java: CompoundRule#ANTI_PATTERNS
+function antiPatternsOf() {
+  if (antiPatterns === null) {
+    const AMERICAN_ENGLISH = Languages.getLanguageForShortCode('en-US');
+    antiPatterns = Rule.makeAntiPatterns([
+      [
+        tokenRegex("['’`´‘]"),
+        token('re'),
+      ],
+      [ // We well received your email
+        new PatternTokenBuilder().posRegex('SENT_START|CC|PCT').build(),
+        tokenRegex('we|you|they|I|s?he|it'),
+        token('well'),
+        new PatternTokenBuilder().posRegex('VB.*').build(),
+      ],
+      [
+        token('how'),
+        token('well'),
+        new PatternTokenBuilder().posRegex('VB.*').build(),
+      ],
+      [
+        tokenRegex('and|&'),
+        token('co'),
+      ],
+      [ // off-key
+        token('power'),
+        token('off'),
+        token('key'),
+      ],
+      [ // see saw seen
+        token('see'),
+        token('saw'),
+        token('seen'),
+      ],
+      [ // moving forward looking for ...
+        token('forward'),
+        token('looking'),
+        new PatternTokenBuilder().posRegex('IN|TO').build(),
+      ],
+      [ // Go through the store front door
+        token('store'),
+        token('front'),
+        tokenRegex('doors?'),
+      ],
+      [ // It goes from surface to surface
+        token('from'),
+        token('surface'),
+        token('to'),
+        token('surface'),
+      ],
+      [ // year end
+        tokenRegex('senior|junior'),
+        token('year'),
+        token('end'),
+      ],
+      [ // under investment
+        token('under'),
+        token('investment'),
+        token('banking'),
+      ],
+      [ // spring clean
+        token('spring'),
+        tokenRegex('cleans?|cleaned|cleaning'),
+        tokenRegex('up|the|my|our|his|her'),
+      ],
+      [ // Serie A team (A-Team)
+        tokenRegex('series?'),
+        tokenRegex('a'),
+      ],
+      [ // They had a hard time sharing their ...
+        token('hard'),
+        token('time'),
+        new PatternTokenBuilder().pos('VBG').build(),
+      ],
+      [ // the first ever green bond by a municipality
+        token('first'),
+        tokenRegex('ever'),
+        tokenRegex('green'),
+      ],
+      [ // inter-state.com
+        tokenRegex('.+'),
+        token('.'),
+        tokenRegex('(com|io|de|nl|co|net|org|es)'),
+      ],
+    ], AMERICAN_ENGLISH);
+  }
+  return antiPatterns;
+}
+
+// Java: CompoundRule (en)
+export class CompoundRule extends AbstractCompoundRule {
+  static FQCN = 'org.languagetool.rules.en.CompoundRule';
+
+  // Java: CompoundRule(ResourceBundle,Language,UserConfig)
+  constructor(messages, english, userConfig) {
+    super(messages, english, userConfig,
+      'This word is normally spelled with a hyphen.',
+      'This word is normally spelled as one.',
+      'This expression is normally spelled as one or with a hyphen.',
+      'Compound');
+    this.english = english;
+    super.useSubRuleSpecificIds();
+    this.addExamplePair(Example.wrong('I now have a <marker>part time</marker> job.'),
+      Example.fixed('I now have a <marker>part-time</marker> job.'));
+    this.setUrl(getUrl('https://languagetool.org/insights/post/hyphen/'));
+  }
+
+  // Java: CompoundRule#getId()
+  getId() {
+    return 'EN_COMPOUNDS';
+  }
+
+  // Java: CompoundRule#getDescription()
+  getDescription() {
+    return 'Hyphenated words: $match';
+  }
+
+  // Java: CompoundRule#getCompoundRuleData()
+  getCompoundRuleData() {
+    if (compoundData === null) {
+      compoundData = new CompoundRuleData('/en/compounds.txt');
+    }
+    return compoundData;
+  }
+
+  // Java: CompoundRule#getAntiPatterns()
+  getAntiPatterns() {
+    return antiPatternsOf();
+  }
+
+  // Java: CompoundRule#isMisspelled(String)
+  isMisspelled(word) {
+    return Objects.requireNonNull(this.english.getDefaultSpellingRule()).isMisspelled(word);
+  }
+}

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

@@ -0,0 +1,87 @@
+// org.languagetool.rules.en.ConsistentApostrophesRule
+import { TextLevelRule } from '@valueerror/ltjs-core/src/core/rules/model/TextLevelRule.js';
+import { RuleMatch } from '@valueerror/ltjs-core/src/core/rules/model/RuleMatch.js';
+import { Example } from '@valueerror/ltjs-core/src/core/rules/model/Examples.js';
+import { getUrl } from '@valueerror/ltjs-core/src/core/Tools.js';
+import { javaReplace } from '@valueerror/ltjs-core/src/lib/java/strings.js';
+
+// Java: ConsistentApostrophesRule
+export class ConsistentApostrophesRule extends TextLevelRule {
+  static FQCN = 'org.languagetool.rules.en.ConsistentApostrophesRule';
+
+  // Java: ConsistentApostrophesRule(ResourceBundle)
+  constructor(messages) {
+    super(messages);
+    this.setDefaultTempOff(); // TODO
+    this.setUrl(getUrl('https://languagetool.org/insights/post/punctuation-guide/#what-is-an-apostrophe'));
+    this.addExamplePair(Example.wrong('It\'s nice, but it <marker>doesn’t</marker> work.'),
+      Example.fixed('It\'s nice, but it <marker>doesn\'t</marker> work.'));
+  }
+
+  // Java: ConsistentApostrophesRule#getId()
+  getId() {
+    return 'EN_CONSISTENT_APOS';
+  }
+
+  // Java: ConsistentApostrophesRule#getDescription()
+  getDescription() {
+    return 'Checks if the two types of apostrophes (\' and ’) are used consistently in a text.';
+  }
+
+  // Java: ConsistentApostrophesRule#match(List)
+  match(sentences) {
+    const matches = [];
+    let pos = 0;
+    const hasTwoTypes = this.hasTwoApostropheTypes(sentences);
+    if (!hasTwoTypes) {
+      return this.toRuleMatchArray(matches);
+    }
+    for (const sentence of sentences) {
+      const tokens = sentence.getTokens();
+      for (const token of tokens) {
+        let message = null;
+        let repl = null;
+        if (token !== null && token.getToken().includes('\'') && !token.hasTypographicApostrophe()) {
+          message = 'You used a typewriter-style apostrophe here, but a typographic apostrophe elsewhere in this text.';
+          repl = javaReplace(token.getToken(), '\'', '’');
+        } else if (token !== null && token.getToken().includes('\'') && token.hasTypographicApostrophe()) {
+          message = 'You used a typographic apostrophe here, but a typewriter-style apostrophe elsewhere in this text.';
+          repl = token.getToken();
+        }
+        if (message !== null) {
+          const match = new RuleMatch(this, sentence, pos + token.getStartPos(), pos + token.getEndPos(),
+            message + ' Both are correct, but consider using the same type everywhere in your text.');
+          match.setSuggestedReplacement(repl);
+          matches.push(match);
+        }
+      }
+      pos += sentence.getCorrectedTextLength();
+    }
+    return this.toRuleMatchArray(matches);
+  }
+
+  // Java: ConsistentApostrophesRule#hasTwoApostropheTypes(List)
+  hasTwoApostropheTypes(sentences) {
+    let hasTypewriterStyle = false;
+    let hasTypographicStyle = false;
+    for (const sentence of sentences) {
+      const tokens = sentence.getTokens();
+      for (const token of tokens) {
+        if (token !== null && token.getToken().includes('\'') && !token.hasTypographicApostrophe()) {
+          hasTypewriterStyle = true;
+        } else if (token !== null && token.getToken().includes('\'') && token.hasTypographicApostrophe()) {
+          hasTypographicStyle = true;
+        }
+        if (hasTypewriterStyle && hasTypographicStyle) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  // Java: ConsistentApostrophesRule#minToCheckParagraph()
+  minToCheckParagraph() {
+    return -1;
+  }
+}

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

@@ -0,0 +1,64 @@
+// org.languagetool.rules.en.ContractionSpellingRule
+import { AbstractSimpleReplaceRule } from '@valueerror/ltjs-core/src/core/rules/AbstractSimpleReplaceRule.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 { Locale } from '@valueerror/ltjs-core/src/lib/java/Locale.js';
+import { getUrl } from '@valueerror/ltjs-core/src/core/Tools.js';
+
+let wrongWords = null; // Java: static wrongWords = loadFromPath("/en/contractions.txt")
+const EN_LOCALE = new Locale('en');
+
+// Java: ContractionSpellingRule
+export class ContractionSpellingRule extends AbstractSimpleReplaceRule {
+  static FQCN = 'org.languagetool.rules.en.ContractionSpellingRule';
+  static CONTRACTION_SPELLING_RULE = 'EN_CONTRACTION_SPELLING';
+
+  // Java: ContractionSpellingRule#getWrongWords()
+  getWrongWords() {
+    if (wrongWords === null) wrongWords = AbstractSimpleReplaceRule.loadFromPath('/en/contractions.txt');
+    return wrongWords;
+  }
+
+  // Java: ContractionSpellingRule(ResourceBundle,Language)
+  constructor(messages, language) {
+    super(messages, language);
+    ContractionSpellingRule.prototype.getWrongWords.call(this); // Java: static initializer runs at class load
+    super.setCategory(Categories.TYPOS.getCategory(messages));
+    this.setLocQualityIssueType(ITSIssueType.Misspelling);
+    this.addExamplePair(Example.wrong('We <marker>havent</marker> earned anything.'),
+      Example.fixed("We <marker>haven't</marker> earned anything."));
+    this.setUrl(getUrl('https://languagetool.org/insights/post/grammar-contractions/'));
+    super.setCheckLemmas(false);
+  }
+
+  // Java: ContractionSpellingRule#getId()
+  getId() {
+    return ContractionSpellingRule.CONTRACTION_SPELLING_RULE;
+  }
+
+  // Java: ContractionSpellingRule#getDescription()
+  getDescription() {
+    return 'Spelling of English contractions';
+  }
+
+  // Java: ContractionSpellingRule#getShort()
+  getShort() {
+    return 'Spelling mistake';
+  }
+
+  // Java: ContractionSpellingRule#getMessage(String,List)
+  getMessage() {
+    return 'Possible spelling mistake found.';
+  }
+
+  // Java: ContractionSpellingRule#isCaseSensitive()
+  isCaseSensitive() {
+    return true;
+  }
+
+  // Java: ContractionSpellingRule#getLocale()
+  getLocale() {
+    return EN_LOCALE;
+  }
+}

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

@@ -0,0 +1,58 @@
+// org.languagetool.rules.en.DateCheckFilter
+import { registerClass } from '@valueerror/ltjs-core/src/core/resources/ClassBroker.js';
+import { Integer } from '@valueerror/ltjs-core/src/lib/java/int.js';
+import { AbstractDateCheckWithSuggestionsFilter } from '@valueerror/ltjs-core/src/core/rules/AbstractDateCheckWithSuggestionsFilter.js';
+import { isNumeric } from '@valueerror/ltjs-core/src/core/text/StringTools.js';
+import { DateFilterHelper } from './DateFilterHelper.js';
+
+// Java: DateCheckFilter
+export class DateCheckFilter extends AbstractDateCheckWithSuggestionsFilter {
+  static FQCN = 'org.languagetool.rules.en.DateCheckFilter';
+  static JAVA_ABSTRACT = false;
+  static JAVA_CONSTRUCTORS = [{ params: [], text: 'public org.languagetool.rules.en.DateCheckFilter()' }];
+
+  dateFilterHelper = new DateFilterHelper();
+
+  // Java: DateCheckFilter#getCalendar()
+  getCalendar() {
+    return this.dateFilterHelper.getCalendar();
+  }
+
+  // Java: DateCheckFilter#getErrorMessageWrongYear()
+  getErrorMessageWrongYear() {
+    return 'This date is wrong. Did you mean "{currentYear}"?';
+  }
+
+  // Java: DateCheckFilter#getDayOfWeek(String) and #getDayOfWeek(Calendar) (overloads, one JS method dispatching on the argument type)
+  getDayOfWeek(arg) {
+    return this.dateFilterHelper.getDayOfWeek(arg);
+  }
+
+  // Java: DateCheckFilter#getMonth(String)
+  getMonth(monthStr) {
+    return this.dateFilterHelper.getMonth(monthStr);
+  }
+
+  // Java: DateCheckFilter#getDayStrLikeOriginal(String,String)
+  getDayStrLikeOriginal(day, original) {
+    if (isNumeric(original)) {
+      return day;
+    }
+    const number = Integer.parseInt(day);
+    if (number >= 11 && number <= 13) {
+      return number + 'th';
+    }
+    switch (number % 10) {
+      case 1:
+        return number + 'st';
+      case 2:
+        return number + 'nd';
+      case 3:
+        return number + 'rd';
+      default:
+        return number + 'th';
+    }
+  }
+}
+
+registerClass(DateCheckFilter.FQCN, DateCheckFilter);

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

@@ -0,0 +1,51 @@
+// org.languagetool.rules.en.DateFilterHelper (package-private)
+import { Calendar } from '@valueerror/ltjs-core/src/lib/java/Calendar.js';
+import { Locale } from '@valueerror/ltjs-core/src/lib/java/Locale.js';
+import { RuntimeException } from '@valueerror/ltjs-core/src/lib/java/errors.js';
+import { toLowerCase } from '@valueerror/ltjs-core/src/lib/java/strings.js';
+import { trimSpecialCharacters } from '@valueerror/ltjs-core/src/core/text/StringTools.js';
+
+// Java: DateFilterHelper
+export class DateFilterHelper {
+  static FQCN = 'org.languagetool.rules.en.DateFilterHelper';
+
+  // Java: DateFilterHelper#getCalendar()
+  getCalendar() {
+    return Calendar.getInstance(Locale.UK);
+  }
+
+  // Java: DateFilterHelper#getDayOfWeek(String) and #getDayOfWeek(Calendar) (overloads, one JS method dispatching on the argument type)
+  getDayOfWeek(arg) {
+    if (arg instanceof Calendar) {
+      return arg.getDisplayName(Calendar.DAY_OF_WEEK, Calendar.LONG, Locale.UK);
+    }
+    const dayStr = arg;
+    const day = toLowerCase(trimSpecialCharacters(dayStr));
+    if (day.startsWith('su')) return Calendar.SUNDAY;
+    if (day.startsWith('mo')) return Calendar.MONDAY;
+    if (day.startsWith('tu')) return Calendar.TUESDAY;
+    if (day.startsWith('we')) return Calendar.WEDNESDAY;
+    if (day.startsWith('th')) return Calendar.THURSDAY;
+    if (day.startsWith('fr')) return Calendar.FRIDAY;
+    if (day.startsWith('sa')) return Calendar.SATURDAY;
+    throw new RuntimeException("Could not find day of week for '" + dayStr + "'");
+  }
+
+  // Java: DateFilterHelper#getMonth(String)
+  getMonth(monthStr) {
+    const mon = toLowerCase(trimSpecialCharacters(monthStr));
+    if (mon.startsWith('jan')) return 1;
+    if (mon.startsWith('feb')) return 2;
+    if (mon.startsWith('mar')) return 3;
+    if (mon.startsWith('apr')) return 4;
+    if (mon.startsWith('may')) return 5;
+    if (mon.startsWith('jun')) return 6;
+    if (mon.startsWith('jul')) return 7;
+    if (mon.startsWith('aug')) return 8;
+    if (mon.startsWith('sep')) return 9;
+    if (mon.startsWith('oct')) return 10;
+    if (mon.startsWith('nov')) return 11;
+    if (mon.startsWith('dec')) return 12;
+    throw new RuntimeException("Could not find month '" + monthStr + "'");
+  }
+}

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

@@ -0,0 +1,17 @@
+// org.languagetool.rules.en.EnglishConvertToSentenceCaseFilter
+import { registerClass } from '@valueerror/ltjs-core/src/core/resources/ClassBroker.js';
+import { ConvertToSentenceCaseFilter } from '@valueerror/ltjs-core/src/core/rules/ConvertToSentenceCaseFilter.js';
+
+// Java: EnglishConvertToSentenceCaseFilter
+export class EnglishConvertToSentenceCaseFilter extends ConvertToSentenceCaseFilter {
+  static FQCN = 'org.languagetool.rules.en.EnglishConvertToSentenceCaseFilter';
+  static JAVA_ABSTRACT = false;
+  static JAVA_CONSTRUCTORS = [{ params: [], text: 'public org.languagetool.rules.en.EnglishConvertToSentenceCaseFilter()' }];
+
+  // Java: EnglishConvertToSentenceCaseFilter#tokenIsException(String)
+  tokenIsException(s) {
+    return s === 'me';
+  }
+}
+
+registerClass(EnglishConvertToSentenceCaseFilter.FQCN, EnglishConvertToSentenceCaseFilter);