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

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

@@ -0,0 +1,23 @@
+// Java: org.languagetool.rules.pl.PolishUnpairedBracketsRule
+import { GenericUnpairedBracketsRule } from '@valueerror/ltjs-core/src/core/rules/GenericUnpairedBracketsRule.js';
+import { Example } from '@valueerror/ltjs-core/src/core/rules/model/Examples.js';
+
+const PL_START_SYMBOLS = ['[', '(', '{', '„', '»', '"'];
+const PL_END_SYMBOLS = [']', ')', '}', '”', '«', '"'];
+
+// Java: PolishUnpairedBracketsRule
+export class PolishUnpairedBracketsRule extends GenericUnpairedBracketsRule {
+  static FQCN = 'org.languagetool.rules.pl.PolishUnpairedBracketsRule';
+
+  // Java: PolishUnpairedBracketsRule(ResourceBundle,Language)
+  constructor(messages) {
+    super(messages, PL_START_SYMBOLS, PL_END_SYMBOLS);
+    this.addExamplePair(Example.wrong('To jest zdanie z <marker>„</marker>cudzysłowem.'),
+      Example.fixed('To jest zdanie z <marker>„</marker>cudzysłowem”.'));
+  }
+
+  // Java: PolishUnpairedBracketsRule#getId()
+  getId() {
+    return 'PL_UNPAIRED_BRACKETS';
+  }
+}

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

@@ -0,0 +1,64 @@
+// Java: org.languagetool.rules.pl.PolishWordRepeatRule
+import { Pattern } from '@valueerror/ltjs-core/src/lib/java/regex/index.js';
+import { AdvancedWordRepeatRule } from '@valueerror/ltjs-core/src/core/rules/AdvancedWordRepeatRule.js';
+import { Example } from '@valueerror/ltjs-core/src/core/rules/model/Examples.js';
+
+// Excluded dictionary words.
+const EXC_WORDS = new Set([
+  'nie', 'tuż', 'aż', 'to', 'siebie', 'być', 'ani', 'ni', 'albo', 'lub', 'czy', 'bądź', 'jako', 'zł', 'np', 'coraz',
+  'bardzo', 'bardziej', 'proc', 'ten', 'jak', 'mln', 'tys', 'swój', 'mój', 'twój', 'nasz', 'wasz', 'i', 'zbyt', 'się',
+]);
+
+// Excluded part of speech classes.
+const EXC_POS = Pattern.compile('prep:.*|ppron.*');
+
+// Excluded non-words (special symbols, Roman numerals etc.)
+const EXC_NONWORDS = Pattern.compile('&quot|&gt|&lt|&amp|[0-9].*|'
+  + 'M*(D?C{0,3}|C[DM])(L?X{0,3}|X[LC])(V?I{0,3}|I[VX])$');
+
+// Java: PolishWordRepeatRule
+export class PolishWordRepeatRule extends AdvancedWordRepeatRule {
+  static FQCN = 'org.languagetool.rules.pl.PolishWordRepeatRule';
+
+  // Java: PolishWordRepeatRule(ResourceBundle)
+  constructor(messages) {
+    super(messages);
+    this.addExamplePair(Example.wrong('Mówiła długo, bo lubiła robić wszystko <marker>długo</marker>.'),
+      Example.fixed('Mówiła długo, bo lubiła robić wszystko <marker>powoli</marker>.'));
+  }
+
+  // Java: PolishWordRepeatRule#getDescription()
+  getDescription() {
+    return 'Powtórzenia wyrazów w zdaniu (monotonia stylistyczna)';
+  }
+
+  // Java: PolishWordRepeatRule#getExcludedNonWordsPattern()
+  getExcludedNonWordsPattern() {
+    return EXC_NONWORDS;
+  }
+
+  // Java: PolishWordRepeatRule#getExcludedPos()
+  getExcludedPos() {
+    return EXC_POS;
+  }
+
+  // Java: PolishWordRepeatRule#getExcludedWordsPattern()
+  getExcludedWordsPattern() {
+    return EXC_WORDS;
+  }
+
+  // Java: PolishWordRepeatRule#getId()
+  getId() {
+    return 'PL_WORD_REPEAT';
+  }
+
+  // Java: PolishWordRepeatRule#getMessage()
+  getMessage() {
+    return 'Powtórzony wyraz w zdaniu';
+  }
+
+  // Java: PolishWordRepeatRule#getShortMessage()
+  getShortMessage() {
+    return 'Powtórzenie wyrazu';
+  }
+}

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

