mittens 0.3.0 → 0.3.2

data/vendor/snowball/javascript/base-stemmer.js

@@ -1,288 +1,277 @@
 // @ts-check
 
-/**@constructor*/
-const BaseStemmer = function() {
-    /** @protected */
-    this.current = '';
-    this.cursor = 0;
-    this.limit = 0;
-    this.limit_backward = 0;
-    this.bra = 0;
-    this.ket = 0;
+export default class BaseStemmer {
+    constructor() {
+        /** @protected */
+        this.current = '';
+        this.c = 0;
+        this.limit = 0;
+        this.limit_backward = 0;
+        this.bra = 0;
+        this.ket = 0;
+        this.af = 0;
+    }
 
     /**
      * @param {string} value
      */
-    this.setCurrent = function(value) {
+    setCurrent(value) {
         this.current = value;
-        this.cursor = 0;
+        this.c = 0;
         this.limit = this.current.length;
         this.limit_backward = 0;
-        this.bra = this.cursor;
+        this.bra = this.c;
         this.ket = this.limit;
-    };
+    }
 
     /**
      * @return {string}
      */
-    this.getCurrent = function() {
+    getCurrent() {
         return this.current;
-    };
+    }
 
     /**
      * @param {BaseStemmer} other
      */
-    this.copy_from = function(other) {
+    copy_from(other) {
         /** @protected */
         this.current          = other.current;
-        this.cursor           = other.cursor;
+        this.c                = other.c;
         this.limit            = other.limit;
         this.limit_backward   = other.limit_backward;
         this.bra              = other.bra;
         this.ket              = other.ket;
-    };
+    }
 
     /**
-     * @param {number[]} s
+     * @param {Array<number>} s
      * @param {number} min
      * @param {number} max
      * @return {boolean}
      */
-    this.in_grouping = function(s, min, max) {
+    in_grouping(s, min, max) {
         /** @protected */
-        if (this.cursor >= this.limit) return false;
-        var ch = this.current.charCodeAt(this.cursor);
+        if (this.c >= this.limit) return false;
+        let ch = this.current.charCodeAt(this.c);
         if (ch > max || ch < min) return false;
         ch -= min;
-        if ((s[ch >>> 3] & (0x1 << (ch & 0x7))) == 0) return false;
-        this.cursor++;
+        if ((s[ch >>> 3] & (0x1 << (ch & 0x7))) === 0) return false;
+        this.c++;
         return true;
-    };
+    }
 
     /**
-     * @param {number[]} s
+     * @param {Array<number>} s
      * @param {number} min
      * @param {number} max
      * @return {boolean}
      */
-    this.go_in_grouping = function(s, min, max) {
+    go_in_grouping(s, min, max) {
         /** @protected */
-        while (this.cursor < this.limit) {
-            var ch = this.current.charCodeAt(this.cursor);
+        while (this.c < this.limit) {
+            let ch = this.current.charCodeAt(this.c);
             if (ch > max || ch < min)
                 return true;
             ch -= min;
-            if ((s[ch >>> 3] & (0x1 << (ch & 0x7))) == 0)
+            if ((s[ch >>> 3] & (0x1 << (ch & 0x7))) === 0)
                 return true;
-            this.cursor++;
+            this.c++;
         }
         return false;
-    };
+    }
 
     /**
-     * @param {number[]} s
+     * @param {Array<number>} s
      * @param {number} min
      * @param {number} max
      * @return {boolean}
      */
-    this.in_grouping_b = function(s, min, max) {
+    in_grouping_b(s, min, max) {
         /** @protected */
-        if (this.cursor <= this.limit_backward) return false;
-        var ch = this.current.charCodeAt(this.cursor - 1);
+        if (this.c <= this.limit_backward) return false;
+        let ch = this.current.charCodeAt(this.c - 1);
         if (ch > max || ch < min) return false;
         ch -= min;
-        if ((s[ch >>> 3] & (0x1 << (ch & 0x7))) == 0) return false;
-        this.cursor--;
+        if ((s[ch >>> 3] & (0x1 << (ch & 0x7))) === 0) return false;
+        this.c--;
         return true;
-    };
+    }
 
     /**
-     * @param {number[]} s
+     * @param {Array<number>} s
      * @param {number} min
      * @param {number} max
      * @return {boolean}
      */
-    this.go_in_grouping_b = function(s, min, max) {
+    go_in_grouping_b(s, min, max) {
         /** @protected */
-        while (this.cursor > this.limit_backward) {
-            var ch = this.current.charCodeAt(this.cursor - 1);
+        while (this.c > this.limit_backward) {
+            let ch = this.current.charCodeAt(this.c - 1);
             if (ch > max || ch < min) return true;
             ch -= min;
-            if ((s[ch >>> 3] & (0x1 << (ch & 0x7))) == 0) return true;
-            this.cursor--;
+            if ((s[ch >>> 3] & (0x1 << (ch & 0x7))) === 0) return true;
+            this.c--;
         }
         return false;
-    };
+    }
 
     /**
-     * @param {number[]} s
+     * @param {Array<number>} s
      * @param {number} min
      * @param {number} max
      * @return {boolean}
      */
-    this.out_grouping = function(s, min, max) {
+    out_grouping(s, min, max) {
         /** @protected */
-        if (this.cursor >= this.limit) return false;
-        var ch = this.current.charCodeAt(this.cursor);
+        if (this.c >= this.limit) return false;
+        let ch = this.current.charCodeAt(this.c);
         if (ch > max || ch < min) {
-            this.cursor++;
+            this.c++;
             return true;
         }
         ch -= min;
-        if ((s[ch >>> 3] & (0X1 << (ch & 0x7))) == 0) {
-            this.cursor++;
+        if ((s[ch >>> 3] & (0X1 << (ch & 0x7))) === 0) {
+            this.c++;
             return true;
         }
         return false;
-    };
+    }
 
     /**
-     * @param {number[]} s
+     * @param {Array<number>} s
      * @param {number} min
      * @param {number} max
      * @return {boolean}
      */
-    this.go_out_grouping = function(s, min, max) {
+    go_out_grouping(s, min, max) {
         /** @protected */
-        while (this.cursor < this.limit) {
-            var ch = this.current.charCodeAt(this.cursor);
+        while (this.c < this.limit) {
+            let ch = this.current.charCodeAt(this.c);
             if (ch <= max && ch >= min) {
                 ch -= min;
-                if ((s[ch >>> 3] & (0X1 << (ch & 0x7))) != 0) {
+                if ((s[ch >>> 3] & (0X1 << (ch & 0x7))) !== 0) {
                     return true;
                 }
             }
-            this.cursor++;
+            this.c++;
         }
         return false;
-    };
+    }
 
     /**
-     * @param {number[]} s
+     * @param {Array<number>} s
      * @param {number} min
      * @param {number} max
      * @return {boolean}
      */
-    this.out_grouping_b = function(s, min, max) {
+    out_grouping_b(s, min, max) {
         /** @protected */
-        if (this.cursor <= this.limit_backward) return false;
-        var ch = this.current.charCodeAt(this.cursor - 1);
+        if (this.c <= this.limit_backward) return false;
+        let ch = this.current.charCodeAt(this.c - 1);
         if (ch > max || ch < min) {
-            this.cursor--;
+            this.c--;
             return true;
         }
         ch -= min;
-        if ((s[ch >>> 3] & (0x1 << (ch & 0x7))) == 0) {
-            this.cursor--;
+        if ((s[ch >>> 3] & (0x1 << (ch & 0x7))) === 0) {
+            this.c--;
             return true;
         }
         return false;
-    };
+    }
 
     /**
-     * @param {number[]} s
+     * @param {Array<number>} s
      * @param {number} min
      * @param {number} max
      * @return {boolean}
      */
-    this.go_out_grouping_b = function(s, min, max) {
+    go_out_grouping_b(s, min, max) {
         /** @protected */
-        while (this.cursor > this.limit_backward) {
-            var ch = this.current.charCodeAt(this.cursor - 1);
+        while (this.c > this.limit_backward) {
+            let ch = this.current.charCodeAt(this.c - 1);
             if (ch <= max && ch >= min) {
                 ch -= min;
-                if ((s[ch >>> 3] & (0x1 << (ch & 0x7))) != 0) {
+                if ((s[ch >>> 3] & (0x1 << (ch & 0x7))) !== 0) {
                     return true;
                 }
             }
-            this.cursor--;
+            this.c--;
         }
         return false;
-    };
+    }
 
     /**
      * @param {string} s
      * @return {boolean}
      */
-    this.eq_s = function(s)
-    {
+    eq_s(s) {
         /** @protected */
-        if (this.limit - this.cursor < s.length) return false;
-        if (this.current.slice(this.cursor, this.cursor + s.length) != s)
-        {
-            return false;
-        }
-        this.cursor += s.length;
+        if (this.limit - this.c < s.length) return false;
+        if (!this.current.startsWith(s, this.c)) return false;
+        this.c += s.length;
         return true;
-    };
+    }
 
     /**
      * @param {string} s
      * @return {boolean}
      */
-    this.eq_s_b = function(s)
-    {
+    eq_s_b(s) {
         /** @protected */
-        if (this.cursor - this.limit_backward < s.length) return false;
-        if (this.current.slice(this.cursor - s.length, this.cursor) != s)
-        {
-            return false;
-        }
-        this.cursor -= s.length;
+        if (this.c - this.limit_backward < s.length) return false;
+        if (!this.current.endsWith(s, this.c)) return false;
+        this.c -= s.length;
         return true;
-    };
+    }
 
     /**
-     * @param {Among[]} v
+     * @param {Array<Array<string|number>>} v
+     * @param {?function(): boolean} call_among_func
      * @return {number}
      */
-    this.find_among = function(v)
-    {
+    find_among(v, call_among_func) {
         /** @protected */
-        var i = 0;
-        var j = v.length;
-
-        var c = this.cursor;
-        var l = this.limit;
-
-        var common_i = 0;
-        var common_j = 0;
-
-        var first_key_inspected = false;
-
-        while (true)
-        {
-            var k = i + ((j - i) >>> 1);
-            var diff = 0;
-            var common = common_i < common_j ? common_i : common_j; // smaller
-            // w[0]: string, w[1]: substring_i, w[2]: result, w[3]: function (optional)
-            var w = v[k];
-            var i2;
-            for (i2 = common; i2 < w[0].length; i2++)
-            {
-                if (c + common == l)
-                {
+        let i = 0;
+        let j = v.length;
+
+        const c = this.c;
+        const l = this.limit;
+
+        let common_i = 0;
+        let common_j = 0;
+
+        let first_key_inspected = false;
+
+        while (true) {
+            const k = i + ((j - i) >>> 1);
+            let diff = 0;
+            let common = common_i < common_j ? common_i : common_j; // smaller
+            // w[0]: string, w[1]: result, w[2]: substring_i (optional), w[3]: function (optional)
+            const w = v[k];
+            let i2;
+            // @ts-expect-error: w[0] always string.
+            for (i2 = common; i2 < w[0].length; i2++) {
+                if (c + common === l) {
                     diff = -1;
                     break;
                 }
+                // @ts-expect-error: w[0] always string.
                 diff = this.current.charCodeAt(c + common) - w[0].charCodeAt(i2);
-                if (diff != 0) break;
+                if (diff !== 0) break;
                 common++;
             }
-            if (diff < 0)
-            {
+            if (diff < 0) {
                 j = k;
                 common_j = common;
-            }
-            else
-            {
+            } else {
                 i = k;
                 common_i = common;
             }
-            if (j - i <= 1)
-            {
+            if (j - i <= 1) {
                 if (i > 0) break; // v->s has been inspected
-                if (j == i) break; // only one item in v
+                if (j === i) break; // only one item in v
 
                 // - but now we need to go round once more to get
                 // v->s inspected. This looks messy, but is actually
@@ -292,90 +281,102 @@ const BaseStemmer = function() {
                 first_key_inspected = true;
             }
         }
-        do {
-            var w = v[i];
-            if (common_i >= w[0].length)
-            {
-                this.cursor = c + w[0].length;
-                if (w.length < 4) return w[2];
-                var res = w[3](this);
-                this.cursor = c + w[0].length;
-                if (res) return w[2];
+        while (true) {
+            const w = v[i];
+            // @ts-expect-error: w[0] always string.
+            if (common_i >= w[0].length) {
+                // @ts-expect-error: w[0] always string.
+                this.c = c + w[0].length;
+                // @ts-expect-error: w[1] always number.
+                if (w.length < 4) return w[1];
+                // @ts-expect-error: w[3] always number.
+                this.af = w[3];
+                // @ts-expect-error: call_among_func never null here.
+                if (call_among_func.call(this)) {
+                    // @ts-expect-error: w[0] always string.
+                    this.c = c + w[0].length;
+                    // @ts-expect-error: w[3] always number.
+                    return w[1];
+                }
             }
-            i = w[1];
-        } while (i >= 0);
-        return 0;
-    };
+            // Tests for undefined (if w.length < 2) or 0.
+            if (!w[2]) return 0;
+            // @ts-expect-error: w[2] always number.
+            i -= w[2];
+        }
+    }
 
     // find_among_b is for backwards processing. Same comments apply
     /**
-     * @param {Among[]} v
-     * @return {number}
+     * @param {Array<Array<string|number>>} v
+     * @param {?function(): boolean} call_among_func
      */
-    this.find_among_b = function(v)
-    {
+    find_among_b(v, call_among_func) {
         /** @protected */
-        var i = 0;
-        var j = v.length
-
-        var c = this.cursor;
-        var lb = this.limit_backward;
-
-        var common_i = 0;
-        var common_j = 0;
-
-        var first_key_inspected = false;
-
-        while (true)
-        {
-            var k = i + ((j - i) >> 1);
-            var diff = 0;
-            var common = common_i < common_j ? common_i : common_j;
-            var w = v[k];
-            var i2;
-            for (i2 = w[0].length - 1 - common; i2 >= 0; i2--)
-            {
-                if (c - common == lb)
-                {
+        let i = 0;
+        let j = v.length
+
+        const c = this.c;
+        const lb = this.limit_backward;
+
+        let common_i = 0;
+        let common_j = 0;
+
+        let first_key_inspected = false;
+
+        while (true) {
+            const k = i + ((j - i) >> 1);
+            let diff = 0;
+            let common = common_i < common_j ? common_i : common_j;
+            const w = v[k];
+            let i2;
+            // @ts-expect-error: w[0] always string.
+            for (i2 = w[0].length - 1 - common; i2 >= 0; i2--) {
+                if (c - common === lb) {
                     diff = -1;
                     break;
                 }
+                // @ts-expect-error: w[0] always string.
                 diff = this.current.charCodeAt(c - 1 - common) - w[0].charCodeAt(i2);
-                if (diff != 0) break;
+                if (diff !== 0) break;
                 common++;
             }
-            if (diff < 0)
-            {
+            if (diff < 0) {
                 j = k;
                 common_j = common;
-            }
-            else
-            {
+            } else {
                 i = k;
                 common_i = common;
             }
-            if (j - i <= 1)
-            {
+            if (j - i <= 1) {
                 if (i > 0) break;
-                if (j == i) break;
+                if (j === i) break;
                 if (first_key_inspected) break;
                 first_key_inspected = true;
             }
         }
-        do {
-            var w = v[i];
-            if (common_i >= w[0].length)
-            {
-                this.cursor = c - w[0].length;
-                if (w.length < 4) return w[2];
-                var res = w[3](this);
-                this.cursor = c - w[0].length;
-                if (res) return w[2];
+        while (true) {
+            const w = v[i];
+            // @ts-expect-error: w[0] always string.
+            if (common_i >= w[0].length) {
+                // @ts-expect-error: w[0] always string.
+                this.c = c - w[0].length;
+                if (w.length < 4) return w[1];
+                // @ts-expect-error: w[3] always number.
+                this.af = w[3];
+                // @ts-expect-error: call_among_func never null here.
+                if (call_among_func.call(this)) {
+                    // @ts-expect-error: w[0] always string.
+                    this.c = c - w[0].length;
+                    return w[1];
+                }
             }
-            i = w[1];
-        } while (i >= 0);
-        return 0;
-    };
+            // Tests for undefined (if w.length < 2) or 0.
+            if (!w[2]) return 0;
+            // @ts-expect-error: w[2] always number.
+            i -= w[2];
+        }
+    }
 
     /* to replace chars between c_bra and c_ket in this.current by the
      * chars in s.
@@ -386,93 +387,59 @@ const BaseStemmer = function() {
      * @param {string} s
      * @return {number}
      */
-    this.replace_s = function(c_bra, c_ket, s)
-    {
-        /** @protected */
-        var adjustment = s.length - (c_ket - c_bra);
+    #replace_s(c_bra, c_ket, s) {
+        const adjustment = s.length - (c_ket - c_bra);
         this.current = this.current.slice(0, c_bra) + s + this.current.slice(c_ket);
         this.limit += adjustment;
-        if (this.cursor >= c_ket) this.cursor += adjustment;
-        else if (this.cursor > c_bra) this.cursor = c_bra;
+        if (this.c >= c_ket) this.c += adjustment;
+        else if (this.c > c_bra) this.c = c_bra;
         return adjustment;
-    };
+    }
 
     /**
-     * @return {boolean}
      */
-    this.slice_check = function()
-    {
-        /** @protected */
-        if (this.bra < 0 ||
-            this.bra > this.ket ||
-            this.ket > this.limit ||
-            this.limit > this.current.length)
-        {
-            return false;
-        }
-        return true;
-    };
+    #slice_check() {
+        console.assert(this.bra >= 0);
+        console.assert(this.bra <= this.ket);
+        console.assert(this.ket <= this.limit);
+        console.assert(this.limit <= this.current.length);
+    }
 
     /**
-     * @param {number} c_bra
-     * @return {boolean}
+     * @param {string} s
      */
-    this.slice_from = function(s)
-    {
+    slice_from(s) {
         /** @protected */
-        var result = false;
-        if (this.slice_check())
-        {
-            this.replace_s(this.bra, this.ket, s);
-            result = true;
-        }
-        return result;
-    };
+        this.#slice_check();
+        this.#replace_s(this.bra, this.ket, s);
+        this.ket = this.bra + s.length;
+    }
 
     /**
-     * @return {boolean}
      */
-    this.slice_del = function()
-    {
+    slice_del() {
         /** @protected */
-        return this.slice_from("");
-    };
+        this.slice_from("");
+    }
 
     /**
      * @param {number} c_bra
      * @param {number} c_ket
      * @param {string} s
      */
-    this.insert = function(c_bra, c_ket, s)
-    {
+    insert(c_bra, c_ket, s) {
         /** @protected */
-        var adjustment = this.replace_s(c_bra, c_ket, s);
+        const adjustment = this.#replace_s(c_bra, c_ket, s);
         if (c_bra <= this.bra) this.bra += adjustment;
         if (c_bra <= this.ket) this.ket += adjustment;
-    };
+    }
 
     /**
      * @return {string}
      */
-    this.slice_to = function()
-    {
+    slice_to() {
         /** @protected */
-        var result = '';
-        if (this.slice_check())
-        {
-            result = this.current.slice(this.bra, this.ket);
-        }
-        return result;
-    };
-
-    /**
-     * @return {string}
-     */
-    this.assign_to = function()
-    {
-        /** @protected */
-        return this.current.slice(0, this.limit);
-    };
-};
-
-if (typeof module === 'object' && module.exports) module.exports = BaseStemmer;
+        this.#slice_check();
+        return this.current.slice(this.bra, this.ket);
+    }
+}