@woosh/meep-engine 2.96.0 → 2.97.0

package/build/meep.module.js

@@ -69972,13 +69972,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);
 };
 
 /**
@@ -71490,8 +71492,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);
 
@@ -82203,22 +82214,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);
 
@@ -82226,15 +82235,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);
 }
 
 /**
@@ -82296,8 +82299,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:
@@ -82328,6 +82335,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);
 }
 
 /**

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.96.0",
+  "version": "2.97.0",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/binary/BitSet.d.ts

@@ -34,9 +34,9 @@ export class BitSet {
     setShrinkFactor(x: number): void;
     /**
      *
-     * @param {number} numBits
+     * @param {number} bit_count
      */
-    setCapacity(numBits: number): void;
+    setCapacity(bit_count: number): void;
     /**
      * Number of bits currently used for flags.
      * @returns {number}

package/src/core/binary/BitSet.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BitSet.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/BitSet.js"],"names":[],"mappings":"AA6DA;;;GAGG;AACH,+BA0BC;;IAzBG;;;;OAIG;IACH,iBAAiB;IAEjB;;;;OAIG;IACH,mBAAoB;IAEpB;;;;OAIG;IACH,sBAA0D;IAE1D;;OAEG;IACH,gBAFU,MAAM,CAEmB;IAGvC,sBAEC;IAED;;;OAGG;IACH,mBAFW,MAAM,QAOhB;IAED;;;OAGG;IACH,qBAFW,MAAM,QAOhB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,YAFa,MAAM,CAIlB;IAO2B,iBAsB3B;IAED,uBAMC;IAO8B,oBAyB9B;IAED;;;;OAIG;IACH,oCAqCC;IAED;;;;OAIG;IACH,4BAFa,MAAM,CAuDlB;IAED;;;;OAIG;IACH,8BAFa,MAAM,CAkDlB;IAED;;;;OAIG;IACH,0BAFW,OAAO,QAmCjB;IAED;;;OAGG;IACH,2BAEC;IAED;;;;OAIG;IACH,qBAHW,MAAM,YACN,MAAM,QAWhB;IAED;;;;OAIG;IACH,uBAHW,MAAM,YACN,MAAM,QAShB;IAGD;;;OAGG;IACH,SAFW,MAAM,SAIhB;IAED;;;;OAIG;IACH,oBAFa,OAAO,CAkBnB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,OAAO,CAUnB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,OAAO,CAUnB;IAED;;;;;OAKG;IACH,sBAJW,MAAM,eACN,MAAM,aACN,MAAM,QAShB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,eACN,MAAM,aACN,MAAM,QAShB;IAED;;;;;OAKG;IACH,gBAJW,MAAM,eACN,MAAM,aACN,MAAM,QAQhB;IAED;;OAEG;IACH,cAgBC;IAED;;;OAGG;IACH,YAFW,MAAM,QAoChB;;;IAED;;;;OAIG;IACH,sCASC"}
+{"version":3,"file":"BitSet.d.ts","sourceRoot":"","sources":["../../../../src/core/binary/BitSet.js"],"names":[],"mappings":"AA6DA;;;GAGG;AACH,+BA0BC;;IAzBG;;;;OAIG;IACH,iBAAiB;IAEjB;;;;OAIG;IACH,mBAAoB;IAEpB;;;;OAIG;IACH,sBAA0D;IAE1D;;OAEG;IACH,gBAFU,MAAM,CAEmB;IAGvC,sBAEC;IAED;;;OAGG;IACH,mBAFW,MAAM,QAOhB;IAED;;;OAGG;IACH,uBAFW,MAAM,QAUhB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,YAFa,MAAM,CAIlB;IAO2B,iBAsB3B;IAED,uBAMC;IAO8B,oBAyB9B;IAED;;;;OAIG;IACH,oCAqCC;IAED;;;;OAIG;IACH,4BAFa,MAAM,CAuDlB;IAED;;;;OAIG;IACH,8BAFa,MAAM,CAkDlB;IAED;;;;OAIG;IACH,0BAFW,OAAO,QAmCjB;IAED;;;OAGG;IACH,2BAEC;IAED;;;;OAIG;IACH,qBAHW,MAAM,YACN,MAAM,QAWhB;IAED;;;;OAIG;IACH,uBAHW,MAAM,YACN,MAAM,QAShB;IAGD;;;OAGG;IACH,SAFW,MAAM,SAIhB;IAED;;;;OAIG;IACH,oBAFa,OAAO,CAkBnB;IAED;;;;OAIG;IACH,iBAHW,MAAM,GACJ,OAAO,CAUnB;IAED;;;;OAIG;IACH,mBAHW,MAAM,GACJ,OAAO,CAUnB;IAED;;;;;OAKG;IACH,sBAJW,MAAM,eACN,MAAM,aACN,MAAM,QAShB;IAED;;;;;OAKG;IACH,qBAJW,MAAM,eACN,MAAM,aACN,MAAM,QAShB;IAED;;;;;OAKG;IACH,gBAJW,MAAM,eACN,MAAM,aACN,MAAM,QAQhB;IAED;;OAEG;IACH,cAgBC;IAED;;;OAGG;IACH,YAFW,MAAM,QAoChB;;;IAED;;;;OAIG;IACH,sCASC"}

package/src/core/binary/BitSet.js

@@ -108,13 +108,16 @@ 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) {
+    assert.isNonNegativeInteger(bit_count, "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);
 };
 
 /**

package/src/core/graph/v2/Graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Graph.d.ts","sourceRoot":"","sources":["../../../../../src/core/graph/v2/Graph.js"],"names":[],"mappings":"AAyBA;;GAEG;AACH;IAEI;;;;;OAKG;IACH,yBAAoB;IACpB;;;;;OAKG;IACH,yBAAoB;IAEpB;;OAEG;IACH;QACI;;WAEG;mBADO,OAAO,CAAC,EAAC,IAAI,CAAC;QAGxB;;WAEG;qBADO,OAAO,CAAC,EAAC,IAAI,CAAC;;;MAK1B;IAGF;;;;OAIG;IACH,cAHW,CAAC,GACC,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,CAAC,GACC,OAAO,CAenB;IAED;;;;OAIG;IACH,iBAHW,CAAC,GACC,OAAO,CAiBnB;IAED;;;;OAIG;IACH,8BAHoB,CAAC,+BAOpB;IAED,wBAEC;IAED;;;OAGG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,wBAJoB,CAAC,KAAE,OAAO,kBAEjB,CAAC,GAAC,SAAS,CAgBvB;IAED;;;;OAIG;IACH,uBAHW,CAAC,GACC,cAAc,CAAC,CAAC,GAAC,SAAS,CAItC;IAED;;;;OAIG;IACH,oBAHW,CAAC,GACA,MAAM,CAUjB;IAED;;;OAGG;IACH,iBAEC;IAED;;;OAGG;IACH,YAFY,SAAS,CAAC,CAAC,CAItB;IAED;;;OAGG;IACH,YAFY,IAAI,KAAK,CAAC,CAAC,CAAC,CAIvB;IAED;;;;;;OAMG;IACH,mBALW,CAAC,UACD,CAAC,cACD,iBAAiB,GACf,KAAK,CAAC,CAAC,CAgBnB;IAED;;;;;OAKG;IACH,cAJW,KAAK,CAAC,CAAC,GACL,OAAO,CA4BnB;IAED;;;;OAIG;IACH,iBAHW,KAAK,CAAC,CAAC,GACL,OAAO,CAwBnB;IAED;;;;OAIG;IACH,cAHW,KAAK,CAAC,CAAC,GACL,OAAO,CAQnB;IAED;;;;OAIG;IACH,8BAHoB,KAAK,CAAC,CAAC,+BAO1B;IAED,wBAEC;IAED;;;;;OAKG;IACH,qBAJW,CAAC,KACD,CAAC,GACC,OAAO,CAWnB;IAED;;;;;OAKG;IACH,qBAJW,CAAC,KACD,CAAC,GACC,KAAK,CAAC,CAAC,GAAC,SAAS,CAiB7B;IAED;;;;;OAKG;IACH,yBAJW,CAAC,MACD,CAAC,GACC,KAAK,CAAC,CAAC,GAAC,SAAS,CAU7B;IAED;;;;;OAKG;IACH,yBAJW,KAAK,CAAC,CAAC,EAAE,QACT,CAAC,GACC,MAAM,CA2BlB;IAED;;;;OAIG;IACH,oBAHW,CAAC,GACC,CAAC,EAAE,CAUf;IAED;;;;OAIG;IACH,mBAHW,CAAC,GACC,OAAO,CAYnB;IAED;;;;;OAKG;IACH,gBAJW,CAAC,QACD,CAAC,GACC,IAAI,GAAC,CAAC,EAAE,CAmEpB;IAED;;OAEG;IACH,cAGC;IAED;;;OAGG;IACH,YAFW,MAAM,CAAC,CAAC,QAOlB;IAED;;OAEG;IACH,SAFa,MAAM,CAAC,CAAC,CAQpB;CACJ;mBA7hBkB,+BAA+B;8BAEpB,oBAAoB;qBADV,YAAY;kCAAZ,YAAY"}
+{"version":3,"file":"Graph.d.ts","sourceRoot":"","sources":["../../../../../src/core/graph/v2/Graph.js"],"names":[],"mappings":"AAyBA;;GAEG;AACH;IAEI;;;;;OAKG;IACH,yBAAoB;IACpB;;;;;OAKG;IACH,yBAAoB;IAEpB;;OAEG;IACH;QACI;;WAEG;mBADO,OAAO,CAAC,EAAC,IAAI,CAAC;QAGxB;;WAEG;qBADO,OAAO,CAAC,EAAC,IAAI,CAAC;;;MAK1B;IAGF;;;;OAIG;IACH,cAHW,CAAC,GACC,OAAO,CAInB;IAED;;;;OAIG;IACH,cAHW,CAAC,GACC,OAAO,CAenB;IAED;;;;OAIG;IACH,iBAHW,CAAC,GACC,OAAO,CAiBnB;IAED;;;;OAIG;IACH,8BAHoB,CAAC,+BAOpB;IAED,wBAEC;IAED;;;OAGG;IACH,gBAFa,MAAM,CAIlB;IAED;;;;;OAKG;IACH,wBAJoB,CAAC,KAAE,OAAO,kBAEjB,CAAC,GAAC,SAAS,CAgBvB;IAED;;;;OAIG;IACH,uBAHW,CAAC,GACC,cAAc,CAAC,CAAC,GAAC,SAAS,CAItC;IAED;;;;OAIG;IACH,oBAHW,CAAC,GACA,MAAM,CAUjB;IAED;;;OAGG;IACH,iBAEC;IAED;;;OAGG;IACH,YAFY,SAAS,CAAC,CAAC,CAItB;IAED;;;OAGG;IACH,YAFY,IAAI,KAAK,CAAC,CAAC,CAAC,CAIvB;IAED;;;;;;OAMG;IACH,mBALW,CAAC,UACD,CAAC,cACD,iBAAiB,GACf,KAAK,CAAC,CAAC,CAgBnB;IAED;;;;;OAKG;IACH,cAJW,KAAK,CAAC,CAAC,GACL,OAAO,CA4BnB;IAED;;;;OAIG;IACH,iBAHW,KAAK,CAAC,CAAC,GACL,OAAO,CAwBnB;IAED;;;;OAIG;IACH,cAHW,KAAK,CAAC,CAAC,GACL,OAAO,CAQnB;IAED;;;;OAIG;IACH,8BAHoB,KAAK,CAAC,CAAC,+BAO1B;IAED,wBAEC;IAED;;;;;OAKG;IACH,qBAJW,CAAC,KACD,CAAC,GACC,OAAO,CAWnB;IAED;;;;;OAKG;IACH,qBAJW,CAAC,KACD,CAAC,GACC,KAAK,CAAC,CAAC,GAAC,SAAS,CAiB7B;IAED;;;;;OAKG;IACH,yBAJW,CAAC,MACD,CAAC,GACC,KAAK,CAAC,CAAC,GAAC,SAAS,CAU7B;IAED;;;;;OAKG;IACH,yBAJW,KAAK,CAAC,CAAC,EAAE,QACT,CAAC,GACC,MAAM,CA2BlB;IAED;;;;OAIG;IACH,oBAHW,CAAC,GACC,CAAC,EAAE,CAUf;IAED;;;;OAIG;IACH,mBAHW,CAAC,GACC,OAAO,CAYnB;IAED;;;;;OAKG;IACH,gBAJW,CAAC,QACD,CAAC,GACC,IAAI,GAAC,CAAC,EAAE,CA4EpB;IAED;;OAEG;IACH,cAGC;IAED;;;OAGG;IACH,YAFW,MAAM,CAAC,CAAC,QAOlB;IAED;;OAEG;IACH,SAFa,MAAM,CAAC,CAAC,CAQpB;CACJ;mBAtiBkB,+BAA+B;8BAEpB,oBAAoB;qBADV,YAAY;kCAAZ,YAAY"}

package/src/core/graph/v2/Graph.js

@@ -446,8 +446,17 @@ export 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);
 

package/src/core/math/spline/computeNonuniformCaltmullRomSplineDerivative.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Computes derivative of Catmull Rom spline
+ * @param {number[]} result_value
+ * @param {number} result_value_offset
+ * @param {number[]} result_derivative
+ * @param {number} result_derivative_offset
+ * @param {number[]} p0 spline point 0
+ * @param {number[]} p1 spline point 1
+ * @param {number[]} p2 spline point 2
+ * @param {number[]} p3 spline point 3
+ * @param {number} dimensions number of dimensions in the input and output vectors
+ * @param {number} f between 0..1
+ * @param {number} alpha between 0..1
+ */
+export function computeNonuniformCaltmullRomSplineDerivative(result_value: number[], result_value_offset: number, result_derivative: number[], result_derivative_offset: number, p0: number[], p1: number[], p2: number[], p3: number[], dimensions: number, f: number, alpha: number): void;
+//# sourceMappingURL=computeNonuniformCaltmullRomSplineDerivative.d.ts.map