@@ -0,0 +1,63 @@
+// Java: org.languagetool.rules.pl.SimpleReplaceRule
+import { AbstractSimpleReplaceRule } from '@valueerror/ltjs-core/src/core/rules/AbstractSimpleReplaceRule.js';
+import { Category, CategoryId } from '@valueerror/ltjs-core/src/core/rules/model/Category.js';
+import { Example } from '@valueerror/ltjs-core/src/core/rules/model/Examples.js';
+import { ITSIssueType } from '@valueerror/ltjs-core/src/core/rules/model/ITSIssueType.js';
+import { Locale } from '@valueerror/ltjs-core/src/lib/java/Locale.js';
+
+let wrongWords = null; // Java: static wrongWords = loadFromPath("/pl/replace.txt")
+const PL_LOCALE = new Locale('pl');
+
+// Java: SimpleReplaceRule (pl)
+export class SimpleReplaceRule extends AbstractSimpleReplaceRule {
+  static FQCN = 'org.languagetool.rules.pl.SimpleReplaceRule';
+  static POLISH_SIMPLE_REPLACE_RULE = 'PL_SIMPLE_REPLACE';
+
+  // Java: SimpleReplaceRule#getWrongWords()
+  getWrongWords() {
+    if (wrongWords === null) wrongWords = AbstractSimpleReplaceRule.loadFromPath('/pl/replace.txt');
+    return wrongWords;
+  }
+
+  // Java: SimpleReplaceRule(ResourceBundle,Language)
+  constructor(messages, language) {
+    super(messages, language);
+    SimpleReplaceRule.prototype.getWrongWords.call(this); // Java: static initializer runs at class load
+    this.setLocQualityIssueType(ITSIssueType.Misspelling);
+    this.setCategory(new Category(new CategoryId('PRAWDOPODOBNE_LITEROWKI'), 'Prawdopodobne literówki'));
+    this.setCheckLemmas(false);
+    this.addExamplePair(Example.wrong('Uspokój <marker>sei</marker>.'),
+      Example.fixed('Uspokój <marker>się</marker>.'));
+  }
+
+  // Java: SimpleReplaceRule#getId()
+  getId() {
+    return SimpleReplaceRule.POLISH_SIMPLE_REPLACE_RULE;
+  }
+
+  // Java: SimpleReplaceRule#getDescription()
+  getDescription() {
+    return 'Typowe literówki i niepoprawne wyrazy (domowi, sie, niewiadomo, duh, cie…)';
+  }
+
+  // Java: SimpleReplaceRule#getShort()
+  getShort() {
+    return 'Literówka';
+  }
+
+  // Java: SimpleReplaceRule#getMessage(String,List)
+  getMessage(tokenStr, replacements) {
+    return 'Wyraz „' + tokenStr + '” to najczęściej literówka; poprawnie pisze się: '
+        + replacements.join(', ') + '.';
+  }
+
+  // Java: SimpleReplaceRule#isCaseSensitive()
+  isCaseSensitive() {
+    return false;
+  }
+
+  // Java: SimpleReplaceRule#getLocale()
+  getLocale() {
+    return PL_LOCALE;
+  }
+}

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

