@delali/narsil 0.1.15 → 0.2.0

package/dist/languages/romanian.mjs

@@ -1,404 +1,576 @@
-// src/languages/romanian.ts
-var VOWELS = "a\u0103\xE2ei\xEEou";
-var RE_UPPER_I = /I/g;
-var RE_UPPER_U = /U/g;
-var STEP0_SUFFIXES = [
-  "iilor",
-  "ilor",
-  "elor",
-  "ului",
-  "iile",
-  "atei",
-  "a\u021Bie",
-  "a\u021Bia",
-  "ele",
-  "ile",
-  "iei",
-  "ul",
-  "ea",
-  "ii",
-  "ua",
-  "iua",
-  "aua",
-  "a"
+import { withNormalisedSpellings } from '../chunk-GHJWC2E5.mjs';
+import { BaseStemmer } from '../chunk-U2BKYEC7.mjs';
+
+// src/languages/snowball/romanian.ts
+var a_0 = [
+  ["\u015F", 1],
+  ["\u0163", 2]
 ];
-var STEP1_SUFFIX_GROUPS = [
-  [["abilitate", "abilitati", "abilit\u0103\u021Bi", "abilita\u021Bi"].sort((a, b) => b.length - a.length), 1, "abil"],
-  [["ibilitate", "ibilitati", "ibilit\u0103\u021Bi", "ibilita\u021Bi"].sort((a, b) => b.length - a.length), 2, "ibil"],
-  [["ivitate", "ivitati", "ivit\u0103\u021Bi", "ivita\u021Bi"].sort((a, b) => b.length - a.length), 3, "iv"],
-  [
-    [
-      "ical\u0103",
-      "icale",
-      "icali",
-      "ical",
-      "ic\u0103",
-      "ice",
-      "ici",
-      "ic",
-      "icitate",
-      "icitati",
-      "icita\u021Bi",
-      "icit\u0103\u021Bi",
-      "iciva",
-      "icive",
-      "icivi",
-      "iciv",
-      "iciv\u0103",
-      "icator",
-      "icatori",
-      "icatoare",
-      "ic\u0103toare",
-      "ic\u0103tori"
-    ].sort((a, b) => b.length - a.length),
-    4,
-    "ic"
-  ],
-  [
-    ["ativ\u0103", "ative", "ativi", "ativ", "ativa", "a\u021Bie", "a\u021Biune", "ator", "atori", "atoare", "\u0103toare", "\u0103tori"].sort(
-      (a, b) => b.length - a.length
-    ),
-    5,
-    "at"
-  ],
-  [
-    ["itiv\u0103", "itive", "itivi", "itiv", "itiva", "i\u021Bie", "i\u021Biune", "itor", "itori", "itoare"].sort(
-      (a, b) => b.length - a.length
-    ),
-    6,
-    "it"
-  ]
+var as_0 = ["\u0219", "\u021B"];
+var a_1 = [
+  ["", 3],
+  ["I", 1, 1],
+  ["U", 2, 2]
 ];
-var STEP1_STANDARD_SUFFIXES = [
-  [["abil\u0103", "abile", "abili", "abil", "abila"].sort((a, b) => b.length - a.length), null],
-  [["ibil\u0103", "ibile", "ibili", "ibil", "ibila"].sort((a, b) => b.length - a.length), null],
-  [["oas\u0103", "oase", "oasa", "os", "o\u0219i"].sort((a, b) => b.length - a.length), null],
-  [
-    [
-      "at\u0103",
-      "ate",
-      "ati",
-      "at",
-      "ata",
-      "it\u0103",
-      "ite",
-      "iti",
-      "it",
-      "ita",
-      "ant\u0103",
-      "ante",
-      "anti",
-      "ant",
-      "anta",
-      "ut\u0103",
-      "ute",
-      "uti",
-      "ut",
-      "uta",
-      "iv\u0103",
-      "ive",
-      "ivi",
-      "iv",
-      "iva",
-      "iune",
-      "iuni",
-      "itate",
-      "itati",
-      "ita\u021Bi",
-      "it\u0103\u021Bi"
-    ].sort((a, b) => b.length - a.length),
-    null
-  ],
-  [["ist\u0103", "iste", "isti", "ist", "ista", "ism", "isme", "i\u0219ti"].sort((a, b) => b.length - a.length), "ist"]
+var a_2 = [
+  ["ea", 3],
+  ["a\u021Bia", 7],
+  ["aua", 2],
+  ["iua", 4],
+  ["a\u021Bie", 7],
+  ["ele", 3],
+  ["ile", 5],
+  ["iile", 4, 1],
+  ["iei", 4],
+  ["atei", 6],
+  ["ii", 4],
+  ["ului", 1],
+  ["ul", 1],
+  ["elor", 3],
+  ["ilor", 4],
+  ["iilor", 4, 1]
 ];
-var STEP2_SUFFIXES = [
-  "seser\u0103\u021Bi",
-  "aser\u0103\u021Bi",
-  "iser\u0103\u021Bi",
-  "user\u0103\u021Bi",
-  "\xE2ser\u0103\u021Bi",
-  "ser\u0103\u021Bi",
-  "seser\u0103m",
-  "aser\u0103m",
-  "iser\u0103m",
-  "user\u0103m",
-  "\xE2ser\u0103m",
-  "ser\u0103m",
-  "sese\u0219ti",
-  "ase\u0219ti",
-  "ise\u0219ti",
-  "use\u0219ti",
-  "\xE2se\u0219ti",
-  "se\u0219ti",
-  "ar\u0103\u021Bi",
-  "ir\u0103\u021Bi",
-  "ur\u0103\u021Bi",
-  "\xE2r\u0103\u021Bi",
-  "ar\u0103m",
-  "ir\u0103m",
-  "ur\u0103m",
-  "\xE2r\u0103m",
-  "ea\u021Bi",
-  "ia\u021Bi",
-  "a\u021Bi",
-  "eam",
-  "iam",
-  "am",
-  "eaz\u0103",
-  "e\u021Bi",
-  "i\u021Bi",
-  "\xE2\u021Bi",
-  "ar\u0103",
-  "ir\u0103",
-  "ur\u0103",
-  "\xE2r\u0103",
-  "ser\u0103",
-  "aser\u0103",
-  "iser\u0103",
-  "user\u0103",
-  "\xE2ser\u0103",
-  "seser\u0103",
-  "easc",
-  "esc",
-  "\u0103sc",
-  "e\u0219te",
-  "\u0103\u0219te",
-  "e\u0219ti",
-  "\u0103\u0219ti",
-  "are",
-  "ere",
-  "ire",
-  "\xE2re",
-  "ase",
-  "ise",
-  "use",
-  "\xE2se",
-  "sese",
-  "se",
-  "ind",
-  "\xE2nd",
-  "indu",
-  "\xE2ndu",
-  "eze",
-  "ezi",
-  "ez",
-  "eai",
-  "iai",
-  "ai",
-  "\xE2i",
-  "ui",
-  "sei",
-  "asem",
-  "isem",
-  "usem",
-  "\xE2sem",
-  "sesem",
-  "em",
-  "im",
-  "\xE2m",
-  "\u0103m",
-  "eau",
-  "iau",
-  "au",
-  "a\u0219i",
-  "i\u0219i",
-  "u\u0219i",
-  "\xE2\u0219i"
-].sort((a, b) => b.length - a.length);
-var STEP2_VERB_GROUP_SESE = /* @__PURE__ */ new Set([
-  "sese",
-  "sesem",
-  "sese\u0219ti",
-  "seser\u0103m",
-  "seser\u0103\u021Bi",
-  "se",
-  "sei",
-  "se\u0219ti",
-  "ser\u0103",
-  "seser\u0103",
-  "ser\u0103m",
-  "ser\u0103\u021Bi"
-]);
-var STEP3_SUFFIXES = ["ie", "\u0103", "e", "i", "a"];
-function isVowel(ch) {
-  return VOWELS.includes(ch);
-}
-function isLowerVowel(ch) {
-  return VOWELS.includes(ch) || ch === "I" || ch === "U";
-}
-function markVowelAsConsonant(word) {
-  const chars = word.split("");
-  for (let i = 1; i < chars.length - 1; i++) {
-    if (isVowel(chars[i - 1]) && isVowel(chars[i + 1])) {
-      if (chars[i] === "u") chars[i] = "U";
-      if (chars[i] === "i") chars[i] = "I";
+var a_3 = [
+  ["icala", 4],
+  ["iciva", 4],
+  ["ativa", 5],
+  ["itiva", 6],
+  ["icale", 4],
+  ["a\u021Biune", 5],
+  ["i\u021Biune", 6],
+  ["atoare", 5],
+  ["itoare", 6],
+  ["\u0103toare", 5],
+  ["icitate", 4],
+  ["abilitate", 1],
+  ["ibilitate", 2],
+  ["ivitate", 3],
+  ["icive", 4],
+  ["ative", 5],
+  ["itive", 6],
+  ["icali", 4],
+  ["atori", 5],
+  ["icatori", 4, 1],
+  ["itori", 6],
+  ["\u0103tori", 5],
+  ["icitati", 4],
+  ["abilitati", 1],
+  ["ivitati", 3],
+  ["icivi", 4],
+  ["ativi", 5],
+  ["itivi", 6],
+  ["icit\u0103i", 4],
+  ["abilit\u0103i", 1],
+  ["ivit\u0103i", 3],
+  ["icit\u0103\u021Bi", 4],
+  ["abilit\u0103\u021Bi", 1],
+  ["ivit\u0103\u021Bi", 3],
+  ["ical", 4],
+  ["ator", 5],
+  ["icator", 4, 1],
+  ["itor", 6],
+  ["\u0103tor", 5],
+  ["iciv", 4],
+  ["ativ", 5],
+  ["itiv", 6],
+  ["ical\u0103", 4],
+  ["iciv\u0103", 4],
+  ["ativ\u0103", 5],
+  ["itiv\u0103", 6]
+];
+var as_3 = ["abil", "ibil", "iv", "ic", "at", "it"];
+var a_4 = [
+  ["ica", 1],
+  ["abila", 1],
+  ["ibila", 1],
+  ["oasa", 1],
+  ["ata", 1],
+  ["ita", 1],
+  ["anta", 1],
+  ["ista", 3],
+  ["uta", 1],
+  ["iva", 1],
+  ["ic", 1],
+  ["ice", 1],
+  ["abile", 1],
+  ["ibile", 1],
+  ["isme", 3],
+  ["iune", 2],
+  ["oase", 1],
+  ["ate", 1],
+  ["itate", 1, 1],
+  ["ite", 1],
+  ["ante", 1],
+  ["iste", 3],
+  ["ute", 1],
+  ["ive", 1],
+  ["ici", 1],
+  ["abili", 1],
+  ["ibili", 1],
+  ["iuni", 2],
+  ["atori", 1],
+  ["osi", 1],
+  ["ati", 1],
+  ["itati", 1, 1],
+  ["iti", 1],
+  ["anti", 1],
+  ["isti", 3],
+  ["uti", 1],
+  ["i\u0219ti", 3],
+  ["ivi", 1],
+  ["it\u0103i", 1],
+  ["o\u0219i", 1],
+  ["it\u0103\u021Bi", 1],
+  ["abil", 1],
+  ["ibil", 1],
+  ["ism", 3],
+  ["ator", 1],
+  ["os", 1],
+  ["at", 1],
+  ["it", 1],
+  ["ant", 1],
+  ["ist", 3],
+  ["ut", 1],
+  ["iv", 1],
+  ["ic\u0103", 1],
+  ["abil\u0103", 1],
+  ["ibil\u0103", 1],
+  ["oas\u0103", 1],
+  ["at\u0103", 1],
+  ["it\u0103", 1],
+  ["ant\u0103", 1],
+  ["ist\u0103", 3],
+  ["ut\u0103", 1],
+  ["iv\u0103", 1]
+];
+var a_5 = [
+  ["ea", 1],
+  ["ia", 1],
+  ["esc", 1],
+  ["\u0103sc", 1],
+  ["ind", 1],
+  ["\xE2nd", 1],
+  ["are", 1],
+  ["ere", 1],
+  ["ire", 1],
+  ["\xE2re", 1],
+  ["se", 2],
+  ["ase", 1, 1],
+  ["sese", 2, 2],
+  ["ise", 1, 3],
+  ["use", 1, 4],
+  ["\xE2se", 1, 5],
+  ["e\u0219te", 1],
+  ["\u0103\u0219te", 1],
+  ["eze", 1],
+  ["ai", 1],
+  ["eai", 1, 1],
+  ["iai", 1, 2],
+  ["sei", 2],
+  ["e\u0219ti", 1],
+  ["\u0103\u0219ti", 1],
+  ["ui", 1],
+  ["ezi", 1],
+  ["\xE2i", 1],
+  ["a\u0219i", 1],
+  ["se\u0219i", 2],
+  ["ase\u0219i", 1, 1],
+  ["sese\u0219i", 2, 2],
+  ["ise\u0219i", 1, 3],
+  ["use\u0219i", 1, 4],
+  ["\xE2se\u0219i", 1, 5],
+  ["i\u0219i", 1],
+  ["u\u0219i", 1],
+  ["\xE2\u0219i", 1],
+  ["a\u021Bi", 2],
+  ["ea\u021Bi", 1, 1],
+  ["ia\u021Bi", 1, 2],
+  ["e\u021Bi", 2],
+  ["i\u021Bi", 2],
+  ["\xE2\u021Bi", 2],
+  ["ar\u0103\u021Bi", 1],
+  ["ser\u0103\u021Bi", 2],
+  ["aser\u0103\u021Bi", 1, 1],
+  ["seser\u0103\u021Bi", 2, 2],
+  ["iser\u0103\u021Bi", 1, 3],
+  ["user\u0103\u021Bi", 1, 4],
+  ["\xE2ser\u0103\u021Bi", 1, 5],
+  ["ir\u0103\u021Bi", 1],
+  ["ur\u0103\u021Bi", 1],
+  ["\xE2r\u0103\u021Bi", 1],
+  ["am", 1],
+  ["eam", 1, 1],
+  ["iam", 1, 2],
+  ["em", 2],
+  ["asem", 1, 1],
+  ["sesem", 2, 2],
+  ["isem", 1, 3],
+  ["usem", 1, 4],
+  ["\xE2sem", 1, 5],
+  ["im", 2],
+  ["\xE2m", 2],
+  ["\u0103m", 2],
+  ["ar\u0103m", 1, 1],
+  ["ser\u0103m", 2, 2],
+  ["aser\u0103m", 1, 1],
+  ["seser\u0103m", 2, 2],
+  ["iser\u0103m", 1, 3],
+  ["user\u0103m", 1, 4],
+  ["\xE2ser\u0103m", 1, 5],
+  ["ir\u0103m", 1, 8],
+  ["ur\u0103m", 1, 9],
+  ["\xE2r\u0103m", 1, 10],
+  ["au", 1],
+  ["eau", 1, 1],
+  ["iau", 1, 2],
+  ["indu", 1],
+  ["\xE2ndu", 1],
+  ["ez", 1],
+  ["easc\u0103", 1],
+  ["ar\u0103", 1],
+  ["ser\u0103", 2],
+  ["aser\u0103", 1, 1],
+  ["seser\u0103", 2, 2],
+  ["iser\u0103", 1, 3],
+  ["user\u0103", 1, 4],
+  ["\xE2ser\u0103", 1, 5],
+  ["ir\u0103", 1],
+  ["ur\u0103", 1],
+  ["\xE2r\u0103", 1],
+  ["eaz\u0103", 1]
+];
+var a_6 = [
+  ["a", 1],
+  ["e", 1],
+  ["ie", 1, 1],
+  ["i", 1],
+  ["\u0103", 1]
+];
+var g_v = [17, 65, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 32, 0, 0, 4];
+var RomanianStemmer = class extends BaseStemmer {
+  #stem() {
+    let a;
+    let B_standard_suffix_removed;
+    let I_p2;
+    let I_p1;
+    let I_pV;
+    {
+      const v_1 = this.c;
+      while (true) {
+        const v_2 = this.c;
+        lab2: {
+          while (true) {
+            const v_3 = this.c;
+            lab4: {
+              this.bra = this.c;
+              a = this.find_among(a_0);
+              if (a === 0) break lab4;
+              this.ket = this.c;
+              this.slice_from(as_0[a - 1]);
+              this.c = v_3;
+              break;
+            }
+            this.c = v_3;
+            if (this.c >= this.limit) break lab2;
+            this.c++;
+          }
+          continue;
+        }
+        this.c = v_2;
+        break;
+      }
+      this.c = v_1;
     }
-  }
-  return chars.join("");
-}
-function computeRegions(word) {
-  let rv = word.length;
-  let r1 = word.length;
-  let r2 = word.length;
-  if (word.length >= 2) {
-    if (isLowerVowel(word[0])) {
-      if (isLowerVowel(word[1])) {
-        let i2 = 2;
-        while (i2 < word.length && isLowerVowel(word[i2])) i2++;
-        if (i2 < word.length) {
-          i2++;
-          rv = i2;
+    const v_4 = this.c;
+    while (true) {
+      const v_5 = this.c;
+      lab6: {
+        while (true) {
+          const v_6 = this.c;
+          lab8: {
+            if (!this.in_grouping(g_v, 97, 259)) break lab8;
+            this.bra = this.c;
+            lab9: {
+              const v_7 = this.c;
+              lab10: {
+                if (!this.eq_s("u")) break lab10;
+                this.ket = this.c;
+                if (!this.in_grouping(g_v, 97, 259)) break lab10;
+                this.slice_from("U");
+                break lab9;
+              }
+              this.c = v_7;
+              if (!this.eq_s("i")) break lab8;
+              this.ket = this.c;
+              if (!this.in_grouping(g_v, 97, 259)) break lab8;
+              this.slice_from("I");
+            }
+            this.c = v_6;
+            break;
+          }
+          this.c = v_6;
+          if (this.c >= this.limit) break lab6;
+          this.c++;
         }
-      } else {
-        let i2 = 2;
-        while (i2 < word.length && !isLowerVowel(word[i2])) i2++;
-        if (i2 < word.length) {
-          rv = i2 + 1;
+        continue;
+      }
+      this.c = v_5;
+      break;
+    }
+    this.c = v_4;
+    {
+      I_pV = this.limit;
+      I_p1 = this.limit;
+      I_p2 = this.limit;
+      const v_8 = this.c;
+      lab12: {
+        lab13: {
+          const v_9 = this.c;
+          lab14: {
+            if (!this.in_grouping(g_v, 97, 259)) break lab14;
+            lab15: {
+              const v_10 = this.c;
+              lab16: {
+                if (!this.out_grouping(g_v, 97, 259)) break lab16;
+                if (!this.go_out_grouping(g_v, 97, 259)) break lab16;
+                this.c++;
+                break lab15;
+              }
+              this.c = v_10;
+              if (!this.in_grouping(g_v, 97, 259)) break lab14;
+              if (!this.go_in_grouping(g_v, 97, 259)) break lab14;
+              this.c++;
+            }
+            break lab13;
+          }
+          this.c = v_9;
+          if (!this.out_grouping(g_v, 97, 259)) break lab12;
+          lab17: {
+            const v_11 = this.c;
+            lab18: {
+              if (!this.out_grouping(g_v, 97, 259)) break lab18;
+              if (!this.go_out_grouping(g_v, 97, 259)) break lab18;
+              this.c++;
+              break lab17;
+            }
+            this.c = v_11;
+            if (!this.in_grouping(g_v, 97, 259)) break lab12;
+            if (this.c >= this.limit) break lab12;
+            this.c++;
+          }
         }
+        I_pV = this.c;
       }
-    } else if (isLowerVowel(word[1])) {
-      let i2 = 2;
-      while (i2 < word.length && !isLowerVowel(word[i2])) i2++;
-      if (i2 < word.length) {
-        rv = i2 + 1;
+      this.c = v_8;
+      const v_12 = this.c;
+      lab19: {
+        if (!this.go_out_grouping(g_v, 97, 259)) break lab19;
+        this.c++;
+        if (!this.go_in_grouping(g_v, 97, 259)) break lab19;
+        this.c++;
+        I_p1 = this.c;
+        if (!this.go_out_grouping(g_v, 97, 259)) break lab19;
+        this.c++;
+        if (!this.go_in_grouping(g_v, 97, 259)) break lab19;
+        this.c++;
+        I_p2 = this.c;
       }
-    } else {
-      let i2 = 2;
-      while (i2 < word.length) {
-        if (isLowerVowel(word[i2])) {
-          rv = i2 + 1;
+      this.c = v_12;
+    }
+    this.limit_backward = this.c;
+    this.c = this.limit;
+    const v_13 = this.limit - this.c;
+    lab20: {
+      this.ket = this.c;
+      a = this.find_among_b(a_2);
+      if (a === 0) break lab20;
+      this.bra = this.c;
+      if (
+        /**@type {boolean}*/
+        I_p1 > this.c
+      ) break lab20;
+      switch (a) {
+        case 1: {
+          this.slice_del();
+          break;
+        }
+        case 2: {
+          this.slice_from("a");
+          break;
+        }
+        case 3: {
+          this.slice_from("e");
+          break;
+        }
+        case 4: {
+          this.slice_from("i");
+          break;
+        }
+        case 5: {
+          lab21: {
+            if (!this.eq_s_b("ab")) break lab21;
+            break lab20;
+          }
+          this.slice_from("i");
+          break;
+        }
+        case 6: {
+          this.slice_from("at");
+          break;
+        }
+        case 7: {
+          this.slice_from("a\u021Bi");
           break;
         }
-        i2++;
       }
     }
-  }
-  let i = 1;
-  while (i < word.length) {
-    if (!isLowerVowel(word[i]) && isLowerVowel(word[i - 1])) {
-      r1 = i + 1;
-      break;
-    }
-    i++;
-  }
-  i = r1 + 1;
-  while (i < word.length) {
-    if (!isLowerVowel(word[i]) && isLowerVowel(word[i - 1])) {
-      r2 = i + 1;
-      break;
-    }
-    i++;
-  }
-  return { rv, r1, r2 };
-}
-function inRegion(word, regionStart, suffixLen) {
-  return word.length - suffixLen >= regionStart;
-}
-function trySuffix(word, suffixes) {
-  for (const s of suffixes) {
-    if (word.endsWith(s)) return s;
-  }
-  return null;
-}
-function step0(word, r1) {
-  const matched = trySuffix(word, STEP0_SUFFIXES);
-  if (matched && inRegion(word, r1, matched.length)) {
-    switch (matched) {
-      case "ul":
-      case "ului":
-        return word.slice(0, -matched.length);
-      case "aua":
-        return `${word.slice(0, -matched.length)}a`;
-      case "ea":
-      case "ele":
-      case "elor":
-        return `${word.slice(0, -matched.length)}e`;
-      case "iua":
-      case "iei":
-      case "ile":
-      case "iile":
-      case "ilor":
-      case "iilor":
-      case "ii":
-        return `${word.slice(0, -matched.length)}i`;
-      case "a\u021Bia":
-      case "a\u021Bie":
-      case "atei":
-        return `${word.slice(0, -matched.length)}a\u021Bi`;
-      case "ua":
-        return word.slice(0, -matched.length);
-      case "a":
-        return word.slice(0, -1);
-      default:
-        return word.slice(0, -matched.length);
-    }
-  }
-  return word;
-}
-function step1(word, _r1, r2) {
-  for (const [suffixes, _id, replacement] of STEP1_SUFFIX_GROUPS) {
-    const matched = trySuffix(word, suffixes);
-    if (matched && inRegion(word, r2, matched.length)) {
-      return { word: `${word.slice(0, -matched.length)}${replacement}`, changed: true };
-    }
-  }
-  for (const [suffixes, replacement] of STEP1_STANDARD_SUFFIXES) {
-    const matched = trySuffix(word, suffixes);
-    if (matched && inRegion(word, r2, matched.length)) {
-      if (replacement === "ist") {
-        return { word: `${word.slice(0, -matched.length)}ist`, changed: true };
+    this.c = this.limit - v_13;
+    const v_14 = this.limit - this.c;
+    lab22: {
+      B_standard_suffix_removed = false;
+      while (true) {
+        const v_15 = this.limit - this.c;
+        lab23: {
+          const v_16 = this.limit - this.c;
+          this.ket = this.c;
+          a = this.find_among_b(a_3);
+          if (a === 0) break lab23;
+          this.bra = this.c;
+          if (
+            /**@type {boolean}*/
+            I_p1 > this.c
+          ) break lab23;
+          this.slice_from(as_3[a - 1]);
+          B_standard_suffix_removed = true;
+          this.c = this.limit - v_16;
+          continue;
+        }
+        this.c = this.limit - v_15;
+        break;
+      }
+      this.ket = this.c;
+      a = this.find_among_b(a_4);
+      if (a === 0) break lab22;
+      this.bra = this.c;
+      if (
+        /**@type {boolean}*/
+        I_p2 > this.c
+      ) break lab22;
+      switch (a) {
+        case 1: {
+          this.slice_del();
+          break;
+        }
+        case 2: {
+          if (!this.eq_s_b("\u021B")) break lab22;
+          this.bra = this.c;
+          this.slice_from("t");
+          break;
+        }
+        case 3: {
+          this.slice_from("ist");
+          break;
+        }
       }
-      const stripped = word.slice(0, -matched.length);
-      if (matched === "iune" || matched === "iuni") {
-        if (stripped.endsWith("\u021B")) {
-          return { word: `${stripped.slice(0, -1)}t`, changed: true };
+      B_standard_suffix_removed = true;
+    }
+    this.c = this.limit - v_14;
+    const v_17 = this.limit - this.c;
+    lab24: {
+      lab25: {
+        lab26: {
+          if (!B_standard_suffix_removed) break lab26;
+          break lab25;
+        }
+        if (this.c < I_pV) break lab24;
+        const v_18 = this.limit_backward;
+        this.limit_backward = I_pV;
+        this.ket = this.c;
+        a = this.find_among_b(a_5);
+        if (a === 0) {
+          this.limit_backward = v_18;
+          break lab24;
         }
+        this.bra = this.c;
+        switch (a) {
+          case 1: {
+            lab27: {
+              lab28: {
+                if (!this.out_grouping_b(g_v, 97, 259)) break lab28;
+                break lab27;
+              }
+              if (!this.eq_s_b("u")) {
+                this.limit_backward = v_18;
+                break lab24;
+              }
+            }
+            this.slice_del();
+            break;
+          }
+          case 2: {
+            this.slice_del();
+            break;
+          }
+        }
+        this.limit_backward = v_18;
       }
-      return { word: stripped, changed: true };
     }
-  }
-  return { word, changed: false };
-}
-function step2(word, rv) {
-  const matched = trySuffix(word, STEP2_SUFFIXES);
-  if (matched && inRegion(word, rv, matched.length)) {
-    const stripped = word.slice(0, -matched.length);
-    if (STEP2_VERB_GROUP_SESE.has(matched)) {
-      if (!isVowel(stripped[stripped.length - 1]) && stripped[stripped.length - 1] !== "u") {
-        return { word, changed: false };
+    this.c = this.limit - v_17;
+    const v_19 = this.limit - this.c;
+    lab29: {
+      this.ket = this.c;
+      if (this.find_among_b(a_6) === 0) break lab29;
+      this.bra = this.c;
+      if (
+        /**@type {boolean}*/
+        I_pV > this.c
+      ) break lab29;
+      this.slice_del();
+    }
+    this.c = this.limit - v_19;
+    this.c = this.limit_backward;
+    const v_20 = this.c;
+    while (true) {
+      const v_21 = this.c;
+      lab31: {
+        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: {
+            if (this.c >= this.limit) break lab31;
+            this.c++;
+            break;
+          }
+        }
+        continue;
       }
+      this.c = v_21;
+      break;
     }
-    return { word: stripped, changed: true };
-  }
-  return { word, changed: false };
-}
-function step3(word, rv) {
-  const matched = trySuffix(word, STEP3_SUFFIXES);
-  if (matched && inRegion(word, rv, matched.length)) {
-    return word.slice(0, -matched.length);
+    this.c = v_20;
+    return true;
   }
-  return word;
-}
-function restoreMarked(word) {
-  return word.replace(RE_UPPER_I, "i").replace(RE_UPPER_U, "u");
-}
-function stem(word) {
-  if (word.length < 3) return word;
-  word = word.toLowerCase();
-  word = markVowelAsConsonant(word);
-  const { rv, r1, r2 } = computeRegions(word);
-  word = step0(word, r1);
-  const result1 = step1(word, r1, r2);
-  word = result1.word;
-  const step1Changed = result1.changed;
-  if (!step1Changed) {
-    const result2 = step2(word, rv);
-    word = result2.word;
+  stem(input) {
+    this.setCurrent(input);
+    this.#stem();
+    return this.getCurrent();
   }
-  word = step3(word, rv);
-  word = restoreMarked(word);
-  return word;
+};
+var shared = new RomanianStemmer();
+function stem(token) {
+  return shared.stem(token);
 }
+
+// src/languages/romanian.ts
 var stopWords = /* @__PURE__ */ new Set([
   "acea",
   "aceasta",
@@ -624,11 +796,18 @@ var stopWords = /* @__PURE__ */ new Set([
   "\u0163i",
   "\u0163ie"
 ]);
+var CEDILLA_LETTERS = /[\u015F\u0163]/g;
+var COMMA_BELOW = { "\u015F": "\u0219", "\u0163": "\u021B" };
+function normalize(token) {
+  return token.replace(CEDILLA_LETTERS, (letter) => COMMA_BELOW[letter]);
+}
 var romanian = {
   name: "romanian",
+  revision: "daf797aac5310bd4",
   stemmer: stem,
-  stopWords,
-  tokenizer: { splitPattern: /[^a-z0-9ăâîșț]+/gi }
+  stopWords: withNormalisedSpellings(stopWords, normalize),
+  normalizer: normalize,
+  tokenizer: { splitPattern: /[^a-z0-9ăâîșțşţ]+/gi }
 };
 
 export { romanian };