@mark1russell7/collections 0.9.2 → 0.9.4

package/build/index.js

@@ -1,4 +1,5 @@
 import { compose as compose$1 } from "./core/layers.js";
+import { _ as split, a as insert, b as summaryOf, c as locate, d as remove, f as search, g as splice, h as slice, i as height, l as of, m as size, n as at, o as isEmpty, p as set, r as concat$1, s as leaves, t as append, u as prepend, v as splitAt, x as toArray$2, y as summary } from "./functions.js";
 import { none as none$1, some as some$1, toOptional, tryCatch } from "@mark1russell7/optional";
 // src/core/policies.ts
 /**
@@ -4075,283 +4076,81 @@ function priorityQueue(optionsOrElementsOrComparator) {
 	return new PriorityQueue(optionsOrElementsOrComparator);
 }
 // src/impl/summary-tree.ts
-function heightOf(tree) {
-	return tree === null ? 0 : tree.height;
-}
-function sizeOf(tree) {
-	return tree === null ? 0 : tree.size;
-}
-/** The functions that make and join nodes for one monoid. */
-var Builder = class {
-	spec;
-	constructor(spec) {
-		this.spec = spec;
-	}
-	summaryOf(tree) {
-		return tree === null ? this.spec.monoid.empty : tree.summary;
-	}
-	/** This function makes a node. Give `inner` only when it is the summary of `left` and `own`, to save one `combine`. */
-	node(left, leaf, own, right, inner) {
-		if (inner === void 0) inner = left === null ? own : this.spec.monoid.combine(left.summary, own);
-		return {
-			left,
-			leaf,
-			own,
-			inner,
-			right,
-			height: 1 + Math.max(heightOf(left), heightOf(right)),
-			size: sizeOf(left) + 1 + sizeOf(right),
-			summary: right === null ? inner : this.spec.monoid.combine(inner, right.summary)
-		};
-	}
-	/** This function copies a node with a new right subtree. It keeps the summary `inner`, so it calls `combine` once at most. */
-	withRight(n, right) {
-		return this.node(n.left, n.leaf, n.own, right, n.inner);
-	}
-	rotateLeft(n) {
-		const r = n.right;
-		return this.node(this.withRight(n, r.left), r.leaf, r.own, r.right);
-	}
-	rotateRight(n) {
-		const l = n.left;
-		return this.withRight(l, this.node(l.right, n.leaf, n.own, n.right));
-	}
-	/** This function joins a tree that is higher by more than 1 with a leaf and a lower tree on its right. */
-	joinRight(left, leaf, own, right) {
-		const c = left.right;
-		if (heightOf(c) <= heightOf(right) + 1) {
-			const t = this.node(c, leaf, own, right);
-			if (t.height <= heightOf(left.left) + 1) return this.withRight(left, t);
-			return this.rotateLeft(this.withRight(left, this.rotateRight(t)));
-		}
-		const t = this.joinRight(c, leaf, own, right);
-		const joined = this.withRight(left, t);
-		return t.height <= heightOf(left.left) + 1 ? joined : this.rotateLeft(joined);
-	}
-	/** This function joins a lower tree on the left with a leaf and a tree that is higher by more than 1. */
-	joinLeft(left, leaf, own, right, inner) {
-		const c = right.left;
-		if (heightOf(c) <= heightOf(left) + 1) {
-			const t = this.node(left, leaf, own, c, inner);
-			if (t.height <= heightOf(right.right) + 1) return this.node(t, right.leaf, right.own, right.right);
-			return this.rotateRight(this.node(this.rotateLeft(t), right.leaf, right.own, right.right));
-		}
-		const t = this.joinLeft(left, leaf, own, c, inner);
-		const joined = this.node(t, right.leaf, right.own, right.right);
-		return t.height <= heightOf(right.right) + 1 ? joined : this.rotateRight(joined);
-	}
-	/**
-	* This function gives the tree of the leaves of `left`, then `leaf`, then the leaves of `right`. Give `inner` only
-	* when it is the summary of `left` and `own`.
-	*/
-	join(left, leaf, own, right, inner) {
-		if (heightOf(left) > heightOf(right) + 1) return this.joinRight(left, leaf, own, right);
-		if (heightOf(right) > heightOf(left) + 1) return this.joinLeft(left, leaf, own, right, inner);
-		return this.node(left, leaf, own, right, inner);
-	}
-	/** This function removes the last leaf of a tree, and gives the rest and the node of that leaf. */
-	splitLast(tree) {
-		if (tree.right === null) return [tree.left, tree];
-		const [rest, last] = this.splitLast(tree.right);
-		return [this.join(tree.left, tree.leaf, tree.own, rest, tree.inner), last];
-	}
-	concat(left, right) {
-		if (left === null) return right;
-		if (right === null) return left;
-		const [rest, last] = this.splitLast(left);
-		return this.join(rest, last.leaf, last.own, right);
-	}
-	/** This function splits a tree into its first `index` leaves and the other leaves. */
-	splitAt(tree, index) {
-		if (tree === null) return [null, null];
-		const before = sizeOf(tree.left);
-		if (index <= before) {
-			const [a, b] = this.splitAt(tree.left, index);
-			return [a, this.join(b, tree.leaf, tree.own, tree.right)];
-		}
-		const [a, b] = this.splitAt(tree.right, index - before - 1);
-		return [this.join(tree.left, tree.leaf, tree.own, a, tree.inner), b];
-	}
-	/** This function splits a tree before the first leaf whose prefix summary, after `acc`, satisfies the predicate. */
-	splitBy(tree, predicate, acc) {
-		if (tree === null) return [null, null];
-		const { combine } = this.spec.monoid;
-		const throughLeft = tree.left === null ? acc : combine(acc, tree.left.summary);
-		if (tree.left !== null && predicate(throughLeft)) {
-			const [a, b] = this.splitBy(tree.left, predicate, acc);
-			return [a, this.join(b, tree.leaf, tree.own, tree.right)];
-		}
-		const throughLeaf = combine(throughLeft, tree.own);
-		if (predicate(throughLeaf)) return [tree.left, this.join(null, tree.leaf, tree.own, tree.right)];
-		const [a, b] = this.splitBy(tree.right, predicate, throughLeaf);
-		return [this.join(tree.left, tree.leaf, tree.own, a, tree.inner), b];
-	}
-	/** This function replaces the leaf at an index in the tree. It copies only the path to the leaf. */
-	replaceAt(tree, index, leaf, own) {
-		const before = sizeOf(tree.left);
-		if (index === before) return this.node(tree.left, leaf, own, tree.right);
-		if (index < before) return this.node(this.replaceAt(tree.left, index, leaf, own), tree.leaf, tree.own, tree.right);
-		return this.withRight(tree, this.replaceAt(tree.right, index - before - 1, leaf, own));
-	}
-	/** This function puts one leaf before the leaf at an index. It copies only the path, and `join` keeps the balance. */
-	insertAt(tree, index, leaf, own) {
-		if (tree === null) return this.node(null, leaf, own, null);
-		const before = sizeOf(tree.left);
-		if (index <= before) return this.join(this.insertAt(tree.left, index, leaf, own), tree.leaf, tree.own, tree.right);
-		return this.join(tree.left, tree.leaf, tree.own, this.insertAt(tree.right, index - before - 1, leaf, own), tree.inner);
-	}
-	/**
-	* This function replaces the leaf at an index with one or more leaves. It descends once.
-	* At the node of the leaf, it puts the first new leaf in the node.
-	* It puts the other new leaves at the start of the right subtree of that node.
-	*/
-	replaceSpan(tree, index, leaves) {
-		const before = sizeOf(tree.left);
-		if (index < before) return this.join(this.replaceSpan(tree.left, index, leaves), tree.leaf, tree.own, tree.right);
-		if (index > before) return this.join(tree.left, tree.leaf, tree.own, this.replaceSpan(tree.right, index - before - 1, leaves), tree.inner);
-		let right = tree.right;
-		for (let i = 1; i < leaves.length; i++) right = this.insertAt(right, i - 1, leaves[i], this.spec.measure(leaves[i]));
-		return this.join(tree.left, leaves[0], this.spec.measure(leaves[0]), right);
-	}
-	/** This function removes the leaf at an index. It copies only the path, and `join` keeps the balance. */
-	removeAt(tree, index) {
-		const before = sizeOf(tree.left);
-		if (index === before) return this.concat(tree.left, tree.right);
-		if (index < before) return this.join(this.removeAt(tree.left, index), tree.leaf, tree.own, tree.right);
-		return this.join(tree.left, tree.leaf, tree.own, this.removeAt(tree.right, index - before - 1), tree.inner);
-	}
-	/** This function gives the leaf at an index of the tree. The index must be in the tree. */
-	leafAt(tree, index) {
-		let node = tree;
-		for (;;) {
-			const before = sizeOf(node.left);
-			if (index === before) return node.leaf;
-			if (index < before) node = node.left;
-			else {
-				index -= before + 1;
-				node = node.right;
-			}
-		}
-	}
-	/** This function joins the leaves at `index` and `index + 1` when `spec.merge` gives one leaf for them. */
-	seam(tree, index) {
-		const { merge } = this.spec;
-		if (merge === void 0 || tree === null || index < 0 || index + 1 >= tree.size) return tree;
-		const merged = merge(this.leafAt(tree, index), this.leafAt(tree, index + 1));
-		if (merged === void 0) return tree;
-		return this.removeAt(this.replaceAt(tree, index, merged, this.spec.measure(merged)), index + 1);
-	}
-	/** This function makes a balanced tree of the leaves `items[lo]` to `items[hi - 1]`. */
-	build(items, lo, hi) {
-		if (lo >= hi) return null;
-		const mid = lo + hi >>> 1;
-		const leaf = items[mid];
-		return this.node(this.build(items, lo, mid), leaf, this.spec.measure(leaf), this.build(items, mid + 1, hi));
-	}
-};
-/** The largest number of removed and inserted leaves for which `splice` copies paths instead of splitting the tree. */
-const SMALL_EDIT = 8;
-/** The builders of each spec. Each spec has one builder, so that two trees of the same spec can be joined. */
-const builders = /* @__PURE__ */ new WeakMap();
-function builderOf(spec) {
-	let builder = builders.get(spec);
-	if (builder === void 0) {
-		builder = new Builder(spec);
-		builders.set(spec, builder);
-	}
-	return builder;
-}
-function* walk(tree) {
-	const stack = [];
-	let node = tree;
-	while (node !== null || stack.length > 0) {
-		while (node !== null) {
-			stack.push(node);
-			node = node.left;
-		}
-		const top = stack.pop();
-		yield top.leaf;
-		node = top.right;
-	}
-}
-/** This function gives the index of a leaf, with a negative index counted from the end, or -1 when it is not in the tree. */
-function indexOf(index, size) {
-	if (!Number.isInteger(index)) return -1;
-	const at = index < 0 ? size + index : index;
-	return at >= 0 && at < size ? at : -1;
-}
-function clamp$1(value, size) {
-	if (Number.isNaN(value)) return 0;
-	const whole = Math.trunc(value);
-	return whole < 0 ? Math.max(0, size + whole) : Math.min(whole, size);
-}
+/**
+* SummaryTree: the class form of the summary tree, a persistent sequence of leaves with a summary of each part.
+*
+* The class wraps the plain functions of the entry `@mark1russell7/collections/summary-tree`. Its `record` is the
+* plain record that those functions take. A bundle that uses the class keeps each of its methods, so a program that
+* calls only a few operations imports the functions instead.
+*
+* @example
+* // The number of leaves and the total length of the strings
+* const spec = {
+*   monoid: { empty: { count: 0, length: 0 }, combine: (a, b) => ({ count: a.count + b.count, length: a.length + b.length }) },
+*   measure: (leaf: string) => ({ count: 1, length: leaf.length }),
+* };
+* const tree = summaryTree(spec, ["ab", "cde", "f"]);
+* tree.summary; // { count: 3, length: 6 }
+* const [left, right] = tree.split((prefix) => prefix.length > 2); // left: ["ab"], right: ["cde", "f"]
+*/
 /**
 * A persistent sequence of leaves with a summary of each part. Make one with `summaryTree`. Each method that changes
 * the sequence gives a new tree.
 */
 var SummaryTree = class SummaryTree {
-	builder;
-	root;
-	constructor(builder, root) {
-		this.builder = builder;
-		this.root = root;
+	/** The plain record of the tree: its spec and its root. The functions of the entry `./summary-tree` take it. */
+	record;
+	constructor(record) {
+		this.record = record;
 	}
 	/** This function makes a tree of a spec from leaves, as `summaryTree` does. */
 	static of(spec, leaves = []) {
-		const builder = builderOf(spec);
-		const items = [...leaves];
-		return new SummaryTree(builder, builder.build(items, 0, items.length));
+		return new SummaryTree(of(spec, leaves));
 	}
-	wrap(root) {
-		return root === this.root ? this : new SummaryTree(this.builder, root);
+	/** This function wraps a plain record of the entry `./summary-tree` in a tree. It does not copy the nodes. */
+	static fromRecord(record) {
+		return new SummaryTree(record);
 	}
-	treeOf(leaves) {
-		if (leaves instanceof SummaryTree) {
-			if (leaves.builder !== this.builder) throw new TypeError("SummaryTree: the two trees have different specs");
-			return leaves.root;
-		}
-		const items = [...leaves];
-		return this.builder.build(items, 0, items.length);
+	wrap(record) {
+		return record === this.record ? this : new SummaryTree(record);
 	}
 	/** The spec of the tree: its monoid and its measure. */
 	get spec() {
-		return this.builder.spec;
+		return this.record.spec;
 	}
 	/** The number of leaves. */
 	get size() {
-		return sizeOf(this.root);
+		return size(this.record);
 	}
 	get isEmpty() {
-		return this.root === null;
+		return isEmpty(this.record);
 	}
 	/** The summary of all the leaves, in their order. An empty tree has the summary `monoid.empty`. */
 	get summary() {
-		return this.builder.summaryOf(this.root);
+		return summary(this.record);
 	}
 	/** The height of the tree: 0 for an empty tree. The height is at most 1.45 log2(size + 2). */
 	get height() {
-		return heightOf(this.root);
+		return height(this.record);
 	}
 	/**
 	* This function gives the leaf at an index, or `undefined` when the index is not in the tree. A negative index counts
 	* from the end, as `Array.prototype.at` does.
 	*/
 	at(index) {
-		index = indexOf(index, this.size);
-		return index === -1 ? void 0 : this.builder.leafAt(this.root, index);
+		return at(this.record, index);
 	}
 	/** This function gives the summary of the leaves from `start` to `end`, with `end` not included. */
 	summaryOf(start = 0, end = this.size) {
-		return this.slice(start, end).summary;
+		return summaryOf(this.record, start, end);
 	}
 	/** This function gives the tree of the leaves of this tree, then the leaves of `other`. The two trees must have the same spec. */
 	concat(other) {
-		const joined = this.builder.concat(this.root, this.treeOf(other));
-		return this.wrap(this.builder.seam(joined, this.size - 1));
+		return this.wrap(concat$1(this.record, recordOf(other)));
 	}
 	/** This function splits the tree into its first `index` leaves and the other leaves. */
 	splitAt(index) {
-		const [left, right] = this.builder.splitAt(this.root, clamp$1(index, this.size));
+		const [left, right] = splitAt(this.record, index);
 		return [this.wrap(left), this.wrap(right)];
 	}
 	/**
@@ -4360,7 +4159,7 @@ var SummaryTree = class SummaryTree {
 	* prefix. When no prefix satisfies it, the right tree is empty.
 	*/
 	split(predicate) {
-		const [left, right] = this.builder.splitBy(this.root, predicate, this.builder.spec.monoid.empty);
+		const [left, right] = split(this.record, predicate);
 		return [this.wrap(left), this.wrap(right)];
 	}
 	/**
@@ -4368,27 +4167,7 @@ var SummaryTree = class SummaryTree {
 	* nothing. It gives `undefined` when no prefix satisfies the predicate.
 	*/
 	search(predicate) {
-		const { combine } = this.builder.spec.monoid;
-		let node = this.root;
-		let acc = this.builder.spec.monoid.empty;
-		let index = 0;
-		while (node !== null) {
-			const throughLeft = node.left === null ? acc : combine(acc, node.left.summary);
-			if (node.left !== null && predicate(throughLeft)) {
-				node = node.left;
-				continue;
-			}
-			const through = combine(throughLeft, node.own);
-			if (predicate(through)) return {
-				index: index + sizeOf(node.left),
-				leaf: node.leaf,
-				before: throughLeft,
-				through
-			};
-			index += sizeOf(node.left) + 1;
-			acc = through;
-			node = node.right;
-		}
+		return search(this.record, predicate);
 	}
 	/**
 	* This function finds the leaf that holds a position of an additive key, and it calls no `combine`. The key must be
@@ -4401,80 +4180,26 @@ var SummaryTree = class SummaryTree {
 	* const at = rope.locate((s) => s.length, 1000);
 	*/
 	locate(key, target) {
-		if (!(target >= 0)) return void 0;
-		let node = this.root;
-		let index = 0;
-		let rest = target;
-		while (node !== null) {
-			if (node.left !== null) {
-				const left = key(node.left.summary);
-				if (rest < left) {
-					node = node.left;
-					continue;
-				}
-				rest -= left;
-				index += node.left.size;
-			}
-			const own = key(node.own);
-			if (rest < own) return {
-				index,
-				leaf: node.leaf,
-				offset: rest
-			};
-			rest -= own;
-			index += 1;
-			node = node.right;
-		}
+		return locate(this.record, key, target);
 	}
 	/** This function gives the tree of the leaves from `start` to `end`, with `end` not included. A negative index counts from the end. */
 	slice(start = 0, end = this.size) {
-		const from = clamp$1(start, this.size);
-		const to = clamp$1(end, this.size);
-		if (to <= from) return this.wrap(null);
-		const [, rest] = this.builder.splitAt(this.root, from);
-		const [middle] = this.builder.splitAt(rest, to - from);
-		return this.wrap(middle);
+		return this.wrap(slice(this.record, start, end));
 	}
 	/**
 	* This function removes `deleteCount` leaves at `start` and puts the leaves of `inserted` there, as
 	* `Array.prototype.splice` does. It gives the new tree, not the removed leaves.
 	*/
 	splice(start, deleteCount = this.size, inserted = []) {
-		const from = clamp$1(start, this.size);
-		const count = Math.max(0, Math.min(Number.isNaN(deleteCount) ? 0 : Math.trunc(deleteCount), this.size - from));
-		const builder = this.builder;
-		const leaves = inserted instanceof SummaryTree ? void 0 : [...inserted];
-		const added = leaves === void 0 ? inserted.size : leaves.length;
-		if (count === 0 && added === 0) return this;
-		let root = this.root;
-		if (leaves !== void 0 && count + added <= SMALL_EDIT) {
-			const replaced = Math.min(count, added);
-			if (count > 0 && added > count) {
-				for (let i = 0; i < count - 1; i++) root = builder.replaceAt(root, from + i, leaves[i], builder.spec.measure(leaves[i]));
-				root = builder.replaceSpan(root, from + count - 1, leaves.slice(count - 1));
-			} else for (let i = 0; i < added; i++) {
-				const leaf = leaves[i];
-				const own = builder.spec.measure(leaf);
-				root = i < replaced ? builder.replaceAt(root, from + i, leaf, own) : builder.insertAt(root, from + i, leaf, own);
-			}
-			for (let i = replaced; i < count; i++) root = builder.removeAt(root, from + added);
-		} else {
-			const middle = leaves === void 0 ? this.treeOf(inserted) : builder.build(leaves, 0, leaves.length);
-			const [left, rest] = builder.splitAt(root, from);
-			const [, right] = builder.splitAt(rest, count);
-			root = builder.concat(builder.concat(left, middle), right);
-		}
-		if (added > 0) root = builder.seam(root, from + added - 1);
-		return this.wrap(builder.seam(root, from - 1));
+		return this.wrap(splice(this.record, start, deleteCount, recordOf(inserted)));
 	}
 	/** This function puts the leaves of `inserted` before the leaf at `index`. */
 	insert(index, inserted) {
-		return this.splice(index, 0, inserted);
+		return this.wrap(insert(this.record, index, recordOf(inserted)));
 	}
 	/** This function removes the leaves from `start` to `end`, with `end` not included. */
 	remove(start, end = this.size) {
-		const from = clamp$1(start, this.size);
-		return this.splice(from, Math.max(0, clamp$1(end, this.size) - from));
+		return this.wrap(remove(this.record, start, end));
 	}
 	/**
 	* This function replaces the leaf at an index. A negative index counts from the end, as `Array.prototype.with` does.
@@ -4482,27 +4207,29 @@ var SummaryTree = class SummaryTree {
 	* `spec.merge`.
 	*/
 	set(index, leaf) {
-		const at = indexOf(index, this.size);
-		return at === -1 ? this : this.wrap(this.builder.replaceAt(this.root, at, leaf, this.builder.spec.measure(leaf)));
+		return this.wrap(set(this.record, index, leaf));
 	}
 	/** This function adds leaves after the last leaf. */
 	append(...leaves) {
-		return this.concat(leaves);
+		return this.wrap(append(this.record, ...leaves));
 	}
 	/** This function adds leaves before the first leaf. */
 	prepend(...leaves) {
-		const joined = this.builder.concat(this.treeOf(leaves), this.root);
-		return this.wrap(this.builder.seam(joined, leaves.length - 1));
+		return this.wrap(prepend(this.record, ...leaves));
 	}
 	/** This function gives the leaves in their order. */
 	[Symbol.iterator]() {
-		return walk(this.root);
+		return leaves(this.record);
 	}
 	/** This function gives the leaves in an array. */
 	toArray() {
-		return [...walk(this.root)];
+		return toArray$2(this.record);
 	}
 };
+/** This function gives the record of a tree, or the leaves when they are not a tree. */
+function recordOf(leaves) {
+	return leaves instanceof SummaryTree ? leaves.record : leaves;
+}
 /**
 * This function makes a persistent tree of leaves with a summary of each part. Use the same `spec` object for each
 * tree that `concat` or `splice` joins.
@@ -7065,6 +6792,60 @@ async function* asSettled(promises) {
 		yield settled;
 	}
 }
+// src/async/semaphore.ts
+/**
+* This function makes a semaphore with `permits` permits. The value is a whole number of 1 or more, or `Infinity`
+* for no bound. Another value throws a `RangeError`.
+*/
+function semaphore(permits) {
+	if (!(permits === Infinity || Number.isInteger(permits) && permits >= 1)) throw new RangeError(`A semaphore needs a whole number of permits of 1 or more, or Infinity: ${permits}`);
+	let held = 0;
+	const queue = [];
+	let head = 0;
+	const releaseOnce = () => {
+		let done = false;
+		return () => {
+			if (done) return;
+			done = true;
+			if (head < queue.length) {
+				const next = queue[head];
+				head += 1;
+				if (head > 64 && head * 2 > queue.length) {
+					queue.splice(0, head);
+					head = 0;
+				}
+				next();
+			} else held -= 1;
+		};
+	};
+	const acquire = () => {
+		if (held < permits) {
+			held += 1;
+			return Promise.resolve(releaseOnce());
+		}
+		return new Promise((resolve) => {
+			queue.push(() => resolve(releaseOnce()));
+		});
+	};
+	return {
+		permits,
+		get available() {
+			return permits - held;
+		},
+		get waiting() {
+			return queue.length - head;
+		},
+		acquire,
+		async run(task) {
+			const release = await acquire();
+			try {
+				return await task();
+			} finally {
+				release();
+			}
+		}
+	};
+}
 // src/fx/iter.ts
 /**
 * Functional operations for iterables (lazy sync transforms).
@@ -8128,6 +7909,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, 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 };
+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, semaphore, 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