package/src/core/math/spline/computeNonuniformCaltmullRomSplineDerivative.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"computeNonuniformCaltmullRomSplineDerivative.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/computeNonuniformCaltmullRomSplineDerivative.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,2EAZW,MAAM,EAAE,uBACR,MAAM,qBACN,MAAM,EAAE,4BACR,MAAM,MACN,MAAM,EAAE,MACR,MAAM,EAAE,MACR,MAAM,EAAE,MACR,MAAM,EAAE,cACR,MAAM,KACN,MAAM,SACN,MAAM,QA2EhB"}

package/src/core/math/spline/computeNonuniformCaltmullRomSplineDerivative.js

@@ -0,0 +1,90 @@
+import { catmull_rom_compute_T } from "./catmull_rom_compute_T.js";
+
+/**
+ * Computes derivative of Catmull Rom spline
+ * @param {number[]} result_value
+ * @param {number} result_value_offset
+ * @param {number[]} result_derivative
+ * @param {number} result_derivative_offset
+ * @param {number[]} p0 spline point 0
+ * @param {number[]} p1 spline point 1
+ * @param {number[]} p2 spline point 2
+ * @param {number[]} p3 spline point 3
+ * @param {number} dimensions number of dimensions in the input and output vectors
+ * @param {number} f between 0..1
+ * @param {number} alpha between 0..1
+ */
+export function computeNonuniformCaltmullRomSplineDerivative(
+    result_value, result_value_offset,
+    result_derivative, result_derivative_offset,
+    p0, p1, p2, p3,
+    dimensions, f, alpha
+) {
+    /*
+    @see https://math.stackexchange.com/questions/843595/how-can-i-calculate-the-derivative-of-a-catmull-rom-spline-with-nonuniform-param
+    @see http://denkovacs.com/2016/02/catmull-rom-spline-derivatives/
+    @see https://en.wikipedia.org/wiki/Centripetal_Catmull%E2%80%93Rom_spline
+     */
+
+    const half_alpha = alpha * 0.5;
+
+    // calculate T
+    const t0 = 0;
+    let t_01 = catmull_rom_compute_T(p0, p1, dimensions, half_alpha);
+    let t_02 = catmull_rom_compute_T(p1, p2, dimensions, half_alpha);
+    let t_03 = catmull_rom_compute_T(p2, p3, dimensions, half_alpha);
+
+    // safety check for repeated points, to prevent division by 0
+    if (t_01 < 1e-4) {
+        t_01 = 1;
+    }
+    if (t_02 < 1e-4) {
+        t_02 = t_01;
+    }
+    if (t_03 < 1e-4) {
+        t_03 = t_02;
+    }
+
+    const t1 = t_01 + t0;
+    const t2 = t_02 + t1;
+    const t3 = t_03 + t2;
+
+    /**
+     * Interpolation between points 1 and 2
+     * @type {number}
+     */
+    const t = t1 * (1 - f) + t2 * f;
+
+    for (let i = 0; i < dimensions; i++) {
+        // read vector values for the dimension
+        const v0 = p0[i];
+        const v1 = p1[i];
+        const v2 = p2[i];
+        const v3 = p3[i];
+
+        const A1 = (t1 - t) / (t1 - t0) * v0 + (t - t0) / (t1 - t0) * v1;
+        const A2 = (t2 - t) / (t2 - t1) * v1 + (t - t1) / (t2 - t1) * v2;
+        const A3 = (t3 - t) / (t3 - t2) * v2 + (t - t2) / (t3 - t2) * v3;
+
+        const B1 = (t2 - t) / (t2 - t0) * A1 + (t - t0) / (t2 - t0) * A2;
+        const B2 = (t3 - t) / (t3 - t1) * A2 + (t - t1) / (t3 - t1) * A3;
+
+        const C = (t2 - t) / (t2 - t1) * B1 + (t - t1) / (t2 - t1) * B2;
+
+        result_value[result_value_offset + i] = C;
+
+        // derivatives
+
+        const dA1 = (v1 - v0) / (t1 - t0)
+        const dA2 = (v2 - v1) / (t2 - t1);
+        const dA3 = (v3 - v2) / (t3 - t2);
+
+        const dB1 = (A2 - A1) / (t2 - t0) + dA1 * (t2 - t) / (t2 - t0) + dA2 * (t - t0) / (t2 - t0);
+        const dB2 = (A3 - A2) / (t3 - t1) + dA2 * (t3 - t) / (t3 - t1) + dA3 * (t - t1) / (t3 - t1);
+
+        const dC = (B2 - B1) / (t2 - t1) + dB1 * (t2 - t) / (t2 - t1) + dB2 * (t - t1) / (t2 - t1);
+
+        result_derivative[result_derivative_offset + i] = dC;
+    }
+
+}

