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

package/resources/org/languagetool/rules/pl/replace.txt

@@ -0,0 +1,237 @@
+# @author Marcin Miłkowski
+#
+# Bezkontekstowe literówki — tj. wyrazy niewykrywane przez normalny
+# korektor pisowni, a bardzo rzadkie i będące literówkami. Są tutaj
+# też formy bardzo odbiegające od błędu, a więc niegenerowane przez
+# korektor pisowni.
+#
+
+akcesorii=akcesoriów
+akwarii=akwariów
+akuku=a kuku
+apropo=à propos
+apropos=à propos
+centr=centrów
+jurz=już
+poraz=po raz
+piaty=piąty
+dojąć=dojść
+dzieję=dzieje
+zawszę=zawsze
+parz=patrz
+przejcie=przejście
+slaby=słaby
+Aachen=Akwizgran
+Andego=Andy’ego
+Andemu=Andy’emu
+Bałyku=Bałtyku
+Barrego=Barry’ego
+Barremu=Barry’emu
+Billego=Billy’ego
+Billemu=Billy’emu
+Bruca=Bruce’a
+Brucowi=Bruce’owi
+Brucem=Bruce’em
+Brucie=Brusie
+Cliva=Clive’a
+Clivowi=Clive’owi
+Clivem=Clive’em
+Chańcza=Hańcza
+Dava=Dave’a
+Davem=Dave’em
+Dwayna=Dwayne’a
+Dwaynem=Dwayne’em
+Ericem=Erikiem
+Ericiem=Erikiem
+Garego=Gary’go
+Garemu=Gary’emu
+Gregorego=Gregory’ego
+Gregoremu=Gregory’emu
+Harrego=Harry’ego
+Harremu=Harry’emu
+Jeremego=Jeremy’ego
+Jerememu=Jeremy’emu
+Jerrego=Jerry’ego
+Jerremu=Jerry’emu
+Laurenca=Laurence’a
+Laurencem=Laurence’em
+Laurencie=Laurensie
+Lawrenca=Lawrence’a
+Lawrencem=Lawrence’em
+Lawrencie=Lawrensie
+Lukem=Lukiem
+Mika=Mike’a
+Mikowi=Mike’owi
+Mikem=Mikiem
+Miku=Mike’u
+Pierca=Pierce’a
+Piercem=Pierce’em
+Ridga=Ridge’a
+Ridgem=Ridge’em
+Smithie=Smicie
+Steva=Steve’a
+Stevem=Steve’em
+Stevowi=Steve’owi
+Terrego=Terry’ego
+Terremu=Terry’emu
+Wayna=Wayne’a
+Waynem=Wayne’em
+Stéphana=Stéphane’a
+Stéphanowi=Stéphane’owi
+Stéphanem=Stéphane’em
+Yvesa=Yves’a
+Yvesem=Yves’em
+Yvesie=Yvie
+Europom=Europą
+bezsensowy=bezsensowny
+otocznia=otoczenia
+otocznie=otoczenie
+mięli=mieli
+maił=miał
+spadłą=spadła
+conajmniej=co najmniej
+wogle=w ogóle
+wogole=w ogóle
+codzien=co dzień
+codzień=co dzień
+moznaby=można by
+narazie=na razie
+nielada=nie lada
+odrazu=od razu
+opatrznie=opacznie
+nieopacznie=nieopatrznie
+poprostu=po prostu
+pozatym=poza tym
+przedewszystkim=przede wszystkim
+spowrotem=z powrotem
+pryz=przy
+szłem=szedłem
+poszłem=poszedłem
+piatek=piątek
+pokuj=pokój
+prosze=proszę
+rząda=żąda
+sa=są
+sei=się
+sie=się
+ise=się
+ię=się
+sią=się
+chłopcowi=chłopcu
+bratowi=bratu
+aleji=alei
+lubieć=lubić
+bussinesmenów=businessmanów
+synie=synu
+non-stop=non stop
+swomi=swoimi
+uż=już
+łep=łeb
+cie=cię
+dac=dać
+dame=damę
+domie=domu
+mahała=machała
+myłka=zmyłka
+łab=łap
+cz=czy|cz.
+dzis=dziś
+dżaz=jazz
+duto=dłuto
+gróz=gruz
+istniej=istnieje
+joystik=joystick
+juz=już
+krotko=krótko
+lekaż=lekarz
+lekaży=lekarzy
+lekażach=lekarzach
+lekażami=lekarzami
+lekażom=lekarzom
+lekażem=lekarzem
+lekażowi=lekarzowi
+lekażu=lekarzu
+lekażów=lekarzy
+lekaże=lekarze
+mogla=mogła
+moglem=mogłem
+następce=następcę
+niewiadomo=nie wiadomo
+obiat=obiad
+obiedwie=obydwie
+ośródek=ośrodek
+ośródka=ośrodka
+ośródkiem=ośrodkiem
+ośródkowi=ośrodkowi
+ośródku=ośrodku
+ośródków=ośrodków
+ośródkach=ośrodkach
+ośródkami=ośrodkami
+ośródkom=ośrodkom
+ośródki=ośrodki
+pletwa=płetwa
+pletwą=płetwą
+pletwę=płetwę
+pletwie=płetwie
+pletwo=płetwo
+pletwy=płetwy
+pol=pół
+powielekroć=po wielekroć
+urzęd=urząd
+pletwach=płetwach
+pletwami=płetwami
+pletwom=płetwom
+pletw=płetw
+prez=przez
+prob=prób
+bolach=bólach
+bolami=bólami
+bole=bóle
+bolem=bólem
+bolom=bólom
+bolowi=bólowi
+bolu=bólu
+bolów=bólów
+bul=ból
+duh=duch
+niz=niż
+poobiedzie=po obiedzie
+nieprawa=nieprawda
+podroż=podróż
+polak=Polak
+tyko=tylko
+sposobowy=sposoby
+kopi=kopii
+dosiego=do siego
+dożo=dużo
+stanowic=stanowić
+działaś=działać|działań
+storn=stron
+następuję=następuje
+linuks=Linux
+osmy=ósmy
+rug=róg
+bódź=budź
+bódźcie=budźcie
+zespól=zespół
+maż=mąż|masz
+maży=marzy
+mażę=marzę
+maże=marzę
+znal=znał
+znalem=znałem
+Jeszce=Jeszcze
+jusz=już
+Bedę=Będę
+Bedą=Będą
+zrobie=zrobię
+czany=czarny
+poco=po co
+przestala=przestała
+przestalam=przestałam
+graja=grają
+fer=fair
+ostania=ostatnia
+ekonomi=ekonomii
+słonce=słońce
+

