@ac-kit/core 0.1.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"flatten.js","sourceRoot":"","sources":["../../../src/iterable/async/flatten.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,SAAS,CAAC,CAAC,YAAY,CAClC,QAAmD;IAEnD,IAAI,KAAK,EAAE,MAAM,KAAK,IAAI,QAAQ,EAAE,CAAC;QACpC,KAAK,CAAC,CAAC,KAAK,CAAC;IACd,CAAC;AACF,CAAC"}

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

@@ -0,0 +1,18 @@
+import { type EqualityComparator } from "../../object/is-equal.js";
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+/**
+ * Checks whether `item` occurs in `iterable`.
+ *
+ * The async counterpart of `includes`.
+ *
+ * Time complexity: O(n), short-circuiting on the first match.
+ *
+ * @param iterable The iterable to search, sync or async.
+ * @param item The item to search for.
+ * @param comparator The equality comparison function to use (default is
+ *   `isEqual` with "sameValueZero" strategy).
+ * @param signal Aborts the search.
+ * @returns `true` if a matching item was found, `false` otherwise.
+ */
+export declare function includesAsync<T>(iterable: MaybeAsyncIterable<T>, item: T, comparator?: EqualityComparator<T, T>, signal?: AbortSignal): Promise<boolean>;
+//# sourceMappingURL=includes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"includes.d.ts","sourceRoot":"","sources":["../../../src/iterable/async/includes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,kBAAkB,EAAW,MAAM,0BAA0B,CAAC;AAC5E,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE;;;;;;;;;;;;;GAaG;AACH,wBAAsB,aAAa,CAAC,CAAC,EACpC,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC/B,IAAI,EAAE,CAAC,EACP,UAAU,GAAE,kBAAkB,CAAC,CAAC,EAAE,CAAC,CACJ,EAC/B,MAAM,CAAC,EAAE,WAAW,GAClB,OAAO,CAAC,OAAO,CAAC,CAYlB"}

package/dist/iterable/async/includes.js

