@mark1russell7/collections 0.9.2 → 0.9.3

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.