@ac-kit/core 0.1.0

package/dist/iterable/async/pad.d.ts

@@ -0,0 +1,17 @@
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+/**
+ * Yields the elements, then `fill` as many times as needed to reach `length`.
+ *
+ * The async counterpart of `pad`. An input already at or beyond `length` passes
+ * through unchanged — this only ever adds, never truncates.
+ *
+ * Time complexity: O(max(n, length)).
+ *
+ * @param iterable The input iterable, sync or async.
+ * @param length The width to pad up to. Must be a non-negative integer.
+ * @param fill The value to pad with.
+ * @returns An iterator over the elements followed by the padding.
+ * @throws {RangeError} If `length` is not a non-negative integer.
+ */
+export declare function padAsync<T, F>(iterable: MaybeAsyncIterable<T>, length: number, fill: F): AsyncIterableIterator<T | F>;
+//# sourceMappingURL=pad.d.ts.map

package/dist/iterable/async/pad.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pad.d.ts","sourceRoot":"","sources":["../../../src/iterable/async/pad.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE;;;;;;;;;;;;;GAaG;AACH,wBAAuB,QAAQ,CAAC,CAAC,EAAE,CAAC,EACnC,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC/B,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,CAAC,GACL,qBAAqB,CAAC,CAAC,GAAG,CAAC,CAAC,CAe9B"}

package/dist/iterable/async/pad.js

@@ -0,0 +1,28 @@
+/**
+ * Yields the elements, then `fill` as many times as needed to reach `length`.
+ *
+ * The async counterpart of `pad`. An input already at or beyond `length` passes
+ * through unchanged — this only ever adds, never truncates.
+ *
+ * Time complexity: O(max(n, length)).
+ *
+ * @param iterable The input iterable, sync or async.
+ * @param length The width to pad up to. Must be a non-negative integer.
+ * @param fill The value to pad with.
+ * @returns An iterator over the elements followed by the padding.
+ * @throws {RangeError} If `length` is not a non-negative integer.
+ */
+export async function* padAsync(iterable, length, fill) {
+    if (!Number.isInteger(length) || length < 0) {
+        throw new RangeError("padAsync length must be a non-negative integer");
+    }
+    let yielded = 0;
+    for await (const item of iterable) {
+        yielded++;
+        yield item;
+    }
+    for (; yielded < length; yielded++) {
+        yield fill;
+    }
+}
+//# sourceMappingURL=pad.js.map

package/dist/iterable/async/pad.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pad.js","sourceRoot":"","sources":["../../../src/iterable/async/pad.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,KAAK,SAAS,CAAC,CAAC,QAAQ,CAC9B,QAA+B,EAC/B,MAAc,EACd,IAAO;IAEP,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,MAAM,GAAG,CAAC,EAAE,CAAC;QAC7C,MAAM,IAAI,UAAU,CAAC,gDAAgD,CAAC,CAAC;IACxE,CAAC;IAED,IAAI,OAAO,GAAG,CAAC,CAAC;IAEhB,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QACnC,OAAO,EAAE,CAAC;QACV,MAAM,IAAI,CAAC;IACZ,CAAC;IAED,OAAO,OAAO,GAAG,MAAM,EAAE,OAAO,EAAE,EAAE,CAAC;QACpC,MAAM,IAAI,CAAC;IACZ,CAAC;AACF,CAAC"}

package/dist/iterable/async/pairwise.d.ts

@@ -0,0 +1,15 @@
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+/**
+ * Yields each consecutive overlapping pair of elements.
+ *
+ * The async counterpart of `pairwise`. An input of fewer than two elements
+ * yields nothing.
+ *
+ * Time complexity: O(n), allocating one tuple per pair.
+ *
+ * @param iterable The input iterable, sync or async.
+ * @returns An iterator over the pairs, each holding an element and the one
+ *   after it.
+ */
+export declare function pairwiseAsync<T>(iterable: MaybeAsyncIterable<T>): AsyncIterableIterator<[T, T]>;
+//# sourceMappingURL=pairwise.d.ts.map

package/dist/iterable/async/pairwise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pairwise.d.ts","sourceRoot":"","sources":["../../../src/iterable/async/pairwise.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE;;;;;;;;;;;GAWG;AACH,wBAAuB,aAAa,CAAC,CAAC,EACrC,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAC7B,qBAAqB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAY/B"}