@@ -0,0 +1,40 @@
+// Java: org.languagetool.rules.pl.WordCoherencyRule
+import { AbstractWordCoherencyRule } from '@valueerror/ltjs-core/src/core/rules/AbstractWordCoherencyRule.js';
+import { WordCoherencyDataLoader } from '@valueerror/ltjs-core/src/core/rules/WordCoherencyDataLoader.js';
+import { Example } from '@valueerror/ltjs-core/src/core/rules/model/Examples.js';
+
+let wordMap = null; // Java: static wordMap = new WordCoherencyDataLoader().loadWords("/pl/coherency.txt")
+
+// Java: WordCoherencyRule (pl)
+export class WordCoherencyRule extends AbstractWordCoherencyRule {
+  static FQCN = 'org.languagetool.rules.pl.WordCoherencyRule';
+
+  // Java: WordCoherencyRule(ResourceBundle)
+  constructor(messages) {
+    super(messages);
+    this.getWordMap(); // Java: static initializer runs at class load
+    this.addExamplePair(Example.wrong('Grapefruity są zdrowe. <marker>Grejpfrut</marker> smakuje najlepiej smażony.'),
+      Example.fixed('Grapefruity są zdrowe. <marker>Grapefruit</marker> smakuje najlepiej smażony.'));
+  }
+
+  // Java: WordCoherencyRule#getWordMap()
+  getWordMap() {
+    if (wordMap === null) wordMap = new WordCoherencyDataLoader().loadWords('/pl/coherency.txt');
+    return wordMap;
+  }
+
+  // Java: WordCoherencyRule#getMessage(String,String)
+  getMessage(word1, word2) {
+    return 'Formy „' + word1 + '” i „' + word2 + '” zwykle nie powinny być używane jednocześnie.';
+  }
+
+  // Java: WordCoherencyRule#getId()
+  getId() {
+    return 'PL_WORD_COHERENCY';
+  }
+
+  // Java: WordCoherencyRule#getDescription()
+  getDescription() {
+    return 'Jednolita pisownia wyrazów o obocznej dopuszczalnej pisowni';
+  }
+}

package/src/lang/pl/synthesis/PolishSynthesizer.js

