@ac-kit/core 0.1.0

package/dist/iterable/range.js

@@ -0,0 +1,44 @@
+/**
+ * Yields the arithmetic progression from `start` towards `stop`, exclusive.
+ *
+ * Stands in for TC39's `Iterator.range`, and follows it: `start` is required,
+ * `stop` is exclusive, and a `stop` of `Infinity` (or `-Infinity` with a
+ * negative `step`) yields forever. Nothing is materialised.
+ *
+ * Each value is computed as `start + step * index` rather than accumulated, so
+ * a fractional `step` does not drift — `range(0, 1, 0.1)` ends at `0.9`, not at
+ * `0.9999999999999999`.
+ *
+ * Time complexity: O(1) to construct, O(1) per value.
+ *
+ * @param start The first value, inclusive. Must be finite.
+ * @param stop The bound to stop before, exclusive. May be infinite.
+ * @param step How much to advance by. Must be finite and non-zero; a negative
+ *   value counts down.
+ * @returns An iterator over the progression. Empty when `stop` is already on
+ *   the far side of `start`.
+ * @throws {RangeError} If `start` is not finite, `stop` is `NaN`, or `step` is
+ *   zero, `NaN` or infinite.
+ */
+export function* range(start, stop, step = 1) {
+    if (!Number.isFinite(start)) {
+        throw new RangeError("range start must be finite");
+    }
+    if (Number.isNaN(stop)) {
+        throw new RangeError("range stop must be a number");
+    }
+    if (!Number.isFinite(step) || step === 0) {
+        throw new RangeError("range step must be finite and non-zero");
+    }
+    if (step > 0) {
+        for (let index = 0; start + step * index < stop; index++) {
+            yield start + step * index;
+        }
+    }
+    else {
+        for (let index = 0; start + step * index > stop; index++) {
+            yield start + step * index;
+        }
+    }
+}
+//# sourceMappingURL=range.js.map

package/dist/iterable/range.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"range.js","sourceRoot":"","sources":["../../src/iterable/range.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,SAAS,CAAC,CAAC,KAAK,CACrB,KAAa,EACb,IAAY,EACZ,IAAI,GAAG,CAAC;IAER,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QAC7B,MAAM,IAAI,UAAU,CAAC,4BAA4B,CAAC,CAAC;IACpD,CAAC;IACD,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;QACxB,MAAM,IAAI,UAAU,CAAC,6BAA6B,CAAC,CAAC;IACrD,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,IAAI,KAAK,CAAC,EAAE,CAAC;QAC1C,MAAM,IAAI,UAAU,CAAC,wCAAwC,CAAC,CAAC;IAChE,CAAC;IAED,IAAI,IAAI,GAAG,CAAC,EAAE,CAAC;QACd,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,IAAI,GAAG,KAAK,GAAG,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;YAC1D,MAAM,KAAK,GAAG,IAAI,GAAG,KAAK,CAAC;QAC5B,CAAC;IACF,CAAC;SAAM,CAAC;QACP,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,IAAI,GAAG,KAAK,GAAG,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC;YAC1D,MAAM,KAAK,GAAG,IAAI,GAAG,KAAK,CAAC;QAC5B,CAAC;IACF,CAAC;AACF,CAAC"}

package/dist/iterable/repeat-each.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Yields each element `times` times in a row before moving to the next.
+ *
+ * Not `cycle`, which repeats the whole sequence rather than each element:
+ * `repeatEach([1, 2], 2)` yields `1, 1, 2, 2` where `cycle([1, 2], 2)` yields
+ * `1, 2, 1, 2`.
+ *
+ * Time complexity: O(n × times). Nothing is buffered.
+ *
+ * @param iterable The input iterable.
+ * @param times How many times to repeat each element. Must be a non-negative
+ *   integer; zero yields nothing.
+ * @returns An iterator over the repeated elements.
+ * @throws {RangeError} If `times` is not a non-negative integer.
+ */
+export declare function repeatEach<T>(iterable: Iterable<T>, times: number): IterableIterator<T>;
+//# sourceMappingURL=repeat-each.d.ts.map

package/dist/iterable/repeat-each.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repeat-each.d.ts","sourceRoot":"","sources":["../../src/iterable/repeat-each.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,wBAAiB,UAAU,CAAC,CAAC,EAC5B,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EACrB,KAAK,EAAE,MAAM,GACX,gBAAgB,CAAC,CAAC,CAAC,CAcrB"}

