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

package/src/lang/fr/rules/QuestionWhitespaceStrictRule.js

@@ -0,0 +1,38 @@
+// org.languagetool.rules.fr.QuestionWhitespaceStrictRule
+import { QuestionWhitespaceRule } from './QuestionWhitespaceRule.js';
+import { Tag } from '@valueerror/ltjs-core/src/core/rules/model/Tag.js';
+
+// Java: QuestionWhitespaceStrictRule
+export class QuestionWhitespaceStrictRule extends QuestionWhitespaceRule {
+  static FQCN = 'org.languagetool.rules.fr.QuestionWhitespaceStrictRule';
+
+  // Java: QuestionWhitespaceStrictRule(ResourceBundle,Language)
+  constructor(messages, language) {
+    super(messages, language);
+    this.setTags([Tag.picky]);
+    this.setDefaultTempOff();
+  }
+
+  // Java: QuestionWhitespaceStrictRule#getId()
+  getId() {
+    return 'FRENCH_WHITESPACE_STRICT';
+  }
+
+  // Java: QuestionWhitespaceStrictRule#getDescription()
+  getDescription() {
+    return 'Insertion des espaces fines insécables';
+  }
+
+  // Java: QuestionWhitespaceStrictRule#isAllowedWhitespaceChar(AnalyzedTokenReadings[],int)
+  isAllowedWhitespaceChar(tokens, i) {
+    // Strictly speaking, the character before ?!; should be an
+    // "espace fine insécable" (U+202f). In practise, an
+    // "espace insécable" (U+00a0) is also often used. Let's accept both.
+    if (i < 0) {
+      return false;
+    }
+    return tokens[i].getToken() === ' ' || tokens[i].getToken() === ' '
+      // covered by FRENCH_WHITESPACE (non strict). This makes both rules mutually exclusive
+      || !tokens[i].isWhitespace();
+  }
+}

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

