distillate 0.4.0 → 0.6.0

package/dist/serialize-BIIKUHH6.cjs

@@ -0,0 +1,515 @@
+//#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 = /* @__PURE__ */ 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;
+}
+/**
+* Derive `count` bucket indices in `[0, range)` from a key using
+* Kirsch-Mitzenmacher enhanced double hashing `g_i = h1 + i*h2 + i^2`
+* (the RocksDB `+i^2` fix), reduced into range with Lemire multiply-shift.
+*/
+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++) out[i] = reduce(a + Math.imul(i, b) + i * i >>> 0, range);
+}
+//#endregion
+//#region src/core/base64.ts
+const ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const DECODE = (/* @__PURE__ */ new Int16Array(128)).fill(-1);
+for (let i = 0; i < 64; i++) DECODE[ALPHABET.charCodeAt(i)] = i;
+const sym = (n) => ALPHABET.charAt(n & 63);
+function toBase64(bytes) {
+	let out = "";
+	let i = 0;
+	for (; i + 3 <= bytes.length; i += 3) {
+		const n = (bytes[i] ?? 0) << 16 | (bytes[i + 1] ?? 0) << 8 | (bytes[i + 2] ?? 0);
+		out += sym(n >>> 18) + sym(n >>> 12) + sym(n >>> 6) + sym(n);
+	}
+	const rem = bytes.length - i;
+	if (rem === 1) {
+		const n = (bytes[i] ?? 0) << 16;
+		out += sym(n >>> 18) + sym(n >>> 12) + "==";
+	} else if (rem === 2) {
+		const n = (bytes[i] ?? 0) << 16 | (bytes[i + 1] ?? 0) << 8;
+		out += sym(n >>> 18) + sym(n >>> 12) + sym(n >>> 6) + "=";
+	}
+	return out;
+}
+function fromBase64(s) {
+	let len = s.length;
+	while (len > 0 && s.charCodeAt(len - 1) === 61) len--;
+	if (len % 4 === 1) throw new RangeError(`invalid base64 length ${String(len)}`);
+	const out = new Uint8Array(len * 3 >> 2);
+	let acc = 0;
+	let bits = 0;
+	let o = 0;
+	for (let i = 0; i < len; i++) {
+		const v = DECODE[s.charCodeAt(i)] ?? -1;
+		if (v < 0) throw new RangeError(`invalid base64 character at index ${String(i)}`);
+		acc = acc << 6 | v;
+		bits += 6;
+		if (bits >= 8) {
+			bits -= 8;
+			out[o++] = acc >>> bits & 255;
+		}
+	}
+	return out;
+}
+//#endregion
+//#region src/core/crc32.ts
+const T1 = 256;
+const T2 = 512;
+const T3 = 768;
+const T4 = 1024;
+const T5 = 1280;
+const T6 = 1536;
+const T7 = 1792;
+const at = (a, i) => a[i] ?? 0;
+let tables;
+function buildTables() {
+	const t = new Uint32Array(8 * 256);
+	for (let n = 0; n < 256; n++) {
+		let c = n;
+		for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+		t[n] = c >>> 0;
+	}
+	for (let k = 1; k < 8; k++) for (let n = 0; n < 256; n++) {
+		const p = at(t, (k - 1) * 256 + n);
+		t[k * 256 + n] = (at(t, p & 255) ^ p >>> 8) >>> 0;
+	}
+	return t;
+}
+function crc32(bytes) {
+	const t = tables ??= buildTables();
+	const len = bytes.length;
+	const dv = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+	let crc = 4294967295;
+	let i = 0;
+	const last = len - 8;
+	while (i <= last) {
+		const one = (dv.getUint32(i, true) ^ crc) >>> 0;
+		const two = dv.getUint32(i + 4, true);
+		crc = (at(t, T7 + (one & 255)) ^ at(t, T6 + (one >>> 8 & 255)) ^ at(t, T5 + (one >>> 16 & 255)) ^ at(t, T4 + (one >>> 24 & 255)) ^ at(t, T3 + (two & 255)) ^ at(t, T2 + (two >>> 8 & 255)) ^ at(t, T1 + (two >>> 16 & 255)) ^ at(t, two >>> 24 & 255)) >>> 0;
+		i += 8;
+	}
+	for (; i < len; i++) crc = (at(t, (crc ^ dv.getUint8(i)) & 255) ^ crc >>> 8) >>> 0;
+	return (crc ^ 4294967295) >>> 0;
+}
+const HEADER_SIZE = 8;
+const TRAILER_SIZE = 4;
+/**
+* Allocates a full frame once, hands `fill` a writable view over the body region
+* (and a `DataView` scoped to it), then seals the CRC trailer. The body view
+* aliases the frame's buffer, so callers write fields and payload straight into
+* the frame with no intermediate body allocation or copy.
+*/
+function writeFrame(header, bodyLength, fill) {
+	const frame = new Uint8Array(HEADER_SIZE + bodyLength + TRAILER_SIZE);
+	frame[0] = 65;
+	frame[1] = 77;
+	frame[2] = 81;
+	frame[3] = 70;
+	frame[4] = header.version;
+	frame[5] = header.type;
+	frame[6] = header.flags;
+	frame[7] = 0;
+	fill(frame.subarray(HEADER_SIZE, HEADER_SIZE + bodyLength), new DataView(frame.buffer, HEADER_SIZE, bodyLength));
+	const crc = crc32(frame.subarray(0, HEADER_SIZE + bodyLength));
+	new DataView(frame.buffer, frame.byteOffset, frame.byteLength).setUint32(HEADER_SIZE + bodyLength, crc, true);
+	return frame;
+}
+var SerializationError = class extends Error {
+	name = "SerializationError";
+};
+var TruncatedError = class extends SerializationError {
+	name = "TruncatedError";
+};
+var BadMagicError = class extends SerializationError {
+	name = "BadMagicError";
+};
+var UnknownVersionError = class extends SerializationError {
+	name = "UnknownVersionError";
+};
+var UnknownHashVariantError = class extends SerializationError {
+	name = "UnknownHashVariantError";
+};
+var ChecksumError = class extends SerializationError {
+	name = "ChecksumError";
+};
+const JSON_TAG = "distillate";
+/** Wraps a serialized frame in the JSON envelope. */
+function toJSONEnvelope(bytes) {
+	return {
+		$: JSON_TAG,
+		v: 3,
+		data: toBase64(bytes)
+	};
+}
+/**
+* Validates a JSON envelope and returns the raw frame bytes for a structure's
+* own `fromBytes` to decode. Throws {@link SerializationError} on any envelope
+* defect; the frame itself is checked downstream.
+*/
+function fromJSONEnvelope(value) {
+	if (value === null || typeof value !== "object") throw new SerializationError("not a distillate filter JSON object");
+	const o = value;
+	if (o.$ !== JSON_TAG) throw new SerializationError(`expected "$":"${JSON_TAG}"`);
+	if (o.v !== 3) throw new UnknownVersionError(`unsupported JSON version ${String(o.v)}, expected ${String(3)}`);
+	if (typeof o.data !== "string") throw new SerializationError("missing string \"data\"");
+	try {
+		return fromBase64(o.data);
+	} catch {
+		throw new SerializationError("envelope data is not valid base64");
+	}
+}
+/** Byte-wise equality of two frames; the basis for structure `equals`. */
+function bytesEqual(a, b) {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
+/**
+* Asserts a frame body is long enough to hold its fixed params block, so the
+* params can be read without running off the end.
+*/
+function assertMinBodyLength(actual, min, context) {
+	if (actual < min) throw new TruncatedError(`${context}: body of ${String(actual)} bytes is shorter than the ${String(min)}-byte params block`);
+}
+/**
+* Asserts a frame body is exactly the length its declared params imply, so a
+* hostile or truncated frame is rejected before any backing store is allocated.
+*/
+function assertBodyLength(actual, expected, context) {
+	if (actual !== expected) throw new TruncatedError(`${context}: body of ${String(actual)} bytes does not match the declared params (expected ${String(expected)})`);
+}
+function readHeader(frame) {
+	if (frame.length < 12) throw new TruncatedError(`frame of ${String(frame.length)} bytes is shorter than the minimum ${String(12)}`);
+	if (frame[0] !== 65 || frame[1] !== 77 || frame[2] !== 81 || frame[3] !== 70) throw new BadMagicError("frame does not start with the AMQF magic");
+	const version = frame[4] ?? 0;
+	if (version !== 3) throw new UnknownVersionError(`unsupported format version ${String(version)}`);
+	if (new DataView(frame.buffer, frame.byteOffset, frame.byteLength).getUint32(frame.length - TRAILER_SIZE, true) !== crc32(frame.subarray(0, frame.length - TRAILER_SIZE))) throw new ChecksumError("frame CRC32 does not match its contents");
+	return {
+		version,
+		type: frame[5] ?? 0,
+		flags: frame[6] ?? 0,
+		body: frame.subarray(HEADER_SIZE, frame.length - TRAILER_SIZE)
+	};
+}
+//#endregion
+Object.defineProperty(exports, "RHI", {
+	enumerable: true,
+	get: function() {
+		return RHI;
+	}
+});
+Object.defineProperty(exports, "RLO", {
+	enumerable: true,
+	get: function() {
+		return RLO;
+	}
+});
+Object.defineProperty(exports, "SerializationError", {
+	enumerable: true,
+	get: function() {
+		return SerializationError;
+	}
+});
+Object.defineProperty(exports, "UnknownHashVariantError", {
+	enumerable: true,
+	get: function() {
+		return UnknownHashVariantError;
+	}
+});
+Object.defineProperty(exports, "assertBodyLength", {
+	enumerable: true,
+	get: function() {
+		return assertBodyLength;
+	}
+});
+Object.defineProperty(exports, "assertMinBodyLength", {
+	enumerable: true,
+	get: function() {
+		return assertMinBodyLength;
+	}
+});
+Object.defineProperty(exports, "bytesEqual", {
+	enumerable: true,
+	get: function() {
+		return bytesEqual;
+	}
+});
+Object.defineProperty(exports, "fmix64", {
+	enumerable: true,
+	get: function() {
+		return fmix64;
+	}
+});
+Object.defineProperty(exports, "fromJSONEnvelope", {
+	enumerable: true,
+	get: function() {
+		return fromJSONEnvelope;
+	}
+});
+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, "readHeader", {
+	enumerable: true,
+	get: function() {
+		return readHeader;
+	}
+});
+Object.defineProperty(exports, "reduce", {
+	enumerable: true,
+	get: function() {
+		return reduce;
+	}
+});
+Object.defineProperty(exports, "toJSONEnvelope", {
+	enumerable: true,
+	get: function() {
+		return toJSONEnvelope;
+	}
+});
+Object.defineProperty(exports, "writeFrame", {
+	enumerable: true,
+	get: function() {
+		return writeFrame;
+	}
+});