@woosh/meep-engine 2.48.23 → 2.49.1

package/src/core/collection/HashMap.spec.js

@@ -1,4 +1,4 @@
-import { HashMap } from "./HashMap.js";
+import { generate_next_linear_congruential_index, HashMap } from "./HashMap.js";
 import { passThrough, returnOne, strictEquals } from "../function/Functions.js";
 
 /**
@@ -16,6 +16,7 @@ function makeSample() {
     });
 }
 
+
 test('put and get same value', () => {
     const m = makeSample();
 
@@ -107,6 +108,44 @@ test("retrieval works as intended after hash map grows", () => {
 
 });
 
+test("after deletion element is not found", () => {
+    const map = new HashMap({
+        keyHashFunction: passThrough,
+        keyEqualityFunction: strictEquals,
+    });
+
+    map.set(1, "a");
+
+    map.delete(1);
+
+    expect(map.size).toBe(0);
+    expect(map.get(1)).toBeUndefined();
+});
+
+test("deleting an element then inserting another one all with hash collisions", () => {
+    const map = new HashMap({
+        keyHashFunction: returnOne,
+        keyEqualityFunction: strictEquals,
+    });
+
+    map.set(1, "a");
+    map.set(7, "b");
+
+    map.delete(1);
+
+    expect(map.get(7)).toBe("b");
+    expect(map.get(1)).toBeUndefined();
+
+    map.set(13, "c");
+
+    expect(map.get(13)).toBe("c");
+
+    map.delete(13);
+
+    expect(map.get(7)).toBe("b");
+    expect(map.get(13)).toBeUndefined();
+});
+
 
 test("key iterator", () => {
     const map = new HashMap({
@@ -129,3 +168,73 @@ test("value iterator", () => {
 
     expect(map.values().next().value).toBe("hello");
 });
+
+
+test("clear works as expected", () => {
+    const map = new HashMap({
+        keyHashFunction: passThrough,
+        keyEqualityFunction: strictEquals
+    });
+
+    map.set(7, "hello");
+
+    map.clear();
+
+    expect(map.get(7)).toBe(undefined);
+    expect(map.size).toBe(0);
+});
+
+test("lcg 32", () => {
+    const generated = new Uint32Array(32);
+
+    let next = 0;
+    for (let i = 0; i < 32; i++) {
+
+        generated[i] = next;
+
+        next = generate_next_linear_congruential_index(next, 31);
+
+    }
+
+    generated.sort();
+
+    for (let i = 0; i < 32; i++) {
+        expect(generated[i]).toBe(i);
+    }
+});
+
+
+test.skip("performance - random fill 100,000", () => {
+    const map = new HashMap({
+        keyHashFunction: passThrough,
+        keyEqualityFunction: strictEquals
+    });
+
+    const map_warmup = new HashMap({
+        keyHashFunction: passThrough,
+        keyEqualityFunction: strictEquals
+    });
+
+    // warm up
+    for (let i = 0; i < 10000; i++) {
+        map_warmup.set(i, i);
+        map_warmup.get(i);
+    }
+
+    const t0 = performance.now();
+
+    for (let i = 0; i < 100000; i++) {
+        map.set(i, i);
+    }
+
+    const t1 = performance.now();
+
+    for (let i = 0; i < 100000; i++) {
+        map.get(i);
+    }
+
+    const t2 = performance.now();
+
+    console.log(`Fill: ${t1 - t0}ms`)
+    console.log(`Drain: ${t2 - t1}ms`)
+});

package/src/core/collection/array/{typedArrayToDataType.js → typed/typedArrayToDataType.js}

@@ -1,4 +1,4 @@
-import { BinaryDataType } from "../../binary/type/BinaryDataType.js";
+import { BinaryDataType } from "../../../binary/type/BinaryDataType.js";
 
 /**
  *

package/src/core/collection/array/weightedRandomFromArray.spec.js

@@ -0,0 +1,20 @@
+import { weightedRandomFromArray } from "./weightedRandomFromArray.js";
+import { passThrough, returnOne, returnZero } from "../../function/Functions.js";
+
+test("empty array", () => {
+    expect(weightedRandomFromArray([], returnZero, passThrough, null, 0))
+        .toBeUndefined();
+});
+
+test("single element array", () => {
+    expect(weightedRandomFromArray([1], returnZero, passThrough, null, 1))
+        .toBe(1);
+});
+
+test("two elements", () => {
+    expect(weightedRandomFromArray([1,3], returnZero, passThrough, null, 2))
+        .toBe(1);
+
+    expect(weightedRandomFromArray([1,3], returnOne, passThrough, null, 2))
+        .toBe(3);
+});

package/src/core/debug/matchers/AnyOf.js

@@ -20,8 +20,7 @@ export class AnyOf extends BaseMatcher {
 
     matches(item, mismatch_description) {
         for (const matcher of this.#matchers) {
-            if (!matcher.matches(item, NullDescription.INSTANCE)) {
-
+            if (matcher.matches(item, NullDescription.INSTANCE)) {
                 return true;
             }
         }

package/src/core/geom/2d/aabb/AABB2.spec.js

@@ -1,4 +1,4 @@
-import AABB2 from "./AABB2.d.ts";
+import AABB2 from "./AABB2.js";
 
 test('copy', () => {
     const a = new AABB2(1, 2, 5, 11);

package/src/core/geom/2d/aabb/aabb2_compute_center_from_multiple.js

@@ -0,0 +1,19 @@
+import Vector2 from "../../Vector2.js";
+
+/**
+ *
+ * @param {Array.<AABB2>} boxes
+ * @returns {Vector2}
+ */
+export function aabb2_compute_center_from_multiple(boxes) {
+    const numBoxes = boxes.length;
+
+    const center = new Vector2();
+    for (let i = 0; i < numBoxes; i++) {
+        const box = boxes[i];
+        center._add(box.midX(), box.midY());
+    }
+    center.multiplyScalar(1 / numBoxes);
+
+    return center;
+}