package/src/lang/pl/language/Polish.js

@@ -0,0 +1,111 @@
+// Java: org.languagetool.language.Polish
+import { Language } from '@valueerror/ltjs-core/src/core/Language.js';
+import { MARCIN_MILKOWSKI } from '@valueerror/ltjs-core/src/core/language/Contributors.js';
+import { LanguageMaintainedState } from '@valueerror/ltjs-core/src/core/LanguageMaintainedState.js';
+import { createComponent } from '@valueerror/ltjs-core/src/core/language/components.js';
+import { registerClass } from '@valueerror/ltjs-core/src/core/resources/ClassBroker.js';
+import { SRXSentenceTokenizer } from '@valueerror/ltjs-core/src/core/text/tokenizers/SRXSentenceTokenizer.js';
+import { CommaWhitespaceRule } from '@valueerror/ltjs-core/src/core/rules/CommaWhitespaceRule.js';
+import { UppercaseSentenceStartRule } from '@valueerror/ltjs-core/src/core/rules/UppercaseSentenceStartRule.js';
+import { WordRepeatRule } from '@valueerror/ltjs-core/src/core/rules/WordRepeatRule.js';
+import { MultipleWhitespaceRule } from '@valueerror/ltjs-core/src/core/rules/MultipleWhitespaceRule.js';
+import { SentenceWhitespaceRule } from '@valueerror/ltjs-core/src/core/rules/SentenceWhitespaceRule.js';
+import { PolishUnpairedBracketsRule } from '../rules/PolishUnpairedBracketsRule.js';
+import { MorfologikPolishSpellerRule } from '../rules/MorfologikPolishSpellerRule.js';
+import { PolishWordRepeatRule } from '../rules/PolishWordRepeatRule.js';
+import { CompoundRule } from '../rules/CompoundRule.js';
+import { SimpleReplaceRule } from '../rules/SimpleReplaceRule.js';
+import { WordCoherencyRule } from '../rules/WordCoherencyRule.js';
+import { DashRule } from '../rules/DashRule.js';
+import { PolishTagger } from '../tagging/PolishTagger.js';
+import { PolishWordTokenizer } from '../tokenizers/PolishWordTokenizer.js';
+import { PolishSynthesizer } from '../synthesis/PolishSynthesizer.js';
+
+// Java: Polish
+export class Polish extends Language {
+  static FQCN = 'org.languagetool.language.Polish';
+
+  // Java: Polish#getName()
+  getName() {
+    return 'Polish';
+  }
+
+  // Java: Polish#getShortCode()
+  getShortCode() {
+    return 'pl';
+  }
+
+  // Java: Polish#getCountries()
+  getCountries() {
+    return ['PL'];
+  }
+
+  // Java: Polish#createDefaultTagger()
+  createDefaultTagger() {
+    return new PolishTagger();
+  }
+
+  // Java: Polish#createDefaultSentenceTokenizer()
+  createDefaultSentenceTokenizer() {
+    return new SRXSentenceTokenizer(this);
+  }
+
+  // Java: Polish#createDefaultWordTokenizer()
+  createDefaultWordTokenizer() {
+    const wordTokenizer = new PolishWordTokenizer();
+    wordTokenizer.setTagger(this.getTagger());
+    return wordTokenizer;
+  }
+
+  // Java: Polish#createDefaultDisambiguator()
+  createDefaultDisambiguator() {
+    return createComponent('org.languagetool.tagging.disambiguation.pl.PolishHybridDisambiguator');
+  }
+
+  // Java: Polish#createDefaultSynthesizer()
+  createDefaultSynthesizer() {
+    return PolishSynthesizer.INSTANCE;
+  }
+
+  // Java: Polish#getMaintainers()
+  getMaintainers() {
+    return [MARCIN_MILKOWSKI];
+  }
+
+  // Java: Polish#getRelevantRules(ResourceBundle,UserConfig,Language,List)
+  getRelevantRules(messages, userConfig, motherTongue, altLanguages) {
+    return [
+      new CommaWhitespaceRule(messages),
+      new UppercaseSentenceStartRule(messages, this),
+      new WordRepeatRule(messages, this),
+      new MultipleWhitespaceRule(messages, this),
+      new SentenceWhitespaceRule(messages),
+      // specific to Polish:
+      new PolishUnpairedBracketsRule(messages, this),
+      new MorfologikPolishSpellerRule(messages, this, userConfig, altLanguages),
+      new PolishWordRepeatRule(messages),
+      new CompoundRule(messages, this, userConfig),
+      new SimpleReplaceRule(messages, this),
+      new WordCoherencyRule(messages),
+      new DashRule(messages),
+    ];
+  }
+
+  // Java: Polish#getMaintainedState()
+  getMaintainedState() {
+    return LanguageMaintainedState.ActivelyMaintained;
+  }
+
+  // Java: Polish#getPriorityForId(String)
+  getPriorityForId(id) {
+    if (id === 'ZDANIA_ZLOZONE') return -1; // so that it does not override more important rules
+    return super.getPriorityForId(id);
+  }
+
+  // Java: Polish#createDefaultSpellingRule(ResourceBundle)
+  createDefaultSpellingRule(messages) {
+    return new MorfologikPolishSpellerRule(messages, this, null, null);
+  }
+}
+
+registerClass(Polish.FQCN, Polish);

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

