@woosh/meep-engine 2.117.8 → 2.117.10

package/build/meep.cjs

@@ -27,22 +27,39 @@ function isArrayEqualStrict(a, b) {
 }
 
 /**
- * Checks whether supplied argument is a TypedArray instance, such as Flaot32Array
+ * Checks whether supplied argument is a TypedArray instance, such as Float32Array
  * @template T
  * @param {T} o
  * @returns {boolean}
  */
 function isTypedArray(o) {
+    const t = typeof o;
+
+    if(t !== "object"){
+        return false;
+    }
+
+    if(o === null){
+        // special case, null is treated as an object
+        return false;
+    }
+
+    const constructor = o.constructor;
+
     return (
-        o instanceof Int8Array ||
-        o instanceof Uint8Array ||
-        o instanceof Uint8ClampedArray ||
-        o instanceof Int16Array ||
-        o instanceof Uint16Array ||
-        o instanceof Int32Array ||
-        o instanceof Uint32Array ||
-        o instanceof Float32Array ||
-        o instanceof Float64Array
+        constructor === Uint8Array
+        || constructor === Uint16Array
+        || constructor === Uint32Array
+
+        || constructor === Int8Array
+        || constructor === Int16Array
+        || constructor === Int32Array
+
+        || constructor === Float32Array
+        || constructor === Float64Array
+
+        || constructor === BigUint64Array
+        || constructor === BigInt64Array
     );
 }
 
@@ -49065,6 +49082,29 @@ function compute_binary_data_type_from_typed_array(array) {
     }
 }
 
+/**
+ *
+ * @param {number} a_offset
+ * @param {number} b_offset
+ * @param {number} byte_length
+ * @returns {number}
+ */
+function largest_common_alignment_uint32(a_offset, b_offset, byte_length) {
+
+    const mask = a_offset | b_offset | byte_length;
+
+    if ((mask & 3) === 0) {
+        // aligned on 4-byte boundary
+        return 4
+    } else if ((mask & 1) === 0) {
+        // aligned on 2-byte boundary
+        return 2;
+    } else {
+        // worst-case, assume 1-byte boundary
+        return 1;
+    }
+}
+
 //
 
 /**
@@ -49129,11 +49169,11 @@ function is_typed_array_equals(a, b) {
 
     const bytes_per_element = a_constructor.BYTES_PER_ELEMENT;
 
+    const alignment = largest_common_alignment_uint32(a_offset, b_offset,byte_length);
+
     if (
         bytes_per_element < 4
-        && byte_length % 4 === 0
-        && a_offset % 4 === 0
-        && b_offset % 4 === 0
+        && alignment === 4
     ) {
 
         // 4 byte alignment, can use uint32
@@ -49142,9 +49182,7 @@ function is_typed_array_equals(a, b) {
 
     } else if (
         bytes_per_element < 2
-        && byte_length % 2 === 0
-        && a_offset % 2 === 0
-        && b_offset % 2 === 0
+        && alignment === 2
     ) {
 
         // 2 byte alignment, can use uint16