@ac-kit/core 0.1.0

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

@@ -0,0 +1,13 @@
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+/**
+ * Removes null and undefined values from an iterable.
+ *
+ * The async counterpart of `compact`.
+ *
+ * Time complexity: O(1) per element.
+ *
+ * @param iterable The input iterable, sync or async.
+ * @returns An iterator yielding only non-null and non-undefined values.
+ */
+export declare function compactAsync<T extends {}>(iterable: MaybeAsyncIterable<T | null | undefined>): AsyncIterableIterator<T>;
+//# sourceMappingURL=compact.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compact.d.ts","sourceRoot":"","sources":["../../../src/iterable/async/compact.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE;;;;;;;;;GASG;AACH,wBAAuB,YAAY,CAAC,CAAC,SAAS,EAAE,EAC/C,QAAQ,EAAE,kBAAkB,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,GAChD,qBAAqB,CAAC,CAAC,CAAC,CAM1B"}

package/dist/iterable/async/compact.js

@@ -0,0 +1,18 @@
+/**
+ * Removes null and undefined values from an iterable.
+ *
+ * The async counterpart of `compact`.
+ *
+ * Time complexity: O(1) per element.
+ *
+ * @param iterable The input iterable, sync or async.
+ * @returns An iterator yielding only non-null and non-undefined values.
+ */
+export async function* compactAsync(iterable) {
+    for await (const item of iterable) {
+        if (item !== null && item !== undefined) {
+            yield item;
+        }
+    }
+}
+//# sourceMappingURL=compact.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"compact.js","sourceRoot":"","sources":["../../../src/iterable/async/compact.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,SAAS,CAAC,CAAC,YAAY,CAClC,QAAkD;IAElD,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QACnC,IAAI,IAAI,KAAK,IAAI,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACzC,MAAM,IAAI,CAAC;QACZ,CAAC;IACF,CAAC;AACF,CAAC"}

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

@@ -0,0 +1,16 @@
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+/**
+ * Lazily chains any number of iterables into one.
+ *
+ * The async counterpart of `concat`. Sources may be freely mixed: an array and
+ * a stream can be chained together.
+ *
+ * Time complexity: O(1) to construct; iterating the result is O(n) total across
+ * every source iterable.
+ *
+ * @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 concatAsync<T>(...iterables: MaybeAsyncIterable<T>[]): AsyncIterableIterator<T>;
+//# sourceMappingURL=concat.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"concat.d.ts","sourceRoot":"","sources":["../../../src/iterable/async/concat.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE;;;;;;;;;;;;GAYG;AACH,wBAAuB,WAAW,CAAC,CAAC,EACnC,GAAG,SAAS,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAAE,GACnC,qBAAqB,CAAC,CAAC,CAAC,CAI1B"}

package/dist/iterable/async/concat.js

@@ -0,0 +1,19 @@
+/**
+ * Lazily chains any number of iterables into one.
+ *
+ * The async counterpart of `concat`. Sources may be freely mixed: an array and
+ * a stream can be chained together.
+ *
+ * Time complexity: O(1) to construct; iterating the result is O(n) total across
+ * every source iterable.
+ *
+ * @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 async function* concatAsync(...iterables) {
+    for (const iterable of iterables) {
+        yield* iterable;
+    }
+}
+//# sourceMappingURL=concat.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"concat.js","sourceRoot":"","sources":["../../../src/iterable/async/concat.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,SAAS,CAAC,CAAC,WAAW,CACjC,GAAG,SAAkC;IAErC,KAAK,MAAM,QAAQ,IAAI,SAAS,EAAE,CAAC;QAClC,KAAK,CAAC,CAAC,QAAQ,CAAC;IACjB,CAAC;AACF,CAAC"}

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

@@ -0,0 +1,19 @@
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+/**
+ * Drains an iterable without materialising it, for a pipeline whose side
+ * effects are the point.
+ *
+ * The async counterpart of `consume`, and the readable form of an empty-bodied
+ * `for await…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, sync or async.
+ * @param count How many elements to pull. Must be a non-negative integer or
+ *   `Infinity`, the default, which drains to the end.
+ * @param signal Aborts the drain.
+ * @throws {RangeError} If `count` is negative, fractional or `NaN`.
+ */
+export declare function consumeAsync(iterable: MaybeAsyncIterable<unknown>, count?: number, signal?: AbortSignal): Promise<void>;
+//# sourceMappingURL=consume.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"consume.d.ts","sourceRoot":"","sources":["../../../src/iterable/async/consume.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAGlE;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,YAAY,CACjC,QAAQ,EAAE,kBAAkB,CAAC,OAAO,CAAC,EACrC,KAAK,GAAE,MAAiC,EACxC,MAAM,CAAC,EAAE,WAAW,GAClB,OAAO,CAAC,IAAI,CAAC,CAuBf"}