@@ -0,0 +1,40 @@
+// Java: org.languagetool.rules.pl.CompoundRule
+import { AbstractCompoundRule } from '@valueerror/ltjs-core/src/core/rules/AbstractCompoundRule.js';
+import { CompoundRuleData } from '@valueerror/ltjs-core/src/core/rules/CompoundRuleData.js';
+import { Example } from '@valueerror/ltjs-core/src/core/rules/model/Examples.js';
+
+let compoundData = null; // Java: static volatile compoundData
+
+// Java: CompoundRule (pl)
+export class CompoundRule extends AbstractCompoundRule {
+  static FQCN = 'org.languagetool.rules.pl.CompoundRule';
+
+  // Java: CompoundRule(ResourceBundle,Language,UserConfig)
+  constructor(messages, lang, userConfig) {
+    super(messages, lang, userConfig,
+      'Ten wyraz pisze się z łącznikiem.',
+      'Ten wyraz pisze się razem (bez spacji ani łącznika).',
+      'Ten wyraz pisze się z łącznikiem lub bez niego.',
+      'Brak łącznika lub zbędny łącznik');
+    this.addExamplePair(Example.wrong('Witamy w <marker>Rabce Zdroju</marker>.'),
+      Example.fixed('Witamy w <marker>Rabce-Zdroju</marker>.'));
+  }
+
+  // Java: CompoundRule#getId()
+  getId() {
+    return 'PL_COMPOUNDS';
+  }
+
+  // Java: CompoundRule#getDescription()
+  getDescription() {
+    return 'Sprawdza wyrazy z łącznikiem, np. „łapu capu” zamiast „łapu-capu”';
+  }
+
+  // Java: CompoundRule#getCompoundRuleData()
+  getCompoundRuleData() {
+    if (compoundData === null) {
+      compoundData = new CompoundRuleData('/pl/compounds.txt');
+    }
+    return compoundData;
+  }
+}

