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

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

@@ -0,0 +1,42 @@
+// org.languagetool.rules.en.EnglishDashRule
+import { AbstractDashRule } from '@valueerror/ltjs-core/src/core/rules/AbstractDashRule.js';
+import { Example } from '@valueerror/ltjs-core/src/core/rules/model/Examples.js';
+import { getUrl } from '@valueerror/ltjs-core/src/core/Tools.js';
+
+let trie = null; // Java: EnglishDashRule#trie (static, loaded once)
+
+// Java: EnglishDashRule
+export class EnglishDashRule extends AbstractDashRule {
+  static FQCN = 'org.languagetool.rules.en.EnglishDashRule';
+
+  // Java: EnglishDashRule(ResourceBundle)
+  constructor(messages) {
+    super(messages);
+    this.addExamplePair(Example.wrong("I'll buy a new <marker>T—shirt</marker>."),
+      Example.fixed("I'll buy a new <marker>T-shirt</marker>."));
+    this.setUrl(getUrl('https://languagetool.org/insights/post/hyphen/'));
+  }
+
+  // Java: EnglishDashRule#getId()
+  getId() {
+    return 'EN_DASH_RULE';
+  }
+
+  // Java: EnglishDashRule#getDescription()
+  getDescription() {
+    return "Checks if hyphenated words were spelled with dashes (e.g., 'T — shirt' instead 'T-shirt').";
+  }
+
+  // Java: EnglishDashRule#getMessage()
+  getMessage() {
+    return 'A dash was used instead of a hyphen.';
+  }
+
+  // Java: EnglishDashRule#getCompoundsData()
+  getCompoundsData() {
+    if (trie === null) {
+      trie = AbstractDashRule.loadCompoundFile('/en/compounds.txt');
+    }
+    return trie;
+  }
+}

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

@@ -0,0 +1,67 @@
+// org.languagetool.rules.en.EnglishDiacriticsRule
+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 { Locale } from '@valueerror/ltjs-core/src/lib/java/Locale.js';
+import { getUrl } from '@valueerror/ltjs-core/src/core/Tools.js';
+import { English } from '../language/English.js';
+
+const FILE_NAME = '/en/diacritics.txt';
+const EN_LOCALE = new Locale('en'); // locale used on case-conversion
+
+// Java: EnglishDiacriticsRule
+export class EnglishDiacriticsRule extends AbstractSimpleReplaceRule2 {
+  static FQCN = 'org.languagetool.rules.en.EnglishDiacriticsRule';
+  static EN_DIACRITICS_REPLACE = 'EN_DIACRITICS_REPLACE_ORTHOGRAPHY';
+
+  // Java: EnglishDiacriticsRule#getFileNames()
+  getFileNames() {
+    return [FILE_NAME];
+  }
+
+  // Java: EnglishDiacriticsRule(ResourceBundle)
+  constructor(messages) {
+    super(messages, new English());
+    this.useSubRuleSpecificIds();
+    this.setCategory(Categories.TYPOS.getCategory(messages));
+    this.setLocQualityIssueType(ITSIssueType.Misspelling);
+    this.addExamplePair(Example.wrong('<marker>blase</marker>'),
+      Example.fixed('<marker>blasé</marker>'));
+  }
+
+  // Java: EnglishDiacriticsRule#getId()
+  getId() {
+    return EnglishDiacriticsRule.EN_DIACRITICS_REPLACE;
+  }
+
+  // Java: EnglishDiacriticsRule#getDescription()
+  getDescription() {
+    return "Suggest diacritics for '$match'";
+  }
+
+  // Java: EnglishDiacriticsRule#getShort()
+  getShort() {
+    return 'The original word has a diacritic';
+  }
+
+  // Java: EnglishDiacriticsRule#getMessage()
+  getMessage() {
+    return "'$match' is an imported foreign name or expression, which originally has a diacritic.";
+  }
+
+  // Java: EnglishDiacriticsRule#getSuggestionsSeparator()
+  getSuggestionsSeparator() {
+    return ' or ';
+  }
+
+  // Java: EnglishDiacriticsRule#getUrl()
+  getUrl() {
+    return getUrl('https://en.wikipedia.org/wiki/English_terms_with_diacritical_marks');
+  }
+
+  // Java: EnglishDiacriticsRule#getLocale()
+  getLocale() {
+    return EN_LOCALE;
+  }
+}

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