package/dist/iterable/repeat-each.js

@@ -0,0 +1,29 @@
+/**
+ * Yields each element `times` times in a row before moving to the next.
+ *
+ * Not `cycle`, which repeats the whole sequence rather than each element:
+ * `repeatEach([1, 2], 2)` yields `1, 1, 2, 2` where `cycle([1, 2], 2)` yields
+ * `1, 2, 1, 2`.
+ *
+ * Time complexity: O(n × times). Nothing is buffered.
+ *
+ * @param iterable The input iterable.
+ * @param times How many times to repeat each element. Must be a non-negative
+ *   integer; zero yields nothing.
+ * @returns An iterator over the repeated elements.
+ * @throws {RangeError} If `times` is not a non-negative integer.
+ */
+export function* repeatEach(iterable, times) {
+    if (!Number.isInteger(times) || times < 0) {
+        throw new RangeError("repeatEach times must be a non-negative integer");
+    }
+    if (times === 0) {
+        return;
+    }
+    for (const item of iterable) {
+        for (let repeat = 0; repeat < times; repeat++) {
+            yield item;
+        }
+    }
+}
+//# sourceMappingURL=repeat-each.js.map

package/dist/iterable/repeat-each.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"repeat-each.js","sourceRoot":"","sources":["../../src/iterable/repeat-each.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,SAAS,CAAC,CAAC,UAAU,CAC1B,QAAqB,EACrB,KAAa;IAEb,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;QAC3C,MAAM,IAAI,UAAU,CAAC,iDAAiD,CAAC,CAAC;IACzE,CAAC;IAED,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;QACjB,OAAO;IACR,CAAC;IAED,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC7B,KAAK,IAAI,MAAM,GAAG,CAAC,EAAE,MAAM,GAAG,KAAK,EAAE,MAAM,EAAE,EAAE,CAAC;YAC/C,MAAM,IAAI,CAAC;QACZ,CAAC;IACF,CAAC;AACF,CAAC"}

package/dist/iterable/take-while-inclusive.d.ts

@@ -0,0 +1,19 @@
+import type { Predicate } from "../types/callable.js";
+/**
+ * Yields elements for as long as `predicate` holds, _including_ the first one
+ * that fails it.
+ *
+ * One of the two cases `takeWhile` gets wrong: it consumes the failing element
+ * and discards it, which loses a terminator a caller needs — a delimiter, a
+ * sentinel, the record that closed a run. Use `beforeAndAfter` when both sides
+ * are wanted.
+ *
+ * Time complexity: O(1) per element, over the prefix only.
+ *
+ * @param iterable The input iterable.
+ * @param predicate Receives each element and its zero-based index. The first
+ *   element it rejects is yielded, and iteration stops after it.
+ * @returns An iterator over the prefix, terminator included.
+ */
+export declare function takeWhileInclusive<T>(iterable: Iterable<T>, predicate: Predicate<[T, number]>): IterableIterator<T>;
+//# sourceMappingURL=take-while-inclusive.d.ts.map

package/dist/iterable/take-while-inclusive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"take-while-inclusive.d.ts","sourceRoot":"","sources":["../../src/iterable/take-while-inclusive.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEtD;;;;;;;;;;;;;;;GAeG;AACH,wBAAiB,kBAAkB,CAAC,CAAC,EACpC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EACrB,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,GAC/B,gBAAgB,CAAC,CAAC,CAAC,CAUrB"}

package/dist/iterable/take-while-inclusive.js

@@ -0,0 +1,26 @@
+/**
+ * Yields elements for as long as `predicate` holds, _including_ the first one
+ * that fails it.
+ *
+ * One of the two cases `takeWhile` gets wrong: it consumes the failing element
+ * and discards it, which loses a terminator a caller needs — a delimiter, a
+ * sentinel, the record that closed a run. Use `beforeAndAfter` when both sides
+ * are wanted.
+ *
+ * Time complexity: O(1) per element, over the prefix only.
+ *
+ * @param iterable The input iterable.
+ * @param predicate Receives each element and its zero-based index. The first
+ *   element it rejects is yielded, and iteration stops after it.
+ * @returns An iterator over the prefix, terminator included.
+ */
+export function* takeWhileInclusive(iterable, predicate) {
+    let index = 0;
+    for (const item of iterable) {
+        yield item;
+        if (!predicate(item, index++)) {
+            return;
+        }
+    }
+}
+//# sourceMappingURL=take-while-inclusive.js.map