package/src/lang/pl/rules/DashRule.js

@@ -0,0 +1,32 @@
+// Java: org.languagetool.rules.pl.DashRule
+import { AbstractDashRule } from '@valueerror/ltjs-core/src/core/rules/AbstractDashRule.js';
+
+let trie = null; // Java: DashRule#trie (static, loaded once)
+
+// Java: DashRule
+export class DashRule extends AbstractDashRule {
+  static FQCN = 'org.languagetool.rules.pl.DashRule';
+
+  // Java: DashRule(ResourceBundle)
+  constructor(messages) {
+    super(messages);
+  }
+
+  // Java: DashRule#getDescription()
+  getDescription() {
+    return 'Sprawdza, czy wyrazy pisane z łącznikiem zapisano z myślnikami (np. „Lądek — Zdrój” zamiast „Lądek-Zdrój”).';
+  }
+
+  // Java: DashRule#getMessage()
+  getMessage() {
+    return 'Błędne użycie myślnika zamiast łącznika.';
+  }
+
+  // Java: DashRule#getCompoundsData()
+  getCompoundsData() {
+    if (trie === null) {
+      trie = AbstractDashRule.loadCompoundFile('/pl/compounds.txt');
+    }
+    return trie;
+  }
+}

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

@@ -0,0 +1,56 @@
+// Java: org.languagetool.rules.pl.DateCheckFilter
+import { registerClass } from '@valueerror/ltjs-core/src/core/resources/ClassBroker.js';
+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 { AbstractDateCheckFilter } from '@valueerror/ltjs-core/src/core/rules/AbstractDateCheckFilter.js';
+
+// Java: DateCheckFilter (pl)
+export class DateCheckFilter extends AbstractDateCheckFilter {
+  static FQCN = 'org.languagetool.rules.pl.DateCheckFilter';
+  static JAVA_ABSTRACT = false;
+  static JAVA_CONSTRUCTORS = [{ params: [], text: 'public org.languagetool.rules.pl.DateCheckFilter()' }];
+
+  // Java: DateCheckFilter#getCalendar()
+  getCalendar() {
+    return Calendar.getInstance(Locale.forLanguageTag('pl'));
+  }
+
+  // Java: DateCheckFilter#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.forLanguageTag('pl'));
+    }
+    const dayStr = arg;
+    const day = toLowerCase(dayStr);
+    if (day.startsWith('pon')) return Calendar.MONDAY;
+    if (day.startsWith('wt')) return Calendar.TUESDAY;
+    if (day.startsWith('śr')) return Calendar.WEDNESDAY;
+    if (day.startsWith('czw')) return Calendar.THURSDAY;
+    if (day === 'pt' || day.startsWith('piątk') || day === 'piątek') return Calendar.FRIDAY;
+    if (day.startsWith('sob')) return Calendar.SATURDAY;
+    if (day.startsWith('niedz')) return Calendar.SUNDAY;
+    throw new RuntimeException("Could not find day of week for '" + dayStr + "'");
+  }
+
+  // Java: DateCheckFilter#getMonth(String)
+  getMonth(monthStr) {
+    const mon = toLowerCase(monthStr);
+    if (mon === 'stycznia' || monthStr === 'I') return 1;
+    if (mon === 'lutego' || monthStr === 'II') return 2;
+    if (mon === 'marca' || monthStr === 'III') return 3;
+    if (mon === 'kwietnia' || monthStr === 'IV') return 4;
+    if (mon === 'maja' || monthStr === 'V') return 5;
+    if (mon === 'czerwca' || monthStr === 'VI') return 6;
+    if (mon === 'lipca' || monthStr === 'VII') return 7;
+    if (mon === 'sierpnia' || monthStr === 'VIII') return 8;
+    if (mon === 'września' || monthStr === 'IX') return 9;
+    if (mon === 'października' || monthStr === 'X') return 10;
+    if (mon === 'listopada' || monthStr === 'XI') return 11;
+    if (mon === 'grudnia' || monthStr === 'XII') return 12;
+    throw new RuntimeException("Could not find month '" + monthStr + "'");
+  }
+}
+
+registerClass(DateCheckFilter.FQCN, DateCheckFilter);