package/dist/iterable/async/consume.js

@@ -0,0 +1,33 @@
+import { asyncIteratorOf_ } from "./_async-iterator.js";
+/**
+ * Drains an iterable without materialising it, for a pipeline whose side
+ * effects are the point.
+ *
+ * The async counterpart of `consume`, and the readable form of an empty-bodied
+ * `for await…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, sync or async.
+ * @param count How many elements to pull. Must be a non-negative integer or
+ *   `Infinity`, the default, which drains to the end.
+ * @param signal Aborts the drain.
+ * @throws {RangeError} If `count` is negative, fractional or `NaN`.
+ */
+export async function consumeAsync(iterable, count = Number.POSITIVE_INFINITY, signal) {
+    if (count !== Number.POSITIVE_INFINITY &&
+        (!Number.isInteger(count) || count < 0)) {
+        throw new RangeError("consumeAsync count must be a non-negative integer or Infinity");
+    }
+    signal?.throwIfAborted();
+    const iterator = asyncIteratorOf_(iterable);
+    for (let drained = 0; drained < count; drained++) {
+        if ((await iterator.next()).done === true) {
+            return;
+        }
+        signal?.throwIfAborted();
+    }
+    await iterator.return?.();
+}
+//# sourceMappingURL=consume.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"consume.js","sourceRoot":"","sources":["../../../src/iterable/async/consume.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAExD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,KAAK,UAAU,YAAY,CACjC,QAAqC,EACrC,KAAK,GAAW,MAAM,CAAC,iBAAiB,EACxC,MAAoB;IAEpB,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,+DAA+D,CAC/D,CAAC;IACH,CAAC;IAED,MAAM,EAAE,cAAc,EAAE,CAAC;IAEzB,MAAM,QAAQ,GAAG,gBAAgB,CAAC,QAAQ,CAAC,CAAC;IAE5C,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,GAAG,KAAK,EAAE,OAAO,EAAE,EAAE,CAAC;QAClD,IAAI,CAAC,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;YAC3C,OAAO;QACR,CAAC;QAED,MAAM,EAAE,cAAc,EAAE,CAAC;IAC1B,CAAC;IAED,MAAM,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC;AAC3B,CAAC"}

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

@@ -0,0 +1,15 @@
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+/**
+ * Counts the elements of an iterable, consuming it.
+ *
+ * The async counterpart of `count`, without its O(1) fast paths: a stream has
+ * no size to read.
+ *
+ * Time complexity: O(n).
+ *
+ * @param iterable The iterable to count, sync or async.
+ * @param signal Aborts the count.
+ * @returns How many elements it yielded.
+ */
+export declare function countAsync(iterable: MaybeAsyncIterable<unknown>, signal?: AbortSignal): Promise<number>;
+//# sourceMappingURL=count.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"count.d.ts","sourceRoot":"","sources":["../../../src/iterable/async/count.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAGlE;;;;;;;;;;;GAWG;AACH,wBAAsB,UAAU,CAC/B,QAAQ,EAAE,kBAAkB,CAAC,OAAO,CAAC,EACrC,MAAM,CAAC,EAAE,WAAW,GAClB,OAAO,CAAC,MAAM,CAAC,CAYjB"}