@@ -0,0 +1,151 @@
+// Java: org.languagetool.synthesis.pl.PolishSynthesizer
+import { DictionaryLookup } from '@valueerror/ltjs-core/src/lib/fsa/DictionaryLookup.js';
+import { Pattern, PatternSyntaxException } from '@valueerror/ltjs-core/src/lib/java/regex/index.js';
+import { JavaHashSet } from '@valueerror/ltjs-core/src/lib/java/collections/JavaHashSet.js';
+import { javaSplit, javaReplace } from '@valueerror/ltjs-core/src/lib/java/strings.js';
+import { NullPointerException } from '@valueerror/ltjs-core/src/lib/java/errors.js';
+import { registerComponent, sharedComponent } from '@valueerror/ltjs-core/src/core/language/components.js';
+import { BaseSynthesizer } from '@valueerror/ltjs-core/src/core/tagging/synthesis/BaseSynthesizer.js';
+import { loadWords } from '@valueerror/ltjs-core/src/core/tagging/synthesis/SynthesizerTools.js';
+import { getDataBroker } from '@valueerror/ltjs-core/src/core/resources/LtStatics.js';
+
+const RESOURCE_FILENAME = '/pl/polish_synth.dict';
+const TAGS_FILE_NAME = '/pl/polish_tags.txt';
+
+const POTENTIAL_NEGATION_TAG = ':aff';
+const NEGATION_TAG = ':neg';
+const NEGATION_TAG_PATTERN = Pattern.compile(NEGATION_TAG);
+const COMP_TAG = 'com';
+const SUP_TAG = 'sup';
+const PATTERN = Pattern.compile('.*[a-z]\\.[a-z].*');
+const DOT = Pattern.compile('.', Pattern.LITERAL);
+
+// Java: PolishSynthesizer
+export class PolishSynthesizer extends BaseSynthesizer {
+  static FQCN = 'org.languagetool.synthesis.pl.PolishSynthesizer';
+
+  // Java: PolishSynthesizer#INSTANCE
+  static get INSTANCE() {
+    return sharedComponent(PolishSynthesizer.FQCN);
+  }
+
+  // Java: PolishSynthesizer#PolishSynthesizer() (the deprecated (Language) constructor delegates here)
+  constructor() {
+    super(null, RESOURCE_FILENAME, TAGS_FILE_NAME, 'pl');
+    this.plPossibleTags = null; // Java: PolishSynthesizer#possibleTags (private field, separate from BaseSynthesizer's)
+  }
+
+  // Java: PolishSynthesizer#synthesize(AnalyzedToken,String) / synthesize(AnalyzedToken,String,boolean) (overload by argument count)
+  synthesize(token, posTag, posTagRegExp) {
+    return posTagRegExp === undefined ? this.synthesize2(token, posTag) : this.synthesize3(token, posTag, posTagRegExp);
+  }
+
+  // Java: PolishSynthesizer#synthesize(AnalyzedToken,String)
+  synthesize2(token, posTag) {
+    if (posTag === null || posTag === undefined) {
+      return null;
+    }
+    const synthesizer = new DictionaryLookup(this.getDictionary());
+    let isNegated = false;
+    if (token.getPOSTag() !== null) {
+      isNegated = posTag.indexOf(NEGATION_TAG) > 0
+          || (token.getPOSTag().indexOf(NEGATION_TAG) > 0
+          && !(posTag.indexOf(COMP_TAG) > 0) && !(posTag.indexOf(SUP_TAG) > 0));
+    }
+    if (posTag.indexOf('+') > 0) {
+      return this.synthesize3(token, posTag, true);
+    }
+    return this.getWordForms(token, posTag, isNegated, synthesizer);
+  }
+
+  // Java: PolishSynthesizer#synthesize(AnalyzedToken,String,boolean)
+  synthesize3(token, pos, posTagRegExp) {
+    if (pos === null || pos === undefined) {
+      return null;
+    }
+    let posTag = pos;
+    if (posTagRegExp) {
+      if (this.plPossibleTags === null) {
+        this.plPossibleTags = loadWords(getDataBroker().getFromResourceDirAsStream(TAGS_FILE_NAME));
+      }
+      const synthesizer = new DictionaryLookup(this.getDictionary());
+      let results = [];
+
+      let isNegated = false;
+      if (token.getPOSTag() !== null) {
+        isNegated = posTag.indexOf(NEGATION_TAG) > 0
+            || (token.getPOSTag().indexOf(NEGATION_TAG) > 0
+            && !(posTag.indexOf(COMP_TAG) > 0)
+            && !(posTag.indexOf(SUP_TAG) > 0));
+      }
+
+      if (isNegated) {
+        posTag = javaReplace(posTag, NEGATION_TAG, POTENTIAL_NEGATION_TAG + '?');
+      }
+
+      try {
+        const p = Pattern.compile(javaReplace(posTag, '+', '|'));
+        for (const tag of this.plPossibleTags) {
+          const m = p.matcher(tag);
+          if (m.matches()) {
+            const wordForms = this.getWordForms(token, tag, isNegated, synthesizer);
+            if (wordForms !== null) {
+              results.push(...wordForms);
+            }
+          }
+        }
+      } catch (e) {
+        if (!(e instanceof PatternSyntaxException)) throw e;
+        // Java: e.printStackTrace() (rare invalid regexp, issue 1651); results so far are kept
+      }
+      // remove duplicates (HashSet iteration order)
+      results = [...new JavaHashSet(results)];
+      return results;
+    }
+    return this.synthesize2(token, posTag);
+  }
+
+  // Java: PolishSynthesizer#getPosTagCorrection(String)
+  getPosTagCorrection(posTag) {
+    if (posTag === null || posTag === undefined) throw new NullPointerException('Cannot invoke "String.contains(java.lang.CharSequence)" because "posTag" is null');
+    if (posTag.includes('.')) {
+      const tags = javaSplit(posTag, ':');
+      let pos = -1;
+      for (let i = 0; i < tags.length; i++) {
+        if (PATTERN.matcher(tags[i]).matches()) {
+          tags[i] = '(.*' + DOT.matcher(tags[i]).replaceAll('.*|.*') + '.*)';
+          pos = i;
+        }
+      }
+      if (pos === -1) {
+        return posTag;
+      }
+      return tags.join(':');
+    }
+    return posTag;
+  }
+
+  // Java: PolishSynthesizer#getWordForms(AnalyzedToken,String,boolean,IStemmer)
+  getWordForms(token, posTag, isNegated, synthesizer) {
+    const forms = [];
+    if (isNegated) {
+      const wordForms = synthesizer.lookup(token.getLemma() + '|'
+          + NEGATION_TAG_PATTERN.matcher(posTag).replaceFirst(POTENTIAL_NEGATION_TAG));
+      if (wordForms !== null) {
+        for (const wd of wordForms) {
+          forms.push('nie' + wd.getStem());
+        }
+      }
+    } else {
+      const wordForms = synthesizer.lookup(token.getLemma() + '|' + posTag);
+      for (const wd of wordForms) {
+        if (wd.getStem() !== null) {
+          forms.push(String(wd.getStem()));
+        }
+      }
+    }
+    return forms;
+  }
+}
+
+registerComponent(PolishSynthesizer.FQCN, () => new PolishSynthesizer());