package/src/lang/pl/rules/DecadeSpellingFilter.js

@@ -0,0 +1,56 @@
+// Java: org.languagetool.rules.pl.DecadeSpellingFilter
+import { registerClass } from '@valueerror/ltjs-core/src/core/resources/ClassBroker.js';
+import { IllegalArgumentException, NullPointerException } from '@valueerror/ltjs-core/src/lib/java/errors.js';
+import { Integer } from '@valueerror/ltjs-core/src/lib/java/int.js';
+import { javaReplace, substring } from '@valueerror/ltjs-core/src/lib/java/strings.js';
+import { RuleFilter } from '@valueerror/ltjs-core/src/core/patterns/RuleFilter.js';
+import { RuleMatch } from '@valueerror/ltjs-core/src/core/rules/model/RuleMatch.js';
+
+const numbers = [1000, 900, 500, 400, 100, 90, 50, 40, 10, 9, 5, 4, 1];
+const letters = ['M', 'CM', 'D', 'CD', 'C', 'XC', 'L', 'XL', 'X', 'IX', 'V', 'IV', 'I'];
+
+// Java: DecadeSpellingFilter
+export class DecadeSpellingFilter extends RuleFilter {
+  static FQCN = 'org.languagetool.rules.pl.DecadeSpellingFilter';
+  static JAVA_ABSTRACT = false;
+  static JAVA_CONSTRUCTORS = [{ params: [], text: 'public org.languagetool.rules.pl.DecadeSpellingFilter()' }];
+
+  // Java: DecadeSpellingFilter#getRomanNumber(int)
+  getRomanNumber(num) {
+    let roman = '';
+    let n = num; // n represents the part of num that still has to be converted to Roman numeral representation
+    for (let i = 0; i < numbers.length; i++) {
+      while (n >= numbers[i]) {
+        roman += letters[i];
+        n -= numbers[i];
+      }
+    }
+    return roman;
+  }
+
+  // Java: DecadeSpellingFilter#acceptRuleMatch(RuleMatch,Map,int,AnalyzedTokenReadings[],List)
+  acceptRuleMatch(match, args) {
+    try {
+      const lata = args.get('lata');
+      if (lata === null || lata === undefined) {
+        throw new NullPointerException('Cannot invoke "String.substring(int)" because the return value of "java.util.Map.get(Object)" is null');
+      }
+      const decade = substring(lata, 2);
+      const century = substring(lata, 0, 2);
+      const cent = Integer.parseInt(century);
+      const message = javaReplace(javaReplace(match.getMessage(), '{dekada}', decade), '{wiek}', this.getRomanNumber(cent + 1));
+      const ruleMatch = new RuleMatch(match.getRule(), match.getSentence(), match.getFromPos(), match.getToPos(), match.getPatternFromPos(), match.getPatternToPos(),
+        message, match.getShortMessage(), match.getFromPos() === 0, null);
+      ruleMatch.setType(match.getType());
+      return ruleMatch;
+    } catch (e) {
+      if (e instanceof IllegalArgumentException) {
+        // ignore it silently
+        return null;
+      }
+      throw e;
+    }
+  }
+}
+
+registerClass(DecadeSpellingFilter.FQCN, DecadeSpellingFilter);