package/dist/iterable/async/count.js

@@ -0,0 +1,24 @@
+import { asyncIteratorOf_ } from "./_async-iterator.js";
+/**
+ * Counts the elements of an iterable, consuming it.
+ *
+ * The async counterpart of `count`, without its O(1) fast paths: a stream has
+ * no size to read.
+ *
+ * Time complexity: O(n).
+ *
+ * @param iterable The iterable to count, sync or async.
+ * @param signal Aborts the count.
+ * @returns How many elements it yielded.
+ */
+export async function countAsync(iterable, signal) {
+    signal?.throwIfAborted();
+    const iterator = asyncIteratorOf_(iterable);
+    let total = 0;
+    while ((await iterator.next()).done !== true) {
+        signal?.throwIfAborted();
+        total++;
+    }
+    return total;
+}
+//# sourceMappingURL=count.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"count.js","sourceRoot":"","sources":["../../../src/iterable/async/count.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAExD;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,UAAU,CAC/B,QAAqC,EACrC,MAAoB;IAEpB,MAAM,EAAE,cAAc,EAAE,CAAC;IAEzB,MAAM,QAAQ,GAAG,gBAAgB,CAAC,QAAQ,CAAC,CAAC;IAC5C,IAAI,KAAK,GAAG,CAAC,CAAC;IAEd,OAAO,CAAC,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;QAC9C,MAAM,EAAE,cAAc,EAAE,CAAC;QACzB,KAAK,EAAE,CAAC;IACT,CAAC;IAED,OAAO,KAAK,CAAC;AACd,CAAC"}

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

@@ -0,0 +1,19 @@
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+/**
+ * Yields the whole iterable `times` times over.
+ *
+ * The async counterpart of `cycle`. The source is pulled once and buffered,
+ * because an iterator cannot be restarted, so the whole of it is held in memory
+ * from the first pass onwards. Later passes yield from the buffer and never
+ * await.
+ *
+ * Time complexity: O(n × times). Memory: O(n).
+ *
+ * @param iterable The input iterable, sync or async.
+ * @param times How many passes to yield. Must be a non-negative integer or
+ *   `Infinity`, which repeats forever.
+ * @returns An iterator over the repeated elements.
+ * @throws {RangeError} If `times` is negative, fractional or `NaN`.
+ */
+export declare function cycleAsync<T>(iterable: MaybeAsyncIterable<T>, times?: number): AsyncIterableIterator<T>;
+//# sourceMappingURL=cycle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cycle.d.ts","sourceRoot":"","sources":["../../../src/iterable/async/cycle.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE;;;;;;;;;;;;;;;GAeG;AACH,wBAAuB,UAAU,CAAC,CAAC,EAClC,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC/B,KAAK,GAAE,MAAiC,GACtC,qBAAqB,CAAC,CAAC,CAAC,CA4B1B"}

package/dist/iterable/async/cycle.js

