@mark1russell7/collections 0.7.2 → 0.9.0

package/build/index.js

@@ -456,6 +456,38 @@ const onWhen = (emitter, event, predicate, listener) => {
 		if (predicate(payload)) listener(payload);
 	});
 };
+// src/core/removals.ts
+/** The key of the removal channel on a layer. */
+const removals = Symbol.for("@mark1russell7/collections/removals");
+/**
+* This function gives the removal channel of a collection, or `undefined` when no layer of it removes.
+*/
+function removalsOf(collection) {
+	const channel = collection[removals];
+	if (typeof channel !== "object" || channel === null) return void 0;
+	return typeof channel.on === "function" ? channel : void 0;
+}
+/**
+* This function makes the channel of a removing layer over `next`.
+* The channel forwards each removal below. It calls `below` first, so the layer corrects its own state first.
+*/
+function removalSource(next, below) {
+	const listeners = /* @__PURE__ */ new Set();
+	const emit = (removal) => {
+		for (const listener of [...listeners]) listener(removal);
+	};
+	removalsOf(next)?.on((removal) => {
+		below?.(removal);
+		emit(removal);
+	});
+	return {
+		channel: { on(listener) {
+			listeners.add(listener);
+			return () => void listeners.delete(listener);
+		} },
+		emit
+	};
+}
 // src/storage/listeners.ts
 /**
 * The default handler of the error of a listener. It throws the error again in a microtask, as an
@@ -4509,6 +4541,7 @@ function boundedList(options) {
 	const { policy = "throw", onOverflow } = options;
 	const capacity = checkCapacity(options.capacity, "boundedList");
 	return (next) => {
+		const source = removalSource(next);
 		const handleOverflow = (element, dropFrom = "first") => {
 			if (onOverflow) {
 				const context = {
@@ -4523,8 +4556,12 @@ function boundedList(options) {
 				case "throw": throw new Error(`List is full (capacity: ${capacity})`);
 				case "drop-oldest":
 					if (!next.isEmpty) {
-						if (dropFrom === "last") next.pop();
-						else next.shift();
+						const value = dropFrom === "last" ? next.pop() : next.shift();
+						source.emit({
+							value,
+							end: dropFrom,
+							reason: "drop"
+						});
 					}
 					break;
 				case "drop-newest": return;
@@ -4536,6 +4573,7 @@ function boundedList(options) {
 		};
 		const shifted = (index) => policy === "drop-oldest" ? Math.max(0, index - 1) : index;
 		return new Proxy(next, { get(target, prop, receiver) {
+			if (prop === removals) return source.channel;
 			if (prop === "capacity") return capacity;
 			if (prop === "isFull") return target.size >= capacity;
 			if (prop === "remainingCapacity") return Math.max(0, capacity - target.size);
@@ -4601,12 +4639,25 @@ function boundedList(options) {
 	};
 }
 /**
+* This function adds each element with `add`, one after the other, until `add` refuses one.
+* It gives true when one element goes in. A throw of `add` stops it, and the earlier elements stay.
+*/
+function addEach(elements, add) {
+	let added = false;
+	for (const element of Array.from(elements)) {
+		if (!add(element)) break;
+		added = true;
+	}
+	return added;
+}
+/**
 * This function makes a bounded Queue middleware.
 */
 function boundedQueue(options) {
 	const { policy = "throw", onOverflow } = options;
 	const capacity = checkCapacity(options.capacity, "boundedQueue");
 	return (next) => {
+		const source = removalSource(next);
 		const handleOverflow = (element) => {
 			if (onOverflow) {
 				const context = {
@@ -4620,7 +4671,11 @@ function boundedQueue(options) {
 			switch (policy) {
 				case "throw": throw new Error(`Queue is full (capacity: ${capacity})`);
 				case "drop-oldest":
-					if (!next.isEmpty) next.poll();
+					if (!next.isEmpty) source.emit({
+						value: next.poll(),
+						end: "first",
+						reason: "drop"
+					});
 					break;
 				case "drop-newest":
 				case "reject": return;
@@ -4630,6 +4685,7 @@ function boundedQueue(options) {
 			}
 		};
 		return new Proxy(next, { get(target, prop, receiver) {
+			if (prop === removals) return source.channel;
 			if (prop === "capacity") return capacity;
 			if (prop === "isFull") return target.size >= capacity;
 			if (prop === "remainingCapacity") return Math.max(0, capacity - target.size);
@@ -4644,6 +4700,9 @@ function boundedQueue(options) {
 					}
 					return value.call(target, element);
 				};
+				case "addAll": return function(elements) {
+					return addEach(elements, (element) => receiver.add(element));
+				};
 			}
 			return value;
 		} });
@@ -4656,7 +4715,8 @@ function boundedDeque(options) {
 	const { policy = "throw", onOverflow } = options;
 	const capacity = checkCapacity(options.capacity, "boundedDeque");
 	return (next) => {
-		const handleOverflow = (element) => {
+		const source = removalSource(next);
+		const handleOverflow = (element, dropFrom) => {
 			if (onOverflow) {
 				const context = {
 					newElement: element,
@@ -4669,7 +4729,14 @@ function boundedDeque(options) {
 			switch (policy) {
 				case "throw": throw new Error(`Deque is full (capacity: ${capacity})`);
 				case "drop-oldest":
-					if (!next.isEmpty) next.removeFirst();
+					if (!next.isEmpty) {
+						const value = dropFrom === "last" ? next.removeLast() : next.removeFirst();
+						source.emit({
+							value,
+							end: dropFrom,
+							reason: "drop"
+						});
+					}
 					break;
 				case "drop-newest":
 				case "reject": return;
@@ -4679,6 +4746,7 @@ function boundedDeque(options) {
 			}
 		};
 		return new Proxy(next, { get(target, prop, receiver) {
+			if (prop === removals) return source.channel;
 			if (prop === "capacity") return capacity;
 			if (prop === "isFull") return target.size >= capacity;
 			if (prop === "remainingCapacity") return Math.max(0, capacity - target.size);
@@ -4692,11 +4760,14 @@ function boundedDeque(options) {
 				case "offer":
 				case "add": return function(element) {
 					if (target.size >= capacity && policy !== "grow") {
-						handleOverflow(element);
+						handleOverflow(element, prop === "addFirst" || prop === "offerFirst" ? "last" : "first");
 						if (policy === "reject" || policy === "drop-newest") return prop.startsWith("offer") || prop === "add" ? false : void 0;
 					}
 					return value.call(target, element);
 				};
+				case "addAll": return function(elements) {
+					return addEach(elements, (element) => receiver.add(element));
+				};
 			}
 			return value;
 		} });
@@ -4710,6 +4781,9 @@ function boundedMap(options) {
 	const capacity = checkCapacity(options.capacity, "boundedMap");
 	return (next) => {
 		let insertionOrder = [];
+		const source = removalSource(next, ({ key }) => {
+			insertionOrder = insertionOrder.filter((k) => !next.keyEq(k, key));
+		});
 		const handleOverflow = (key, value) => {
 			if (onOverflow) onOverflow({
 				key,
@@ -4721,9 +4795,17 @@ function boundedMap(options) {
 			switch (policy) {
 				case "throw": throw new Error(`Map is full (capacity: ${capacity})`);
 				case "drop-oldest":
-					if (insertionOrder.length > 0) {
+					while (insertionOrder.length > 0) {
 						const oldestKey = insertionOrder.shift();
+						if (!next.has(oldestKey)) continue;
+						const value = next.get(oldestKey);
 						next.delete(oldestKey);
+						source.emit({
+							key: oldestKey,
+							value,
+							reason: "drop"
+						});
+						break;
 					}
 					break;
 				case "drop-newest":
@@ -4734,6 +4816,7 @@ function boundedMap(options) {
 			}
 		};
 		return new Proxy(next, { get(target, prop, receiver) {
+			if (prop === removals) return source.channel;
 			if (prop === "capacity") return capacity;
 			if (prop === "isFull") return target.size >= capacity;
 			if (prop === "remainingCapacity") return Math.max(0, capacity - target.size);
@@ -5063,6 +5146,24 @@ function safe() {
 }
 // src/behaviors/evented.ts
 /**
+* This function gives each removal below `next` to `listener` and counts the removals.
+* With the counts, a layer tells a refused add (the size did not grow) from an add that caused a drop.
+*/
+function hear(next, listener) {
+	const heard = {
+		all: 0,
+		first: 0
+	};
+	removalsOf(next)?.on((removal) => {
+		heard.all++;
+		if ("end" in removal && removal.end === "first") heard.first++;
+		listener(removal);
+	});
+	return heard;
+}
+/** This function tells if a call added an element: the size grew, after the removals of the layers below. */
+const added = (size, sizeBefore, heard, heardBefore) => size - sizeBefore + heard.all - heardBefore > 0;
+/**
 * This function makes an evented List middleware.
 *
 * This function emits events for add, remove, set, clear, sort, and reverse operations.
@@ -5070,28 +5171,44 @@ function safe() {
 function eventedList() {
 	return (next) => {
 		const emitter = new Emitter();
+		const heard = hear(next, ({ value, end, reason }) => emitter.emit("remove", end === void 0 ? {
+			value,
+			reason
+		} : {
+			value,
+			index: end === "first" ? 0 : next.size,
+			reason
+		}));
 		return new Proxy(next, { get(target, prop, receiver) {
 			if (prop === "on") return emitter.on.bind(emitter);
 			const value = Reflect.get(target, prop, receiver);
 			if (typeof value === "function") switch (prop) {
 				case "add":
 				case "push": return function(element) {
+					const size = target.size;
+					const all = heard.all;
 					const result = value.call(target, element);
-					emitter.emit("add", { value: element });
+					if (added(target.size, size, heard, all)) emitter.emit("add", { value: element });
 					return result;
 				};
 				case "unshift": return function(element) {
+					const size = target.size;
+					const all = heard.all;
 					value.call(target, element);
-					emitter.emit("add", {
+					if (added(target.size, size, heard, all)) emitter.emit("add", {
 						value: element,
 						index: 0
 					});
 				};
 				case "insert": return function(index, element) {
+					const size = target.size;
+					const all = heard.all;
+					const first = heard.first;
 					value.call(target, index, element);
+					if (!added(target.size, size, heard, all)) return;
 					emitter.emit("add", {
 						value: element,
-						index
+						index: heard.first > first ? Math.max(0, index - 1) : index
 					});
 				};
 				case "set": return function(index, element) {
@@ -5118,7 +5235,10 @@ function eventedList() {
 				};
 				case "pop": return function() {
 					const removed = value.call(target);
-					emitter.emit("remove", { value: removed });
+					emitter.emit("remove", {
+						value: removed,
+						index: target.size
+					});
 					return removed;
 				};
 				case "shift": return function() {
@@ -5152,6 +5272,10 @@ function eventedList() {
 function eventedQueue() {
 	return (next) => {
 		const emitter = new Emitter();
+		hear(next, ({ value, reason }) => emitter.emit("dequeue", {
+			value,
+			reason
+		}));
 		return new Proxy(next, { get(target, prop, receiver) {
 			if (prop === "on") return emitter.on.bind(emitter);
 			const value = Reflect.get(target, prop, receiver);
@@ -5184,23 +5308,25 @@ function eventedQueue() {
 function eventedDeque() {
 	return (next) => {
 		const emitter = new Emitter();
+		const heard = hear(next, ({ value, end, reason }) => emitter.emit(end === "last" ? "removeLast" : "removeFirst", {
+			value,
+			reason
+		}));
 		return new Proxy(next, { get(target, prop, receiver) {
 			if (prop === "on") return emitter.on.bind(emitter);
 			const value = Reflect.get(target, prop, receiver);
 			if (typeof value === "function") switch (prop) {
 				case "addFirst":
 				case "offerFirst":
-				case "push": return function(element) {
-					const result = value.call(target, element);
-					emitter.emit("addFirst", { value: element });
-					return result;
-				};
 				case "addLast":
 				case "offerLast":
 				case "offer":
-				case "add": return function(element) {
+				case "add":
+				case "push": return function(element) {
+					const size = target.size;
+					const all = heard.all;
 					const result = value.call(target, element);
-					emitter.emit("addLast", { value: element });
+					if (added(target.size, size, heard, all)) emitter.emit(prop === "addFirst" || prop === "offerFirst" ? "addFirst" : "addLast", { value: element });
 					return result;
 				};
 				case "removeFirst":
@@ -5233,13 +5359,20 @@ function eventedDeque() {
 function eventedMap() {
 	return (next) => {
 		const emitter = new Emitter();
+		const heard = hear(next, ({ key, value, reason }) => emitter.emit("delete", {
+			key,
+			value,
+			reason
+		}));
 		return new Proxy(next, { get(target, prop, receiver) {
 			if (prop === "on") return emitter.on.bind(emitter);
 			const value = Reflect.get(target, prop, receiver);
 			if (typeof value === "function") switch (prop) {
 				case "set": return function(key, val) {
+					const size = target.size;
+					const all = heard.all;
 					const oldValue = value.call(target, key, val);
-					emitter.emit("set", {
+					if (oldValue !== void 0 || added(target.size, size, heard, all)) emitter.emit("set", {
 						key,
 						value: val,
 						oldValue
@@ -5269,6 +5402,10 @@ function eventedMap() {
 function evented() {
 	return (next) => {
 		const emitter = new Emitter();
+		hear(next, ({ value, reason }) => emitter.emit("remove", {
+			value,
+			reason
+		}));
 		return new Proxy(next, { get(target, prop, receiver) {
 			if (prop === "on") return emitter.on.bind(emitter);
 			const value = Reflect.get(target, prop, receiver);
@@ -5641,6 +5778,10 @@ function lruMap(options) {
 			else tail = node.prev;
 			nodeMap.delete(node.key);
 		};
+		const source = removalSource(next, ({ key }) => {
+			const node = nodeMap.get(key);
+			if (node) removeNode(node);
+		});
 		const dropStaleNodes = () => {
 			for (const node of [...nodeMap.values()]) if (!next.has(node.key)) removeNode(node);
 		};
@@ -5655,24 +5796,23 @@ function lruMap(options) {
 					value: candidate.value,
 					timestamp: candidate.lastAccessed
 				});
+				source.emit({
+					key: candidate.key,
+					value: candidate.value,
+					reason: "evict"
+				});
 				return;
 			}
 		};
 		return new Proxy(next, { get(target, prop, receiver) {
+			if (prop === removals) return source.channel;
 			if (prop === "isFull") return target.size >= capacity;
 			const composite = compositeMapMethod(receiver, prop);
 			if (composite) return composite;
 			const value = Reflect.get(target, prop, receiver);
 			if (typeof value === "function") switch (prop) {
 				case "get": return function(key) {
-					let result;
-					try {
-						result = value.call(target, key);
-					} catch (error) {
-						const stale = nodeMap.get(key);
-						if (stale) removeNode(stale);
-						throw error;
-					}
+					const result = value.call(target, key);
 					const node = nodeMap.get(key);
 					if (node) moveToHead(node);
 					return result;
@@ -5680,10 +5820,7 @@ function lruMap(options) {
 				case "has": return function(key) {
 					const result = value.call(target, key);
 					const node = nodeMap.get(key);
-					if (node) {
-						if (result) moveToHead(node);
-						else removeNode(node);
-					}
+					if (node && result) moveToHead(node);
 					return result;
 				};
 				case "set": return function(key, val) {
@@ -5698,7 +5835,7 @@ function lruMap(options) {
 					} else {
 						const stale = nodeMap.get(key);
 						if (stale) removeNode(stale);
-						if (nodeMap.size >= capacity) dropStaleNodes();
+						if (nodeMap.size >= 2 * capacity) dropStaleNodes();
 						if (target.size >= capacity) evictLRU();
 						const result = value.call(target, key, val);
 						addNode(key, val);
@@ -5886,33 +6023,40 @@ function startExpirationTimer(check, interval) {
 /**
 * This function makes a TTL Map middleware.
 *
-* Automatically removes entries after TTL expires.
-* This function uses a background interval to check for expired entries.
+* An entry is live while the time is less than the time of its last `set` plus `ttl`.
+* Each access to the map first removes the expired entries, so each read shows only live entries.
+* The layer gives each expired entry to `onExpire` one time, in the order of expiry.
+* A background interval also removes expired entries, so `onExpire` occurs with no access.
+*
+* The layer keeps the times in the order of expiry, so the removal before an access is amortized O(1).
+* This order needs a clock that does not go back. If `Date.now()` goes back, an entry can stay until the entries before it expire.
 */
 function ttlMap(options) {
 	const { ttl, checkInterval = 1e3, onExpire } = options;
 	return (next) => {
 		const metadata = /* @__PURE__ */ new Map();
 		let intervalId = null;
-		const checkExpired = () => {
+		const source = removalSource(next, ({ key }) => void metadata.delete(key));
+		const sweep = () => {
 			const now = Date.now();
-			const expired = [];
-			for (const [key, entry] of metadata) if (now >= entry.expiresAt) expired.push(key);
-			for (const key of expired) {
-				const entry = metadata.get(key);
-				if (entry) {
-					next.delete(key);
-					metadata.delete(key);
-					if (onExpire) onExpire({
-						key,
-						value: entry.value,
-						createdAt: entry.createdAt,
-						expiredAt: now
-					});
-				}
+			for (const [key, entry] of metadata) {
+				if (now < entry.expiresAt) return;
+				metadata.delete(key);
+				next.delete(key);
+				onExpire?.({
+					key,
+					value: entry.value,
+					createdAt: entry.createdAt,
+					expiredAt: now
+				});
+				source.emit({
+					key,
+					value: entry.value,
+					reason: "expire"
+				});
 			}
 		};
-		intervalId = startExpirationTimer(checkExpired, checkInterval);
+		intervalId = startExpirationTimer(sweep, checkInterval);
 		const dispose = () => {
 			if (intervalId) {
 				clearInterval(intervalId);
@@ -5921,31 +6065,18 @@ function ttlMap(options) {
 		};
 		return new Proxy(next, { get(target, prop, receiver) {
 			if (prop === "dispose") return dispose;
+			if (prop === removals) return source.channel;
 			const composite = compositeMapMethod(receiver, prop);
 			if (composite) return composite;
+			sweep();
 			const value = Reflect.get(target, prop, receiver);
-			if (typeof value === "function") switch (prop) {
-				case "get": return function(key) {
-					const entry = metadata.get(key);
-					if (entry && Date.now() >= entry.expiresAt) {
-						target.delete(key);
-						metadata.delete(key);
-						throw new Error(`Key expired: ${key}`);
-					}
-					return value.call(target, key);
-				};
-				case "has": return function(key) {
-					const entry = metadata.get(key);
-					if (entry && Date.now() >= entry.expiresAt) {
-						target.delete(key);
-						metadata.delete(key);
-						return false;
-					}
-					return value.call(target, key);
-				};
+			if (typeof value !== "function") return value;
+			switch (prop) {
 				case "set": return function(key, val) {
-					const now = Date.now();
+					sweep();
 					const result = value.call(target, key, val);
+					const now = Date.now();
+					metadata.delete(key);
 					metadata.set(key, {
 						value: val,
 						expiresAt: now + ttl,
@@ -5954,16 +6085,36 @@ function ttlMap(options) {
 					return result;
 				};
 				case "delete": return function(key) {
-					const result = value.call(target, key);
+					sweep();
 					metadata.delete(key);
-					return result;
+					return value.call(target, key);
 				};
 				case "clear": return function() {
-					value.call(target);
 					metadata.clear();
+					value.call(target);
+				};
+				case Symbol.iterator:
+				case "entries": return function() {
+					sweep();
+					return Array.from(target).values();
+				};
+				case "keys": return function() {
+					sweep();
+					return Array.from(target, (e) => e.key).values();
+				};
+				case "values": return function() {
+					sweep();
+					return Array.from(target, (e) => e.value).values();
+				};
+				case "forEach": return function(callback) {
+					sweep();
+					for (const e of Array.from(target)) callback(e.value, e.key, receiver);
+				};
+				default: return function(...args) {
+					sweep();
+					return value.apply(target, args);
 				};
 			}
-			return value;
 		} });
 	};
 }
@@ -5978,6 +6129,7 @@ function ttlCollection(options) {
 	return (next) => {
 		const metadata = /* @__PURE__ */ new Map();
 		let intervalId = null;
+		const source = removalSource(next, ({ value }) => void metadata.delete(value));
 		const checkExpired = () => {
 			const now = Date.now();
 			const expired = [];
@@ -5992,6 +6144,10 @@ function ttlCollection(options) {
 						createdAt: entry.createdAt,
 						expiredAt: now
 					});
+					source.emit({
+						value: element,
+						reason: "expire"
+					});
 				}
 			}
 		};
@@ -6004,6 +6160,7 @@ function ttlCollection(options) {
 		};
 		return new Proxy(next, { get(target, prop, receiver) {
 			if (prop === "dispose") return dispose;
+			if (prop === removals) return source.channel;
 			const value = Reflect.get(target, prop, receiver);
 			if (typeof value === "function") switch (prop) {
 				case "add": return function(element) {
@@ -7928,6 +8085,6 @@ function stringHashCode(str) {
 	}
 	return hash;
 }
-export { ArrayDeque, ArrayList, AsyncEmitter, AsyncQueue, Channel, CollectionBuilder, DEFAULT_CONFLICT_POLICY, DEFAULT_EVICTION_POLICY, DEFAULT_GROWTH_POLICY, DEFAULT_OVERFLOW_POLICY, DEFAULT_RETRY_POLICY, DEFAULT_UNDERFLOW_POLICY, DEFAULT_VALIDATION_POLICY, Emitter, EventBatcher, HashMap, HashSet, KEY_DIGITS, LRUCache, LinkedHashMap, LinkedList, PriorityQueue, StorageListeners, SummaryTree, TTLCache, TreeMap, TreeSet, arrayContains, arrayDeque, arrayIterator, arrayList, arrayRemove, arrayRemoveAll, asSettled, asyncQueue, average, averagingNumber, blockMethods, booleanCompare, bounded, boundedDeque, boundedList, boundedMap, boundedQueue, buffered, buildList, buildMap, bundle, channel, checkBounds, checkInsertBounds, checkRangeBounds, chunk, clamp, collect, toArray as collectToArray, toList as collectToList, toMap as collectToMap, toSet as collectToSet, combineHashes, compareKeys, comparing, comparingKey, compose, concat, count, counting, createEmitter, dateCompare, deepEq, defaultCompare, defaultEq, defaultHash, delegate, distinct, distinctConsecutive, dropIndex, emptyList, emptyMap, emptyQueue, enhanceMethod, enumerate, eqBy, evented, eventedDeque, eventedList, eventedMap, eventedQueue, every, fanIn, fanOut, filter, filtering, find, findIndex, findLastIndex, first, flatMap, flatMapping, flatten, forwardEvent, groupBy, groupingBy, groupingByWith, hasCapability, hashBy, hashMap, hashNumber, hashSet, hashString, immutableListOf, immutableMapOf, interceptMethods, isValidKey, toMap$1 as iterToMap, joining, keyBetween, keysBetween, keysForDrop, last, linkedHashMap, linkedList, listOf, lruCache, lruMap, map, mapOf, mapping, max, maxBy, merge, min, minBy, mutableListOf, mutableMapOf, nCopies, none, nullsFirst, nullsLast, numberCompare, onWhen, partition, partitioningBy, pipe, pipeline, priorityQueue, queueOf, range, rangeTo, readWriteLock, readonly, readonlyCollection, readonlyList, readonlyMap, readonlyQueue, reduce, reducing, reducingWith, reentrantSynchronized, reportListenerError, requireNonEmpty, requireNonNull, reverse, reverseArrayIterator, reversed, safe, safeDeque, safeList, safeMap, safeQueue, scan, select, shallowEq, singletonList, singletonMap, skip, skipWhile, some, sort, stringCompare, stringCompareIgnoreCase, stringHashCode, sum, summarizingNumber, summaryTree, summingNumber, synchronized, synchronizedCollection, synchronizedList, synchronizedMap, synchronizedSet, take, takeWhile, tap, teeing, thenComparing, ticker, timeout, toArray$1 as toArray, toList$1 as toList, toMap$2 as toMap, toSet$1 as toSet, treeMap, treeSet, ttlCache, ttlCollection, ttlMap, unbuffered, unmodifiableCollection, unmodifiableList, unmodifiableMap, window, workerPool, zip };
+export { ArrayDeque, ArrayList, AsyncEmitter, AsyncQueue, Channel, CollectionBuilder, DEFAULT_CONFLICT_POLICY, DEFAULT_EVICTION_POLICY, DEFAULT_GROWTH_POLICY, DEFAULT_OVERFLOW_POLICY, DEFAULT_RETRY_POLICY, DEFAULT_UNDERFLOW_POLICY, DEFAULT_VALIDATION_POLICY, Emitter, EventBatcher, HashMap, HashSet, KEY_DIGITS, LRUCache, LinkedHashMap, LinkedList, PriorityQueue, StorageListeners, SummaryTree, TTLCache, TreeMap, TreeSet, arrayContains, arrayDeque, arrayIterator, arrayList, arrayRemove, arrayRemoveAll, asSettled, asyncQueue, average, averagingNumber, blockMethods, booleanCompare, bounded, boundedDeque, boundedList, boundedMap, boundedQueue, buffered, buildList, buildMap, bundle, channel, checkBounds, checkInsertBounds, checkRangeBounds, chunk, clamp, collect, toArray as collectToArray, toList as collectToList, toMap as collectToMap, toSet as collectToSet, combineHashes, compareKeys, comparing, comparingKey, compose, concat, count, counting, createEmitter, dateCompare, deepEq, defaultCompare, defaultEq, defaultHash, delegate, distinct, distinctConsecutive, dropIndex, emptyList, emptyMap, emptyQueue, enhanceMethod, enumerate, eqBy, evented, eventedDeque, eventedList, eventedMap, eventedQueue, every, fanIn, fanOut, filter, filtering, find, findIndex, findLastIndex, first, flatMap, flatMapping, flatten, forwardEvent, groupBy, groupingBy, groupingByWith, hasCapability, hashBy, hashMap, hashNumber, hashSet, hashString, immutableListOf, immutableMapOf, interceptMethods, isValidKey, toMap$1 as iterToMap, joining, keyBetween, keysBetween, keysForDrop, last, linkedHashMap, linkedList, listOf, lruCache, lruMap, map, mapOf, mapping, max, maxBy, merge, min, minBy, mutableListOf, mutableMapOf, nCopies, none, nullsFirst, nullsLast, numberCompare, onWhen, partition, partitioningBy, pipe, pipeline, priorityQueue, queueOf, range, rangeTo, readWriteLock, readonly, readonlyCollection, readonlyList, readonlyMap, readonlyQueue, reduce, reducing, reducingWith, reentrantSynchronized, removalSource, removals, removalsOf, reportListenerError, requireNonEmpty, requireNonNull, reverse, reverseArrayIterator, reversed, safe, safeDeque, safeList, safeMap, safeQueue, scan, select, shallowEq, singletonList, singletonMap, skip, skipWhile, some, sort, stringCompare, stringCompareIgnoreCase, stringHashCode, sum, summarizingNumber, summaryTree, summingNumber, synchronized, synchronizedCollection, synchronizedList, synchronizedMap, synchronizedSet, take, takeWhile, tap, teeing, thenComparing, ticker, timeout, toArray$1 as toArray, toList$1 as toList, toMap$2 as toMap, toSet$1 as toSet, treeMap, treeSet, ttlCache, ttlCollection, ttlMap, unbuffered, unmodifiableCollection, unmodifiableList, unmodifiableMap, window, workerPool, zip };
 
 //# sourceMappingURL=index.js.map