distillate 0.13.0 → 0.14.1

package/dist/topk/index.js

@@ -0,0 +1,411 @@
+import { t as normalize } from "../bytes-Be7tq1F7.js";
+import { a as TruncatedError, c as assertBodyLength, 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, u as assertParamsPadding } from "../serialize-CMSYFym-.js";
+import { i as assertProbability, o as assertUint32, r as assertPositiveInt, t as ParamError } from "../params-CeajSrwv.js";
+//#region src/topk/halfsip.ts
+function halfSipHash13(bytes, k0, k1) {
+	let v0 = k0 | 0;
+	let v1 = k1 | 0;
+	let v2 = 1819895653 ^ k0 | 0;
+	let v3 = 1952801890 ^ k1 | 0;
+	const len = bytes.length;
+	const end = len & -4;
+	for (let i = 0; i < end; i += 4) {
+		const m = (bytes[i] ?? 0) | (bytes[i + 1] ?? 0) << 8 | (bytes[i + 2] ?? 0) << 16 | (bytes[i + 3] ?? 0) << 24;
+		v3 ^= m;
+		v0 = v0 + v1 | 0;
+		v1 = v1 << 5 | v1 >>> 27;
+		v1 ^= v0;
+		v0 = v0 << 16 | v0 >>> 16;
+		v2 = v2 + v3 | 0;
+		v3 = v3 << 8 | v3 >>> 24;
+		v3 ^= v2;
+		v0 = v0 + v3 | 0;
+		v3 = v3 << 7 | v3 >>> 25;
+		v3 ^= v0;
+		v2 = v2 + v1 | 0;
+		v1 = v1 << 13 | v1 >>> 19;
+		v1 ^= v2;
+		v2 = v2 << 16 | v2 >>> 16;
+		v0 ^= m;
+	}
+	let b = len << 24;
+	for (let i = len - 1; i >= end; i--) b |= (bytes[i] ?? 0) << 8 * (i - end);
+	v3 ^= b;
+	for (let r = 0; r < 4; r++) {
+		if (r === 1) {
+			v0 ^= b;
+			v2 ^= 255;
+		}
+		v0 = v0 + v1 | 0;
+		v1 = v1 << 5 | v1 >>> 27;
+		v1 ^= v0;
+		v0 = v0 << 16 | v0 >>> 16;
+		v2 = v2 + v3 | 0;
+		v3 = v3 << 8 | v3 >>> 24;
+		v3 ^= v2;
+		v0 = v0 + v3 | 0;
+		v3 = v3 << 7 | v3 >>> 25;
+		v3 ^= v0;
+		v2 = v2 + v1 | 0;
+		v1 = v1 << 13 | v1 >>> 19;
+		v1 ^= v2;
+		v2 = v2 << 16 | v2 >>> 16;
+	}
+	return (v1 ^ v3) >>> 0;
+}
+const TOPK_MAX_CAPACITY = 2 ** 24;
+function topKLoadLimit(capacity) {
+	return Math.floor(.75 * capacity);
+}
+function topKPurgeWidth(capacity) {
+	return topKLoadLimit(capacity) + 2 >> 1;
+}
+function topKSizing(epsilon) {
+	assertProbability(epsilon, "epsilon");
+	for (let capacity = 4; capacity <= TOPK_MAX_CAPACITY; capacity *= 2) if (1 / topKPurgeWidth(capacity) <= epsilon) return { capacity };
+	throw new ParamError(`epsilon ${String(epsilon)} needs more than the maximum capacity ${String(TOPK_MAX_CAPACITY)}`);
+}
+//#endregion
+//#region src/topk/topk.ts
+const TYPE = 9;
+const TABLE_START = 8;
+const PARAMS_SIZE = 32;
+const PARAMS_FIELDS_END = 24;
+function assertCount(value, label) {
+	if (!Number.isSafeInteger(value) || value < 0) throw new SerializationError(`topk: ${label} ${String(value)} is not an integer in [0, ${String(Number.MAX_SAFE_INTEGER)}]`);
+}
+function compareBytes(a, b) {
+	for (let i = 0; i < Math.min(a.length, b.length); i++) {
+		const diff = (a[i] ?? 0) - (b[i] ?? 0);
+		if (diff !== 0) return diff;
+	}
+	return a.length - b.length;
+}
+var TopKOverflowError = class extends RangeError {
+	name = "TopKOverflowError";
+};
+var TopKParamMismatchError = class extends Error {
+	name = "TopKParamMismatchError";
+};
+var TopK = class TopK {
+	#capacity;
+	#loadLimit;
+	#k0 = 0;
+	#k1 = 0;
+	#keyed = false;
+	#size = 0;
+	#counts = new Uint32Array(0);
+	#keyOffsets = new Uint32Array(0);
+	#keyLengths = new Uint32Array(0);
+	#arena;
+	#arenaLen = 0;
+	#entries = 0;
+	#offset = 0;
+	#total = 0;
+	static create(epsilon) {
+		return new TopK(topKSizing(epsilon));
+	}
+	static from(keys, epsilon) {
+		const sketch = TopK.create(epsilon);
+		for (const key of keys) sketch.add(key);
+		return sketch;
+	}
+	static fromBytes(bytes) {
+		const { type, flags, body } = readHeader(bytes);
+		if (type !== TYPE) throw new SerializationError(`expected DSTL type ${String(TYPE)}, got ${String(type)}`);
+		if ((flags & 15) !== 0) throw new UnknownHashVariantError(`unsupported hash variant ${String(flags & 15)}`);
+		assertMinBodyLength(body.length, PARAMS_SIZE, "topk");
+		assertParamsPadding(body, PARAMS_FIELDS_END, PARAMS_SIZE, "topk");
+		const view = new DataView(body.buffer, body.byteOffset, body.byteLength);
+		const capacity = view.getUint32(0, true);
+		const entries = view.getUint32(4, true);
+		if (entries > topKLoadLimit(capacity)) throw new SerializationError(`topk: frame holds ${String(entries)} entries, above the load limit ${String(topKLoadLimit(capacity))} for capacity ${String(capacity)}`);
+		const tableEnd = PARAMS_SIZE + 8 * entries;
+		assertMinBodyLength(body.length, tableEnd, "topk");
+		let keyBytes = 0;
+		for (let i = 0; i < entries; i++) keyBytes += view.getUint32(PARAMS_SIZE + 4 * (entries + i), true);
+		assertBodyLength(body.length, tableEnd + keyBytes, "topk");
+		const offset = view.getFloat64(8, true);
+		const total = view.getFloat64(16, true);
+		assertCount(offset, "offset");
+		assertCount(total, "total");
+		let sketch;
+		try {
+			sketch = new TopK({ capacity });
+			sketch.#allocate(sketch.#fit(entries));
+		} catch (err) {
+			if (err instanceof ParamError) throw new SerializationError(`topk: ${err.message}`);
+			throw err;
+		}
+		let keyAt = tableEnd;
+		let stored = 0;
+		let prevCount = Infinity;
+		let prevKey = new Uint8Array(0);
+		for (let i = 0; i < entries; i++) {
+			const count = view.getUint32(PARAMS_SIZE + 4 * i, true);
+			const len = view.getUint32(PARAMS_SIZE + 4 * (entries + i), true);
+			const key = body.subarray(keyAt, keyAt + len);
+			keyAt += len;
+			if (count === 0) throw new SerializationError(`topk: entry ${String(i)} has count 0`);
+			if (count > prevCount || count === prevCount && compareBytes(prevKey, key) >= 0) throw new SerializationError(`topk: entry ${String(i)} is out of canonical order`);
+			prevCount = count;
+			prevKey = key;
+			const slot = sketch.#slotFor(key);
+			if ((sketch.#counts[slot] ?? 0) !== 0) throw new SerializationError(`topk: entry ${String(i)} repeats a key already held`);
+			sketch.#storeKey(slot, key);
+			sketch.#counts[slot] = count;
+			stored += count;
+		}
+		const width = topKPurgeWidth(capacity);
+		if (stored + width * offset > total) throw new SerializationError(`topk: stored counts ${String(stored)} plus ${String(width)} x offset ${String(offset)} exceed total ${String(total)}`);
+		sketch.#entries = entries;
+		sketch.#offset = offset;
+		sketch.#total = total;
+		return sketch;
+	}
+	constructor({ capacity }) {
+		assertUint32(capacity, "capacity");
+		if (!Number.isInteger(Math.log2(capacity))) throw new ParamError(`capacity must be a power of two, got ${String(capacity)}`);
+		if (capacity < 4 || capacity > TOPK_MAX_CAPACITY) throw new ParamError(`capacity must be in [${String(4)}, ${String(TOPK_MAX_CAPACITY)}], got ${String(capacity)}`);
+		this.#capacity = capacity;
+		this.#loadLimit = topKLoadLimit(capacity);
+		this.#allocate(Math.min(TABLE_START, capacity));
+		this.#arena = new Uint8Array(256);
+	}
+	get capacity() {
+		return this.#capacity;
+	}
+	get epsilon() {
+		return 1 / topKPurgeWidth(this.#capacity);
+	}
+	get total() {
+		return this.#total;
+	}
+	error() {
+		return this.#offset;
+	}
+	#purge() {
+		const keys = [];
+		const counts = [];
+		for (let slot = 0; slot < this.#size; slot++) {
+			const stored = this.#counts[slot] ?? 0;
+			if (stored === 0) continue;
+			keys.push(this.#keyAt(slot).slice());
+			counts.push(stored);
+		}
+		this.#reduceTo(keys, counts);
+	}
+	#reduceTo(keys, counts) {
+		while (keys.length > this.#loadLimit) {
+			const median = [...counts].sort((a, b) => a - b)[counts.length >> 1] ?? 0;
+			let kept = 0;
+			for (let i = 0; i < keys.length; i++) {
+				const survived = (counts[i] ?? 0) - median;
+				if (survived <= 0) continue;
+				keys[kept] = keys[i] ?? new Uint8Array(0);
+				counts[kept] = survived;
+				kept++;
+			}
+			keys.length = kept;
+			counts.length = kept;
+			this.#offset += median;
+		}
+		const size = this.#fit(keys.length);
+		if (size > this.#size) this.#allocate(size);
+		else this.#counts.fill(0);
+		this.#arenaLen = 0;
+		this.#entries = keys.length;
+		for (let i = 0; i < keys.length; i++) {
+			const bytes = keys[i] ?? new Uint8Array(0);
+			const slot = this.#slotFor(bytes);
+			this.#storeKey(slot, bytes);
+			this.#counts[slot] = counts[i] ?? 0;
+		}
+	}
+	#allocate(size) {
+		this.#size = size;
+		this.#counts = new Uint32Array(size);
+		this.#keyOffsets = new Uint32Array(size);
+		this.#keyLengths = new Uint32Array(size);
+	}
+	#resize(size) {
+		const counts = this.#counts;
+		const offsets = this.#keyOffsets;
+		const lengths = this.#keyLengths;
+		this.#allocate(size);
+		for (let old = 0; old < counts.length; old++) {
+			const stored = counts[old] ?? 0;
+			if (stored === 0) continue;
+			const at = offsets[old] ?? 0;
+			const len = lengths[old] ?? 0;
+			const slot = this.#slotFor(this.#arena.subarray(at, at + len));
+			this.#counts[slot] = stored;
+			this.#keyOffsets[slot] = at;
+			this.#keyLengths[slot] = len;
+		}
+	}
+	#fit(entries) {
+		let size = Math.min(TABLE_START, this.#capacity);
+		while (size < this.#capacity && topKLoadLimit(size) < entries) size *= 2;
+		return size;
+	}
+	#slotHolds(slot, bytes) {
+		const len = this.#keyLengths[slot] ?? 0;
+		if (len !== bytes.length) return false;
+		const at = this.#keyOffsets[slot] ?? 0;
+		for (let i = 0; i < len; i++) if (this.#arena[at + i] !== bytes[i]) return false;
+		return true;
+	}
+	#storeKey(slot, bytes) {
+		let arena = this.#arena;
+		if (this.#arenaLen + bytes.length > arena.length) {
+			let size = arena.length;
+			while (size < this.#arenaLen + bytes.length) size *= 2;
+			const grown = new Uint8Array(size);
+			grown.set(arena.subarray(0, this.#arenaLen));
+			arena = grown;
+			this.#arena = grown;
+		}
+		arena.set(bytes, this.#arenaLen);
+		this.#keyOffsets[slot] = this.#arenaLen;
+		this.#keyLengths[slot] = bytes.length;
+		this.#arenaLen += bytes.length;
+	}
+	#slotFor(bytes) {
+		if (!this.#keyed) {
+			const key = crypto.getRandomValues(new Uint32Array(2));
+			this.#k0 = key[0] ?? 0;
+			this.#k1 = key[1] ?? 0;
+			this.#keyed = true;
+		}
+		const mask = this.#size - 1;
+		let slot = halfSipHash13(bytes, this.#k0, this.#k1) & mask;
+		for (;;) {
+			if ((this.#counts[slot] ?? 0) === 0) return slot;
+			if (this.#slotHolds(slot, bytes)) return slot;
+			slot = slot + 1 & mask;
+		}
+	}
+	add(key, count = 1) {
+		assertPositiveInt(count, "count");
+		if (this.#total + count > Number.MAX_SAFE_INTEGER) throw new TopKOverflowError(`adding ${String(count)} would carry the total past ${String(Number.MAX_SAFE_INTEGER)}`);
+		const bytes = normalize(key);
+		const slot = this.#slotFor(bytes);
+		const stored = this.#counts[slot] ?? 0;
+		if (stored + count > 4294967295) throw new TopKOverflowError(`adding ${String(count)} would carry a stored count past ${String(4294967295)}`);
+		if (stored === 0) {
+			this.#storeKey(slot, bytes);
+			this.#entries++;
+		}
+		this.#counts[slot] = stored + count;
+		this.#total += count;
+		if (this.#entries > topKLoadLimit(this.#size)) {
+			if (this.#size < this.#capacity) this.#resize(this.#size * 2);
+			else this.#purge();
+		}
+	}
+	count(key) {
+		const bytes = normalize(key);
+		const stored = this.#counts[this.#slotFor(bytes)] ?? 0;
+		return stored === 0 ? 0 : stored + this.#offset;
+	}
+	top(k) {
+		assertPositiveInt(k, "k");
+		return this.#canonicalSlots().slice(0, k).map((slot) => {
+			const at = this.#keyOffsets[slot] ?? 0;
+			return {
+				key: this.#arena.slice(at, at + (this.#keyLengths[slot] ?? 0)),
+				count: (this.#counts[slot] ?? 0) + this.#offset,
+				lowerBound: this.#counts[slot] ?? 0
+			};
+		});
+	}
+	union(other) {
+		if (this.#capacity !== other.#capacity) throw new TopKParamMismatchError(`cannot union Top-K sketches with capacity ${String(this.#capacity)} and ${String(other.#capacity)}`);
+		if (this.#total + other.#total > Number.MAX_SAFE_INTEGER) throw new TopKOverflowError(`union would carry the total past ${String(Number.MAX_SAFE_INTEGER)}`);
+		const keys = [];
+		const counts = [];
+		const indexOf = new Int32Array(this.#size).fill(-1);
+		for (let slot = 0; slot < this.#size; slot++) {
+			const stored = this.#counts[slot] ?? 0;
+			if (stored === 0) continue;
+			indexOf[slot] = keys.length;
+			keys.push(this.#keyAt(slot).slice());
+			counts.push(stored);
+		}
+		for (let slot = 0; slot < other.#size; slot++) {
+			const stored = other.#counts[slot] ?? 0;
+			if (stored === 0) continue;
+			const key = other.#keyAt(slot);
+			const at = indexOf[this.#slotFor(key)] ?? -1;
+			if (at >= 0) {
+				const sum = (counts[at] ?? 0) + stored;
+				if (sum > 4294967295) throw new TopKOverflowError(`union would carry a stored count to ${String(sum)}, past ${String(4294967295)}`);
+				counts[at] = sum;
+			} else {
+				keys.push(key.slice());
+				counts.push(stored);
+			}
+		}
+		const merged = new TopK({ capacity: this.#capacity });
+		merged.#offset = this.#offset + other.#offset;
+		merged.#total = this.#total + other.#total;
+		merged.#reduceTo(keys, counts);
+		return merged;
+	}
+	toBytes() {
+		const slots = this.#canonicalSlots();
+		const tableEnd = PARAMS_SIZE + 8 * slots.length;
+		return writeFrame({
+			version: 5,
+			type: TYPE,
+			flags: 0
+		}, PARAMS_SIZE, 8 * slots.length + this.#arenaLen, (body, view) => {
+			view.setUint32(0, this.#capacity, true);
+			view.setUint32(4, slots.length, true);
+			view.setFloat64(8, this.#offset, true);
+			view.setFloat64(16, this.#total, true);
+			let keyAt = tableEnd;
+			slots.forEach((slot, i) => {
+				const at = this.#keyOffsets[slot] ?? 0;
+				const len = this.#keyLengths[slot] ?? 0;
+				view.setUint32(PARAMS_SIZE + 4 * i, this.#counts[slot] ?? 0, true);
+				view.setUint32(PARAMS_SIZE + 4 * (slots.length + i), len, true);
+				body.set(this.#arena.subarray(at, at + len), keyAt);
+				keyAt += len;
+			});
+		});
+	}
+	equals(other) {
+		if (this.#capacity !== other.#capacity || this.#offset !== other.#offset || this.#total !== other.#total || this.#entries !== other.#entries) return false;
+		for (let slot = 0; slot < this.#size; slot++) {
+			const stored = this.#counts[slot] ?? 0;
+			if (stored === 0) continue;
+			if (other.#counts[other.#slotFor(this.#keyAt(slot))] !== stored) return false;
+		}
+		return true;
+	}
+	toJSON() {
+		return toJSONEnvelope(this.toBytes());
+	}
+	static fromJSON(value) {
+		return TopK.fromBytes(fromJSONEnvelope(value));
+	}
+	#canonicalSlots() {
+		const slots = [];
+		for (let slot = 0; slot < this.#size; slot++) if ((this.#counts[slot] ?? 0) !== 0) slots.push(slot);
+		return slots.sort((a, b) => {
+			const byCount = (this.#counts[b] ?? 0) - (this.#counts[a] ?? 0);
+			return byCount !== 0 ? byCount : this.#compareKeys(a, b);
+		});
+	}
+	#compareKeys(a, b) {
+		return compareBytes(this.#keyAt(a), this.#keyAt(b));
+	}
+	#keyAt(slot) {
+		const at = this.#keyOffsets[slot] ?? 0;
+		return this.#arena.subarray(at, at + (this.#keyLengths[slot] ?? 0));
+	}
+};
+//#endregion
+export { BadMagicError, ChecksumError, ParamError, ReservedBitsError, SerializationError, TopK, TopKOverflowError, TopKParamMismatchError, TruncatedError, UnknownHashVariantError, UnknownVersionError, topKSizing };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "distillate",
-  "version": "0.13.0",
+  "version": "0.14.1",
   "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",
@@ -95,6 +95,14 @@
       "import": "./dist/countmin/index.js",
       "require": "./dist/countmin/index.cjs"
     },
+    "./topk": {
+      "types": {
+        "import": "./dist/topk/index.d.ts",
+        "require": "./dist/topk/index.d.cts"
+      },
+      "import": "./dist/topk/index.js",
+      "require": "./dist/topk/index.cjs"
+    },
     "./package.json": "./package.json"
   },
   "main": "./dist/index.cjs",
@@ -105,17 +113,17 @@
   ],
   "devDependencies": {
     "@arethetypeswrong/cli": "^0.18.5",
-    "@microsoft/api-extractor": "^7.59.1",
-    "@types/node": "^22.20.3",
-    "@vitest/coverage-v8": "^5.0.1",
-    "fast-check": "^4.10.1",
+    "@microsoft/api-extractor": "^7.59.2",
+    "@types/node": "^22.20.4",
+    "@vitest/coverage-v8": "^5.0.2",
+    "fast-check": "^4.10.2",
     "mitata": "^1.0.34",
     "publint": "^0.3.24",
     "tsdown": "^0.23.0",
-    "tsx": "^4.23.13",
+    "tsx": "^4.23.15",
     "typedoc": "^0.28.20",
     "typescript": "^5.9.3",
-    "vitest": "^5.0.1"
+    "vitest": "^5.0.2"
   },
   "engines": {
     "node": ">=22"

package/dist/sizing-BmKfHf_V.d.cts

@@ -1,34 +0,0 @@
-//#region src/core/sizing.d.ts
-/** Bloom filter geometry: the `BloomParams` fields a sizing solve determines. */
-interface BloomSizing {
-  /** Number of bits in the filter. */
-  m: number;
-  /** Number of hash probes per key. */
-  k: number;
-}
-/** Optimal Bloom-filter sizing: `m` bits and `k` hashes for `n` items at target FPR `epsilon`. */
-declare function bloomSizing(n: number, epsilon: number): BloomSizing;
-/** HyperLogLog geometry: the `HllParams` fields a sizing solve determines. */
-interface HllSizing {
-  /** Precision: the sketch holds `2 ** p` registers. */
-  p: number;
-}
-/**
- * Smallest precision whose standard error `1.04 / sqrt(2 ** p)` meets
- * `relativeError`. Throws {@link ParamError} when even `HLL_MAX_P` cannot.
- */
-declare function hllSizing(relativeError: number): HllSizing;
-/** Count-Min geometry: the `CountMinParams` fields a sizing solve determines. */
-interface CountMinSizing {
-  /** Counters per row. */
-  width: number;
-  /** Number of rows, one probe each. */
-  depth: number;
-}
-/**
- * Count-Min sizing: `width` columns and `depth` rows for an estimate at most
- * `epsilon * total` above the true count, with probability `1 - delta`.
- */
-declare function countMinSizing(epsilon: number, delta: number): CountMinSizing;
-//#endregion
-export { countMinSizing as a, bloomSizing as i, CountMinSizing as n, hllSizing as o, HllSizing as r, BloomSizing as t };

package/dist/sizing-BmKfHf_V.d.ts

@@ -1,34 +0,0 @@
-//#region src/core/sizing.d.ts
-/** Bloom filter geometry: the `BloomParams` fields a sizing solve determines. */
-interface BloomSizing {
-  /** Number of bits in the filter. */
-  m: number;
-  /** Number of hash probes per key. */
-  k: number;
-}
-/** Optimal Bloom-filter sizing: `m` bits and `k` hashes for `n` items at target FPR `epsilon`. */
-declare function bloomSizing(n: number, epsilon: number): BloomSizing;
-/** HyperLogLog geometry: the `HllParams` fields a sizing solve determines. */
-interface HllSizing {
-  /** Precision: the sketch holds `2 ** p` registers. */
-  p: number;
-}
-/**
- * Smallest precision whose standard error `1.04 / sqrt(2 ** p)` meets
- * `relativeError`. Throws {@link ParamError} when even `HLL_MAX_P` cannot.
- */
-declare function hllSizing(relativeError: number): HllSizing;
-/** Count-Min geometry: the `CountMinParams` fields a sizing solve determines. */
-interface CountMinSizing {
-  /** Counters per row. */
-  width: number;
-  /** Number of rows, one probe each. */
-  depth: number;
-}
-/**
- * Count-Min sizing: `width` columns and `depth` rows for an estimate at most
- * `epsilon * total` above the true count, with probability `1 - delta`.
- */
-declare function countMinSizing(epsilon: number, delta: number): CountMinSizing;
-//#endregion
-export { countMinSizing as a, bloomSizing as i, CountMinSizing as n, hllSizing as o, HllSizing as r, BloomSizing as t };

package/dist/sizing-D3-_7pdP.js

@@ -1,25 +0,0 @@
-import { i as assertProbability, t as ParamError } from "./params-CeajSrwv.js";
-//#region src/core/sizing.ts
-function bloomSizing(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))
-	};
-}
-function hllSizing(relativeError) {
-	assertProbability(relativeError, "relativeError");
-	const p = Math.max(4, Math.ceil(2 * Math.log2(1.04 / relativeError)));
-	if (p > 18) throw new ParamError(`relativeError ${String(relativeError)} needs precision ${String(p)}, above the maximum ${String(18)}`);
-	return { p };
-}
-function countMinSizing(epsilon, delta) {
-	assertProbability(epsilon, "epsilon");
-	assertProbability(delta, "delta");
-	return {
-		width: Math.ceil(Math.E / epsilon),
-		depth: Math.ceil(Math.log(1 / delta))
-	};
-}
-//#endregion
-export { countMinSizing as n, hllSizing as r, bloomSizing as t };

package/dist/sizing-R1pwbzjC.cjs

@@ -1,42 +0,0 @@
-const require_params = require("./params-UTZbJ22c.cjs");
-//#region src/core/sizing.ts
-function bloomSizing(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))
-	};
-}
-function hllSizing(relativeError) {
-	require_params.assertProbability(relativeError, "relativeError");
-	const p = Math.max(4, Math.ceil(2 * Math.log2(1.04 / relativeError)));
-	if (p > 18) throw new require_params.ParamError(`relativeError ${String(relativeError)} needs precision ${String(p)}, above the maximum ${String(18)}`);
-	return { p };
-}
-function countMinSizing(epsilon, delta) {
-	require_params.assertProbability(epsilon, "epsilon");
-	require_params.assertProbability(delta, "delta");
-	return {
-		width: Math.ceil(Math.E / epsilon),
-		depth: Math.ceil(Math.log(1 / delta))
-	};
-}
-//#endregion
-Object.defineProperty(exports, "bloomSizing", {
-	enumerable: true,
-	get: function() {
-		return bloomSizing;
-	}
-});
-Object.defineProperty(exports, "countMinSizing", {
-	enumerable: true,
-	get: function() {
-		return countMinSizing;
-	}
-});
-Object.defineProperty(exports, "hllSizing", {
-	enumerable: true,
-	get: function() {
-		return hllSizing;
-	}
-});