@@ -0,0 +1,37 @@
+/**
+ * Yields the whole iterable `times` times over.
+ *
+ * The async counterpart of `cycle`. The source is pulled once and buffered,
+ * because an iterator cannot be restarted, so the whole of it is held in memory
+ * from the first pass onwards. Later passes yield from the buffer and never
+ * await.
+ *
+ * Time complexity: O(n × times). Memory: O(n).
+ *
+ * @param iterable The input iterable, sync or async.
+ * @param times How many passes to yield. Must be a non-negative integer or
+ *   `Infinity`, which repeats forever.
+ * @returns An iterator over the repeated elements.
+ * @throws {RangeError} If `times` is negative, fractional or `NaN`.
+ */
+export async function* cycleAsync(iterable, times = Number.POSITIVE_INFINITY) {
+    if (times !== Number.POSITIVE_INFINITY &&
+        (!Number.isInteger(times) || times < 0)) {
+        throw new RangeError("cycleAsync times must be a non-negative integer or Infinity");
+    }
+    if (times === 0) {
+        return;
+    }
+    const buffer = [];
+    for await (const item of iterable) {
+        buffer.push(item);
+        yield item;
+    }
+    if (buffer.length === 0) {
+        return;
+    }
+    for (let pass = 1; pass < times; pass++) {
+        yield* buffer;
+    }
+}
+//# sourceMappingURL=cycle.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cycle.js","sourceRoot":"","sources":["../../../src/iterable/async/cycle.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,KAAK,SAAS,CAAC,CAAC,UAAU,CAChC,QAA+B,EAC/B,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,6DAA6D,CAC7D,CAAC;IACH,CAAC;IAED,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;QACjB,OAAO;IACR,CAAC;IAED,MAAM,MAAM,GAAQ,EAAE,CAAC;IAEvB,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QACnC,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QAClB,MAAM,IAAI,CAAC;IACZ,CAAC;IAED,IAAI,MAAM,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACzB,OAAO;IACR,CAAC;IAED,KAAK,IAAI,IAAI,GAAG,CAAC,EAAE,IAAI,GAAG,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC;QACzC,KAAK,CAAC,CAAC,MAAM,CAAC;IACf,CAAC;AACF,CAAC"}

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

@@ -0,0 +1,17 @@
+import type { MaybeAsyncCallable } from "../../types/callable.js";
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+/**
+ * Yields the difference between each element and the one before it.
+ *
+ * The async counterpart of `deltas`. `subtract` is required rather than
+ * defaulting to numeric subtraction, and receives `(current, previous)`.
+ *
+ * Time complexity: O(1) per element, plus whatever `subtract` costs.
+ *
+ * @param iterable The input iterable, sync or async.
+ * @param subtract Computes the difference between an element and its
+ *   predecessor.
+ * @returns An iterator over the consecutive differences.
+ */
+export declare function deltasAsync<T, D>(iterable: MaybeAsyncIterable<T>, subtract: MaybeAsyncCallable<[T, T], D>): AsyncIterableIterator<D>;
+//# sourceMappingURL=deltas.d.ts.map

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

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

package/dist/iterable/async/deltas.js

@@ -0,0 +1,25 @@
+/**
+ * Yields the difference between each element and the one before it.
+ *
+ * The async counterpart of `deltas`. `subtract` is required rather than
+ * defaulting to numeric subtraction, and receives `(current, previous)`.
+ *
+ * Time complexity: O(1) per element, plus whatever `subtract` costs.
+ *
+ * @param iterable The input iterable, sync or async.
+ * @param subtract Computes the difference between an element and its
+ *   predecessor.
+ * @returns An iterator over the consecutive differences.
+ */
+export async function* deltasAsync(iterable, subtract) {
+    let previous;
+    let hasPrevious = false;
+    for await (const item of iterable) {
+        if (hasPrevious) {
+            yield await subtract(item, previous);
+        }
+        previous = item;
+        hasPrevious = true;
+    }
+}
+//# sourceMappingURL=deltas.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deltas.js","sourceRoot":"","sources":["../../../src/iterable/async/deltas.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,SAAS,CAAC,CAAC,WAAW,CACjC,QAA+B,EAC/B,QAAuC;IAEvC,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,MAAM,QAAQ,CAAC,IAAI,EAAE,QAAS,CAAC,CAAC;QACvC,CAAC;QAED,QAAQ,GAAG,IAAI,CAAC;QAChB,WAAW,GAAG,IAAI,CAAC;IACpB,CAAC;AACF,CAAC"}

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

