@delali/narsil 0.1.15 → 0.2.0

package/dist/languages/portuguese.mjs

@@ -1,396 +1,623 @@
-// src/languages/portuguese.ts
-var VOWELS = "aeiou\xE0\xE1\xE2\xE9\xEA\xED\xF3\xF4\xFA\xFC";
-function isVowel(ch) {
-  return VOWELS.includes(ch);
-}
-function findRegions(word) {
-  const length = word.length;
-  let rv = length;
-  if (length > 3) {
-    if (!isVowel(word[1])) {
-      for (let i = 2; i < length; i++) {
-        if (isVowel(word[i])) {
-          rv = i + 1;
-          break;
-        }
-      }
-    } else if (isVowel(word[0]) && isVowel(word[1])) {
-      for (let i = 2; i < length; i++) {
-        if (!isVowel(word[i])) {
-          rv = i + 1;
-          break;
+import { removeMarks } from '../chunk-KH3YGMVT.mjs';
+import { withNormalisedSpellings } from '../chunk-GHJWC2E5.mjs';
+import { BaseStemmer } from '../chunk-U2BKYEC7.mjs';
+
+// src/languages/snowball/portuguese.ts
+var a_0 = [
+  ["", 3],
+  ["\xE3", 1, 1],
+  ["\xF5", 2, 2]
+];
+var a_1 = [
+  ["", 3],
+  ["a~", 1, 1],
+  ["o~", 2, 2]
+];
+var a_2 = [
+  ["ic", -1],
+  ["ad", -1],
+  ["os", -1],
+  ["iv", 1]
+];
+var a_3 = [
+  ["ante", 1],
+  ["avel", 1],
+  ["\xEDvel", 1]
+];
+var a_4 = [
+  ["ic", 1],
+  ["abil", 1],
+  ["iv", 1]
+];
+var a_5 = [
+  ["ica", 1],
+  ["\xE2ncia", 1],
+  ["\xEAncia", 4],
+  ["logia", 2],
+  ["ira", 9],
+  ["adora", 1],
+  ["osa", 1],
+  ["ista", 1],
+  ["iva", 8],
+  ["eza", 1],
+  ["idade", 7],
+  ["ante", 1],
+  ["mente", 6],
+  ["amente", 5, 1],
+  ["\xE1vel", 1],
+  ["\xEDvel", 1],
+  ["ico", 1],
+  ["ismo", 1],
+  ["oso", 1],
+  ["amento", 1],
+  ["imento", 1],
+  ["ivo", 8],
+  ["a\xE7a~o", 1],
+  ["u\xE7a~o", 3],
+  ["ador", 1],
+  ["icas", 1],
+  ["\xEAncias", 4],
+  ["logias", 2],
+  ["iras", 9],
+  ["adoras", 1],
+  ["osas", 1],
+  ["istas", 1],
+  ["ivas", 8],
+  ["ezas", 1],
+  ["idades", 7],
+  ["adores", 1],
+  ["antes", 1],
+  ["a\xE7o~es", 1],
+  ["u\xE7o~es", 3],
+  ["icos", 1],
+  ["ismos", 1],
+  ["osos", 1],
+  ["amentos", 1],
+  ["imentos", 1],
+  ["ivos", 8]
+];
+var a_6 = [
+  ["ada", 1],
+  ["ida", 1],
+  ["ia", 1],
+  ["aria", 1, 1],
+  ["eria", 1, 2],
+  ["iria", 1, 3],
+  ["ara", 1],
+  ["era", 1],
+  ["ira", 1],
+  ["ava", 1],
+  ["asse", 1],
+  ["esse", 1],
+  ["isse", 1],
+  ["aste", 1],
+  ["este", 1],
+  ["iste", 1],
+  ["ei", 1],
+  ["arei", 1, 1],
+  ["erei", 1, 2],
+  ["irei", 1, 3],
+  ["am", 1],
+  ["iam", 1, 1],
+  ["ariam", 1, 1],
+  ["eriam", 1, 2],
+  ["iriam", 1, 3],
+  ["aram", 1, 5],
+  ["eram", 1, 6],
+  ["iram", 1, 7],
+  ["avam", 1, 8],
+  ["em", 1],
+  ["arem", 1, 1],
+  ["erem", 1, 2],
+  ["irem", 1, 3],
+  ["assem", 1, 4],
+  ["essem", 1, 5],
+  ["issem", 1, 6],
+  ["ado", 1],
+  ["ido", 1],
+  ["ando", 1],
+  ["endo", 1],
+  ["indo", 1],
+  ["ara~o", 1],
+  ["era~o", 1],
+  ["ira~o", 1],
+  ["ar", 1],
+  ["er", 1],
+  ["ir", 1],
+  ["as", 1],
+  ["adas", 1, 1],
+  ["idas", 1, 2],
+  ["ias", 1, 3],
+  ["arias", 1, 1],
+  ["erias", 1, 2],
+  ["irias", 1, 3],
+  ["aras", 1, 7],
+  ["eras", 1, 8],
+  ["iras", 1, 9],
+  ["avas", 1, 10],
+  ["es", 1],
+  ["ardes", 1, 1],
+  ["erdes", 1, 2],
+  ["irdes", 1, 3],
+  ["ares", 1, 4],
+  ["eres", 1, 5],
+  ["ires", 1, 6],
+  ["asses", 1, 7],
+  ["esses", 1, 8],
+  ["isses", 1, 9],
+  ["astes", 1, 10],
+  ["estes", 1, 11],
+  ["istes", 1, 12],
+  ["is", 1],
+  ["ais", 1, 1],
+  ["eis", 1, 2],
+  ["areis", 1, 1],
+  ["ereis", 1, 2],
+  ["ireis", 1, 3],
+  ["\xE1reis", 1, 4],
+  ["\xE9reis", 1, 5],
+  ["\xEDreis", 1, 6],
+  ["\xE1sseis", 1, 7],
+  ["\xE9sseis", 1, 8],
+  ["\xEDsseis", 1, 9],
+  ["\xE1veis", 1, 10],
+  ["\xEDeis", 1, 11],
+  ["ar\xEDeis", 1, 1],
+  ["er\xEDeis", 1, 2],
+  ["ir\xEDeis", 1, 3],
+  ["ados", 1],
+  ["idos", 1],
+  ["amos", 1],
+  ["\xE1ramos", 1, 1],
+  ["\xE9ramos", 1, 2],
+  ["\xEDramos", 1, 3],
+  ["\xE1vamos", 1, 4],
+  ["\xEDamos", 1, 5],
+  ["ar\xEDamos", 1, 1],
+  ["er\xEDamos", 1, 2],
+  ["ir\xEDamos", 1, 3],
+  ["emos", 1],
+  ["aremos", 1, 1],
+  ["eremos", 1, 2],
+  ["iremos", 1, 3],
+  ["\xE1ssemos", 1, 4],
+  ["\xEAssemos", 1, 5],
+  ["\xEDssemos", 1, 6],
+  ["imos", 1],
+  ["armos", 1],
+  ["ermos", 1],
+  ["irmos", 1],
+  ["\xE1mos", 1],
+  ["ar\xE1s", 1],
+  ["er\xE1s", 1],
+  ["ir\xE1s", 1],
+  ["eu", 1],
+  ["iu", 1],
+  ["ou", 1],
+  ["ar\xE1", 1],
+  ["er\xE1", 1],
+  ["ir\xE1", 1]
+];
+var a_7 = [
+  ["a", 1],
+  ["i", 1],
+  ["o", 1],
+  ["os", 1],
+  ["\xE1", 1],
+  ["\xED", 1],
+  ["\xF3", 1]
+];
+var a_8 = [
+  ["e", 1],
+  ["\xE7", 2],
+  ["\xE9", 1],
+  ["\xEA", 1]
+];
+var g_v = [17, 65, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 19, 12, 2];
+var PortugueseStemmer = class extends BaseStemmer {
+  #stem() {
+    let a;
+    let I_p2;
+    let I_p1;
+    let I_pV;
+    const v_1 = this.c;
+    while (true) {
+      const v_2 = this.c;
+      lab1: {
+        this.bra = this.c;
+        a = this.find_among(a_0);
+        this.ket = this.c;
+        switch (a) {
+          case 1: {
+            this.slice_from("a~");
+            break;
+          }
+          case 2: {
+            this.slice_from("o~");
+            break;
+          }
+          case 3: {
+            if (this.c >= this.limit) break lab1;
+            this.c++;
+            break;
+          }
         }
+        continue;
       }
-    } else {
-      rv = 3;
-    }
-  }
-  let r1 = length;
-  for (let i = 1; i < length; i++) {
-    if (!isVowel(word[i]) && isVowel(word[i - 1])) {
-      r1 = i + 1;
+      this.c = v_2;
       break;
     }
-  }
-  let r2 = length;
-  for (let i = r1 + 1; i < length; i++) {
-    if (!isVowel(word[i]) && isVowel(word[i - 1])) {
-      r2 = i + 1;
-      break;
-    }
-  }
-  return { rv, r1, r2 };
-}
-function endsWith(word, suffix) {
-  return word.endsWith(suffix);
-}
-function suffixInRegion(word, suffix, regionStart) {
-  return word.length - suffix.length >= regionStart;
-}
-function removeSuffix(word, suffix) {
-  return word.slice(0, word.length - suffix.length);
-}
-function replaceSuffix(word, suffix, replacement) {
-  return word.slice(0, word.length - suffix.length) + replacement;
-}
-var STANDARD_SUFFIXES = [
-  { suffix: "amentos", group: 1 },
-  { suffix: "imentos", group: 1 },
-  { suffix: "adoras", group: 1 },
-  { suffix: "adores", group: 1 },
-  { suffix: "logias", group: 2 },
-  { suffix: "idades", group: 7 },
-  { suffix: "amento", group: 1 },
-  { suffix: "imento", group: 1 },
-  { suffix: "adora", group: 1 },
-  { suffix: "istas", group: 1 },
-  { suffix: "antes", group: 1 },
-  { suffix: "ismos", group: 1 },
-  { suffix: "\xE2ncia", group: 1 },
-  { suffix: "logia", group: 2 },
-  { suffix: "\xEAncia", group: 4 },
-  { suffix: "\xEAncias", group: 4 },
-  { suffix: "amente", group: 5 },
-  { suffix: "mente", group: 6 },
-  { suffix: "idade", group: 7 },
-  { suffix: "\xE1vel", group: 1 },
-  { suffix: "\xEDvel", group: 1 },
-  { suffix: "ador", group: 1 },
-  { suffix: "ante", group: 1 },
-  { suffix: "ista", group: 1 },
-  { suffix: "ismo", group: 1 },
-  { suffix: "icas", group: 1 },
-  { suffix: "icos", group: 1 },
-  { suffix: "osas", group: 1 },
-  { suffix: "osos", group: 1 },
-  { suffix: "iva", group: 8 },
-  { suffix: "ivo", group: 8 },
-  { suffix: "ivas", group: 8 },
-  { suffix: "ivos", group: 8 },
-  { suffix: "ica", group: 1 },
-  { suffix: "ico", group: 1 },
-  { suffix: "osa", group: 1 },
-  { suffix: "oso", group: 1 },
-  { suffix: "ezas", group: 1 },
-  { suffix: "eza", group: 1 },
-  { suffix: "ira", group: 9 },
-  { suffix: "iras", group: 9 },
-  { suffix: "a\xE7a~o", group: 1 },
-  { suffix: "u\xE7a~o", group: 3 },
-  { suffix: "a\xE7o~es", group: 1 },
-  { suffix: "u\xE7o~es", group: 3 }
-];
-function findLongestMatch(word, suffixes) {
-  let best = null;
-  for (const entry of suffixes) {
-    if (endsWith(word, entry.suffix)) {
-      if (best === null || entry.suffix.length > best.suffix.length) {
-        best = entry;
+    this.c = v_1;
+    {
+      I_pV = this.limit;
+      I_p1 = this.limit;
+      I_p2 = this.limit;
+      const v_3 = this.c;
+      lab3: {
+        lab4: {
+          const v_4 = this.c;
+          lab5: {
+            if (!this.in_grouping(g_v, 97, 250)) break lab5;
+            lab6: {
+              const v_5 = this.c;
+              lab7: {
+                if (!this.out_grouping(g_v, 97, 250)) break lab7;
+                if (!this.go_out_grouping(g_v, 97, 250)) break lab7;
+                this.c++;
+                break lab6;
+              }
+              this.c = v_5;
+              if (!this.in_grouping(g_v, 97, 250)) break lab5;
+              if (!this.go_in_grouping(g_v, 97, 250)) break lab5;
+              this.c++;
+            }
+            break lab4;
+          }
+          this.c = v_4;
+          if (!this.out_grouping(g_v, 97, 250)) break lab3;
+          lab8: {
+            const v_6 = this.c;
+            lab9: {
+              if (!this.out_grouping(g_v, 97, 250)) break lab9;
+              if (!this.go_out_grouping(g_v, 97, 250)) break lab9;
+              this.c++;
+              break lab8;
+            }
+            this.c = v_6;
+            if (!this.in_grouping(g_v, 97, 250)) break lab3;
+            if (this.c >= this.limit) break lab3;
+            this.c++;
+          }
+        }
+        I_pV = this.c;
       }
-    }
-  }
-  return best;
-}
-function removeStandardSuffix(word, r1, r2, rv) {
-  const match = findLongestMatch(word, STANDARD_SUFFIXES);
-  if (match === null) return { word, changed: false };
-  const { suffix, group } = match;
-  if (group === 1) {
-    if (!suffixInRegion(word, suffix, r2)) return { word, changed: false };
-    return { word: removeSuffix(word, suffix), changed: true };
-  }
-  if (group === 2) {
-    if (!suffixInRegion(word, suffix, r2)) return { word, changed: false };
-    return { word: replaceSuffix(word, suffix, "log"), changed: true };
-  }
-  if (group === 3) {
-    if (!suffixInRegion(word, suffix, r2)) return { word, changed: false };
-    return { word: replaceSuffix(word, suffix, "u"), changed: true };
-  }
-  if (group === 4) {
-    if (!suffixInRegion(word, suffix, r2)) return { word, changed: false };
-    return { word: replaceSuffix(word, suffix, "ente"), changed: true };
-  }
-  if (group === 5) {
-    if (!suffixInRegion(word, suffix, r1)) return { word, changed: false };
-    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.c = v_3;
+      const v_7 = this.c;
+      lab10: {
+        if (!this.go_out_grouping(g_v, 97, 250)) break lab10;
+        this.c++;
+        if (!this.go_in_grouping(g_v, 97, 250)) break lab10;
+        this.c++;
+        I_p1 = this.c;
+        if (!this.go_out_grouping(g_v, 97, 250)) break lab10;
+        this.c++;
+        if (!this.go_in_grouping(g_v, 97, 250)) break lab10;
+        this.c++;
+        I_p2 = this.c;
       }
-    } else if (endsWith(word, "os") && suffixInRegion(word, "os", r2)) {
-      word = removeSuffix(word, "os");
-    } else if (endsWith(word, "ic") && suffixInRegion(word, "ic", r2)) {
-      word = removeSuffix(word, "ic");
-    } else if (endsWith(word, "ad") && suffixInRegion(word, "ad", r2)) {
-      word = removeSuffix(word, "ad");
-    }
-    return { word, changed: true };
-  }
-  if (group === 6) {
-    if (!suffixInRegion(word, suffix, r2)) return { word, changed: false };
-    word = removeSuffix(word, suffix);
-    if (endsWith(word, "ante") && suffixInRegion(word, "ante", r2)) {
-      word = removeSuffix(word, "ante");
-    } else if (endsWith(word, "avel") && suffixInRegion(word, "avel", r2)) {
-      word = removeSuffix(word, "avel");
-    } else if (endsWith(word, "\xEDvel") && suffixInRegion(word, "\xEDvel", r2)) {
-      word = removeSuffix(word, "\xEDvel");
+      this.c = v_7;
     }
-    return { word, changed: true };
-  }
-  if (group === 7) {
-    if (!suffixInRegion(word, suffix, r2)) return { word, changed: false };
-    word = removeSuffix(word, suffix);
-    if (endsWith(word, "abil") && suffixInRegion(word, "abil", r2)) {
-      word = removeSuffix(word, "abil");
-    } else if (endsWith(word, "ic") && suffixInRegion(word, "ic", r2)) {
-      word = removeSuffix(word, "ic");
-    } else if (endsWith(word, "iv") && suffixInRegion(word, "iv", r2)) {
-      word = removeSuffix(word, "iv");
-    }
-    return { word, changed: true };
-  }
-  if (group === 8) {
-    if (!suffixInRegion(word, suffix, r2)) return { word, changed: false };
-    word = removeSuffix(word, suffix);
-    if (endsWith(word, "at") && suffixInRegion(word, "at", r2)) {
-      word = removeSuffix(word, "at");
-    }
-    return { word, changed: true };
-  }
-  if (group === 9) {
-    if (!suffixInRegion(word, suffix, rv)) return { word, changed: false };
-    const withoutSuffix = removeSuffix(word, suffix);
-    if (endsWith(withoutSuffix, "e")) {
-      return { word: replaceSuffix(word, suffix, "ir"), changed: true };
-    }
-    return { word, changed: false };
-  }
-  return { word, changed: false };
-}
-var VERB_SUFFIXES = [
-  "ar\xEDamos",
-  "er\xEDamos",
-  "ir\xEDamos",
-  "\xE1ssemos",
-  "\xEAssemos",
-  "\xEDssemos",
-  "\xE1ramos",
-  "\xE9ramos",
-  "\xEDramos",
-  "\xE1vamos",
-  "\xEDamos",
-  "aremos",
-  "eremos",
-  "iremos",
-  "ar\xEDeis",
-  "er\xEDeis",
-  "ir\xEDeis",
-  "\xE1sseis",
-  "\xE9sseis",
-  "\xEDsseis",
-  "\xE1veis",
-  "\xEDeis",
-  "ardes",
-  "erdes",
-  "irdes",
-  "areis",
-  "ereis",
-  "ireis",
-  "\xE1reis",
-  "\xE9reis",
-  "\xEDreis",
-  "asses",
-  "esses",
-  "isses",
-  "astes",
-  "estes",
-  "istes",
-  "ariam",
-  "eriam",
-  "iriam",
-  "arias",
-  "erias",
-  "irias",
-  "assem",
-  "essem",
-  "issem",
-  "armos",
-  "ermos",
-  "irmos",
-  "aram",
-  "eram",
-  "iram",
-  "avam",
-  "arem",
-  "erem",
-  "irem",
-  "ando",
-  "endo",
-  "indo",
-  "ados",
-  "idos",
-  "amos",
-  "emos",
-  "imos",
-  "ar\xE1s",
-  "er\xE1s",
-  "ir\xE1s",
-  "ares",
-  "eres",
-  "ires",
-  "avas",
-  "aria",
-  "eria",
-  "iria",
-  "asse",
-  "esse",
-  "isse",
-  "aste",
-  "este",
-  "iste",
-  "arei",
-  "erei",
-  "irei",
-  "ada",
-  "ida",
-  "ara",
-  "era",
-  "ira",
-  "ava",
-  "ado",
-  "ido",
-  "ais",
-  "eis",
-  "is",
-  "iam",
-  "\xE1mos",
-  "ara~o",
-  "era~o",
-  "ira~o",
-  "am",
-  "em",
-  "ar",
-  "er",
-  "ir",
-  "as",
-  "es",
-  "eu",
-  "iu",
-  "ou",
-  "ia",
-  "ei",
-  "ar\xE1",
-  "er\xE1",
-  "ir\xE1"
-];
-function removeVerbSuffix(word, rv) {
-  let longestSuffix = null;
-  for (const suffix of VERB_SUFFIXES) {
-    if (endsWith(word, suffix) && suffixInRegion(word, suffix, rv)) {
-      if (longestSuffix === null || suffix.length > longestSuffix.length) {
-        longestSuffix = suffix;
+    this.limit_backward = this.c;
+    this.c = this.limit;
+    const v_8 = this.limit - this.c;
+    lab11: {
+      lab12: {
+        const v_9 = this.limit - this.c;
+        lab13: {
+          const v_10 = this.limit - this.c;
+          lab14: {
+            const v_11 = this.limit - this.c;
+            lab15: {
+              this.ket = this.c;
+              a = this.find_among_b(a_5);
+              if (a === 0) break lab15;
+              this.bra = this.c;
+              switch (a) {
+                case 1: {
+                  if (
+                    /**@type {boolean}*/
+                    I_p2 > this.c
+                  ) break lab15;
+                  this.slice_del();
+                  break;
+                }
+                case 2: {
+                  if (
+                    /**@type {boolean}*/
+                    I_p2 > this.c
+                  ) break lab15;
+                  this.slice_from("log");
+                  break;
+                }
+                case 3: {
+                  if (
+                    /**@type {boolean}*/
+                    I_p2 > this.c
+                  ) break lab15;
+                  this.slice_from("u");
+                  break;
+                }
+                case 4: {
+                  if (
+                    /**@type {boolean}*/
+                    I_p2 > this.c
+                  ) break lab15;
+                  this.slice_from("ente");
+                  break;
+                }
+                case 5: {
+                  if (
+                    /**@type {boolean}*/
+                    I_p1 > this.c
+                  ) break lab15;
+                  this.slice_del();
+                  const v_12 = this.limit - this.c;
+                  lab16: {
+                    this.ket = this.c;
+                    a = this.find_among_b(a_2);
+                    if (a === 0) {
+                      this.c = this.limit - v_12;
+                      break lab16;
+                    }
+                    this.bra = this.c;
+                    if (
+                      /**@type {boolean}*/
+                      I_p2 > this.c
+                    ) {
+                      this.c = this.limit - v_12;
+                      break lab16;
+                    }
+                    this.slice_del();
+                    switch (a) {
+                      case 1: {
+                        this.ket = this.c;
+                        if (!this.eq_s_b("at")) {
+                          this.c = this.limit - v_12;
+                          break lab16;
+                        }
+                        this.bra = this.c;
+                        if (
+                          /**@type {boolean}*/
+                          I_p2 > this.c
+                        ) {
+                          this.c = this.limit - v_12;
+                          break lab16;
+                        }
+                        this.slice_del();
+                        break;
+                      }
+                    }
+                  }
+                  break;
+                }
+                case 6: {
+                  if (
+                    /**@type {boolean}*/
+                    I_p2 > this.c
+                  ) break lab15;
+                  this.slice_del();
+                  const v_13 = this.limit - this.c;
+                  lab17: {
+                    this.ket = this.c;
+                    if (this.find_among_b(a_3) === 0) {
+                      this.c = this.limit - v_13;
+                      break lab17;
+                    }
+                    this.bra = this.c;
+                    if (
+                      /**@type {boolean}*/
+                      I_p2 > this.c
+                    ) {
+                      this.c = this.limit - v_13;
+                      break lab17;
+                    }
+                    this.slice_del();
+                  }
+                  break;
+                }
+                case 7: {
+                  if (
+                    /**@type {boolean}*/
+                    I_p2 > this.c
+                  ) break lab15;
+                  this.slice_del();
+                  const v_14 = this.limit - this.c;
+                  lab18: {
+                    this.ket = this.c;
+                    if (this.find_among_b(a_4) === 0) {
+                      this.c = this.limit - v_14;
+                      break lab18;
+                    }
+                    this.bra = this.c;
+                    if (
+                      /**@type {boolean}*/
+                      I_p2 > this.c
+                    ) {
+                      this.c = this.limit - v_14;
+                      break lab18;
+                    }
+                    this.slice_del();
+                  }
+                  break;
+                }
+                case 8: {
+                  if (
+                    /**@type {boolean}*/
+                    I_p2 > this.c
+                  ) break lab15;
+                  this.slice_del();
+                  const v_15 = this.limit - this.c;
+                  lab19: {
+                    this.ket = this.c;
+                    if (!this.eq_s_b("at")) {
+                      this.c = this.limit - v_15;
+                      break lab19;
+                    }
+                    this.bra = this.c;
+                    if (
+                      /**@type {boolean}*/
+                      I_p2 > this.c
+                    ) {
+                      this.c = this.limit - v_15;
+                      break lab19;
+                    }
+                    this.slice_del();
+                  }
+                  break;
+                }
+                case 9: {
+                  if (
+                    /**@type {boolean}*/
+                    I_pV > this.c
+                  ) break lab15;
+                  if (!this.eq_s_b("e")) break lab15;
+                  this.slice_from("ir");
+                  break;
+                }
+              }
+              break lab14;
+            }
+            this.c = this.limit - v_11;
+            if (this.c < I_pV) break lab13;
+            const v_16 = this.limit_backward;
+            this.limit_backward = I_pV;
+            this.ket = this.c;
+            if (this.find_among_b(a_6) === 0) {
+              this.limit_backward = v_16;
+              break lab13;
+            }
+            this.bra = this.c;
+            this.slice_del();
+            this.limit_backward = v_16;
+          }
+          this.c = this.limit - v_10;
+          const v_17 = this.limit - this.c;
+          lab20: {
+            this.ket = this.c;
+            if (!this.eq_s_b("i")) break lab20;
+            this.bra = this.c;
+            const v_18 = this.limit - this.c;
+            if (!this.eq_s_b("c")) break lab20;
+            this.c = this.limit - v_18;
+            if (
+              /**@type {boolean}*/
+              I_pV > this.c
+            ) break lab20;
+            this.slice_del();
+          }
+          this.c = this.limit - v_17;
+          break lab12;
+        }
+        this.c = this.limit - v_9;
+        this.ket = this.c;
+        if (this.find_among_b(a_7) === 0) break lab11;
+        this.bra = this.c;
+        if (
+          /**@type {boolean}*/
+          I_pV > this.c
+        ) break lab11;
+        this.slice_del();
       }
     }
-  }
-  if (longestSuffix !== null) {
-    return { word: removeSuffix(word, longestSuffix), changed: true };
-  }
-  return { word, changed: false };
-}
-var RESIDUAL_SUFFIXES = ["a", "i", "o", "os", "\xE1", "\xED", "\xF3"];
-function removeResidualSuffix(word, rv) {
-  let longestSuffix = null;
-  for (const suffix of RESIDUAL_SUFFIXES) {
-    if (endsWith(word, suffix) && suffixInRegion(word, suffix, rv)) {
-      if (longestSuffix === null || suffix.length > longestSuffix.length) {
-        longestSuffix = suffix;
+    this.c = this.limit - v_8;
+    const v_19 = this.limit - this.c;
+    lab21: {
+      this.ket = this.c;
+      a = this.find_among_b(a_8);
+      if (a === 0) break lab21;
+      this.bra = this.c;
+      switch (a) {
+        case 1: {
+          if (
+            /**@type {boolean}*/
+            I_pV > this.c
+          ) break lab21;
+          this.slice_del();
+          this.ket = this.c;
+          lab22: {
+            const v_20 = this.limit - this.c;
+            lab23: {
+              if (!this.eq_s_b("u")) break lab23;
+              this.bra = this.c;
+              const v_21 = this.limit - this.c;
+              if (!this.eq_s_b("g")) break lab23;
+              this.c = this.limit - v_21;
+              break lab22;
+            }
+            this.c = this.limit - v_20;
+            if (!this.eq_s_b("i")) break lab21;
+            this.bra = this.c;
+            const v_22 = this.limit - this.c;
+            if (!this.eq_s_b("c")) break lab21;
+            this.c = this.limit - v_22;
+          }
+          if (
+            /**@type {boolean}*/
+            I_pV > this.c
+          ) break lab21;
+          this.slice_del();
+          break;
+        }
+        case 2: {
+          this.slice_from("c");
+          break;
+        }
       }
     }
-  }
-  if (longestSuffix !== null) {
-    return { word: removeSuffix(word, longestSuffix), changed: true };
-  }
-  return { word, changed: false };
-}
-function removeResidualForm(word, rv) {
-  if (endsWith(word, "\xEA") && suffixInRegion(word, "\xEA", rv)) {
-    return removeSuffix(word, "\xEA");
-  }
-  if (endsWith(word, "\xE9") && suffixInRegion(word, "\xE9", rv)) {
-    return removeSuffix(word, "\xE9");
-  }
-  if (endsWith(word, "e") && suffixInRegion(word, "e", rv)) {
-    word = removeSuffix(word, "e");
-    if (endsWith(word, "gu") && suffixInRegion(word, "u", rv)) {
-      word = removeSuffix(word, "u");
-    } else if (endsWith(word, "ci") && suffixInRegion(word, "i", rv)) {
-      word = removeSuffix(word, "i");
-    }
-    return word;
-  }
-  if (endsWith(word, "\xE7")) {
-    return replaceSuffix(word, "\xE7", "c");
-  }
-  return word;
-}
-function normalizeNasals(word) {
-  return word.replace(/\u00e3/g, "a~").replace(/\u00f5/g, "o~");
-}
-function restoreNasals(word) {
-  return word.replace(/a~/g, "\xE3").replace(/o~/g, "\xF5");
-}
-function stem(word) {
-  if (word.length < 3) return word;
-  word = word.toLowerCase();
-  word = normalizeNasals(word);
-  const { rv, r1, r2 } = findRegions(word);
-  const standardResult = removeStandardSuffix(word, r1, r2, rv);
-  let standardOrVerbChanged = standardResult.changed;
-  if (standardResult.changed) {
-    word = standardResult.word;
-  } else {
-    const verbResult = removeVerbSuffix(word, rv);
-    standardOrVerbChanged = verbResult.changed;
-    word = verbResult.word;
-  }
-  if (standardOrVerbChanged) {
-    if (endsWith(word, "i") && suffixInRegion(word, "i", rv)) {
-      const preceding = word.length >= 2 ? word[word.length - 2] : "";
-      if (preceding === "c") {
-        word = removeSuffix(word, "i");
+    this.c = this.limit - v_19;
+    this.c = this.limit_backward;
+    const v_23 = this.c;
+    while (true) {
+      const v_24 = this.c;
+      lab25: {
+        this.bra = this.c;
+        a = this.find_among(a_1);
+        this.ket = this.c;
+        switch (a) {
+          case 1: {
+            this.slice_from("\xE3");
+            break;
+          }
+          case 2: {
+            this.slice_from("\xF5");
+            break;
+          }
+          case 3: {
+            if (this.c >= this.limit) break lab25;
+            this.c++;
+            break;
+          }
+        }
+        continue;
       }
+      this.c = v_24;
+      break;
     }
-  } else {
-    const residualResult = removeResidualSuffix(word, rv);
-    word = residualResult.word;
+    this.c = v_23;
+    return true;
   }
-  word = removeResidualForm(word, rv);
-  word = restoreNasals(word);
-  return word;
+  stem(input) {
+    this.setCurrent(input);
+    this.#stem();
+    return this.getCurrent();
+  }
+};
+var shared = new PortugueseStemmer();
+function stem(token) {
+  return shared.stem(token);
 }
+
+// src/languages/portuguese.ts
 var stopWords = /* @__PURE__ */ new Set([
   "de",
   "a",
@@ -596,11 +823,17 @@ var stopWords = /* @__PURE__ */ new Set([
   "ter\xEDamos",
   "teriam"
 ]);
+var DIAERESIS = /\u0308/g;
+function normalize(token) {
+  return removeMarks(token, DIAERESIS);
+}
 var portuguese = {
   name: "portuguese",
+  revision: "c0a0c5c97ab9ca6e",
   stemmer: stem,
-  stopWords,
-  tokenizer: { splitPattern: /[^a-z0-9\u00e0-\u00fa]+/gi }
+  stopWords: withNormalisedSpellings(stopWords, normalize),
+  normalizer: normalize,
+  tokenizer: { splitPattern: /[^a-z0-9àáâãçéêíóôõúü]+/gi }
 };
 
 export { portuguese };