package/src/lang/pl/rules/MorfologikPolishSpellerRule.js

@@ -0,0 +1,141 @@
+// Java: org.languagetool.rules.pl.MorfologikPolishSpellerRule
+import { Pattern } from '@valueerror/ltjs-core/src/lib/java/regex/index.js';
+import { javaSplit, toLowerCase } from '@valueerror/ltjs-core/src/lib/java/strings.js';
+import { registerComponent } from '@valueerror/ltjs-core/src/core/language/components.js';
+import { MorfologikSpellerRule } from '@valueerror/ltjs-core/src/core/rules/spelling/morfologik/MorfologikSpellerRule.js';
+import { RuleMatch } from '@valueerror/ltjs-core/src/core/rules/model/RuleMatch.js';
+import { SuggestedReplacement } from '@valueerror/ltjs-core/src/core/rules/model/SuggestedReplacement.js';
+import { Categories } from '@valueerror/ltjs-core/src/core/rules/model/Category.js';
+import { Example } from '@valueerror/ltjs-core/src/core/rules/model/Examples.js';
+
+const RESOURCE_FILENAME = '/pl/hunspell/pl_PL.dict';
+const POLISH_TOKENIZING_CHARS = Pattern.compile('(?:[Qq]uasi|[Nn]iby)-');
+
+// The set of prefixes that are not allowed to be split in the suggestions.
+const prefixes = new Set([
+  'arcy', 'neo', 'pre', 'anty', 'eks', 'bez', 'beze', 'ekstra', 'hiper', 'infra', 'kontr', 'maksi', 'midi', 'między',
+  'mini', 'nad', 'nade', 'około', 'ponad', 'post', 'pro', 'przeciw', 'pseudo', 'super', 'śród', 'ultra', 'wice', 'wokół', 'wokoło',
+]);
+
+// non-word suffixes that should not be suggested (only morphological endings, never after a space)
+const bannedSuffixes = new Set(['ami', 'ach', 'e', 'ego', 'em', 'emu', 'ie', 'im', 'm', 'om', 'owie', 'owi', 'ze']);
+
+// Java: MorfologikPolishSpellerRule
+export class MorfologikPolishSpellerRule extends MorfologikSpellerRule {
+  static FQCN = 'org.languagetool.rules.pl.MorfologikPolishSpellerRule';
+
+  // Java: MorfologikPolishSpellerRule(ResourceBundle,Language,UserConfig,List)
+  constructor(messages, language, userConfig, altLanguages) {
+    super(messages, language, userConfig, altLanguages);
+    this.setCategory(Categories.TYPOS.getCategory(messages));
+    this.addExamplePair(Example.wrong('To jest zdanie z <marker>bledem</marker>'),
+      Example.fixed('To jest zdanie z <marker>błędem</marker>.'));
+    this.userConfig = userConfig;
+  }
+
+  // Java: MorfologikPolishSpellerRule#getFileName()
+  getFileName() {
+    return RESOURCE_FILENAME;
+  }
+
+  // Java: MorfologikPolishSpellerRule#getId()
+  getId() {
+    return 'MORFOLOGIK_RULE_PL_PL';
+  }
+
+  // Java: MorfologikPolishSpellerRule#tokenizingPattern()
+  tokenizingPattern() {
+    return POLISH_TOKENIZING_CHARS;
+  }
+
+  // Java: MorfologikPolishSpellerRule#getRuleMatches(String,int,AnalyzedSentence,List,int,AnalyzedTokenReadings[])
+  getRuleMatches(word, startPos, sentence, ruleMatchesSoFar) {
+    const speller1 = this.speller1;
+    const ruleMatches = [];
+    if ((this.isMisspelled(speller1, word) && this.isNotCompound(word)) || this.isProhibited(word)) {
+      const ruleMatch = new RuleMatch(this, sentence, startPos, startPos
+        + word.length, this.messages.getString('spelling'),
+      this.messages.getString('desc_spelling_short'));
+      if (this.userConfig !== null && !this.userConfig.isSuggestionsEnabled()) {
+        ruleMatches.push(ruleMatch);
+        return ruleMatches;
+      }
+      // If lower case word is not a misspelled word, return it as the only suggestion
+      const createSuggestions = this.userConfig === null || this.userConfig.getMaxSpellingSuggestions() === 0
+        || ruleMatchesSoFar.length <= this.userConfig.getMaxSpellingSuggestions();
+      if (!this.isMisspelled(speller1, toLowerCase(word, this.conversionLocale))) {
+        if (createSuggestions) {
+          ruleMatch.setSuggestedReplacements([toLowerCase(word, this.conversionLocale)]);
+        } else {
+          // limited to save CPU
+          ruleMatch.setSuggestedReplacement(this.messages.getString('too_many_errors'));
+        }
+        ruleMatches.push(ruleMatch);
+        return ruleMatches;
+      }
+      if (createSuggestions) {
+        const suggestions = SuggestedReplacement.convert(speller1.getSuggestions(word));
+        suggestions.splice(0, 0, ...this.getAdditionalTopSuggestions(suggestions, word));
+        suggestions.push(...this.getAdditionalSuggestions(suggestions, word));
+        if (suggestions.length > 0) {
+          ruleMatch.setSuggestedReplacementObjects(this.pruneSuggestions(this.orderSuggestions(suggestions, word)));
+        }
+      } else {
+        // limited to save CPU
+        ruleMatch.setSuggestedReplacement(this.messages.getString('too_many_errors'));
+      }
+      ruleMatches.push(ruleMatch);
+    }
+    return ruleMatches;
+  }
+
+  // Java: MorfologikPolishSpellerRule#isNotCompound(String)
+  isNotCompound(word) {
+    const probablyCorrectWords = [];
+    for (let i = 2; i < word.length; i++) {
+      // chop from left to right
+      const first = word.substring(0, i);
+      const second = word.substring(i);
+      if (prefixes.has(toLowerCase(first, this.conversionLocale))
+        && !this.isMisspelled(this.speller1, second)
+        && second.length > first.length) { // but not for short words such as "premoc"
+        // ignore this match, it's fine
+        probablyCorrectWords.push(word); // FIXME: some strange words are being accepted, like prekupa
+      } else {
+        const testedTokens = [first, second];
+        const taggedToks = this.language.getTagger().tag(testedTokens);
+        if (taggedToks.length === 2
+          // "białozielony", trzynastobitowy
+          && (taggedToks[0].hasPosTag('adja')
+          || (taggedToks[0].hasPosTag('num:comp')
+          && !taggedToks[0].hasPosTag('adv')))
+          && taggedToks[1].hasPartialPosTag('adj:')) {
+          probablyCorrectWords.push(word);
+        }
+      }
+    }
+    if (probablyCorrectWords.length > 0) {
+      this.addIgnoreTokens(probablyCorrectWords);
+      return false;
+    }
+    return true;
+  }
+
+  // Java: MorfologikPolishSpellerRule#pruneSuggestions(List)
+  pruneSuggestions(suggestions) {
+    const prunedSuggestions = [];
+    for (const suggestion of suggestions) {
+      if (suggestion.getReplacement().indexOf(' ') === -1) {
+        prunedSuggestions.push(suggestion);
+      } else {
+        const complexSug = javaSplit(suggestion.getReplacement(), ' ');
+        if (complexSug.length > 1 && !bannedSuffixes.has(complexSug[1])) {
+          prunedSuggestions.push(suggestion);
+        }
+      }
+    }
+    return prunedSuggestions;
+  }
+}
+
+registerComponent(MorfologikPolishSpellerRule.FQCN, (...args) => new MorfologikPolishSpellerRule(...args));