@@ -0,0 +1,18 @@
+import type { MaybeAsyncPredicate } from "../../types/callable.js";
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+/**
+ * Skips elements from the start for as long as `predicate` holds, then yields
+ * everything from the first rejected element onwards.
+ *
+ * The async counterpart of `dropWhile`. The predicate is not consulted again
+ * once it has rejected.
+ *
+ * Time complexity: O(1) per element.
+ *
+ * @param iterable The input iterable, sync or async.
+ * @param predicate Receives each element and its zero-based index. Skipping
+ *   stops the first time it resolves `false`.
+ * @returns An iterator over the elements from the first rejection onwards.
+ */
+export declare function dropWhileAsync<T>(iterable: MaybeAsyncIterable<T>, predicate: MaybeAsyncPredicate<[T, number]>): AsyncIterableIterator<T>;
+//# sourceMappingURL=drop-while.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"drop-while.d.ts","sourceRoot":"","sources":["../../../src/iterable/async/drop-while.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE;;;;;;;;;;;;;GAaG;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,CAY1B"}

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

@@ -0,0 +1,26 @@
+/**
+ * Skips elements from the start for as long as `predicate` holds, then yields
+ * everything from the first rejected element onwards.
+ *
+ * The async counterpart of `dropWhile`. The predicate is not consulted again
+ * once it has rejected.
+ *
+ * Time complexity: O(1) per element.
+ *
+ * @param iterable The input iterable, sync or async.
+ * @param predicate Receives each element and its zero-based index. Skipping
+ *   stops the first time it resolves `false`.
+ * @returns An iterator over the elements from the first rejection onwards.
+ */
+export async function* dropWhileAsync(iterable, predicate) {
+    let index = 0;
+    let dropping = true;
+    for await (const item of iterable) {
+        if (dropping && (await predicate(item, index++))) {
+            continue;
+        }
+        dropping = false;
+        yield item;
+    }
+}
+//# sourceMappingURL=drop-while.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"drop-while.js","sourceRoot":"","sources":["../../../src/iterable/async/drop-while.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,KAAK,SAAS,CAAC,CAAC,cAAc,CACpC,QAA+B,EAC/B,SAA2C;IAE3C,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,IAAI,QAAQ,GAAG,IAAI,CAAC;IAEpB,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QACnC,IAAI,QAAQ,IAAI,CAAC,MAAM,SAAS,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC;YAClD,SAAS;QACV,CAAC;QAED,QAAQ,GAAG,KAAK,CAAC;QACjB,MAAM,IAAI,CAAC;IACZ,CAAC;AACF,CAAC"}

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

@@ -0,0 +1,17 @@
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+/**
+ * Yields everything after the first `count` elements.
+ *
+ * The async counterpart of `drop`. An input shorter than `count` yields
+ * nothing.
+ *
+ * Time complexity: O(n) — the skipped elements are still pulled from the
+ * source, because an iterable offers no way to seek past them.
+ *
+ * @param iterable The input iterable, sync or async.
+ * @param count How many elements to skip. Must be a non-negative integer.
+ * @returns An iterator over the remaining elements.
+ * @throws {RangeError} If `count` is not a non-negative integer.
+ */
+export declare function dropAsync<T>(iterable: MaybeAsyncIterable<T>, count: number): AsyncIterableIterator<T>;
+//# sourceMappingURL=drop.d.ts.map

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

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

package/dist/iterable/async/drop.js

@@ -0,0 +1,28 @@
+/**
+ * Yields everything after the first `count` elements.
+ *
+ * The async counterpart of `drop`. An input shorter than `count` yields
+ * nothing.
+ *
+ * Time complexity: O(n) — the skipped elements are still pulled from the
+ * source, because an iterable offers no way to seek past them.
+ *
+ * @param iterable The input iterable, sync or async.
+ * @param count How many elements to skip. Must be a non-negative integer.
+ * @returns An iterator over the remaining elements.
+ * @throws {RangeError} If `count` is not a non-negative integer.
+ */
+export async function* dropAsync(iterable, count) {
+    if (!Number.isInteger(count) || count < 0) {
+        throw new RangeError("dropAsync count must be a non-negative integer");
+    }
+    let dropped = 0;
+    for await (const item of iterable) {
+        if (dropped < count) {
+            dropped++;
+            continue;
+        }
+        yield item;
+    }
+}
+//# sourceMappingURL=drop.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"drop.js","sourceRoot":"","sources":["../../../src/iterable/async/drop.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;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,OAAO,GAAG,CAAC,CAAC;IAEhB,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QACnC,IAAI,OAAO,GAAG,KAAK,EAAE,CAAC;YACrB,OAAO,EAAE,CAAC;YACV,SAAS;QACV,CAAC;QAED,MAAM,IAAI,CAAC;IACZ,CAAC;AACF,CAAC"}

