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

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

@@ -0,0 +1,31 @@
+// org.languagetool.rules.fr.DMYDateCheckFilter
+import { registerClass } from '@valueerror/ltjs-core/src/core/resources/ClassBroker.js';
+import { RuntimeException } from '@valueerror/ltjs-core/src/lib/java/errors.js';
+import { javaSplit } from '@valueerror/ltjs-core/src/lib/java/strings.js';
+import { DateCheckFilter } from './DateCheckFilter.js';
+
+// Java: DMYDateCheckFilter
+export class DMYDateCheckFilter extends DateCheckFilter {
+  static FQCN = 'org.languagetool.rules.fr.DMYDateCheckFilter';
+  static JAVA_ABSTRACT = false;
+  static JAVA_CONSTRUCTORS = [{ params: [], text: 'public org.languagetool.rules.fr.DMYDateCheckFilter()' }];
+
+  // Java: DMYDateCheckFilter#acceptRuleMatch(RuleMatch,Map,int,AnalyzedTokenReadings[],List)
+  acceptRuleMatch(match, args, patternTokenPos, patternTokens, tokenPositions) {
+    if (args.containsKey('year') || args.containsKey('month') || args.containsKey('day')) {
+      throw new RuntimeException("Set only 'weekDay' and 'date' for " + 'DMYDateCheckFilter');
+    }
+    const dateString = this.getRequired('date', args);
+    const parts = javaSplit(dateString, '-');
+    if (parts.length !== 3) {
+      throw new RuntimeException("Expected date in format 'dd-mm-yyyy': '" + dateString + "'");
+    }
+    args.put('day', parts[0]);
+    args.put('month', parts[1]);
+    args.put('year', parts[2]);
+    // DEV-017: parent expects token indexes; the wrapper's text values are checked as weekday vs. date text
+    return this.acceptRuleMatchFromText(match, args);
+  }
+}
+
+registerClass(DMYDateCheckFilter.FQCN, DMYDateCheckFilter);

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

@@ -0,0 +1,35 @@
+// org.languagetool.rules.fr.DateCheckFilter
+import { registerClass } from '@valueerror/ltjs-core/src/core/resources/ClassBroker.js';
+import { AbstractDateCheckWithSuggestionsFilter } from '@valueerror/ltjs-core/src/core/rules/AbstractDateCheckWithSuggestionsFilter.js';
+import { DateFilterHelper } from './DateFilterHelper.js';
+
+// Java: DateCheckFilter
+export class DateCheckFilter extends AbstractDateCheckWithSuggestionsFilter {
+  static FQCN = 'org.languagetool.rules.fr.DateCheckFilter';
+  static JAVA_ABSTRACT = false;
+  static JAVA_CONSTRUCTORS = [{ params: [], text: 'public org.languagetool.rules.fr.DateCheckFilter()' }];
+
+  dateFilterHelper = new DateFilterHelper();
+
+  // Java: DateCheckFilter#getMonth(String)
+  getMonth(localizedMonth) {
+    return this.dateFilterHelper.getMonth(localizedMonth);
+  }
+
+  // Java: DateCheckFilter#getCalendar()
+  getCalendar() {
+    return this.dateFilterHelper.getCalendar();
+  }
+
+  // Java: DateCheckFilter#getDayOfWeek(String) and #getDayOfWeek(Calendar) (overloads, one JS method dispatching on the argument type)
+  getDayOfWeek(arg) {
+    return this.dateFilterHelper.getDayOfWeek(arg);
+  }
+
+  // Java: DateCheckFilter#getErrorMessageWrongYear()
+  getErrorMessageWrongYear() {
+    return 'Cette date est incorrecte. Faites-vous référence à l\'année "{currentYear}" ?';
+  }
+}
+
+registerClass(DateCheckFilter.FQCN, DateCheckFilter);

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