package/dist/iterable/async/pairwise.js

@@ -0,0 +1,24 @@
+/**
+ * Yields each consecutive overlapping pair of elements.
+ *
+ * The async counterpart of `pairwise`. An input of fewer than two elements
+ * yields nothing.
+ *
+ * Time complexity: O(n), allocating one tuple per pair.
+ *
+ * @param iterable The input iterable, sync or async.
+ * @returns An iterator over the pairs, each holding an element and the one
+ *   after it.
+ */
+export async function* pairwiseAsync(iterable) {
+    let previous;
+    let hasPrevious = false;
+    for await (const item of iterable) {
+        if (hasPrevious) {
+            yield [previous, item];
+        }
+        previous = item;
+        hasPrevious = true;
+    }
+}
+//# sourceMappingURL=pairwise.js.map

package/dist/iterable/async/pairwise.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pairwise.js","sourceRoot":"","sources":["../../../src/iterable/async/pairwise.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,SAAS,CAAC,CAAC,aAAa,CACnC,QAA+B;IAE/B,IAAI,QAAW,CAAC;IAChB,IAAI,WAAW,GAAG,KAAK,CAAC;IAExB,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QACnC,IAAI,WAAW,EAAE,CAAC;YACjB,MAAM,CAAC,QAAS,EAAE,IAAI,CAAC,CAAC;QACzB,CAAC;QAED,QAAQ,GAAG,IAAI,CAAC;QAChB,WAAW,GAAG,IAAI,CAAC;IACpB,CAAC;AACF,CAAC"}

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

@@ -0,0 +1,17 @@
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+/**
+ * Yields each element `times` times in a row before moving to the next.
+ *
+ * The async counterpart of `repeatEach`. Not `cycleAsync`, which repeats the
+ * whole sequence rather than each element.
+ *
+ * Time complexity: O(n × times). Nothing is buffered.
+ *
+ * @param iterable The input iterable, sync or async.
+ * @param times How many times to repeat each element. Must be a non-negative
+ *   integer.
+ * @returns An iterator over the repeated elements.
+ * @throws {RangeError} If `times` is not a non-negative integer.
+ */
+export declare function repeatEachAsync<T>(iterable: MaybeAsyncIterable<T>, times: number): AsyncIterableIterator<T>;
+//# sourceMappingURL=repeat-each.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"repeat-each.d.ts","sourceRoot":"","sources":["../../../src/iterable/async/repeat-each.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE;;;;;;;;;;;;;GAaG;AACH,wBAAuB,eAAe,CAAC,CAAC,EACvC,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC/B,KAAK,EAAE,MAAM,GACX,qBAAqB,CAAC,CAAC,CAAC,CAgB1B"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"repeat-each.js","sourceRoot":"","sources":["../../../src/iterable/async/repeat-each.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,KAAK,SAAS,CAAC,CAAC,eAAe,CACrC,QAA+B,EAC/B,KAAa;IAEb,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;QAC3C,MAAM,IAAI,UAAU,CACnB,sDAAsD,CACtD,CAAC;IACH,CAAC;IAED,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;QACjB,OAAO;IACR,CAAC;IAED,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QACnC,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/async/take-while-inclusive.d.ts