package/dist/iterable/async/filter-map.d.ts

@@ -0,0 +1,20 @@
+import type { MaybeAsyncCallable } from "../../types/callable.js";
+import type { DefinedValue } from "../../types/defined-value.js";
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+/**
+ * Maps and filters in one pass: yields every mapped value except the ones the
+ * mapper declines to produce.
+ *
+ * The async counterpart of `filterMap`. `undefined` is the decline signal, and
+ * the result type cannot include it, so "no value here" is never confused with
+ * "the value is `undefined`".
+ *
+ * Time complexity: O(1) per element, plus whatever `mapper` costs.
+ *
+ * @param iterable The input iterable, sync or async.
+ * @param mapper Receives each element and its zero-based index. Resolves to the
+ *   mapped value, or `undefined` to drop the element.
+ * @returns An iterator over the produced values.
+ */
+export declare function filterMapAsync<T, R extends DefinedValue>(iterable: MaybeAsyncIterable<T>, mapper: MaybeAsyncCallable<[T, number], R | undefined>): AsyncIterableIterator<R>;
+//# sourceMappingURL=filter-map.d.ts.map

package/dist/iterable/async/filter-map.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-map.d.ts","sourceRoot":"","sources":["../../../src/iterable/async/filter-map.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE;;;;;;;;;;;;;;GAcG;AACH,wBAAuB,cAAc,CAAC,CAAC,EAAE,CAAC,SAAS,YAAY,EAC9D,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC/B,MAAM,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,GACpD,qBAAqB,CAAC,CAAC,CAAC,CAU1B"}

package/dist/iterable/async/filter-map.js

@@ -0,0 +1,25 @@
+/**
+ * Maps and filters in one pass: yields every mapped value except the ones the
+ * mapper declines to produce.
+ *
+ * The async counterpart of `filterMap`. `undefined` is the decline signal, and
+ * the result type cannot include it, so "no value here" is never confused with
+ * "the value is `undefined`".
+ *
+ * Time complexity: O(1) per element, plus whatever `mapper` costs.
+ *
+ * @param iterable The input iterable, sync or async.
+ * @param mapper Receives each element and its zero-based index. Resolves to the
+ *   mapped value, or `undefined` to drop the element.
+ * @returns An iterator over the produced values.
+ */
+export async function* filterMapAsync(iterable, mapper) {
+    let index = 0;
+    for await (const item of iterable) {
+        const mapped = await mapper(item, index++);
+        if (mapped !== undefined) {
+            yield mapped;
+        }
+    }
+}
+//# sourceMappingURL=filter-map.js.map

package/dist/iterable/async/filter-map.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"filter-map.js","sourceRoot":"","sources":["../../../src/iterable/async/filter-map.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,KAAK,SAAS,CAAC,CAAC,cAAc,CACpC,QAA+B,EAC/B,MAAsD;IAEtD,IAAI,KAAK,GAAG,CAAC,CAAC;IAEd,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QACnC,MAAM,MAAM,GAAG,MAAM,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;QAE3C,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;YAC1B,MAAM,MAAM,CAAC;QACd,CAAC;IACF,CAAC;AACF,CAAC"}

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