package/dist/iterable/take-while-inclusive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"take-while-inclusive.js","sourceRoot":"","sources":["../../src/iterable/take-while-inclusive.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,SAAS,CAAC,CAAC,kBAAkB,CAClC,QAAqB,EACrB,SAAiC;IAEjC,IAAI,KAAK,GAAG,CAAC,CAAC;IAEd,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC7B,MAAM,IAAI,CAAC;QAEX,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC;YAC/B,OAAO;QACR,CAAC;IACF,CAAC;AACF,CAAC"}

package/dist/iterable/take-while.d.ts

@@ -0,0 +1,18 @@
+import type { Predicate } from "../types/callable.js";
+/**
+ * Yields elements from the start for as long as `predicate` holds, stopping at
+ * the first one it rejects.
+ *
+ * The rejecting element is consumed but not yielded, and nothing after it is
+ * pulled — use `takeWhileInclusive` to keep it, or `beforeAndAfter` to keep
+ * both sides.
+ *
+ * Time complexity: O(1) per element, over the prefix only.
+ *
+ * @param iterable The input iterable.
+ * @param predicate Receives each element and its zero-based index. Yielding
+ *   stops the first time it returns `false`.
+ * @returns An iterator over the leading elements that satisfy `predicate`.
+ */
+export declare function takeWhile<T>(iterable: Iterable<T>, predicate: Predicate<[T, number]>): IterableIterator<T>;
+//# sourceMappingURL=take-while.d.ts.map

package/dist/iterable/take-while.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"take-while.d.ts","sourceRoot":"","sources":["../../src/iterable/take-while.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEtD;;;;;;;;;;;;;;GAcG;AACH,wBAAiB,SAAS,CAAC,CAAC,EAC3B,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EACrB,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,GAC/B,gBAAgB,CAAC,CAAC,CAAC,CAUrB"}

package/dist/iterable/take-while.js

@@ -0,0 +1,25 @@
+/**
+ * Yields elements from the start for as long as `predicate` holds, stopping at
+ * the first one it rejects.
+ *
+ * The rejecting element is consumed but not yielded, and nothing after it is
+ * pulled — use `takeWhileInclusive` to keep it, or `beforeAndAfter` to keep
+ * both sides.
+ *
+ * Time complexity: O(1) per element, over the prefix only.
+ *
+ * @param iterable The input iterable.
+ * @param predicate Receives each element and its zero-based index. Yielding
+ *   stops the first time it returns `false`.
+ * @returns An iterator over the leading elements that satisfy `predicate`.
+ */
+export function* takeWhile(iterable, predicate) {
+    let index = 0;
+    for (const item of iterable) {
+        if (!predicate(item, index++)) {
+            return;
+        }
+        yield item;
+    }
+}
+//# sourceMappingURL=take-while.js.map

package/dist/iterable/take-while.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"take-while.js","sourceRoot":"","sources":["../../src/iterable/take-while.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,MAAM,SAAS,CAAC,CAAC,SAAS,CACzB,QAAqB,EACrB,SAAiC;IAEjC,IAAI,KAAK,GAAG,CAAC,CAAC;IAEd,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC7B,IAAI,CAAC,SAAS,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC;YAC/B,OAAO;QACR,CAAC;QAED,MAAM,IAAI,CAAC;IACZ,CAAC;AACF,CAAC"}

package/dist/iterable/take.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Yields at most the first `count` elements, then stops.
+ *
+ * What `Array.prototype.slice(0, count)` does for an array, without
+ * materialising, and without needing to know the length up front. The source is
+ * closed as soon as the quota is met, so taking from an infinite iterable
+ * terminates.
+ *
+ * Time complexity: O(count).
+ *
+ * @param iterable The input iterable.
+ * @param count How many elements to yield. Must be a non-negative integer; zero
+ *   yields nothing and consumes nothing.
+ * @returns An iterator over the leading elements.
+ * @throws {RangeError} If `count` is not a non-negative integer.
+ */
+export declare function take<T>(iterable: Iterable<T>, count: number): IterableIterator<T>;
+//# sourceMappingURL=take.d.ts.map

package/dist/iterable/take.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"take.d.ts","sourceRoot":"","sources":["../../src/iterable/take.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAiB,IAAI,CAAC,CAAC,EACtB,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EACrB,KAAK,EAAE,MAAM,GACX,gBAAgB,CAAC,CAAC,CAAC,CAkBrB"}