@@ -0,0 +1,19 @@
+import type { MaybeAsyncPredicate } from "../../types/callable.js";
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+/**
+ * Yields elements for as long as `predicate` holds, _including_ the first one
+ * that fails it.
+ *
+ * The async counterpart of `takeWhileInclusive`, and one of the two cases
+ * `takeWhileAsync` gets wrong: it consumes the failing element and discards it,
+ * which loses a terminator a caller needs.
+ *
+ * Time complexity: O(1) per element, over the prefix only.
+ *
+ * @param iterable The input iterable, sync or async.
+ * @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 takeWhileInclusiveAsync<T>(iterable: MaybeAsyncIterable<T>, predicate: MaybeAsyncPredicate<[T, number]>): AsyncIterableIterator<T>;
+//# sourceMappingURL=take-while-inclusive.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"take-while-inclusive.d.ts","sourceRoot":"","sources":["../../../src/iterable/async/take-while-inclusive.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE;;;;;;;;;;;;;;GAcG;AACH,wBAAuB,uBAAuB,CAAC,CAAC,EAC/C,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC/B,SAAS,EAAE,mBAAmB,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,GACzC,qBAAqB,CAAC,CAAC,CAAC,CAU1B"}

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

@@ -0,0 +1,25 @@
+/**
+ * Yields elements for as long as `predicate` holds, _including_ the first one
+ * that fails it.
+ *
+ * The async counterpart of `takeWhileInclusive`, and one of the two cases
+ * `takeWhileAsync` gets wrong: it consumes the failing element and discards it,
+ * which loses a terminator a caller needs.
+ *
+ * Time complexity: O(1) per element, over the prefix only.
+ *
+ * @param iterable The input iterable, sync or async.
+ * @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 async function* takeWhileInclusiveAsync(iterable, predicate) {
+    let index = 0;
+    for await (const item of iterable) {
+        yield item;
+        if (!(await predicate(item, index++))) {
+            return;
+        }
+    }
+}
+//# sourceMappingURL=take-while-inclusive.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"take-while-inclusive.js","sourceRoot":"","sources":["../../../src/iterable/async/take-while-inclusive.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,KAAK,SAAS,CAAC,CAAC,uBAAuB,CAC7C,QAA+B,EAC/B,SAA2C;IAE3C,IAAI,KAAK,GAAG,CAAC,CAAC;IAEd,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QACnC,MAAM,IAAI,CAAC;QAEX,IAAI,CAAC,CAAC,MAAM,SAAS,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC;YACvC,OAAO;QACR,CAAC;IACF,CAAC;AACF,CAAC"}

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

@@ -0,0 +1,17 @@
+import type { MaybeAsyncPredicate } from "../../types/callable.js";
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+/**
+ * Yields elements from the start for as long as `predicate` holds, stopping at
+ * the first one it rejects.
+ *
+ * The async counterpart of `takeWhile`. The predicate may itself be async.
+ *
+ * Time complexity: O(1) per element, over the prefix only.
+ *
+ * @param iterable The input iterable, sync or async.
+ * @param predicate Receives each element and its zero-based index. Yielding
+ *   stops the first time it resolves `false`.
+ * @returns An iterator over the leading elements that satisfy `predicate`.
+ */
+export declare function takeWhileAsync<T>(iterable: MaybeAsyncIterable<T>, predicate: MaybeAsyncPredicate<[T, number]>): AsyncIterableIterator<T>;
+//# sourceMappingURL=take-while.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"take-while.d.ts","sourceRoot":"","sources":["../../../src/iterable/async/take-while.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE;;;;;;;;;;;;GAYG;AACH,wBAAuB,cAAc,CAAC,CAAC,EACtC,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC/B,SAAS,EAAE,mBAAmB,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,GACzC,qBAAqB,CAAC,CAAC,CAAC,CAU1B"}

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

@@ -0,0 +1,23 @@
+/**
+ * Yields elements from the start for as long as `predicate` holds, stopping at
+ * the first one it rejects.
+ *
+ * The async counterpart of `takeWhile`. The predicate may itself be async.
+ *
+ * Time complexity: O(1) per element, over the prefix only.
+ *
+ * @param iterable The input iterable, sync or async.
+ * @param predicate Receives each element and its zero-based index. Yielding
+ *   stops the first time it resolves `false`.
+ * @returns An iterator over the leading elements that satisfy `predicate`.
+ */
+export async function* takeWhileAsync(iterable, predicate) {
+    let index = 0;
+    for await (const item of iterable) {
+        if (!(await predicate(item, index++))) {
+            return;
+        }
+        yield item;
+    }
+}
+//# sourceMappingURL=take-while.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"take-while.js","sourceRoot":"","sources":["../../../src/iterable/async/take-while.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,SAAS,CAAC,CAAC,cAAc,CACpC,QAA+B,EAC/B,SAA2C;IAE3C,IAAI,KAAK,GAAG,CAAC,CAAC;IAEd,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QACnC,IAAI,CAAC,CAAC,MAAM,SAAS,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC;YACvC,OAAO;QACR,CAAC;QAED,MAAM,IAAI,CAAC;IACZ,CAAC;AACF,CAAC"}

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