@@ -0,0 +1,16 @@
+import type { DefinedValue } from "../../types/defined-value.js";
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+/**
+ * Returns the first element, or `undefined` when the iterable is empty.
+ *
+ * The async counterpart of `first`. `T` cannot itself include `undefined`, so
+ * the absent case is never ambiguous.
+ *
+ * Time complexity: O(1). The iterator is closed without being drained.
+ *
+ * @param iterable The iterable to read from, sync or async.
+ * @param signal Aborts the read.
+ * @returns The first element, or `undefined` if there is none.
+ */
+export declare function firstAsync<T extends DefinedValue>(iterable: MaybeAsyncIterable<T>, signal?: AbortSignal): Promise<T | undefined>;
+//# sourceMappingURL=first.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"first.d.ts","sourceRoot":"","sources":["../../../src/iterable/async/first.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE;;;;;;;;;;;GAWG;AACH,wBAAsB,UAAU,CAAC,CAAC,SAAS,YAAY,EACtD,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC/B,MAAM,CAAC,EAAE,WAAW,GAClB,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAQxB"}

package/dist/iterable/async/first.js

@@ -0,0 +1,20 @@
+/**
+ * Returns the first element, or `undefined` when the iterable is empty.
+ *
+ * The async counterpart of `first`. `T` cannot itself include `undefined`, so
+ * the absent case is never ambiguous.
+ *
+ * Time complexity: O(1). The iterator is closed without being drained.
+ *
+ * @param iterable The iterable to read from, sync or async.
+ * @param signal Aborts the read.
+ * @returns The first element, or `undefined` if there is none.
+ */
+export async function firstAsync(iterable, signal) {
+    signal?.throwIfAborted();
+    for await (const item of iterable) {
+        return item;
+    }
+    return undefined;
+}
+//# sourceMappingURL=first.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"first.js","sourceRoot":"","sources":["../../../src/iterable/async/first.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,UAAU,UAAU,CAC/B,QAA+B,EAC/B,MAAoB;IAEpB,MAAM,EAAE,cAAc,EAAE,CAAC;IAEzB,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QACnC,OAAO,IAAI,CAAC;IACb,CAAC;IAED,OAAO,SAAS,CAAC;AAClB,CAAC"}

package/dist/iterable/async/flatten-deep.d.ts

@@ -0,0 +1,21 @@
+/**
+ * An iterable whose elements are either `T` or another iterable of the same
+ * shape, to any depth, sync or async at every level.
+ *
+ * Written as an explicit union rather than through `MaybeAsyncIterable` so the
+ * recursion sits under an interface, which is what lets TypeScript defer it.
+ */
+export type NestedAsyncIterable<T> = Iterable<T | NestedAsyncIterable<T>> | AsyncIterable<T | NestedAsyncIterable<T>>;
+/**
+ * Lazily flattens nested iterables to any depth.
+ *
+ * The async counterpart of `flattenDeep`, and it shares the rule that matters:
+ * a `string` is never descended into, even though it is iterable.
+ *
+ * Time complexity: O(n) over the total number of leaves.
+ *
+ * @param iterable The nested iterable to flatten.
+ * @returns An iterator over the leaves, in order.
+ */
+export declare function flattenDeepAsync<T>(iterable: NestedAsyncIterable<T>): AsyncIterableIterator<T>;
+//# sourceMappingURL=flatten-deep.d.ts.map

package/dist/iterable/async/flatten-deep.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flatten-deep.d.ts","sourceRoot":"","sources":["../../../src/iterable/async/flatten-deep.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,MAAM,mBAAmB,CAAC,CAAC,IAC9B,QAAQ,CAAC,CAAC,GAAG,mBAAmB,CAAC,CAAC,CAAC,CAAC,GACpC,aAAa,CAAC,CAAC,GAAG,mBAAmB,CAAC,CAAC,CAAC,CAAC,CAAC;AAE7C;;;;;;;;;;GAUG;AACH,wBAAuB,gBAAgB,CAAC,CAAC,EACxC,QAAQ,EAAE,mBAAmB,CAAC,CAAC,CAAC,GAC9B,qBAAqB,CAAC,CAAC,CAAC,CAQ1B"}

