@woosh/meep-engine 3.45.0 → 3.46.0

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

@@ -0,0 +1,224 @@
+/**
+ * Truncate to 64 bits.
+ * @param {bigint} v
+ * @returns {bigint}
+ */
+export function u64(v: bigint): bigint;
+/**
+ * @param {bigint} a
+ * @param {bigint} b
+ * @returns {bigint}
+ */
+export function mul64(a: bigint, b: bigint): bigint;
+/**
+ * @param {bigint} a
+ * @param {bigint} b
+ * @returns {bigint}
+ */
+export function add64(a: bigint, b: bigint): bigint;
+/**
+ * Two's-complement 64-bit subtraction.
+ * @param {bigint} a
+ * @param {bigint} b
+ * @returns {bigint}
+ */
+export function sub64(a: bigint, b: bigint): bigint;
+/**
+ * @param {bigint} v
+ * @param {number} bits
+ * @returns {bigint}
+ */
+export function rotl64(v: bigint, bits: number): bigint;
+/**
+ * Rotate within 32 bits, as the reference's `XXH_rotl32`.
+ * @param {bigint} v
+ * @param {number} bits
+ * @returns {bigint}
+ */
+export function rotl32(v: bigint, bits: number): bigint;
+/**
+ * @param {bigint} v
+ * @param {number} bits
+ * @returns {bigint}
+ */
+export function xorshift64(v: bigint, bits: number): bigint;
+/**
+ * Byte-reverse a 32-bit value, as the reference's `XXH_swap32`.
+ * @param {bigint} v
+ * @returns {bigint}
+ */
+export function swap32(v: bigint): bigint;
+/**
+ * Byte-reverse a 64-bit value, as the reference's `XXH_swap64`.
+ * @param {bigint} v
+ * @returns {bigint}
+ */
+export function swap64(v: bigint): bigint;
+/**
+ * Widening 32x32 -> 64 multiply of the low halves of both operands, as the reference's
+ * `XXH_mult32to64`.
+ *
+ * @param {bigint} a
+ * @param {bigint} b
+ * @returns {bigint}
+ */
+export function mult32to64(a: bigint, b: bigint): bigint;
+/**
+ * 64x64 -> 128 multiply, folded down by XOR of the two halves.
+ *
+ * @param {bigint} a
+ * @param {bigint} b
+ * @returns {bigint}
+ */
+export function mul128_fold64(a: bigint, b: bigint): bigint;
+/**
+ * The fast finalizing mix, for input whose bits are already partially mixed.
+ * @param {bigint} h64
+ * @returns {bigint}
+ */
+export function xxh3_avalanche(h64: bigint): bigint;
+/**
+ * The stronger finalizing mix (after Pelle Evensen's rrmxmx), for input that has not been mixed yet.
+ * @param {bigint} h64
+ * @param {number} len
+ * @returns {bigint}
+ */
+export function xxh3_rrmxmx(h64: bigint, len: number): bigint;
+/**
+ * XXH64's finalizing mix, which XXH3 reuses for its shortest inputs.
+ * @param {bigint} hash
+ * @returns {bigint}
+ */
+export function xxh64_avalanche(hash: bigint): bigint;
+/**
+ * Read a little-endian u32 at `offset`.
+ *
+ * @param {Uint8Array} bytes
+ * @param {number} offset
+ * @returns {bigint}
+ */
+export function read_u32(bytes: Uint8Array, offset: number): bigint;
+/**
+ * Read a little-endian u64 at `offset`.
+ *
+ * @param {Uint8Array} bytes
+ * @param {number} offset
+ * @returns {bigint}
+ */
+export function read_u64(bytes: Uint8Array, offset: number): bigint;
+/**
+ * Write a little-endian u64 at `offset`.
+ *
+ * @param {Uint8Array} bytes
+ * @param {number} offset
+ * @param {bigint} value
+ */
+export function write_u64(bytes: Uint8Array, offset: number, value: bigint): void;
+/**
+ * The 16-byte mixing step shared by every mid-size path.
+ *
+ * @param {Uint8Array} input
+ * @param {number} input_offset
+ * @param {Uint8Array} secret
+ * @param {number} secret_offset
+ * @param {bigint} seed
+ * @returns {bigint}
+ */
+export function xxh3_mix16b(input: Uint8Array, input_offset: number, secret: Uint8Array, secret_offset: number, seed: bigint): bigint;
+/**
+ * Derive a 192-byte secret from `seed`, as the reference's `XXH3_initCustomSecret`. This is what
+ * makes a seeded hash of a long input differ from the unseeded one.
+ *
+ * @param {bigint} seed
+ * @returns {Uint8Array} freshly allocated, {@link XXH3_SECRET}'s length
+ */
+export function xxh3_init_custom_secret(seed: bigint): Uint8Array;
+/**
+ * Run the whole long-input accumulator loop: whole blocks with a scramble after each, then the
+ * trailing partial block, then the (possibly overlapping) final stripe.
+ *
+ * @param {BigUint64Array} acc
+ * @param {Uint8Array} input
+ * @param {Uint8Array} secret
+ */
+export function xxh3_hash_long_loop(acc: BigUint64Array, input: Uint8Array, secret: Uint8Array): void;
+/**
+ * Fold the eight lanes down to one 64-bit value.
+ *
+ * @param {BigUint64Array} acc
+ * @param {Uint8Array} secret
+ * @param {number} secret_offset
+ * @param {bigint} start
+ * @returns {bigint}
+ */
+export function xxh3_merge_accs(acc: BigUint64Array, secret: Uint8Array, secret_offset: number, start: bigint): bigint;
+/**
+ * The accumulator lanes' initial state.
+ * @returns {BigUint64Array} freshly allocated, {@link XXH_ACC_NB} lanes
+ */
+export function xxh3_init_acc(): BigUint64Array;
+/**
+ * The secret a seeded hash of a long input runs against: the default one for seed 0, a derived one
+ * otherwise. Shared by both variants so they agree on the seed-0 shortcut.
+ *
+ * @param {bigint} seed
+ * @returns {Uint8Array}
+ */
+export function xxh3_long_secret(seed: bigint): Uint8Array;
+/**
+ * Common argument checks for the public entry points.
+ *
+ * @param {Uint8Array} input
+ * @param {bigint} seed
+ */
+export function xxh3_assert_arguments(input: Uint8Array, seed: bigint): void;
+/**
+ * The pieces of xxHash3 that the 64-bit and 128-bit variants share: the primes, the mixing stages,
+ * and the long-input accumulator loop. Everything here is a direct transcription of the reference
+ * implementation's scalar path — the vectorized paths produce identical results by construction, so
+ * the scalar one is the whole specification.
+ *
+ * Arithmetic is `BigInt` masked to 64 bits after every operation. This is a build-time hash (asset
+ * identity, container checksums), never a per-frame one, so clarity against the reference wins over
+ * the 32-bit-lane decomposition a runtime implementation would need.
+ *
+ * @see https://github.com/Cyan4973/xxHash/blob/dev/xxhash.h
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+/**
+ * @readonly
+ * @type {bigint}
+ */
+export const XXH_MASK_64: bigint;
+export const XXH_PRIME32_1: 2654435761n;
+export const XXH_PRIME32_2: 2246822519n;
+export const XXH_PRIME32_3: 3266489917n;
+export const XXH_PRIME64_1: 11400714785074694791n;
+export const XXH_PRIME64_2: 14029467366897019727n;
+export const XXH_PRIME64_3: 1609587929392839161n;
+export const XXH_PRIME64_4: 9650029242287828579n;
+export const XXH_PRIME64_5: 2870177450012600261n;
+export const XXH_PRIME_MX1: 1609587791953885689n;
+export const XXH_PRIME_MX2: 11507291218515648293n;
+/**
+ * Shortest secret any variant accepts, and the anchor for the mid-size tail offsets.
+ * @readonly
+ * @type {number}
+ */
+export const XXH3_SECRET_SIZE_MIN: number;
+/**
+ * Longest input still handled by the "mid size" single-shot paths.
+ * @readonly
+ * @type {number}
+ */
+export const XXH3_MIDSIZE_MAX: number;
+export const XXH3_MIDSIZE_STARTOFFSET: 3;
+export const XXH3_MIDSIZE_LASTOFFSET: 17;
+export const XXH_STRIPE_LEN: 64;
+export const XXH_SECRET_CONSUME_RATE: 8;
+export const XXH_ACC_NB: 8;
+export const XXH_SECRET_LASTACC_START: 7;
+export const XXH_SECRET_MERGEACCS_START: 11;
+//# sourceMappingURL=xxh3_common.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"xxh3_common.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/hash/xxh3_common.js"],"names":[],"mappings":"AA+DA;;;;GAIG;AACH,uBAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,yBAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,yBAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;GAKG;AACH,yBAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,0BAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAMlB;AAED;;;;;GAKG;AACH,0BAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAOlB;AAED;;;;GAIG;AACH,8BAJW,MAAM,QACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;GAIG;AACH,0BAHW,MAAM,GACJ,MAAM,CAMlB;AAED;;;;GAIG;AACH,0BAHW,MAAM,GACJ,MAAM,CAWlB;AAED;;;;;;;GAOG;AACH,8BAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;GAMG;AACH,iCAJW,MAAM,KACN,MAAM,GACJ,MAAM,CAMlB;AAED;;;;GAIG;AACH,oCAHW,MAAM,GACJ,MAAM,CASlB;AAED;;;;;GAKG;AACH,iCAJW,MAAM,OACN,MAAM,GACJ,MAAM,CAUlB;AAED;;;;GAIG;AACH,sCAHW,MAAM,GACJ,MAAM,CAWlB;AAED;;;;;;GAMG;AACH,gCAJW,UAAU,UACV,MAAM,GACJ,MAAM,CASlB;AAED;;;;;;GAMG;AACH,gCAJW,UAAU,UACV,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;GAMG;AACH,iCAJW,UAAU,UACV,MAAM,SACN,MAAM,QAShB;AAED;;;;;;;;;GASG;AACH,mCAPW,UAAU,gBACV,MAAM,UACN,UAAU,iBACV,MAAM,QACN,MAAM,GACJ,MAAM,CAUlB;AAED;;;;;;GAMG;AACH,8CAHW,MAAM,GACJ,UAAU,CAgBtB;AA6DD;;;;;;;GAOG;AACH,yCAJW,cAAc,SACd,UAAU,UACV,UAAU,QAwBpB;AAED;;;;;;;;GAQG;AACH,qCANW,cAAc,UACd,UAAU,iBACV,MAAM,SACN,MAAM,GACJ,MAAM,CAalB;AAED;;;GAGG;AACH,iCAFa,cAAc,CAe1B;AAED;;;;;;GAMG;AACH,uCAHW,MAAM,GACJ,UAAU,CAQtB;AAED;;;;;GAKG;AACH,6CAHW,UAAU,QACV,MAAM,QAOhB;AAxdD;;;;;;;;;;;;;;GAcG;AAEH;;;GAGG;AACH,0BAFU,MAAM,CAE+B;AAI/C,wCAAyC;AACzC,wCAAyC;AACzC,wCAAyC;AAEzC,kDAAiD;AACjD,kDAAiD;AACjD,iDAAiD;AACjD,iDAAiD;AACjD,iDAAiD;AAEjD,iDAAiD;AACjD,kDAAiD;AAEjD;;;;GAIG;AACH,mCAFU,MAAM,CAEwB;AAExC;;;;GAIG;AACH,+BAFU,MAAM,CAEoB;AAEpC,yCAA0C;AAC1C,yCAA0C;AAE1C,gCAAiC;AACjC,wCAAyC;AACzC,2BAA4B;AAC5B,yCAA0C;AAC1C,4CAA6C"}

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