@@ -0,0 +1,15 @@
+// org.languagetool.rules.en.EnglishMultitokenSpeller
+import { MultitokenSpeller } from '@valueerror/ltjs-core/src/core/rules/spelling/multitoken/MultitokenSpeller.js';
+import { Languages } from '@valueerror/ltjs-core/src/core/Languages.js';
+import { registerComponent } from '@valueerror/ltjs-core/src/core/language/components.js';
+
+// Java: EnglishMultitokenSpeller (INSTANCE is the shared component 'org.languagetool.rules.en.EnglishMultitokenSpeller')
+export class EnglishMultitokenSpeller extends MultitokenSpeller {
+  static FQCN = 'org.languagetool.rules.en.EnglishMultitokenSpeller';
+
+  // Java: EnglishMultitokenSpeller()
+  constructor() {
+    super(Languages.getLanguageForShortCode('en'), ['/en/multiwords.txt', '/spelling_global.txt']); // , "/en/hyphenated_words.txt"
+  }
+}
+registerComponent(EnglishMultitokenSpeller.FQCN, () => new EnglishMultitokenSpeller());

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

@@ -0,0 +1,38 @@
+// org.languagetool.rules.en.EnglishNumberInWordFilter
+import { registerClass } from '@valueerror/ltjs-core/src/core/resources/ClassBroker.js';
+import { Locale } from '@valueerror/ltjs-core/src/lib/java/Locale.js';
+import { MESSAGE_BUNDLE } from '@valueerror/ltjs-core/src/core/JLanguageToolConstants.js';
+import { getDataBroker } from '@valueerror/ltjs-core/src/core/resources/LtStatics.js';
+import { AbstractNumberInWordFilter } from '@valueerror/ltjs-core/src/core/rules/AbstractNumberInWordFilter.js';
+import { AmericanEnglish } from '../language/AmericanEnglish.js';
+import { MorfologikAmericanSpellerRule } from './MorfologikAmericanSpellerRule.js';
+
+let englishSpellerRule = null; // Java: EnglishNumberInWordFilter#englishSpellerRule (static)
+
+// Java: EnglishNumberInWordFilter
+export class EnglishNumberInWordFilter extends AbstractNumberInWordFilter {
+  static FQCN = 'org.languagetool.rules.en.EnglishNumberInWordFilter';
+  static JAVA_ABSTRACT = false;
+  static JAVA_CONSTRUCTORS = [{ params: [], text: 'public org.languagetool.rules.en.EnglishNumberInWordFilter() throws java.io.IOException' }];
+
+  // Java: EnglishNumberInWordFilter#EnglishNumberInWordFilter()
+  constructor() {
+    super(AmericanEnglish.getInstance());
+    const messages = getDataBroker().getResourceBundle(MESSAGE_BUNDLE, new Locale(this.language.getShortCode()));
+    if (englishSpellerRule === null) {
+      englishSpellerRule = new MorfologikAmericanSpellerRule(messages, AmericanEnglish.getInstance());
+    }
+  }
+
+  // Java: EnglishNumberInWordFilter#isMisspelled(String)
+  isMisspelled(word) {
+    return englishSpellerRule.isMisspelled(word);
+  }
+
+  // Java: EnglishNumberInWordFilter#getSuggestions(String)
+  getSuggestions(word) {
+    return englishSpellerRule.getSpellingSuggestions(word);
+  }
+}
+
+registerClass(EnglishNumberInWordFilter.FQCN, EnglishNumberInWordFilter);

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