package/dist/iterable/take.js

@@ -0,0 +1,32 @@
+/**
+ * Yields at most the first `count` elements, then stops.
+ *
+ * What `Array.prototype.slice(0, count)` does for an array, without
+ * materialising, and without needing to know the length up front. The source is
+ * closed as soon as the quota is met, so taking from an infinite iterable
+ * terminates.
+ *
+ * Time complexity: O(count).
+ *
+ * @param iterable The input iterable.
+ * @param count How many elements to yield. Must be a non-negative integer; zero
+ *   yields nothing and consumes nothing.
+ * @returns An iterator over the leading elements.
+ * @throws {RangeError} If `count` is not a non-negative integer.
+ */
+export function* take(iterable, count) {
+    if (!Number.isInteger(count) || count < 0) {
+        throw new RangeError("take count must be a non-negative integer");
+    }
+    if (count === 0) {
+        return;
+    }
+    let taken = 0;
+    for (const item of iterable) {
+        yield item;
+        if (++taken >= count) {
+            return;
+        }
+    }
+}
+//# sourceMappingURL=take.js.map

package/dist/iterable/take.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"take.js","sourceRoot":"","sources":["../../src/iterable/take.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,SAAS,CAAC,CAAC,IAAI,CACpB,QAAqB,EACrB,KAAa;IAEb,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;QAC3C,MAAM,IAAI,UAAU,CAAC,2CAA2C,CAAC,CAAC;IACnE,CAAC;IAED,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;QACjB,OAAO;IACR,CAAC;IAED,IAAI,KAAK,GAAG,CAAC,CAAC;IAEd,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC7B,MAAM,IAAI,CAAC;QAEX,IAAI,EAAE,KAAK,IAAI,KAAK,EAAE,CAAC;YACtB,OAAO;QACR,CAAC;IACF,CAAC;AACF,CAAC"}

package/dist/iterable/tap.d.ts

@@ -0,0 +1,17 @@
+import type { Callable } from "../types/callable.js";
+/**
+ * Yields the elements unchanged, running `onItem` for each as it passes.
+ *
+ * How a lazy pipeline is instrumented: the side effect runs when an element is
+ * pulled, not when the pipeline is built, so nothing is observed that the
+ * consumer did not ask for.
+ *
+ * Time complexity: O(1) per element, plus whatever `onItem` costs.
+ *
+ * @param iterable The input iterable.
+ * @param onItem Receives each element and its zero-based index. Its return
+ *   value is ignored.
+ * @returns An iterator over the unchanged elements.
+ */
+export declare function tap<T>(iterable: Iterable<T>, onItem: Callable<[T, number]>): IterableIterator<T>;
+//# sourceMappingURL=tap.d.ts.map

package/dist/iterable/tap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tap.d.ts","sourceRoot":"","sources":["../../src/iterable/tap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAErD;;;;;;;;;;;;;GAaG;AACH,wBAAiB,GAAG,CAAC,CAAC,EACrB,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EACrB,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,GAC3B,gBAAgB,CAAC,CAAC,CAAC,CAOrB"}

package/dist/iterable/tap.js

@@ -0,0 +1,22 @@
+/**
+ * Yields the elements unchanged, running `onItem` for each as it passes.
+ *
+ * How a lazy pipeline is instrumented: the side effect runs when an element is
+ * pulled, not when the pipeline is built, so nothing is observed that the
+ * consumer did not ask for.
+ *
+ * Time complexity: O(1) per element, plus whatever `onItem` costs.
+ *
+ * @param iterable The input iterable.
+ * @param onItem Receives each element and its zero-based index. Its return
+ *   value is ignored.
+ * @returns An iterator over the unchanged elements.
+ */
+export function* tap(iterable, onItem) {
+    let index = 0;
+    for (const item of iterable) {
+        onItem(item, index++);
+        yield item;
+    }
+}
+//# sourceMappingURL=tap.js.map

package/dist/iterable/tap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tap.js","sourceRoot":"","sources":["../../src/iterable/tap.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,MAAM,SAAS,CAAC,CAAC,GAAG,CACnB,QAAqB,EACrB,MAA6B;IAE7B,IAAI,KAAK,GAAG,CAAC,CAAC;IAEd,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC7B,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;QACtB,MAAM,IAAI,CAAC;IACZ,CAAC;AACF,CAAC"}

