@woosh/meep-engine 3.45.0 → 3.46.0

package/src/core/geom/3d/mat4/m4_multiply_f64.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"m4_multiply_f64.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_multiply_f64.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qCALW,YAAY,KACZ,YAAY,KACZ,YAAY,GACV,YAAY,CA6ExB"}

package/src/core/geom/3d/mat4/m4_multiply_f64.js

@@ -0,0 +1,106 @@
+import { assert } from "../../../assert.js";
+
+/**
+ * Multiplies two 4x4 matrices held in `Float64Array`s.
+ * `out = a * b`.
+ *
+ * A deliberate duplicate of {@link m4_multiply}: the same arithmetic in the same order, so the two give
+ * the same result bit for bit, and they must stay identical. Change one, change the other.
+ *
+ * It exists because {@link m4_multiply} is shared. About twenty modules call it, with `Float32Array`,
+ * `Float64Array`, `Transform64` and plain `Array` operands, and V8 keeps one set of type feedback per
+ * function, so its element loads and stores go megamorphic. A megamorphic store boxes every number it
+ * writes into a fresh HeapNumber. Measured in the dance-stage example (2026-10-12), on `Transform64`
+ * operands: 193 B per call through the shared {@link m4_multiply}, ~10 B through an identical copy no
+ * other caller reached. `Transform64#multiplyTransforms` composes every attached entity, ~1,700 calls a
+ * frame there, and that boxing was a third of the main thread's allocation.
+ *
+ * So this copy must only ever see `Float64Array` storage; a `Transform64` is one. A single caller passing
+ * a `Float32Array` or an `Array` would pollute this copy's feedback too, and bring the boxing back for
+ * every caller. The assertions are what keep such a caller out: anything else goes through
+ * {@link m4_multiply}.
+ *
+ * All of `a` is read before the first write, and each column of `b` before the column of `out` it
+ * produces, so `out` may be `a` or `b`.
+ *
+ * @param {Float64Array} out the receiving matrix
+ * @param {Float64Array} a the first operand
+ * @param {Float64Array} b the second operand
+ * @returns {Float64Array} `out` parameter
+ */
+export function m4_multiply_f64(out, a, b) {
+    // A bare instanceof, not assert.isInstanceOf: that one is shared by every call site in the engine,
+    // and once it had seen their mix of classes, this function took 21 ns a call through it against
+    // 15.5 ns this way (node 24, 2026-10-12, a build that keeps assertions). Each check throws before
+    // the first element access, so a rejected operand never reaches this copy's element feedback.
+    assert.ok(out instanceof Float64Array, 'out is not a Float64Array');
+    assert.greaterThanOrEqual(out.length, 16, 'out.length');
+
+    assert.ok(a instanceof Float64Array, 'a is not a Float64Array');
+    assert.greaterThanOrEqual(a.length, 16, 'a.length');
+
+    assert.ok(b instanceof Float64Array, 'b is not a Float64Array');
+    assert.greaterThanOrEqual(b.length, 16, 'b.length');
+
+    // Adapted from gl-matrix, by way of m4_multiply
+
+    const a00 = a[0],
+        a01 = a[1],
+        a02 = a[2],
+        a03 = a[3],
+        a10 = a[4],
+        a11 = a[5],
+        a12 = a[6],
+        a13 = a[7],
+        a20 = a[8],
+        a21 = a[9],
+        a22 = a[10],
+        a23 = a[11],
+        a30 = a[12],
+        a31 = a[13],
+        a32 = a[14],
+        a33 = a[15];
+
+    // Cache only the current line of the second matrix
+    let b0 = b[0],
+        b1 = b[1],
+        b2 = b[2],
+        b3 = b[3];
+
+    out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+    out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+    out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+    out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+
+    b0 = b[4];
+    b1 = b[5];
+    b2 = b[6];
+    b3 = b[7];
+
+    out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+    out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+    out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+    out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+
+    b0 = b[8];
+    b1 = b[9];
+    b2 = b[10];
+    b3 = b[11];
+
+    out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+    out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+    out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+    out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+
+    b0 = b[12];
+    b1 = b[13];
+    b2 = b[14];
+    b3 = b[15];
+
+    out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;
+    out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;
+    out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;
+    out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
+
+    return out;
+}

package/src/core/geom/ConicRay.js

@@ -1,5 +1,5 @@
 import { assert } from "../assert.js";