package/src/lang/pl/tagging/PolishHybridDisambiguator.js

@@ -0,0 +1,25 @@
+// Java: org.languagetool.tagging.disambiguation.pl.PolishHybridDisambiguator
+import { registerComponent } from '@valueerror/ltjs-core/src/core/language/components.js';
+import { AbstractDisambiguator } from '@valueerror/ltjs-core/src/core/tagging/disambiguation/AbstractDisambiguator.js';
+import { MultiWordChunker } from '@valueerror/ltjs-core/src/core/tagging/disambiguation/MultiWordChunker.js';
+import { XmlRuleDisambiguator } from '@valueerror/ltjs-core/src/core/disambiguation/XmlRuleDisambiguator.js';
+import { Polish } from '../language/Polish.js';
+
+// Java: PolishHybridDisambiguator
+export class PolishHybridDisambiguator extends AbstractDisambiguator {
+  static FQCN = 'org.languagetool.tagging.disambiguation.pl.PolishHybridDisambiguator';
+
+  // Java: PolishHybridDisambiguator#PolishHybridDisambiguator() (field initialisers: chunker, then a second Polish instance)
+  constructor() {
+    super();
+    this.chunker = MultiWordChunker.getInstance('/pl/multiwords.txt');
+    this.disambiguator = new XmlRuleDisambiguator(new Polish());
+  }
+
+  // Java: PolishHybridDisambiguator#disambiguate(AnalyzedSentence)
+  disambiguate(input, checkCanceled = null) {
+    return this.chunker.disambiguate(this.disambiguator.disambiguate(input, checkCanceled), checkCanceled);
+  }
+}
+
+registerComponent(PolishHybridDisambiguator.FQCN, () => new PolishHybridDisambiguator());

package/src/lang/pl/tagging/PolishTagger.js