package/dist/iterable/tee.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Fans one iterable out to `count` independent iterators over the same
+ * elements.
+ *
+ * An iterator cannot be restarted, so anything one branch has read that another
+ * has not yet reached is buffered — the span between the slowest and the
+ * fastest consumer, and nothing more. Consumers read at their own pace; a
+ * branch that is never advanced pins the buffer at its position, so an
+ * abandoned branch should be left out of `count` rather than ignored.
+ *
+ * Reading the branches in lockstep keeps the buffer at one element. Draining
+ * one branch fully before starting the next buffers the whole source.
+ *
+ * Time complexity: O(1) amortised per element per branch. Memory: O(span).
+ *
+ * @param iterable The iterable to fan out.
+ * @param count How many branches to produce. Must be a non-negative integer.
+ * @returns One iterator per branch, each yielding every element of the source.
+ * @throws {RangeError} If `count` is not a non-negative integer.
+ */
+export declare function tee<T>(iterable: Iterable<T>, count?: number): IterableIterator<T>[];
+//# sourceMappingURL=tee.d.ts.map

package/dist/iterable/tee.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tee.d.ts","sourceRoot":"","sources":["../../src/iterable/tee.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,GAAG,CAAC,CAAC,EACpB,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EACrB,KAAK,SAAI,GACP,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAqDvB"}

package/dist/iterable/tee.js

@@ -0,0 +1,64 @@
+/**
+ * Fans one iterable out to `count` independent iterators over the same
+ * elements.
+ *
+ * An iterator cannot be restarted, so anything one branch has read that another
+ * has not yet reached is buffered — the span between the slowest and the
+ * fastest consumer, and nothing more. Consumers read at their own pace; a
+ * branch that is never advanced pins the buffer at its position, so an
+ * abandoned branch should be left out of `count` rather than ignored.
+ *
+ * Reading the branches in lockstep keeps the buffer at one element. Draining
+ * one branch fully before starting the next buffers the whole source.
+ *
+ * Time complexity: O(1) amortised per element per branch. Memory: O(span).
+ *
+ * @param iterable The iterable to fan out.
+ * @param count How many branches to produce. Must be a non-negative integer.
+ * @returns One iterator per branch, each yielding every element of the source.
+ * @throws {RangeError} If `count` is not a non-negative integer.
+ */
+export function tee(iterable, count = 2) {
+    if (!Number.isInteger(count) || count < 0) {
+        throw new RangeError("tee count must be a non-negative integer");
+    }
+    const iterator = iterable[Symbol.iterator]();
+    const buffer = [];
+    const cursors = Array.from({ length: count }).fill(0);
+    let bufferStart = 0;
+    let exhausted = false;
+    function* branch(id) {
+        while (true) {
+            const wanted = cursors[id];
+            if (wanted === bufferStart + buffer.length) {
+                if (exhausted) {
+                    return;
+                }
+                const result = iterator.next();
+                if (result.done === true) {
+                    exhausted = true;
+                    return;
+                }
+                buffer.push(result.value);
+            }
+            const value = buffer[wanted - bufferStart];
+            cursors[id] = wanted + 1;
+            let slowest = Number.POSITIVE_INFINITY;
+            for (let other = 0; other < cursors.length; other++) {
+                if (cursors[other] < slowest) {
+                    slowest = cursors[other];
+                }
+            }
+            // Compact only once the dead prefix is worth the copy, which keeps the
+            // per-element cost amortised O(1) rather than O(span).
+            const dead = slowest - bufferStart;
+            if (dead > 0 && dead * 2 >= buffer.length) {
+                buffer.splice(0, dead);
+                bufferStart = slowest;
+            }
+            yield value;
+        }
+    }
+    return Array.from({ length: count }, (_unused, id) => branch(id));
+}
+//# sourceMappingURL=tee.js.map