@@ -0,0 +1,29 @@
+// org.languagetool.rules.en.EnglishPartialPosTagFilter
+import { registerClass } from '@valueerror/ltjs-core/src/core/resources/ClassBroker.js';
+import { Languages } from '@valueerror/ltjs-core/src/core/Languages.js';
+import { AnalyzedSentence } from '@valueerror/ltjs-core/src/core/AnalyzedSentence.js';
+import { IOException, RuntimeException } from '@valueerror/ltjs-core/src/lib/java/errors.js';
+import { PartialPosTagFilter } from '@valueerror/ltjs-core/src/core/rules/PartialPosTagFilter.js';
+
+// Java: EnglishPartialPosTagFilter
+export class EnglishPartialPosTagFilter extends PartialPosTagFilter {
+  static FQCN = 'org.languagetool.rules.en.EnglishPartialPosTagFilter';
+  static JAVA_ABSTRACT = false;
+  static JAVA_CONSTRUCTORS = [{ params: [], text: 'public org.languagetool.rules.en.EnglishPartialPosTagFilter()' }];
+
+  // Java: EnglishPartialPosTagFilter#tag(String)
+  tag(token) {
+    try {
+      const englishLanguage = Languages.getLanguageForShortCode('en');
+      const tags = englishLanguage.getTagger().tag([token]);
+      const atr = [...tags];
+      const disambiguated = englishLanguage.getDisambiguator().disambiguate(new AnalyzedSentence(atr));
+      return [...disambiguated.getTokens()];
+    } catch (e) {
+      if (e instanceof IOException) throw new RuntimeException("Could not tag and disambiguate '" + token + "'", e);
+      throw e;
+    }
+  }
+}
+
+registerClass(EnglishPartialPosTagFilter.FQCN, EnglishPartialPosTagFilter);

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

@@ -0,0 +1,67 @@
+// org.languagetool.rules.en.EnglishPlainEnglishRule
+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 { Locale } from '@valueerror/ltjs-core/src/lib/java/Locale.js';
+import { getUrl } from '@valueerror/ltjs-core/src/core/Tools.js';
+import { English } from '../language/English.js';
+
+const FILE_NAME = '/en/wordiness.txt';
+const EN_LOCALE = new Locale('en'); // locale used on case-conversion
+
+// Java: EnglishPlainEnglishRule
+export class EnglishPlainEnglishRule extends AbstractSimpleReplaceRule2 {
+  static FQCN = 'org.languagetool.rules.en.EnglishPlainEnglishRule';
+  static EN_PLAIN_ENGLISH_REPLACE = 'EN_PLAIN_ENGLISH_REPLACE';
+
+  // Java: EnglishPlainEnglishRule#getFileNames()
+  getFileNames() {
+    return [FILE_NAME];
+  }
+
+  // Java: EnglishPlainEnglishRule(ResourceBundle)
+  constructor(messages) {
+    super(messages, new English());
+    this.setDefaultOff(); // reactivate after feature freeze
+    this.setCategory(Categories.PLAIN_ENGLISH.getCategory(messages));
+    this.setLocQualityIssueType(ITSIssueType.Style);
+    this.addExamplePair(Example.wrong('<marker>fatal outcome</marker>'),
+      Example.fixed('<marker>death</marker>'));
+  }
+
+  // Java: EnglishPlainEnglishRule#getId()
+  getId() {
+    return EnglishPlainEnglishRule.EN_PLAIN_ENGLISH_REPLACE;
+  }
+
+  // Java: EnglishPlainEnglishRule#getDescription()
+  getDescription() {
+    return '1. Wordiness (General)';
+  }
+
+  // Java: EnglishPlainEnglishRule#getShort()
+  getShort() {
+    return 'Wordiness';
+  }
+
+  // Java: EnglishPlainEnglishRule#getMessage()
+  getMessage() {
+    return "'$match' is a wordy or complex expression. In some cases, it might be preferable to use $suggestions.";
+  }
+
+  // Java: EnglishPlainEnglishRule#getSuggestionsSeparator()
+  getSuggestionsSeparator() {
+    return ' or ';
+  }
+
+  // Java: EnglishPlainEnglishRule#getUrl()
+  getUrl() {
+    return getUrl('https://en.wikipedia.org/wiki/List_of_plain_English_words_and_phrases');
+  }
+
+  // Java: EnglishPlainEnglishRule#getLocale()
+  getLocale() {
+    return EN_LOCALE;
+  }
+}

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

