@woosh/meep-engine 2.95.1 → 2.97.0

package/build/meep.cjs

@@ -3171,35 +3171,39 @@ const cos$1 = Math.cos;
 let Quaternion$1 = class Quaternion {
     /**
      *
-     * @param {Number} [x=0]
-     * @param {Number} [y=0]
-     * @param {Number} [z=0]
-     * @param {Number} [w=1]
+     * @param {number} [x=0]
+     * @param {number} [y=0]
+     * @param {number} [z=0]
+     * @param {number} [w=1]
      * @constructor
      */
     constructor(x = 0, y = 0, z = 0, w = 1) {
 
         /**
          *
-         * @type {Number}
+         * @type {number}
          */
         this.x = x;
         /**
          *
-         * @type {Number}
+         * @type {number}
          */
         this.y = y;
         /**
          *
-         * @type {Number}
+         * @type {number}
          */
         this.z = z;
         /**
          *
-         * @type {Number}
+         * @type {number}
          */
         this.w = w;
 
+        /**
+         * @readonly
+         * @type {Signal<number, number, number, number, number, number, number, number>}
+         */
         this.onChanged = new Signal();
     }
 
@@ -4481,6 +4485,7 @@ let Quaternion$1 = class Quaternion {
 
     /**
      * Based on GDC talk from Bungie on destiny, compressing quaternions for animation
+     * @deprecated use `quat_decode_from_uint32` instead
      * @param {number} value
      */
     decodeFromUint32(value) {
@@ -4489,6 +4494,7 @@ let Quaternion$1 = class Quaternion {
 
     /**
      * Based on GDC talk from Bungie on destiny, compressing quaternions for animation
+     * @deprecated use `quat_encode_to_uint32` instead
      * @returns {number}
      */
     encodeToUint32() {
@@ -69968,13 +69974,15 @@ BitSet.prototype.setShrinkFactor = function (x) {
 
 /**
  *
- * @param {number} numBits
+ * @param {number} bit_count
  */
-BitSet.prototype.setCapacity = function (numBits) {
-    if (this.__length > numBits) {
-        throw  new Error(`Current length is greater than requested size`);
+BitSet.prototype.setCapacity = function (bit_count) {
+
+    if (this.__length > bit_count) {
+        throw  new Error(`Current length(=${this.__length}) is greater than requested size(=${bit_count})`);
     }
-    this.__resize(numBits);
+
+    this.__resize(bit_count);
 };
 
 /**
@@ -71486,8 +71494,17 @@ class Graph {
      */
     findPath(start, goal) {
         const start_node_container = this.__nodes.get(start);
+
+        if (start_node_container === undefined) {
+            throw new Error(`Start node not found in the graph '${start}'`);
+        }
+
         const goal_node_container = this.__nodes.get(goal);
 
+        if (goal_node_container === undefined) {
+            throw new Error(`Goal node not found in the graph '${goal}'`);
+        }
+
         const open = new Set();
         open.add(start_node_container);
 
@@ -81288,132 +81305,6 @@ class Tag {
 
 Tag.typeName = "Tag";
 
-const peq = new Uint32Array(0x10000);
-const myers_32 = (a, b) => {
-    const n = a.length;
-    const m = b.length;
-    const lst = 1 << (n - 1);
-    let pv = -1;
-    let mv = 0;
-    let sc = n;
-    let i = n;
-    while (i--) {
-        peq[a.charCodeAt(i)] |= 1 << i;
-    }
-    for (i = 0; i < m; i++) {
-        let eq = peq[b.charCodeAt(i)];
-        const xv = eq | mv;
-        eq |= ((eq & pv) + pv) ^ pv;
-        mv |= ~(eq | pv);
-        pv &= eq;
-        if (mv & lst) {
-            sc++;
-        }
-        if (pv & lst) {
-            sc--;
-        }
-        mv = (mv << 1) | 1;
-        pv = (pv << 1) | ~(xv | mv);
-        mv &= xv;
-    }
-    i = n;
-    while (i--) {
-        peq[a.charCodeAt(i)] = 0;
-    }
-    return sc;
-};
-const myers_x = (b, a) => {
-    const n = a.length;
-    const m = b.length;
-    const mhc = [];
-    const phc = [];
-    const hsize = Math.ceil(n / 32);
-    const vsize = Math.ceil(m / 32);
-    for (let i = 0; i < hsize; i++) {
-        phc[i] = -1;
-        mhc[i] = 0;
-    }
-    let j = 0;
-    for (; j < vsize - 1; j++) {
-        let mv = 0;
-        let pv = -1;
-        const start = j * 32;
-        const vlen = Math.min(32, m) + start;
-        for (let k = start; k < vlen; k++) {
-            peq[b.charCodeAt(k)] |= 1 << k;
-        }
-        for (let i = 0; i < n; i++) {
-            const eq = peq[a.charCodeAt(i)];
-            const pb = (phc[(i / 32) | 0] >>> i) & 1;
-            const mb = (mhc[(i / 32) | 0] >>> i) & 1;
-            const xv = eq | mv;
-            const xh = ((((eq | mb) & pv) + pv) ^ pv) | eq | mb;
-            let ph = mv | ~(xh | pv);
-            let mh = pv & xh;
-            if ((ph >>> 31) ^ pb) {
-                phc[(i / 32) | 0] ^= 1 << i;
-            }
-            if ((mh >>> 31) ^ mb) {
-                mhc[(i / 32) | 0] ^= 1 << i;
-            }
-            ph = (ph << 1) | pb;
-            mh = (mh << 1) | mb;
-            pv = mh | ~(xv | ph);
-            mv = ph & xv;
-        }
-        for (let k = start; k < vlen; k++) {
-            peq[b.charCodeAt(k)] = 0;
-        }
-    }
-    let mv = 0;
-    let pv = -1;
-    const start = j * 32;
-    const vlen = Math.min(32, m - start) + start;
-    for (let k = start; k < vlen; k++) {
-        peq[b.charCodeAt(k)] |= 1 << k;
-    }
-    let score = m;
-    for (let i = 0; i < n; i++) {
-        const eq = peq[a.charCodeAt(i)];
-        const pb = (phc[(i / 32) | 0] >>> i) & 1;
-        const mb = (mhc[(i / 32) | 0] >>> i) & 1;
-        const xv = eq | mv;
-        const xh = ((((eq | mb) & pv) + pv) ^ pv) | eq | mb;
-        let ph = mv | ~(xh | pv);
-        let mh = pv & xh;
-        score += (ph >>> (m - 1)) & 1;
-        score -= (mh >>> (m - 1)) & 1;
-        if ((ph >>> 31) ^ pb) {
-            phc[(i / 32) | 0] ^= 1 << i;
-        }
-        if ((mh >>> 31) ^ mb) {
-            mhc[(i / 32) | 0] ^= 1 << i;
-        }
-        ph = (ph << 1) | pb;
-        mh = (mh << 1) | mb;
-        pv = mh | ~(xv | ph);
-        mv = ph & xv;
-    }
-    for (let k = start; k < vlen; k++) {
-        peq[b.charCodeAt(k)] = 0;
-    }
-    return score;
-};
-const distance = (a, b) => {
-    if (a.length < b.length) {
-        const tmp = b;
-        b = a;
-        a = tmp;
-    }
-    if (b.length === 0) {
-        return a.length;
-    }
-    if (a.length <= 32) {
-        return myers_32(a, b);
-    }
-    return myers_x(a, b);
-};
-
 class Token {
     /**
      * @template V,T
@@ -82324,6 +82215,187 @@ function seedVariablesIntoTemplateString(template, seed) {
     return result;
 }
 
+/**
+ * Calculate Jaro distance between two strings, this is a measure of string similarity. Higher value means more similarity.
+ * @param {string} first
+ * @param {string} second
+ * @param {number} first_length
+ * @param {number} second_length
+ * @return {number}
+ */
+function string_jaro_distance(
+    first, second,
+    first_length, second_length
+) {
+
+    const matches1 = BitSet.fixedSize(first_length);
+    const matches2 = BitSet.fixedSize(second_length);
+
+    const matches = getMatching(first, second, matches1, matches2);
+
+    if (matches <= 0) {
+        return 0;
+    }
+
+    const transpositions = getTranspositions(first, second, matches1, matches2);
+    return (matches / first_length + matches / second_length + (matches - transpositions) / matches) / 3;
+
+}
+
+/**
+ * Find matching characters in both strings according to Jaro algorithm
+ * @param {string} a1
+ * @param {string} a2
+ * @param {BitSet} matches1
+ * @param {BitSet} matches2
+ * @return {number}
+ */
+function getMatching(a1, a2, matches1, matches2) {
+    const a1_length = a1.length;
+    const a2_length = a2.length;
+
+    // Window is modified to work with string of length 1
+    const matchWindow = max2(
+        0,
+        Math.floor(max2(a1_length, a2_length) * 0.5) - 1
+    );
+
+    let matches = 0;
+
+    // Loop to find matched characters:
+    for (let index1 = 0; index1 < a1_length; index1++) {
+
+        // Use the highest of the window diff and the min of the window and string 2 length:
+        const start = max2(0, index1 - matchWindow);
+        const end = min2(index1 + matchWindow + 1, a2_length);
+
+        // Iterate second string index:
+        for (let index2 = start; index2 < end; index2++) {
+
+            // If second string character already matched, skip:
+            if (matches2.get(index2)) {
+                continue;
+            }
+
+            // If the characters don't match, skip:
+            if (a1.charAt(index1) !== a2.charAt(index2)) {
+                continue;
+            }
+
+            // Assume match if the above 2 checks don't continue:
+            matches1.set(index1, true);
+            matches2.set(index2, true);
+
+            // Add matches by 1, break inner loop:
+            ++matches;
+            break;
+        }
+    }
+
+    return matches;
+}
+
+/**
+ * Calculate the number of transpositions between the two words
+ * @param {string} a1 The first string to compare
+ * @param {string} a2 The second string to compare
+ * @param {BitSet} matches1
+ * @param {BitSet} matches2
+ * @returns {number}
+ */
+function getTranspositions(
+    a1, a2,
+    matches1, matches2
+) {
+    let transpositions = 0;
+
+    // Loop to find transpositions:
+    const a1_length = a1.length;
+    const a2_length = a2.length;
+
+    for (let i1 = 0, i2 = 0; i1 < a1_length; i1++) {
+        // If a non-matching character was found, skip:
+        if (matches1.get(i1) === false) {
+            continue;
+        }
+
+        // Move i2 index to the next match:
+        while (
+            i2 < a2_length
+            && matches2.get(i2) === false
+            ) {
+            i2++;
+        }
+
+        // If the characters don't match, increase transposition:
+        if (a1.charAt(i1) !== a2.charAt(i2)) {
+            transpositions++;
+        }
+
+        // Iterate i2 index normally:
+        i2++;
+    }
+
+    return Math.floor(transpositions * 0.5);
+}
+
+/**
+ * Calculate the Jaro-Winkler distance between two strings
+ * @param {string} first The string to compare
+ * @param {string} second The string to compare with
+ * @returns {number} similarity score, higher value means strings are more similar
+ */
+function string_jaro_winkler(first, second) {
+    const l1 = first.length;
+    const l2 = second.length;
+
+    if (l1 === 0 && l2 === 0) {
+        // special case for empty string
+        return 1;
+    }
+
+    // Calculate the Jaro distance:
+    const similarity = string_jaro_distance(first, second, l1, l2);
+
+    if (similarity === 0) {
+        // no similarity at all
+        return 0;
+    }
+
+    // Transform to Jaro-Winkler:
+    // Prefix scale gives more favorable ratings to strings that share common prefixes:
+    const prefix_scale = 0.1;
+    const prefix = getPrefix(first, second, min3(l1, l2, 4));
+    return similarity + prefix * prefix_scale * (1 - similarity);
+}
+
+/**
+ * Counts the number of common characters at the beginning
+ * of each word up to a maximum of 4
+ * @param {string} a1 The first string to compare
+ * @param {string} a2 The second string to compare
+ * @param {number} character_limit
+ * @returns {number}
+ */
+function getPrefix(a1, a2, character_limit) {
+
+    let p = 0;
+
+    for (; p < character_limit; p++) {
+        if (a1.charAt(p) !== a2.charAt(p)) {
+            return p;
+        }
+    }
+
+    return ++p;
+}
+
+/**
+ * Higher value means string are more similar
+ * @type {(function(string, string): number)}
+ */
+const string_compute_similarity = string_jaro_winkler;
+
 /**
  * Represents information about a language
  */
@@ -82529,7 +82601,7 @@ class Localization {
      * @param {number} value
      */
     formatIntegerByThousands(value) {
-        const formatter = new Intl.NumberFormat(this.locale.getValue(), {useGrouping: true});
+        const formatter = new Intl.NumberFormat(this.locale.getValue(), { useGrouping: true });
 
         return formatter.format(value);
     }
@@ -82549,10 +82621,10 @@ class Localization {
 
             //try to find similar keys
             const similarities = Object.keys(this.json).map(function (key) {
-                const distance$1 = distance(key, id);
+                const distance = string_compute_similarity(key, id);
                 return {
                     key,
-                    distance: distance$1
+                    distance
                 };
             });