@delali/narsil 0.1.15 → 0.2.1-next.25

package/dist/languages/irish.mjs

@@ -1,152 +1,235 @@
-// src/languages/irish.ts
-var VOWELS = "aeiou\xE1\xE9\xED\xF3\xFA";
-function isVowel(ch) {
-  return VOWELS.includes(ch);
-}
-function findRegions(word) {
-  let r1 = word.length;
-  let r2 = word.length;
-  let rv = word.length;
-  for (let i = 1; i < word.length; i++) {
-    if (!isVowel(word[i]) && isVowel(word[i - 1])) {
-      r1 = i + 1;
-      break;
+import { BaseStemmer } from '../chunk-U2BKYEC7.mjs';
+
+// src/languages/snowball/irish.ts
+var a_0 = [
+  ["b'", 1],
+  ["bh", 4],
+  ["bhf", 2, 1],
+  ["bp", 8],
+  ["ch", 5],
+  ["d'", 1],
+  ["d'fh", 2, 1],
+  ["dh", 6],
+  ["dt", 9],
+  ["fh", 2],
+  ["gc", 5],
+  ["gh", 7],
+  ["h-", 1],
+  ["m'", 1],
+  ["mb", 4],
+  ["mh", 10],
+  ["n-", 1],
+  ["nd", 6],
+  ["ng", 7],
+  ["ph", 8],
+  ["sh", 3],
+  ["t-", 1],
+  ["th", 9],
+  ["ts", 3]
+];
+var as_0 = ["", "f", "s", "b", "c", "d", "g", "p", "t", "m"];
+var a_1 = [
+  ["\xEDochta", 1],
+  ["a\xEDochta", 1, 1],
+  ["ire", 2],
+  ["aire", 2, 1],
+  ["abh", 1],
+  ["eabh", 1, 1],
+  ["ibh", 1],
+  ["aibh", 1, 1],
+  ["amh", 1],
+  ["eamh", 1, 1],
+  ["imh", 1],
+  ["aimh", 1, 1],
+  ["\xEDocht", 1],
+  ["a\xEDocht", 1, 1],
+  ["ir\xED", 2],
+  ["air\xED", 2, 1]
+];
+var a_2 = [
+  ["\xF3ideacha", 6],
+  ["patacha", 5],
+  ["achta", 1],
+  ["arcachta", 2, 1],
+  ["eachta", 1, 2],
+  ["grafa\xEDochta", 4],
+  ["paite", 5],
+  ["ach", 1],
+  ["each", 1, 1],
+  ["\xF3ideach", 6, 1],
+  ["gineach", 3, 2],
+  ["patach", 5, 4],
+  ["grafa\xEDoch", 4],
+  ["pataigh", 5],
+  ["\xF3idigh", 6],
+  ["acht\xFAil", 1],
+  ["eacht\xFAil", 1, 1],
+  ["gineas", 3],
+  ["ginis", 3],
+  ["acht", 1],
+  ["arcacht", 2, 1],
+  ["eacht", 1, 2],
+  ["grafa\xEDocht", 4],
+  ["arcachta\xED", 2],
+  ["grafa\xEDochta\xED", 4]
+];
+var a_3 = [
+  ["imid", 1],
+  ["aimid", 1, 1],
+  ["\xEDmid", 1],
+  ["a\xEDmid", 1, 1],
+  ["adh", 2],
+  ["eadh", 2, 1],
+  ["faidh", 1],
+  ["fidh", 1],
+  ["\xE1il", 2],
+  ["ain", 2],
+  ["tear", 2],
+  ["tar", 2]
+];
+var g_v = [17, 65, 16, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 17, 4, 2];
+var IrishStemmer = 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;
+      a = this.find_among(a_0);
+      if (a === 0) break lab0;
+      this.ket = this.c;
+      this.slice_from(as_0[a - 1]);
     }
-  }
-  for (let i = r1 + 1; i < word.length; i++) {
-    if (!isVowel(word[i]) && isVowel(word[i - 1])) {
-      r2 = i + 1;
-      break;
+    this.c = v_1;
+    {
+      I_pV = this.limit;
+      I_p1 = this.limit;
+      I_p2 = this.limit;
+      const v_2 = this.c;
+      lab2: {
+        if (!this.go_out_grouping(g_v, 97, 250)) break lab2;
+        this.c++;
+        I_pV = this.c;
+        if (!this.go_in_grouping(g_v, 97, 250)) break lab2;
+        this.c++;
+        I_p1 = this.c;
+        if (!this.go_out_grouping(g_v, 97, 250)) break lab2;
+        this.c++;
+        if (!this.go_in_grouping(g_v, 97, 250)) break lab2;
+        this.c++;
+        I_p2 = this.c;
+      }
+      this.c = v_2;
     }
-  }
-  let foundConsonantCluster = false;
-  for (let i = 0; i < word.length; i++) {
-    if (!foundConsonantCluster) {
-      if (!isVowel(word[i])) continue;
-      foundConsonantCluster = false;
-      for (let j = i + 1; j < word.length; j++) {
-        if (!isVowel(word[j])) {
-          rv = j + 1;
-          foundConsonantCluster = true;
+    this.limit_backward = this.c;
+    this.c = this.limit;
+    const v_3 = this.limit - this.c;
+    lab3: {
+      this.ket = this.c;
+      a = this.find_among_b(a_1);
+      if (a === 0) break lab3;
+      this.bra = this.c;
+      switch (a) {
+        case 1: {
+          if (
+            /**@type {boolean}*/
+            I_p1 > this.c
+          ) break lab3;
+          this.slice_del();
+          break;
+        }
+        case 2: {
+          if (
+            /**@type {boolean}*/
+            I_p2 > this.c
+          ) break lab3;
+          this.slice_del();
           break;
         }
       }
-      if (foundConsonantCluster) break;
     }
-  }
-  return { r1, r2, rv };
-}
-var ECLIPSIS = [
-  ["bhf", "f"],
-  ["mb", "b"],
-  ["gc", "c"],
-  ["nd", "d"],
-  ["ng", "g"],
-  ["bp", "p"],
-  ["ts", "s"],
-  ["dt", "t"]
-];
-var LENITION = [
-  ["bh", "b"],
-  ["ch", "c"],
-  ["dh", "d"],
-  ["fh", "f"],
-  ["gh", "g"],
-  ["mh", "m"],
-  ["ph", "p"],
-  ["sh", "s"],
-  ["th", "t"]
-];
-function removeInitialMutations(word) {
-  if (word.startsWith("d'") || word.startsWith("b'")) {
-    const rest = word.slice(2);
-    if (rest.length > 0 && isVowel(rest[0])) {
-      return rest;
-    }
-  }
-  if (word.startsWith("h-") || word.startsWith("n-") || word.startsWith("t-")) {
-    const rest = word.slice(2);
-    if (rest.length > 0 && isVowel(rest[0])) {
-      return rest;
-    }
-  }
-  for (const [mutation, replacement] of ECLIPSIS) {
-    if (word.startsWith(mutation)) {
-      return `${replacement}${word.slice(mutation.length)}`;
-    }
-  }
-  for (const [mutation, replacement] of LENITION) {
-    if (word.startsWith(mutation)) {
-      return `${replacement}${word.slice(mutation.length)}`;
+    this.c = this.limit - v_3;
+    const v_4 = this.limit - this.c;
+    lab4: {
+      this.ket = this.c;
+      a = this.find_among_b(a_2);
+      if (a === 0) break lab4;
+      this.bra = this.c;
+      switch (a) {
+        case 1: {
+          if (
+            /**@type {boolean}*/
+            I_p2 > this.c
+          ) break lab4;
+          this.slice_del();
+          break;
+        }
+        case 2: {
+          this.slice_from("arc");
+          break;
+        }
+        case 3: {
+          this.slice_from("gin");
+          break;
+        }
+        case 4: {
+          this.slice_from("graf");
+          break;
+        }
+        case 5: {
+          this.slice_from("paite");
+          break;
+        }
+        case 6: {
+          this.slice_from("\xF3id");
+          break;
+        }
+      }
     }
-  }
-  return word;
-}
-var NOUN_SUFFIXES = [
-  "arcachta\xED",
-  "gineadach",
-  "a\xEDochta\xED",
-  "eachta\xED",
-  "\xEDochta\xED",
-  "a\xEDochta",
-  "achta\xED",
-  "eachta",
-  "gineas",
-  "\xE9altas",
-  "\xEDochta",
-  "a\xEDocht",
-  "eanna",
-  "achta",
-  "eacht",
-  "anna",
-  "acht",
-  "aire",
-  "ire"
-];
-var VERB_SUFFIXES = [
-  "a\xEDomar",
-  "a\xEDtear",
-  "aimid",
-  "aim\xEDs",
-  "aimis",
-  "a\xEDodh",
-  "a\xEDonn",
-  "eamar",
-  "imid",
-  "\xEDmid",
-  "\xEDm\xEDs",
-  "imis",
-  "tear",
-  "eadh",
-  "aidh",
-  "igh",
-  "ann",
-  "adh"
-];
-function removeSuffixInRegion(word, suffixes, regionStart) {
-  for (const suffix of suffixes) {
-    if (word.endsWith(suffix) && word.length - suffix.length >= regionStart) {
-      return word.slice(0, word.length - suffix.length);
+    this.c = this.limit - v_4;
+    const v_5 = this.limit - this.c;
+    lab5: {
+      this.ket = this.c;
+      a = this.find_among_b(a_3);
+      if (a === 0) break lab5;
+      this.bra = this.c;
+      switch (a) {
+        case 1: {
+          if (
+            /**@type {boolean}*/
+            I_pV > this.c
+          ) break lab5;
+          this.slice_del();
+          break;
+        }
+        case 2: {
+          if (
+            /**@type {boolean}*/
+            I_p1 > this.c
+          ) break lab5;
+          this.slice_del();
+          break;
+        }
+      }
     }
+    this.c = this.limit - v_5;
+    this.c = this.limit_backward;
+    return true;
   }
-  return null;
-}
-function stem(word) {
-  if (word.length < 3) return word;
-  word = removeInitialMutations(word);
-  if (word.length < 3) return word;
-  const { r2, rv } = findRegions(word);
-  const nounResult = removeSuffixInRegion(word, NOUN_SUFFIXES, r2);
-  if (nounResult !== null) {
-    word = nounResult;
-  } else {
-    const verbResult = removeSuffixInRegion(word, VERB_SUFFIXES, rv);
-    if (verbResult !== null) {
-      word = verbResult;
-    }
+  stem(input) {
+    this.setCurrent(input);
+    this.#stem();
+    return this.getCurrent();
   }
-  return word;
+};
+var shared = new IrishStemmer();
+function stem(token) {
+  return shared.stem(token);
 }
+
+// src/languages/irish.ts
 var stopWords = /* @__PURE__ */ new Set([
   "a",
   "ach",
@@ -260,9 +343,10 @@ var stopWords = /* @__PURE__ */ new Set([
 ]);
 var irish = {
   name: "irish",
+  revision: "c79c8adddaf02ae4",
   stemmer: stem,
   stopWords,
-  tokenizer: { splitPattern: /[^a-z0-9áéíóú]+/gi }
+  tokenizer: { splitPattern: /[^a-z0-9áéíóú'-]+/gi }
 };
 
 export { irish };

package/dist/languages/italian.d.ts

@@ -1,5 +1,14 @@
-import { L as LanguageModule } from '../language-ONQ3iVDf.js';
+import { L as LanguageModule } from '../language-DB8KG1z5.js';
 
+/**
+ * Italian analysis: the Snowball stemmer, the stop word list, and the rules
+ * that split Italian text into tokens.
+ *
+ * Import it and pass it to {@link registerLanguage} before you create an index
+ * whose `language` is `italian`.
+ *
+ * @public
+ */
 declare const italian: LanguageModule;
 
 export { italian };