@woosh/meep-engine 2.96.0 → 2.97.0

package/build/meep.cjs

@@ -69974,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);
 };
 
 /**
@@ -71492,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);
 
@@ -82205,22 +82216,20 @@ function seedVariablesIntoTemplateString(template, seed) {
 }
 
 /**
- * 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
+ * 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_winkler(first, second) {
-    const l1 = first.length;
-    const l2 = second.length;
-
-    if (l1 === 0 && l2 === 0) {
-        // special case for empty string
-        return 1;
-    }
+function string_jaro_distance(
+    first, second,
+    first_length, second_length
+) {
 
-    const matches1 = BitSet.fixedSize(l1);
-    const matches2 = BitSet.fixedSize(l2);
+    const matches1 = BitSet.fixedSize(first_length);
+    const matches2 = BitSet.fixedSize(second_length);
 
     const matches = getMatching(first, second, matches1, matches2);
 
@@ -82228,15 +82237,9 @@ function string_jaro_winkler(first, second) {
         return 0;
     }
 
-    // Calculate the Jaro distance:
     const transpositions = getTranspositions(first, second, matches1, matches2);
-    const similarity = (matches / l1 + matches / l2 + (matches - transpositions) / matches) / 3;
+    return (matches / first_length + matches / second_length + (matches - transpositions) / matches) / 3;
 
-    // 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);
 }
 
 /**
@@ -82298,8 +82301,12 @@ function getMatching(a1, a2, matches1, matches2) {
  * @param {string} a2 The second string to compare
  * @param {BitSet} matches1
  * @param {BitSet} matches2
+ * @returns {number}
  */
-function getTranspositions(a1, a2, matches1, matches2) {
+function getTranspositions(
+    a1, a2,
+    matches1, matches2
+) {
     let transpositions = 0;
 
     // Loop to find transpositions:
@@ -82330,6 +82337,36 @@ function getTranspositions(a1, a2, matches1, matches2) {
     }
 
     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);
 }
 
 /**