@@ -0,0 +1,95 @@
+// Java: org.languagetool.tagging.pl.PolishTagger
+import { Locale } from '@valueerror/ltjs-core/src/lib/java/Locale.js';
+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 { AnalyzedToken } from '@valueerror/ltjs-core/src/core/AnalyzedToken.js';
+import { AnalyzedTokenReadings } from '@valueerror/ltjs-core/src/core/AnalyzedTokenReadings.js';
+import { BaseTagger } from '@valueerror/ltjs-core/src/core/tagging/BaseTagger.js';
+import { CachingWordListLoader } from '@valueerror/ltjs-core/src/core/rules/spelling/CachingWordListLoader.js';
+import { asString, isMixedCase, uppercaseFirstChar } from '@valueerror/ltjs-core/src/core/text/StringTools.js';
+
+const NEGATION_PREFIX = 'nie';
+const COMPAR_SUPERL = Pattern.compile('(adv|adj:.+):(com|sup)'); // Java: PolishTagger#COMPAR_SUPERL
+const MIN_NEGATED_LENGTH = NEGATION_PREFIX.length + 4;
+const NEGATION_EXCEPTIONS_FILE = '/pl/nie_compar_exceptions.txt';
+
+// Java: PolishTagger
+export class PolishTagger extends BaseTagger {
+  static FQCN = 'org.languagetool.tagging.pl.PolishTagger';
+
+  // Java: PolishTagger#PolishTagger()
+  constructor() {
+    super('/pl/polish.dict', new Locale('pl'));
+    this.negationExceptions = new Set(new CachingWordListLoader().loadWords(NEGATION_EXCEPTIONS_FILE));
+  }
+
+  // Java: PolishTagger#tag(List)
+  tag(sentenceTokens) {
+    const tokenReadings = [];
+    let pos = 0;
+    for (const word of sentenceTokens) {
+      const l = [];
+      const lowerWord = toLowerCase(word, this.locale);
+      const taggerTokens = this.asAnalyzedTokenListForTaggedWords(word, this.getWordTagger().tag(word));
+      const isLowercase = word === lowerWord;
+      // normal case
+      this.plAddTokens(taggerTokens, l);
+      if (!isLowercase) {
+        // lowercase
+        const lowerTaggerTokens = this.asAnalyzedTokenListForTaggedWords(word, this.getWordTagger().tag(lowerWord));
+        this.plAddTokens(lowerTaggerTokens, l);
+      }
+      // uppercase
+      if (l.length === 0 && isLowercase) {
+        const upperTaggerTokens = this.asAnalyzedTokenListForTaggedWords(word, this.getWordTagger().tag(uppercaseFirstChar(word)));
+        this.plAddTokens(upperTaggerTokens, l);
+      }
+      // additional language-dependent tagging, e.g. joined "nie"
+      if (l.length === 0) {
+        this.plAddTokens(this.additionalTags(word, this.getWordTagger()), l);
+      }
+      if (l.length === 0) {
+        l.push(new AnalyzedToken(word, null, null));
+      }
+      tokenReadings.push(new AnalyzedTokenReadings(l, pos));
+      pos += word.length;
+    }
+    return tokenReadings;
+  }
+
+  // Java: PolishTagger#additionalTags(String,WordTagger)
+  additionalTags(word, wordTagger) {
+    const lowerWord = toLowerCase(word, this.locale);
+    if (lowerWord.length < MIN_NEGATED_LENGTH
+        || !lowerWord.startsWith(NEGATION_PREFIX)
+        || isMixedCase(word)
+        || this.negationExceptions.has(lowerWord)) {
+      return null;
+    }
+    // Only one lookup, so "nienielepiej" stays untagged.
+    const base = lowerWord.substring(NEGATION_PREFIX.length);
+    const result = [];
+    for (const baseToken of this.asAnalyzedTokenListForTaggedWords(word, wordTagger.tag(base))) {
+      const posTag = baseToken.getPOSTag();
+      if (posTag !== null && baseToken.getLemma() !== null && COMPAR_SUPERL.matcher(posTag).matches()) {
+        result.push(new AnalyzedToken(word, posTag, NEGATION_PREFIX + baseToken.getLemma()));
+      }
+    }
+    return result.length === 0 ? null : result;
+  }
+
+  // Java: PolishTagger#addTokens(List,List) (private; renamed so BaseTagger#addTokens keeps its behaviour)
+  plAddTokens(taggedTokens, l) {
+    if (taggedTokens !== null) {
+      for (const at of taggedTokens) {
+        const tagsArr = javaSplit(asString(at.getPOSTag()), '\\+');
+        for (const currTag of tagsArr) {
+          l.push(new AnalyzedToken(at.getToken(), currTag, at.getLemma()));
+        }
+      }
+    }
+  }
+}
+
+registerComponent(PolishTagger.FQCN, () => new PolishTagger());

package/src/lang/pl/tokenizers/PolishWordTokenizer.js