@@ -0,0 +1,55 @@
+// org.languagetool.rules.fr.DateFilterHelper (package-private)
+import { Calendar } from '@valueerror/ltjs-core/src/lib/java/Calendar.js';
+import { Locale } from '@valueerror/ltjs-core/src/lib/java/Locale.js';
+import { RuntimeException } from '@valueerror/ltjs-core/src/lib/java/errors.js';
+import { toLowerCase } from '@valueerror/ltjs-core/src/lib/java/strings.js';
+
+// Java: DateFilterHelper
+export class DateFilterHelper {
+  static FQCN = 'org.languagetool.rules.fr.DateFilterHelper';
+
+  // Java: DateFilterHelper#getCalendar()
+  getCalendar() {
+    return Calendar.getInstance(Locale.FRENCH);
+  }
+
+  // Java: DateFilterHelper#getDayOfWeek(String) and #getDayOfWeek(Calendar) (overloads, one JS method dispatching on the argument type)
+  getDayOfWeek(arg) {
+    if (arg instanceof Calendar) {
+      return arg.getDisplayName(Calendar.DAY_OF_WEEK, Calendar.LONG, Locale.FRENCH);
+    }
+    const dayStr = arg;
+    const day = toLowerCase(dayStr);
+    if (day.startsWith('dim')) return Calendar.SUNDAY;
+    if (day.startsWith('lun')) return Calendar.MONDAY;
+    if (day.startsWith('mar')) return Calendar.TUESDAY;
+    if (day.startsWith('mer')) return Calendar.WEDNESDAY;
+    if (day.startsWith('jeu')) return Calendar.THURSDAY;
+    if (day.startsWith('ven')) return Calendar.FRIDAY;
+    if (day.startsWith('sam')) return Calendar.SATURDAY;
+    throw new RuntimeException("Could not find day of week for '" + dayStr + "'");
+  }
+
+  // Java: DateFilterHelper#getMonth(String)
+  getMonth(monthStr) {
+    const mon = toLowerCase(monthStr);
+    if (mon.startsWith('jan')) return 1;
+    if (mon.startsWith('fév')) return 2;
+    if (mon.startsWith('fev')) return 2;
+    if (mon.startsWith('mar')) return 3;
+    if (mon.startsWith('avr')) return 4;
+    if (mon.startsWith('mai')) return 5;
+    // "juin" and "juillet" are never abbreviated with 3 letters
+    // since it would be ambiguous (both start with "jui").
+    if (mon.startsWith('juin')) return 6;
+    if (mon.startsWith('juil')) return 7;
+    if (mon.startsWith('aou') ||
+        mon.startsWith('aoû')) return 8;
+    if (mon.startsWith('sep')) return 9;
+    if (mon.startsWith('oct')) return 10;
+    if (mon.startsWith('nov')) return 11;
+    if (mon.startsWith('déc')) return 12;
+    if (mon.startsWith('dec')) return 12;
+    throw new RuntimeException("Could not find month '" + monthStr + "'");
+  }
+}

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