package/dist/iterable/tee.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tee.js","sourceRoot":"","sources":["../../src/iterable/tee.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,GAAG,CAClB,QAAqB,EACrB,KAAK,GAAG,CAAC;IAET,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;QAC3C,MAAM,IAAI,UAAU,CAAC,0CAA0C,CAAC,CAAC;IAClE,CAAC;IAED,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;IAC7C,MAAM,MAAM,GAAQ,EAAE,CAAC;IACvB,MAAM,OAAO,GAAG,KAAK,CAAC,IAAI,CAAS,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAC9D,IAAI,WAAW,GAAG,CAAC,CAAC;IACpB,IAAI,SAAS,GAAG,KAAK,CAAC;IAEtB,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAU;QAC1B,OAAO,IAAI,EAAE,CAAC;YACb,MAAM,MAAM,GAAG,OAAO,CAAC,EAAE,CAAE,CAAC;YAE5B,IAAI,MAAM,KAAK,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC;gBAC5C,IAAI,SAAS,EAAE,CAAC;oBACf,OAAO;gBACR,CAAC;gBAED,MAAM,MAAM,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC;gBAE/B,IAAI,MAAM,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;oBAC1B,SAAS,GAAG,IAAI,CAAC;oBACjB,OAAO;gBACR,CAAC;gBAED,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;YAC3B,CAAC;YAED,MAAM,KAAK,GAAG,MAAM,CAAC,MAAM,GAAG,WAAW,CAAE,CAAC;YAC5C,OAAO,CAAC,EAAE,CAAC,GAAG,MAAM,GAAG,CAAC,CAAC;YAEzB,IAAI,OAAO,GAAG,MAAM,CAAC,iBAAiB,CAAC;YACvC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,OAAO,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;gBACrD,IAAI,OAAO,CAAC,KAAK,CAAE,GAAG,OAAO,EAAE,CAAC;oBAC/B,OAAO,GAAG,OAAO,CAAC,KAAK,CAAE,CAAC;gBAC3B,CAAC;YACF,CAAC;YAED,uEAAuE;YACvE,uDAAuD;YACvD,MAAM,IAAI,GAAG,OAAO,GAAG,WAAW,CAAC;YACnC,IAAI,IAAI,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC,IAAI,MAAM,CAAC,MAAM,EAAE,CAAC;gBAC3C,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;gBACvB,WAAW,GAAG,OAAO,CAAC;YACvB,CAAC;YAED,MAAM,KAAK,CAAC;QACb,CAAC;IACF,CAAC;IAED,OAAO,KAAK,CAAC,IAAI,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC,OAAO,EAAE,EAAE,EAAE,EAAE,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC;AACnE,CAAC"}

package/dist/iterable/trim-while.d.ts

@@ -0,0 +1,31 @@
+import type { Predicate } from "../types/callable.js";
+/**
+ * Yields the elements with any trailing run satisfying `predicate` removed.
+ *
+ * The generic form of `String.prototype.trimEnd`. An element is only known to
+ * be trailing once something that fails `predicate` follows it, so a run of
+ * candidates is held back until then — a source ending in a long run of matches
+ * buffers that whole run.
+ *
+ * Time complexity: O(n). Memory: O(longest matching run).
+ *
+ * @param iterable The input iterable.
+ * @param predicate Decides whether an element may be trimmed.
+ * @returns An iterator over the elements, trailing matches removed.
+ */
+export declare function trimEndWhile<T>(iterable: Iterable<T>, predicate: Predicate<[T]>): IterableIterator<T>;
+/**
+ * Yields the elements with any leading _and_ trailing run satisfying
+ * `predicate` removed.
+ *
+ * The generic form of `String.prototype.trim`. The start-only case is
+ * `dropWhile`, which this composes rather than duplicating.
+ *
+ * Time complexity: O(n). Memory: O(longest matching run), as `trimEndWhile`.
+ *
+ * @param iterable The input iterable.
+ * @param predicate Decides whether an element may be trimmed.
+ * @returns An iterator over the elements, leading and trailing matches removed.
+ */
+export declare function trimWhile<T>(iterable: Iterable<T>, predicate: Predicate<[T]>): IterableIterator<T>;
+//# sourceMappingURL=trim-while.d.ts.map

package/dist/iterable/trim-while.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trim-while.d.ts","sourceRoot":"","sources":["../../src/iterable/trim-while.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAGtD;;;;;;;;;;;;;GAaG;AACH,wBAAiB,YAAY,CAAC,CAAC,EAC9B,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EACrB,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,GACvB,gBAAgB,CAAC,CAAC,CAAC,CAarB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,CAAC,EAC1B,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EACrB,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,GACvB,gBAAgB,CAAC,CAAC,CAAC,CAKrB"}

package/dist/iterable/trim-while.js