package/src/core/geom/2d/quad-tree/qt_collect_by_circle.js

@@ -1,4 +1,4 @@
-import { aabb2_signed_distance_sqr_to_point } from "../aabb/aabb2_signed_distance_sqr_to_point.js";
+import { aabb2_distance_sqr_to_point } from "../aabb/aabb2_distance_sqr_to_point.js";
 
 /**
  *
@@ -33,7 +33,7 @@ export function qt_collect_by_circle(
 
         const node = node_stack[stack_pointer];
 
-        const d2 = aabb2_signed_distance_sqr_to_point(node.x0, node.y0, node.x1, node.y1, x, y);
+        const d2 = aabb2_distance_sqr_to_point(node.x0, node.y0, node.x1, node.y1, x, y);
 
         if (d2 > r2) {
             // not a match
@@ -46,7 +46,7 @@ export function qt_collect_by_circle(
         for (let i = 0; i < data_count; i++) {
             const datum = data[i];
 
-            const d2_to_datum = aabb2_signed_distance_sqr_to_point(datum.x0, datum.y0, datum.x1, datum.y1, x, y);
+            const d2_to_datum = aabb2_distance_sqr_to_point(datum.x0, datum.y0, datum.x1, datum.y1, x, y);
 
             if (d2_to_datum <= r2) {
                 result[result_cursor++] = datum;

package/src/core/geom/2d/quad-tree/qt_query_data_nearest_to_point.js

@@ -1,4 +1,3 @@
-import { max2 } from "../../../math/max2.js";
 import { aabb2_distance_sqr_to_point } from "../aabb/aabb2_distance_sqr_to_point.js";
 
 /**
@@ -17,20 +16,18 @@ const node_stack = [];
  */
 export function qt_query_data_nearest_to_point(tree, x, y, max_distance = Infinity) {
 
-    let stack_pointer = 0;
+    let stack_pointer = 1;
 
-    node_stack[stack_pointer] = tree;
-    stack_pointer++;
+    node_stack[0] = tree;
 
     let best_leaf_data = undefined;
     let best_distance_sqr = max_distance * max_distance;
 
-    while (stack_pointer > 0) {
+    while (stack_pointer-- > 0) {
 
-        --stack_pointer;
         const node = node_stack[stack_pointer];
 
-        const distance_sqr = max2(0, aabb2_distance_sqr_to_point(node.x0, node.y0, node.x1, node.y1, x, y));
+        const distance_sqr = aabb2_distance_sqr_to_point(node.x0, node.y0, node.x1, node.y1, x, y);
 
         if (distance_sqr >= best_distance_sqr) {
             // too far
@@ -38,11 +35,12 @@ export function qt_query_data_nearest_to_point(tree, x, y, max_distance = Infini
         }
 
         const data = node.data;
+        const data_count = data.length;
 
-        for (let i = 0; i < data.length; i++) {
+        for (let i = 0; i < data_count; i++) {
             const datum = data[i];
 
-            const distance_sqr = max2(0, aabb2_distance_sqr_to_point(datum.x0, datum.y0, datum.x1, datum.y1, x, y));
+            const distance_sqr = aabb2_distance_sqr_to_point(datum.x0, datum.y0, datum.x1, datum.y1, x, y);
 
             if (distance_sqr < best_distance_sqr) {
                 best_leaf_data = datum;

package/src/core/geom/3d/aabb/aabb3_compute_plane_side.js

@@ -1,4 +1,4 @@
-import { v3_distance_above_plane } from "../../v3_distance_above_plane.js";
+import { v3_dot } from "../../v3_dot.js";
 
 /**
  * 2,0,or -2; 2: above, -2 : below, 0 : intersects plane
@@ -26,7 +26,6 @@ export function aabb3_compute_plane_side(
     _y1,
     _z1
 ) {
-    let result = 0;
 
     let x0,
         y0,
@@ -60,23 +59,26 @@ export function aabb3_compute_plane_side(
         z1 = _z0;
     }
 
-    // check the nearest corner
+    /*
+      planar tests are inlined for performance and to save on a few operation,
+      if you write it out fully it would be vec4 dot product and comparison to 0,
+      since we don't have 4th component for AABB corners,
+      we can use vec3 and just move planar offset to the right-hand side of the comparison operation
+     */
 
-    if (v3_distance_above_plane(x0, y0, z0, plane_normal_x, plane_normal_y, plane_normal_z, plane_constant) >= 0) {
-        // above the plane
-        result += 1;
-    } else {
-        result -= 1;
-    }
+    const neg_plane_constant = -plane_constant;
 
     // check the farthest corner
+    if (v3_dot(x1, y1, z1, plane_normal_x, plane_normal_y, plane_normal_z) < neg_plane_constant) {
+        // if furthest corner is below plane, the nearest one will be as well, no need to continue
+        return -2;
+    }
 
-    if (v3_distance_above_plane(x1, y1, z1, plane_normal_x, plane_normal_y, plane_normal_z, plane_constant) >= 0) {
-        // above the plane
-        result += 1;
-    } else {
-        result -= 1;
+    // check the nearest corner
+    if (v3_dot(plane_normal_x, plane_normal_y, plane_normal_z, x0, y0, z0) >= neg_plane_constant) {
+        // above the plane, both corners are above the plane
+        return 2;
     }
 
-    return result;
+    return 0;
 }

package/src/core/geom/3d/aabb/aabb3_compute_plane_side.spec.js

@@ -0,0 +1,25 @@
+import { aabb3_compute_plane_side } from "./aabb3_compute_plane_side.js";
+
+test("fully above plane", () => {
+    expect(aabb3_compute_plane_side(
+        0, 1, 0, 0,
+        -1, 0.1, -1,
+        1, 1, 1
+    )).toBe(2);
+});
+
+test("fully below plane", () => {
+    expect(aabb3_compute_plane_side(
+        0, 1, 0, 0,
+        -1, -1, -1,
+        1, -0.1, 1
+    )).toBe(-2);
+});
+
+test("intersects plane", () => {
+    expect(aabb3_compute_plane_side(
+        0, 1, 0, 0,
+        -1, -1, -1,
+        1, 1, 1
+    )).toBe(0);
+});

package/src/core/geom/3d/aabb/aabb3_detailed_volume_intersection.js

@@ -1,12 +1,12 @@
 import { aabb3_build_corners } from "./aabb3_build_corners.js";
 import { aabb_build_frustum } from "./aabb3_build_frustum.js";
-import { plane3_computeLineSegmentIntersection } from "../../Plane.js";
 import { aabb3_corner_edge_mapping } from "./aabb3_corner_edge_mapping.js";
 import { aabb3_edge_corner_mapping } from "./aabb3_edge_corner_mapping.js";
 import { plane_computeConvex3PlaneIntersection } from "../plane/plane_computeConvex3PlaneIntersection.js";
 import { is_point_within_planes } from "../plane/is_point_within_planes.js";
 import { v3_distance_above_plane } from "../../v3_distance_above_plane.js";
 import { EPSILON } from "../../../math/EPSILON.js";
+import { plane3_computeLineSegmentIntersection } from "../plane/plane3_computeLineSegmentIntersection.js";
 
 /**
  * Common piece of continuous memory for better cache coherence

package/src/core/geom/3d/aabb/aabb3_from_v3_array.js

@@ -1,5 +1,6 @@
 import { min2 } from "../../../math/min2.js";
 import { max2 } from "../../../math/max2.js";
+import { assert } from "../../../assert.js";
 
 /**
  *
@@ -8,6 +9,8 @@ import { max2 } from "../../../math/max2.js";
  * @param {number} input_length length of the input array
  */
 export function aabb3_from_v3_array(result, input, input_length) {
+    assert.equal(input_length % 3, 0, `Input must be divisible by 3, instead was ${input_length}`)
+
     let x0 = Infinity;
     let y0 = Infinity;
     let z0 = Infinity;

package/src/core/geom/3d/aabb/aabb3_from_v3_array.spec.js

@@ -0,0 +1,32 @@
+import { aabb3_from_v3_array } from "./aabb3_from_v3_array.js";
+import { AABB3 } from "./AABB3.js";
+
+test("empty list", () => {
+    const box = new AABB3();
+
+    aabb3_from_v3_array(box, [], 0);
+
+    expect(box.x0).toEqual(Infinity);
+    expect(box.x1).toEqual(-Infinity);
+
+    expect(box.y0).toEqual(Infinity);
+    expect(box.y1).toEqual(-Infinity);
+
+    expect(box.z0).toEqual(Infinity);
+    expect(box.z1).toEqual(-Infinity);
+});
+
+test("1 point", () => {
+    const box = new AABB3();
+
+    aabb3_from_v3_array(box, [1, 3, -5], 3);
+
+    expect(box.x0).toEqual(1);
+    expect(box.x1).toEqual(1);
+
+    expect(box.y0).toEqual(3);
+    expect(box.y1).toEqual(3);
+
+    expect(box.z0).toEqual(-5);
+    expect(box.z1).toEqual(-5);
+});

package/src/core/geom/3d/aabb/aabb3_intersects_aabb3.spec.js

@@ -0,0 +1,115 @@
+import { aabb3_intersects_aabb3 } from "./aabb3_intersects_aabb3.js";
+
+test("full containment", () => {
+
+    expect(aabb3_intersects_aabb3(
+        0, 0, 0, 3, 3, 3,
+        1, 1, 1, 2, 2, 2
+    )).toBe(true);
+
+    expect(aabb3_intersects_aabb3(
+        -3, -3, -3, 0, 0, 0,
+        -2, -2, -2, -1, -1, -1
+    )).toBe(true);
+
+});
+
+test("complete separation", () => {
+
+    // X
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        2, 1, 1, 3, 2, 2
+    )).toBe(false);
+
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        -3, 1, 1, -2, 2, 2
+    )).toBe(false);
+
+    // Y
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        1, 2, 1, 2, 3, 2
+    )).toBe(false);
+
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        1, -3, 1, 2, -2, 2
+    )).toBe(false);
+
+    // Z
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        1, 1, 2, 2, 2, 3
+    )).toBe(false);
+
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        1, 1, -3, 2, 2, -2
+    )).toBe(false);
+
+    // XY
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        2, 2, 1, 3, 3, 2
+    )).toBe(false);
+
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        -3, 2, 1, -2, 3, 2
+    )).toBe(false);
+
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        2, -3, 1, 3, -2, 2
+    )).toBe(false);
+
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        -3, -3, 1, -2, -2, 2
+    )).toBe(false);
+
+    // YZ
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        1, 2, 2, 2, 3, 3
+    )).toBe(false);
+
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        1, -3, 2, 2, -2, 3
+    )).toBe(false);
+
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        1, 2, -3, 2, 3, 2
+    )).toBe(false);
+
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        1, -3, -3, 2, -2, 2
+    )).toBe(false);
+
+    // ZX
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        2, 2, 1, 3, 3, 2
+    )).toBe(false);
+
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        2, -3, 2, 3, -2, 2
+    )).toBe(false);
+
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        -3, 2, 1, -2, 3, 2
+    )).toBe(false);
+
+    expect(aabb3_intersects_aabb3(
+        -1, -1, -1, 1, 1, 1,
+        -3, -3, 2, -2, -2, 2
+    )).toBe(false);
+
+});