@@ -0,0 +1,80 @@
+// org.languagetool.rules.fr.FindSuggestionsFilter
+import { registerClass } from '@valueerror/ltjs-core/src/core/resources/ClassBroker.js';
+import { Pattern } from '@valueerror/ltjs-core/src/lib/java/regex/index.js';
+import { arrayGet } from '@valueerror/ltjs-core/src/lib/java/arrays.js';
+import { javaSplit, substring } from '@valueerror/ltjs-core/src/lib/java/strings.js';
+import { AnalyzedSentence } from '@valueerror/ltjs-core/src/core/AnalyzedSentence.js';
+import { AnalyzedToken } from '@valueerror/ltjs-core/src/core/AnalyzedToken.js';
+import { AnalyzedTokenReadings } from '@valueerror/ltjs-core/src/core/AnalyzedTokenReadings.js';
+import { AbstractFindSuggestionsFilter } from '@valueerror/ltjs-core/src/core/rules/AbstractFindSuggestionsFilter.js';
+import { makeWrong } from '@valueerror/ltjs-core/src/core/text/StringTools.js';
+import { FrenchSynthesizer } from '../synthesis/FrenchSynthesizer.js';
+import { FrenchTagger } from '../tagging/FrenchTagger.js';
+import { French } from './FrenchLazy.js';
+
+const ENDS_IN_VOWEL = Pattern.compile('[aeioué]$'); // Java: FindSuggestionsFilter#ENDS_IN_VOWEL
+const PATTERN = Pattern.compile("^[smntl]'|^(nous|vous|le|la|les|me|te|se|leur|en|y) "); // Java: FindSuggestionsFilter#PATTERN
+
+// Java: FindSuggestionsFilter
+export class FindSuggestionsFilter extends AbstractFindSuggestionsFilter {
+  static FQCN = 'org.languagetool.rules.fr.FindSuggestionsFilter';
+  static JAVA_ABSTRACT = false;
+  static JAVA_CONSTRUCTORS = [{ params: [], text: 'public org.languagetool.rules.fr.FindSuggestionsFilter() throws java.io.IOException' }];
+
+  // Java: FindSuggestionsFilter#FindSuggestionsFilter()
+  constructor() {
+    super();
+    this.morfologikRule = French.getInstance().getDefaultSpellingRule();
+  }
+
+  // Java: FindSuggestionsFilter#getTagger()
+  getTagger() {
+    return FrenchTagger.INSTANCE;
+  }
+
+  // Java: FindSuggestionsFilter#getSynthesizer()
+  getSynthesizer() {
+    return FrenchSynthesizer.INSTANCE;
+  }
+
+  // Java: FindSuggestionsFilter#getSpellingSuggestions(AnalyzedTokenReadings)
+  getSpellingSuggestions(atr) {
+    let w;
+    if (atr.isTagged()) {
+      w = makeWrong(atr.getToken());
+    } else {
+      w = atr.getToken();
+    }
+    const suggestions = [];
+    const wordsToCheck = [];
+    wordsToCheck.push(w);
+    if (w.endsWith('s')) {
+      wordsToCheck.push(substring(w, 0, w.length - 1));
+    }
+    if (ENDS_IN_VOWEL.matcher(w).matches()) {
+      wordsToCheck.push(w + 's');
+    }
+    for (const word of wordsToCheck) {
+      const atk = new Array(1);
+      const token = new AnalyzedToken(word, null, null);
+      atk[0] = new AnalyzedTokenReadings(token);
+      const sentence = new AnalyzedSentence(atk);
+      const matches = this.morfologikRule.match(sentence);
+      if (matches.length > 0) {
+        suggestions.push(...matches[0].getSuggestedReplacements());
+      }
+    }
+    return suggestions;
+  }
+
+  // Java: FindSuggestionsFilter#cleanSuggestion(String)
+  cleanSuggestion(s) {
+    // remove pronouns before verbs
+    let output = PATTERN.matcher(s).replaceAll('');
+    // check only first element
+    output = arrayGet(javaSplit(output, ' '), 0);
+    return output;
+  }
+}
+
+registerClass(FindSuggestionsFilter.FQCN, FindSuggestionsFilter);

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

@@ -0,0 +1,9 @@
+// Lazy access to French (import cycle French -> rules -> French); same class as the Java static import
+import { getClassBroker } from '@valueerror/ltjs-core/src/core/resources/LtStatics.js';
+
+export const French = {
+  // Java: French#getInstance()
+  getInstance() {
+    return getClassBroker().forName('org.languagetool.language.French').getInstance();
+  },
+};

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

@@ -0,0 +1,15 @@
+// org.languagetool.rules.fr.FrenchMultitokenSpeller
+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: FrenchMultitokenSpeller (INSTANCE is the shared component 'org.languagetool.rules.fr.FrenchMultitokenSpeller')
+export class FrenchMultitokenSpeller extends MultitokenSpeller {
+  static FQCN = 'org.languagetool.rules.fr.FrenchMultitokenSpeller';
+
+  // Java: FrenchMultitokenSpeller()
+  constructor() {
+    super(Languages.getLanguageForShortCode('fr'), ['/fr/multiwords.txt', '/spelling_global.txt', '/fr/hyphenated_words.txt']);
+  }
+}
+registerComponent(FrenchMultitokenSpeller.FQCN, () => new FrenchMultitokenSpeller());

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

@@ -0,0 +1,29 @@
+// org.languagetool.rules.fr.FrenchNumberInWordFilter
+import { registerClass } from '@valueerror/ltjs-core/src/core/resources/ClassBroker.js';
+import { AbstractNumberInWordFilter } from '@valueerror/ltjs-core/src/core/rules/AbstractNumberInWordFilter.js';
+import { French } from './FrenchLazy.js';
+
+// Java: FrenchNumberInWordFilter
+export class FrenchNumberInWordFilter extends AbstractNumberInWordFilter {
+  static FQCN = 'org.languagetool.rules.fr.FrenchNumberInWordFilter';
+  static JAVA_ABSTRACT = false;
+  static JAVA_CONSTRUCTORS = [{ params: [], text: 'public org.languagetool.rules.fr.FrenchNumberInWordFilter() throws java.io.IOException' }];
+
+  // Java: FrenchNumberInWordFilter#FrenchNumberInWordFilter()
+  constructor() {
+    super(French.getInstance());
+    this.frenchSpellerRule = French.getInstance().getDefaultSpellingRule();
+  }
+
+  // Java: FrenchNumberInWordFilter#isMisspelled(String)
+  isMisspelled(word) {
+    return this.frenchSpellerRule.isMisspelled(word);
+  }
+
+  // Java: FrenchNumberInWordFilter#getSuggestions(String)
+  getSuggestions(word) {
+    return this.frenchSpellerRule.getSpellingSuggestions(word);
+  }
+}
+
+registerClass(FrenchNumberInWordFilter.FQCN, FrenchNumberInWordFilter);

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