-import { combine_hash } from "../collection/array/combine_hash.js";
+import { hash_mix2 } from "../math/hash/hash_mix2.js";
 import { EPSILON } from "../math/EPSILON.js";
 import { epsilonEquals } from "../math/epsilonEquals.js";
 import { PI2 } from "../math/PI2.js";
@@ -90,7 +90,7 @@ export class ConicRay {
      * @return {number}
      */
     hash() {
-        return combine_hash(
+        return hash_mix2(
             computeHashFloat(this.angle),
             this.direction.hash()
         );

package/src/core/geom/Vector4.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Vector4.d.ts","sourceRoot":"","sources":["../../../../src/core/geom/Vector4.js"],"names":[],"mappings":"AAMA;;;GAGG;AAGH;;GAEG;AACH;;;;;;;;;;;;;GAaG;AACH,8DAFwB,MAAM;IAuc1B;;;;;;OAMG;IACH,gBALW,OAAO,MACP,OAAO,qBAEP,OAAO,QASjB;IApbD;;;;OAIG;IACH,uDAEC;IArCD;;;;;;;;OAQG;IACH,gBAPW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,EAuBhB;IAXG,UAAW;IACX,UAAW;IACX,UAAW;IACX,UAAW;IAEX;;;;OAIG;IACH,wBAA6B;IAoBjC;;;OAGG;IACH,iBAEC;IAdD;;;OAGG;IACH,gBAEC;IAkBD;;;OAGG;IACH,iBAEC;IAdD;;;OAGG;IACH,gBAEC;IAkBD;;;OAGG;IACH,iBAEC;IAdD;;;OAGG;IACH,gBAEC;IAkBD;;;OAGG;IACH,iBAEC;IAdD;;;OAGG;IACH,gBAEC;IAUD;;;;OAIG;IACH,qBAHW,MAAM,EAAE,WACR,MAAM,QAShB;IAED;;;;OAIG;IACH,oBAHW,MAAM,EAAE,WACR,MAAM,QAOhB;IAED;;;;;;;OAOG;IACH,iDAFa,OAAO,CAkCnB;IAED;;;OAGG;IACH,oBAFW,OAAO,QAQjB;IAED;;;;OAIG;IACH,+BAFa,OAAO,CAOnB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,kBAlBW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAoBnB;IAED;;;;OAIG;IACH,WAHW,OAAO,GACL,MAAM,CAIlB;IAED;;;;OAIG;IACH,SAHW,OAAO,GAAC,OAAO,GACb,OAAO,CASnB;IAED;;;;;;;OAOG;IACH,QANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,IAAI,CAShB;IAED;;;;;OAKG;IACH,iBAJW,OAAO,SACP,MAAM,GACJ,IAAI,CAShB;IAED;;;;OAIG;IACH,qBAHW;QAAC,QAAQ,EAAE,MAAM,EAAE,GAAC,YAAY,CAAA;KAAC,GAC/B,OAAO,CAInB;IAED;;;;OAIG;IACH,gBAHW,MAAM,EAAE,GAAC,YAAY,GACpB,OAAO,CASlB;IAED;;;;OAIG;IACH,WAHW,OAAO,GACL,OAAO,CAInB;IAED;;;OAGG;IACH,SAFa,OAAO,CAQnB;IAED;;;OAGG;IACH,mBAFW,UAAU,QAyBpB;IAED;;;;OAIG;IACH,aAHW,OAAO,GACL,OAAO,CAInB;IAED;;;OAGG;IACH,QAFY,MAAM,CASjB;IAED;;;;OAIG;IACH,gBAJW,OAAO,MACP,OAAO,mBAKjB;IAGD;;OAEG;IACH,WAFa,MAAM,EAAE,CAQpB;IAED;;;;OAIG;IACH,mBAHW,MAAM,EAAE,UACR,MAAM,QAIhB;IAED;;;;;MAOC;IAED,0BAEC;IAED;;;OAGG;IACH,uBAFW,YAAY,QAOtB;IAED;;;OAGG;IACH,yBAFW,YAAY,QAStB;IAmBL;;;OAGG;IACH,oBAFU,OAAO,CAEU;IAE3B,mBAlXe,MAAM,EAAE,WACR,MAAM,UAiXM;IAC3B,iBArWe,MAAM,EAAE,WACR,MAAM,UAoWI;CATxB;;kBAaS,MAAM;;;yBAvfH,OAAO,iBAAiB,EAAE,UAAU;sBACpC,OAAO,cAAc,EAAE,OAAO;2BAK9B,OAAO,2BAA2B,EAAE,YAAY"}
+{"version":3,"file":"Vector4.d.ts","sourceRoot":"","sources":["../../../../src/core/geom/Vector4.js"],"names":[],"mappings":"AAOA;;;GAGG;AAGH;;GAEG;AACH;;;;;;;;;;;;;GAaG;AACH,8DAFwB,MAAM;IAyc1B;;;;;;OAMG;IACH,gBALW,OAAO,MACP,OAAO,qBAEP,OAAO,QASjB;IAtbD;;;;OAIG;IACH,uDAEC;IArCD;;;;;;;;OAQG;IACH,gBAPW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,EAuBhB;IAXG,UAAW;IACX,UAAW;IACX,UAAW;IACX,UAAW;IAEX;;;;OAIG;IACH,wBAA6B;IAoBjC;;;OAGG;IACH,iBAEC;IAdD;;;OAGG;IACH,gBAEC;IAkBD;;;OAGG;IACH,iBAEC;IAdD;;;OAGG;IACH,gBAEC;IAkBD;;;OAGG;IACH,iBAEC;IAdD;;;OAGG;IACH,gBAEC;IAkBD;;;OAGG;IACH,iBAEC;IAdD;;;OAGG;IACH,gBAEC;IAUD;;;;OAIG;IACH,qBAHW,MAAM,EAAE,WACR,MAAM,QAShB;IAED;;;;OAIG;IACH,oBAHW,MAAM,EAAE,WACR,MAAM,QAOhB;IAED;;;;;;;OAOG;IACH,iDAFa,OAAO,CAkCnB;IAED;;;OAGG;IACH,oBAFW,OAAO,QAQjB;IAED;;;;OAIG;IACH,+BAFa,OAAO,CAOnB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,kBAlBW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAoBnB;IAED;;;;OAIG;IACH,WAHW,OAAO,GACL,MAAM,CAIlB;IAED;;;;OAIG;IACH,SAHW,OAAO,GAAC,OAAO,GACb,OAAO,CASnB;IAED;;;;;;;OAOG;IACH,QANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,IAAI,CAShB;IAED;;;;;OAKG;IACH,iBAJW,OAAO,SACP,MAAM,GACJ,IAAI,CAShB;IAED;;;;OAIG;IACH,qBAHW;QAAC,QAAQ,EAAE,MAAM,EAAE,GAAC,YAAY,CAAA;KAAC,GAC/B,OAAO,CAInB;IAED;;;;OAIG;IACH,gBAHW,MAAM,EAAE,GAAC,YAAY,GACpB,OAAO,CASlB;IAED;;;;OAIG;IACH,WAHW,OAAO,GACL,OAAO,CAInB;IAED;;;OAGG;IACH,SAFa,OAAO,CAQnB;IAED;;;OAGG;IACH,mBAFW,UAAU,QAyBpB;IAED;;;;OAIG;IACH,aAHW,OAAO,GACL,OAAO,CAInB;IAED;;;OAGG;IACH,QAFY,MAAM,CAWjB;IAED;;;;OAIG;IACH,gBAJW,OAAO,MACP,OAAO,mBAKjB;IAGD;;OAEG;IACH,WAFa,MAAM,EAAE,CAQpB;IAED;;;;OAIG;IACH,mBAHW,MAAM,EAAE,UACR,MAAM,QAIhB;IAED;;;;;MAOC;IAED,0BAEC;IAED;;;OAGG;IACH,uBAFW,YAAY,QAOtB;IAED;;;OAGG;IACH,yBAFW,YAAY,QAStB;IAmBL;;;OAGG;IACH,oBAFU,OAAO,CAEU;IAE3B,mBApXe,MAAM,EAAE,WACR,MAAM,UAmXM;IAC3B,iBAvWe,MAAM,EAAE,WACR,MAAM,UAsWI;CATxB;;kBAaS,MAAM;;;yBAzfH,OAAO,iBAAiB,EAAE,UAAU;sBACpC,OAAO,cAAc,EAAE,OAAO;2BAK9B,OAAO,2BAA2B,EAAE,YAAY"}

package/src/core/geom/Vector4.js

@@ -1,5 +1,6 @@
 import { assert } from "../assert.js";
-import { combine_hash } from "../collection/array/combine_hash.js";
+import { hash_mix2 } from "../math/hash/hash_mix2.js";
+import { hash_mix3 } from "../math/hash/hash_mix3.js";
 import { Signal } from "../events/signal/Signal.js";
 import { lerp } from "../math/lerp.js";
 import { computeHashFloat } from "../primitives/numbers/computeHashFloat.js";
@@ -405,10 +406,12 @@ export class Vector4 extends Float64Array {
      * @return {number}
      */
     hash() {
-        return combine_hash(
-            computeHashFloat(this[0]),
-            computeHashFloat(this[1]),
-            computeHashFloat(this[2]),
+        return hash_mix2(
+            hash_mix3(
+                computeHashFloat(this[0]),
+                computeHashFloat(this[1]),
+                computeHashFloat(this[2])
+            ),
             computeHashFloat(this[3])
         );
     }

package/src/core/math/hash/XXH128Hash.d.ts

@@ -0,0 +1,38 @@
+/**
+ * A 128-bit xxHash3 result, kept as its two 64-bit halves because that is how the reference
+ * implementation names them and how every serialized form writes them.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class XXH128Hash {
+    /**
+     * @param {bigint} low64
+     * @param {bigint} high64
+     */
+    constructor(low64: bigint, high64: bigint);
+    /**
+     * @type {bigint}
+     */
+    low64: bigint;
+    /**
+     * @type {bigint}
+     */
+    high64: bigint;
+    /**
+     * @param {XXH128Hash} other
+     * @returns {boolean}
+     */
+    equals(other: XXH128Hash): boolean;
+    /**
+     * @returns {string} 32 lowercase hex digits, high half first
+     */
+    toString(): string;
+    /**
+     * Useful for type checking
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isXXH128Hash: boolean;
+}
+//# sourceMappingURL=XXH128Hash.d.ts.map

package/src/core/math/hash/XXH128Hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"XXH128Hash.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/hash/XXH128Hash.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AACH;IAWI;;;OAGG;IACH,mBAHW,MAAM,UACN,MAAM,EAQhB;IApBD;;OAEG;IACH,OAFU,MAAM,CAEL;IAEX;;OAEG;IACH,QAFU,MAAM,CAEJ;IAcZ;;;OAGG;IACH,cAHW,UAAU,GACR,OAAO,CAInB;IAED;;OAEG;IACH,YAFa,MAAM,CAIlB;IAGL;;;;OAIG;IACH,uBAFU,OAAO,CAEgB;CAPhC"}

package/src/core/math/hash/XXH128Hash.js

@@ -0,0 +1,55 @@
+import { assert } from "../../assert.js";
+import { XXH_MASK_64 } from "./xxh3_common.js";
+
+/**
+ * A 128-bit xxHash3 result, kept as its two 64-bit halves because that is how the reference
+ * implementation names them and how every serialized form writes them.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class XXH128Hash {
+    /**
+     * @type {bigint}
+     */
+    low64 = 0n;
+
+    /**
+     * @type {bigint}
+     */
+    high64 = 0n;
+
+    /**
+     * @param {bigint} low64
+     * @param {bigint} high64
+     */
+    constructor(low64, high64) {
+        assert.equal(typeof low64, 'bigint', `low64 must be a bigint, instead was '${typeof low64}'`);
+        assert.equal(typeof high64, 'bigint', `high64 must be a bigint, instead was '${typeof high64}'`);
+
+        this.low64 = low64 & XXH_MASK_64;
+        this.high64 = high64 & XXH_MASK_64;
+    }
+
+    /**
+     * @param {XXH128Hash} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        return this.low64 === other.low64 && this.high64 === other.high64;
+    }
+
+    /**
+     * @returns {string} 32 lowercase hex digits, high half first
+     */
+    toString() {
+        return this.high64.toString(16).padStart(16, '0') + this.low64.toString(16).padStart(16, '0');
+    }
+}
+
+/**
+ * Useful for type checking
+ * @readonly
+ * @type {boolean}
+ */
+XXH128Hash.prototype.isXXH128Hash = true;

package/src/core/math/hash/XXH3_SECRET.d.ts

@@ -0,0 +1,13 @@
+/**
+ * xxHash3's default secret — the pseudorandom key material every unseeded hash mixes with, taken
+ * directly from FARSH by the reference implementation. Reproduced byte-for-byte; changing a single
+ * byte changes every hash this module produces.
+ *
+ * @see https://github.com/Cyan4973/xxHash/blob/dev/xxhash.h
+ * @readonly
+ * @type {Uint8Array}
+ *
+ * @copyright Company Named Limited (c) 2026
+ */
+export const XXH3_SECRET: Uint8Array;
+//# sourceMappingURL=XXH3_SECRET.d.ts.map

package/src/core/math/hash/XXH3_SECRET.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"XXH3_SECRET.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/hash/XXH3_SECRET.js"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,0BAJU,UAAU,CAiBjB"}

package/src/core/math/hash/XXH3_SECRET.js

@@ -0,0 +1,25 @@
+/**
+ * xxHash3's default secret — the pseudorandom key material every unseeded hash mixes with, taken
+ * directly from FARSH by the reference implementation. Reproduced byte-for-byte; changing a single
+ * byte changes every hash this module produces.
+ *
+ * @see https://github.com/Cyan4973/xxHash/blob/dev/xxhash.h
+ * @readonly
+ * @type {Uint8Array}
+ *
+ * @copyright Company Named Limited (c) 2026
+ */
+export const XXH3_SECRET = new Uint8Array([
+    0xb8, 0xfe, 0x6c, 0x39, 0x23, 0xa4, 0x4b, 0xbe, 0x7c, 0x01, 0x81, 0x2c, 0xf7, 0x21, 0xad, 0x1c,
+    0xde, 0xd4, 0x6d, 0xe9, 0x83, 0x90, 0x97, 0xdb, 0x72, 0x40, 0xa4, 0xa4, 0xb7, 0xb3, 0x67, 0x1f,
+    0xcb, 0x79, 0xe6, 0x4e, 0xcc, 0xc0, 0xe5, 0x78, 0x82, 0x5a, 0xd0, 0x7d, 0xcc, 0xff, 0x72, 0x21,
+    0xb8, 0x08, 0x46, 0x74, 0xf7, 0x43, 0x24, 0x8e, 0xe0, 0x35, 0x90, 0xe6, 0x81, 0x3a, 0x26, 0x4c,
+    0x3c, 0x28, 0x52, 0xbb, 0x91, 0xc3, 0x00, 0xcb, 0x88, 0xd0, 0x65, 0x8b, 0x1b, 0x53, 0x2e, 0xa3,
+    0x71, 0x64, 0x48, 0x97, 0xa2, 0x0d, 0xf9, 0x4e, 0x38, 0x19, 0xef, 0x46, 0xa9, 0xde, 0xac, 0xd8,
+    0xa8, 0xfa, 0x76, 0x3f, 0xe3, 0x9c, 0x34, 0x3f, 0xf9, 0xdc, 0xbb, 0xc7, 0xc7, 0x0b, 0x4f, 0x1d,
+    0x8a, 0x51, 0xe0, 0x4b, 0xcd, 0xb4, 0x59, 0x31, 0xc8, 0x9f, 0x7e, 0xc9, 0xd9, 0x78, 0x73, 0x64,
+    0xea, 0xc5, 0xac, 0x83, 0x34, 0xd3, 0xeb, 0xc3, 0xc5, 0x81, 0xa0, 0xff, 0xfa, 0x13, 0x63, 0xeb,
+    0x17, 0x0d, 0xdd, 0x51, 0xb7, 0xf0, 0xda, 0x49, 0xd3, 0x16, 0x55, 0x26, 0x29, 0xd4, 0x68, 0x9e,
+    0x2b, 0x16, 0xbe, 0x58, 0x7d, 0x47, 0xa1, 0xfc, 0x8f, 0xf8, 0xb8, 0xd1, 0x7a, 0xd0, 0x31, 0xce,
+    0x45, 0xcb, 0x3a, 0x8f, 0x95, 0x16, 0x04, 0x28, 0xaf, 0xd7, 0xfb, 0xca, 0xbb, 0x4b, 0x40, 0x7e,
+]);

package/src/core/math/hash/crc32.d.ts

@@ -0,0 +1,16 @@
+/**
+ * 32-bit Cyclic Redundancy Checksum.
+ * @see https://en.wikipedia.org/wiki/Cyclic_redundancy_check
+ * @param {Uint8Array} buffer byte buffer
+ * @param {number} [offset=0] where to start in the input buffer
+ * @param {number} [length=buffer.length] how many bytes to include in checksum calculation
+ * @return {number} Unsigned 32-bit integer value
+ * @copyright Company Named Limited (c) 2026
+ *
+ * @example
+ *      const buffer = new BinaryBuffer();
+ *      buffer.writeASCIIString("Hello World");
+ *      const checksum = crc32(buffer.raw_bytes, 0, buffer.position);
+ */
+export function crc32(buffer: Uint8Array, offset?: number, length?: number): number;
+//# sourceMappingURL=crc32.d.ts.map

package/src/core/math/hash/crc32.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crc32.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/hash/crc32.js"],"names":[],"mappings":"AA2EA;;;;;;;;;;;;;GAaG;AACH,8BAXW,UAAU,WACV,MAAM,WACN,MAAM,GACL,MAAM,CAcjB"}

package/src/core/math/hash/crc32.js

@@ -0,0 +1,96 @@
+import { assert } from "../../assert.js";
+
+/*
+ * CRC-32/ISO-3309, the reflected 0xEDB88320 variant. The same checksum PNG chunks, ZIP local file
+ * headers and gzip trailers all carry, which is why this lives in core rather than beside any one
+ * of them.
+ *
+ * Ported from C source at https://www.w3.org/TR/PNG-CRCAppendix.html
+ * See also ISO 3309 [ISO-3309] or ITU-T V.42 [ITU-V42] for a formal specification
+ */
+
+/**
+ *
+ * @type {Uint32Array}
+ */
+const crc_table = new Uint32Array(256);
+
+// Precompute checksum table
+for (let n = 0; n < 256; n++) {
+    let c = n;
+
+    for (let k = 0; k < 8; k++) {
+
+        if ((c & 1) !== 0) {
+            // CRC32b polynomial
+            c = 0xedb88320 ^ (c >>> 1);
+        } else {
+            c = c >>> 1;
+        }
+
+    }
+
+    crc_table[n] = c;
+}
+
+const INITIAL = 0xffffffff;
+
+/**
+ * Update a running CRC with the bytes buf[0..len-1]--the CRC
+ * should be initialized to all 1's, and the transmitted value
+ * is the 1's complement of the final running CRC (see the crc32() routine below)).
+ * @param {number} input_crc starting CRC value
+ * @param {Uint8Array} buffer
+ * @param {number} offset
+ * @param {number} length
+ * @return {number}
+ */
+function update_crc(
+    input_crc,
+    buffer,
+    offset,
+    length,
+) {
+    assert.isNonNegativeInteger(input_crc, 'input_crc');
+    assert.defined(buffer, 'buffer');
+    assert.isNonNegativeInteger(offset, 'offset');
+    assert.isNonNegativeInteger(length, 'length');
+
+    let crc = input_crc;
+
+    const end = offset + length;
+
+    for (let n = offset; n < end; n++) {
+
+        const byte = buffer[n];
+
+        const lookup_index = (crc ^ byte) & 0xff;
+
+        crc = crc_table[lookup_index] ^ (crc >>> 8);
+
+    }
+
+    return crc;
+}
+
+/**
+ * 32-bit Cyclic Redundancy Checksum.
+ * @see https://en.wikipedia.org/wiki/Cyclic_redundancy_check
+ * @param {Uint8Array} buffer byte buffer
+ * @param {number} [offset=0] where to start in the input buffer
+ * @param {number} [length=buffer.length] how many bytes to include in checksum calculation
+ * @return {number} Unsigned 32-bit integer value
+ * @copyright Company Named Limited (c) 2026
+ *
+ * @example
+ *      const buffer = new BinaryBuffer();
+ *      buffer.writeASCIIString("Hello World");
+ *      const checksum = crc32(buffer.raw_bytes, 0, buffer.position);
+ */
+export function crc32(
+    buffer,
+    offset=0,
+    length=buffer.length,
+) {
+    return (update_crc(INITIAL, buffer, offset, length) ^ INITIAL) >>> 0;
+}

package/src/core/math/hash/xxh3_128.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Hash `input` to a 128-bit value.
+ *
+ * @param {Uint8Array} input bytes to hash; an empty array is valid
+ * @param {bigint} [seed] alters the whole hash; 0 selects the reference's unseeded behaviour
+ * @returns {XXH128Hash}
+ */
+export function xxh3_128(input: Uint8Array, seed?: bigint): XXH128Hash;
+import { XXH128Hash } from "./XXH128Hash.js";
+//# sourceMappingURL=xxh3_128.d.ts.map

package/src/core/math/hash/xxh3_128.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"xxh3_128.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/hash/xxh3_128.js"],"names":[],"mappings":"AA2TA;;;;;;GAMG;AACH,gCAJW,UAAU,SACV,MAAM,GACJ,UAAU,CAoBtB;2BApV0B,iBAAiB"}