@@ -0,0 +1,67 @@
+// org.languagetool.rules.en.EnglishRedundancyRule
+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 { Locale } from '@valueerror/ltjs-core/src/lib/java/Locale.js';
+import { getUrl } from '@valueerror/ltjs-core/src/core/Tools.js';
+import { English } from '../language/English.js';
+
+const FILE_NAME = '/en/redundancies.txt';
+const EN_LOCALE = new Locale('en'); // locale used on case-conversion
+
+// Java: EnglishRedundancyRule
+export class EnglishRedundancyRule extends AbstractSimpleReplaceRule2 {
+  static FQCN = 'org.languagetool.rules.en.EnglishRedundancyRule';
+  static EN_REDUNDANCY_REPLACE = 'EN_REDUNDANCY_REPLACE';
+
+  // Java: EnglishRedundancyRule#getFileNames()
+  getFileNames() {
+    return [FILE_NAME];
+  }
+
+  // Java: EnglishRedundancyRule(ResourceBundle)
+  constructor(messages) {
+    super(messages, new English());
+    this.setCategory(Categories.REDUNDANCY.getCategory(messages));
+    this.setLocQualityIssueType(ITSIssueType.Style);
+    this.setDefaultOff(); // see #1997
+    this.addExamplePair(Example.wrong('<marker>tuna fish</marker>'),
+      Example.fixed('<marker>tuna</marker>'));
+  }
+
+  // Java: EnglishRedundancyRule#getId()
+  getId() {
+    return EnglishRedundancyRule.EN_REDUNDANCY_REPLACE;
+  }
+
+  // Java: EnglishRedundancyRule#getDescription()
+  getDescription() {
+    return '1. Redundancy (General)';
+  }
+
+  // Java: EnglishRedundancyRule#getShort()
+  getShort() {
+    return 'Redundancy';
+  }
+
+  // Java: EnglishRedundancyRule#getMessage()
+  getMessage() {
+    return "'$match' is a redundancy. In some cases, it might be preferable to use $suggestions";
+  }
+
+  // Java: EnglishRedundancyRule#getSuggestionsSeparator()
+  getSuggestionsSeparator() {
+    return ' or ';
+  }
+
+  // Java: EnglishRedundancyRule#getUrl()
+  getUrl() {
+    return getUrl('https://en.wikipedia.org/wiki/Redundancy_(linguistics)');
+  }
+
+  // Java: EnglishRedundancyRule#getLocale()
+  getLocale() {
+    return EN_LOCALE;
+  }
+}

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