@@ -0,0 +1,16 @@
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+/**
+ * Yields at most the first `count` elements, then stops.
+ *
+ * The async counterpart of `take`. The source is closed as soon as the quota is
+ * met, so taking from an endless stream terminates.
+ *
+ * Time complexity: O(count).
+ *
+ * @param iterable The input iterable, sync or async.
+ * @param count How many elements to yield. Must be a non-negative integer.
+ * @returns An iterator over the leading elements.
+ * @throws {RangeError} If `count` is not a non-negative integer.
+ */
+export declare function takeAsync<T>(iterable: MaybeAsyncIterable<T>, count: number): AsyncIterableIterator<T>;
+//# sourceMappingURL=take.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"take.d.ts","sourceRoot":"","sources":["../../../src/iterable/async/take.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE;;;;;;;;;;;;GAYG;AACH,wBAAuB,SAAS,CAAC,CAAC,EACjC,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC/B,KAAK,EAAE,MAAM,GACX,qBAAqB,CAAC,CAAC,CAAC,CAkB1B"}

package/dist/iterable/async/take.js

@@ -0,0 +1,29 @@
+/**
+ * Yields at most the first `count` elements, then stops.
+ *
+ * The async counterpart of `take`. The source is closed as soon as the quota is
+ * met, so taking from an endless stream terminates.
+ *
+ * Time complexity: O(count).
+ *
+ * @param iterable The input iterable, sync or async.
+ * @param count How many elements to yield. Must be a non-negative integer.
+ * @returns An iterator over the leading elements.
+ * @throws {RangeError} If `count` is not a non-negative integer.
+ */
+export async function* takeAsync(iterable, count) {
+    if (!Number.isInteger(count) || count < 0) {
+        throw new RangeError("takeAsync count must be a non-negative integer");
+    }
+    if (count === 0) {
+        return;
+    }
+    let taken = 0;
+    for await (const item of iterable) {
+        yield item;
+        if (++taken >= count) {
+            return;
+        }
+    }
+}
+//# sourceMappingURL=take.js.map

package/dist/iterable/async/take.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"take.js","sourceRoot":"","sources":["../../../src/iterable/async/take.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,SAAS,CAAC,CAAC,SAAS,CAC/B,QAA+B,EAC/B,KAAa;IAEb,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;QAC3C,MAAM,IAAI,UAAU,CAAC,gDAAgD,CAAC,CAAC;IACxE,CAAC;IAED,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;QACjB,OAAO;IACR,CAAC;IAED,IAAI,KAAK,GAAG,CAAC,CAAC;IAEd,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QACnC,MAAM,IAAI,CAAC;QAEX,IAAI,EAAE,KAAK,IAAI,KAAK,EAAE,CAAC;YACtB,OAAO;QACR,CAAC;IACF,CAAC;AACF,CAAC"}

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

@@ -0,0 +1,18 @@
+import type { MaybeAsyncCallable } from "../../types/callable.js";
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+/**
+ * Yields the elements unchanged, running `onItem` for each as it passes.
+ *
+ * The async counterpart of `tap`. An async `onItem` is awaited before the
+ * element is yielded, so the side effect is ordered against the stream rather
+ * than racing it.
+ *
+ * Time complexity: O(1) per element, plus whatever `onItem` costs.
+ *
+ * @param iterable The input iterable, sync or async.
+ * @param onItem Receives each element and its zero-based index. Its resolved
+ *   value is ignored.
+ * @returns An iterator over the unchanged elements.
+ */
+export declare function tapAsync<T>(iterable: MaybeAsyncIterable<T>, onItem: MaybeAsyncCallable<[T, number]>): AsyncIterableIterator<T>;
+//# sourceMappingURL=tap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tap.d.ts","sourceRoot":"","sources":["../../../src/iterable/async/tap.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE;;;;;;;;;;;;;GAaG;AACH,wBAAuB,QAAQ,CAAC,CAAC,EAChC,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC/B,MAAM,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,GACrC,qBAAqB,CAAC,CAAC,CAAC,CAO1B"}

package/dist/iterable/async/tap.js