@@ -0,0 +1,63 @@
+// org.languagetool.rules.fr.SimpleReplaceRule
+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 { Locale } from '@valueerror/ltjs-core/src/lib/java/Locale.js';
+
+let wrongWords = null; // Java: static wrongWords = loadFromPath("/fr/replace.txt", "/fr/replace_custom.txt")
+const FR_LOCALE = new Locale('FR');
+
+// Java: SimpleReplaceRule
+export class SimpleReplaceRule extends AbstractSimpleReplaceRule {
+  static FQCN = 'org.languagetool.rules.fr.SimpleReplaceRule';
+
+  // Java: SimpleReplaceRule#getWrongWords()
+  getWrongWords() {
+    if (wrongWords === null) wrongWords = AbstractSimpleReplaceRule.loadFromPath('/fr/replace.txt', '/fr/replace_custom.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
+    super.setCategory(Categories.TYPOS.getCategory(messages));
+    super.setLocQualityIssueType(ITSIssueType.Misspelling);
+    this.setIgnoreTaggedWords();
+    this.setCheckLemmas(false);
+    super.useSubRuleSpecificIds();
+  }
+
+  // Java: SimpleReplaceRule#getId()
+  getId() {
+    return 'FR_SIMPLE_REPLACE_SIMPLE';
+  }
+
+  // Java: SimpleReplaceRule#getDescription()
+  getDescription() {
+    return 'Mot incorrect : $match';
+  }
+
+  // Java: SimpleReplaceRule#getShort()
+  getShort() {
+    return 'Mot incorrect';
+  }
+
+  // Java: SimpleReplaceRule#getMessage(String,List)
+  getMessage(tokenStr, replacements) {
+    if (replacements.length > 0) {
+      return 'Vouliez-vous dire « ' + replacements[0] + ' » ?';
+    }
+    return this.getShort();
+  }
+
+  // Java: SimpleReplaceRule#isCaseSensitive()
+  isCaseSensitive() {
+    return false;
+  }
+
+  // Java: SimpleReplaceRule#getLocale()
+  getLocale() {
+    return FR_LOCALE;
+  }
+}

package/src/lang/fr/rules/SuggestionsFilter.js

@@ -0,0 +1,29 @@
+// org.languagetool.rules.fr.SuggestionsFilter
+import { registerClass } from '@valueerror/ltjs-core/src/core/resources/ClassBroker.js';
+import { Pattern } from '@valueerror/ltjs-core/src/lib/java/regex/index.js';
+import { RuleFilter } from '@valueerror/ltjs-core/src/core/patterns/RuleFilter.js';
+
+// Java: SuggestionsFilter
+export class SuggestionsFilter extends RuleFilter {
+  static FQCN = 'org.languagetool.rules.fr.SuggestionsFilter';
+  static JAVA_ABSTRACT = false;
+  static JAVA_CONSTRUCTORS = [{ params: [], text: 'public org.languagetool.rules.fr.SuggestionsFilter()' }];
+
+  // Java: SuggestionsFilter#acceptRuleMatch(RuleMatch,Map,int,AnalyzedTokenReadings[],List)
+  acceptRuleMatch(match, arguments_) {
+    const removeSuggestionsRegexp = this.getRequired('RemoveSuggestionsRegexp', arguments_);
+    const ruleMatch = match;
+    const replacements = match.getSuggestedReplacements();
+    const newReplacements = [];
+    const p = Pattern.compile(removeSuggestionsRegexp, Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE);
+    for (const r of replacements) {
+      if (!p.matcher(r).matches()) {
+        newReplacements.push(r);
+      }
+    }
+    ruleMatch.setSuggestedReplacements(newReplacements);
+    return ruleMatch;
+  }
+}
+
+registerClass(SuggestionsFilter.FQCN, SuggestionsFilter);

package/src/lang/fr/rules/WordWithDeterminerFilter.js

@@ -0,0 +1,168 @@
+// org.languagetool.rules.fr.WordWithDeterminerFilter
+import { registerClass } from '@valueerror/ltjs-core/src/core/resources/ClassBroker.js';
+import { IllegalArgumentException, RuntimeException } from '@valueerror/ltjs-core/src/lib/java/errors.js';
+import { Integer } from '@valueerror/ltjs-core/src/lib/java/int.js';
+import { listGet } from '@valueerror/ltjs-core/src/lib/java/arrays.js';
+import { Pattern } from '@valueerror/ltjs-core/src/lib/java/regex/index.js';
+import { equalsIgnoreCase, javaMatches, javaReplace, toUpperCase } from '@valueerror/ltjs-core/src/lib/java/strings.js';
+import { Languages } from '@valueerror/ltjs-core/src/core/Languages.js';
+import { RuleMatch } from '@valueerror/ltjs-core/src/core/rules/model/RuleMatch.js';
+import { RuleFilter } from '@valueerror/ltjs-core/src/core/patterns/RuleFilter.js';
+import { isAllUppercase, isCapitalizedWord, uppercaseFirstChar } from '@valueerror/ltjs-core/src/core/text/StringTools.js';
+import { FrenchSynthesizer } from '../synthesis/FrenchSynthesizer.js';
+
+const detPattern = Pattern.compile('(P.)?D .*|J .*|V.* ppa .*'); // Java: WordWithDeterminerFilter#detPattern
+const wordPattern = Pattern.compile('[ZNJ] .*|V.* ppa .*'); // Java: WordWithDeterminerFilter#wordPattern
+// 0=MS, 1=FS, 2=MP, 3=FP
+const genderNumber = ['([me]) (s|sp)', '([fe]) (s|sp)', '([me]) (p|sp)', '([fe]) (p|sp)']; // Java: WordWithDeterminerFilter#genderNumber
+const determiner = '((P.)?D |J |V.* ppa )'; // Java: WordWithDeterminerFilter#determiner
+const exceptionsDeterminer = ['bels', 'fols', 'mols', 'nouvels']; // Java: WordWithDeterminerFilter#exceptionsDeterminer
+const categoryToCheck = 'CAT_ELISION'; // Java: WordWithDeterminerFilter#categoryToCheck
+const rulesToCheck = ['CET_CE', 'CE_CET', 'MA_VOYELLE', 'MON_NFS', 'VIEUX']; // Java: WordWithDeterminerFilter#rulesToCheck
+
+// Java: WordWithDeterminerFilter (create suggestions for: determiner + noun/adjective)
+export class WordWithDeterminerFilter extends RuleFilter {
+  static FQCN = 'org.languagetool.rules.fr.WordWithDeterminerFilter';
+  static JAVA_ABSTRACT = false;
+  static JAVA_CONSTRUCTORS = [{ params: [], text: 'public org.languagetool.rules.fr.WordWithDeterminerFilter()' }];
+
+  // Java: WordWithDeterminerFilter#acceptRuleMatch(RuleMatch,Map,int,AnalyzedTokenReadings[],List)
+  acceptRuleMatch(match, arguments_, patternTokenPos, patternTokens) {
+    const lt = Languages.getLanguageForShortCode('fr').createDefaultJLanguageTool();
+    const wordFrom = this.getRequired('wordFrom', arguments_);
+    const determinerFrom = this.getRequired('determinerFrom', arguments_);
+    let posWord = 0;
+    let posDeterminer = 0;
+    if (wordFrom !== null && determinerFrom !== null) {
+      posWord = Integer.parseInt(wordFrom);
+      if (posWord < 1 || posWord > patternTokens.length) {
+        throw new IllegalArgumentException('WordWithDeterminerFilter: Index out of bounds in '
+            + match.getRule().getFullId() + ', wordFrom: ' + posWord);
+      }
+      posDeterminer = Integer.parseInt(determinerFrom);
+      if (posDeterminer < 1 || posDeterminer > patternTokens.length) {
+        throw new IllegalArgumentException('WordWithDeterminerFilter: Index out of bounds in '
+            + match.getRule().getFullId() + ', posDeterminer: ' + posWord);
+      }
+    } else {
+      throw new IllegalArgumentException('WordWithDeterminerFilter: undefined parameters wordFrom or determinerFrom in '
+          + match.getRule().getFullId());
+    }
+    const atrDeterminer = patternTokens[posDeterminer - 1];
+    const atrWord = patternTokens[posWord - 1];
+    const isDeterminerCapitalized = isCapitalizedWord(atrDeterminer.getToken());
+    const isWordCapitalized = isCapitalizedWord(atrWord.getToken());
+    const isDeterminerAllupper = isAllUppercase(atrDeterminer.getToken())
+        && !equalsIgnoreCase(atrDeterminer.getToken(), "L'");
+    const isWordAllupper = isAllUppercase(atrWord.getToken());
+    const atDeterminer = this.getAnalyzedToken(atrDeterminer, detPattern);
+    const atWord = this.getAnalyzedToken(atrWord, wordPattern);
+    if (atWord === null || atDeterminer === null) {
+      throw new RuntimeException(
+          "Error analyzing sentence: '" + match.getSentence().getText() + "' with rule " + match.getRule().getFullId());
+    }
+    const isNoun = atWord.getPOSTag().startsWith('N') || atWord.getPOSTag().startsWith('Z');
+    const isAdjective = atWord.getPOSTag().startsWith('J');
+
+    let prefix = '[ZNJ] ';
+    if (isNoun && !isAdjective) {
+      prefix = '[NZ] ';
+    } else if (!isNoun && isAdjective) {
+      prefix = 'J ';
+    }
+
+    // synthesize all forms
+    const determinerForms = new Array(4);
+    const wordForms = new Array(4);
+    for (let i = 0; i < 4; i++) {
+      determinerForms[i] = FrenchSynthesizer.INSTANCE.synthesize(atDeterminer, determiner + genderNumber[i], true);
+      wordForms[i] = FrenchSynthesizer.INSTANCE.synthesize(atWord, prefix + genderNumber[i], true);
+      // if it cannot be synthesyzed, keep the original determiner
+      if (determinerForms[i].length === 0 && javaMatches(atDeterminer.getPOSTag(), '.+' + genderNumber[i])) {
+        determinerForms[i] = [atDeterminer.getToken()];
+      }
+      // if it cannot be synthesyzed, keep the original word
+      if (wordForms[i].length === 0 && javaMatches(atWord.getPOSTag(), '.+' + genderNumber[i])) {
+        wordForms[i] = [atWord.getToken()];
+      }
+    }
+    // generate suggestions
+    const replacements = [];
+    for (let i = 0; i < 4; i++) {
+      for (let cw = 0; cw < wordForms[i].length; cw++) {
+        for (let cd = 0; cd < determinerForms[i].length; cd++) {
+          if (exceptionsDeterminer.includes(determinerForms[i][cd])) {
+            continue;
+          }
+          if (determinerForms[i][cd] != null && wordForms[i][cw] != null) {
+            let det = determinerForms[i][cd];
+            let word = wordForms[i][cw];
+            if (isDeterminerCapitalized) {
+              det = uppercaseFirstChar(det);
+            }
+            if (isWordCapitalized) {
+              word = uppercaseFirstChar(word);
+            }
+            if (isDeterminerAllupper) {
+              det = toUpperCase(det);
+            }
+            if (isWordAllupper) {
+              word = toUpperCase(word);
+            }
+            let r = det + ' ' + word;
+            r = javaReplace(r, "' ", "'");
+            // remove suggestions with errors
+            if (this.suggestionHasNoErrors(r, lt) && !replacements.includes(r)) {
+              if (r.endsWith(atWord.getToken())) {
+                replacements.unshift(r);
+              } else {
+                replacements.push(r);
+              }
+            }
+          }
+        }
+      }
+    }
+    const message = match.getMessage();
+    const ruleMatch = new RuleMatch(match.getRule(), match.getSentence(), match.getFromPos(), match.getToPos(),
+        message, match.getShortMessage());
+    ruleMatch.setType(match.getType());
+    // add existing suggestion in the XML rule
+    replacements.splice(0, 0, ...match.getSuggestedReplacements());
+    if (replacements.length > 0) {
+      ruleMatch.setSuggestedReplacements(replacements);
+    }
+    return ruleMatch;
+  }
+
+  // Java: WordWithDeterminerFilter#suggestionHasNoErrors(String,JLanguageTool)
+  suggestionHasNoErrors(newSuggestion, lt) {
+    const analyzedSentence = listGet(lt.analyzeText(newSuggestion), 0);
+    for (const r of lt.getAllActiveRules()) {
+      if (r.getCategory().getId().toString() === categoryToCheck || rulesToCheck.includes(r.getId())) {
+        const matches = r.match(analyzedSentence);
+        if (matches.length > 0) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+
+  // Java: WordWithDeterminerFilter#getAnalyzedToken(AnalyzedTokenReadings,Pattern)
+  getAnalyzedToken(aToken, pattern) {
+    for (const analyzedToken of aToken) {
+      let posTag = analyzedToken.getPOSTag();
+      if (posTag === null) {
+        posTag = 'UNKNOWN';
+      }
+      const m = pattern.matcher(posTag);
+      if (m.matches()) {
+        return analyzedToken;
+      }
+    }
+    return null;
+  }
+}
+
+registerClass(WordWithDeterminerFilter.FQCN, WordWithDeterminerFilter);

package/src/lang/fr/synthesis/FrenchSynthesizer.js

@@ -0,0 +1,36 @@
+// Java: org.languagetool.synthesis.FrenchSynthesizer
+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 { toLowerCase } from '@valueerror/ltjs-core/src/lib/java/strings.js';
+
+const exceptionsEgrave = ['burkinabè', 'koinè', 'épistémè'];
+
+// Java: FrenchSynthesizer
+export class FrenchSynthesizer extends BaseSynthesizer {
+  static FQCN = 'org.languagetool.synthesis.FrenchSynthesizer';
+
+  // Java: FrenchSynthesizer#INSTANCE
+  static get INSTANCE() {
+    return sharedComponent(FrenchSynthesizer.FQCN);
+  }
+
+  // Java: FrenchSynthesizer#FrenchSynthesizer() (the deprecated (Language) constructor delegates here)
+  constructor() {
+    super('fr/fr.sor', '/fr/french_synth.dict', '/fr/french_tags.txt', 'fr');
+  }
+
+  // Java: FrenchSynthesizer#isException(String)
+  isException(w) {
+    // remove: qq, qqe...
+    if (w.startsWith('qq')) {
+      return true;
+    }
+    // informè V ind pres 1 s
+    if (w.endsWith('è') && !exceptionsEgrave.includes(toLowerCase(w))) {
+      return true;
+    }
+    return false;
+  }
+}
+
+registerComponent(FrenchSynthesizer.FQCN, () => new FrenchSynthesizer());

package/src/lang/fr/tagging/FrenchHybridDisambiguator.js

@@ -0,0 +1,28 @@
+// org.languagetool.tagging.disambiguation.fr.FrenchHybridDisambiguator (spelling_global chunker, multiword chunker, then XML rules)
+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 { French } from '../language/French.js';
+
+// Java: FrenchHybridDisambiguator
+export class FrenchHybridDisambiguator extends AbstractDisambiguator {
+  static FQCN = 'org.languagetool.tagging.disambiguation.fr.FrenchHybridDisambiguator';
+
+  // Java: FrenchHybridDisambiguator#FrenchHybridDisambiguator() (field initialisers run before the constructor body)
+  constructor() {
+    super();
+    this.chunker = MultiWordChunker.getInstance('/fr/multiwords.txt', true, true, false);
+    this.disambiguator = new XmlRuleDisambiguator(French.getInstance(), true);
+    this.chunkerGlobal = MultiWordChunker.getInstance('/spelling_global.txt', false, true, false, MultiWordChunker.tagForNotAddingTags);
+    this.chunker.setRemovePreviousTags(true);
+    this.chunkerGlobal.setIgnoreSpelling(true);
+  }
+
+  // Java: FrenchHybridDisambiguator#disambiguate(AnalyzedSentence) / disambiguate(AnalyzedSentence,CheckCancelledCallback)
+  disambiguate(input, checkCanceled = null) {
+    return this.disambiguator.disambiguate(this.chunker.disambiguate(this.chunkerGlobal.disambiguate(input, checkCanceled), checkCanceled), checkCanceled);
+  }
+}
+
+registerComponent(FrenchHybridDisambiguator.FQCN, () => new FrenchHybridDisambiguator());

package/src/lang/fr/tagging/FrenchTagger.js

@@ -0,0 +1,176 @@
+// Java: org.languagetool.tagging.fr.FrenchTagger
+import { NullPointerException } from '@valueerror/ltjs-core/src/lib/java/errors.js';
+import { Locale } from '@valueerror/ltjs-core/src/lib/java/Locale.js';
+import { Pattern } from '@valueerror/ltjs-core/src/lib/java/regex/index.js';
+import { toLowerCase } from '@valueerror/ltjs-core/src/lib/java/strings.js';
+import { AnalyzedToken } from '@valueerror/ltjs-core/src/core/AnalyzedToken.js';
+import { AnalyzedTokenReadings } from '@valueerror/ltjs-core/src/core/AnalyzedTokenReadings.js';
+import { ChunkTag } from '@valueerror/ltjs-core/src/core/chunking/ChunkTag.js';
+import { registerComponent, sharedComponent } from '@valueerror/ltjs-core/src/core/language/components.js';
+import { BaseTagger } from '@valueerror/ltjs-core/src/core/tagging/BaseTagger.js';
+import { convertToTitleCaseIteratingChars, isAllUppercase, isCapitalizedWord, isEmoji } from '@valueerror/ltjs-core/src/core/text/StringTools.js';
+
+const VERB = Pattern.compile('V .+');
+const PREFIXES_FOR_VERBS = Pattern.compile(
+  '(auto|auto-|re-|sur-)([^-].*[aeiouêàéèíòóïü].+[aeiouêàéèíòóïü].*)', Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE);
+const NOUN_ADJ = Pattern.compile('[NJ] .+|V ppa.*');
+const PREFIXES_NOUN_ADJ = Pattern.compile(
+  '(post-|sur-|mini-|méga-|demi-|péri-|anti-|géo-|nord-|sud-|néo-|méga-|ultra-|pro-|inter-|micro-|macro-|sous-|haut-|auto-|ré-|pré-|super-|vice-|hyper-|proto-|grand-|pseudo-)(.+)',
+  Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE);
+const PREFIXES_FOR_NOUN_ADJ = Pattern.compile(
+  '(mini|méga)([^-].*[aeiouêàéèíòóïü].+[aeiouêàéèíòóïü].*)', Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE);
+
+const AMBIGOUS_TOKENS = ['-Le', '-Les', '-La', '-Elle', '-Elles', '-On', '-Tu', '-Vous', '-Il', '-Ils', '-Ce'];
+
+// Java: FrenchTagger
+export class FrenchTagger extends BaseTagger {
+  static FQCN = 'org.languagetool.tagging.fr.FrenchTagger';
+
+  // Java: FrenchTagger#INSTANCE
+  static get INSTANCE() {
+    return sharedComponent(FrenchTagger.FQCN);
+  }
+
+  // Java: FrenchTagger#FrenchTagger()
+  constructor() {
+    super('/fr/french.dict', Locale.FRENCH, false);
+  }
+
+  // Java: FrenchTagger#overwriteWithManualTagger()
+  overwriteWithManualTagger() {
+    return false;
+  }
+
+  // Java: FrenchTagger#tag(List)
+  tag(sentenceTokens) {
+    const tokenReadings = [];
+    let pos = 0;
+    for (let word of sentenceTokens) {
+      if (word === null || word === undefined) throw new NullPointerException('Cannot invoke "String.length()" because "word" is null');
+      let containsTypewriterApostrophe = false;
+      let containsTypographicApostrophe = false;
+      if (word.length > 1) {
+        if (word.includes("'")) {
+          containsTypewriterApostrophe = true;
+        }
+        if (word.includes('’')) {
+          containsTypographicApostrophe = true;
+          word = word.replaceAll('’', "'");
+        }
+      }
+      let l = this.tagWord(word, word);
+      if (l.length === 0 && toLowerCase(word).includes('oe')) {
+        l = this.tagWord(word.replaceAll('oe', 'œ').replaceAll('OE', 'Œ'), word);
+      }
+      if (l.length === 0 && isEmoji(word)) {
+        l.push(new AnalyzedToken(word, '_emoji_', '_emoji_'));
+      }
+      if (l.length === 0) {
+        l.push(new AnalyzedToken(word, null, null));
+      }
+      const atr = new AnalyzedTokenReadings(l, pos);
+      if (containsTypewriterApostrophe) {
+        atr.setChunkTags([new ChunkTag('containsTypewriterApostrophe')]);
+      }
+      if (containsTypographicApostrophe) {
+        atr.setChunkTags([new ChunkTag('containsTypographicApostrophe')]);
+      }
+      tokenReadings.push(atr);
+      pos += word.length;
+    }
+    return tokenReadings;
+  }
+
+  // Java: FrenchTagger#tagWord(String,String)
+  tagWord(word, originalWord) {
+    const l = [];
+    const lowerWord = toLowerCase(word, this.locale);
+    const isStartUpper = isCapitalizedWord(word);
+    const isAllUpper = isAllUppercase(word);
+    const isHyphenatedTitleCase = !AMBIGOUS_TOKENS.includes(originalWord)
+      && originalWord.includes('-') && originalWord === convertToTitleCaseIteratingChars(lowerWord);
+    l.push(...this.asAnalyzedTokenListForTaggedWords(originalWord, this.getWordTagger().tag(word)));
+    if (isAllUpper || isStartUpper || isHyphenatedTitleCase) {
+      l.push(...this.asAnalyzedTokenListForTaggedWords(originalWord, this.getWordTagger().tag(lowerWord)));
+    }
+    if (l.length === 0 && isAllUpper) {
+      const firstUpper = convertToTitleCaseIteratingChars(lowerWord);
+      l.push(...this.asAnalyzedTokenListForTaggedWords(originalWord, this.getWordTagger().tag(firstUpper)));
+    }
+    if (l.length === 0) {
+      const add = this.additionalTags(word);
+      if (add !== null) l.push(...add);
+    }
+    return l;
+  }
+
+  // Java: FrenchTagger#additionalTags(String)
+  additionalTags(word) {
+    let additionalTaggedTokens = [];
+    let matcher = PREFIXES_FOR_VERBS.matcher(word);
+    if (matcher.matches()) {
+      const possibleVerb = toLowerCase(matcher.group(2));
+      const taggerTokens = this.asAnalyzedTokenListForTaggedWords(word, this.getWordTagger().tag(possibleVerb));
+      for (const taggerToken of taggerTokens) {
+        const posTag = taggerToken.getPOSTag();
+        if (posTag !== null) {
+          if (VERB.matcher(posTag).matches()) {
+            const lemma = toLowerCase(matcher.group(1)) + taggerToken.getLemma();
+            additionalTaggedTokens.push(new AnalyzedToken(word, posTag, lemma));
+          }
+        }
+      }
+      if (additionalTaggedTokens.length > 0) {
+        return additionalTaggedTokens;
+      }
+    }
+    matcher = PREFIXES_FOR_NOUN_ADJ.matcher(word);
+    if (matcher.matches()) {
+      const possibleNoun = toLowerCase(matcher.group(2));
+      const taggerTokens = this.asAnalyzedTokenListForTaggedWords(word, this.getWordTagger().tag(possibleNoun));
+      for (const taggerToken of taggerTokens) {
+        const posTag = taggerToken.getPOSTag();
+        if (posTag !== null) {
+          if (NOUN_ADJ.matcher(posTag).matches()) {
+            const lemma = toLowerCase(matcher.group(1)) + taggerToken.getLemma();
+            additionalTaggedTokens.push(new AnalyzedToken(word, posTag, lemma));
+          }
+        }
+      }
+      if (additionalTaggedTokens.length > 0) {
+        return additionalTaggedTokens;
+      }
+    }
+    matcher = PREFIXES_NOUN_ADJ.matcher(word);
+    if (matcher.matches()) {
+      const possibleNoun = toLowerCase(matcher.group(2));
+      let taggerTokens = this.asAnalyzedTokenListForTaggedWords(word, this.getWordTagger().tag(possibleNoun));
+      for (const taggerToken of taggerTokens) {
+        const posTag = taggerToken.getPOSTag();
+        if (posTag !== null) {
+          if (NOUN_ADJ.matcher(posTag).matches()) {
+            const lemma = toLowerCase(matcher.group(1)) + taggerToken.getLemma();
+            additionalTaggedTokens.push(new AnalyzedToken(word, posTag, lemma));
+          }
+        }
+      }
+      if (additionalTaggedTokens.length === 0) {
+        taggerTokens = this.asAnalyzedTokenListForTaggedWords(word, this.getWordTagger().tag(toLowerCase(possibleNoun)));
+        for (const taggerToken of taggerTokens) {
+          const posTag = taggerToken.getPOSTag();
+          if (posTag !== null) {
+            if (NOUN_ADJ.matcher(posTag).matches()) {
+              const lemma = toLowerCase(matcher.group(1)) + taggerToken.getLemma();
+              additionalTaggedTokens.push(new AnalyzedToken(word, posTag, lemma));
+            }
+          }
+        }
+      }
+      return additionalTaggedTokens;
+    }
+    additionalTaggedTokens = null;
+    return additionalTaggedTokens;
+  }
+}
+
+registerComponent(FrenchTagger.FQCN, () => new FrenchTagger());