@@ -0,0 +1,212 @@
+// org.languagetool.rules.en.EnglishRepeatedWordsRule
+import { AbstractRepeatedWordsRule } from '@valueerror/ltjs-core/src/core/rules/AbstractRepeatedWordsRule.js';
+import { Rule } from '@valueerror/ltjs-core/src/core/rules/model/Rule.js';
+import { Tag } from '@valueerror/ltjs-core/src/core/rules/model/Tag.js';
+import { PatternTokenBuilder } from '@valueerror/ltjs-core/src/core/patterns/PatternTokenBuilder.js';
+import { token, tokenRegex, posRegex, pos } from '@valueerror/ltjs-core/src/core/patterns/PatternRuleBuilderHelper.js';
+import '@valueerror/ltjs-core/src/core/disambiguation/DisambiguationPatternRule.js';
+import { getUrl } from '@valueerror/ltjs-core/src/core/Tools.js';
+import { getClassBroker } from '@valueerror/ltjs-core/src/core/resources/LtStatics.js';
+import { EnglishSynthesizer } from '../synthesis/EnglishSynthesizer.js';
+
+let wordsToCheck = null; // Java: static wordsToCheck = loadWords("/en/synonyms.txt")
+
+// Java: EnglishRepeatedWordsRule#ANTI_PATTERNS (static field, built here on first use)
+function antiPatternList() {
+  return [
+
+    [
+      new PatternTokenBuilder().csToken("need").matchInflectedForms().build(),   // "I still need -> require to sign in"
+      token("to")
+    ],
+
+    [
+      new PatternTokenBuilder().tokenRegex("solve(s|d|ing)?").setSkip(3).build(),   // "solve the problem" is a unique collocation
+      tokenRegex("problems?")                                                    // "solve the issue|concern|difficulty" sounds bizarre
+    ],                                                                             // lots of disables in Matomo
+
+    [
+      posRegex("SENT_START|PCT"),       // "No problem, I'm not in a rush."
+      token("no"),
+      token("problem"),
+      pos("PCT")
+    ],
+
+    [
+      tokenRegex("math|word"),       // "math/word problem"
+      tokenRegex("problems?")
+    ],
+
+    [
+      tokenRegex("as"),       // "doesn't apply to the group as a whole"
+      tokenRegex("a"),
+      tokenRegex("whole")
+    ],
+
+    [
+      token("more"),
+      token("often"),
+      token("than"),
+      token("not")
+    ],
+
+    [
+      token("often"),
+      token("times")
+    ],
+
+    [
+      tokenRegex("details?|facts?|it|journals?|questions?|research|results?|study|studies|this|these|those|which"),
+      new PatternTokenBuilder().pos("RB").min(0).build(),
+      new PatternTokenBuilder().csToken("suggest").matchInflectedForms().build()
+    ],
+
+    [
+      new PatternTokenBuilder().csToken("form").matchInflectedForms().build(),   // "form in the bloodstream"
+      posRegex("IN|PCT|RP|TO|SENT_END")
+    ],
+
+    [
+      new PatternTokenBuilder().tokenRegex("bonds?|crystals?|ions?|rocks?|.*valence").setSkip(10).build(),
+      new PatternTokenBuilder().csToken("form").matchInflectedForms().build()
+    ],
+
+    [
+      new PatternTokenBuilder().tokenRegex("form(s|ed|ing)?").setSkip(10).build(),
+      tokenRegex("bonds?|crystals?|ions?|rocks?|.*valence")
+    ],
+
+    [
+      token("interesting"),
+      tokenRegex("facts?|things?")
+    ],
+
+    [
+      token("several"),
+      tokenRegex("hundreds?|thousands?|millions?")
+    ],
+
+    [
+      token("must"),
+      token("be"),
+      token("nice")
+    ],
+
+    [
+      token("nice"),
+      token("day")
+    ],
+
+    [
+      token("nice"),
+      token("to"),
+      new PatternTokenBuilder().token("meet").min(0).build(),
+      posRegex("PRP_O.*")
+    ],
+
+    [
+      new PatternTokenBuilder().csToken("be").matchInflectedForms().build(),  // nice and plump
+      token("nice"),
+      token("and"),
+      pos("JJ"),
+      posRegex("PCT|SENT_END")
+    ],
+
+    [
+      posRegex("P?DT|PRP$.*"),  // the proposed agreement
+      token("proposed"),
+      posRegex("N.*")
+    ],
+
+    [
+      new PatternTokenBuilder().csToken("propose").matchInflectedForms().build(),
+      tokenRegex("to|marriage")
+    ],
+
+    [
+      token("too"),
+      token("literally")
+    ],
+
+    [
+      token("literally"),
+      token("and"),
+      token("figuratively")
+    ],
+
+    [
+      token("literally"),
+      token("everything")
+    ],
+
+    [
+      token("literally"),
+      posRegex("PCT|SENT_END")
+    ],
+
+    [
+      posRegex("CC"),       // "Or maybe it's because I have eyes that see!"
+      token("maybe")
+    ]
+
+  ];
+}
+
+// Java: EnglishRepeatedWordsRule
+export class EnglishRepeatedWordsRule extends AbstractRepeatedWordsRule {
+  static FQCN = 'org.languagetool.rules.en.EnglishRepeatedWordsRule';
+
+  // Java: EnglishRepeatedWordsRule#getAntiPatterns()
+  getAntiPatterns() {
+    return this.antiPatterns();
+  }
+
+  // Java: EnglishRepeatedWordsRule(ResourceBundle)
+  constructor(messages) {
+    super(messages, getClassBroker().forName('org.languagetool.language.AmericanEnglish').getInstance());
+    if (wordsToCheck === null) wordsToCheck = AbstractRepeatedWordsRule.loadWords('/en/synonyms.txt');
+    this.setTags([Tag.picky]);
+    this.antiPatterns = Rule.cacheAntiPatterns(getClassBroker().forName('org.languagetool.language.AmericanEnglish').getInstance(), antiPatternList());
+    const id = this.getId();
+    if (id === 'EN_REPEATEDWORDS_DEFINITELY') {
+      this.setUrl(getUrl('https://languagetool.org/insights/post/i-agree-synonyms/'));
+    }
+    if (id === 'EN_REPEATEDWORDS_CHOOSE') {
+      this.setUrl(getUrl('https://languagetool.org/insights/post/choose-vs-chose/'));
+    }
+    // super.setDefaultTempOff();
+  }
+
+  // Java: EnglishRepeatedWordsRule#getMessage()
+  getMessage() {
+    return 'This word has been used in one of the immediately preceding sentences. Using a synonym could make your text more interesting to read, unless the repetition is intentional.';
+  }
+
+  // Java: EnglishRepeatedWordsRule#getDescription()
+  getDescription() {
+    return 'Suggest synonyms for repeated words.';
+  }
+
+  // Java: EnglishRepeatedWordsRule#getWordsToCheck()
+  getWordsToCheck() {
+    return wordsToCheck;
+  }
+
+  // Java: EnglishRepeatedWordsRule#getShortMessage()
+  getShortMessage() {
+    return 'Style: repeated word';
+  }
+
+  // Java: EnglishRepeatedWordsRule#getSynthesizer()
+  getSynthesizer() {
+    return EnglishSynthesizer.INSTANCE;
+  }
+
+  // Java: EnglishRepeatedWordsRule#isException(AnalyzedTokenReadings[],int,boolean,boolean,boolean)
+  isException(tokens, i, sentStart, isCapitalized, isAllUppercase) {
+    if (isAllUppercase || (isCapitalized && !sentStart)) {
+      return true;
+    }
+    return tokens[i].hasPosTagStartingWith('NNP');
+  }
+}

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