@@ -0,0 +1,22 @@
+/**
+ * Yields the elements unchanged, running `onItem` for each as it passes.
+ *
+ * The async counterpart of `tap`. An async `onItem` is awaited before the
+ * element is yielded, so the side effect is ordered against the stream rather
+ * than racing it.
+ *
+ * Time complexity: O(1) per element, plus whatever `onItem` costs.
+ *
+ * @param iterable The input iterable, sync or async.
+ * @param onItem Receives each element and its zero-based index. Its resolved
+ *   value is ignored.
+ * @returns An iterator over the unchanged elements.
+ */
+export async function* tapAsync(iterable, onItem) {
+    let index = 0;
+    for await (const item of iterable) {
+        await onItem(item, index++);
+        yield item;
+    }
+}
+//# sourceMappingURL=tap.js.map

package/dist/iterable/async/tap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tap.js","sourceRoot":"","sources":["../../../src/iterable/async/tap.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,KAAK,SAAS,CAAC,CAAC,QAAQ,CAC9B,QAA+B,EAC/B,MAAuC;IAEvC,IAAI,KAAK,GAAG,CAAC,CAAC;IAEd,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QACnC,MAAM,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;QAC5B,MAAM,IAAI,CAAC;IACZ,CAAC;AACF,CAAC"}

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

