@woosh/meep-engine 2.109.20 → 2.109.22

package/build/meep.cjs

@@ -14,9 +14,7 @@ function isArrayEqualStrict(a, b) {
         return false;
     }
 
-    let i = 0;
-
-    for (; i < il; i++) {
+    for (let i = 0; i < il; i++) {
 
         if (a[i] !== b[i]) {
             return false;
@@ -49016,7 +49014,7 @@ function compute_typed_array_constructor_from_data_type(dt) {
 //
 
 /**
- *
+ * Optimized equality method for typed arrays, typically significantly faster than `isArrayEqualStrict`, especially for larger arrays
  * @param {Uint8Array|Uint32Array} a
  * @param {Uint8Array|Uint32Array} b
  * @returns {boolean}
@@ -49034,7 +49032,12 @@ function is_typed_array_equals(a, b) {
         return false;
     }
 
-    if (a_length < 128) {
+    if (a_length === 0) {
+        // both arrays are empty
+        return true;
+    }
+
+    if (a_length < 128) { // size is determined empirically, nothing special about the number itself
         // small array, do direct compare
         return isArrayEqualStrict(a, b);
     }
@@ -49073,6 +49076,7 @@ function is_typed_array_equals(a, b) {
         a_proxy = new Uint32Array(a_buffer, a.byteOffset, byte_length / 4);
         b_proxy = new Uint32Array(b_buffer, b.byteOffset, byte_length / 4);
     } else if (bytes_per_element < 2 && byte_length % 2 === 0) {
+        // 2 byte alignment, can use uint16
         a_proxy = new Uint16Array(a_buffer, a.byteOffset, byte_length / 2);
         b_proxy = new Uint16Array(b_buffer, b.byteOffset, byte_length / 2);
     }
@@ -76724,9 +76728,10 @@ function planesEqual(a, b) {
  * @param {T[]} a
  * @param {T[]} b
  * @param {function(T,T):boolean} elements_equal
+ * @param {*} [element_equal_context]
  * @returns {boolean}
  */
-function isArraysEqualWithComparator(a, b, elements_equal) {
+function isArraysEqualWithComparator(a, b, elements_equal, element_equal_context) {
     if (a === b) {
         // same object
         return true;
@@ -76747,7 +76752,7 @@ function isArraysEqualWithComparator(a, b, elements_equal) {
         const aE = a[i];
         const bE = b[i];
 
-        if (!elements_equal(aE, bE)) {
+        if (!elements_equal.call(element_equal_context, aE, bE)) {
             return false;
         }
     }
@@ -102533,9 +102538,16 @@ function easeInOutQuad(t) {
  * @template A,B
  * @param {A} a
  * @param {B} b
+ * @param {function(a:A, b:B):boolean} [value_equality_function] allows you to insert custom element comparison function
+ * @param {*} [value_equality_function_context]
  * @returns {boolean}
  */
-function objectDeepEquals(a, b) {
+function objectDeepEquals(
+    a, b,
+    value_equality_function = objectDeepEquals,
+    value_equality_function_context = null
+) {
+
     if (a === b) {
         // identity shortcut
         return true;
@@ -102551,43 +102563,64 @@ function objectDeepEquals(a, b) {
     if (tA !== "object") {
         // primitive types, identity equality already checked
         return false;
-    } else {
+    }
+
+    if (a === null || b === null) {
+        // we know that A and B are not the same, so if one of them is a null - there is no possible equality
+        return false;
+    }
 
-        if (a === null || b === null) {
-            // we know that A and B are not the same, so if one of them is a null - there is no possible equality
+    if (Array.isArray(a)) {
+        // special fast path for arrays
+        if (!Array.isArray(b)) {
+            // one is an array, the other is not
             return false;
         }
+        return isArraysEqualWithComparator(a, b, value_equality_function, value_equality_function_context);
+    }
 
-        if (Array.isArray(a)) {
-            // special fast path for arrays
-            if (!Array.isArray(b)) {
-                // one is an array, the other is not
-                return false;
-            }
-            return isArraysEqualWithComparator(a, b, objectDeepEquals);
-        }
+    // try equals function
+    if (
+        typeof a.equals === "function"
+        && typeof b.equals === "function"
+    ) {
+        return a.equals(b);
+    }
 
-        const keys_a = Object.keys(a);
-        const keys_b = Object.keys(b);
+    const keys_a = Object.keys(a);
+    const keys_b = Object.keys(b);
 
-        if (!isArrayEqualStrict(keys_a, keys_b)) {
-            // different fields
-            return false;
-        }
+    // sort keys to eliminate ordering concerns
+    keys_a.sort();
+    keys_b.sort();
 
-        const key_count = keys_a.length;
+    if (!isArrayEqualStrict(keys_a, keys_b)) {
+        // different fields
+        return false;
+    }
 
-        for (let i = 0; i < key_count; i++) {
-            const key = keys_a[i];
+    const key_count = keys_a.length;
 
-            if (!objectDeepEquals(a[key], b[key])) {
-                return false;
-            }
-        }
+    for (let i = 0; i < key_count; i++) {
+        const key = keys_a[i];
 
-        return true;
+        const a_value = a[key];
+        const b_value = b[key];
 
+        const values_are_equal = value_equality_function.call(
+            value_equality_function_context,
+            a_value,
+            b_value
+        );
+
+        if (!values_are_equal) {
+            return false;
+        }
     }
+
+    // looks like we have equality
+    return true;
+
 }
 
 /**