@@ -0,0 +1,47 @@
+// org.languagetool.rules.en.EnglishSpecificCaseRule
+import { AbstractSpecificCaseRule } from '@valueerror/ltjs-core/src/core/rules/AbstractSpecificCaseRule.js';
+import { Example } from '@valueerror/ltjs-core/src/core/rules/model/Examples.js';
+import { getUrl } from '@valueerror/ltjs-core/src/core/Tools.js';
+
+// Java: EnglishSpecificCaseRule
+export class EnglishSpecificCaseRule extends AbstractSpecificCaseRule {
+  static FQCN = 'org.languagetool.rules.en.EnglishSpecificCaseRule';
+
+  // Java: EnglishSpecificCaseRule#getPhrasesPath()
+  getPhrasesPath() {
+    return '/en/specific_case.txt';
+  }
+
+  // Java: EnglishSpecificCaseRule#getInitialCapitalMessage()
+  getInitialCapitalMessage() {
+    return 'If the term is a proper noun, use initial capitals.';
+  }
+
+  // Java: EnglishSpecificCaseRule#getOtherCapitalizationMessage()
+  getOtherCapitalizationMessage() {
+    return 'If the term is a proper noun, use the suggested capitalization.';
+  }
+
+  // Java: EnglishSpecificCaseRule#getShortMessage()
+  getShortMessage() {
+    return 'Proper noun';
+  }
+
+  // Java: EnglishSpecificCaseRule(ResourceBundle)
+  constructor(messages) {
+    super(messages);
+    this.setUrl(getUrl('https://languagetool.org/insights/post/spelling-capital-letters/'));
+    this.addExamplePair(Example.wrong('I really like <marker>Harry potter</marker>.'),
+      Example.fixed('I really like <marker>Harry Potter</marker>.'));
+  }
+
+  // Java: EnglishSpecificCaseRule#getId()
+  getId() {
+    return 'EN_SPECIFIC_CASE';
+  }
+
+  // Java: EnglishSpecificCaseRule#getDescription()
+  getDescription() {
+    return 'Checks upper/lower case spelling of some proper nouns';
+  }
+}

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

@@ -0,0 +1,12 @@
+// org.languagetool.rules.en.EnglishSuppressMisspelledSuggestionsFilter
+import { registerClass } from '@valueerror/ltjs-core/src/core/resources/ClassBroker.js';
+import { AbstractSuppressMisspelledSuggestionsFilter } from '@valueerror/ltjs-core/src/core/rules/AbstractSuppressMisspelledSuggestionsFilter.js';
+
+// Java: EnglishSuppressMisspelledSuggestionsFilter
+export class EnglishSuppressMisspelledSuggestionsFilter extends AbstractSuppressMisspelledSuggestionsFilter {
+  static FQCN = 'org.languagetool.rules.en.EnglishSuppressMisspelledSuggestionsFilter';
+  static JAVA_ABSTRACT = false;
+  static JAVA_CONSTRUCTORS = [{ params: [], text: 'public org.languagetool.rules.en.EnglishSuppressMisspelledSuggestionsFilter() throws java.io.IOException' }];
+}
+
+registerClass(EnglishSuppressMisspelledSuggestionsFilter.FQCN, EnglishSuppressMisspelledSuggestionsFilter);

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