@@ -0,0 +1,44 @@
+import { dropWhile } from "./drop-while.js";
+/**
+ * Yields the elements with any trailing run satisfying `predicate` removed.
+ *
+ * The generic form of `String.prototype.trimEnd`. An element is only known to
+ * be trailing once something that fails `predicate` follows it, so a run of
+ * candidates is held back until then — a source ending in a long run of matches
+ * buffers that whole run.
+ *
+ * Time complexity: O(n). Memory: O(longest matching run).
+ *
+ * @param iterable The input iterable.
+ * @param predicate Decides whether an element may be trimmed.
+ * @returns An iterator over the elements, trailing matches removed.
+ */
+export function* trimEndWhile(iterable, predicate) {
+    const pending = [];
+    for (const item of iterable) {
+        if (predicate(item)) {
+            pending.push(item);
+            continue;
+        }
+        yield* pending;
+        pending.length = 0;
+        yield item;
+    }
+}
+/**
+ * Yields the elements with any leading _and_ trailing run satisfying
+ * `predicate` removed.
+ *
+ * The generic form of `String.prototype.trim`. The start-only case is
+ * `dropWhile`, which this composes rather than duplicating.
+ *
+ * Time complexity: O(n). Memory: O(longest matching run), as `trimEndWhile`.
+ *
+ * @param iterable The input iterable.
+ * @param predicate Decides whether an element may be trimmed.
+ * @returns An iterator over the elements, leading and trailing matches removed.
+ */
+export function trimWhile(iterable, predicate) {
+    return trimEndWhile(dropWhile(iterable, (item) => predicate(item)), predicate);
+}
+//# sourceMappingURL=trim-while.js.map

package/dist/iterable/trim-while.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"trim-while.js","sourceRoot":"","sources":["../../src/iterable/trim-while.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;;;;;;;;;;;;GAaG;AACH,MAAM,SAAS,CAAC,CAAC,YAAY,CAC5B,QAAqB,EACrB,SAAyB;IAEzB,MAAM,OAAO,GAAQ,EAAE,CAAC;IAExB,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC7B,IAAI,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC;YACrB,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;YACnB,SAAS;QACV,CAAC;QAED,KAAK,CAAC,CAAC,OAAO,CAAC;QACf,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC;QACnB,MAAM,IAAI,CAAC;IACZ,CAAC;AACF,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,SAAS,CACxB,QAAqB,EACrB,SAAyB;IAEzB,OAAO,YAAY,CAClB,SAAS,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,EAC9C,SAAS,CACT,CAAC;AACH,CAAC"}

package/dist/iterable/unfold.d.ts

@@ -0,0 +1,19 @@
+import type { Callable } from "../types/callable.js";
+/**
+ * Generates a sequence from a seed, one step at a time — the dual of `reduce`,
+ * which collapses a sequence into a single value.
+ *
+ * `next` returns the value to yield paired with the state to carry forward, or
+ * `undefined` to stop. `range` is one instance of this shape, and is kept
+ * separate because a counter deserves a name rather than a closure.
+ *
+ * Time complexity: O(1) per element, plus whatever `next` costs. Nothing is
+ * buffered, and a `next` that never stops yields forever.
+ *
+ * @param seed The initial state.
+ * @param next Receives the current state and returns `[value, nextState]`, or
+ *   `undefined` to end the sequence.
+ * @returns An iterator over the generated values.
+ */
+export declare function unfold<S, T>(seed: S, next: Callable<[S], readonly [value: T, state: S] | undefined>): IterableIterator<T>;
+//# sourceMappingURL=unfold.d.ts.map

package/dist/iterable/unfold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unfold.d.ts","sourceRoot":"","sources":["../../src/iterable/unfold.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAErD;;;;;;;;;;;;;;;GAeG;AACH,wBAAiB,MAAM,CAAC,CAAC,EAAE,CAAC,EAC3B,IAAI,EAAE,CAAC,EACP,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,GAAG,SAAS,CAAC,GAC5D,gBAAgB,CAAC,CAAC,CAAC,CAarB"}

package/dist/iterable/unfold.js

