@qntx/nostr 0.12.1 → 0.14.0

package/dist/memory-index-3GSrPIWj.mjs

@@ -0,0 +1,671 @@
+import { S as parseEventAddress, _ as eventAddress, f as sortEvents, o as itemCompare, t as compareEventsDesc, y as formatEventAddress } from "./event-DvM1f03b.mjs";
+import { i as filterTagConditions, o as matchFilter } from "./filter-3jOh4uLN.mjs";
+import { i as trimOldest } from "./collections-DtwMc1NU.mjs";
+import { i as DeletionState, n as decidePut, r as outboxBoundKey, t as applyPutMemory } from "./put-BEM5j8xK.mjs";
+//#region src/storage/sorted-events.ts
+/**
+* Chunk bounds: a chunk splice moves at most `CHUNK_MAX` element refs and a chunk merge at
+* `CHUNK_MIN` keeps chunk count proportional to `size` under removals.
+*/
+const CHUNK_MAX = 1024;
+const CHUNK_MIN = 128;
+/** Reverse of `compareEventsDesc`: `created_at` asc, `id` desc — the physical chunk order. */
+function compareAsc(a, b) {
+	if (a.created_at !== b.created_at) return a.created_at - b.created_at;
+	if (a.id < b.id) return 1;
+	if (a.id > b.id) return -1;
+	return 0;
+}
+function mid(lo, hi) {
+	return lo + Math.floor((hi - lo) / 2);
+}
+/** A read cursor over a `SortedEvents` range in canonical order; `value` is the current event. */
+var EventCursor = class {
+	#chunks;
+	#chunk;
+	#index;
+	#endChunk;
+	#endIndex;
+	constructor(chunks, chunk, index, endChunk, endIndex) {
+		this.#chunks = chunks;
+		this.#chunk = chunk;
+		this.#index = index;
+		this.#endChunk = endChunk;
+		this.#endIndex = endIndex;
+	}
+	get value() {
+		const chunk = this.#chunk;
+		const index = this.#index;
+		if (chunk < this.#endChunk || chunk === this.#endChunk && index <= this.#endIndex) return;
+		return this.#chunks[chunk]?.[index];
+	}
+	next() {
+		this.#index -= 1;
+		if (this.#index < 0) {
+			this.#chunk -= 1;
+			this.#index = (this.#chunks[this.#chunk]?.length ?? 1) - 1;
+		}
+	}
+};
+/**
+* Event refs sorted in canonical order (`compareEventsDesc`: `created_at` desc, `id` asc) stored as
+* chunks of ≤ `CHUNK_MAX` elements in ascending physical order so insertion and removal
+* binary-search a chunk and then move a bounded number of refs — appending newer events (live
+* ingest, ascending fills) pushes at the end, and appending older ones (relay backfill) moves at
+* most one chunk's worth of refs. Internal to the memory index; not exported.
+*/
+var SortedEvents = class {
+	#chunks = [];
+	#size = 0;
+	get size() {
+		return this.#size;
+	}
+	clear() {
+		this.#chunks = [];
+		this.#size = 0;
+	}
+	/** Index of the chunk `event` belongs to: the last one whose first element is not newer. */
+	#chunkOf(event) {
+		const chunks = this.#chunks;
+		let lo = 0;
+		let hi = chunks.length;
+		while (lo < hi) {
+			const m = mid(lo, hi);
+			const first = chunks[m]?.[0];
+			if (first !== void 0 && compareAsc(first, event) <= 0) lo = m + 1;
+			else hi = m;
+		}
+		return lo - 1;
+	}
+	insert(event) {
+		const chunks = this.#chunks;
+		if (chunks.length === 0) {
+			chunks.push([event]);
+			this.#size = 1;
+			return;
+		}
+		const chunkIndex = Math.max(this.#chunkOf(event), 0);
+		const chunk = chunks[chunkIndex];
+		if (chunk === void 0) return;
+		let a = 0;
+		let b = chunk.length;
+		while (a < b) {
+			const m = mid(a, b);
+			const element = chunk[m];
+			if (element !== void 0 && compareAsc(element, event) <= 0) a = m + 1;
+			else b = m;
+		}
+		chunk.splice(a, 0, event);
+		this.#size += 1;
+		if (chunk.length > CHUNK_MAX) {
+			const half = chunk.splice(Math.floor(CHUNK_MAX / 2));
+			chunks.splice(chunkIndex + 1, 0, half);
+		}
+	}
+	remove(event) {
+		const chunks = this.#chunks;
+		const chunkIndex = this.#chunkOf(event);
+		if (chunkIndex < 0) return false;
+		const chunk = chunks[chunkIndex];
+		if (chunk === void 0) return false;
+		let a = 0;
+		let b = chunk.length;
+		while (a < b) {
+			const m = mid(a, b);
+			const element = chunk[m];
+			if (element !== void 0 && compareAsc(element, event) < 0) a = m + 1;
+			else b = m;
+		}
+		const found = chunk[a];
+		if (found === void 0 || compareAsc(found, event) !== 0) return false;
+		chunk.splice(a, 1);
+		this.#size -= 1;
+		if (chunk.length === 0) chunks.splice(chunkIndex, 1);
+		else if (chunk.length < CHUNK_MIN) {
+			const next = chunks[chunkIndex + 1];
+			const prev = chunks[chunkIndex - 1];
+			if (next !== void 0 && chunk.length + next.length <= CHUNK_MAX) {
+				chunk.push(...next);
+				chunks.splice(chunkIndex + 1, 1);
+			} else if (prev !== void 0 && prev.length + chunk.length <= CHUNK_MAX) {
+				prev.push(...chunk);
+				chunks.splice(chunkIndex, 1);
+			}
+		}
+		return true;
+	}
+	/**
+	* Cursor over the [since, until] `created_at` window in canonical (desc) order: iteration starts
+	* at the newest element with `created_at <= until` and stops before the first with `created_at <
+	* since`. Chunks and their elements are stored ascending; the cursor walks back.
+	*/
+	cursor(since, until) {
+		const chunks = this.#chunks;
+		let chunk = chunks.length - 1;
+		let index = -1;
+		if (until === void 0) index = (chunks[chunk]?.length ?? 1) - 1;
+		else {
+			let lo = 0;
+			let hi = chunks.length;
+			while (lo < hi) {
+				const m = mid(lo, hi);
+				const first = chunks[m]?.[0];
+				if (first !== void 0 && first.created_at <= until) lo = m + 1;
+				else hi = m;
+			}
+			chunk = lo - 1;
+			if (chunk >= 0) {
+				const bucket = chunks[chunk];
+				let a = 0;
+				let b = bucket?.length ?? 0;
+				while (a < b) {
+					const m = mid(a, b);
+					const element = bucket?.[m];
+					if (element !== void 0 && element.created_at <= until) a = m + 1;
+					else b = m;
+				}
+				index = a - 1;
+			}
+		}
+		let endChunk = -1;
+		let endIndex = -1;
+		if (since !== void 0) {
+			let lo = 0;
+			let hi = chunks.length;
+			while (lo < hi) {
+				const m = mid(lo, hi);
+				const last = chunks[m]?.at(-1);
+				if (last !== void 0 && last.created_at >= since) hi = m;
+				else lo = m + 1;
+			}
+			if (lo === chunks.length) endChunk = Number.MAX_SAFE_INTEGER;
+			else {
+				const bucket = chunks[lo];
+				let a = 0;
+				let b = bucket?.length ?? 0;
+				while (a < b) {
+					const m = mid(a, b);
+					const element = bucket?.[m];
+					if (element !== void 0 && element.created_at >= since) b = m;
+					else a = m + 1;
+				}
+				if (a === 0) {
+					endChunk = lo - 1;
+					endIndex = (chunks[endChunk]?.length ?? 1) - 1;
+				} else {
+					endChunk = lo;
+					endIndex = a - 1;
+				}
+			}
+		}
+		return new EventCursor(chunks, chunk, index, endChunk, endIndex);
+	}
+};
+//#endregion
+//#region src/storage/memory-index.ts
+/**
+* NIP-01 only defines single-letter tag conditions; `#e`/`#p` hold hex ids (filter side
+* lowercased).
+*/
+const SINGLE_ASCII_LETTER = /^[a-zA-Z]$/;
+/**
+* Synchronous in-memory event index with NIP-01 replaceable / addressable / ephemeral handling and
+* NIP-09 deletion (kind 5) application. Shared by {@link MemoryEventStore} (async facade) and
+* `ReactiveEventStore`.
+*/
+var MemoryIndex = class {
+	#byId = /* @__PURE__ */ new Map();
+	#all = new SortedEvents();
+	#byPubkey = /* @__PURE__ */ new Map();
+	#byKind = /* @__PURE__ */ new Map();
+	#byKindPubkey = /* @__PURE__ */ new Map();
+	#byTag = /* @__PURE__ */ new Map();
+	#replaceable = /* @__PURE__ */ new Map();
+	#watermarks = /* @__PURE__ */ new Map();
+	#watermarkIds = /* @__PURE__ */ new Map();
+	#deletion = new DeletionState();
+	#outboxBounds = /* @__PURE__ */ new Map();
+	#maxTombstones;
+	#maxWatermarks;
+	#onInsert;
+	#onRemove;
+	constructor(opts) {
+		this.#maxTombstones = opts?.maxTombstones;
+		this.#maxWatermarks = opts?.maxWatermarks ?? 0;
+		this.#onInsert = opts?.onInsert;
+		this.#onRemove = opts?.onRemove;
+	}
+	put(raw) {
+		const lookup = {
+			deletion: this.#deletion,
+			getById: (id) => this.#byId.get(id),
+			getReplaceable: (addr) => {
+				const id = this.#replaceable.get(addr);
+				const ev = id === void 0 ? void 0 : this.#byId.get(id);
+				if (ev) return {
+					id: ev.id,
+					created_at: ev.created_at
+				};
+				const watermark = this.#watermarks.get(addr);
+				return watermark === void 0 ? void 0 : {
+					...watermark,
+					evicted: true
+				};
+			}
+		};
+		const decision = decidePut(raw, lookup);
+		if (decision.action === "delete") {
+			for (const p of decision.plan.pendingIds) this.#dropWatermarkId(p.id);
+			for (const c of decision.plan.coordinates) this.#dropWatermark(c.key);
+		}
+		const result = applyPutMemory({
+			deletion: this.#deletion,
+			indexInsert: (e) => this.#indexInsert(e),
+			indexRemove: (id) => this.#indexRemove(id)
+		}, decision);
+		this.#trimTombstones();
+		return result;
+	}
+	/** Sequential `put` in input order. */
+	putMany(events) {
+		const results = [];
+		for (const event of events) results.push(this.put(event));
+		return results;
+	}
+	get(id) {
+		const key = id.toLowerCase();
+		if (this.#deletion.ids.has(key)) return;
+		return this.#byId.get(key);
+	}
+	/** Current event at a `kind:pubkey:d` coordinate (replaceable or addressable). */
+	getByAddress(address) {
+		const coord = parseEventAddress(address);
+		if (!coord) return;
+		const id = this.#replaceable.get(formatEventAddress(coord.kind, coord.pubkey, coord.identifier));
+		if (id === void 0) return;
+		if (this.#deletion.ids.has(id)) return;
+		return this.#byId.get(id);
+	}
+	query(filters) {
+		const seen = /* @__PURE__ */ new Set();
+		const events = [];
+		for (const filter of filters) for (const event of this.#matchedEvents(filter)) {
+			if (seen.has(event.id)) continue;
+			seen.add(event.id);
+			events.push(event);
+		}
+		sortEvents(events);
+		return events;
+	}
+	count(filters) {
+		const seen = /* @__PURE__ */ new Set();
+		for (const filter of filters) for (const event of this.#matchedEvents(filter)) seen.add(event.id);
+		return seen.size;
+	}
+	negentropyItems(filter) {
+		if (filter.limit === 0) return [];
+		const items = [];
+		const { limit } = filter;
+		if (filter.ids) {
+			const seen = /* @__PURE__ */ new Set();
+			for (const raw of filter.ids) {
+				const event = this.#byId.get(raw.toLowerCase());
+				if (!event || seen.has(event.id)) continue;
+				seen.add(event.id);
+				if (this.#deletion.covers(event) || !matchFilter(filter, event)) continue;
+				items.push({
+					id: event.id,
+					created_at: event.created_at
+				});
+			}
+		} else {
+			const cursor = this.#candidates(filter);
+			while (cursor.value !== void 0) {
+				const event = cursor.value;
+				cursor.next();
+				if (this.#deletion.covers(event) || !matchFilter(filter, event)) continue;
+				items.push({
+					id: event.id,
+					created_at: event.created_at
+				});
+				if (limit !== void 0 && items.length >= limit) break;
+			}
+		}
+		if (filter.limit !== void 0) {
+			if (filter.ids) items.sort(compareEventsDesc);
+			if (items.length > filter.limit) items.length = filter.limit;
+		}
+		items.sort(itemCompare);
+		return items;
+	}
+	/** Remove by id and tombstone (like a local NIP-09). Returns removed count. */
+	remove(ids) {
+		let n = 0;
+		for (const raw of ids) {
+			const id = raw.toLowerCase();
+			if (this.#indexRemove(id)) n += 1;
+			this.#deletion.ids.add(id);
+			this.#deletion.pending.delete(id);
+		}
+		this.#trimTombstones();
+		return n;
+	}
+	/**
+	* Remove by id without writing a tombstone (LRU eviction). When the evicted event is the current
+	* winner of a replaceable/addressable address, a `{ id, created_at }` watermark is recorded so
+	* stale versions stay rejected while the body is gone; the watermarks are FIFO-bounded by
+	* `maxWatermarks`.
+	*/
+	evict(ids) {
+		let n = 0;
+		for (const raw of ids) {
+			const id = raw.toLowerCase();
+			const event = this.#byId.get(id);
+			if (event === void 0) continue;
+			const addr = eventAddress(event);
+			const winner = addr !== void 0 && this.#replaceable.get(addr) === id;
+			if (this.#indexRemove(id)) n += 1;
+			if (winner) this.#setWatermark(addr, {
+				id,
+				created_at: event.created_at
+			});
+		}
+		return n;
+	}
+	/**
+	* True when the id is tombstoned, or the coordinate has a deletion marker that still covers the
+	* current event at that address: a replacement published after the marker's `until` clears the
+	* deletion. Coordinates are matched on the canonical lowercase pubkey.
+	*/
+	isDeleted(idOrAddress) {
+		if (this.#deletion.ids.has(idOrAddress.toLowerCase())) return true;
+		const coord = parseEventAddress(idOrAddress);
+		if (!coord) return false;
+		const address = formatEventAddress(coord.kind, coord.pubkey, coord.identifier);
+		const until = this.#deletion.coordinates.get(address);
+		if (until === void 0) return false;
+		const id = this.#replaceable.get(address);
+		if (id === void 0) return true;
+		const event = this.#byId.get(id);
+		return event === void 0 || event.created_at <= until;
+	}
+	getOutboxBound(pubkey, kind) {
+		const persisted = this.#outboxBounds.get(outboxBoundKey(pubkey, kind));
+		if (persisted) return {
+			oldest: persisted.oldest,
+			newest: persisted.newest
+		};
+		return this.#deriveOutboxBound(pubkey, kind);
+	}
+	setOutboxBound(pubkey, kind, bound) {
+		this.#outboxBounds.set(outboxBoundKey(pubkey, kind), {
+			oldest: bound.oldest,
+			newest: bound.newest
+		});
+	}
+	clear() {
+		if (this.#onRemove) for (const event of this.#byId.values()) this.#onRemove(event);
+		this.#byId.clear();
+		this.#all.clear();
+		this.#byPubkey.clear();
+		this.#byKind.clear();
+		this.#byKindPubkey.clear();
+		this.#byTag.clear();
+		this.#replaceable.clear();
+		this.#watermarks.clear();
+		this.#watermarkIds.clear();
+		this.#deletion.clear();
+		this.#outboxBounds.clear();
+	}
+	get size() {
+		return this.#byId.size;
+	}
+	#indexInsert(event) {
+		this.#byId.set(event.id, event);
+		const { pubkey } = event;
+		this.#all.insert(event);
+		insertBucket(this.#byPubkey, pubkey, event);
+		insertBucket(this.#byKind, event.kind, event);
+		insertBucket(this.#byKindPubkey, `${event.kind}:${pubkey}`, event);
+		for (const key of tagKeys(event)) insertBucket(this.#byTag, key, event);
+		const addr = eventAddress(event);
+		if (addr !== void 0) {
+			this.#replaceable.set(addr, event.id);
+			this.#dropWatermark(addr);
+		}
+		this.#onInsert?.(event);
+	}
+	#indexRemove(id) {
+		this.#dropWatermarkId(id);
+		const event = this.#byId.get(id);
+		if (!event) return false;
+		this.#byId.delete(id);
+		const { pubkey } = event;
+		this.#all.remove(event);
+		removeBucket(this.#byPubkey, pubkey, event);
+		removeBucket(this.#byKind, event.kind, event);
+		removeBucket(this.#byKindPubkey, `${event.kind}:${pubkey}`, event);
+		for (const key of tagKeys(event)) removeBucket(this.#byTag, key, event);
+		const addr = eventAddress(event);
+		if (addr !== void 0 && this.#replaceable.get(addr) === id) this.#replaceable.delete(addr);
+		this.#onRemove?.(event);
+		return true;
+	}
+	#matchedEvents(filter) {
+		if (filter.limit === 0) return [];
+		const { limit } = filter;
+		const matched = [];
+		if (filter.ids) {
+			const seen = /* @__PURE__ */ new Set();
+			for (const raw of filter.ids) {
+				const event = this.#byId.get(raw.toLowerCase());
+				if (!event || seen.has(event.id)) continue;
+				seen.add(event.id);
+				if (this.#deletion.covers(event) || !matchFilter(filter, event)) continue;
+				matched.push(event);
+			}
+			sortEvents(matched);
+			return limit === void 0 ? matched : matched.slice(0, limit);
+		}
+		const cursor = this.#candidates(filter);
+		while (cursor.value !== void 0) {
+			const event = cursor.value;
+			cursor.next();
+			if (this.#deletion.covers(event) || !matchFilter(filter, event)) continue;
+			matched.push(event);
+			if (limit !== void 0 && matched.length >= limit) break;
+		}
+		return matched;
+	}
+	/**
+	* Smallest-total bucket set for the filter's usable indexes: `authors`×`kinds` (both present),
+	* `authors`, `kinds`, each single-letter `#x` condition (a bucket per value; `#e`/`#p` filter
+	* values lowercased like `matchFilter`, others verbatim), or `all` as the fallback.
+	*/
+	#plan(filter) {
+		const { authors, kinds } = filter;
+		const tagConds = filterTagConditions(filter);
+		let best;
+		let bestTotal = Number.POSITIVE_INFINITY;
+		const consider = (buckets) => {
+			let total = 0;
+			const present = [];
+			for (const bucket of buckets) if (bucket !== void 0) {
+				present.push(bucket);
+				total += bucket.size;
+			}
+			if (total < bestTotal) {
+				bestTotal = total;
+				best = present;
+			}
+		};
+		if (authors !== void 0 && kinds !== void 0) {
+			const buckets = [];
+			for (const pk of authors) {
+				const pubkey = pk.toLowerCase();
+				for (const kind of kinds) buckets.push(this.#byKindPubkey.get(`${kind}:${pubkey}`));
+			}
+			consider(buckets);
+		}
+		if (authors !== void 0) consider(authors.map((pk) => this.#byPubkey.get(pk.toLowerCase())));
+		if (kinds !== void 0) consider(kinds.map((kind) => this.#byKind.get(kind)));
+		for (const { name, values } of tagConds) consider(values.map((v) => this.#byTag.get(`${name}:${v}`)));
+		if (best === void 0 || bestTotal > this.#all.size) return [this.#all];
+		return best;
+	}
+	/** Canonical-order candidates from the planned buckets, each clipped to `since`/`until`. */
+	#candidates(filter) {
+		const buckets = this.#plan(filter);
+		const cursors = [];
+		for (const bucket of buckets) {
+			const cursor = bucket.cursor(filter.since, filter.until);
+			if (cursor.value !== void 0) cursors.push(cursor);
+		}
+		if (cursors.length === 0) return EMPTY_CURSOR;
+		if (cursors.length === 1) return cursors[0] ?? EMPTY_CURSOR;
+		return new CursorHeap(cursors);
+	}
+	#deriveOutboxBound(pubkey, kind) {
+		const bucket = this.#byKindPubkey.get(`${kind}:${pubkey.toLowerCase()}`);
+		if (bucket === void 0) return;
+		let oldest;
+		let newest;
+		const cursor = bucket.cursor();
+		while (cursor.value !== void 0) {
+			const event = cursor.value;
+			cursor.next();
+			if (this.#deletion.covers(event)) continue;
+			newest ??= event.created_at;
+			oldest = event.created_at;
+		}
+		if (oldest === void 0 || newest === void 0) return;
+		return {
+			oldest,
+			newest
+		};
+	}
+	#setWatermark(addr, watermark) {
+		if (this.#maxWatermarks === 0) return;
+		this.#dropWatermark(addr);
+		this.#watermarks.set(addr, watermark);
+		this.#watermarkIds.set(watermark.id, addr);
+		trimOldest(this.#watermarks, this.#maxWatermarks, (a) => this.#dropWatermark(a));
+	}
+	#dropWatermark(addr) {
+		const watermark = this.#watermarks.get(addr);
+		if (watermark === void 0) return;
+		this.#watermarks.delete(addr);
+		this.#watermarkIds.delete(watermark.id);
+	}
+	#dropWatermarkId(id) {
+		const addr = this.#watermarkIds.get(id);
+		if (addr === void 0) return;
+		this.#watermarkIds.delete(id);
+		this.#watermarks.delete(addr);
+	}
+	#trimTombstones() {
+		const cap = this.#maxTombstones;
+		if (cap === void 0) return;
+		trimOldest(this.#deletion.ids, cap, (id) => {
+			this.#deletion.pending.delete(id);
+		});
+		trimOldest(this.#deletion.pending, cap);
+		trimOldest(this.#deletion.coordinates, cap);
+	}
+};
+const EMPTY_CURSOR = {
+	value: void 0,
+	next: () => void 0
+};
+/**
+* Binary-heap k-way merge of sorted cursors. `next()` advances every cursor sitting on the emitted
+* event, which dedupes an event present in several buckets (multi-value `#x` filters); copies
+* compare equal so they always surface adjacent. Entries pair each cursor with its head event so
+* heap comparisons never read `undefined`.
+*/
+var CursorHeap = class {
+	#heap;
+	constructor(cursors) {
+		const heap = [];
+		for (const cursor of cursors) {
+			const event = cursor.value;
+			if (event !== void 0) heap.push({
+				cursor,
+				event
+			});
+		}
+		this.#heap = heap;
+		for (let i = Math.floor(heap.length / 2) - 1; i >= 0; i--) this.#siftDown(i);
+	}
+	get value() {
+		return this.#heap[0]?.event;
+	}
+	next() {
+		const emitted = this.#heap[0]?.event;
+		if (emitted === void 0) return;
+		while (this.#heap[0]?.event === emitted) {
+			const [root] = this.#heap;
+			if (root === void 0) return;
+			root.cursor.next();
+			const nextEvent = root.cursor.value;
+			if (nextEvent === void 0) {
+				const last = this.#heap.pop();
+				if (this.#heap.length > 0 && last !== void 0) {
+					this.#heap[0] = last;
+					this.#siftDown(0);
+				}
+			} else {
+				root.event = nextEvent;
+				this.#siftDown(0);
+			}
+		}
+	}
+	#less(a, b) {
+		const x = this.#heap[a];
+		const y = this.#heap[b];
+		return x !== void 0 && y !== void 0 && compareEventsDesc(x.event, y.event) < 0;
+	}
+	#siftDown(start) {
+		const heap = this.#heap;
+		let i = start;
+		for (;;) {
+			let min = i;
+			if (this.#less(2 * i + 1, min)) min = 2 * i + 1;
+			if (this.#less(2 * i + 2, min)) min = 2 * i + 2;
+			if (min === i) return;
+			const tmp = heap[i];
+			const swap = heap[min];
+			if (tmp === void 0 || swap === void 0) return;
+			heap[i] = swap;
+			heap[min] = tmp;
+			i = min;
+		}
+	}
+};
+/** Distinct `${name}:${value}` bucket keys for every ASCII single-letter tag name on the event. */
+function tagKeys(event) {
+	const keys = /* @__PURE__ */ new Set();
+	for (const tag of event.tags) {
+		const [name, value] = tag;
+		if (name === void 0 || value === void 0 || !SINGLE_ASCII_LETTER.test(name)) continue;
+		keys.add(`${name}:${value}`);
+	}
+	return [...keys];
+}
+function insertBucket(map, key, event) {
+	let bucket = map.get(key);
+	if (bucket === void 0) {
+		bucket = new SortedEvents();
+		map.set(key, bucket);
+	}
+	bucket.insert(event);
+}
+function removeBucket(map, key, event) {
+	const bucket = map.get(key);
+	if (bucket === void 0 || !bucket.remove(event)) return;
+	if (bucket.size === 0) map.delete(key);
+}
+//#endregion
+export { MemoryIndex as t };
+
+//# sourceMappingURL=memory-index-3GSrPIWj.mjs.map