distillate 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Akshay
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,105 @@
+# distillate
+
+[![CI](https://github.com/akshay-xp/distillate/actions/workflows/ci.yml/badge.svg)](https://github.com/akshay-xp/distillate/actions/workflows/ci.yml)
+[![npm](https://img.shields.io/npm/v/distillate)](https://www.npmjs.com/package/distillate)
+[![license](https://img.shields.io/npm/l/distillate)](./LICENSE)
+
+Probabilistic data structures for JavaScript: space-efficient, approximate answers with tunable error and zero false negatives. TypeScript-first, zero dependencies, and the right structure per workload. It opens with a family of membership filters (the next-generation successor to Bloom filter packages) and is built to grow into other sketches.
+
+> **Pre-release (0.x).** The published structures are correct, tested, and benchmarked, but the public API may still change before `1.0`, and more structures (Cuckoo, Scalable Bloom) are on the way. Pin a version if you depend on it.
+
+## Why
+
+An approximate-membership query (AMQ) filter answers "is this in the set?" with a tunable false-positive rate and **zero false negatives**, in a fraction of the space of storing the set itself.
+
+- **Runs anywhere**: Node, Bun, Deno, browsers, and Cloudflare/Vercel edge. No `eval`, no required WASM compile.
+- **Correct**: no false negatives (property-tested); false-positive rates validated against theory.
+- **Small**: per-structure subpath imports, `sideEffects: false`, zero runtime dependencies.
+- **Portable**: a versioned little-endian binary format (`toBytes` / `fromBytes`) for persistence and cross-language reads.
+
+## Install
+
+```sh
+npm install distillate
+# or: pnpm add distillate / bun add distillate / deno add npm:distillate
+```
+
+Requires Node 20+ (or any modern Bun/Deno/browser/edge runtime).
+
+## Runtime support
+
+`distillate` targets ES2022 with zero runtime dependencies and no `eval`, so it runs on every modern JavaScript runtime:
+
+- **Node.js** 20, 22, 24 (LTS and current)
+- **Bun** and **Deno**
+- Browsers and Cloudflare/Vercel edge
+
+Every push runs a CI smoke matrix that imports the built package on Node 20/22/24, Bun, and Deno, so cross-runtime support is verified, not assumed.
+
+## Structures
+
+Each structure ships as its own subpath, so you only bundle what you import.
+
+| Import               | Structure     | Mutable? | Use for                                              |
+| -------------------- | ------------- | -------- | ---------------------------------------------------- |
+| `distillate/bloom`   | Classic Bloom | yes      | Familiar default, migration from `bloom-filters`     |
+| `distillate/blocked` | Blocked Bloom | yes      | Streaming inserts, speed-first, cache-friendly       |
+| `distillate/fuse`    | Binary Fuse   | no       | Static set built once and queried a lot; least space |
+
+### Classic Bloom (`distillate/bloom`)
+
+```ts
+import { BloomFilter } from "distillate/bloom";
+
+const filter = BloomFilter.create(100_000, 0.01); // capacity, target FPR
+filter.add("alice");
+filter.has("alice"); // true
+filter.has("bob"); // false (or a ~1% false positive)
+
+const bytes = filter.toBytes();
+const restored = BloomFilter.fromBytes(bytes);
+```
+
+Also: `union(other)` (merge equal-parameter filters), `bitsPerKey`, and a low-level `new BloomFilter({ m, k, seed })`.
+
+### Blocked Bloom (`distillate/blocked`)
+
+```ts
+import { BlockedBloomFilter } from "distillate/blocked";
+
+const filter = BlockedBloomFilter.create(100_000, 0.01);
+filter.add("alice");
+filter.has("alice"); // true
+```
+
+Same surface as Classic Bloom (`add` / `has` / `union` / `toBytes` / `fromBytes` / `bitsPerKey`). Confines every lookup to one cache line, trading ~20-30% more space for cache-friendly throughput.
+
+### Binary Fuse (`distillate/fuse`)
+
+A **static** filter: built once from the full key set, then immutable. The most space-efficient option (~9 bits/key at ~0.39% FPR for 8-bit; ~19 bits/key at ~1/65536 for 16-bit).
+
+```ts
+import { BinaryFuse8, BinaryFuse16 } from "distillate/fuse";
+
+const filter = BinaryFuse8.from(["alice", "bob", "carol"]);
+filter.has("alice"); // true
+filter.size; // 3
+filter.bitsPerKey; // ~9
+
+// Lower false-positive rate, twice the space:
+const precise = BinaryFuse16.from(["alice", "bob", "carol"]);
+```
+
+Also: `toBytes` / `fromBytes`. No `add` / `delete`; rebuild `from` the new set to change membership.
+
+## Docs
+
+Design notes, the structure decision matrix, hashing, and the binary format live in [`docs/`](./docs):
+
+- [overview](./docs/overview.md): what and why
+- [structures](./docs/structures.md): decision matrix and the full lineup
+- [architecture](./docs/architecture.md), [hashing](./docs/hashing.md), [serialization](./docs/serialization.md)
+
+## License
+
+[MIT](./LICENSE) © Akshay

package/dist/blocked/index.cjs

@@ -0,0 +1,116 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_serialize = require("../serialize-C5rwVPvv.cjs");
+//#region src/blocked/blocked.ts
+const TYPE = 2;
+const SALT = Uint32Array.of(1203114875, 1150766481, 2284105051, 2729912477, 1884591559, 770785867, 2667333959, 1550580529);
+/**
+* Split-block probe: derive one block index and 8 single-bit lane masks for
+* `key`. Writes lane word indices into `outWords` and their masks into
+* `outBits` (both length 8, caller-owned so no per-call allocation). A block is
+* 256 bits = 8 contiguous 32-bit lanes; word `block*8 + i` gets one bit set.
+*/
+var BlockedBloomParamMismatchError = class extends Error {
+	name = "BlockedBloomParamMismatchError";
+};
+var BlockedBloomFilter = class BlockedBloomFilter {
+	#lanes;
+	#numBlocks;
+	#seed;
+	#n;
+	#words = /* @__PURE__ */ new Uint32Array(8);
+	#bits = /* @__PURE__ */ new Uint32Array(8);
+	static #ANCHORS = [
+		[2, 10.5],
+		[3, 16.9],
+		[4, 26.4]
+	];
+	static create(n, epsilon) {
+		const t = Math.log10(1 / epsilon);
+		const a = BlockedBloomFilter.#ANCHORS;
+		let seg = a.findIndex((p) => t <= p[0]);
+		if (seg < 1) seg = seg === -1 ? a.length - 1 : 1;
+		const [t0, b0] = a[seg - 1] ?? [0, 0];
+		const [t1, b1] = a[seg] ?? [0, 0];
+		const bitsPerKey = b0 + (b1 - b0) / (t1 - t0) * (t - t0);
+		return new BlockedBloomFilter({
+			bitsPerKey: Math.ceil(bitsPerKey),
+			capacity: n
+		});
+	}
+	constructor({ bitsPerKey, capacity, seed = 0 }) {
+		this.#numBlocks = Math.max(1, Math.ceil(bitsPerKey * capacity / 256));
+		this.#lanes = new Uint32Array(this.#numBlocks * 8);
+		this.#seed = seed;
+		this.#n = capacity;
+	}
+	get bitsPerKey() {
+		return this.#numBlocks * 256 / this.#n;
+	}
+	static fromBytes(bytes) {
+		const { body } = require_serialize.readHeader(bytes);
+		const dv = new DataView(body.buffer, body.byteOffset, body.byteLength);
+		const numBlocks = dv.getUint32(0, true);
+		const seed = dv.getUint32(4, true);
+		const n = dv.getUint32(8, true);
+		const f = new BlockedBloomFilter({
+			bitsPerKey: 256,
+			capacity: numBlocks,
+			seed
+		});
+		f.#n = n;
+		new Uint8Array(f.#lanes.buffer).set(body.subarray(12));
+		return f;
+	}
+	toBytes() {
+		const lanes = new Uint8Array(this.#lanes.buffer, this.#lanes.byteOffset, this.#lanes.byteLength);
+		const body = new Uint8Array(12 + lanes.length);
+		const dv = new DataView(body.buffer);
+		dv.setUint32(0, this.#numBlocks, true);
+		dv.setUint32(4, this.#seed, true);
+		dv.setUint32(8, this.#n, true);
+		body.set(lanes, 12);
+		return require_serialize.writeHeader({
+			version: 1,
+			type: TYPE,
+			flags: 0
+		}, body);
+	}
+	union(other) {
+		if (this.#numBlocks !== other.#numBlocks || this.#seed !== other.#seed) throw new BlockedBloomParamMismatchError("cannot union blocked Bloom filters whose parameters do not match");
+		const r = new BlockedBloomFilter({
+			bitsPerKey: this.bitsPerKey,
+			capacity: this.#n,
+			seed: this.#seed
+		});
+		for (let i = 0; i < this.#lanes.length; i++) r.#lanes[i] = (this.#lanes[i] ?? 0) | (other.#lanes[i] ?? 0);
+		return r;
+	}
+	add(key) {
+		fillBlock(key, this.#numBlocks, this.#seed, this.#words, this.#bits);
+		for (let i = 0; i < 8; i++) {
+			const w = this.#words[i] ?? 0;
+			this.#lanes[w] = (this.#lanes[w] ?? 0) | (this.#bits[i] ?? 0);
+		}
+	}
+	has(key) {
+		fillBlock(key, this.#numBlocks, this.#seed, this.#words, this.#bits);
+		for (let i = 0; i < 8; i++) {
+			const bit = this.#bits[i] ?? 0;
+			if (((this.#lanes[this.#words[i] ?? 0] ?? 0) & bit) >>> 0 !== bit) return false;
+		}
+		return true;
+	}
+};
+function fillBlock(key, numBlocks, seed, outWords, outBits) {
+	const { h1lo, h1hi, h2lo, h2hi } = require_serialize.hash128(require_serialize.normalize(key), seed);
+	const block = require_serialize.reduce((h1lo ^ h1hi) >>> 0, numBlocks);
+	const x = (h2lo ^ h2hi) >>> 0;
+	const base = block * 8;
+	for (let i = 0; i < 8; i++) {
+		outWords[i] = base + i;
+		outBits[i] = 1 << (Math.imul(x, SALT[i] ?? 0) >>> 27) >>> 0;
+	}
+}
+//#endregion
+exports.BlockedBloomFilter = BlockedBloomFilter;
+exports.BlockedBloomParamMismatchError = BlockedBloomParamMismatchError;

package/dist/blocked/index.d.cts

@@ -0,0 +1,29 @@
+import { t as BytesLike } from "../bytes-DCuYtUVS.cjs";
+//#region src/blocked/blocked.d.ts
+/**
+ * Split-block probe: derive one block index and 8 single-bit lane masks for
+ * `key`. Writes lane word indices into `outWords` and their masks into
+ * `outBits` (both length 8, caller-owned so no per-call allocation). A block is
+ * 256 bits = 8 contiguous 32-bit lanes; word `block*8 + i` gets one bit set.
+ */
+declare class BlockedBloomParamMismatchError extends Error {
+  override readonly name = "BlockedBloomParamMismatchError";
+}
+interface BlockedBloomParams {
+  bitsPerKey: number;
+  capacity: number;
+  seed?: number;
+}
+declare class BlockedBloomFilter {
+  #private;
+  static create(n: number, epsilon: number): BlockedBloomFilter;
+  constructor({ bitsPerKey, capacity, seed }: BlockedBloomParams);
+  get bitsPerKey(): number;
+  static fromBytes(bytes: Uint8Array): BlockedBloomFilter;
+  toBytes(): Uint8Array;
+  union(other: BlockedBloomFilter): BlockedBloomFilter;
+  add(key: BytesLike): void;
+  has(key: BytesLike): boolean;
+}
+//#endregion
+export { BlockedBloomFilter, BlockedBloomParamMismatchError, type BlockedBloomParams };

package/dist/blocked/index.d.ts

@@ -0,0 +1,29 @@
+import { t as BytesLike } from "../bytes-DCuYtUVS.js";
+//#region src/blocked/blocked.d.ts
+/**
+ * Split-block probe: derive one block index and 8 single-bit lane masks for
+ * `key`. Writes lane word indices into `outWords` and their masks into
+ * `outBits` (both length 8, caller-owned so no per-call allocation). A block is
+ * 256 bits = 8 contiguous 32-bit lanes; word `block*8 + i` gets one bit set.
+ */
+declare class BlockedBloomParamMismatchError extends Error {
+  override readonly name = "BlockedBloomParamMismatchError";
+}
+interface BlockedBloomParams {
+  bitsPerKey: number;
+  capacity: number;
+  seed?: number;
+}
+declare class BlockedBloomFilter {
+  #private;
+  static create(n: number, epsilon: number): BlockedBloomFilter;
+  constructor({ bitsPerKey, capacity, seed }: BlockedBloomParams);
+  get bitsPerKey(): number;
+  static fromBytes(bytes: Uint8Array): BlockedBloomFilter;
+  toBytes(): Uint8Array;
+  union(other: BlockedBloomFilter): BlockedBloomFilter;
+  add(key: BytesLike): void;
+  has(key: BytesLike): boolean;
+}
+//#endregion
+export { BlockedBloomFilter, BlockedBloomParamMismatchError, type BlockedBloomParams };

package/dist/blocked/index.js

@@ -0,0 +1,114 @@
+import { i as hash128, n as readHeader, o as reduce, r as writeHeader, s as normalize } from "../serialize-E_4WyueA.js";
+//#region src/blocked/blocked.ts
+const TYPE = 2;
+const SALT = Uint32Array.of(1203114875, 1150766481, 2284105051, 2729912477, 1884591559, 770785867, 2667333959, 1550580529);
+/**
+* Split-block probe: derive one block index and 8 single-bit lane masks for
+* `key`. Writes lane word indices into `outWords` and their masks into
+* `outBits` (both length 8, caller-owned so no per-call allocation). A block is
+* 256 bits = 8 contiguous 32-bit lanes; word `block*8 + i` gets one bit set.
+*/
+var BlockedBloomParamMismatchError = class extends Error {
+	name = "BlockedBloomParamMismatchError";
+};
+var BlockedBloomFilter = class BlockedBloomFilter {
+	#lanes;
+	#numBlocks;
+	#seed;
+	#n;
+	#words = /* @__PURE__ */ new Uint32Array(8);
+	#bits = /* @__PURE__ */ new Uint32Array(8);
+	static #ANCHORS = [
+		[2, 10.5],
+		[3, 16.9],
+		[4, 26.4]
+	];
+	static create(n, epsilon) {
+		const t = Math.log10(1 / epsilon);
+		const a = BlockedBloomFilter.#ANCHORS;
+		let seg = a.findIndex((p) => t <= p[0]);
+		if (seg < 1) seg = seg === -1 ? a.length - 1 : 1;
+		const [t0, b0] = a[seg - 1] ?? [0, 0];
+		const [t1, b1] = a[seg] ?? [0, 0];
+		const bitsPerKey = b0 + (b1 - b0) / (t1 - t0) * (t - t0);
+		return new BlockedBloomFilter({
+			bitsPerKey: Math.ceil(bitsPerKey),
+			capacity: n
+		});
+	}
+	constructor({ bitsPerKey, capacity, seed = 0 }) {
+		this.#numBlocks = Math.max(1, Math.ceil(bitsPerKey * capacity / 256));
+		this.#lanes = new Uint32Array(this.#numBlocks * 8);
+		this.#seed = seed;
+		this.#n = capacity;
+	}
+	get bitsPerKey() {
+		return this.#numBlocks * 256 / this.#n;
+	}
+	static fromBytes(bytes) {
+		const { body } = readHeader(bytes);
+		const dv = new DataView(body.buffer, body.byteOffset, body.byteLength);
+		const numBlocks = dv.getUint32(0, true);
+		const seed = dv.getUint32(4, true);
+		const n = dv.getUint32(8, true);
+		const f = new BlockedBloomFilter({
+			bitsPerKey: 256,
+			capacity: numBlocks,
+			seed
+		});
+		f.#n = n;
+		new Uint8Array(f.#lanes.buffer).set(body.subarray(12));
+		return f;
+	}
+	toBytes() {
+		const lanes = new Uint8Array(this.#lanes.buffer, this.#lanes.byteOffset, this.#lanes.byteLength);
+		const body = new Uint8Array(12 + lanes.length);
+		const dv = new DataView(body.buffer);
+		dv.setUint32(0, this.#numBlocks, true);
+		dv.setUint32(4, this.#seed, true);
+		dv.setUint32(8, this.#n, true);
+		body.set(lanes, 12);
+		return writeHeader({
+			version: 1,
+			type: TYPE,
+			flags: 0
+		}, body);
+	}
+	union(other) {
+		if (this.#numBlocks !== other.#numBlocks || this.#seed !== other.#seed) throw new BlockedBloomParamMismatchError("cannot union blocked Bloom filters whose parameters do not match");
+		const r = new BlockedBloomFilter({
+			bitsPerKey: this.bitsPerKey,
+			capacity: this.#n,
+			seed: this.#seed
+		});
+		for (let i = 0; i < this.#lanes.length; i++) r.#lanes[i] = (this.#lanes[i] ?? 0) | (other.#lanes[i] ?? 0);
+		return r;
+	}
+	add(key) {
+		fillBlock(key, this.#numBlocks, this.#seed, this.#words, this.#bits);
+		for (let i = 0; i < 8; i++) {
+			const w = this.#words[i] ?? 0;
+			this.#lanes[w] = (this.#lanes[w] ?? 0) | (this.#bits[i] ?? 0);
+		}
+	}
+	has(key) {
+		fillBlock(key, this.#numBlocks, this.#seed, this.#words, this.#bits);
+		for (let i = 0; i < 8; i++) {
+			const bit = this.#bits[i] ?? 0;
+			if (((this.#lanes[this.#words[i] ?? 0] ?? 0) & bit) >>> 0 !== bit) return false;
+		}
+		return true;
+	}
+};
+function fillBlock(key, numBlocks, seed, outWords, outBits) {
+	const { h1lo, h1hi, h2lo, h2hi } = hash128(normalize(key), seed);
+	const block = reduce((h1lo ^ h1hi) >>> 0, numBlocks);
+	const x = (h2lo ^ h2hi) >>> 0;
+	const base = block * 8;
+	for (let i = 0; i < 8; i++) {
+		outWords[i] = base + i;
+		outBits[i] = 1 << (Math.imul(x, SALT[i] ?? 0) >>> 27) >>> 0;
+	}
+}
+//#endregion
+export { BlockedBloomFilter, BlockedBloomParamMismatchError };

package/dist/bloom/index.cjs

@@ -0,0 +1,132 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_serialize = require("../serialize-C5rwVPvv.cjs");
+//#region src/core/bitset.ts
+var BitSetRangeError = class extends RangeError {
+	name = "BitSetRangeError";
+};
+const MAX_BITS = 2 ** 32;
+var BitSet = class BitSet {
+	#bits;
+	static fromBytes(bytes) {
+		const bs = new BitSet(bytes.length * 8);
+		bs.#bits.set(bytes);
+		return bs;
+	}
+	constructor(nbits) {
+		if (nbits > MAX_BITS) throw new BitSetRangeError(`BitSet capacity ${String(nbits)} exceeds the 2^32-bit limit`);
+		this.#bits = new Uint8Array(Math.ceil(nbits / 8));
+	}
+	set(i) {
+		const idx = i >>> 3;
+		this.#bits[idx] = (this.#bits[idx] ?? 0) | 1 << (i & 7);
+	}
+	get(i) {
+		return ((this.#bits[i >>> 3] ?? 0) & 1 << (i & 7)) !== 0;
+	}
+	get bytes() {
+		return this.#bits;
+	}
+	count() {
+		let total = 0;
+		for (let byte of this.#bits) while (byte) {
+			byte &= byte - 1;
+			total++;
+		}
+		return total;
+	}
+};
+//#endregion
+//#region src/core/sizing.ts
+/** Optimal Bloom-filter sizing: `m` bits and `k` hashes for `n` items at target FPR `epsilon`. */
+function optimal(n, epsilon) {
+	const m = Math.ceil(-n * Math.log(epsilon) / (Math.LN2 * Math.LN2));
+	return {
+		m,
+		k: Math.max(1, Math.round(m / n * Math.LN2))
+	};
+}
+//#endregion
+//#region src/bloom/bloom.ts
+const TYPE = 1;
+var BloomParamMismatchError = class extends Error {
+	name = "BloomParamMismatchError";
+};
+var BloomFilter = class BloomFilter {
+	#bits;
+	#m;
+	#k;
+	#seed;
+	#scratch;
+	#n;
+	static create(n, epsilon) {
+		const f = new BloomFilter(optimal(n, epsilon));
+		f.#n = n;
+		return f;
+	}
+	static fromBytes(bytes) {
+		const { body } = require_serialize.readHeader(bytes);
+		const dv = new DataView(body.buffer, body.byteOffset, body.byteLength);
+		const m = dv.getUint32(0, true);
+		const k = body[4] ?? 0;
+		const seed = dv.getUint32(5, true);
+		const f = new BloomFilter({
+			m,
+			k,
+			seed
+		});
+		f.#bits.bytes.set(body.subarray(9));
+		return f;
+	}
+	constructor({ m, k, seed = 0 }) {
+		this.#bits = new BitSet(m);
+		this.#m = m;
+		this.#k = k;
+		this.#seed = seed;
+		this.#scratch = new Uint32Array(k);
+		this.#n = Math.round(m * Math.LN2 / k);
+	}
+	/** Analytic design bits-per-key `m / n`. */
+	get bitsPerKey() {
+		return this.#m / this.#n;
+	}
+	toBytes() {
+		const payload = this.#bits.bytes;
+		const body = new Uint8Array(9 + payload.length);
+		const dv = new DataView(body.buffer, body.byteOffset, body.byteLength);
+		dv.setUint32(0, this.#m, true);
+		body[4] = this.#k;
+		dv.setUint32(5, this.#seed, true);
+		body.set(payload, 9);
+		return require_serialize.writeHeader({
+			version: 1,
+			type: TYPE,
+			flags: 0
+		}, body);
+	}
+	union(other) {
+		if (this.#m !== other.#m || this.#k !== other.#k || this.#seed !== other.#seed) throw new BloomParamMismatchError("cannot union Bloom filters whose parameters do not match");
+		const a = this.#bits.bytes;
+		const b = other.#bits.bytes;
+		const merged = new Uint8Array(a.length);
+		for (let i = 0; i < a.length; i++) merged[i] = (a[i] ?? 0) | (b[i] ?? 0);
+		const r = new BloomFilter({
+			m: this.#m,
+			k: this.#k,
+			seed: this.#seed
+		});
+		r.#bits.bytes.set(merged);
+		return r;
+	}
+	add(key) {
+		require_serialize.probeInto(key, this.#k, this.#m, this.#seed, this.#scratch);
+		for (let i = 0; i < this.#k; i++) this.#bits.set(this.#scratch[i] ?? 0);
+	}
+	has(key) {
+		require_serialize.probeInto(key, this.#k, this.#m, this.#seed, this.#scratch);
+		for (let i = 0; i < this.#k; i++) if (!this.#bits.get(this.#scratch[i] ?? 0)) return false;
+		return true;
+	}
+};
+//#endregion
+exports.BloomFilter = BloomFilter;
+exports.BloomParamMismatchError = BloomParamMismatchError;

package/dist/bloom/index.d.cts

@@ -0,0 +1,24 @@
+import { t as BytesLike } from "../bytes-DCuYtUVS.cjs";
+//#region src/bloom/bloom.d.ts
+declare class BloomParamMismatchError extends Error {
+  override readonly name = "BloomParamMismatchError";
+}
+interface BloomParams {
+  m: number;
+  k: number;
+  seed?: number;
+}
+declare class BloomFilter {
+  #private;
+  static create(n: number, epsilon: number): BloomFilter;
+  static fromBytes(bytes: Uint8Array): BloomFilter;
+  constructor({ m, k, seed }: BloomParams);
+  /** Analytic design bits-per-key `m / n`. */
+  get bitsPerKey(): number;
+  toBytes(): Uint8Array;
+  union(other: BloomFilter): BloomFilter;
+  add(key: BytesLike): void;
+  has(key: BytesLike): boolean;
+}
+//#endregion
+export { BloomFilter, BloomParamMismatchError, type BloomParams };

package/dist/bloom/index.d.ts

@@ -0,0 +1,24 @@
+import { t as BytesLike } from "../bytes-DCuYtUVS.js";
+//#region src/bloom/bloom.d.ts
+declare class BloomParamMismatchError extends Error {
+  override readonly name = "BloomParamMismatchError";
+}
+interface BloomParams {
+  m: number;
+  k: number;
+  seed?: number;
+}
+declare class BloomFilter {
+  #private;
+  static create(n: number, epsilon: number): BloomFilter;
+  static fromBytes(bytes: Uint8Array): BloomFilter;
+  constructor({ m, k, seed }: BloomParams);
+  /** Analytic design bits-per-key `m / n`. */
+  get bitsPerKey(): number;
+  toBytes(): Uint8Array;
+  union(other: BloomFilter): BloomFilter;
+  add(key: BytesLike): void;
+  has(key: BytesLike): boolean;
+}
+//#endregion
+export { BloomFilter, BloomParamMismatchError, type BloomParams };