package/dist/iterable/async/flatten-deep.js

@@ -0,0 +1,28 @@
+/**
+ * Lazily flattens nested iterables to any depth.
+ *
+ * The async counterpart of `flattenDeep`, and it shares the rule that matters:
+ * a `string` is never descended into, even though it is iterable.
+ *
+ * Time complexity: O(n) over the total number of leaves.
+ *
+ * @param iterable The nested iterable to flatten.
+ * @returns An iterator over the leaves, in order.
+ */
+export async function* flattenDeepAsync(iterable) {
+    for await (const item of iterable) {
+        if (isNestedAsyncIterable_(item)) {
+            yield* flattenDeepAsync(item);
+        }
+        else {
+            yield item;
+        }
+    }
+}
+// `typeof === "object"` is what excludes `string`: it is iterable but primitive.
+function isNestedAsyncIterable_(item) {
+    return (typeof item === "object" &&
+        item !== null &&
+        (Symbol.iterator in item || Symbol.asyncIterator in item));
+}
+//# sourceMappingURL=flatten-deep.js.map

package/dist/iterable/async/flatten-deep.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flatten-deep.js","sourceRoot":"","sources":["../../../src/iterable/async/flatten-deep.ts"],"names":[],"mappings":"AAWA;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,SAAS,CAAC,CAAC,gBAAgB,CACtC,QAAgC;IAEhC,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QACnC,IAAI,sBAAsB,CAAC,IAAI,CAAC,EAAE,CAAC;YAClC,KAAK,CAAC,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;QAC/B,CAAC;aAAM,CAAC;YACP,MAAM,IAAI,CAAC;QACZ,CAAC;IACF,CAAC;AACF,CAAC;AAED,iFAAiF;AACjF,SAAS,sBAAsB,CAC9B,IAAgC;IAEhC,OAAO,CACN,OAAO,IAAI,KAAK,QAAQ;QACxB,IAAI,KAAK,IAAI;QACb,CAAC,MAAM,CAAC,QAAQ,IAAI,IAAI,IAAI,MAAM,CAAC,aAAa,IAAI,IAAI,CAAC,CACzD,CAAC;AACH,CAAC"}

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

@@ -0,0 +1,14 @@
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+/**
+ * Lazily concatenates an iterable of iterables, one level deep.
+ *
+ * The async counterpart of `flatten`. Both levels may be sync or async, so a
+ * stream of arrays and an array of streams both flatten.
+ *
+ * Time complexity: O(1) to construct; O(n) total across every inner iterable.
+ *
+ * @param iterable The iterable of iterables to flatten.
+ * @returns An iterator over every element of every inner iterable, in order.
+ */
+export declare function flattenAsync<T>(iterable: MaybeAsyncIterable<MaybeAsyncIterable<T>>): AsyncIterableIterator<T>;
+//# sourceMappingURL=flatten.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flatten.d.ts","sourceRoot":"","sources":["../../../src/iterable/async/flatten.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE;;;;;;;;;;GAUG;AACH,wBAAuB,YAAY,CAAC,CAAC,EACpC,QAAQ,EAAE,kBAAkB,CAAC,kBAAkB,CAAC,CAAC,CAAC,CAAC,GACjD,qBAAqB,CAAC,CAAC,CAAC,CAI1B"}

package/dist/iterable/async/flatten.js

@@ -0,0 +1,17 @@
+/**
+ * Lazily concatenates an iterable of iterables, one level deep.
+ *
+ * The async counterpart of `flatten`. Both levels may be sync or async, so a
+ * stream of arrays and an array of streams both flatten.
+ *
+ * Time complexity: O(1) to construct; O(n) total across every inner iterable.
+ *
+ * @param iterable The iterable of iterables to flatten.
+ * @returns An iterator over every element of every inner iterable, in order.
+ */
+export async function* flattenAsync(iterable) {
+    for await (const inner of iterable) {
+        yield* inner;
+    }
+}
+//# sourceMappingURL=flatten.js.map