@delali/narsil 0.1.15 → 0.2.1-next.25

package/dist/languages/danish.mjs

@@ -1,123 +1,222 @@
-// src/languages/danish.ts
-var VOWELS = "aeiouy\xE5\xE6\xF8";
-var S_ENDINGS = "abcdfghjklmnoprtvyz\xE5";
-var STEP1_SUFFIXES = [
-  "erendes",
-  "hedens",
-  "erende",
-  "erens",
-  "endes",
-  "ernes",
-  "enes",
-  "eres",
-  "erets",
-  "heder",
-  "ethed",
-  "erede",
-  "heden",
-  "ered",
-  "erer",
-  "ende",
-  "erne",
-  "ene",
-  "ere",
-  "eren",
-  "heds",
-  "eret",
-  "ens",
-  "ers",
-  "ets",
-  "hed",
-  "en",
-  "er",
-  "es",
-  "et",
-  "e"
+import { removeMarks } from '../chunk-KH3YGMVT.mjs';
+import { withNormalisedSpellings } from '../chunk-GHJWC2E5.mjs';
+import { BaseStemmer } from '../chunk-U2BKYEC7.mjs';
+
+// src/languages/snowball/danish.ts
+var a_0 = [
+  ["hed", 1],
+  ["ethed", 1, 1],
+  ["ered", 1],
+  ["e", 1],
+  ["erede", 1, 1],
+  ["ende", 1, 2],
+  ["erende", 1, 1],
+  ["ene", 1, 4],
+  ["erne", 1, 5],
+  ["ere", 1, 6],
+  ["en", 1],
+  ["heden", 1, 1],
+  ["eren", 1, 2],
+  ["er", 1],
+  ["heder", 1, 1],
+  ["erer", 1, 2],
+  ["s", 2],
+  ["heds", 1, 1],
+  ["es", 1, 2],
+  ["endes", 1, 1],
+  ["erendes", 1, 1],
+  ["enes", 1, 3],
+  ["ernes", 1, 4],
+  ["eres", 1, 5],
+  ["ens", 1, 8],
+  ["hedens", 1, 1],
+  ["erens", 1, 2],
+  ["ers", 1, 11],
+  ["ets", 1, 12],
+  ["erets", 1, 1],
+  ["et", 1],
+  ["eret", 1, 1]
 ];
-var UNDOUBLE_PAIRS = ["gd", "dt", "gt", "kt"];
-var STEP3_SUFFIXES = [
-  { text: "elig", replacement: null },
-  { text: "l\xF8st", replacement: "l\xF8s" },
-  { text: "lig", replacement: null },
-  { text: "els", replacement: null },
-  { text: "ig", replacement: null }
+var a_1 = [
+  ["gd", -1],
+  ["dt", -1],
+  ["gt", -1],
+  ["kt", -1]
 ];
-function isVowel(ch) {
-  return VOWELS.includes(ch);
-}
-function isConsonant(ch) {
-  return ch.length === 1 && !isVowel(ch);
-}
-function computeR1(word) {
-  let foundVowel = false;
-  for (let i = 0; i < word.length; i++) {
-    if (foundVowel && !isVowel(word[i])) {
-      return Math.max(i + 1, 3);
-    }
-    if (isVowel(word[i])) {
-      foundVowel = true;
+var a_2 = [
+  ["ig", 1],
+  ["lig", 1, 1],
+  ["elig", 1, 1],
+  ["els", 1],
+  ["l\xF8st", 2]
+];
+var g_undouble_c = [53, 94, 7];
+var g_v = [17, 65, 16, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 48, 0, 128];
+var g_s_ending = [1, 0, 0, 0, 0, 0, 0, 188, 251, 171, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64];
+var DanishStemmer = class extends BaseStemmer {
+  #I_p1 = 0;
+  #r_consonant_pair() {
+    const v_1 = this.limit - this.c;
+    if (this.c < this.#I_p1) return false;
+    const v_2 = this.limit_backward;
+    this.limit_backward = this.#I_p1;
+    this.ket = this.c;
+    if (this.find_among_b(a_1) === 0) {
+      this.limit_backward = v_2;
+      return false;
     }
+    this.bra = this.c;
+    this.limit_backward = v_2;
+    this.c = this.limit - v_1;
+    if (this.c <= this.limit_backward) return false;
+    this.c--;
+    this.bra = this.c;
+    this.slice_del();
+    return true;
   }
-  return word.length;
-}
-function step1(word, r1) {
-  for (const suffix of STEP1_SUFFIXES) {
-    if (word.endsWith(suffix) && word.length - suffix.length >= r1) {
-      return word.slice(0, -suffix.length);
+  #stem() {
+    let a;
+    let S_ch;
+    this.#I_p1 = this.limit;
+    const v_1 = this.c;
+    lab0: {
+      lab1: {
+        const v_2 = this.c;
+        lab2: {
+          while (true) {
+            lab4: {
+              if (!this.eq_s("'")) break lab4;
+              break;
+            }
+            if (this.c >= this.limit) break lab2;
+            this.c++;
+          }
+          break lab1;
+        }
+        this.c = v_2;
+        if (!this.go_out_grouping(g_v, 97, 248)) break lab0;
+        this.c++;
+        if (!this.go_in_grouping(g_v, 97, 248)) break lab0;
+        this.c++;
+      }
+      this.#I_p1 = this.c;
     }
-  }
-  if (word.endsWith("s") && word.length - 1 >= r1) {
-    const preceding = word[word.length - 2];
-    if (preceding && S_ENDINGS.includes(preceding)) {
-      return word.slice(0, -1);
+    this.c = v_1;
+    const v_3 = this.c;
+    if (this.c + 3 > this.limit) return false;
+    this.c += 3;
+    lab5: {
+      if (
+        /**@type {boolean}*/
+        this.#I_p1 >= this.c
+      ) break lab5;
+      this.#I_p1 = this.c;
     }
-  }
-  return word;
-}
-function undouble(word, r1) {
-  if (word.length < r1) return word;
-  for (const pair of UNDOUBLE_PAIRS) {
-    if (word.endsWith(pair)) {
-      return word.slice(0, -1);
+    this.c = v_3;
+    this.limit_backward = this.c;
+    this.c = this.limit;
+    const v_4 = this.limit - this.c;
+    lab6: {
+      if (this.c < this.#I_p1) break lab6;
+      const v_5 = this.limit_backward;
+      this.limit_backward = this.#I_p1;
+      this.ket = this.c;
+      a = this.find_among_b(a_0);
+      if (a === 0) {
+        this.limit_backward = v_5;
+        break lab6;
+      }
+      this.bra = this.c;
+      this.limit_backward = v_5;
+      switch (a) {
+        case 1: {
+          this.slice_del();
+          break;
+        }
+        case 2: {
+          if (!this.in_grouping_b(g_s_ending, 39, 229)) break lab6;
+          this.slice_del();
+          break;
+        }
+      }
     }
-  }
-  return word;
-}
-function step3(word, r1) {
-  if (word.endsWith("igst")) {
-    word = word.slice(0, -2);
-  }
-  for (const { text, replacement } of STEP3_SUFFIXES) {
-    if (word.endsWith(text) && word.length - text.length >= r1) {
-      if (replacement !== null) {
-        return word.slice(0, -text.length) + replacement;
+    this.c = this.limit - v_4;
+    const v_6 = this.limit - this.c;
+    this.#r_consonant_pair();
+    this.c = this.limit - v_6;
+    const v_7 = this.limit - this.c;
+    lab7: {
+      const v_8 = this.limit - this.c;
+      lab8: {
+        this.ket = this.c;
+        if (!this.eq_s_b("st")) break lab8;
+        this.bra = this.c;
+        if (!this.eq_s_b("ig")) break lab8;
+        this.slice_del();
+      }
+      this.c = this.limit - v_8;
+      if (this.c < this.#I_p1) break lab7;
+      const v_9 = this.limit_backward;
+      this.limit_backward = this.#I_p1;
+      this.ket = this.c;
+      a = this.find_among_b(a_2);
+      if (a === 0) {
+        this.limit_backward = v_9;
+        break lab7;
+      }
+      this.bra = this.c;
+      this.limit_backward = v_9;
+      switch (a) {
+        case 1: {
+          this.slice_del();
+          const v_10 = this.limit - this.c;
+          this.#r_consonant_pair();
+          this.c = this.limit - v_10;
+          break;
+        }
+        case 2: {
+          this.slice_from("l\xF8s");
+          break;
+        }
+      }
+    }
+    this.c = this.limit - v_7;
+    const v_11 = this.limit - this.c;
+    lab9: {
+      if (this.c < this.#I_p1) break lab9;
+      const v_12 = this.limit_backward;
+      this.limit_backward = this.#I_p1;
+      this.ket = this.c;
+      if (!this.in_grouping_b(g_undouble_c, 98, 116)) {
+        this.limit_backward = v_12;
+        break lab9;
       }
-      word = word.slice(0, -text.length);
-      word = undouble(word, r1);
-      return word;
+      this.bra = this.c;
+      S_ch = this.slice_to();
+      this.limit_backward = v_12;
+      if (!this.eq_s_b(S_ch)) break lab9;
+      this.slice_del();
     }
+    this.c = this.limit - v_11;
+    this.ket = this.c;
+    if (!this.eq_s_b("'")) return false;
+    this.bra = this.c;
+    this.slice_del();
+    this.c = this.limit_backward;
+    return true;
   }
-  return word;
-}
-function step4(word, r1) {
-  if (word.length < 2 || word.length <= r1) return word;
-  const last = word[word.length - 1];
-  const secondLast = word[word.length - 2];
-  if (isConsonant(last) && last === secondLast) {
-    return word.slice(0, -1);
+  stem(input) {
+    this.setCurrent(input);
+    this.#stem();
+    return this.getCurrent();
   }
-  return word;
-}
-function stem(word) {
-  if (word.length < 3) return word;
-  word = word.toLowerCase();
-  const r1 = computeR1(word);
-  word = step1(word, r1);
-  word = undouble(word, r1);
-  word = step3(word, r1);
-  word = step4(word, r1);
-  return word;
+};
+var shared = new DanishStemmer();
+function stem(token) {
+  return shared.stem(token);
 }
+
+// src/languages/danish.ts
 var stopWords = /* @__PURE__ */ new Set([
   "og",
   "i",
@@ -214,11 +313,17 @@ var stopWords = /* @__PURE__ */ new Set([
   "jer",
   "s\xE5dan"
 ]);
+var STRESS_ACCENT = /\u0301/g;
+function normalize(token) {
+  return removeMarks(token, STRESS_ACCENT);
+}
 var danish = {
   name: "danish",
+  revision: "4337c6ed283fa798",
   stemmer: stem,
-  stopWords,
-  tokenizer: { splitPattern: /[^a-z0-9æøå]+/gi }
+  stopWords: withNormalisedSpellings(stopWords, normalize),
+  normalizer: normalize,
+  tokenizer: { splitPattern: /[^a-z0-9æøåé]+/gi }
 };
 
 export { danish };

package/dist/languages/dutch.d.ts

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