package/src/core/primitives/strings/string_jaro_distance.d.ts

@@ -0,0 +1,10 @@
+/**
+ * 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}
+ */
+export function string_jaro_distance(first: string, second: string, first_length: number, second_length: number): number;
+//# sourceMappingURL=string_jaro_distance.d.ts.map

package/src/core/primitives/strings/string_jaro_distance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"string_jaro_distance.d.ts","sourceRoot":"","sources":["../../../../../src/core/primitives/strings/string_jaro_distance.js"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH,4CANW,MAAM,UACN,MAAM,gBACN,MAAM,iBACN,MAAM,GACL,MAAM,CAmBjB"}

package/src/core/primitives/strings/string_jaro_distance.js

@@ -0,0 +1,127 @@
+import { BitSet } from "../../binary/BitSet.js";
+import { max2 } from "../../math/max2.js";
+import { min2 } from "../../math/min2.js";
+
+/**
+ * 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}
+ */
+export 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);
+}

package/src/core/primitives/strings/string_jaro_winkler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"string_jaro_winkler.d.ts","sourceRoot":"","sources":["../../../../../src/core/primitives/strings/string_jaro_winkler.js"],"names":[],"mappings":"AAKA;;;;;GAKG;AACH,2CAJW,MAAM,UACN,MAAM,GACJ,MAAM,CA6BlB"}
+{"version":3,"file":"string_jaro_winkler.d.ts","sourceRoot":"","sources":["../../../../../src/core/primitives/strings/string_jaro_winkler.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,2CAJW,MAAM,UACN,MAAM,GACJ,MAAM,CAwBlB"}

package/src/core/primitives/strings/string_jaro_winkler.js

@@ -1,7 +1,5 @@
-import { BitSet } from "../../binary/BitSet.js";
-import { max2 } from "../../math/max2.js";
-import { min2 } from "../../math/min2.js";
 import { min3 } from "../../math/min3.js";
+import { string_jaro_distance } from "./string_jaro_distance.js";
 
 /**
  * Calculate the Jaro-Winkler distance between two strings
@@ -18,19 +16,14 @@ export function string_jaro_winkler(first, second) {
         return 1;
     }
 
-    const matches1 = BitSet.fixedSize(l1);
-    const matches2 = BitSet.fixedSize(l2);
-
-    const matches = getMatching(first, second, matches1, matches2);
+    // Calculate the Jaro distance:
+    const similarity = string_jaro_distance(first, second, l1, l2);
 
-    if (matches <= 0) {
+    if (similarity === 0) {
+        // no similarity at all
         return 0;
     }
 
-    // Calculate the Jaro distance:
-    const transpositions = getTranspositions(first, second, matches1, matches2);
-    const similarity = (matches / l1 + matches / l2 + (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;
@@ -38,99 +31,6 @@ export function string_jaro_winkler(first, second) {
     return similarity + prefix * prefix_scale * (1 - similarity);
 }
 
-/**
- * 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
- */
-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);
-}
-
 /**
  * Counts the number of common characters at the beginning
  * of each word up to a maximum of 4