distillate 0.1.0

package/dist/serialize-E_4WyueA.js

@@ -0,0 +1,271 @@
+//#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
+const C1LO = 289559509;
+const C1HI = 2277735313;
+const C2LO = 658871167;
+const C2HI = 1291169091;
+let RLO = 0;
+let RHI = 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 rotl64(lo, hi, r) {
+	if (r < 32) {
+		RLO = (lo << r | hi >>> 32 - r) >>> 0;
+		RHI = (hi << r | lo >>> 32 - r) >>> 0;
+	} else {
+		const s = r - 32;
+		RLO = (hi << s | lo >>> 32 - s) >>> 0;
+		RHI = (lo << s | hi >>> 32 - s) >>> 0;
+	}
+}
+function add64(alo, ahi, blo, bhi) {
+	const lo = (alo >>> 0) + (blo >>> 0);
+	RHI = ahi + bhi + (lo > 4294967295 ? 1 : 0) >>> 0;
+	RLO = lo >>> 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 hash128(bytes, seed = 0) {
+	const len = bytes.length;
+	const nblocks = len >>> 4;
+	let h1lo = seed >>> 0;
+	let h1hi = 0;
+	let h2lo = seed >>> 0;
+	let h2hi = 0;
+	for (let i = 0; i < nblocks; i++) {
+		const b = i * 16;
+		let k1lo = ((bytes[b] ?? 0) | (bytes[b + 1] ?? 0) << 8 | (bytes[b + 2] ?? 0) << 16 | (bytes[b + 3] ?? 0) << 24) >>> 0;
+		let k1hi = ((bytes[b + 4] ?? 0) | (bytes[b + 5] ?? 0) << 8 | (bytes[b + 6] ?? 0) << 16 | (bytes[b + 7] ?? 0) << 24) >>> 0;
+		let k2lo = ((bytes[b + 8] ?? 0) | (bytes[b + 9] ?? 0) << 8 | (bytes[b + 10] ?? 0) << 16 | (bytes[b + 11] ?? 0) << 24) >>> 0;
+		let k2hi = ((bytes[b + 12] ?? 0) | (bytes[b + 13] ?? 0) << 8 | (bytes[b + 14] ?? 0) << 16 | (bytes[b + 15] ?? 0) << 24) >>> 0;
+		mul64(k1lo, k1hi, C1LO, C1HI);
+		rotl64(RLO, RHI, 31);
+		mul64(RLO, RHI, C2LO, C2HI);
+		k1lo = RLO;
+		k1hi = RHI;
+		h1lo ^= k1lo;
+		h1hi ^= k1hi;
+		rotl64(h1lo, h1hi, 27);
+		add64(RLO, RHI, h2lo, h2hi);
+		mul64(RLO, RHI, 5, 0);
+		add64(RLO, RHI, 1390208809, 0);
+		h1lo = RLO;
+		h1hi = RHI;
+		mul64(k2lo, k2hi, C2LO, C2HI);
+		rotl64(RLO, RHI, 33);
+		mul64(RLO, RHI, C1LO, C1HI);
+		k2lo = RLO;
+		k2hi = RHI;
+		h2lo ^= k2lo;
+		h2hi ^= k2hi;
+		rotl64(h2lo, h2hi, 31);
+		add64(RLO, RHI, h1lo, h1hi);
+		mul64(RLO, RHI, 5, 0);
+		add64(RLO, RHI, 944331445, 0);
+		h2lo = RLO;
+		h2hi = RHI;
+	}
+	let k1lo = 0;
+	let k1hi = 0;
+	let k2lo = 0;
+	let k2hi = 0;
+	const tail = nblocks * 16;
+	const rem = len & 15;
+	if (rem >= 15) k2hi ^= (bytes[tail + 14] ?? 0) << 16;
+	if (rem >= 14) k2hi ^= (bytes[tail + 13] ?? 0) << 8;
+	if (rem >= 13) k2hi ^= bytes[tail + 12] ?? 0;
+	if (rem >= 12) k2lo ^= (bytes[tail + 11] ?? 0) << 24;
+	if (rem >= 11) k2lo ^= (bytes[tail + 10] ?? 0) << 16;
+	if (rem >= 10) k2lo ^= (bytes[tail + 9] ?? 0) << 8;
+	if (rem >= 9) {
+		k2lo ^= bytes[tail + 8] ?? 0;
+		k2lo >>>= 0;
+		k2hi >>>= 0;
+		mul64(k2lo, k2hi, C2LO, C2HI);
+		rotl64(RLO, RHI, 33);
+		mul64(RLO, RHI, C1LO, C1HI);
+		h2lo ^= RLO;
+		h2hi ^= RHI;
+	}
+	if (rem >= 8) k1hi ^= (bytes[tail + 7] ?? 0) << 24;
+	if (rem >= 7) k1hi ^= (bytes[tail + 6] ?? 0) << 16;
+	if (rem >= 6) k1hi ^= (bytes[tail + 5] ?? 0) << 8;
+	if (rem >= 5) k1hi ^= bytes[tail + 4] ?? 0;
+	if (rem >= 4) k1lo ^= (bytes[tail + 3] ?? 0) << 24;
+	if (rem >= 3) k1lo ^= (bytes[tail + 2] ?? 0) << 16;
+	if (rem >= 2) k1lo ^= (bytes[tail + 1] ?? 0) << 8;
+	if (rem >= 1) {
+		k1lo ^= bytes[tail] ?? 0;
+		k1lo >>>= 0;
+		k1hi >>>= 0;
+		mul64(k1lo, k1hi, C1LO, C1HI);
+		rotl64(RLO, RHI, 31);
+		mul64(RLO, RHI, C2LO, C2HI);
+		h1lo ^= RLO;
+		h1hi ^= RHI;
+	}
+	h1lo = (h1lo ^ len) >>> 0;
+	h2lo = (h2lo ^ len) >>> 0;
+	add64(h1lo, h1hi, h2lo, h2hi);
+	h1lo = RLO;
+	h1hi = RHI;
+	add64(h2lo, h2hi, h1lo, h1hi);
+	h2lo = RLO;
+	h2hi = RHI;
+	fmix64(h1lo, h1hi);
+	h1lo = RLO;
+	h1hi = RHI;
+	fmix64(h2lo, h2hi);
+	h2lo = RLO;
+	h2hi = RHI;
+	add64(h1lo, h1hi, h2lo, h2hi);
+	h1lo = RLO;
+	h1hi = RHI;
+	add64(h2lo, h2hi, h1lo, h1hi);
+	h2lo = RLO;
+	h2hi = RHI;
+	return {
+		h1lo: h1lo >>> 0,
+		h1hi: h1hi >>> 0,
+		h2lo: h2lo >>> 0,
+		h2hi: h2hi >>> 0
+	};
+}
+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;
+}
+/**
+* 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) {
+	const { h1lo, h1hi, h2lo, h2hi } = hash128(normalize(key), seed);
+	const a = (h1lo ^ h1hi) >>> 0;
+	const b = (h2lo ^ h2hi) >>> 0;
+	for (let i = 0; i < count; i++) out[i] = reduce(a + Math.imul(i, b) + i * i >>> 0, range);
+}
+//#endregion
+//#region src/core/crc32.ts
+let table;
+function buildTable() {
+	const t = /* @__PURE__ */ new Uint32Array(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;
+	}
+	return t;
+}
+function crc32(bytes) {
+	table ??= buildTable();
+	let crc = 4294967295;
+	for (const byte of bytes) crc = (table[(crc ^ byte) & 255] ?? 0) ^ crc >>> 8;
+	return (crc ^ 4294967295) >>> 0;
+}
+const HEADER_SIZE = 8;
+const TRAILER_SIZE = 4;
+function writeHeader(header, body) {
+	const frame = new Uint8Array(HEADER_SIZE + body.length + 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;
+	frame.set(body, HEADER_SIZE);
+	const crc = crc32(frame.subarray(0, HEADER_SIZE + body.length));
+	new DataView(frame.buffer, frame.byteOffset, frame.byteLength).setUint32(HEADER_SIZE + body.length, 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 ChecksumError = class extends SerializationError {
+	name = "ChecksumError";
+};
+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 !== 1) 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
+export { probeInto as a, hash128 as i, readHeader as n, reduce as o, writeHeader as r, normalize as s, SerializationError as t };

package/package.json

@@ -0,0 +1,114 @@
+{
+  "name": "distillate",
+  "version": "0.1.0",
+  "description": "Probabilistic data structures for JavaScript. Space-efficient, approximate-membership filters (Bloom, Blocked Bloom, Binary Fuse) with tunable error and a portable binary format; zero dependencies, universal.",
+  "keywords": [
+    "bloom-filter",
+    "cuckoo-filter",
+    "binary-fuse",
+    "xor-filter",
+    "amq",
+    "approximate-membership",
+    "probabilistic",
+    "probabilistic-data-structures",
+    "set",
+    "filter"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/akshay-xp/distillate.git"
+  },
+  "homepage": "https://github.com/akshay-xp/distillate#readme",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": {
+        "import": "./dist/index.d.ts",
+        "require": "./dist/index.d.cts"
+      },
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    },
+    "./bloom": {
+      "types": {
+        "import": "./dist/bloom/index.d.ts",
+        "require": "./dist/bloom/index.d.cts"
+      },
+      "import": "./dist/bloom/index.js",
+      "require": "./dist/bloom/index.cjs"
+    },
+    "./blocked": {
+      "types": {
+        "import": "./dist/blocked/index.d.ts",
+        "require": "./dist/blocked/index.d.cts"
+      },
+      "import": "./dist/blocked/index.js",
+      "require": "./dist/blocked/index.cjs"
+    },
+    "./fuse": {
+      "types": {
+        "import": "./dist/fuse/index.d.ts",
+        "require": "./dist/fuse/index.d.cts"
+      },
+      "import": "./dist/fuse/index.js",
+      "require": "./dist/fuse/index.cjs"
+    },
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsdown",
+    "publint": "publint --strict",
+    "check": "publint --strict && attw --pack . --profile node16",
+    "attw": "attw --pack . --profile node16",
+    "test": "vitest run",
+    "changeset": "changeset",
+    "version": "changeset version",
+    "release": "changeset publish",
+    "bench": "tsx bench/core.bench.ts && tsx bench/bloom.bench.ts && tsx bench/blocked.bench.ts && tsx bench/fuse.bench.ts",
+    "typecheck": "tsc --noEmit",
+    "format": "prettier --write .",
+    "format:check": "prettier --check .",
+    "lint": "eslint .",
+    "lint:fix": "eslint . --fix",
+    "prepare": "husky"
+  },
+  "lint-staged": {
+    "*.ts": [
+      "eslint --fix --no-warn-ignored",
+      "prettier --write"
+    ],
+    "*.{js,mjs,cjs,json,md,yml,yaml}": "prettier --write"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.5",
+    "@changesets/cli": "^2.31.1",
+    "@commitlint/cli": "^21.2.1",
+    "@commitlint/config-conventional": "^21.2.0",
+    "@eslint/js": "^10.0.1",
+    "eslint": "^10.8.0",
+    "eslint-config-prettier": "^10.1.8",
+    "fast-check": "^4.9.0",
+    "husky": "^9.1.7",
+    "lint-staged": "^17.2.0",
+    "mitata": "^1.0.34",
+    "prettier": "^3.9.6",
+    "publint": "^0.3.22",
+    "tsdown": "^0.22.14",
+    "tsx": "^4.23.1",
+    "typescript": "^5.9.3",
+    "typescript-eslint": "^8.65.0",
+    "vitest": "^4.1.10"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "packageManager": "pnpm@10.33.0"
+}