@delali/narsil 0.1.14 → 0.2.0

package/dist/languages/french.mjs

@@ -1,462 +1,974 @@
-// src/languages/french.ts
-var VOWELS = "aeiouy\xE2\xE0\xEB\xE9\xE8\xEF\xEE\xF4\xF9\xFB\xFC";
-function isVowel(ch) {
-  return VOWELS.includes(ch);
-}
-function findRegions(word) {
-  let rv = word.length;
-  let r1 = word.length;
-  let r2 = word.length;
-  if (word.length >= 2 && isVowel(word[0]) && isVowel(word[1])) {
-    rv = 3;
-  } else if (word.startsWith("par") || word.startsWith("col") || word.startsWith("tap")) {
-    rv = 3;
-  } else {
-    for (let i = 1; i < word.length; i++) {
-      if (isVowel(word[i])) {
-        rv = i + 1;
-        break;
+import { BaseStemmer } from '../chunk-U2BKYEC7.mjs';
+
+// src/languages/snowball/french.ts
+var a_0 = [
+  ["col", -1],
+  ["ni", 1],
+  ["par", -1],
+  ["tap", -1]
+];
+var a_1 = [
+  ["", 7],
+  ["H", 6, 1],
+  ["He", 4, 1],
+  ["Hi", 5, 2],
+  ["I", 1, 4],
+  ["U", 2, 5],
+  ["Y", 3, 6]
+];
+var a_2 = [
+  ["iqU", 3],
+  ["abl", 3],
+  ["I\xE8r", 4],
+  ["i\xE8r", 4],
+  ["eus", 2],
+  ["iv", 1]
+];
+var a_3 = [
+  ["ic", 2],
+  ["abil", 1],
+  ["iv", 3]
+];
+var a_4 = [
+  ["iqUe", 1],
+  ["atrice", 2],
+  ["ance", 1],
+  ["ence", 5],
+  ["logie", 3],
+  ["able", 1],
+  ["isme", 1],
+  ["euse", 12],
+  ["iste", 1],
+  ["ive", 8],
+  ["if", 8],
+  ["usion", 4],
+  ["ation", 2],
+  ["ution", 4],
+  ["ateur", 2],
+  ["iqUes", 1],
+  ["atrices", 2],
+  ["ances", 1],
+  ["ences", 5],
+  ["logies", 3],
+  ["ables", 1],
+  ["ismes", 1],
+  ["euses", 12],
+  ["istes", 1],
+  ["ives", 8],
+  ["ifs", 8],
+  ["usions", 4],
+  ["ations", 2],
+  ["utions", 4],
+  ["ateurs", 2],
+  ["ments", 16],
+  ["ements", 6, 1],
+  ["issements", 13, 1],
+  ["it\xE9s", 7],
+  ["ment", 16],
+  ["ement", 6, 1],
+  ["issement", 13, 1],
+  ["amment", 14, 3],
+  ["emment", 15, 4],
+  ["aux", 10],
+  ["eaux", 9, 1],
+  ["eux", 1],
+  ["oux", 11],
+  ["it\xE9", 7]
+];
+var a_5 = [
+  ["ira", 1],
+  ["ie", 1],
+  ["isse", 1],
+  ["issante", 1],
+  ["i", 1],
+  ["irai", 1, 1],
+  ["ir", 1],
+  ["iras", 1],
+  ["ies", 1],
+  ["\xEEmes", 1],
+  ["isses", 1],
+  ["issantes", 1],
+  ["\xEEtes", 1],
+  ["is", 1],
+  ["irais", 1, 1],
+  ["issais", 1, 2],
+  ["irions", 1],
+  ["issions", 1],
+  ["irons", 1],
+  ["issons", 1],
+  ["issants", 1],
+  ["it", 1],
+  ["irait", 1, 1],
+  ["issait", 1, 2],
+  ["issant", 1],
+  ["iraIent", 1],
+  ["issaIent", 1],
+  ["irent", 1],
+  ["issent", 1],
+  ["iront", 1],
+  ["\xEEt", 1],
+  ["iriez", 1],
+  ["issiez", 1],
+  ["irez", 1],
+  ["issez", 1]
+];
+var a_6 = [
+  ["al", 1],
+  ["\xE9pl", -1],
+  ["auv", -1]
+];
+var a_7 = [
+  ["a", 3],
+  ["era", 2, 1],
+  ["aise", 4],
+  ["asse", 3],
+  ["ante", 3],
+  ["\xE9e", 2],
+  ["ai", 3],
+  ["erai", 2, 1],
+  ["er", 2],
+  ["as", 3],
+  ["eras", 2, 1],
+  ["\xE2mes", 3],
+  ["aises", 4],
+  ["asses", 3],
+  ["antes", 3],
+  ["\xE2tes", 3],
+  ["\xE9es", 2],
+  ["ais", 4],
+  ["eais", 2, 1],
+  ["erais", 2, 2],
+  ["ions", 1],
+  ["erions", 2, 1],
+  ["assions", 3, 2],
+  ["erons", 2],
+  ["ants", 3],
+  ["\xE9s", 2],
+  ["ait", 3],
+  ["erait", 2, 1],
+  ["ant", 3],
+  ["aIent", 3],
+  ["eraIent", 2, 1],
+  ["\xE8rent", 2],
+  ["assent", 3],
+  ["eront", 2],
+  ["\xE2t", 3],
+  ["ez", 2],
+  ["iez", 2, 1],
+  ["eriez", 2, 1],
+  ["assiez", 3, 2],
+  ["erez", 2, 4],
+  ["\xE9", 2]
+];
+var a_8 = [
+  ["e", 3],
+  ["I\xE8re", 2, 1],
+  ["i\xE8re", 2, 2],
+  ["ion", 1],
+  ["Ier", 2],
+  ["ier", 2]
+];
+var a_9 = [
+  ["ell", -1],
+  ["eill", -1],
+  ["enn", -1],
+  ["onn", -1],
+  ["ett", -1]
+];
+var g_v = [17, 65, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128, 130, 103, 8, 5];
+var g_oux_ending = [65, 85];
+var g_elision_char = [131, 14, 3];
+var g_keep_with_s = [1, 65, 20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 128];
+var FrenchStemmer = class extends BaseStemmer {
+  #stem() {
+    let a;
+    let I_p2;
+    let I_p1;
+    let I_pV;
+    const v_1 = this.c;
+    lab0: {
+      this.bra = this.c;
+      lab1: {
+        lab2: {
+          if (!this.in_grouping(g_elision_char, 99, 116)) break lab2;
+          break lab1;
+        }
+        if (!this.eq_s("qu")) break lab0;
       }
+      if (!this.eq_s("'")) break lab0;
+      this.ket = this.c;
+      if (
+        /**@type {boolean}*/
+        this.c >= this.limit
+      ) break lab0;
+      this.slice_del();
     }
-  }
-  for (let i = 0; i < word.length - 1; i++) {
-    if (isVowel(word[i]) && !isVowel(word[i + 1])) {
-      r1 = i + 2;
-      break;
-    }
-  }
-  for (let i = r1; i < word.length - 1; i++) {
-    if (isVowel(word[i]) && !isVowel(word[i + 1])) {
-      r2 = i + 2;
-      break;
-    }
-  }
-  return { rv, r1, r2 };
-}
-function markVowelConsonantForms(word) {
-  const chars = word.split("");
-  for (let i = 0; i < chars.length; i++) {
-    if (chars[i] === "u" && i > 0 && i < chars.length - 1 && isVowel(chars[i - 1]) && isVowel(chars[i + 1])) {
-      chars[i] = "U";
-    }
-    if (chars[i] === "i" && i > 0 && i < chars.length - 1 && isVowel(chars[i - 1]) && isVowel(chars[i + 1])) {
-      chars[i] = "I";
-    }
-    if (chars[i] === "y" && i > 0 && isVowel(chars[i - 1])) {
-      chars[i] = "Y";
-    }
-    if (chars[i] === "y" && i < chars.length - 1 && isVowel(chars[i + 1])) {
-      chars[i] = "Y";
-    }
-    if (chars[i] === "u" && i > 0 && chars[i - 1] === "q") {
-      chars[i] = "U";
-    }
-  }
-  return chars.join("");
-}
-function restoreMarkedLetters(word) {
-  return word.replace(/I/g, "i").replace(/U/g, "u").replace(/Y/g, "y");
-}
-function endsWith(word, suffix) {
-  return word.endsWith(suffix);
-}
-function removeSuffix(word, suffix) {
-  return word.slice(0, word.length - suffix.length);
-}
-function suffixInRegion(word, suffix, regionStart) {
-  return word.length - suffix.length >= regionStart;
-}
-function findLongestAmong(word, suffixes, regionStart) {
-  let longestMatch = null;
-  for (const suffix of suffixes) {
-    if (endsWith(word, suffix) && suffixInRegion(word, suffix, regionStart)) {
-      if (longestMatch === null || suffix.length > longestMatch.length) {
-        longestMatch = suffix;
+    this.c = v_1;
+    const v_2 = this.c;
+    while (true) {
+      const v_3 = this.c;
+      lab4: {
+        while (true) {
+          const v_4 = this.c;
+          lab6: {
+            lab7: {
+              const v_5 = this.c;
+              lab8: {
+                if (!this.in_grouping(g_v, 97, 251)) break lab8;
+                this.bra = this.c;
+                lab9: {
+                  const v_6 = this.c;
+                  lab10: {
+                    if (!this.eq_s("u")) break lab10;
+                    this.ket = this.c;
+                    if (!this.in_grouping(g_v, 97, 251)) break lab10;
+                    this.slice_from("U");
+                    break lab9;
+                  }
+                  this.c = v_6;
+                  lab11: {
+                    if (!this.eq_s("i")) break lab11;
+                    this.ket = this.c;
+                    if (!this.in_grouping(g_v, 97, 251)) break lab11;
+                    this.slice_from("I");
+                    break lab9;
+                  }
+                  this.c = v_6;
+                  if (!this.eq_s("y")) break lab8;
+                  this.ket = this.c;
+                  this.slice_from("Y");
+                }
+                break lab7;
+              }
+              this.c = v_5;
+              lab12: {
+                this.bra = this.c;
+                if (!this.eq_s("\xEB")) break lab12;
+                this.ket = this.c;
+                this.slice_from("He");
+                break lab7;
+              }
+              this.c = v_5;
+              lab13: {
+                this.bra = this.c;
+                if (!this.eq_s("\xEF")) break lab13;
+                this.ket = this.c;
+                this.slice_from("Hi");
+                break lab7;
+              }
+              this.c = v_5;
+              lab14: {
+                this.bra = this.c;
+                if (!this.eq_s("y")) break lab14;
+                this.ket = this.c;
+                if (!this.in_grouping(g_v, 97, 251)) break lab14;
+                this.slice_from("Y");
+                break lab7;
+              }
+              this.c = v_5;
+              if (!this.eq_s("q")) break lab6;
+              this.bra = this.c;
+              if (!this.eq_s("u")) break lab6;
+              this.ket = this.c;
+              this.slice_from("U");
+            }
+            this.c = v_4;
+            break;
+          }
+          this.c = v_4;
+          if (this.c >= this.limit) break lab4;
+          this.c++;
+        }
+        continue;
       }
+      this.c = v_3;
+      break;
     }
-  }
-  return longestMatch;
-}
-function step1StandardSuffix(word, rv, r1, r2) {
-  const standardSuffixes = [
-    "issements",
-    "issement",
-    "atrices",
-    "atrice",
-    "ateurs",
-    "ateur",
-    "ations",
-    "ation",
-    "usions",
-    "ution",
-    "usion",
-    "utions",
-    "logies",
-    "logie",
-    "ements",
-    "ement",
-    "ences",
-    "ence",
-    "ances",
-    "ance",
-    "ables",
-    "able",
-    "ismes",
-    "isme",
-    "istes",
-    "iste",
-    "euses",
-    "euse",
-    "ments",
-    "ment",
-    "iqUes",
-    "iqUe",
-    "it\xE9s",
-    "it\xE9",
-    "ives",
-    "ive",
-    "eaux",
-    "ifs",
-    "if",
-    "aux",
-    "eux"
-  ];
-  const suffix = findLongestAmong(word, standardSuffixes, 0);
-  if (!suffix) return { word, changed: false };
-  if (["ance", "ances", "iqUe", "iqUes", "isme", "ismes", "able", "ables", "iste", "istes"].includes(suffix)) {
-    if (suffixInRegion(word, suffix, r2)) {
-      return { word: removeSuffix(word, suffix), changed: true };
-    }
-    return { word, changed: false };
-  }
-  if (["atrice", "atrices", "ateur", "ateurs", "ation", "ations"].includes(suffix)) {
-    if (suffixInRegion(word, suffix, r2)) {
-      word = removeSuffix(word, suffix);
-      if (endsWith(word, "ic")) {
-        if (suffixInRegion(word, "ic", r2)) {
-          word = removeSuffix(word, "ic");
-        } else {
-          word = `${removeSuffix(word, "ic")}iqU`;
+    this.c = v_2;
+    {
+      I_pV = this.limit;
+      I_p1 = this.limit;
+      I_p2 = this.limit;
+      const v_7 = this.c;
+      lab16: {
+        lab17: {
+          const v_8 = this.c;
+          lab18: {
+            if (!this.in_grouping(g_v, 97, 251)) break lab18;
+            if (!this.in_grouping(g_v, 97, 251)) break lab18;
+            if (this.c >= this.limit) break lab18;
+            this.c++;
+            break lab17;
+          }
+          this.c = v_8;
+          lab19: {
+            a = this.find_among(a_0);
+            if (a === 0) break lab19;
+            switch (a) {
+              case 1: {
+                if (!this.in_grouping(g_v, 97, 251)) break lab19;
+                break;
+              }
+            }
+            break lab17;
+          }
+          this.c = v_8;
+          if (this.c >= this.limit) break lab16;
+          this.c++;
+          if (!this.go_out_grouping(g_v, 97, 251)) break lab16;
+          this.c++;
         }
+        I_pV = this.c;
       }
-      return { word, changed: true };
-    }
-    return { word, changed: false };
-  }
-  if (["logie", "logies"].includes(suffix)) {
-    if (suffixInRegion(word, suffix, r2)) {
-      return { word: `${removeSuffix(word, suffix)}log`, changed: true };
-    }
-    return { word, changed: false };
-  }
-  if (["usion", "usions", "ution", "utions"].includes(suffix)) {
-    if (suffixInRegion(word, suffix, r2)) {
-      return { word: `${removeSuffix(word, suffix)}u`, changed: true };
-    }
-    return { word, changed: false };
-  }
-  if (["ence", "ences"].includes(suffix)) {
-    if (suffixInRegion(word, suffix, r2)) {
-      return { word: `${removeSuffix(word, suffix)}ent`, changed: true };
+      this.c = v_7;
+      const v_9 = this.c;
+      lab20: {
+        if (!this.go_out_grouping(g_v, 97, 251)) break lab20;
+        this.c++;
+        if (!this.go_in_grouping(g_v, 97, 251)) break lab20;
+        this.c++;
+        I_p1 = this.c;
+        if (!this.go_out_grouping(g_v, 97, 251)) break lab20;
+        this.c++;
+        if (!this.go_in_grouping(g_v, 97, 251)) break lab20;
+        this.c++;
+        I_p2 = this.c;
+      }
+      this.c = v_9;
     }
-    return { word, changed: false };
-  }
-  if (suffix === "ement" || suffix === "ements") {
-    if (suffixInRegion(word, suffix, rv)) {
-      word = removeSuffix(word, suffix);
-      if (endsWith(word, "iv") && suffixInRegion(word, "iv", r2)) {
-        word = removeSuffix(word, "iv");
-        if (endsWith(word, "at") && suffixInRegion(word, "at", r2)) {
-          word = removeSuffix(word, "at");
+    this.limit_backward = this.c;
+    this.c = this.limit;
+    const v_10 = this.limit - this.c;
+    lab21: {
+      lab22: {
+        const v_11 = this.limit - this.c;
+        lab23: {
+          const v_12 = this.limit - this.c;
+          lab24: {
+            const v_13 = this.limit - this.c;
+            lab25: {
+              this.ket = this.c;
+              a = this.find_among_b(a_4);
+              if (a === 0) break lab25;
+              this.bra = this.c;
+              switch (a) {
+                case 1: {
+                  if (
+                    /**@type {boolean}*/
+                    I_p2 > this.c
+                  ) break lab25;
+                  this.slice_del();
+                  break;
+                }
+                case 2: {
+                  if (
+                    /**@type {boolean}*/
+                    I_p2 > this.c
+                  ) break lab25;
+                  this.slice_del();
+                  const v_14 = this.limit - this.c;
+                  lab26: {
+                    this.ket = this.c;
+                    if (!this.eq_s_b("ic")) {
+                      this.c = this.limit - v_14;
+                      break lab26;
+                    }
+                    this.bra = this.c;
+                    lab27: {
+                      const v_15 = this.limit - this.c;
+                      lab28: {
+                        if (
+                          /**@type {boolean}*/
+                          I_p2 > this.c
+                        ) break lab28;
+                        this.slice_del();
+                        break lab27;
+                      }
+                      this.c = this.limit - v_15;
+                      this.slice_from("iqU");
+                    }
+                  }
+                  break;
+                }
+                case 3: {
+                  if (
+                    /**@type {boolean}*/
+                    I_p2 > this.c
+                  ) break lab25;
+                  this.slice_from("log");
+                  break;
+                }
+                case 4: {
+                  if (
+                    /**@type {boolean}*/
+                    I_p2 > this.c
+                  ) break lab25;
+                  this.slice_from("u");
+                  break;
+                }
+                case 5: {
+                  if (
+                    /**@type {boolean}*/
+                    I_p2 > this.c
+                  ) break lab25;
+                  this.slice_from("ent");
+                  break;
+                }
+                case 6: {
+                  if (
+                    /**@type {boolean}*/
+                    I_pV > this.c
+                  ) break lab25;
+                  this.slice_del();
+                  const v_16 = this.limit - this.c;
+                  lab29: {
+                    this.ket = this.c;
+                    a = this.find_among_b(a_2);
+                    if (a === 0) {
+                      this.c = this.limit - v_16;
+                      break lab29;
+                    }
+                    this.bra = this.c;
+                    switch (a) {
+                      case 1: {
+                        if (
+                          /**@type {boolean}*/
+                          I_p2 > this.c
+                        ) {
+                          this.c = this.limit - v_16;
+                          break lab29;
+                        }
+                        this.slice_del();
+                        this.ket = this.c;
+                        if (!this.eq_s_b("at")) {
+                          this.c = this.limit - v_16;
+                          break lab29;
+                        }
+                        this.bra = this.c;
+                        if (
+                          /**@type {boolean}*/
+                          I_p2 > this.c
+                        ) {
+                          this.c = this.limit - v_16;
+                          break lab29;
+                        }
+                        this.slice_del();
+                        break;
+                      }
+                      case 2: {
+                        lab30: {
+                          const v_17 = this.limit - this.c;
+                          lab31: {
+                            if (
+                              /**@type {boolean}*/
+                              I_p2 > this.c
+                            ) break lab31;
+                            this.slice_del();
+                            break lab30;
+                          }
+                          this.c = this.limit - v_17;
+                          if (
+                            /**@type {boolean}*/
+                            I_p1 > this.c
+                          ) {
+                            this.c = this.limit - v_16;
+                            break lab29;
+                          }
+                          this.slice_from("eux");
+                        }
+                        break;
+                      }
+                      case 3: {
+                        if (
+                          /**@type {boolean}*/
+                          I_p2 > this.c
+                        ) {
+                          this.c = this.limit - v_16;
+                          break lab29;
+                        }
+                        this.slice_del();
+                        break;
+                      }
+                      case 4: {
+                        if (
+                          /**@type {boolean}*/
+                          I_pV > this.c
+                        ) {
+                          this.c = this.limit - v_16;
+                          break lab29;
+                        }
+                        this.slice_from("i");
+                        break;
+                      }
+                    }
+                  }
+                  break;
+                }
+                case 7: {
+                  if (
+                    /**@type {boolean}*/
+                    I_p2 > this.c
+                  ) break lab25;
+                  this.slice_del();
+                  const v_18 = this.limit - this.c;
+                  lab32: {
+                    this.ket = this.c;
+                    a = this.find_among_b(a_3);
+                    if (a === 0) {
+                      this.c = this.limit - v_18;
+                      break lab32;
+                    }
+                    this.bra = this.c;
+                    switch (a) {
+                      case 1: {
+                        lab33: {
+                          const v_19 = this.limit - this.c;
+                          lab34: {
+                            if (
+                              /**@type {boolean}*/
+                              I_p2 > this.c
+                            ) break lab34;
+                            this.slice_del();
+                            break lab33;
+                          }
+                          this.c = this.limit - v_19;
+                          this.slice_from("abl");
+                        }
+                        break;
+                      }
+                      case 2: {
+                        lab35: {
+                          const v_20 = this.limit - this.c;
+                          lab36: {
+                            if (
+                              /**@type {boolean}*/
+                              I_p2 > this.c
+                            ) break lab36;
+                            this.slice_del();
+                            break lab35;
+                          }
+                          this.c = this.limit - v_20;
+                          this.slice_from("iqU");
+                        }
+                        break;
+                      }
+                      case 3: {
+                        if (
+                          /**@type {boolean}*/
+                          I_p2 > this.c
+                        ) {
+                          this.c = this.limit - v_18;
+                          break lab32;
+                        }
+                        this.slice_del();
+                        break;
+                      }
+                    }
+                  }
+                  break;
+                }
+                case 8: {
+                  if (
+                    /**@type {boolean}*/
+                    I_p2 > this.c
+                  ) break lab25;
+                  this.slice_del();
+                  const v_21 = this.limit - this.c;
+                  lab37: {
+                    this.ket = this.c;
+                    if (!this.eq_s_b("at")) {
+                      this.c = this.limit - v_21;
+                      break lab37;
+                    }
+                    this.bra = this.c;
+                    if (
+                      /**@type {boolean}*/
+                      I_p2 > this.c
+                    ) {
+                      this.c = this.limit - v_21;
+                      break lab37;
+                    }
+                    this.slice_del();
+                    this.ket = this.c;
+                    if (!this.eq_s_b("ic")) {
+                      this.c = this.limit - v_21;
+                      break lab37;
+                    }
+                    this.bra = this.c;
+                    lab38: {
+                      const v_22 = this.limit - this.c;
+                      lab39: {
+                        if (
+                          /**@type {boolean}*/
+                          I_p2 > this.c
+                        ) break lab39;
+                        this.slice_del();
+                        break lab38;
+                      }
+                      this.c = this.limit - v_22;
+                      this.slice_from("iqU");
+                    }
+                  }
+                  break;
+                }
+                case 9: {
+                  this.slice_from("eau");
+                  break;
+                }
+                case 10: {
+                  if (
+                    /**@type {boolean}*/
+                    I_p1 > this.c
+                  ) break lab25;
+                  this.slice_from("al");
+                  break;
+                }
+                case 11: {
+                  if (!this.in_grouping_b(g_oux_ending, 98, 112)) break lab25;
+                  this.slice_from("ou");
+                  break;
+                }
+                case 12: {
+                  lab40: {
+                    const v_23 = this.limit - this.c;
+                    lab41: {
+                      if (
+                        /**@type {boolean}*/
+                        I_p2 > this.c
+                      ) break lab41;
+                      this.slice_del();
+                      break lab40;
+                    }
+                    this.c = this.limit - v_23;
+                    if (
+                      /**@type {boolean}*/
+                      I_p1 > this.c
+                    ) break lab25;
+                    this.slice_from("eux");
+                  }
+                  break;
+                }
+                case 13: {
+                  if (
+                    /**@type {boolean}*/
+                    I_p1 > this.c
+                  ) break lab25;
+                  if (!this.out_grouping_b(g_v, 97, 251)) break lab25;
+                  this.slice_del();
+                  break;
+                }
+                case 14: {
+                  if (
+                    /**@type {boolean}*/
+                    I_pV > this.c
+                  ) break lab25;
+                  this.slice_from("ant");
+                  break lab25;
+                }
+                case 15: {
+                  if (
+                    /**@type {boolean}*/
+                    I_pV > this.c
+                  ) break lab25;
+                  this.slice_from("ent");
+                  break lab25;
+                }
+                case 16: {
+                  const v_24 = this.limit - this.c;
+                  if (!this.in_grouping_b(g_v, 97, 251)) break lab25;
+                  if (
+                    /**@type {boolean}*/
+                    I_pV > this.c
+                  ) break lab25;
+                  this.c = this.limit - v_24;
+                  this.slice_del();
+                  break lab25;
+                }
+              }
+              break lab24;
+            }
+            this.c = this.limit - v_13;
+            lab42: {
+              if (this.c < I_pV) break lab42;
+              const v_25 = this.limit_backward;
+              this.limit_backward = I_pV;
+              this.ket = this.c;
+              if (this.find_among_b(a_5) === 0) {
+                this.limit_backward = v_25;
+                break lab42;
+              }
+              this.bra = this.c;
+              lab43: {
+                if (!this.eq_s_b("H")) break lab43;
+                this.limit_backward = v_25;
+                break lab42;
+              }
+              if (!this.out_grouping_b(g_v, 97, 251)) {
+                this.limit_backward = v_25;
+                break lab42;
+              }
+              this.slice_del();
+              this.limit_backward = v_25;
+              break lab24;
+            }
+            this.c = this.limit - v_13;
+            if (this.c < I_pV) break lab23;
+            const v_26 = this.limit_backward;
+            this.limit_backward = I_pV;
+            this.ket = this.c;
+            a = this.find_among_b(a_7);
+            if (a === 0) {
+              this.limit_backward = v_26;
+              break lab23;
+            }
+            this.bra = this.c;
+            this.limit_backward = v_26;
+            switch (a) {
+              case 1: {
+                if (
+                  /**@type {boolean}*/
+                  I_p2 > this.c
+                ) break lab23;
+                this.slice_del();
+                break;
+              }
+              case 2: {
+                this.slice_del();
+                break;
+              }
+              case 3: {
+                const v_27 = this.limit - this.c;
+                lab44: {
+                  if (!this.eq_s_b("e")) {
+                    this.c = this.limit - v_27;
+                    break lab44;
+                  }
+                  if (
+                    /**@type {boolean}*/
+                    I_pV > this.c
+                  ) {
+                    this.c = this.limit - v_27;
+                    break lab44;
+                  }
+                  this.bra = this.c;
+                }
+                this.slice_del();
+                break;
+              }
+              case 4: {
+                {
+                  const v_28 = this.limit - this.c;
+                  lab45: {
+                    a = this.find_among_b(a_6);
+                    if (a === 0) break lab45;
+                    switch (a) {
+                      case 1: {
+                        if (this.c <= this.limit_backward) break lab45;
+                        this.c--;
+                        if (
+                          /**@type {boolean}*/
+                          this.c > this.limit_backward
+                        ) break lab45;
+                        break;
+                      }
+                    }
+                    break lab23;
+                  }
+                  this.c = this.limit - v_28;
+                }
+                this.slice_del();
+                break;
+              }
+            }
+          }
+          this.c = this.limit - v_12;
+          const v_29 = this.limit - this.c;
+          lab46: {
+            this.ket = this.c;
+            lab47: {
+              const v_30 = this.limit - this.c;
+              lab48: {
+                if (!this.eq_s_b("Y")) break lab48;
+                this.bra = this.c;
+                this.slice_from("i");
+                break lab47;
+              }
+              this.c = this.limit - v_30;
+              if (!this.eq_s_b("\xE7")) {
+                this.c = this.limit - v_29;
+                break lab46;
+              }
+              this.bra = this.c;
+              this.slice_from("c");
+            }
+          }
+          break lab22;
         }
-      } else if (endsWith(word, "eus")) {
-        if (suffixInRegion(word, "eus", r2)) {
-          word = removeSuffix(word, "eus");
-        } else if (suffixInRegion(word, "eus", r1)) {
-          word = `${removeSuffix(word, "eus")}eux`;
+        this.c = this.limit - v_11;
+        const v_31 = this.limit - this.c;
+        lab49: {
+          this.ket = this.c;
+          if (!this.eq_s_b("s")) {
+            this.c = this.limit - v_31;
+            break lab49;
+          }
+          this.bra = this.c;
+          const v_32 = this.limit - this.c;
+          lab50: {
+            lab51: {
+              if (!this.eq_s_b("Hi")) break lab51;
+              break lab50;
+            }
+            if (!this.out_grouping_b(g_keep_with_s, 97, 232)) {
+              this.c = this.limit - v_31;
+              break lab49;
+            }
+          }
+          this.c = this.limit - v_32;
+          this.slice_del();
         }
-      } else if (endsWith(word, "abl") && suffixInRegion(word, "abl", r2)) {
-        word = removeSuffix(word, "abl");
-      } else if (endsWith(word, "iqU") && suffixInRegion(word, "iqU", r2)) {
-        word = removeSuffix(word, "iqU");
-      } else if ((endsWith(word, "i\xE8r") || endsWith(word, "I\xE8r")) && suffixInRegion(word, "i\xE8r", rv)) {
-        const sSuffix = endsWith(word, "I\xE8r") ? "I\xE8r" : "i\xE8r";
-        word = `${removeSuffix(word, sSuffix)}i`;
-      }
-      return { word, changed: true };
-    }
-    return { word, changed: false };
-  }
-  if (["it\xE9", "it\xE9s"].includes(suffix)) {
-    if (suffixInRegion(word, suffix, r2)) {
-      word = removeSuffix(word, suffix);
-      if (endsWith(word, "abil") && suffixInRegion(word, "abil", r2)) {
-        word = removeSuffix(word, "abil");
-      } else if (endsWith(word, "abil")) {
-        word = `${removeSuffix(word, "abil")}abl`;
-      } else if (endsWith(word, "ic")) {
-        if (suffixInRegion(word, "ic", r2)) {
-          word = removeSuffix(word, "ic");
-        } else {
-          word = `${removeSuffix(word, "ic")}iqU`;
+        if (this.c < I_pV) break lab21;
+        const v_33 = this.limit_backward;
+        this.limit_backward = I_pV;
+        this.ket = this.c;
+        a = this.find_among_b(a_8);
+        if (a === 0) {
+          this.limit_backward = v_33;
+          break lab21;
         }
-      } else if (endsWith(word, "iv") && suffixInRegion(word, "iv", r2)) {
-        word = removeSuffix(word, "iv");
-      }
-      return { word, changed: true };
-    }
-    return { word, changed: false };
-  }
-  if (["if", "ifs", "ive", "ives"].includes(suffix)) {
-    if (suffixInRegion(word, suffix, r2)) {
-      word = removeSuffix(word, suffix);
-      if (endsWith(word, "at") && suffixInRegion(word, "at", r2)) {
-        word = removeSuffix(word, "at");
-        if (endsWith(word, "ic")) {
-          if (suffixInRegion(word, "ic", r2)) {
-            word = removeSuffix(word, "ic");
-          } else {
-            word = `${removeSuffix(word, "ic")}iqU`;
+        this.bra = this.c;
+        switch (a) {
+          case 1: {
+            if (
+              /**@type {boolean}*/
+              I_p2 > this.c
+            ) {
+              this.limit_backward = v_33;
+              break lab21;
+            }
+            lab52: {
+              lab53: {
+                if (!this.eq_s_b("s")) break lab53;
+                break lab52;
+              }
+              if (!this.eq_s_b("t")) {
+                this.limit_backward = v_33;
+                break lab21;
+              }
+            }
+            this.slice_del();
+            break;
+          }
+          case 2: {
+            this.slice_from("i");
+            break;
+          }
+          case 3: {
+            this.slice_del();
+            break;
           }
         }
+        this.limit_backward = v_33;
       }
-      return { word, changed: true };
     }
-    return { word, changed: false };
-  }
-  if (suffix === "eaux") {
-    return { word: `${removeSuffix(word, "eaux")}eau`, changed: true };
-  }
-  if (suffix === "aux") {
-    if (suffixInRegion(word, suffix, r1)) {
-      return { word: `${removeSuffix(word, "aux")}al`, changed: true };
-    }
-    return { word, changed: false };
-  }
-  if (["euse", "euses"].includes(suffix)) {
-    if (suffixInRegion(word, suffix, r2)) {
-      return { word: removeSuffix(word, suffix), changed: true };
-    }
-    if (suffixInRegion(word, suffix, r1)) {
-      return { word: `${removeSuffix(word, suffix)}eux`, changed: true };
+    this.c = this.limit - v_10;
+    const v_34 = this.limit - this.c;
+    lab54: {
+      const v_35 = this.limit - this.c;
+      if (this.find_among_b(a_9) === 0) break lab54;
+      this.c = this.limit - v_35;
+      this.ket = this.c;
+      if (this.c <= this.limit_backward) break lab54;
+      this.c--;
+      this.bra = this.c;
+      this.slice_del();
     }
-    return { word, changed: false };
-  }
-  if (suffix === "issement" || suffix === "issements") {
-    if (suffixInRegion(word, suffix, r1)) {
-      const stemmed = removeSuffix(word, suffix);
-      if (stemmed.length > 0 && !isVowel(stemmed[stemmed.length - 1])) {
-        return { word: stemmed, changed: true };
+    this.c = this.limit - v_34;
+    const v_36 = this.limit - this.c;
+    lab55: {
+      {
+        let v_37 = 1;
+        while (true) {
+          lab56: {
+            if (!this.out_grouping_b(g_v, 97, 251)) break lab56;
+            v_37--;
+            continue;
+          }
+          break;
+        }
+        if (v_37 > 0) break lab55;
       }
-    }
-    return { word, changed: false };
-  }
-  if (suffix === "amment") {
-    if (suffixInRegion(word, suffix, rv)) {
-      return { word: `${removeSuffix(word, "amment")}ant`, changed: true };
-    }
-    return { word, changed: false };
-  }
-  if (suffix === "emment") {
-    if (suffixInRegion(word, suffix, rv)) {
-      return { word: `${removeSuffix(word, "emment")}ent`, changed: true };
-    }
-    return { word, changed: false };
-  }
-  if (suffix === "ment" || suffix === "ments") {
-    if (suffixInRegion(word, suffix, rv)) {
-      const stemmed = removeSuffix(word, suffix);
-      if (stemmed.length > 0 && isVowel(stemmed[stemmed.length - 1])) {
-        return { word: stemmed, changed: true };
+      this.ket = this.c;
+      lab57: {
+        lab58: {
+          if (!this.eq_s_b("\xE9")) break lab58;
+          break lab57;
+        }
+        if (!this.eq_s_b("\xE8")) break lab55;
       }
+      this.bra = this.c;
+      this.slice_from("e");
     }
-    return { word, changed: false };
-  }
-  if (suffix === "eux") {
-    if (suffixInRegion(word, suffix, r2)) {
-      return { word: removeSuffix(word, suffix), changed: true };
-    }
-    return { word, changed: false };
-  }
-  return { word, changed: false };
-}
-function step2aIVerbSuffix(word, rv) {
-  const suffixes = [
-    "issantes",
-    "issante",
-    "issants",
-    "issant",
-    "issions",
-    "issons",
-    "issais",
-    "issait",
-    "issiez",
-    "issez",
-    "isses",
-    "isse",
-    "iraIent",
-    "issaIent",
-    "irions",
-    "iront",
-    "irais",
-    "irait",
-    "iriez",
-    "irons",
-    "irent",
-    "irez",
-    "irai",
-    "iras",
-    "\xEEmes",
-    "\xEEtes",
-    "ies",
-    "ira",
-    "ir",
-    "is",
-    "it",
-    "ie",
-    "i",
-    "\xEEt"
-  ];
-  const suffix = findLongestAmong(word, suffixes, rv);
-  if (!suffix) return { word, changed: false };
-  const stemmed = removeSuffix(word, suffix);
-  if (stemmed.length > 0 && !isVowel(stemmed[stemmed.length - 1]) && stemmed[stemmed.length - 1] !== "H") {
-    return { word: stemmed, changed: true };
-  }
-  return { word, changed: false };
-}
-function step2bOtherVerbSuffix(word, rv, r2) {
-  const group1Suffixes = [
-    "eraIent",
-    "erions",
-    "assions",
-    "assent",
-    "assiez",
-    "erais",
-    "erait",
-    "eriez",
-    "erons",
-    "eront",
-    "erez",
-    "antes",
-    "asses",
-    "eras",
-    "ante",
-    "asse",
-    "\xE2mes",
-    "\xE2tes",
-    "\xE9es",
-    "era",
-    "erai",
-    "ais",
-    "ait",
-    "ant",
-    "\xE9e",
-    "\xE9s",
-    "er",
-    "ez",
-    "ai",
-    "as",
-    "a",
-    "\xE9",
-    "\xE2t",
-    "\xE8rent"
-  ];
-  const ionsSuffix = "ions";
-  if (endsWith(word, ionsSuffix) && suffixInRegion(word, ionsSuffix, r2)) {
-    return { word: removeSuffix(word, ionsSuffix), changed: true };
-  }
-  const suffix = findLongestAmong(word, group1Suffixes, rv);
-  if (suffix) {
-    return { word: removeSuffix(word, suffix), changed: true };
-  }
-  return { word, changed: false };
-}
-function step3ResidualSuffix(word, rv, r2) {
-  if (endsWith(word, "s")) {
-    const beforeS = word.slice(0, -1);
-    if (beforeS.length > 0) {
-      const lastChar = beforeS[beforeS.length - 1];
-      if (lastChar !== "a" && lastChar !== "i" && lastChar !== "o" && lastChar !== "u" && lastChar !== "\xE8" && lastChar !== "s") {
-        word = beforeS;
+    this.c = this.limit - v_36;
+    this.c = this.limit_backward;
+    const v_38 = this.c;
+    while (true) {
+      const v_39 = this.c;
+      lab60: {
+        this.bra = this.c;
+        a = this.find_among(a_1);
+        this.ket = this.c;
+        switch (a) {
+          case 1: {
+            this.slice_from("i");
+            break;
+          }
+          case 2: {
+            this.slice_from("u");
+            break;
+          }
+          case 3: {
+            this.slice_from("y");
+            break;
+          }
+          case 4: {
+            this.slice_from("\xEB");
+            break;
+          }
+          case 5: {
+            this.slice_from("\xEF");
+            break;
+          }
+          case 6: {
+            this.slice_del();
+            break;
+          }
+          case 7: {
+            if (this.c >= this.limit) break lab60;
+            this.c++;
+            break;
+          }
+        }
+        continue;
       }
+      this.c = v_39;
+      break;
     }
+    this.c = v_38;
+    return true;
   }
-  const ionSuffix = "ion";
-  if (endsWith(word, ionSuffix) && suffixInRegion(word, ionSuffix, r2)) {
-    const stemmed = removeSuffix(word, ionSuffix);
-    if (stemmed.length > 0 && (stemmed[stemmed.length - 1] === "s" || stemmed[stemmed.length - 1] === "t") && suffixInRegion(word, ionSuffix, rv)) {
-      return stemmed;
-    }
-  }
-  const residualSuffixes = ["I\xE8re", "i\xE8re", "Ier", "ier"];
-  for (const suffix of residualSuffixes) {
-    if (endsWith(word, suffix) && suffixInRegion(word, suffix, rv)) {
-      return `${removeSuffix(word, suffix)}i`;
-    }
-  }
-  if (endsWith(word, "e") && suffixInRegion(word, "e", rv)) {
-    return removeSuffix(word, "e");
-  }
-  return word;
-}
-function step4Undouble(word) {
-  const doublePatterns = ["enn", "onn", "ett", "ell", "eill"];
-  for (const pattern of doublePatterns) {
-    if (endsWith(word, pattern)) {
-      return word.slice(0, -1);
-    }
-  }
-  return word;
-}
-function step5UnAccent(word) {
-  if (word.length < 2) return word;
-  const lastChar = word[word.length - 1];
-  const secondLastChar = word[word.length - 2];
-  if ((lastChar === "\xE9" || lastChar === "\xE8") && !isVowel(secondLastChar)) {
-    return `${word.slice(0, -1)}e`;
-  }
-  if (!isVowel(lastChar) && (secondLastChar === "\xE9" || secondLastChar === "\xE8")) {
-    return `${word.slice(0, -2)}e${lastChar}`;
-  }
-  return word;
-}
-function stem(word) {
-  if (word.length < 3) return word;
-  if (word[0] === "y") {
-    word = `Y${word.slice(1)}`;
-  }
-  word = markVowelConsonantForms(word);
-  const { rv, r1, r2 } = findRegions(word);
-  const step1Result = step1StandardSuffix(word, rv, r1, r2);
-  let stemChanged = step1Result.changed;
-  word = step1Result.word;
-  if (!stemChanged) {
-    const step2aResult = step2aIVerbSuffix(word, rv);
-    if (step2aResult.changed) {
-      word = step2aResult.word;
-      stemChanged = true;
-    } else {
-      const step2bResult = step2bOtherVerbSuffix(word, rv, r2);
-      word = step2bResult.word;
-      stemChanged = step2bResult.changed;
-    }
-  }
-  if (stemChanged) {
-    if (endsWith(word, "Y")) {
-      word = `${word.slice(0, -1)}i`;
-    }
-    if (endsWith(word, "\xE7")) {
-      word = `${word.slice(0, -1)}c`;
-    }
-  } else {
-    word = step3ResidualSuffix(word, rv, r2);
+  stem(input) {
+    this.setCurrent(input);
+    this.#stem();
+    return this.getCurrent();
   }
-  word = step4Undouble(word);
-  word = step5UnAccent(word);
-  word = restoreMarkedLetters(word);
-  return word.toLowerCase();
+};
+var shared = new FrenchStemmer();
+function stem(token) {
+  return shared.stem(token);
 }
+
+// src/languages/french.ts
 var stopWords = /* @__PURE__ */ new Set([
   "au",
   "aux",
@@ -625,10 +1137,11 @@ var stopWords = /* @__PURE__ */ new Set([
 ]);
 var french = {
   name: "french",
+  revision: "240a93ad04b96326",
   stemmer: stem,
   stopWords,
   tokenizer: {
-    splitPattern: /[^a-z0-9äâàéèëêïîöôùüûœç-]+/gi
+    splitPattern: /[^a-z0-9äâàéèëêïîöôùüûœçÿæ-]+/gi
   }
 };