@@ -0,0 +1,112 @@
+// Java: org.languagetool.tokenizers.pl.PolishWordTokenizer
+import { StringTokenizer } from '@valueerror/ltjs-core/src/lib/java/StringTokenizer.js';
+import { isDigit } from '@valueerror/ltjs-core/src/lib/java/Character.js';
+import { javaSplit } from '@valueerror/ltjs-core/src/lib/java/strings.js';
+import { IOException, RuntimeException } from '@valueerror/ltjs-core/src/lib/java/errors.js';
+import { registerComponent } from '@valueerror/ltjs-core/src/core/language/components.js';
+import { WordTokenizer } from '@valueerror/ltjs-core/src/core/text/tokenizers/WordTokenizer.js';
+
+// Polish prefixes that should never be used to split parts of words
+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',
+]);
+
+// Java: PolishWordTokenizer
+export class PolishWordTokenizer extends WordTokenizer {
+  static FQCN = 'org.languagetool.tokenizers.pl.PolishWordTokenizer';
+
+  // Java: PolishWordTokenizer#PolishWordTokenizer()
+  constructor() {
+    super();
+    this.tagger = null;
+    this.plTokenizing = `${super.getTokenizingCharacters()}–‚`; // n-dash
+  }
+
+  // Java: PolishWordTokenizer#tokenize(String)
+  tokenize(text) {
+    const l = [];
+    const st = new StringTokenizer(text, this.plTokenizing, true);
+    while (st.hasMoreElements()) {
+      const token = st.nextToken();
+      if (token.length > 1) {
+        if (token.endsWith('-')) {
+          l.push(token.substring(0, token.length - 1));
+          l.push('-');
+        } else if (token.charAt(0) === '-') {
+          l.push('-');
+          l.push(...this.tokenize(token.substring(1)));
+        } else if (token.includes('-')) {
+          const tokenParts = javaSplit(token, '-');
+          if (prefixes.has(tokenParts[0]) || this.tagger === null) {
+            l.push(token);
+          } else if (isDigit(tokenParts[tokenParts.length - 1].charCodeAt(0))) {
+            // split numbers at dash or minus sign, 1-10
+            for (let i = 0; i < tokenParts.length; i++) {
+              l.push(tokenParts[i]);
+              if (i !== tokenParts.length - 1) {
+                l.push('-');
+              }
+            }
+          } else {
+            const testedTokens = [...tokenParts, token];
+            try {
+              const taggedToks = this.tagger.tag(testedTokens);
+              if (taggedToks.length === tokenParts.length + 1 && !taggedToks[tokenParts.length].isTagged()) {
+                let isCompound = false;
+                switch (tokenParts.length) {
+                  case 2:
+                    if ((taggedToks[0].hasPosTag('adja') // "niemiecko-indonezyjski"
+                        && taggedToks[1].hasPartialPosTag('adj:'))
+                        || (taggedToks[0].hasPartialPosTag('subst:') // "kobieta-wojownik"
+                        && taggedToks[1].hasPartialPosTag('subst:'))
+                        || (taggedToks[0].hasPartialPosTag('num:') // osiemnaście-dwadzieścia
+                        && taggedToks[1].hasPartialPosTag('num:'))) {
+                      isCompound = true;
+                    }
+                    break;
+                  case 3:
+                    if (taggedToks[0].hasPosTag('adja')
+                        && taggedToks[1].hasPosTag('adja')
+                        && taggedToks[2].hasPartialPosTag('adj:')) {
+                      isCompound = true;
+                    }
+                    break;
+                  default:
+                    break;
+                }
+                if (isCompound) {
+                  for (let i = 0; i < tokenParts.length; i++) {
+                    l.push(tokenParts[i]);
+                    if (i !== tokenParts.length - 1) {
+                      l.push('-');
+                    }
+                  }
+                } else {
+                  l.push(token);
+                }
+              } else {
+                l.push(token);
+              }
+            } catch (e) {
+              if (e instanceof IOException) throw new RuntimeException(e);
+              throw e;
+            }
+          }
+        } else {
+          l.push(token);
+        }
+      } else {
+        l.push(token);
+      }
+    }
+    return this.joinEMailsAndUrls(l);
+  }
+
+  // Java: PolishWordTokenizer#setTagger(Tagger)
+  setTagger(tagger) {
+    this.tagger = tagger;
+  }
+}
+
+registerComponent(PolishWordTokenizer.FQCN, () => new PolishWordTokenizer());