@@ -0,0 +1,28 @@
+/**
+ * Generates a sequence from a seed, one step at a time — the dual of `reduce`,
+ * which collapses a sequence into a single value.
+ *
+ * `next` returns the value to yield paired with the state to carry forward, or
+ * `undefined` to stop. `range` is one instance of this shape, and is kept
+ * separate because a counter deserves a name rather than a closure.
+ *
+ * Time complexity: O(1) per element, plus whatever `next` costs. Nothing is
+ * buffered, and a `next` that never stops yields forever.
+ *
+ * @param seed The initial state.
+ * @param next Receives the current state and returns `[value, nextState]`, or
+ *   `undefined` to end the sequence.
+ * @returns An iterator over the generated values.
+ */
+export function* unfold(seed, next) {
+    let state = seed;
+    while (true) {
+        const step = next(state);
+        if (step === undefined) {
+            return;
+        }
+        yield step[0];
+        state = step[1];
+    }
+}
+//# sourceMappingURL=unfold.js.map

package/dist/iterable/unfold.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unfold.js","sourceRoot":"","sources":["../../src/iterable/unfold.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,SAAS,CAAC,CAAC,MAAM,CACtB,IAAO,EACP,IAA8D;IAE9D,IAAI,KAAK,GAAG,IAAI,CAAC;IAEjB,OAAO,IAAI,EAAE,CAAC;QACb,MAAM,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC;QAEzB,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACxB,OAAO;QACR,CAAC;QAED,MAAM,IAAI,CAAC,CAAC,CAAC,CAAC;QACd,KAAK,GAAG,IAAI,CAAC,CAAC,CAAC,CAAC;IACjB,CAAC;AACF,CAAC"}

package/dist/iterable/unzip.d.ts

@@ -0,0 +1,22 @@
+/** One array per tuple position, holding that position's values. */
+export type Unzipped<T extends readonly unknown[]> = {
+    [K in keyof T]: T[K][];
+};
+/**
+ * Splits an iterable of tuples into one array per tuple position — the inverse
+ * of `zip`.
+ *
+ * Eager, unlike most of this directory: a column cannot be produced without
+ * reading every row.
+ *
+ * Ragged input is tolerated. The result has as many columns as the longest
+ * tuple seen, and a tuple shorter than that contributes nothing to the columns
+ * it does not reach, so those columns end up shorter rather than padded.
+ *
+ * Time complexity: O(n × width).
+ *
+ * @param tuples The tuples to split.
+ * @returns The columns. Empty when the input is.
+ */
+export declare function unzip<const T extends readonly unknown[]>(tuples: Iterable<T>): Unzipped<T>;
+//# sourceMappingURL=unzip.d.ts.map

package/dist/iterable/unzip.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unzip.d.ts","sourceRoot":"","sources":["../../src/iterable/unzip.ts"],"names":[],"mappings":"AAAA,oEAAoE;AACpE,MAAM,MAAM,QAAQ,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,IAAI;KACnD,CAAC,IAAI,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,EAAE;CACtB,CAAC;AAEF;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,KAAK,CAAC,KAAK,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,EACvD,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,GACjB,QAAQ,CAAC,CAAC,CAAC,CAYb"}

package/dist/iterable/unzip.js

@@ -0,0 +1,28 @@
+/**
+ * Splits an iterable of tuples into one array per tuple position — the inverse
+ * of `zip`.
+ *
+ * Eager, unlike most of this directory: a column cannot be produced without
+ * reading every row.
+ *
+ * Ragged input is tolerated. The result has as many columns as the longest
+ * tuple seen, and a tuple shorter than that contributes nothing to the columns
+ * it does not reach, so those columns end up shorter rather than padded.
+ *
+ * Time complexity: O(n × width).
+ *
+ * @param tuples The tuples to split.
+ * @returns The columns. Empty when the input is.
+ */
+export function unzip(tuples) {
+    const columns = [];
+    for (const tuple of tuples) {
+        for (let index = 0; index < tuple.length; index++) {
+            (columns[index] ??= []).push(tuple[index]);
+        }
+    }
+    // Safe: one column was appended per tuple position, so the array has exactly
+    // the arity and element types `Unzipped<T>` describes.
+    return columns;
+}
+//# sourceMappingURL=unzip.js.map

package/dist/iterable/unzip.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unzip.js","sourceRoot":"","sources":["../../src/iterable/unzip.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,KAAK,CACpB,MAAmB;IAEnB,MAAM,OAAO,GAAgB,EAAE,CAAC;IAEhC,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC5B,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;YACnD,CAAC,OAAO,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;QAC5C,CAAC;IACF,CAAC;IAED,6EAA6E;IAC7E,uDAAuD;IACvD,OAAO,OAAsB,CAAC;AAC/B,CAAC"}