@@ -0,0 +1,476 @@
+import { assert } from "../../assert.js";
+import { XXH3_SECRET } from "./XXH3_SECRET.js";
+
+/**
+ * The pieces of xxHash3 that the 64-bit and 128-bit variants share: the primes, the mixing stages,
+ * and the long-input accumulator loop. Everything here is a direct transcription of the reference
+ * implementation's scalar path — the vectorized paths produce identical results by construction, so
+ * the scalar one is the whole specification.
+ *
+ * Arithmetic is `BigInt` masked to 64 bits after every operation. This is a build-time hash (asset
+ * identity, container checksums), never a per-frame one, so clarity against the reference wins over
+ * the 32-bit-lane decomposition a runtime implementation would need.
+ *
+ * @see https://github.com/Cyan4973/xxHash/blob/dev/xxhash.h
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * @readonly
+ * @type {bigint}
+ */
+export const XXH_MASK_64 = 0xFFFFFFFFFFFFFFFFn;
+
+const MASK_32 = 0xFFFFFFFFn;
+
+export const XXH_PRIME32_1 = 0x9E3779B1n;
+export const XXH_PRIME32_2 = 0x85EBCA77n;
+export const XXH_PRIME32_3 = 0xC2B2AE3Dn;
+
+export const XXH_PRIME64_1 = 0x9E3779B185EBCA87n;
+export const XXH_PRIME64_2 = 0xC2B2AE3D27D4EB4Fn;
+export const XXH_PRIME64_3 = 0x165667B19E3779F9n;
+export const XXH_PRIME64_4 = 0x85EBCA77C2B2AE63n;
+export const XXH_PRIME64_5 = 0x27D4EB2F165667C5n;
+
+export const XXH_PRIME_MX1 = 0x165667919E3779F9n;
+export const XXH_PRIME_MX2 = 0x9FB21C651E98DF25n;
+
+/**
+ * Shortest secret any variant accepts, and the anchor for the mid-size tail offsets.
+ * @readonly
+ * @type {number}
+ */
+export const XXH3_SECRET_SIZE_MIN = 136;
+
+/**
+ * Longest input still handled by the "mid size" single-shot paths.
+ * @readonly
+ * @type {number}
+ */
+export const XXH3_MIDSIZE_MAX = 240;
+
+export const XXH3_MIDSIZE_STARTOFFSET = 3;
+export const XXH3_MIDSIZE_LASTOFFSET = 17;
+
+export const XXH_STRIPE_LEN = 64;
+export const XXH_SECRET_CONSUME_RATE = 8;
+export const XXH_ACC_NB = 8;
+export const XXH_SECRET_LASTACC_START = 7;
+export const XXH_SECRET_MERGEACCS_START = 11;
+
+/**
+ * Truncate to 64 bits.
+ * @param {bigint} v
+ * @returns {bigint}
+ */
+export function u64(v) {
+    return v & XXH_MASK_64;
+}
+
+/**
+ * @param {bigint} a
+ * @param {bigint} b
+ * @returns {bigint}
+ */
+export function mul64(a, b) {
+    return (a * b) & XXH_MASK_64;
+}
+
+/**
+ * @param {bigint} a
+ * @param {bigint} b
+ * @returns {bigint}
+ */
+export function add64(a, b) {
+    return (a + b) & XXH_MASK_64;
+}
+
+/**
+ * Two's-complement 64-bit subtraction.
+ * @param {bigint} a
+ * @param {bigint} b
+ * @returns {bigint}
+ */
+export function sub64(a, b) {
+    return (a - b) & XXH_MASK_64;
+}
+
+/**
+ * @param {bigint} v
+ * @param {number} bits
+ * @returns {bigint}
+ */
+export function rotl64(v, bits) {
+    const n = BigInt(bits);
+
+    return ((v << n) | (v >> (64n - n))) & XXH_MASK_64;
+}
+
+/**
+ * Rotate within 32 bits, as the reference's `XXH_rotl32`.
+ * @param {bigint} v
+ * @param {number} bits
+ * @returns {bigint}
+ */
+export function rotl32(v, bits) {
+    const x = v & MASK_32;
+    const n = BigInt(bits);
+
+    return ((x << n) | (x >> (32n - n))) & MASK_32;
+}
+
+/**
+ * @param {bigint} v
+ * @param {number} bits
+ * @returns {bigint}
+ */
+export function xorshift64(v, bits) {
+    return v ^ (v >> BigInt(bits));
+}
+
+/**
+ * Byte-reverse a 32-bit value, as the reference's `XXH_swap32`.
+ * @param {bigint} v
+ * @returns {bigint}
+ */
+export function swap32(v) {
+    const x = v & MASK_32;
+
+    return ((x << 24n) | ((x & 0xFF00n) << 8n) | ((x >> 8n) & 0xFF00n) | (x >> 24n)) & MASK_32;
+}
+
+/**
+ * Byte-reverse a 64-bit value, as the reference's `XXH_swap64`.
+ * @param {bigint} v
+ * @returns {bigint}
+ */
+export function swap64(v) {
+    return ((v & 0x00000000000000FFn) << 56n)
+        | ((v & 0x000000000000FF00n) << 40n)
+        | ((v & 0x0000000000FF0000n) << 24n)
+        | ((v & 0x00000000FF000000n) << 8n)
+        | ((v & 0x000000FF00000000n) >> 8n)
+        | ((v & 0x0000FF0000000000n) >> 24n)
+        | ((v & 0x00FF000000000000n) >> 40n)
+        | ((v & 0xFF00000000000000n) >> 56n);
+}
+
+/**
+ * Widening 32x32 -> 64 multiply of the low halves of both operands, as the reference's
+ * `XXH_mult32to64`.
+ *
+ * @param {bigint} a
+ * @param {bigint} b
+ * @returns {bigint}
+ */
+export function mult32to64(a, b) {
+    return (a & MASK_32) * (b & MASK_32);
+}
+
+/**
+ * 64x64 -> 128 multiply, folded down by XOR of the two halves.
+ *
+ * @param {bigint} a
+ * @param {bigint} b
+ * @returns {bigint}
+ */
+export function mul128_fold64(a, b) {
+    const product = a * b;
+
+    return (product ^ (product >> 64n)) & XXH_MASK_64;
+}
+
+/**
+ * The fast finalizing mix, for input whose bits are already partially mixed.
+ * @param {bigint} h64
+ * @returns {bigint}
+ */
+export function xxh3_avalanche(h64) {
+    let h = xorshift64(h64, 37);
+
+    h = mul64(h, XXH_PRIME_MX1);
+    h = xorshift64(h, 32);
+
+    return h & XXH_MASK_64;
+}
+
+/**
+ * The stronger finalizing mix (after Pelle Evensen's rrmxmx), for input that has not been mixed yet.
+ * @param {bigint} h64
+ * @param {number} len
+ * @returns {bigint}
+ */
+export function xxh3_rrmxmx(h64, len) {
+    let h = h64 ^ rotl64(h64, 49) ^ rotl64(h64, 24);
+
+    h = mul64(h, XXH_PRIME_MX2);
+    h = u64(h ^ add64(h >> 35n, BigInt(len)));
+    h = mul64(h, XXH_PRIME_MX2);
+
+    return xorshift64(h, 28) & XXH_MASK_64;
+}
+
+/**
+ * XXH64's finalizing mix, which XXH3 reuses for its shortest inputs.
+ * @param {bigint} hash
+ * @returns {bigint}
+ */
+export function xxh64_avalanche(hash) {
+    let h = hash ^ (hash >> 33n);
+
+    h = mul64(h, XXH_PRIME64_2);
+    h ^= h >> 29n;
+    h = mul64(h, XXH_PRIME64_3);
+    h ^= h >> 32n;
+
+    return h & XXH_MASK_64;
+}
+
+/**
+ * Read a little-endian u32 at `offset`.
+ *
+ * @param {Uint8Array} bytes
+ * @param {number} offset
+ * @returns {bigint}
+ */
+export function read_u32(bytes, offset) {
+    return BigInt(
+        bytes[offset]
+        | (bytes[offset + 1] << 8)
+        | (bytes[offset + 2] << 16)
+        | (bytes[offset + 3] << 24)
+    ) & MASK_32;
+}
+
+/**
+ * Read a little-endian u64 at `offset`.
+ *
+ * @param {Uint8Array} bytes
+ * @param {number} offset
+ * @returns {bigint}
+ */
+export function read_u64(bytes, offset) {
+    return read_u32(bytes, offset) | (read_u32(bytes, offset + 4) << 32n);
+}
+
+/**
+ * Write a little-endian u64 at `offset`.
+ *
+ * @param {Uint8Array} bytes
+ * @param {number} offset
+ * @param {bigint} value
+ */
+export function write_u64(bytes, offset, value) {
+    let v = value & XXH_MASK_64;
+
+    for (let i = 0; i < 8; i++) {
+        bytes[offset + i] = Number(v & 0xFFn);
+        v >>= 8n;
+    }
+}
+
+/**
+ * The 16-byte mixing step shared by every mid-size path.
+ *
+ * @param {Uint8Array} input
+ * @param {number} input_offset
+ * @param {Uint8Array} secret
+ * @param {number} secret_offset
+ * @param {bigint} seed
+ * @returns {bigint}
+ */
+export function xxh3_mix16b(input, input_offset, secret, secret_offset, seed) {
+    const input_lo = read_u64(input, input_offset);
+    const input_hi = read_u64(input, input_offset + 8);
+
+    return mul128_fold64(
+        input_lo ^ add64(read_u64(secret, secret_offset), seed),
+        input_hi ^ sub64(read_u64(secret, secret_offset + 8), seed)
+    );
+}
+
+/**
+ * Derive a 192-byte secret from `seed`, as the reference's `XXH3_initCustomSecret`. This is what
+ * makes a seeded hash of a long input differ from the unseeded one.
+ *
+ * @param {bigint} seed
+ * @returns {Uint8Array} freshly allocated, {@link XXH3_SECRET}'s length
+ */
+export function xxh3_init_custom_secret(seed) {
+    const result = new Uint8Array(XXH3_SECRET.length);
+
+    const pair_count = XXH3_SECRET.length / 16;
+
+    for (let i = 0; i < pair_count; i++) {
+        const lo = add64(read_u64(XXH3_SECRET, 16 * i), seed);
+        const hi = sub64(read_u64(XXH3_SECRET, 16 * i + 8), seed);
+
+        write_u64(result, 16 * i, lo);
+        write_u64(result, 16 * i + 8, hi);
+    }
+
+    return result;
+}
+
+/**
+ * Accumulate one 64-byte stripe into the eight lanes.
+ *
+ * @param {BigUint64Array} acc
+ * @param {Uint8Array} input
+ * @param {number} input_offset
+ * @param {Uint8Array} secret
+ * @param {number} secret_offset
+ */
+function accumulate_512(acc, input, input_offset, secret, secret_offset) {
+    for (let lane = 0; lane < XXH_ACC_NB; lane++) {
+        const data_val = read_u64(input, input_offset + lane * 8);
+        const data_key = data_val ^ read_u64(secret, secret_offset + lane * 8);
+
+        acc[lane ^ 1] = add64(acc[lane ^ 1], data_val);
+        acc[lane] = add64(mult32to64(data_key, data_key >> 32n), acc[lane]);
+    }
+}
+
+/**
+ * Accumulate `stripe_count` consecutive stripes, advancing the secret by
+ * {@link XXH_SECRET_CONSUME_RATE} per stripe.
+ *
+ * @param {BigUint64Array} acc
+ * @param {Uint8Array} input
+ * @param {number} input_offset
+ * @param {Uint8Array} secret
+ * @param {number} stripe_count
+ */
+function accumulate(acc, input, input_offset, secret, stripe_count) {
+    for (let n = 0; n < stripe_count; n++) {
+        accumulate_512(
+            acc,
+            input, input_offset + n * XXH_STRIPE_LEN,
+            secret, n * XXH_SECRET_CONSUME_RATE
+        );
+    }
+}
+
+/**
+ * Scramble the lanes between blocks, so that a block's contribution cannot be undone by a later one.
+ *
+ * @param {BigUint64Array} acc
+ * @param {Uint8Array} secret
+ * @param {number} secret_offset
+ */
+function scramble_acc(acc, secret, secret_offset) {
+    for (let lane = 0; lane < XXH_ACC_NB; lane++) {
+        const key64 = read_u64(secret, secret_offset + lane * 8);
+
+        let acc64 = xorshift64(acc[lane], 47);
+
+        acc64 ^= key64;
+        acc64 = mul64(acc64, XXH_PRIME32_1);
+
+        acc[lane] = acc64;
+    }
+}
+
+/**
+ * Run the whole long-input accumulator loop: whole blocks with a scramble after each, then the
+ * trailing partial block, then the (possibly overlapping) final stripe.
+ *
+ * @param {BigUint64Array} acc
+ * @param {Uint8Array} input
+ * @param {Uint8Array} secret
+ */
+export function xxh3_hash_long_loop(acc, input, secret) {
+    const len = input.length;
+    const secret_size = secret.length;
+
+    const stripes_per_block = ((secret_size - XXH_STRIPE_LEN) / XXH_SECRET_CONSUME_RATE) | 0;
+    const block_len = XXH_STRIPE_LEN * stripes_per_block;
+    const block_count = ((len - 1) / block_len) | 0;
+
+    for (let n = 0; n < block_count; n++) {
+        accumulate(acc, input, n * block_len, secret, stripes_per_block);
+        scramble_acc(acc, secret, secret_size - XXH_STRIPE_LEN);
+    }
+
+    const trailing_stripes = (((len - 1) - (block_len * block_count)) / XXH_STRIPE_LEN) | 0;
+
+    accumulate(acc, input, block_count * block_len, secret, trailing_stripes);
+
+    accumulate_512(
+        acc,
+        input, len - XXH_STRIPE_LEN,
+        secret, secret_size - XXH_STRIPE_LEN - XXH_SECRET_LASTACC_START
+    );
+}
+
+/**
+ * Fold the eight lanes down to one 64-bit value.
+ *
+ * @param {BigUint64Array} acc
+ * @param {Uint8Array} secret
+ * @param {number} secret_offset
+ * @param {bigint} start
+ * @returns {bigint}
+ */
+export function xxh3_merge_accs(acc, secret, secret_offset, start) {
+    let result = start & XXH_MASK_64;
+
+    for (let i = 0; i < 4; i++) {
+        result = add64(result, mul128_fold64(
+            acc[2 * i] ^ read_u64(secret, secret_offset + 16 * i),
+            acc[2 * i + 1] ^ read_u64(secret, secret_offset + 16 * i + 8)
+        ));
+    }
+
+    return xxh3_avalanche(result);
+}
+
+/**
+ * The accumulator lanes' initial state.
+ * @returns {BigUint64Array} freshly allocated, {@link XXH_ACC_NB} lanes
+ */
+export function xxh3_init_acc() {
+    const acc = new BigUint64Array(XXH_ACC_NB);
+
+    acc[0] = XXH_PRIME32_3;
+    acc[1] = XXH_PRIME64_1;
+    acc[2] = XXH_PRIME64_2;
+    acc[3] = XXH_PRIME64_3;
+    acc[4] = XXH_PRIME64_4;
+    acc[5] = XXH_PRIME32_2;
+    acc[6] = XXH_PRIME64_5;
+    acc[7] = XXH_PRIME32_1;
+
+    return acc;
+}
+
+/**
+ * The secret a seeded hash of a long input runs against: the default one for seed 0, a derived one
+ * otherwise. Shared by both variants so they agree on the seed-0 shortcut.
+ *
+ * @param {bigint} seed
+ * @returns {Uint8Array}
+ */
+export function xxh3_long_secret(seed) {
+    if (seed === 0n) {
+        return XXH3_SECRET;
+    }
+
+    return xxh3_init_custom_secret(seed);
+}
+
+/**
+ * Common argument checks for the public entry points.
+ *
+ * @param {Uint8Array} input
+ * @param {bigint} seed
+ */
+export function xxh3_assert_arguments(input, seed) {
+    assert.defined(input, 'input');
+    assert.notNull(input, 'input');
+    assert.isArrayLike(input, 'input');
+    assert.equal(typeof seed, 'bigint', `seed must be a bigint, instead was '${typeof seed}'`);
+}