@@ -0,0 +1,23 @@
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+/**
+ * Fans one iterable out to `count` independent iterators over the same
+ * elements.
+ *
+ * The async counterpart of `tee`. 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.
+ *
+ * Branches may be advanced concurrently. A pull from the source is shared:
+ * branches that need the same not-yet-read element all await the one in-flight
+ * read rather than issuing their own, so the source is never advanced twice for
+ * one element.
+ *
+ * Time complexity: O(1) amortised per element per branch. Memory: O(span).
+ *
+ * @param iterable The iterable to fan out, sync or async.
+ * @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 teeAsync<T>(iterable: MaybeAsyncIterable<T>, count?: number): AsyncIterableIterator<T>[];
+//# sourceMappingURL=tee.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tee.d.ts","sourceRoot":"","sources":["../../../src/iterable/async/tee.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAGlE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EACzB,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC/B,KAAK,SAAI,GACP,qBAAqB,CAAC,CAAC,CAAC,EAAE,CAmE5B"}

package/dist/iterable/async/tee.js

@@ -0,0 +1,77 @@
+import { asyncIteratorOf_ } from "./_async-iterator.js";
+/**
+ * Fans one iterable out to `count` independent iterators over the same
+ * elements.
+ *
+ * The async counterpart of `tee`. 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.
+ *
+ * Branches may be advanced concurrently. A pull from the source is shared:
+ * branches that need the same not-yet-read element all await the one in-flight
+ * read rather than issuing their own, so the source is never advanced twice for
+ * one element.
+ *
+ * Time complexity: O(1) amortised per element per branch. Memory: O(span).
+ *
+ * @param iterable The iterable to fan out, sync or async.
+ * @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 teeAsync(iterable, count = 2) {
+    if (!Number.isInteger(count) || count < 0) {
+        throw new RangeError("teeAsync count must be a non-negative integer");
+    }
+    const iterator = asyncIteratorOf_(iterable);
+    const buffer = [];
+    const cursors = Array.from({ length: count }).fill(0);
+    let bufferStart = 0;
+    let exhausted = false;
+    let pending;
+    async function readOne_() {
+        const result = await iterator.next();
+        if (result.done === true) {
+            exhausted = true;
+        }
+        else {
+            buffer.push(result.value);
+        }
+        pending = undefined;
+    }
+    // Branches racing for the same unread element share one read: whoever
+    // arrives first starts it, the rest await the promise it left behind.
+    function pullOne_() {
+        pending ??= readOne_();
+        return pending;
+    }
+    async function* branch(id) {
+        while (true) {
+            const wanted = cursors[id];
+            while (wanted === bufferStart + buffer.length && !exhausted) {
+                await pullOne_();
+            }
+            if (wanted === bufferStart + buffer.length) {
+                return;
+            }
+            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/async/tee.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tee.js","sourceRoot":"","sources":["../../../src/iterable/async/tee.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAExD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,QAAQ,CACvB,QAA+B,EAC/B,KAAK,GAAG,CAAC;IAET,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;QAC3C,MAAM,IAAI,UAAU,CAAC,+CAA+C,CAAC,CAAC;IACvE,CAAC;IAED,MAAM,QAAQ,GAAG,gBAAgB,CAAC,QAAQ,CAAC,CAAC;IAC5C,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;IACtB,IAAI,OAAkC,CAAC;IAEvC,KAAK,UAAU,QAAQ;QACtB,MAAM,MAAM,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;QAErC,IAAI,MAAM,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;YAC1B,SAAS,GAAG,IAAI,CAAC;QAClB,CAAC;aAAM,CAAC;YACP,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;QAC3B,CAAC;QAED,OAAO,GAAG,SAAS,CAAC;IACrB,CAAC;IAED,sEAAsE;IACtE,sEAAsE;IACtE,SAAS,QAAQ;QAChB,OAAO,KAAK,QAAQ,EAAE,CAAC;QAEvB,OAAO,OAAO,CAAC;IAChB,CAAC;IAED,KAAK,SAAS,CAAC,CAAC,MAAM,CAAC,EAAU;QAChC,OAAO,IAAI,EAAE,CAAC;YACb,MAAM,MAAM,GAAG,OAAO,CAAC,EAAE,CAAE,CAAC;YAE5B,OAAO,MAAM,KAAK,WAAW,GAAG,MAAM,CAAC,MAAM,IAAI,CAAC,SAAS,EAAE,CAAC;gBAC7D,MAAM,QAAQ,EAAE,CAAC;YAClB,CAAC;YAED,IAAI,MAAM,KAAK,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC;gBAC5C,OAAO;YACR,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/async/trim-while.d.ts

@@ -0,0 +1,31 @@
+import type { MaybeAsyncPredicate } from "../../types/callable.js";
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+/**
+ * Yields the elements with any trailing run satisfying `predicate` removed.
+ *
+ * The async counterpart of `trimEndWhile`. 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.
+ *
+ * Time complexity: O(n). Memory: O(longest matching run).
+ *
+ * @param iterable The input iterable, sync or async.
+ * @param predicate Decides whether an element may be trimmed.
+ * @returns An iterator over the elements, trailing matches removed.
+ */
+export declare function trimEndWhileAsync<T>(iterable: MaybeAsyncIterable<T>, predicate: MaybeAsyncPredicate<[T]>): AsyncIterableIterator<T>;
+/**
+ * Yields the elements with any leading _and_ trailing run satisfying
+ * `predicate` removed.
+ *
+ * The async counterpart of `trimWhile`. The start-only case is
+ * `dropWhileAsync`, which this composes rather than duplicating.
+ *
+ * Time complexity: O(n). Memory: O(longest matching run).
+ *
+ * @param iterable The input iterable, sync or async.
+ * @param predicate Decides whether an element may be trimmed.
+ * @returns An iterator over the elements, leading and trailing matches removed.
+ */
+export declare function trimWhileAsync<T>(iterable: MaybeAsyncIterable<T>, predicate: MaybeAsyncPredicate<[T]>): AsyncIterableIterator<T>;
+//# sourceMappingURL=trim-while.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trim-while.d.ts","sourceRoot":"","sources":["../../../src/iterable/async/trim-while.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAGlE;;;;;;;;;;;;GAYG;AACH,wBAAuB,iBAAiB,CAAC,CAAC,EACzC,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC/B,SAAS,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC,GACjC,qBAAqB,CAAC,CAAC,CAAC,CAa1B;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAC/B,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC/B,SAAS,EAAE,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC,GACjC,qBAAqB,CAAC,CAAC,CAAC,CAK1B"}

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