package/src/core/geom/3d/aabb/aabb3_raycast.js

@@ -27,7 +27,12 @@ import { max2 } from "../../../math/max2.js";
  * @see https://gdbooks.gitbooks.io/3dcollisions/content/Chapter3/raycast_aabb.html
  * @see https://blog.johnnovak.net/2016/10/22/the-nim-ray-tracer-project-part-4-calculating-box-normals/
  */
-export function aabb3_raycast(result, result_offset, x0, y0, z0, x1, y1, z1, origin_x, origin_y, origin_z, direction_x, direction_y, direction_z) {
+export function aabb3_raycast(
+    result, result_offset,
+    x0, y0, z0, x1, y1, z1,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z
+) {
 
     // first find intersection
     const dir_inv_x = 1 / direction_x;

package/src/core/geom/3d/aabb/serializeAABB3Encoded_v0.js

@@ -44,32 +44,32 @@ export function serializeAABB3Encoded_v0(buffer, box, x0, y0, z0, x1, y1, z1) {
     const zD = z1 - z0;
 
     if ((header & 1) === 0) {
-        const _x0 = (((box.x0 - x0) / xD) * 65535) | 0;
+        const _x0 = Math.floor(((box.x0 - x0) / xD) * 65535);
         buffer.writeUint16(_x0);
     }
 
     if ((header & 2) === 0) {
-        const _x1 = (((box.x1 - x0) / xD) * 65535) | 0;
+        const _x1 = Math.ceil(((box.x1 - x0) / xD) * 65535);
         buffer.writeUint16(_x1);
     }
 
     if ((header & 4) === 0) {
-        const _y0 = (((box.y0 - y0) / yD) * 65535) | 0;
+        const _y0 = Math.floor(((box.y0 - y0) / yD) * 65535);
         buffer.writeUint16(_y0);
     }
 
     if ((header & 8) === 0) {
-        const _y1 = (((box.y1 - y0) / yD) * 65535) | 0;
+        const _y1 = Math.ceil(((box.y1 - y0) / yD) * 65535);
         buffer.writeUint16(_y1);
     }
 
     if ((header & 16) === 0) {
-        const _z0 = (((box.z0 - z0) / zD) * 65535) | 0;
+        const _z0 = Math.floor(((box.z0 - z0) / zD) * 65535);
         buffer.writeUint16(_z0);
     }
 
     if ((header & 32) === 0) {
-        const _z1 = (((box.z1 - z0) / zD) * 65535) | 0;
+        const _z1 = Math.ceil(((box.z1 - z0) / zD) * 65535);
         buffer.writeUint16(_z1);
     }
 }

package/src/core/geom/3d/{CircleMath.js → compute_circle_bounding_box.js}

@@ -12,7 +12,7 @@ import { v3_angle_between } from "../v3_angle_between.js";
  * @param {number} normalZ orientation of the circle
  * @param {number} radius
  */
-export function computeCircleBoundingBox(
+export function compute_circle_bounding_box(
     result,
     centerX, centerY, centerZ,
     normalX, normalY, normalZ,

package/src/core/geom/3d/decompose_matrix_4_array.js

@@ -2,34 +2,35 @@ const hypot = Math.hypot;
 
 /**
  *
- * @param {number[]} m
+ * @param {number[]} mat4
  * @param {Vector3} position
  * @param {Quaternion} rotation
  * @param {Vector3} scale
  */
-export function decompose_matrix_4_array(m, position, rotation, scale) {
-    const m11 = m[0];
-    const m12 = m[1];
-    const m13 = m[2];
+export function decompose_matrix_4_array(mat4, position, rotation, scale) {
+    const m11 = mat4[0];
+    const m12 = mat4[1];
+    const m13 = mat4[2];
 
     const scale_x = hypot(m11, m12, m13);
 
-    const m21 = m[4];
-    const m22 = m[5];
-    const m23 = m[6];
+    const m21 = mat4[4];
+    const m22 = mat4[5];
+    const m23 = mat4[6];
 
     const scale_y = hypot(m21, m22, m23);
 
-    const m31 = m[8];
-    const m32 = m[9];
-    const m33 = m[10];
+    const m31 = mat4[8];
+    const m32 = mat4[9];
+    const m33 = mat4[10];
 
     const scale_z = hypot(m31, m32, m33);
 
     // extract rotation matrix
-    const is1 = 1 / scale_x;
-    const is2 = 1 / scale_y;
-    const is3 = 1 / scale_z;
+    // take care of potential division by 0 when scale is 0. Result is inexact, but we get don't break the system at least
+    const is1 = scale_x !== 0 ? 1 / scale_x : 1e7;
+    const is2 = scale_y !== 0 ? 1 / scale_y : 1e7;
+    const is3 = scale_z !== 0 ? 1 / scale_z : 1e7;
 
     const sm11 = m11 * is1;
     const sm12 = m12 * is1;
@@ -43,14 +44,12 @@ export function decompose_matrix_4_array(m, position, rotation, scale) {
     const sm32 = m32 * is3;
     const sm33 = m33 * is3;
 
-    // TODO take care of cases where scale is 0
-
     // write out results
 
     position.set(
-        m[12],
-        m[13],
-        m[14]
+        mat4[12],
+        mat4[13],
+        mat4[14]
     );
 
     scale.set(

package/src/core/geom/3d/frustum/frustum3_computeNearestPointToPoint.js

@@ -1,4 +1,3 @@
-import { computePlanePlaneIntersection } from "../../Plane.js";
 import Vector3 from "../../Vector3.js";
 import { plane3_projectPoint } from "../plane/plane3_projectPoint.js";
 import { ray_computeNearestPointToPoint } from "../ray/ray_computeNearestPointToPoint.js";
@@ -6,6 +5,7 @@ import { v3_distance_above_plane } from "../../v3_distance_above_plane.js";
 import {
     plane_three_computeConvex3PlaneIntersection
 } from "../plane/plane_three_compute_convex3_plane_intersection.js";
+import { computePlanePlaneIntersection } from "../plane/computePlanePlaneIntersection.js";
 
 /**
  *

package/src/{engine/graphics/ecs/mesh-v2 → core/geom/3d/matrix}/allocate_transform_m4.js

@@ -1,4 +1,4 @@
-import { MATRIX_4_IDENTITY } from "../../../../core/geom/3d/matrix/MATRIX_4_IDENTITY.js";
+import { MATRIX_4_IDENTITY } from "./MATRIX_4_IDENTITY.js";
 
 /**
  * Larger bucket sizes provide better cache locality