@@ -0,0 +1,29 @@
+// org.languagetool.rules.fr.FrenchPartialPosTagFilter
+import { registerClass } from '@valueerror/ltjs-core/src/core/resources/ClassBroker.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';
+import { French } from './FrenchLazy.js';
+
+// Java: FrenchPartialPosTagFilter
+export class FrenchPartialPosTagFilter extends PartialPosTagFilter {
+  static FQCN = 'org.languagetool.rules.fr.FrenchPartialPosTagFilter';
+  static JAVA_ABSTRACT = false;
+  static JAVA_CONSTRUCTORS = [{ params: [], text: 'public org.languagetool.rules.fr.FrenchPartialPosTagFilter()' }];
+
+  // Java: FrenchPartialPosTagFilter#tag(String)
+  tag(token) {
+    try {
+      const frenchLanguage = French.getInstance();
+      const tags = frenchLanguage.getTagger().tag([token]);
+      const atr = [...tags];
+      const disambiguated = frenchLanguage.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(FrenchPartialPosTagFilter.FQCN, FrenchPartialPosTagFilter);

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

@@ -0,0 +1,76 @@
+// org.languagetool.rules.fr.FrenchRepeatedWordsRule
+import { AbstractRepeatedWordsRule } from '@valueerror/ltjs-core/src/core/rules/AbstractRepeatedWordsRule.js';
+import { replaceOnce } from '@valueerror/ltjs-core/src/lib/java/StringUtils.js';
+import { getClassBroker } from '@valueerror/ltjs-core/src/core/resources/LtStatics.js';
+import { FrenchSynthesizer } from '../synthesis/FrenchSynthesizer.js';
+
+let wordsToCheck = null; // Java: static wordsToCheck = loadWords("/fr/synonyms.txt")
+
+// Java: FrenchRepeatedWordsRule
+export class FrenchRepeatedWordsRule extends AbstractRepeatedWordsRule {
+  static FQCN = 'org.languagetool.rules.fr.FrenchRepeatedWordsRule';
+
+  // Java: FrenchRepeatedWordsRule(ResourceBundle)
+  constructor(messages) {
+    super(messages, getClassBroker().forName('org.languagetool.language.French').getInstance());
+    if (wordsToCheck === null) wordsToCheck = AbstractRepeatedWordsRule.loadWords('/fr/synonyms.txt');
+    // super.setDefaultTempOff();
+  }
+
+  // Java: FrenchRepeatedWordsRule#getMessage()
+  getMessage() {
+    return "Ce mot apparaît déjà dans l'une des phrases précédant immédiatement celle-ci. Utilisez un synonyme pour apporter plus de variété à votre texte, excepté si la répétition est intentionnelle.";
+  }
+
+  // Java: FrenchRepeatedWordsRule#getDescription()
+  getDescription() {
+    return ('Synonymes de mots répétés.');
+  }
+
+  // Java: FrenchRepeatedWordsRule#getWordsToCheck()
+  getWordsToCheck() {
+    return wordsToCheck;
+  }
+
+  // Java: FrenchRepeatedWordsRule#getShortMessage()
+  getShortMessage() {
+    return 'Style : Mot répété';
+  }
+
+  // Java: FrenchRepeatedWordsRule#getSynthesizer()
+  getSynthesizer() {
+    return FrenchSynthesizer.INSTANCE;
+  }
+
+  // Java: FrenchRepeatedWordsRule#adjustPostag(String)
+  adjustPostag(postag) {
+    if (postag.endsWith('e sp')) {
+      return replaceOnce(postag, 'e sp', '. .*');
+    } else if (postag.endsWith('m s')) {
+      return replaceOnce(postag, 'm s', '[me] sp?');
+    } else if (postag.endsWith('f s')) {
+      return replaceOnce(postag, 'f s', '[fe] sp?');
+    } else if (postag.endsWith('m p')) {
+      return replaceOnce(postag, 'm p', '[me] s?p');
+    } else if (postag.endsWith('f p')) {
+      return replaceOnce(postag, 'f p', '[fe] s?p');
+    } else if (postag.endsWith('e s')) {
+      return replaceOnce(postag, 'e s', '[me] sp?'); // also F ?
+    } else if (postag.endsWith('e p')) {
+      return replaceOnce(postag, 'e p', '[me] s?p'); // also F ?
+    } else if (postag.endsWith('m sp')) {
+      return replaceOnce(postag, 'm sp', '[me] s?p?');
+    } else if (postag.endsWith('f sp')) {
+      return replaceOnce(postag, 'f sp', '[fe] s?p?');
+    }
+    return postag;
+  }
+
+  // Java: FrenchRepeatedWordsRule#isException(AnalyzedTokenReadings[],int,boolean,boolean,boolean)
+  isException(tokens, i, sentStart, isCapitalized, isAllUppercase) {
+    if (isAllUppercase || (isCapitalized && !sentStart)) {
+      return true;
+    }
+    return tokens[i].hasPosTagStartingWith('Z');
+  }
+}

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

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

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

@@ -0,0 +1,159 @@
+// org.languagetool.rules.fr.InterrogativeVerbFilter
+import { registerClass } from '@valueerror/ltjs-core/src/core/resources/ClassBroker.js';
+import { IllegalArgumentException } from '@valueerror/ltjs-core/src/lib/java/errors.js';
+import { Integer } from '@valueerror/ltjs-core/src/lib/java/int.js';
+import { equalsIgnoreCase, javaReplace, substring } from '@valueerror/ltjs-core/src/lib/java/strings.js';
+import { AnalyzedSentence } from '@valueerror/ltjs-core/src/core/AnalyzedSentence.js';
+import { AnalyzedToken } from '@valueerror/ltjs-core/src/core/AnalyzedToken.js';
+import { AnalyzedTokenReadings } from '@valueerror/ltjs-core/src/core/AnalyzedTokenReadings.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 { preserveCase } from '@valueerror/ltjs-core/src/core/text/StringTools.js';
+import { FrenchSynthesizer } from '../synthesis/FrenchSynthesizer.js';
+import { FrenchTagger } from '../tagging/FrenchTagger.js';
+import { French } from './FrenchLazy.js';
+
+// Java: InterrogativeVerbFilter
+export class InterrogativeVerbFilter extends RuleFilter {
+  static FQCN = 'org.languagetool.rules.fr.InterrogativeVerbFilter';
+  static JAVA_ABSTRACT = false;
+  static JAVA_CONSTRUCTORS = [{ params: [], text: 'public org.languagetool.rules.fr.InterrogativeVerbFilter() throws java.io.IOException' }];
+
+  // Java: InterrogativeVerbFilter#InterrogativeVerbFilter()
+  constructor() {
+    super();
+    this.morfologikRule = French.getInstance().getDefaultSpellingRule();
+  }
+
+  // Java: InterrogativeVerbFilter#acceptRuleMatch(RuleMatch,Map,int,AnalyzedTokenReadings[],List)
+  acceptRuleMatch(match, arguments_, patternTokenPos, patternTokens) {
+    const replacements = [];
+    const pronounFrom = this.getRequired('PronounFrom', arguments_);
+    const verbFrom = this.getRequired('VerbFrom', arguments_);
+    let desiredPostag = null;
+    const extraSuggestions = [];
+    if (pronounFrom !== null && verbFrom !== null) {
+      const posPronoun = Integer.parseInt(pronounFrom);
+      if (posPronoun < 1 || posPronoun > patternTokens.length) {
+        throw new IllegalArgumentException('ConfusionCheckFilter: Index out of bounds in ' + match.getRule().getFullId()
+            + ', PronounFrom: ' + posPronoun);
+      }
+      const posVerb = Integer.parseInt(verbFrom);
+      if (posVerb < 1 || posVerb > patternTokens.length) {
+        throw new IllegalArgumentException(
+            'ConfusionCheckFilter: Index out of bounds in ' + match.getRule().getFullId() + ', VerbFrom: ' + posVerb);
+      }
+      const atrPronoun = patternTokens[posPronoun - 1];
+
+      // vous
+      if (atrPronoun.matchesPosTagRegex('R pers obj 2 p')) {
+        desiredPostag = 'V.* (imp) [23] [sp]|V .*(ind|cond).* 2 p';
+      } else if (atrPronoun.matchesPosTagRegex('R pers obj 1 p')) { // nous
+        desiredPostag = 'V.* (imp) .*|V .*(ind|cond).* 1 p';
+      } else if (atrPronoun.matchesPosTagRegex('R pers obj.*')) { // moi, toi, le, la, lui, nous, vous, les, leur
+        desiredPostag = 'V.* (imp) .*';
+      } else if (atrPronoun.matchesPosTagRegex('.* 1 s')) {
+        desiredPostag = 'V .*(ind|cond).* 1 s';
+        const atrVerb = patternTokens[posVerb - 1];
+        const reading = atrVerb.readingWithTagRegex('V .*');
+        if (reading !== null) {
+          const participles = FrenchSynthesizer.INSTANCE.synthesize(reading, 'V ppa [me] sp?', true);
+          if (participles.length > 0) {
+            if (participles[0].endsWith('é')) {
+              extraSuggestions.push(participles[0]);
+              extraSuggestions.push(substring(participles[0], 0, participles[0].length - 1) + 'è');
+            }
+          }
+        }
+      } else if (atrPronoun.matchesPosTagRegex('.* 2 s')) {
+        desiredPostag = 'V .*(ind|cond).* 2 s';
+      } else if (atrPronoun.matchesPosTagRegex('.* 3( [mfe])? s')) {
+        desiredPostag = 'V .*(ind|cond).* 3 s';
+      } else if (atrPronoun.matchesPosTagRegex('.* 1 p')) {
+        desiredPostag = 'V .*(ind|cond).* 1 p';
+      } else if (atrPronoun.matchesPosTagRegex('.* 2 p')) {
+        desiredPostag = 'V .*(ind|cond).* 2 p';
+      } else if (atrPronoun.matchesPosTagRegex('.* 3( [mf])? p')) {
+        desiredPostag = 'V .*(ind|cond).* 3 p';
+      }
+
+      // add: trompè-je and trompé-je for original sentence "trompe-je"
+      if (extraSuggestions.length > 0) {
+        for (const extraSuggestion of extraSuggestions) {
+          const separator = (atrPronoun.getToken().startsWith('-') ? '' : '-');
+          const completeSuggestion = extraSuggestion + separator + atrPronoun.getToken();
+          if (!replacements.includes(completeSuggestion)
+              && !completeSuggestion.endsWith('e-je')) { // exclude trompe-je
+            replacements.push(completeSuggestion);
+          }
+        }
+      } else if (desiredPostag !== null) {
+        const auxPatternTokens = new Array(1);
+        if (patternTokens[posVerb - 1].isTagged()) {
+          auxPatternTokens[0] = new AnalyzedTokenReadings(
+              new AnalyzedToken(this.makeWrong(patternTokens[posVerb - 1].getToken()), null, null));
+        } else {
+          auxPatternTokens[0] = patternTokens[posVerb - 1];
+        }
+        const sentence = new AnalyzedSentence(auxPatternTokens);
+        const matches = this.morfologikRule.match(sentence);
+        if (matches.length > 0) {
+          const suggestions = matches[0].getSuggestedReplacements();
+          const analyzedSuggestions = FrenchTagger.INSTANCE.tag(suggestions);
+          for (const analyzedSuggestion of analyzedSuggestions) {
+            if (analyzedSuggestion.matchesPosTagRegex(desiredPostag)) {
+              const separator = (atrPronoun.getToken().startsWith('-') ? '' : '-');
+              let completeSuggestion = analyzedSuggestion.getToken() + separator + atrPronoun.getToken();
+              if (equalsIgnoreCase(completeSuggestion, 'peux-je')) {
+                completeSuggestion = preserveCase('puis-je', completeSuggestion);
+              }
+              if (completeSuggestion.endsWith('e-je')) { // exclude trompe-je -> trompé-je, trompè-je
+                completeSuggestion = substring(completeSuggestion, 0, completeSuggestion.length - 4) + 'é-je';
+                if (!replacements.includes(completeSuggestion)) {
+                  replacements.push(completeSuggestion);
+                }
+                completeSuggestion = substring(completeSuggestion, 0, completeSuggestion.length - 4) + 'è-je';
+                if (!replacements.includes(completeSuggestion)) {
+                  replacements.push(completeSuggestion);
+                }
+              } else if (!replacements.includes(completeSuggestion)) {
+                replacements.push(completeSuggestion);
+              }
+            }
+          }
+        }
+      }
+    }
+
+    const message = match.getMessage();
+    const ruleMatch = new RuleMatch(match.getRule(), match.getSentence(), match.getFromPos(), match.getToPos(),
+        message, match.getShortMessage());
+    ruleMatch.setType(match.getType());
+    if (replacements.length > 0) {
+      ruleMatch.setSuggestedReplacements(replacements);
+    }
+    return ruleMatch;
+  }
+
+  // Java: InterrogativeVerbFilter#makeWrong(String)
+  makeWrong(s) {
+    /* this doesn't work for some cases: ex. tarta / trata */
+    if (s.includes('a')) { return javaReplace(s, 'a', 'ä'); }
+    if (s.includes('e')) { return javaReplace(s, 'e', 'ë'); }
+    if (s.includes('i')) { return javaReplace(s, 'i', 'í'); }
+    if (s.includes('o')) { return javaReplace(s, 'o', 'ö'); }
+    if (s.includes('u')) { return javaReplace(s, 'u', 'ü'); }
+    if (s.includes('é')) { return javaReplace(s, 'é', 'ë'); }
+    if (s.includes('à')) { return javaReplace(s, 'à', 'ä'); }
+    if (s.includes('è')) { return javaReplace(s, 'è', 'ë'); }
+    if (s.includes('ù')) { return javaReplace(s, 'ù', 'ü'); }
+    if (s.includes('â')) { return javaReplace(s, 'â', 'ä'); }
+    if (s.includes('ê')) { return javaReplace(s, 'ê', 'ë'); }
+    if (s.includes('î')) { return javaReplace(s, 'î', 'ï'); }
+    if (s.includes('ô')) { return javaReplace(s, 'ô', 'ö'); }
+    if (s.includes('û')) { return javaReplace(s, 'û', 'ü'); }
+    return s + '-';
+  }
+}
+
+registerClass(InterrogativeVerbFilter.FQCN, InterrogativeVerbFilter);

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

@@ -0,0 +1,32 @@
+// org.languagetool.rules.fr.MakeContractionsFilter
+import { registerClass } from '@valueerror/ltjs-core/src/core/resources/ClassBroker.js';
+import { Pattern } from '@valueerror/ltjs-core/src/lib/java/regex/index.js';
+import { AbstractMakeContractionsFilter } from '@valueerror/ltjs-core/src/core/rules/AbstractMakeContractionsFilter.js';
+
+const FLAGS = Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE | Pattern.UNICODE_CHARACTER_CLASS;
+const DE_LE = Pattern.compile('\\bde le\\b', FLAGS); // Java: MakeContractionsFilter#DE_LE
+const A_LE = Pattern.compile('\\bà le\\b', FLAGS); // Java: MakeContractionsFilter#A_LE
+const DE_LES = Pattern.compile('\\bde les\\b', FLAGS); // Java: MakeContractionsFilter#DE_LES
+const A_LES = Pattern.compile('\\bà les\\b', FLAGS); // Java: MakeContractionsFilter#A_LES
+
+// Java: MakeContractionsFilter
+export class MakeContractionsFilter extends AbstractMakeContractionsFilter {
+  static FQCN = 'org.languagetool.rules.fr.MakeContractionsFilter';
+  static JAVA_ABSTRACT = false;
+  static JAVA_CONSTRUCTORS = [{ params: [], text: 'public org.languagetool.rules.fr.MakeContractionsFilter()' }];
+
+  // Java: MakeContractionsFilter#fixContractions(String)
+  fixContractions(suggestion) {
+    let matcher = DE_LE.matcher(suggestion);
+    suggestion = matcher.replaceAll('du');
+    matcher = A_LE.matcher(suggestion);
+    suggestion = matcher.replaceAll('au');
+    matcher = DE_LES.matcher(suggestion);
+    suggestion = matcher.replaceAll('des');
+    matcher = A_LES.matcher(suggestion);
+    suggestion = matcher.replaceAll('aux');
+    return suggestion;
+  }
+}
+
+registerClass(MakeContractionsFilter.FQCN, MakeContractionsFilter);