@@ -0,0 +1,43 @@
+import { dropWhileAsync } from "./drop-while.js";
+/**
+ * Yields the elements with any trailing run satisfying `predicate` removed.
+ *
+ * The async counterpart of `trimEndWhile`. 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.
+ *
+ * Time complexity: O(n). Memory: O(longest matching run).
+ *
+ * @param iterable The input iterable, sync or async.
+ * @param predicate Decides whether an element may be trimmed.
+ * @returns An iterator over the elements, trailing matches removed.
+ */
+export async function* trimEndWhileAsync(iterable, predicate) {
+    const pending = [];
+    for await (const item of iterable) {
+        if (await 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 async counterpart of `trimWhile`. The start-only case is
+ * `dropWhileAsync`, which this composes rather than duplicating.
+ *
+ * Time complexity: O(n). Memory: O(longest matching run).
+ *
+ * @param iterable The input iterable, sync or async.
+ * @param predicate Decides whether an element may be trimmed.
+ * @returns An iterator over the elements, leading and trailing matches removed.
+ */
+export function trimWhileAsync(iterable, predicate) {
+    return trimEndWhileAsync(dropWhileAsync(iterable, async (item) => predicate(item)), predicate);
+}
+//# sourceMappingURL=trim-while.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trim-while.js","sourceRoot":"","sources":["../../../src/iterable/async/trim-while.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAEjD;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,SAAS,CAAC,CAAC,iBAAiB,CACvC,QAA+B,EAC/B,SAAmC;IAEnC,MAAM,OAAO,GAAQ,EAAE,CAAC;IAExB,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QACnC,IAAI,MAAM,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC;YAC3B,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,cAAc,CAC7B,QAA+B,EAC/B,SAAmC;IAEnC,OAAO,iBAAiB,CACvB,cAAc,CAAC,QAAQ,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,CAAC,EACzD,SAAS,CACT,CAAC;AACH,CAAC"}

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

@@ -0,0 +1,17 @@
+import type { MaybeAsyncCallable } from "../../types/callable.js";
+/**
+ * Generates a sequence from a seed, one step at a time — the dual of `reduce`.
+ *
+ * The async counterpart of `unfold`, and the shape a paginated API has: the
+ * state is the cursor, and `next` resolves to the page plus the cursor that
+ * follows it, or `undefined` when there are no more.
+ *
+ * Time complexity: O(1) per element, plus whatever `next` costs.
+ *
+ * @param seed The initial state.
+ * @param next Receives the current state and resolves to `[value, nextState]`,
+ *   or `undefined` to end the sequence.
+ * @returns An iterator over the generated values.
+ */
+export declare function unfoldAsync<S, T>(seed: S, next: MaybeAsyncCallable<[S], readonly [value: T, state: S] | undefined>): AsyncIterableIterator<T>;
+//# sourceMappingURL=unfold.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"unfold.d.ts","sourceRoot":"","sources":["../../../src/iterable/async/unfold.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE;;;;;;;;;;;;;GAaG;AACH,wBAAuB,WAAW,CAAC,CAAC,EAAE,CAAC,EACtC,IAAI,EAAE,CAAC,EACP,IAAI,EAAE,kBAAkB,CAAC,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC,GAAG,SAAS,CAAC,GACtE,qBAAqB,CAAC,CAAC,CAAC,CAa1B"}

package/dist/iterable/async/unfold.js

@@ -0,0 +1,26 @@
+/**
+ * Generates a sequence from a seed, one step at a time — the dual of `reduce`.
+ *
+ * The async counterpart of `unfold`, and the shape a paginated API has: the
+ * state is the cursor, and `next` resolves to the page plus the cursor that
+ * follows it, or `undefined` when there are no more.
+ *
+ * Time complexity: O(1) per element, plus whatever `next` costs.
+ *
+ * @param seed The initial state.
+ * @param next Receives the current state and resolves to `[value, nextState]`,
+ *   or `undefined` to end the sequence.
+ * @returns An iterator over the generated values.
+ */
+export async function* unfoldAsync(seed, next) {
+    let state = seed;
+    while (true) {
+        const step = await next(state);
+        if (step === undefined) {
+            return;
+        }
+        yield step[0];
+        state = step[1];
+    }
+}
+//# sourceMappingURL=unfold.js.map

package/dist/iterable/async/unfold.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unfold.js","sourceRoot":"","sources":["../../../src/iterable/async/unfold.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,KAAK,SAAS,CAAC,CAAC,WAAW,CACjC,IAAO,EACP,IAAwE;IAExE,IAAI,KAAK,GAAG,IAAI,CAAC;IAEjB,OAAO,IAAI,EAAE,CAAC;QACb,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,CAAC;QAE/B,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"}