distillate 0.9.0 → 0.10.0

package/dist/fuse/index.d.ts

@@ -1,7 +1,8 @@
-import { a as TruncatedError, c as BytesLike, i as SerializationError, n as ChecksumError, o as UnknownHashVariantError, r as FilterJSON, s as UnknownVersionError, t as BadMagicError } from "../serialize-Bv1zWzrh.js";
+import { t as BytesLike } from "../bytes-DCuYtUVS.js";
+import { a as ReservedBitsError, c as UnknownHashVariantError, l as UnknownVersionError, n as ChecksumError, o as SerializationError, r as FilterJSON, s as TruncatedError, t as BadMagicError } from "../serialize--xR6vGSW.js";
 //#region src/fuse/fuse.d.ts
 /** Thrown when binary fuse construction fails to converge on the key set. */
-declare class BinaryFuseBuildError extends Error {
+export declare class BinaryFuseBuildError extends Error {
   /** Discriminates this error from other `Error`s. */
   override readonly name = "BinaryFuseBuildError";
 }
@@ -20,7 +21,7 @@ interface FuseParams {
  * @param width - Fingerprint width in bits: `8` for {@link BinaryFuse8}, `16` for {@link BinaryFuse16}.
  * @returns Bits per key (`0` for an empty filter).
  */
-declare function fuseBitsPerKey(n: number, width: 8 | 16): number;
+export declare function fuseBitsPerKey(n: number, width: 8 | 16): number;
 interface FuseState {
   fp: Uint8Array | Uint16Array;
   seed: number;
@@ -81,7 +82,7 @@ declare abstract class BinaryFuse {
  * filter.size; // 3
  * ```
  */
-declare class BinaryFuse8 extends BinaryFuse {
+export declare class BinaryFuse8 extends BinaryFuse {
   /**
    * Builds a filter from the given keys; duplicates are ignored.
    *
@@ -115,7 +116,7 @@ declare class BinaryFuse8 extends BinaryFuse {
  * filter.has("alice"); // true
  * ```
  */
-declare class BinaryFuse16 extends BinaryFuse {
+export declare class BinaryFuse16 extends BinaryFuse {
   /**
    * Builds a filter from the given keys; duplicates are ignored.
    *
@@ -140,4 +141,4 @@ declare class BinaryFuse16 extends BinaryFuse {
   static fromJSON(value: unknown): BinaryFuse16;
 }
 //#endregion
-export { BadMagicError, BinaryFuse16, BinaryFuse8, BinaryFuseBuildError, ChecksumError, type FilterJSON, SerializationError, TruncatedError, UnknownHashVariantError, UnknownVersionError, fuseBitsPerKey };
+export { BadMagicError, ChecksumError, type FilterJSON, ReservedBitsError, SerializationError, TruncatedError, UnknownHashVariantError, UnknownVersionError };

package/dist/fuse/index.js

@@ -1,8 +1,10 @@
-import { _ as hash128KeyInto, a as UnknownHashVariantError, c as assertMinBodyLength, d as readHeader, f as toJSONEnvelope, g as fmix64, h as RLO, i as TruncatedError, l as bytesEqual, m as RHI, n as ChecksumError, o as UnknownVersionError, p as writeFrame, r as SerializationError, s as assertBodyLength, t as BadMagicError, u as fromJSONEnvelope, y as mul64 } from "../serialize-D59Ri81a.js";
+import { i as hash128KeyInto, n as RLO, o as mul64, r as fmix64, t as RHI } from "../hasher-DVWXS_vJ.js";
+import { a as TruncatedError, c as assertBodyLength, d as bytesEqual, f as fromJSONEnvelope, g as writeFrame, h as toJSONEnvelope, i as SerializationError, l as assertMinBodyLength, m as readHeader, n as ChecksumError, o as UnknownHashVariantError, r as ReservedBitsError, s as UnknownVersionError, t as BadMagicError } from "../serialize-CMSYFym-.js";
 //#region src/fuse/fuse.ts
 const ARITY = 3;
 const TYPE_FUSE8 = 3;
 const TYPE_FUSE16 = 4;
+const PARAMS_SIZE = 16;
 var BinaryFuseBuildError = class extends Error {
 	name = "BinaryFuseBuildError";
 };
@@ -43,10 +45,10 @@ function computeParams(size) {
 	const segMask = seg - 1;
 	const sizeFactor = Math.max(1.125, .875 + .25 * Math.log(1e6) / Math.log(Math.max(size, 2)));
 	const capacity = Math.round(size * sizeFactor);
-	let segCount = Math.floor((capacity + seg - 1) / seg) - (ARITY - 1);
+	let segCount = Math.floor((capacity + seg - 1) / seg) - 2;
 	if (segCount <= 0) segCount = 1;
 	let arrayLength = (segCount + ARITY - 1) * seg;
-	segCount = Math.floor((arrayLength + seg - 1) / seg) - (ARITY - 1);
+	segCount = Math.floor((arrayLength + seg - 1) / seg) - 2;
 	if (segCount <= 0) segCount = 1;
 	arrayLength = (segCount + ARITY - 1) * seg;
 	return {
@@ -160,7 +162,7 @@ function fuseStateFromBytes(bytes, expectedType) {
 	const { type, flags, body } = readHeader(bytes);
 	if (type !== expectedType) throw new SerializationError(`expected DSTL type ${String(expectedType)}, got ${String(type)}`);
 	if ((flags & 15) !== 0) throw new UnknownHashVariantError(`unsupported hash variant ${String(flags & 15)}`);
-	assertMinBodyLength(body.length, 16, "fuse");
+	assertMinBodyLength(body.length, PARAMS_SIZE, "fuse");
 	const dv = new DataView(body.buffer, body.byteOffset, body.byteLength);
 	const seed = dv.getUint32(0, true);
 	const seg = dv.getUint32(4, true);
@@ -170,8 +172,8 @@ function fuseStateFromBytes(bytes, expectedType) {
 	if (segCountLen % seg !== 0) throw new SerializationError(`fuse segment count length ${String(segCountLen)} is not a multiple of segment length ${String(seg)}`);
 	const bpe = expectedType === TYPE_FUSE8 ? 1 : 2;
 	const expectedArrayLength = size === 0 ? 0 : segCountLen + 2 * seg;
-	assertBodyLength(body.length, 16 + expectedArrayLength * bpe, "fuse");
-	const laneBytes = body.subarray(16);
+	assertBodyLength(body.length, PARAMS_SIZE + expectedArrayLength * bpe, "fuse");
+	const laneBytes = body.subarray(PARAMS_SIZE);
 	const arrayLength = laneBytes.length / bpe;
 	const fp = bpe === 1 ? new Uint8Array(arrayLength) : new Uint16Array(arrayLength);
 	new Uint8Array(fp.buffer).set(laneBytes);
@@ -214,16 +216,17 @@ var BinaryFuse = class {
 	}
 	toBytes() {
 		const laneBytes = new Uint8Array(this.#fp.buffer, this.#fp.byteOffset, this.#fp.byteLength);
+		const type = this.#fp.BYTES_PER_ELEMENT === 1 ? TYPE_FUSE8 : TYPE_FUSE16;
 		return writeFrame({
-			version: 4,
-			type: this.#fp.BYTES_PER_ELEMENT === 1 ? TYPE_FUSE8 : TYPE_FUSE16,
+			version: 5,
+			type,
 			flags: 0
-		}, 16 + laneBytes.length, (body, dv) => {
+		}, PARAMS_SIZE, laneBytes.length, (body, dv) => {
 			dv.setUint32(0, this.#seed, true);
 			dv.setUint32(4, this.#seg, true);
 			dv.setUint32(8, this.#segCountLen, true);
 			dv.setUint32(12, this.#size, true);
-			body.set(laneBytes, 16);
+			body.set(laneBytes, PARAMS_SIZE);
 		});
 	}
 	has(key) {
@@ -269,4 +272,4 @@ var BinaryFuse16 = class BinaryFuse16 extends BinaryFuse {
 	}
 };
 //#endregion
-export { BadMagicError, BinaryFuse16, BinaryFuse8, BinaryFuseBuildError, ChecksumError, SerializationError, TruncatedError, UnknownHashVariantError, UnknownVersionError, fuseBitsPerKey };
+export { BadMagicError, BinaryFuse16, BinaryFuse8, BinaryFuseBuildError, ChecksumError, ReservedBitsError, SerializationError, TruncatedError, UnknownHashVariantError, UnknownVersionError, fuseBitsPerKey };

package/dist/hasher-D8LCBTOM.cjs

@@ -0,0 +1,276 @@
+//#region src/core/bytes.ts
+const encoder = new TextEncoder();
+function normalize(input) {
+	if (typeof input === "string") return encoder.encode(input);
+	if (input instanceof Uint8Array) return input;
+	return new Uint8Array(input);
+}
+//#endregion
+//#region src/core/hasher.ts
+let RLO = 0;
+let RHI = 0;
+const LANES = {
+	w0: 0,
+	w1: 0,
+	w2: 0,
+	w3: 0
+};
+function mul64(alo, ahi, blo, bhi) {
+	const a0 = alo & 65535;
+	const a1 = alo >>> 16;
+	const a2 = ahi & 65535;
+	const a3 = ahi >>> 16;
+	const b0 = blo & 65535;
+	const b1 = blo >>> 16;
+	const b2 = bhi & 65535;
+	const b3 = bhi >>> 16;
+	let c0 = a0 * b0;
+	let c1 = c0 >>> 16;
+	c0 &= 65535;
+	c1 += a1 * b0;
+	let c2 = c1 >>> 16;
+	c1 &= 65535;
+	c1 += a0 * b1;
+	c2 += c1 >>> 16;
+	c1 &= 65535;
+	c2 += a2 * b0;
+	let c3 = c2 >>> 16;
+	c2 &= 65535;
+	c2 += a1 * b1;
+	c3 += c2 >>> 16;
+	c2 &= 65535;
+	c2 += a0 * b2;
+	c3 += c2 >>> 16;
+	c2 &= 65535;
+	c3 += a3 * b0 + a2 * b1 + a1 * b2 + a0 * b3;
+	c3 &= 65535;
+	RLO = (c1 << 16 | c0) >>> 0;
+	RHI = (c3 << 16 | c2) >>> 0;
+}
+function fmix64(lo, hi) {
+	let l = lo;
+	let h = hi;
+	l = (l ^ h >>> 1) >>> 0;
+	mul64(l, h, 3981806797, 4283543511);
+	l = RLO;
+	h = RHI;
+	l = (l ^ h >>> 1) >>> 0;
+	mul64(l, h, 444984403, 3301882366);
+	l = RLO;
+	h = RHI;
+	l = (l ^ h >>> 1) >>> 0;
+	RLO = l;
+	RHI = h;
+}
+function rotl32(x, r) {
+	return (x << r | x >>> 32 - r) >>> 0;
+}
+function fmix32(h) {
+	let x = h;
+	x ^= x >>> 16;
+	x = Math.imul(x, 2246822507);
+	x ^= x >>> 13;
+	x = Math.imul(x, 3266489909);
+	x ^= x >>> 16;
+	return x >>> 0;
+}
+const K1 = 597399067;
+const K2 = 2869860233;
+const K3 = 951274213;
+const K4 = 2716044179;
+function computeLanes(bytes, seed, len) {
+	const nblocks = len >>> 4;
+	let h1 = seed >>> 0;
+	let h2 = seed >>> 0;
+	let h3 = seed >>> 0;
+	let h4 = seed >>> 0;
+	for (let i = 0; i < nblocks; i++) {
+		const b = i * 16;
+		let k1 = ((bytes[b] ?? 0) | (bytes[b + 1] ?? 0) << 8 | (bytes[b + 2] ?? 0) << 16 | (bytes[b + 3] ?? 0) << 24) >>> 0;
+		let k2 = ((bytes[b + 4] ?? 0) | (bytes[b + 5] ?? 0) << 8 | (bytes[b + 6] ?? 0) << 16 | (bytes[b + 7] ?? 0) << 24) >>> 0;
+		let k3 = ((bytes[b + 8] ?? 0) | (bytes[b + 9] ?? 0) << 8 | (bytes[b + 10] ?? 0) << 16 | (bytes[b + 11] ?? 0) << 24) >>> 0;
+		let k4 = ((bytes[b + 12] ?? 0) | (bytes[b + 13] ?? 0) << 8 | (bytes[b + 14] ?? 0) << 16 | (bytes[b + 15] ?? 0) << 24) >>> 0;
+		k1 = Math.imul(rotl32(Math.imul(k1, K1), 15), K2);
+		h1 ^= k1;
+		h1 = rotl32(h1, 19);
+		h1 = h1 + h2 >>> 0;
+		h1 = Math.imul(h1, 5) + 1444728091 >>> 0;
+		k2 = Math.imul(rotl32(Math.imul(k2, K2), 16), K3);
+		h2 ^= k2;
+		h2 = rotl32(h2, 17);
+		h2 = h2 + h3 >>> 0;
+		h2 = Math.imul(h2, 5) + 197830471 >>> 0;
+		k3 = Math.imul(rotl32(Math.imul(k3, K3), 17), K4);
+		h3 ^= k3;
+		h3 = rotl32(h3, 15);
+		h3 = h3 + h4 >>> 0;
+		h3 = Math.imul(h3, 5) + 2530024501 >>> 0;
+		k4 = Math.imul(rotl32(Math.imul(k4, K4), 18), K1);
+		h4 ^= k4;
+		h4 = rotl32(h4, 13);
+		h4 = h4 + h1 >>> 0;
+		h4 = Math.imul(h4, 5) + 850148119 >>> 0;
+	}
+	let k1 = 0;
+	let k2 = 0;
+	let k3 = 0;
+	let k4 = 0;
+	const tail = nblocks * 16;
+	const rem = len & 15;
+	if (rem >= 15) k4 ^= (bytes[tail + 14] ?? 0) << 16;
+	if (rem >= 14) k4 ^= (bytes[tail + 13] ?? 0) << 8;
+	if (rem >= 13) {
+		k4 ^= bytes[tail + 12] ?? 0;
+		k4 = Math.imul(rotl32(Math.imul(k4, K4), 18), K1);
+		h4 ^= k4;
+	}
+	if (rem >= 12) k3 ^= (bytes[tail + 11] ?? 0) << 24;
+	if (rem >= 11) k3 ^= (bytes[tail + 10] ?? 0) << 16;
+	if (rem >= 10) k3 ^= (bytes[tail + 9] ?? 0) << 8;
+	if (rem >= 9) {
+		k3 ^= bytes[tail + 8] ?? 0;
+		k3 = Math.imul(rotl32(Math.imul(k3, K3), 17), K4);
+		h3 ^= k3;
+	}
+	if (rem >= 8) k2 ^= (bytes[tail + 7] ?? 0) << 24;
+	if (rem >= 7) k2 ^= (bytes[tail + 6] ?? 0) << 16;
+	if (rem >= 6) k2 ^= (bytes[tail + 5] ?? 0) << 8;
+	if (rem >= 5) {
+		k2 ^= bytes[tail + 4] ?? 0;
+		k2 = Math.imul(rotl32(Math.imul(k2, K2), 16), K3);
+		h2 ^= k2;
+	}
+	if (rem >= 4) k1 ^= (bytes[tail + 3] ?? 0) << 24;
+	if (rem >= 3) k1 ^= (bytes[tail + 2] ?? 0) << 16;
+	if (rem >= 2) k1 ^= (bytes[tail + 1] ?? 0) << 8;
+	if (rem >= 1) {
+		k1 ^= bytes[tail] ?? 0;
+		k1 = Math.imul(rotl32(Math.imul(k1, K1), 15), K2);
+		h1 ^= k1;
+	}
+	h1 = (h1 ^ len) >>> 0;
+	h2 = (h2 ^ len) >>> 0;
+	h3 = (h3 ^ len) >>> 0;
+	h4 = (h4 ^ len) >>> 0;
+	h1 = h1 + h2 >>> 0;
+	h1 = h1 + h3 >>> 0;
+	h1 = h1 + h4 >>> 0;
+	h2 = h2 + h1 >>> 0;
+	h3 = h3 + h1 >>> 0;
+	h4 = h4 + h1 >>> 0;
+	h1 = fmix32(h1);
+	h2 = fmix32(h2);
+	h3 = fmix32(h3);
+	h4 = fmix32(h4);
+	h1 = h1 + h2 >>> 0;
+	h1 = h1 + h3 >>> 0;
+	h1 = h1 + h4 >>> 0;
+	h2 = h2 + h1 >>> 0;
+	h3 = h3 + h1 >>> 0;
+	h4 = h4 + h1 >>> 0;
+	LANES.w0 = h1;
+	LANES.w1 = h2;
+	LANES.w2 = h3;
+	LANES.w3 = h4;
+}
+const keyEncoder = new TextEncoder();
+let keyBuf = new Uint8Array(256);
+let encBytes = keyBuf;
+let encLen = 0;
+function encodeKey(key) {
+	if (typeof key === "string") {
+		const cap = key.length * 3;
+		if (keyBuf.length < cap) keyBuf = new Uint8Array(cap);
+		encLen = keyEncoder.encodeInto(key, keyBuf).written;
+		encBytes = keyBuf;
+		return;
+	}
+	encBytes = normalize(key);
+	encLen = encBytes.length;
+}
+function keyToLanes(key, seed) {
+	encodeKey(key);
+	computeLanes(encBytes, seed, encLen);
+}
+function hash128KeyInto(key, seed, out) {
+	keyToLanes(key, seed);
+	out.w0 = LANES.w0;
+	out.w1 = LANES.w1;
+	out.w2 = LANES.w2;
+	out.w3 = LANES.w3;
+}
+function reduce(x, range) {
+	const xlo = x & 65535;
+	const xhi = x >>> 16;
+	const rlo = range & 65535;
+	const rhi = range >>> 16;
+	const lolo = xlo * rlo;
+	const lohi = xlo * rhi;
+	const hilo = xhi * rlo;
+	const hihi = xhi * rhi;
+	const carry = (lolo >>> 16) + (lohi & 65535) + (hilo & 65535);
+	return hihi + (lohi >>> 16) + (hilo >>> 16) + (carry >>> 16) >>> 0;
+}
+function hash32x2Into(key, seed, out) {
+	keyToLanes(key, seed);
+	out[0] = LANES.w0;
+	out[1] = LANES.w1;
+}
+function probeInto(key, count, range, seed, out) {
+	keyToLanes(key, seed);
+	const a = LANES.w0;
+	const b = LANES.w1;
+	for (let i = 0; i < count; i++) {
+		const x = a + Math.imul(i, b) + i * i >>> 0;
+		out[i] = reduce(x, range);
+	}
+}
+//#endregion
+Object.defineProperty(exports, "RHI", {
+	enumerable: true,
+	get: function() {
+		return RHI;
+	}
+});
+Object.defineProperty(exports, "RLO", {
+	enumerable: true,
+	get: function() {
+		return RLO;
+	}
+});
+Object.defineProperty(exports, "fmix64", {
+	enumerable: true,
+	get: function() {
+		return fmix64;
+	}
+});
+Object.defineProperty(exports, "hash128KeyInto", {
+	enumerable: true,
+	get: function() {
+		return hash128KeyInto;
+	}
+});
+Object.defineProperty(exports, "hash32x2Into", {
+	enumerable: true,
+	get: function() {
+		return hash32x2Into;
+	}
+});
+Object.defineProperty(exports, "mul64", {
+	enumerable: true,
+	get: function() {
+		return mul64;
+	}
+});
+Object.defineProperty(exports, "probeInto", {
+	enumerable: true,
+	get: function() {
+		return probeInto;
+	}
+});
+Object.defineProperty(exports, "reduce", {
+	enumerable: true,
+	get: function() {
+		return reduce;
+	}
+});

package/dist/hasher-DVWXS_vJ.js

@@ -0,0 +1,229 @@
+//#region src/core/bytes.ts
+const encoder = new TextEncoder();
+function normalize(input) {
+	if (typeof input === "string") return encoder.encode(input);
+	if (input instanceof Uint8Array) return input;
+	return new Uint8Array(input);
+}
+//#endregion
+//#region src/core/hasher.ts
+let RLO = 0;
+let RHI = 0;
+const LANES = {
+	w0: 0,
+	w1: 0,
+	w2: 0,
+	w3: 0
+};
+function mul64(alo, ahi, blo, bhi) {
+	const a0 = alo & 65535;
+	const a1 = alo >>> 16;
+	const a2 = ahi & 65535;
+	const a3 = ahi >>> 16;
+	const b0 = blo & 65535;
+	const b1 = blo >>> 16;
+	const b2 = bhi & 65535;
+	const b3 = bhi >>> 16;
+	let c0 = a0 * b0;
+	let c1 = c0 >>> 16;
+	c0 &= 65535;
+	c1 += a1 * b0;
+	let c2 = c1 >>> 16;
+	c1 &= 65535;
+	c1 += a0 * b1;
+	c2 += c1 >>> 16;
+	c1 &= 65535;
+	c2 += a2 * b0;
+	let c3 = c2 >>> 16;
+	c2 &= 65535;
+	c2 += a1 * b1;
+	c3 += c2 >>> 16;
+	c2 &= 65535;
+	c2 += a0 * b2;
+	c3 += c2 >>> 16;
+	c2 &= 65535;
+	c3 += a3 * b0 + a2 * b1 + a1 * b2 + a0 * b3;
+	c3 &= 65535;
+	RLO = (c1 << 16 | c0) >>> 0;
+	RHI = (c3 << 16 | c2) >>> 0;
+}
+function fmix64(lo, hi) {
+	let l = lo;
+	let h = hi;
+	l = (l ^ h >>> 1) >>> 0;
+	mul64(l, h, 3981806797, 4283543511);
+	l = RLO;
+	h = RHI;
+	l = (l ^ h >>> 1) >>> 0;
+	mul64(l, h, 444984403, 3301882366);
+	l = RLO;
+	h = RHI;
+	l = (l ^ h >>> 1) >>> 0;
+	RLO = l;
+	RHI = h;
+}
+function rotl32(x, r) {
+	return (x << r | x >>> 32 - r) >>> 0;
+}
+function fmix32(h) {
+	let x = h;
+	x ^= x >>> 16;
+	x = Math.imul(x, 2246822507);
+	x ^= x >>> 13;
+	x = Math.imul(x, 3266489909);
+	x ^= x >>> 16;
+	return x >>> 0;
+}
+const K1 = 597399067;
+const K2 = 2869860233;
+const K3 = 951274213;
+const K4 = 2716044179;
+function computeLanes(bytes, seed, len) {
+	const nblocks = len >>> 4;
+	let h1 = seed >>> 0;
+	let h2 = seed >>> 0;
+	let h3 = seed >>> 0;
+	let h4 = seed >>> 0;
+	for (let i = 0; i < nblocks; i++) {
+		const b = i * 16;
+		let k1 = ((bytes[b] ?? 0) | (bytes[b + 1] ?? 0) << 8 | (bytes[b + 2] ?? 0) << 16 | (bytes[b + 3] ?? 0) << 24) >>> 0;
+		let k2 = ((bytes[b + 4] ?? 0) | (bytes[b + 5] ?? 0) << 8 | (bytes[b + 6] ?? 0) << 16 | (bytes[b + 7] ?? 0) << 24) >>> 0;
+		let k3 = ((bytes[b + 8] ?? 0) | (bytes[b + 9] ?? 0) << 8 | (bytes[b + 10] ?? 0) << 16 | (bytes[b + 11] ?? 0) << 24) >>> 0;
+		let k4 = ((bytes[b + 12] ?? 0) | (bytes[b + 13] ?? 0) << 8 | (bytes[b + 14] ?? 0) << 16 | (bytes[b + 15] ?? 0) << 24) >>> 0;
+		k1 = Math.imul(rotl32(Math.imul(k1, K1), 15), K2);
+		h1 ^= k1;
+		h1 = rotl32(h1, 19);
+		h1 = h1 + h2 >>> 0;
+		h1 = Math.imul(h1, 5) + 1444728091 >>> 0;
+		k2 = Math.imul(rotl32(Math.imul(k2, K2), 16), K3);
+		h2 ^= k2;
+		h2 = rotl32(h2, 17);
+		h2 = h2 + h3 >>> 0;
+		h2 = Math.imul(h2, 5) + 197830471 >>> 0;
+		k3 = Math.imul(rotl32(Math.imul(k3, K3), 17), K4);
+		h3 ^= k3;
+		h3 = rotl32(h3, 15);
+		h3 = h3 + h4 >>> 0;
+		h3 = Math.imul(h3, 5) + 2530024501 >>> 0;
+		k4 = Math.imul(rotl32(Math.imul(k4, K4), 18), K1);
+		h4 ^= k4;
+		h4 = rotl32(h4, 13);
+		h4 = h4 + h1 >>> 0;
+		h4 = Math.imul(h4, 5) + 850148119 >>> 0;
+	}
+	let k1 = 0;
+	let k2 = 0;
+	let k3 = 0;
+	let k4 = 0;
+	const tail = nblocks * 16;
+	const rem = len & 15;
+	if (rem >= 15) k4 ^= (bytes[tail + 14] ?? 0) << 16;
+	if (rem >= 14) k4 ^= (bytes[tail + 13] ?? 0) << 8;
+	if (rem >= 13) {
+		k4 ^= bytes[tail + 12] ?? 0;
+		k4 = Math.imul(rotl32(Math.imul(k4, K4), 18), K1);
+		h4 ^= k4;
+	}
+	if (rem >= 12) k3 ^= (bytes[tail + 11] ?? 0) << 24;
+	if (rem >= 11) k3 ^= (bytes[tail + 10] ?? 0) << 16;
+	if (rem >= 10) k3 ^= (bytes[tail + 9] ?? 0) << 8;
+	if (rem >= 9) {
+		k3 ^= bytes[tail + 8] ?? 0;
+		k3 = Math.imul(rotl32(Math.imul(k3, K3), 17), K4);
+		h3 ^= k3;
+	}
+	if (rem >= 8) k2 ^= (bytes[tail + 7] ?? 0) << 24;
+	if (rem >= 7) k2 ^= (bytes[tail + 6] ?? 0) << 16;
+	if (rem >= 6) k2 ^= (bytes[tail + 5] ?? 0) << 8;
+	if (rem >= 5) {
+		k2 ^= bytes[tail + 4] ?? 0;
+		k2 = Math.imul(rotl32(Math.imul(k2, K2), 16), K3);
+		h2 ^= k2;
+	}
+	if (rem >= 4) k1 ^= (bytes[tail + 3] ?? 0) << 24;
+	if (rem >= 3) k1 ^= (bytes[tail + 2] ?? 0) << 16;
+	if (rem >= 2) k1 ^= (bytes[tail + 1] ?? 0) << 8;
+	if (rem >= 1) {
+		k1 ^= bytes[tail] ?? 0;
+		k1 = Math.imul(rotl32(Math.imul(k1, K1), 15), K2);
+		h1 ^= k1;
+	}
+	h1 = (h1 ^ len) >>> 0;
+	h2 = (h2 ^ len) >>> 0;
+	h3 = (h3 ^ len) >>> 0;
+	h4 = (h4 ^ len) >>> 0;
+	h1 = h1 + h2 >>> 0;
+	h1 = h1 + h3 >>> 0;
+	h1 = h1 + h4 >>> 0;
+	h2 = h2 + h1 >>> 0;
+	h3 = h3 + h1 >>> 0;
+	h4 = h4 + h1 >>> 0;
+	h1 = fmix32(h1);
+	h2 = fmix32(h2);
+	h3 = fmix32(h3);
+	h4 = fmix32(h4);
+	h1 = h1 + h2 >>> 0;
+	h1 = h1 + h3 >>> 0;
+	h1 = h1 + h4 >>> 0;
+	h2 = h2 + h1 >>> 0;
+	h3 = h3 + h1 >>> 0;
+	h4 = h4 + h1 >>> 0;
+	LANES.w0 = h1;
+	LANES.w1 = h2;
+	LANES.w2 = h3;
+	LANES.w3 = h4;
+}
+const keyEncoder = new TextEncoder();
+let keyBuf = new Uint8Array(256);
+let encBytes = keyBuf;
+let encLen = 0;
+function encodeKey(key) {
+	if (typeof key === "string") {
+		const cap = key.length * 3;
+		if (keyBuf.length < cap) keyBuf = new Uint8Array(cap);
+		encLen = keyEncoder.encodeInto(key, keyBuf).written;
+		encBytes = keyBuf;
+		return;
+	}
+	encBytes = normalize(key);
+	encLen = encBytes.length;
+}
+function keyToLanes(key, seed) {
+	encodeKey(key);
+	computeLanes(encBytes, seed, encLen);
+}
+function hash128KeyInto(key, seed, out) {
+	keyToLanes(key, seed);
+	out.w0 = LANES.w0;
+	out.w1 = LANES.w1;
+	out.w2 = LANES.w2;
+	out.w3 = LANES.w3;
+}
+function reduce(x, range) {
+	const xlo = x & 65535;
+	const xhi = x >>> 16;
+	const rlo = range & 65535;
+	const rhi = range >>> 16;
+	const lolo = xlo * rlo;
+	const lohi = xlo * rhi;
+	const hilo = xhi * rlo;
+	const hihi = xhi * rhi;
+	const carry = (lolo >>> 16) + (lohi & 65535) + (hilo & 65535);
+	return hihi + (lohi >>> 16) + (hilo >>> 16) + (carry >>> 16) >>> 0;
+}
+function hash32x2Into(key, seed, out) {
+	keyToLanes(key, seed);
+	out[0] = LANES.w0;
+	out[1] = LANES.w1;
+}
+function probeInto(key, count, range, seed, out) {
+	keyToLanes(key, seed);
+	const a = LANES.w0;
+	const b = LANES.w1;
+	for (let i = 0; i < count; i++) {
+		const x = a + Math.imul(i, b) + i * i >>> 0;
+		out[i] = reduce(x, range);
+	}
+}
+//#endregion
+export { hash32x2Into as a, reduce as c, hash128KeyInto as i, RLO as n, mul64 as o, fmix64 as r, probeInto as s, RHI as t };

package/dist/hll/index.cjs

@@ -1,5 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_serialize = require("../serialize-Ul2LKFJU.cjs");
+const require_hasher = require("../hasher-D8LCBTOM.cjs");
+const require_serialize = require("../serialize-CHikZ4GH.cjs");
 const require_params = require("../params-UTZbJ22c.cjs");
 const require_sizing = require("../sizing-BLzZk2zr.cjs");
 //#region src/hll/estimate.ts
@@ -100,7 +101,7 @@ var Registers = class {
 	}
 };
 const RHO_BITS = 6;
-const RHO_MASK = (1 << RHO_BITS) - 1;
+const RHO_MASK = 63;
 function encodeSparse(index, rho) {
 	return index << RHO_BITS | rho;
 }
@@ -138,7 +139,8 @@ function compact(buf, len) {
 //#region src/hll/hll.ts
 const ERROR_CONSTANT = 1.04;
 const TYPE = 5;
-const PARAMS_SIZE = 6;
+const PARAMS_SIZE = 8;
+const PARAMS_FIELDS_END = 6;
 const DENSE = 0;
 const SPARSE = 1;
 const ENTRY_SIZE = 4;
@@ -181,6 +183,7 @@ var HyperLogLog = class HyperLogLog {
 		if (type !== TYPE) throw new require_serialize.SerializationError(`expected DSTL type ${String(TYPE)}, got ${String(type)}`);
 		if ((flags & 15) !== 0) throw new require_serialize.UnknownHashVariantError(`unsupported hash variant ${String(flags & 15)}`);
 		require_serialize.assertMinBodyLength(body.length, PARAMS_SIZE, "hll");
+		require_serialize.assertParamsPadding(body, PARAMS_FIELDS_END, PARAMS_SIZE, "hll");
 		const dv = new DataView(body.buffer, body.byteOffset, body.byteLength);
 		const p = body[0] ?? 0;
 		const encoding = body[1] ?? 0;
@@ -221,10 +224,10 @@ var HyperLogLog = class HyperLogLog {
 			const entries = compact(sparse, this.#len);
 			this.#len = entries;
 			return require_serialize.writeFrame({
-				version: 4,
+				version: 5,
 				type: TYPE,
 				flags: 0
-			}, PARAMS_SIZE + entries * ENTRY_SIZE, (body, dv) => {
+			}, PARAMS_SIZE, entries * ENTRY_SIZE, (body, dv) => {
 				body[0] = this.#p;
 				body[1] = SPARSE;
 				dv.setUint32(2, this.#seed, true);
@@ -233,10 +236,10 @@ var HyperLogLog = class HyperLogLog {
 		}
 		const payload = this.#registers.bytes;
 		return require_serialize.writeFrame({
-			version: 4,
+			version: 5,
 			type: TYPE,
 			flags: 0
-		}, PARAMS_SIZE + payload.length, (body, dv) => {
+		}, PARAMS_SIZE, payload.length, (body, dv) => {
 			body[0] = this.#p;
 			body[1] = DENSE;
 			dv.setUint32(2, this.#seed, true);
@@ -260,7 +263,7 @@ var HyperLogLog = class HyperLogLog {
 	}
 	add(key) {
 		const s = this.#scratch;
-		require_serialize.hash128KeyInto(key, this.#seed, s);
+		require_hasher.hash128KeyInto(key, this.#seed, s);
 		const p = this.#p;
 		const tail = s.w0 << p >>> 0;
 		const rho = tail !== 0 ? Math.clz32(tail) + 1 : 32 - p + Math.clz32(s.w1) + 1;
@@ -355,6 +358,7 @@ exports.BadMagicError = require_serialize.BadMagicError;
 exports.ChecksumError = require_serialize.ChecksumError;
 exports.HyperLogLog = HyperLogLog;
 exports.ParamError = require_params.ParamError;
+exports.ReservedBitsError = require_serialize.ReservedBitsError;
 exports.SerializationError = require_serialize.SerializationError;
 exports.TruncatedError = require_serialize.TruncatedError;
 exports.UnknownHashVariantError = require_serialize.UnknownHashVariantError;