@@ -0,0 +1,26 @@
+import { isEqual } from "../../object/is-equal.js";
+/**
+ * Checks whether `item` occurs in `iterable`.
+ *
+ * The async counterpart of `includes`.
+ *
+ * Time complexity: O(n), short-circuiting on the first match.
+ *
+ * @param iterable The iterable to search, sync or async.
+ * @param item The item to search for.
+ * @param comparator The equality comparison function to use (default is
+ *   `isEqual` with "sameValueZero" strategy).
+ * @param signal Aborts the search.
+ * @returns `true` if a matching item was found, `false` otherwise.
+ */
+export async function includesAsync(iterable, item, comparator = (a, b) => isEqual(a, b, "sameValueZero"), signal) {
+    signal?.throwIfAborted();
+    for await (const candidate of iterable) {
+        signal?.throwIfAborted();
+        if (comparator(candidate, item)) {
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=includes.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"includes.js","sourceRoot":"","sources":["../../../src/iterable/async/includes.ts"],"names":[],"mappings":"AAAA,OAAO,EAA2B,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAG5E;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,KAAK,UAAU,aAAa,CAClC,QAA+B,EAC/B,IAAO,EACP,UAAU,GAA6B,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAC/C,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,eAAe,CAAC,EAC/B,MAAoB;IAEpB,MAAM,EAAE,cAAc,EAAE,CAAC;IAEzB,IAAI,KAAK,EAAE,MAAM,SAAS,IAAI,QAAQ,EAAE,CAAC;QACxC,MAAM,EAAE,cAAc,EAAE,CAAC;QAEzB,IAAI,UAAU,CAAC,SAAS,EAAE,IAAI,CAAC,EAAE,CAAC;YACjC,OAAO,IAAI,CAAC;QACb,CAAC;IACF,CAAC;IAED,OAAO,KAAK,CAAC;AACd,CAAC"}

package/dist/iterable/async/indices-where.d.ts

@@ -0,0 +1,31 @@
+import type { MaybeAsyncPredicate } from "../../types/callable.js";
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+/**
+ * Yields the zero-based index of every element satisfying `predicate`, rather
+ * than the elements themselves.
+ *
+ * The async counterpart of `indicesWhere`.
+ *
+ * Time complexity: O(1) per element.
+ *
+ * @param iterable The input iterable, sync or async.
+ * @param predicate Receives each element and its zero-based index.
+ * @returns An iterator over the matching indices, ascending.
+ */
+export declare function indicesWhereAsync<T>(iterable: MaybeAsyncIterable<T>, predicate: MaybeAsyncPredicate<[T, number]>): AsyncIterableIterator<number>;
+/**
+ * Yields the zero-based index of every element satisfying `predicate`, scanning
+ * from the end.
+ *
+ * The async counterpart of `lastIndicesWhere`. An async source has no end to
+ * start from, so the whole of it is materialised first and held in memory.
+ *
+ * Time complexity: O(n). Memory: O(n).
+ *
+ * @param iterable The input iterable, sync or async.
+ * @param predicate Receives each element and its zero-based index.
+ * @param signal Aborts the materialisation.
+ * @returns An iterator over the matching indices, descending.
+ */
+export declare function lastIndicesWhereAsync<T>(iterable: MaybeAsyncIterable<T>, predicate: MaybeAsyncPredicate<[T, number]>, signal?: AbortSignal): AsyncIterableIterator<number>;
+//# sourceMappingURL=indices-where.d.ts.map

package/dist/iterable/async/indices-where.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"indices-where.d.ts","sourceRoot":"","sources":["../../../src/iterable/async/indices-where.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AACnE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE;;;;;;;;;;;GAWG;AACH,wBAAuB,iBAAiB,CAAC,CAAC,EACzC,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC/B,SAAS,EAAE,mBAAmB,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,GACzC,qBAAqB,CAAC,MAAM,CAAC,CAU/B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAuB,qBAAqB,CAAC,CAAC,EAC7C,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC/B,SAAS,EAAE,mBAAmB,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,EAC3C,MAAM,CAAC,EAAE,WAAW,GAClB,qBAAqB,CAAC,MAAM,CAAC,CAe/B"}

package/dist/iterable/async/indices-where.js

@@ -0,0 +1,49 @@
+/**
+ * Yields the zero-based index of every element satisfying `predicate`, rather
+ * than the elements themselves.
+ *
+ * The async counterpart of `indicesWhere`.
+ *
+ * Time complexity: O(1) per element.
+ *
+ * @param iterable The input iterable, sync or async.
+ * @param predicate Receives each element and its zero-based index.
+ * @returns An iterator over the matching indices, ascending.
+ */
+export async function* indicesWhereAsync(iterable, predicate) {
+    let index = 0;
+    for await (const item of iterable) {
+        if (await predicate(item, index)) {
+            yield index;
+        }
+        index++;
+    }
+}
+/**
+ * Yields the zero-based index of every element satisfying `predicate`, scanning
+ * from the end.
+ *
+ * The async counterpart of `lastIndicesWhere`. An async source has no end to
+ * start from, so the whole of it is materialised first and held in memory.
+ *
+ * Time complexity: O(n). Memory: O(n).
+ *
+ * @param iterable The input iterable, sync or async.
+ * @param predicate Receives each element and its zero-based index.
+ * @param signal Aborts the materialisation.
+ * @returns An iterator over the matching indices, descending.
+ */
+export async function* lastIndicesWhereAsync(iterable, predicate, signal) {
+    signal?.throwIfAborted();
+    const items = [];
+    for await (const item of iterable) {
+        signal?.throwIfAborted();
+        items.push(item);
+    }
+    for (let index = items.length - 1; index >= 0; index--) {
+        if (await predicate(items[index], index)) {
+            yield index;
+        }
+    }
+}
+//# sourceMappingURL=indices-where.js.map

package/dist/iterable/async/indices-where.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"indices-where.js","sourceRoot":"","sources":["../../../src/iterable/async/indices-where.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,SAAS,CAAC,CAAC,iBAAiB,CACvC,QAA+B,EAC/B,SAA2C;IAE3C,IAAI,KAAK,GAAG,CAAC,CAAC;IAEd,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QACnC,IAAI,MAAM,SAAS,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC;YAClC,MAAM,KAAK,CAAC;QACb,CAAC;QAED,KAAK,EAAE,CAAC;IACT,CAAC;AACF,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,KAAK,SAAS,CAAC,CAAC,qBAAqB,CAC3C,QAA+B,EAC/B,SAA2C,EAC3C,MAAoB;IAEpB,MAAM,EAAE,cAAc,EAAE,CAAC;IAEzB,MAAM,KAAK,GAAQ,EAAE,CAAC;IAEtB,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QACnC,MAAM,EAAE,cAAc,EAAE,CAAC;QACzB,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAClB,CAAC;IAED,KAAK,IAAI,KAAK,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC;QACxD,IAAI,MAAM,SAAS,CAAC,KAAK,CAAC,KAAK,CAAE,EAAE,KAAK,CAAC,EAAE,CAAC;YAC3C,MAAM,KAAK,CAAC;QACb,CAAC;IACF,CAAC;AACF,CAAC"}

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

@@ -0,0 +1,15 @@
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+/**
+ * Yields `separator` between consecutive elements, with none before the first
+ * or after the last.
+ *
+ * The async counterpart of `intersperse`.
+ *
+ * Time complexity: O(1) per element.
+ *
+ * @param iterable The input iterable, sync or async.
+ * @param separator The value to place between elements.
+ * @returns An iterator over the elements, separated.
+ */
+export declare function intersperseAsync<T, S>(iterable: MaybeAsyncIterable<T>, separator: S): AsyncIterableIterator<T | S>;
+//# sourceMappingURL=intersperse.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"intersperse.d.ts","sourceRoot":"","sources":["../../../src/iterable/async/intersperse.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAElE;;;;;;;;;;;GAWG;AACH,wBAAuB,gBAAgB,CAAC,CAAC,EAAE,CAAC,EAC3C,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC/B,SAAS,EAAE,CAAC,GACV,qBAAqB,CAAC,CAAC,GAAG,CAAC,CAAC,CAW9B"}

package/dist/iterable/async/intersperse.js

@@ -0,0 +1,23 @@
+/**
+ * Yields `separator` between consecutive elements, with none before the first
+ * or after the last.
+ *
+ * The async counterpart of `intersperse`.
+ *
+ * Time complexity: O(1) per element.
+ *
+ * @param iterable The input iterable, sync or async.
+ * @param separator The value to place between elements.
+ * @returns An iterator over the elements, separated.
+ */
+export async function* intersperseAsync(iterable, separator) {
+    let isFirst = true;
+    for await (const item of iterable) {
+        if (!isFirst) {
+            yield separator;
+        }
+        yield item;
+        isFirst = false;
+    }
+}
+//# sourceMappingURL=intersperse.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"intersperse.js","sourceRoot":"","sources":["../../../src/iterable/async/intersperse.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,KAAK,SAAS,CAAC,CAAC,gBAAgB,CACtC,QAA+B,EAC/B,SAAY;IAEZ,IAAI,OAAO,GAAG,IAAI,CAAC;IAEnB,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QACnC,IAAI,CAAC,OAAO,EAAE,CAAC;YACd,MAAM,SAAS,CAAC;QACjB,CAAC;QAED,MAAM,IAAI,CAAC;QACX,OAAO,GAAG,KAAK,CAAC;IACjB,CAAC;AACF,CAAC"}

package/dist/iterable/async/is-iterable-equal.d.ts

@@ -0,0 +1,22 @@
+import { type EqualityComparisonStrategy } from "../../object/is-equal.js";
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+/**
+ * Checks whether two iterables yield equal elements in the same order, and the
+ * same number of them.
+ *
+ * The async counterpart of `isIterableEqual`. Both sides are advanced
+ * concurrently, so a round costs the slower source rather than their sum.
+ * Short-circuits on the first difference, closing whichever iterator has not
+ * ended.
+ *
+ * Time complexity: O(n) worst case.
+ *
+ * @param a The first iterable, sync or async.
+ * @param b The second iterable, sync or async.
+ * @param comparisonStrategy The equality comparison strategy to use (default is
+ *   "strict"). Resolved once, not re-dispatched per element.
+ * @param signal Aborts the comparison.
+ * @returns `true` if both iterables yield the same elements in the same order.
+ */
+export declare function isIterableEqualAsync<T>(a: MaybeAsyncIterable<T>, b: MaybeAsyncIterable<T>, comparisonStrategy?: EqualityComparisonStrategy<T, T>, signal?: AbortSignal): Promise<boolean>;
+//# sourceMappingURL=is-iterable-equal.d.ts.map

package/dist/iterable/async/is-iterable-equal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-iterable-equal.d.ts","sourceRoot":"","sources":["../../../src/iterable/async/is-iterable-equal.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,0BAA0B,EAE/B,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAIlE;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,oBAAoB,CAAC,CAAC,EAC3C,CAAC,EAAE,kBAAkB,CAAC,CAAC,CAAC,EACxB,CAAC,EAAE,kBAAkB,CAAC,CAAC,CAAC,EACxB,kBAAkB,GAAE,0BAA0B,CAC7C,CAAC,EACD,CAAC,CAC+C,EACjD,MAAM,CAAC,EAAE,WAAW,GAClB,OAAO,CAAC,OAAO,CAAC,CAkClB"}

package/dist/iterable/async/is-iterable-equal.js

@@ -0,0 +1,49 @@
+import { resolveEqualityComparator, } from "../../object/is-equal.js";
+import { IS_ITERABLE_EQUAL_DEFAULT_COMPARISON_STRATEGY } from "../is-iterable-equal.js";
+import { asyncIteratorOf_ } from "./_async-iterator.js";
+/**
+ * Checks whether two iterables yield equal elements in the same order, and the
+ * same number of them.
+ *
+ * The async counterpart of `isIterableEqual`. Both sides are advanced
+ * concurrently, so a round costs the slower source rather than their sum.
+ * Short-circuits on the first difference, closing whichever iterator has not
+ * ended.
+ *
+ * Time complexity: O(n) worst case.
+ *
+ * @param a The first iterable, sync or async.
+ * @param b The second iterable, sync or async.
+ * @param comparisonStrategy The equality comparison strategy to use (default is
+ *   "strict"). Resolved once, not re-dispatched per element.
+ * @param signal Aborts the comparison.
+ * @returns `true` if both iterables yield the same elements in the same order.
+ */
+export async function isIterableEqualAsync(a, b, comparisonStrategy = IS_ITERABLE_EQUAL_DEFAULT_COMPARISON_STRATEGY, signal) {
+    signal?.throwIfAborted();
+    const comparator = resolveEqualityComparator(comparisonStrategy);
+    const iteratorA = asyncIteratorOf_(a);
+    const iteratorB = asyncIteratorOf_(b);
+    while (true) {
+        const [resultA, resultB] = await Promise.all([
+            iteratorA.next(),
+            iteratorB.next(),
+        ]);
+        signal?.throwIfAborted();
+        if (resultA.done === true || resultB.done === true) {
+            const bothDone = resultA.done === true && resultB.done === true;
+            if (resultA.done !== true) {
+                await iteratorA.return?.();
+            }
+            if (resultB.done !== true) {
+                await iteratorB.return?.();
+            }
+            return bothDone;
+        }
+        if (!comparator(resultA.value, resultB.value)) {
+            await Promise.all([iteratorA.return?.(), iteratorB.return?.()]);
+            return false;
+        }
+    }
+}
+//# sourceMappingURL=is-iterable-equal.js.map

package/dist/iterable/async/is-iterable-equal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-iterable-equal.js","sourceRoot":"","sources":["../../../src/iterable/async/is-iterable-equal.ts"],"names":[],"mappings":"AAAA,OAAO,EAEN,yBAAyB,GACzB,MAAM,0BAA0B,CAAC;AAElC,OAAO,EAAE,6CAA6C,EAAE,MAAM,yBAAyB,CAAC;AACxF,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAExD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACzC,CAAwB,EACxB,CAAwB,EACxB,kBAAkB,GAGd,6CAA6C,EACjD,MAAoB;IAEpB,MAAM,EAAE,cAAc,EAAE,CAAC;IAEzB,MAAM,UAAU,GAAG,yBAAyB,CAAC,kBAAkB,CAAC,CAAC;IACjE,MAAM,SAAS,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC;IACtC,MAAM,SAAS,GAAG,gBAAgB,CAAC,CAAC,CAAC,CAAC;IAEtC,OAAO,IAAI,EAAE,CAAC;QACb,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,MAAM,OAAO,CAAC,GAAG,CAAC;YAC5C,SAAS,CAAC,IAAI,EAAE;YAChB,SAAS,CAAC,IAAI,EAAE;SAChB,CAAC,CAAC;QAEH,MAAM,EAAE,cAAc,EAAE,CAAC;QAEzB,IAAI,OAAO,CAAC,IAAI,KAAK,IAAI,IAAI,OAAO,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;YACpD,MAAM,QAAQ,GAAG,OAAO,CAAC,IAAI,KAAK,IAAI,IAAI,OAAO,CAAC,IAAI,KAAK,IAAI,CAAC;YAEhE,IAAI,OAAO,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;gBAC3B,MAAM,SAAS,CAAC,MAAM,EAAE,EAAE,CAAC;YAC5B,CAAC;YACD,IAAI,OAAO,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;gBAC3B,MAAM,SAAS,CAAC,MAAM,EAAE,EAAE,CAAC;YAC5B,CAAC;YAED,OAAO,QAAQ,CAAC;QACjB,CAAC;QAED,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YAC/C,MAAM,OAAO,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,MAAM,EAAE,EAAE,EAAE,SAAS,CAAC,MAAM,EAAE,EAAE,CAAC,CAAC,CAAC;YAEhE,OAAO,KAAK,CAAC;QACd,CAAC;IACF,CAAC;AACF,CAAC"}

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

@@ -0,0 +1,16 @@
+import type { DefinedValue } from "../../types/defined-value.js";
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+/**
+ * Returns the last element, or `undefined` when the iterable is empty.
+ *
+ * The async counterpart of `last`, without its array fast path: an async source
+ * has no length to index into, so the whole of it is drained.
+ *
+ * Time complexity: O(n).
+ *
+ * @param iterable The iterable to read from, sync or async.
+ * @param signal Aborts the drain.
+ * @returns The last element, or `undefined` if there is none.
+ */
+export declare function lastAsync<T extends DefinedValue>(iterable: MaybeAsyncIterable<T>, signal?: AbortSignal): Promise<T | undefined>;
+//# sourceMappingURL=last.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"last.d.ts","sourceRoot":"","sources":["../../../src/iterable/async/last.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,SAAS,CAAC,CAAC,SAAS,YAAY,EACrD,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC/B,MAAM,CAAC,EAAE,WAAW,GAClB,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAWxB"}

package/dist/iterable/async/last.js

@@ -0,0 +1,22 @@
+/**
+ * Returns the last element, or `undefined` when the iterable is empty.
+ *
+ * The async counterpart of `last`, without its array fast path: an async source
+ * has no length to index into, so the whole of it is drained.
+ *
+ * Time complexity: O(n).
+ *
+ * @param iterable The iterable to read from, sync or async.
+ * @param signal Aborts the drain.
+ * @returns The last element, or `undefined` if there is none.
+ */
+export async function lastAsync(iterable, signal) {
+    signal?.throwIfAborted();
+    let result;
+    for await (const item of iterable) {
+        signal?.throwIfAborted();
+        result = item;
+    }
+    return result;
+}
+//# sourceMappingURL=last.js.map

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

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

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

@@ -0,0 +1,15 @@
+import type { MaybeAsyncCallable } from "../../types/callable.js";
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+/**
+ * Yields `mapper(element)` for each element, lazily.
+ *
+ * The async counterpart of `map`.
+ *
+ * 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.
+ * @returns An iterator over the mapped values.
+ */
+export declare function mapAsync<T, R>(iterable: MaybeAsyncIterable<T>, mapper: MaybeAsyncCallable<[T, number], R>): AsyncIterableIterator<R>;
+//# sourceMappingURL=map.d.ts.map

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

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

package/dist/iterable/async/map.js

@@ -0,0 +1,18 @@
+/**
+ * Yields `mapper(element)` for each element, lazily.
+ *
+ * The async counterpart of `map`.
+ *
+ * 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.
+ * @returns An iterator over the mapped values.
+ */
+export async function* mapAsync(iterable, mapper) {
+    let index = 0;
+    for await (const item of iterable) {
+        yield await mapper(item, index++);
+    }
+}
+//# sourceMappingURL=map.js.map

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

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

package/dist/iterable/async/mark-ends.d.ts

@@ -0,0 +1,18 @@
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+import type { MarkedEnd } from "../mark-ends.js";
+/**
+ * Yields each element tagged with whether it is the first and whether it is the
+ * last.
+ *
+ * The async counterpart of `markEnds`. Knowing an element is the last one
+ * requires a one-element lookahead, so the source always runs one step ahead of
+ * what has been yielded — on a slow stream that means one extra pending read at
+ * all times.
+ *
+ * Time complexity: O(1) per element, allocating one tuple per yield.
+ *
+ * @param iterable The input iterable, sync or async.
+ * @returns An iterator over the tagged elements.
+ */
+export declare function markEndsAsync<T>(iterable: MaybeAsyncIterable<T>): AsyncIterableIterator<MarkedEnd<T>>;
+//# sourceMappingURL=mark-ends.d.ts.map

package/dist/iterable/async/mark-ends.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mark-ends.d.ts","sourceRoot":"","sources":["../../../src/iterable/async/mark-ends.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAClE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAGjD;;;;;;;;;;;;;GAaG;AACH,wBAAuB,aAAa,CAAC,CAAC,EACrC,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAC7B,qBAAqB,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAsBrC"}

package/dist/iterable/async/mark-ends.js

@@ -0,0 +1,33 @@
+import { asyncIteratorOf_ } from "./_async-iterator.js";
+/**
+ * Yields each element tagged with whether it is the first and whether it is the
+ * last.
+ *
+ * The async counterpart of `markEnds`. Knowing an element is the last one
+ * requires a one-element lookahead, so the source always runs one step ahead of
+ * what has been yielded — on a slow stream that means one extra pending read at
+ * all times.
+ *
+ * Time complexity: O(1) per element, allocating one tuple per yield.
+ *
+ * @param iterable The input iterable, sync or async.
+ * @returns An iterator over the tagged elements.
+ */
+export async function* markEndsAsync(iterable) {
+    const iterator = asyncIteratorOf_(iterable);
+    let current = await iterator.next();
+    if (current.done === true) {
+        return;
+    }
+    let isFirst = true;
+    while (true) {
+        const next = await iterator.next();
+        yield [current.value, isFirst, next.done === true];
+        if (next.done === true) {
+            return;
+        }
+        current = next;
+        isFirst = false;
+    }
+}
+//# sourceMappingURL=mark-ends.js.map

package/dist/iterable/async/mark-ends.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mark-ends.js","sourceRoot":"","sources":["../../../src/iterable/async/mark-ends.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAExD;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,KAAK,SAAS,CAAC,CAAC,aAAa,CACnC,QAA+B;IAE/B,MAAM,QAAQ,GAAG,gBAAgB,CAAC,QAAQ,CAAC,CAAC;IAC5C,IAAI,OAAO,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;IAEpC,IAAI,OAAO,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;QAC3B,OAAO;IACR,CAAC;IAED,IAAI,OAAO,GAAG,IAAI,CAAC;IAEnB,OAAO,IAAI,EAAE,CAAC;QACb,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;QAEnC,MAAM,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,EAAE,IAAI,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;QAEnD,IAAI,IAAI,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;YACxB,OAAO;QACR,CAAC;QAED,OAAO,GAAG,IAAI,CAAC;QACf,OAAO,GAAG,KAAK,CAAC;IACjB,CAAC;AACF,CAAC"}

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

@@ -0,0 +1,20 @@
+import type { DefinedValue } from "../../types/defined-value.js";
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+/**
+ * Returns the element at `index`, or `undefined` when the iterable is shorter
+ * than that.
+ *
+ * The async counterpart of `nth`. Only counts forward; a negative index would
+ * mean buffering the whole tail, so it is rejected.
+ *
+ * Time complexity: O(index). The iterator is closed as soon as the element is
+ * reached.
+ *
+ * @param iterable The iterable to read from, sync or async.
+ * @param index The zero-based position to read. Must be a non-negative integer.
+ * @param signal Aborts the read.
+ * @returns The element at `index`, or `undefined` if there is none.
+ * @throws {RangeError} If `index` is not a non-negative integer.
+ */
+export declare function nthAsync<T extends DefinedValue>(iterable: MaybeAsyncIterable<T>, index: number, signal?: AbortSignal): Promise<T | undefined>;
+//# sourceMappingURL=nth.d.ts.map

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

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

package/dist/iterable/async/nth.js

@@ -0,0 +1,32 @@
+/**
+ * Returns the element at `index`, or `undefined` when the iterable is shorter
+ * than that.
+ *
+ * The async counterpart of `nth`. Only counts forward; a negative index would
+ * mean buffering the whole tail, so it is rejected.
+ *
+ * Time complexity: O(index). The iterator is closed as soon as the element is
+ * reached.
+ *
+ * @param iterable The iterable to read from, sync or async.
+ * @param index The zero-based position to read. Must be a non-negative integer.
+ * @param signal Aborts the read.
+ * @returns The element at `index`, or `undefined` if there is none.
+ * @throws {RangeError} If `index` is not a non-negative integer.
+ */
+export async function nthAsync(iterable, index, signal) {
+    if (!Number.isInteger(index) || index < 0) {
+        throw new RangeError("nthAsync index must be a non-negative integer");
+    }
+    signal?.throwIfAborted();
+    let position = 0;
+    for await (const item of iterable) {
+        signal?.throwIfAborted();
+        if (position === index) {
+            return item;
+        }
+        position++;
+    }
+    return undefined;
+}
+//# sourceMappingURL=nth.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nth.js","sourceRoot":"","sources":["../../../src/iterable/async/nth.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,KAAK,UAAU,QAAQ,CAC7B,QAA+B,EAC/B,KAAa,EACb,MAAoB;IAEpB,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,EAAE,cAAc,EAAE,CAAC;IAEzB,IAAI,QAAQ,GAAG,CAAC,CAAC;IAEjB,IAAI,KAAK,EAAE,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QACnC,MAAM,EAAE,cAAc,EAAE,CAAC;QAEzB,IAAI,QAAQ,KAAK,KAAK,EAAE,CAAC;YACxB,OAAO,IAAI,CAAC;QACb,CAAC;QAED,QAAQ,EAAE,CAAC;IACZ,CAAC;IAED,OAAO,SAAS,CAAC;AAClB,CAAC"}

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

@@ -0,0 +1,20 @@
+import type { DefinedValue } from "../../types/defined-value.js";
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+/**
+ * Returns the single element of an iterable, or `undefined` when it is empty,
+ * rejecting any larger count.
+ *
+ * The async counterpart of `one`, and the tolerant half of the pair `onlyAsync`
+ * completes.
+ *
+ * Time complexity: O(1) — at most two elements are pulled, so this is safe on
+ * an endless stream.
+ *
+ * @param iterable The iterable to read from, sync or async.
+ * @param description What the iterable holds, used in the error message.
+ * @param signal Aborts the read.
+ * @returns The single element, or `undefined` if there is none.
+ * @throws {RangeError} If the iterable holds more than one element.
+ */
+export declare function oneAsync<T extends DefinedValue>(iterable: MaybeAsyncIterable<T>, description?: string, signal?: AbortSignal): Promise<T | undefined>;
+//# sourceMappingURL=one.d.ts.map

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

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

package/dist/iterable/async/one.js

@@ -0,0 +1,32 @@
+import { asyncIteratorOf_ } from "./_async-iterator.js";
+/**
+ * Returns the single element of an iterable, or `undefined` when it is empty,
+ * rejecting any larger count.
+ *
+ * The async counterpart of `one`, and the tolerant half of the pair `onlyAsync`
+ * completes.
+ *
+ * Time complexity: O(1) — at most two elements are pulled, so this is safe on
+ * an endless stream.
+ *
+ * @param iterable The iterable to read from, sync or async.
+ * @param description What the iterable holds, used in the error message.
+ * @param signal Aborts the read.
+ * @returns The single element, or `undefined` if there is none.
+ * @throws {RangeError} If the iterable holds more than one element.
+ */
+export async function oneAsync(iterable, description = "item", signal) {
+    signal?.throwIfAborted();
+    const iterator = asyncIteratorOf_(iterable);
+    const first = await iterator.next();
+    signal?.throwIfAborted();
+    if (first.done === true) {
+        return undefined;
+    }
+    if ((await iterator.next()).done !== true) {
+        await iterator.return?.();
+        throw new RangeError(`expected at most one ${description}, found more`);
+    }
+    return first.value;
+}
+//# sourceMappingURL=one.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"one.js","sourceRoot":"","sources":["../../../src/iterable/async/one.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAExD;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,KAAK,UAAU,QAAQ,CAC7B,QAA+B,EAC/B,WAAW,GAAG,MAAM,EACpB,MAAoB;IAEpB,MAAM,EAAE,cAAc,EAAE,CAAC;IAEzB,MAAM,QAAQ,GAAG,gBAAgB,CAAC,QAAQ,CAAC,CAAC;IAC5C,MAAM,KAAK,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;IAEpC,MAAM,EAAE,cAAc,EAAE,CAAC;IAEzB,IAAI,KAAK,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;QACzB,OAAO,SAAS,CAAC;IAClB,CAAC;IAED,IAAI,CAAC,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;QAC3C,MAAM,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC;QAE1B,MAAM,IAAI,UAAU,CAAC,wBAAwB,WAAW,cAAc,CAAC,CAAC;IACzE,CAAC;IAED,OAAO,KAAK,CAAC,KAAK,CAAC;AACpB,CAAC"}

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

@@ -0,0 +1,18 @@
+import type { MaybeAsyncIterable } from "../../types/iterator.js";
+/**
+ * Returns the single element of an iterable, rejecting any other count.
+ *
+ * The async counterpart of `only`. Use `oneAsync` where an empty iterable is
+ * acceptable.
+ *
+ * Time complexity: O(1) — at most two elements are pulled, so this is safe on
+ * an endless stream.
+ *
+ * @param iterable The iterable to read from, sync or async.
+ * @param description What the iterable holds, used in the error message.
+ * @param signal Aborts the read.
+ * @returns The single element.
+ * @throws {RangeError} If the iterable is empty or holds more than one element.
+ */
+export declare function onlyAsync<T>(iterable: MaybeAsyncIterable<T>, description?: string, signal?: AbortSignal): Promise<T>;
+//# sourceMappingURL=only.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"only.d.ts","sourceRoot":"","sources":["../../../src/iterable/async/only.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,yBAAyB,CAAC;AAGlE;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,SAAS,CAAC,CAAC,EAChC,QAAQ,EAAE,kBAAkB,CAAC,CAAC,CAAC,EAC/B,WAAW,SAAS,EACpB,MAAM,CAAC,EAAE,WAAW,GAClB,OAAO,CAAC,CAAC,CAAC,CAmBZ"}

package/dist/iterable/async/only.js

@@ -0,0 +1,31 @@
+import { asyncIteratorOf_ } from "./_async-iterator.js";
+/**
+ * Returns the single element of an iterable, rejecting any other count.
+ *
+ * The async counterpart of `only`. Use `oneAsync` where an empty iterable is
+ * acceptable.
+ *
+ * Time complexity: O(1) — at most two elements are pulled, so this is safe on
+ * an endless stream.
+ *
+ * @param iterable The iterable to read from, sync or async.
+ * @param description What the iterable holds, used in the error message.
+ * @param signal Aborts the read.
+ * @returns The single element.
+ * @throws {RangeError} If the iterable is empty or holds more than one element.
+ */
+export async function onlyAsync(iterable, description = "item", signal) {
+    signal?.throwIfAborted();
+    const iterator = asyncIteratorOf_(iterable);
+    const first = await iterator.next();
+    signal?.throwIfAborted();
+    if (first.done === true) {
+        throw new RangeError(`expected exactly one ${description}, found none`);
+    }
+    if ((await iterator.next()).done !== true) {
+        await iterator.return?.();
+        throw new RangeError(`expected exactly one ${description}, found more`);
+    }
+    return first.value;
+}
+//# sourceMappingURL=only.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"only.js","sourceRoot":"","sources":["../../../src/iterable/async/only.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAExD;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAC9B,QAA+B,EAC/B,WAAW,GAAG,MAAM,EACpB,MAAoB;IAEpB,MAAM,EAAE,cAAc,EAAE,CAAC;IAEzB,MAAM,QAAQ,GAAG,gBAAgB,CAAC,QAAQ,CAAC,CAAC;IAC5C,MAAM,KAAK,GAAG,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC;IAEpC,MAAM,EAAE,cAAc,EAAE,CAAC;IAEzB,IAAI,KAAK,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;QACzB,MAAM,IAAI,UAAU,CAAC,wBAAwB,WAAW,cAAc,CAAC,CAAC;IACzE,CAAC;IAED,IAAI,CAAC,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;QAC3C,MAAM,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC;QAE1B,MAAM,IAAI,UAAU,CAAC,wBAAwB,WAAW,cAAc,CAAC,CAAC;IACzE,CAAC;IAED,OAAO,KAAK,CAAC,KAAK,CAAC;AACpB,CAAC"}