@ac-kit/core 0.1.0

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

@@ -0,0 +1,17 @@
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+import type { Unzipped } from "../unzip.js";
+/**
+ * Splits an iterable of tuples into one array per tuple position — the inverse
+ * of `zipAsync`.
+ *
+ * The async counterpart of `unzip`, and eager for the same reason: a column
+ * cannot be produced without reading every row.
+ *
+ * Time complexity: O(n × width).
+ *
+ * @param tuples The tuples to split, sync or async.
+ * @param signal Aborts the read.
+ * @returns The columns. Empty when the input is.
+ */
+export declare function unzipAsync<const T extends readonly unknown[]>(tuples: MaybeAsyncIterable<T>, signal?: AbortSignal): Promise<Unzipped<T>>;
+//# sourceMappingURL=unzip.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"unzip.d.ts","sourceRoot":"","sources":["../../../src/iterable/async/unzip.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAE5C;;;;;;;;;;;;GAYG;AACH,wBAAsB,UAAU,CAAC,KAAK,CAAC,CAAC,SAAS,SAAS,OAAO,EAAE,EAClE,MAAM,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC7B,MAAM,CAAC,EAAE,WAAW,GAClB,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAgBtB"}

package/dist/iterable/async/unzip.js

@@ -0,0 +1,27 @@
+/**
+ * Splits an iterable of tuples into one array per tuple position — the inverse
+ * of `zipAsync`.
+ *
+ * The async counterpart of `unzip`, and eager for the same reason: a column
+ * cannot be produced without reading every row.
+ *
+ * Time complexity: O(n × width).
+ *
+ * @param tuples The tuples to split, sync or async.
+ * @param signal Aborts the read.
+ * @returns The columns. Empty when the input is.
+ */
+export async function unzipAsync(tuples, signal) {
+    signal?.throwIfAborted();
+    const columns = [];
+    for await (const tuple of tuples) {
+        signal?.throwIfAborted();
+        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/async/unzip.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unzip.js","sourceRoot":"","sources":["../../../src/iterable/async/unzip.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,UAAU,UAAU,CAC/B,MAA6B,EAC7B,MAAoB;IAEpB,MAAM,EAAE,cAAc,EAAE,CAAC;IAEzB,MAAM,OAAO,GAAgB,EAAE,CAAC;IAEhC,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAClC,MAAM,EAAE,cAAc,EAAE,CAAC;QAEzB,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"}

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

@@ -0,0 +1,17 @@
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+/**
+ * Yields every overlapping window of `size` consecutive elements.
+ *
+ * The async counterpart of `windowed`. Not `chunkAsync`: windows overlap,
+ * chunks do not, and a short trailing window is never yielded.
+ *
+ * Time complexity: O(n), allocating one array per window.
+ *
+ * @param iterable The input iterable, sync or async.
+ * @param size How many elements per window. Must be a positive integer.
+ * @param step How far to advance between windows. Must be a positive integer.
+ * @returns An iterator over the windows.
+ * @throws {RangeError} If `size` or `step` is not a positive integer.
+ */
+export declare function windowedAsync<T>(iterable: MaybeAsyncIterable<T>, size: number, step?: number): AsyncIterableIterator<T[]>;
+//# sourceMappingURL=windowed.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"windowed.d.ts","sourceRoot":"","sources":["../../../src/iterable/async/windowed.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE;;;;;;;;;;;;;GAaG;AACH,wBAAuB,aAAa,CAAC,CAAC,EACrC,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC/B,IAAI,EAAE,MAAM,EACZ,IAAI,SAAI,GACN,qBAAqB,CAAC,CAAC,EAAE,CAAC,CA8B5B"}

package/dist/iterable/async/windowed.js

@@ -0,0 +1,42 @@
+/**
+ * Yields every overlapping window of `size` consecutive elements.
+ *
+ * The async counterpart of `windowed`. Not `chunkAsync`: windows overlap,
+ * chunks do not, and a short trailing window is never yielded.
+ *
+ * Time complexity: O(n), allocating one array per window.
+ *
+ * @param iterable The input iterable, sync or async.
+ * @param size How many elements per window. Must be a positive integer.
+ * @param step How far to advance between windows. Must be a positive integer.
+ * @returns An iterator over the windows.
+ * @throws {RangeError} If `size` or `step` is not a positive integer.
+ */
+export async function* windowedAsync(iterable, size, step = 1) {
+    if (!Number.isInteger(size) || size < 1) {
+        throw new RangeError("windowedAsync size must be a positive integer");
+    }
+    if (!Number.isInteger(step) || step < 1) {
+        throw new RangeError("windowedAsync step must be a positive integer");
+    }
+    const buffer = [];
+    let skip = 0;
+    for await (const item of iterable) {
+        if (skip > 0) {
+            skip--;
+            continue;
+        }
+        buffer.push(item);
+        if (buffer.length === size) {
+            yield [...buffer];
+            if (step >= size) {
+                buffer.length = 0;
+                skip = step - size;
+            }
+            else {
+                buffer.splice(0, step);
+            }
+        }
+    }
+}
+//# sourceMappingURL=windowed.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"windowed.js","sourceRoot":"","sources":["../../../src/iterable/async/windowed.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,KAAK,SAAS,CAAC,CAAC,aAAa,CACnC,QAA+B,EAC/B,IAAY,EACZ,IAAI,GAAG,CAAC;IAER,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,IAAI,GAAG,CAAC,EAAE,CAAC;QACzC,MAAM,IAAI,UAAU,CAAC,+CAA+C,CAAC,CAAC;IACvE,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,IAAI,GAAG,CAAC,EAAE,CAAC;QACzC,MAAM,IAAI,UAAU,CAAC,+CAA+C,CAAC,CAAC;IACvE,CAAC;IAED,MAAM,MAAM,GAAQ,EAAE,CAAC;IACvB,IAAI,IAAI,GAAG,CAAC,CAAC;IAEb,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QACnC,IAAI,IAAI,GAAG,CAAC,EAAE,CAAC;YACd,IAAI,EAAE,CAAC;YACP,SAAS;QACV,CAAC;QAED,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAElB,IAAI,MAAM,CAAC,MAAM,KAAK,IAAI,EAAE,CAAC;YAC5B,MAAM,CAAC,GAAG,MAAM,CAAC,CAAC;YAElB,IAAI,IAAI,IAAI,IAAI,EAAE,CAAC;gBAClB,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC;gBAClB,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;YACpB,CAAC;iBAAM,CAAC;gBACP,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC;YACxB,CAAC;QACF,CAAC;IACF,CAAC;AACF,CAAC"}

package/dist/iterable/async/zip-longest.d.ts

@@ -0,0 +1,18 @@
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+import type { ZippedLongest } from "../zip-longest.js";
+/**
+ * Yields tuples pairing the first element of every iterable, then the second,
+ * and so on, continuing until the _longest_ one runs out and substituting
+ * `fill` for every iterable that has already ended.
+ *
+ * The async counterpart of `zipLongest`. Each round advances every unexhausted
+ * source concurrently.
+ *
+ * Time complexity: O(1) per tuple, allocating one tuple per yield.
+ *
+ * @param iterables The iterables to advance in lockstep.
+ * @param fill The value standing in for an iterable that has already ended.
+ * @returns An iterator over the tuples. Empty when no iterables were given.
+ */
+export declare function zipLongestAsync<const T extends readonly MaybeAsyncIterable<unknown>[], F>(iterables: T, fill: F): AsyncIterableIterator<ZippedLongest<T, F>>;
+//# sourceMappingURL=zip-longest.d.ts.map

package/dist/iterable/async/zip-longest.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip-longest.d.ts","sourceRoot":"","sources":["../../../src/iterable/async/zip-longest.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAGvD;;;;;;;;;;;;;GAaG;AACH,wBAAuB,eAAe,CACrC,KAAK,CAAC,CAAC,SAAS,SAAS,kBAAkB,CAAC,OAAO,CAAC,EAAE,EACtD,CAAC,EACA,SAAS,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,GAAG,qBAAqB,CAAC,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAmDnE"}

package/dist/iterable/async/zip-longest.js

@@ -0,0 +1,52 @@
+import { asyncIteratorOf_ } from "./_async-iterator.js";
+/**
+ * Yields tuples pairing the first element of every iterable, then the second,
+ * and so on, continuing until the _longest_ one runs out and substituting
+ * `fill` for every iterable that has already ended.
+ *
+ * The async counterpart of `zipLongest`. Each round advances every unexhausted
+ * source concurrently.
+ *
+ * Time complexity: O(1) per tuple, allocating one tuple per yield.
+ *
+ * @param iterables The iterables to advance in lockstep.
+ * @param fill The value standing in for an iterable that has already ended.
+ * @returns An iterator over the tuples. Empty when no iterables were given.
+ */
+export async function* zipLongestAsync(iterables, fill) {
+    if (iterables.length === 0) {
+        return;
+    }
+    const iterators = iterables.map((iterable) => asyncIteratorOf_(iterable));
+    const exhausted = Array.from({ length: iterators.length }).fill(false);
+    let remaining = iterators.length;
+    try {
+        while (true) {
+            // `Promise.resolve` rather than an `async` wrapper: a sync source's
+            // `next()` returns a plain result, and wrapping costs an extra tick.
+            const results = await Promise.all(iterators.map((iterator, index) => Promise.resolve(exhausted[index] === true ? undefined : iterator.next())));
+            const values = results.map((result, index) => {
+                if (result === undefined) {
+                    return fill;
+                }
+                if (result.done === true) {
+                    exhausted[index] = true;
+                    remaining--;
+                    return fill;
+                }
+                return result.value;
+            });
+            if (remaining === 0) {
+                return;
+            }
+            // Safe: one value per iterable, in order, so the array has exactly the
+            // arity and element types `ZippedLongest<T, F>` describes.
+            yield values;
+        }
+    }
+    finally {
+        // Cleanup: every source must be closed even if one `return` rejects.
+        await Promise.allSettled(iterators.map((iterator) => Promise.resolve(iterator.return?.())));
+    }
+}
+//# sourceMappingURL=zip-longest.js.map

package/dist/iterable/async/zip-longest.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip-longest.js","sourceRoot":"","sources":["../../../src/iterable/async/zip-longest.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAExD;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,KAAK,SAAS,CAAC,CAAC,eAAe,CAGpC,SAAY,EAAE,IAAO;IACtB,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC5B,OAAO;IACR,CAAC;IAED,MAAM,SAAS,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC,CAAC;IAC1E,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAU,EAAE,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,CAAC,CAAC,IAAI,CACvE,KAAK,CACL,CAAC;IACF,IAAI,SAAS,GAAG,SAAS,CAAC,MAAM,CAAC;IAEjC,IAAI,CAAC;QACJ,OAAO,IAAI,EAAE,CAAC;YACb,oEAAoE;YACpE,qEAAqE;YACrE,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAChC,SAAS,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,KAAK,EAAE,EAAE,CACjC,OAAO,CAAC,OAAO,CACd,SAAS,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,EAAE,CACvD,CACD,CACD,CAAC;YAEF,MAAM,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE;gBAC5C,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;oBAC1B,OAAO,IAAI,CAAC;gBACb,CAAC;gBAED,IAAI,MAAM,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;oBAC1B,SAAS,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC;oBACxB,SAAS,EAAE,CAAC;oBACZ,OAAO,IAAI,CAAC;gBACb,CAAC;gBAED,OAAO,MAAM,CAAC,KAAK,CAAC;YACrB,CAAC,CAAC,CAAC;YAEH,IAAI,SAAS,KAAK,CAAC,EAAE,CAAC;gBACrB,OAAO;YACR,CAAC;YAED,uEAAuE;YACvE,2DAA2D;YAC3D,MAAM,MAA6B,CAAC;QACrC,CAAC;IACF,CAAC;YAAS,CAAC;QACV,qEAAqE;QACrE,MAAM,OAAO,CAAC,UAAU,CACvB,SAAS,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,CACjE,CAAC;IACH,CAAC;AACF,CAAC"}

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

@@ -0,0 +1,21 @@
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+import type { Zipped } from "../zip.js";
+/**
+ * Yields tuples pairing the first element of every iterable, then the second,
+ * and so on, stopping as soon as any one of them runs out.
+ *
+ * The async counterpart of `zip`. Sources may be mixed, so a materialised array
+ * can be paired with a stream. Each round advances every source concurrently
+ * rather than one after another, so a round costs the slowest source, not their
+ * sum.
+ *
+ * Every source iterator is closed when iteration ends, whether it ended by
+ * exhaustion or because the consumer stopped pulling.
+ *
+ * Time complexity: O(1) per tuple, allocating one tuple per yield.
+ *
+ * @param iterables The iterables to advance in lockstep.
+ * @returns An iterator over the tuples. Empty when no iterables were given.
+ */
+export declare function zipAsync<const T extends readonly MaybeAsyncIterable<unknown>[]>(iterables: T): AsyncIterableIterator<Zipped<T>>;
+//# sourceMappingURL=zip.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"zip.d.ts","sourceRoot":"","sources":["../../../src/iterable/async/zip.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AAGxC;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAuB,QAAQ,CAC9B,KAAK,CAAC,CAAC,SAAS,SAAS,kBAAkB,CAAC,OAAO,CAAC,EAAE,EACrD,SAAS,EAAE,CAAC,GAAG,qBAAqB,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CA6BhD"}

package/dist/iterable/async/zip.js

@@ -0,0 +1,42 @@
+import { asyncIteratorOf_ } from "./_async-iterator.js";
+/**
+ * Yields tuples pairing the first element of every iterable, then the second,
+ * and so on, stopping as soon as any one of them runs out.
+ *
+ * The async counterpart of `zip`. Sources may be mixed, so a materialised array
+ * can be paired with a stream. Each round advances every source concurrently
+ * rather than one after another, so a round costs the slowest source, not their
+ * sum.
+ *
+ * Every source iterator is closed when iteration ends, whether it ended by
+ * exhaustion or because the consumer stopped pulling.
+ *
+ * Time complexity: O(1) per tuple, allocating one tuple per yield.
+ *
+ * @param iterables The iterables to advance in lockstep.
+ * @returns An iterator over the tuples. Empty when no iterables were given.
+ */
+export async function* zipAsync(iterables) {
+    if (iterables.length === 0) {
+        return;
+    }
+    const iterators = iterables.map((iterable) => asyncIteratorOf_(iterable));
+    try {
+        while (true) {
+            // `Promise.resolve` rather than an `async` wrapper: a sync source's
+            // `next()` returns a plain result, and wrapping costs an extra tick.
+            const results = await Promise.all(iterators.map((iterator) => Promise.resolve(iterator.next())));
+            if (results.some((result) => result.done === true)) {
+                return;
+            }
+            // Safe: one result per iterable, in order, so the mapped array has
+            // exactly the arity and element types `Zipped<T>` describes.
+            yield results.map((result) => result.value);
+        }
+    }
+    finally {
+        // Cleanup: every source must be closed even if one `return` rejects.
+        await Promise.allSettled(iterators.map((iterator) => Promise.resolve(iterator.return?.())));
+    }
+}
+//# sourceMappingURL=zip.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"zip.js","sourceRoot":"","sources":["../../../src/iterable/async/zip.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAExD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,KAAK,SAAS,CAAC,CAAC,QAAQ,CAE7B,SAAY;IACb,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC5B,OAAO;IACR,CAAC;IAED,MAAM,SAAS,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,gBAAgB,CAAC,QAAQ,CAAC,CAAC,CAAC;IAE1E,IAAI,CAAC;QACJ,OAAO,IAAI,EAAE,CAAC;YACb,oEAAoE;YACpE,qEAAqE;YACrE,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,GAAG,CAChC,SAAS,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,CAC7D,CAAC;YAEF,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,KAAK,IAAI,CAAC,EAAE,CAAC;gBACpD,OAAO;YACR,CAAC;YAED,mEAAmE;YACnE,6DAA6D;YAC7D,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,KAAK,CAAc,CAAC;QAC1D,CAAC;IACF,CAAC;YAAS,CAAC;QACV,qEAAqE;QACrE,MAAM,OAAO,CAAC,UAAU,CACvB,SAAS,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,CACjE,CAAC;IACH,CAAC;AACF,CAAC"}

package/dist/iterable/before-and-after.d.ts

@@ -0,0 +1,25 @@
+import type { Predicate } from "../types/callable.js";
+/**
+ * Splits an iterable at the first element failing `predicate`, returning the
+ * prefix and the remainder as two iterators over the same source.
+ *
+ * The other case `takeWhile` gets wrong: it discards everything from the split
+ * point on. Here the failing element starts the second iterator, so nothing is
+ * lost and the source is still only walked once.
+ *
+ * The two share one underlying iterator, so **the first must be consumed before
+ * the second**. Reading the second early is allowed and drains the first
+ * silently, discarding its elements — that is the only way to know where the
+ * split is. Abandoning the first part-way is also allowed: the second then
+ * resumes from wherever the source was left, with no boundary element.
+ *
+ * Time complexity: O(1) per element. Memory: O(1) — one element is held at the
+ * boundary, never the prefix.
+ *
+ * @param iterable The input iterable.
+ * @param predicate Receives each element and its zero-based index.
+ * @returns The leading elements that satisfy `predicate`, then the rest
+ *   starting at the first that does not.
+ */
+export declare function beforeAndAfter<T>(iterable: Iterable<T>, predicate: Predicate<[T, number]>): [before: IterableIterator<T>, after: IterableIterator<T>];
+//# sourceMappingURL=before-and-after.d.ts.map

package/dist/iterable/before-and-after.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"before-and-after.d.ts","sourceRoot":"","sources":["../../src/iterable/before-and-after.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEtD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAC/B,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EACrB,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,GAC/B,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,gBAAgB,CAAC,CAAC,CAAC,CAAC,CA8C3D"}

package/dist/iterable/before-and-after.js

@@ -0,0 +1,59 @@
+/**
+ * Splits an iterable at the first element failing `predicate`, returning the
+ * prefix and the remainder as two iterators over the same source.
+ *
+ * The other case `takeWhile` gets wrong: it discards everything from the split
+ * point on. Here the failing element starts the second iterator, so nothing is
+ * lost and the source is still only walked once.
+ *
+ * The two share one underlying iterator, so **the first must be consumed before
+ * the second**. Reading the second early is allowed and drains the first
+ * silently, discarding its elements — that is the only way to know where the
+ * split is. Abandoning the first part-way is also allowed: the second then
+ * resumes from wherever the source was left, with no boundary element.
+ *
+ * Time complexity: O(1) per element. Memory: O(1) — one element is held at the
+ * boundary, never the prefix.
+ *
+ * @param iterable The input iterable.
+ * @param predicate Receives each element and its zero-based index.
+ * @returns The leading elements that satisfy `predicate`, then the rest
+ *   starting at the first that does not.
+ */
+export function beforeAndAfter(iterable, predicate) {
+    const iterator = iterable[Symbol.iterator]();
+    let boundary;
+    function* before() {
+        let index = 0;
+        while (boundary === undefined) {
+            const result = iterator.next();
+            if (result.done === true || !predicate(result.value, index++)) {
+                boundary = result;
+                return;
+            }
+            yield result.value;
+        }
+    }
+    const beforeIterator = before();
+    function* after() {
+        // A `before` abandoned early closes without reaching the split, so stop
+        // draining when it reports done rather than waiting for a boundary.
+        while (boundary === undefined) {
+            if (beforeIterator.next().done === true) {
+                break;
+            }
+        }
+        if (boundary !== undefined && boundary.done !== true) {
+            yield boundary.value;
+        }
+        while (true) {
+            const result = iterator.next();
+            if (result.done === true) {
+                return;
+            }
+            yield result.value;
+        }
+    }
+    return [beforeIterator, after()];
+}
+//# sourceMappingURL=before-and-after.js.map

package/dist/iterable/before-and-after.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"before-and-after.js","sourceRoot":"","sources":["../../src/iterable/before-and-after.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,cAAc,CAC7B,QAAqB,EACrB,SAAiC;IAEjC,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;IAC7C,IAAI,QAAuC,CAAC;IAE5C,QAAQ,CAAC,CAAC,MAAM;QACf,IAAI,KAAK,GAAG,CAAC,CAAC;QAEd,OAAO,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC/B,MAAM,MAAM,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC;YAE/B,IAAI,MAAM,CAAC,IAAI,KAAK,IAAI,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC;gBAC/D,QAAQ,GAAG,MAAM,CAAC;gBAClB,OAAO;YACR,CAAC;YAED,MAAM,MAAM,CAAC,KAAK,CAAC;QACpB,CAAC;IACF,CAAC;IAED,MAAM,cAAc,GAAG,MAAM,EAAE,CAAC;IAEhC,QAAQ,CAAC,CAAC,KAAK;QACd,wEAAwE;QACxE,oEAAoE;QACpE,OAAO,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC/B,IAAI,cAAc,CAAC,IAAI,EAAE,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;gBACzC,MAAM;YACP,CAAC;QACF,CAAC;QAED,IAAI,QAAQ,KAAK,SAAS,IAAI,QAAQ,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;YACtD,MAAM,QAAQ,CAAC,KAAK,CAAC;QACtB,CAAC;QAED,OAAO,IAAI,EAAE,CAAC;YACb,MAAM,MAAM,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC;YAE/B,IAAI,MAAM,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;gBAC1B,OAAO;YACR,CAAC;YAED,MAAM,MAAM,CAAC,KAAK,CAAC;QACpB,CAAC;IACF,CAAC;IAED,OAAO,CAAC,cAAc,EAAE,KAAK,EAAE,CAAC,CAAC;AAClC,CAAC"}

package/dist/iterable/big-int-range.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Yields the arithmetic progression from `start` towards `stop`, exclusive,
+ * over `bigint`.
+ *
+ * The `bigint` sibling of `range`, which TC39's `Iterator.range` also covers.
+ * Values are accumulated rather than index-scaled, because `bigint` arithmetic
+ * is exact and has nothing to drift.
+ *
+ * Time complexity: O(1) per value.
+ *
+ * @param start The first value, inclusive.
+ * @param stop The bound to stop before, exclusive.
+ * @param step How much to advance by. Must be 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 `step` is zero.
+ */
+export declare function bigIntRange(start: bigint, stop: bigint, step?: bigint): IterableIterator<bigint>;
+//# sourceMappingURL=big-int-range.d.ts.map

package/dist/iterable/big-int-range.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"big-int-range.d.ts","sourceRoot":"","sources":["../../src/iterable/big-int-range.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAiB,WAAW,CAC3B,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,IAAI,SAAK,GACP,gBAAgB,CAAC,MAAM,CAAC,CAc1B"}

package/dist/iterable/big-int-range.js

@@ -0,0 +1,34 @@
+/**
+ * Yields the arithmetic progression from `start` towards `stop`, exclusive,
+ * over `bigint`.
+ *
+ * The `bigint` sibling of `range`, which TC39's `Iterator.range` also covers.
+ * Values are accumulated rather than index-scaled, because `bigint` arithmetic
+ * is exact and has nothing to drift.
+ *
+ * Time complexity: O(1) per value.
+ *
+ * @param start The first value, inclusive.
+ * @param stop The bound to stop before, exclusive.
+ * @param step How much to advance by. Must be 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 `step` is zero.
+ */
+export function* bigIntRange(start, stop, step = 1n) {
+    if (step === 0n) {
+        throw new RangeError("bigIntRange step must be non-zero");
+    }
+    if (step > 0n) {
+        for (let value = start; value < stop; value += step) {
+            yield value;
+        }
+    }
+    else {
+        for (let value = start; value > stop; value += step) {
+            yield value;
+        }
+    }
+}
+//# sourceMappingURL=big-int-range.js.map

package/dist/iterable/big-int-range.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"big-int-range.js","sourceRoot":"","sources":["../../src/iterable/big-int-range.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,SAAS,CAAC,CAAC,WAAW,CAC3B,KAAa,EACb,IAAY,EACZ,IAAI,GAAG,EAAE;IAET,IAAI,IAAI,KAAK,EAAE,EAAE,CAAC;QACjB,MAAM,IAAI,UAAU,CAAC,mCAAmC,CAAC,CAAC;IAC3D,CAAC;IAED,IAAI,IAAI,GAAG,EAAE,EAAE,CAAC;QACf,KAAK,IAAI,KAAK,GAAG,KAAK,EAAE,KAAK,GAAG,IAAI,EAAE,KAAK,IAAI,IAAI,EAAE,CAAC;YACrD,MAAM,KAAK,CAAC;QACb,CAAC;IACF,CAAC;SAAM,CAAC;QACP,KAAK,IAAI,KAAK,GAAG,KAAK,EAAE,KAAK,GAAG,IAAI,EAAE,KAAK,IAAI,IAAI,EAAE,CAAC;YACrD,MAAM,KAAK,CAAC;QACb,CAAC;IACF,CAAC;AACF,CAAC"}

package/dist/iterable/chunk.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Yields consecutive, non-overlapping groups of `size` items.
+ *
+ * The inverse of `Array.prototype.flat()`, which already covers the other
+ * direction natively. A final group shorter than `size` is yielded as-is when
+ * the input length is not a multiple of it.
+ *
+ * Time complexity: O(n).
+ *
+ * @param iterable The input iterable.
+ * @param size How many items per group. Must be a positive integer.
+ * @returns An iterator over the groups.
+ * @throws {RangeError} If `size` is not a positive integer.
+ */
+export declare function chunk<T>(iterable: Iterable<T>, size: number): IterableIterator<T[]>;
+//# sourceMappingURL=chunk.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk.d.ts","sourceRoot":"","sources":["../../src/iterable/chunk.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,wBAAiB,KAAK,CAAC,CAAC,EACvB,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EACrB,IAAI,EAAE,MAAM,GACV,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAmBvB"}

package/dist/iterable/chunk.js

@@ -0,0 +1,31 @@
+/**
+ * Yields consecutive, non-overlapping groups of `size` items.
+ *
+ * The inverse of `Array.prototype.flat()`, which already covers the other
+ * direction natively. A final group shorter than `size` is yielded as-is when
+ * the input length is not a multiple of it.
+ *
+ * Time complexity: O(n).
+ *
+ * @param iterable The input iterable.
+ * @param size How many items per group. Must be a positive integer.
+ * @returns An iterator over the groups.
+ * @throws {RangeError} If `size` is not a positive integer.
+ */
+export function* chunk(iterable, size) {
+    if (!Number.isInteger(size) || size < 1) {
+        throw new RangeError("chunk size must be a positive integer");
+    }
+    let group = [];
+    for (const item of iterable) {
+        group.push(item);
+        if (group.length === size) {
+            yield group;
+            group = [];
+        }
+    }
+    if (group.length > 0) {
+        yield group;
+    }
+}
+//# sourceMappingURL=chunk.js.map

package/dist/iterable/chunk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk.js","sourceRoot":"","sources":["../../src/iterable/chunk.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,SAAS,CAAC,CAAC,KAAK,CACrB,QAAqB,EACrB,IAAY;IAEZ,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,IAAI,GAAG,CAAC,EAAE,CAAC;QACzC,MAAM,IAAI,UAAU,CAAC,uCAAuC,CAAC,CAAC;IAC/D,CAAC;IAED,IAAI,KAAK,GAAQ,EAAE,CAAC;IAEpB,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC7B,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAEjB,IAAI,KAAK,CAAC,MAAM,KAAK,IAAI,EAAE,CAAC;YAC3B,MAAM,KAAK,CAAC;YACZ,KAAK,GAAG,EAAE,CAAC;QACZ,CAAC;IACF,CAAC;IAED,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACtB,MAAM,KAAK,CAAC;IACb,CAAC;AACF,CAAC"}

package/dist/iterable/compact.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Removes null and undefined values from an iterable.
+ *
+ * @param array The input iterable.
+ * @returns An iterator yielding only non-null and non-undefined values.
+ */
+export declare function compact<T extends {}>(iterable: Iterable<T | null | undefined>): IterableIterator<T>;
+//# sourceMappingURL=compact.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compact.d.ts","sourceRoot":"","sources":["../../src/iterable/compact.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAiB,OAAO,CAAC,CAAC,SAAS,EAAE,EACpC,QAAQ,EAAE,QAAQ,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,GACtC,gBAAgB,CAAC,CAAC,CAAC,CAMrB"}

package/dist/iterable/compact.js

@@ -0,0 +1,14 @@
+/**
+ * Removes null and undefined values from an iterable.
+ *
+ * @param array The input iterable.
+ * @returns An iterator yielding only non-null and non-undefined values.
+ */
+export function* compact(iterable) {
+    for (const item of iterable) {
+        if (item !== null && item !== undefined) {
+            yield item;
+        }
+    }
+}
+//# sourceMappingURL=compact.js.map

package/dist/iterable/compact.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compact.js","sourceRoot":"","sources":["../../src/iterable/compact.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,SAAS,CAAC,CAAC,OAAO,CACvB,QAAwC;IAExC,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC7B,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACzC,MAAM,IAAI,CAAC;QACZ,CAAC;IACF,CAAC;AACF,CAAC"}

package/dist/iterable/concat.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Lazily chains any number of iterables into one.
+ *
+ * Time complexity: O(1) to construct; iterating the result is O(n) total across
+ * every source iterable, same as iterating each individually.
+ *
+ * @param iterables The iterables to chain, in order.
+ * @returns An iterator yielding every element of the first iterable, then every
+ *   element of the second, and so on.
+ */
+export declare function concat<T>(...iterables: Iterable<T>[]): IterableIterator<T>;
+//# sourceMappingURL=concat.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"concat.d.ts","sourceRoot":"","sources":["../../src/iterable/concat.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,wBAAiB,MAAM,CAAC,CAAC,EAAE,GAAG,SAAS,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAI3E"}

package/dist/iterable/concat.js

@@ -0,0 +1,16 @@
+/**
+ * Lazily chains any number of iterables into one.
+ *
+ * Time complexity: O(1) to construct; iterating the result is O(n) total across
+ * every source iterable, same as iterating each individually.
+ *
+ * @param iterables The iterables to chain, in order.
+ * @returns An iterator yielding every element of the first iterable, then every
+ *   element of the second, and so on.
+ */
+export function* concat(...iterables) {
+    for (const iterable of iterables) {
+        yield* iterable;
+    }
+}
+//# sourceMappingURL=concat.js.map

package/dist/iterable/concat.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"concat.js","sourceRoot":"","sources":["../../src/iterable/concat.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,SAAS,CAAC,CAAC,MAAM,CAAI,GAAG,SAAwB;IACrD,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;QAClC,KAAK,CAAC,CAAC,QAAQ,CAAC;IACjB,CAAC;AACF,CAAC"}

package/dist/iterable/consume.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Drains an iterable without materialising it, for a pipeline whose side
+ * effects are the point.
+ *
+ * The readable form of an empty-bodied `for…of`, which reads like a mistake.
+ * The iterator is closed when a `count` cuts the drain short.
+ *
+ * Time complexity: O(min(n, count)). Memory: O(1).
+ *
+ * @param iterable The iterable to drain.
+ * @param count How many elements to pull. Must be a non-negative integer or
+ *   `Infinity`, the default, which drains to the end.
+ * @throws {RangeError} If `count` is negative, fractional or `NaN`.
+ */
+export declare function consume(iterable: Iterable<unknown>, count?: number): void;
+//# sourceMappingURL=consume.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"consume.d.ts","sourceRoot":"","sources":["../../src/iterable/consume.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,wBAAgB,OAAO,CACtB,QAAQ,EAAE,QAAQ,CAAC,OAAO,CAAC,EAC3B,KAAK,GAAE,MAAiC,GACtC,IAAI,CAmBN"}

package/dist/iterable/consume.js

@@ -0,0 +1,28 @@
+/**
+ * Drains an iterable without materialising it, for a pipeline whose side
+ * effects are the point.
+ *
+ * The readable form of an empty-bodied `for…of`, which reads like a mistake.
+ * The iterator is closed when a `count` cuts the drain short.
+ *
+ * Time complexity: O(min(n, count)). Memory: O(1).
+ *
+ * @param iterable The iterable to drain.
+ * @param count How many elements to pull. Must be a non-negative integer or
+ *   `Infinity`, the default, which drains to the end.
+ * @throws {RangeError} If `count` is negative, fractional or `NaN`.
+ */
+export function consume(iterable, count = Number.POSITIVE_INFINITY) {
+    if (count !== Number.POSITIVE_INFINITY &&
+        (!Number.isInteger(count) || count < 0)) {
+        throw new RangeError("consume count must be a non-negative integer or Infinity");
+    }
+    const iterator = iterable[Symbol.iterator]();
+    for (let drained = 0; drained < count; drained++) {
+        if (iterator.next().done === true) {
+            return;
+        }
+    }
+    iterator.return?.();
+}
+//# sourceMappingURL=consume.js.map

package/dist/iterable/consume.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"consume.js","sourceRoot":"","sources":["../../src/iterable/consume.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,OAAO,CACtB,QAA2B,EAC3B,KAAK,GAAW,MAAM,CAAC,iBAAiB;IAExC,IACC,KAAK,KAAK,MAAM,CAAC,iBAAiB;QAClC,CAAC,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,CAAC,EACtC,CAAC;QACF,MAAM,IAAI,UAAU,CACnB,0DAA0D,CAC1D,CAAC;IACH,CAAC;IAED,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;IAE7C,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,GAAG,KAAK,EAAE,OAAO,EAAE,EAAE,CAAC;QAClD,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;YACnC,OAAO;QACR,CAAC;IACF,CAAC;IAED,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC;AACrB,CAAC"}

package/dist/iterable/count.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Counts the elements of an iterable, consuming it.
+ *
+ * Named for what it returns rather than `length`, which would promise O(1).
+ *
+ * Time complexity: O(1) for an `Array`, `Set` or `Map`, which already know
+ * their own size; O(n) for anything else, which has to be drained.
+ *
+ * @param iterable The iterable to count.
+ * @returns How many elements it yielded.
+ */
+export declare function count(iterable: Iterable<unknown>): number;
+//# sourceMappingURL=count.d.ts.map