@@ -0,0 +1,25 @@
+// org.languagetool.rules.en.EnglishUnpairedBracketsRule
+import { GenericUnpairedBracketsRule } from '@valueerror/ltjs-core/src/core/rules/GenericUnpairedBracketsRule.js';
+import { Example } from '@valueerror/ltjs-core/src/core/rules/model/Examples.js';
+import { getUrl } from '@valueerror/ltjs-core/src/core/Tools.js';
+
+const EN_START_SYMBOLS = ['[', '(', '{'];
+const EN_END_SYMBOLS = [']', ')', '}'];
+
+// Java: EnglishUnpairedBracketsRule
+export class EnglishUnpairedBracketsRule extends GenericUnpairedBracketsRule {
+  static FQCN = 'org.languagetool.rules.en.EnglishUnpairedBracketsRule';
+
+  // Java: EnglishUnpairedBracketsRule(ResourceBundle,Language)
+  constructor(messages) {
+    super(messages, EN_START_SYMBOLS, EN_END_SYMBOLS);
+    this.setUrl(getUrl('https://languagetool.org/insights/post/punctuation-guide/#what-are-parentheses'));
+    this.addExamplePair(Example.wrong('He lived in a <marker>(</marker>large house.'),
+      Example.fixed('He lived in a <marker>(</marker>large<marker>)</marker> house.'));
+  }
+
+  // Java: EnglishUnpairedBracketsRule#getId()
+  getId() {
+    return 'EN_UNPAIRED_BRACKETS';
+  }
+}

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

@@ -0,0 +1,41 @@
+// org.languagetool.rules.en.EnglishUnpairedQuotesRule
+import { GenericUnpairedQuotesRule } from '@valueerror/ltjs-core/src/core/rules/GenericUnpairedQuotesRule.js';
+import { Example } from '@valueerror/ltjs-core/src/core/rules/model/Examples.js';
+import { getUrl } from '@valueerror/ltjs-core/src/core/Tools.js';
+
+const EN_START_SYMBOLS = ['“', '"', "'", '‘'];
+const EN_END_SYMBOLS = ['”', '"', "'", '’'];
+
+// Java: EnglishUnpairedQuotesRule
+export class EnglishUnpairedQuotesRule extends GenericUnpairedQuotesRule {
+  static FQCN = 'org.languagetool.rules.en.EnglishUnpairedQuotesRule';
+
+  // Java: EnglishUnpairedQuotesRule(ResourceBundle,Language)
+  constructor(messages) {
+    super(messages, EN_START_SYMBOLS, EN_END_SYMBOLS);
+    this.setUrl(getUrl('https://languagetool.org/insights/post/punctuation-guide/#what-are-quotation-marks'));
+    this.addExamplePair(Example.wrong('"I\'m over here,<marker></marker> she said.'),
+      Example.fixed('"I\'m over here,<marker>"</marker> she said.'));
+  }
+
+  // Java: EnglishUnpairedQuotesRule#getId()
+  getId() {
+    return 'EN_UNPAIRED_QUOTES';
+  }
+
+  // Java: EnglishUnpairedQuotesRule#isNotBeginningApostrophe(AnalyzedTokenReadings[],int)
+  isNotBeginningApostrophe(tokens, i) {
+    if (tokens[i].hasPosTag('_apostrophe_contraction_') || tokens[i].hasPosTag('POS') || tokens[i].hasPosTag('NNP')) {
+      return false;
+    }
+    return true;
+  }
+
+  // Java: EnglishUnpairedQuotesRule#isNotEndingApostrophe(AnalyzedTokenReadings[],int)
+  isNotEndingApostrophe(tokens, i) {
+    if (tokens[i].hasPosTag('_apostrophe_contraction_') || tokens[i].hasPosTag('POS') || tokens[i].hasPosTag('NNP')) {
+      return false;
+    }
+    return true;
+  }
+}