@ac-kit/core 0.1.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"count.d.ts","sourceRoot":"","sources":["../../src/iterable/count.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,QAAQ,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,MAAM,CAgBzD"}

package/dist/iterable/count.js

@@ -0,0 +1,28 @@
+import { isMap } from "../guards/is-map.js";
+import { isSet } from "../guards/is-set.js";
+/**
+ * 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 function count(iterable) {
+    if (Array.isArray(iterable)) {
+        return iterable.length;
+    }
+    if (isSet(iterable) || isMap(iterable)) {
+        return iterable.size;
+    }
+    const iterator = iterable[Symbol.iterator]();
+    let total = 0;
+    while (iterator.next().done !== true) {
+        total++;
+    }
+    return total;
+}
+//# sourceMappingURL=count.js.map

package/dist/iterable/count.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"count.js","sourceRoot":"","sources":["../../src/iterable/count.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC5C,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAE5C;;;;;;;;;;GAUG;AACH,MAAM,UAAU,KAAK,CAAC,QAA2B;IAChD,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC7B,OAAO,QAAQ,CAAC,MAAM,CAAC;IACxB,CAAC;IACD,IAAI,KAAK,CAAC,QAAQ,CAAC,IAAI,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC;QACxC,OAAO,QAAQ,CAAC,IAAI,CAAC;IACtB,CAAC;IAED,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;IAC7C,IAAI,KAAK,GAAG,CAAC,CAAC;IAEd,OAAO,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;QACtC,KAAK,EAAE,CAAC;IACT,CAAC;IAED,OAAO,KAAK,CAAC;AACd,CAAC"}

package/dist/iterable/cycle.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Yields the whole iterable `times` times over.
+ *
+ * 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.
+ *
+ * Time complexity: O(n × times). Memory: O(n).
+ *
+ * @param iterable The input iterable.
+ * @param times How many passes to yield. Must be a non-negative integer or
+ *   `Infinity`, which repeats forever. Zero yields nothing and consumes
+ *   nothing.
+ * @returns An iterator over the repeated elements.
+ * @throws {RangeError} If `times` is negative, fractional or `NaN`.
+ */
+export declare function cycle<T>(iterable: Iterable<T>, times?: number): IterableIterator<T>;
+//# sourceMappingURL=cycle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cycle.d.ts","sourceRoot":"","sources":["../../src/iterable/cycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAiB,KAAK,CAAC,CAAC,EACvB,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EACrB,KAAK,GAAE,MAAiC,GACtC,gBAAgB,CAAC,CAAC,CAAC,CA4BrB"}

package/dist/iterable/cycle.js

@@ -0,0 +1,37 @@
+/**
+ * Yields the whole iterable `times` times over.
+ *
+ * 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.
+ *
+ * Time complexity: O(n × times). Memory: O(n).
+ *
+ * @param iterable The input iterable.
+ * @param times How many passes to yield. Must be a non-negative integer or
+ *   `Infinity`, which repeats forever. Zero yields nothing and consumes
+ *   nothing.
+ * @returns An iterator over the repeated elements.
+ * @throws {RangeError} If `times` is negative, fractional or `NaN`.
+ */
+export function* cycle(iterable, times = Number.POSITIVE_INFINITY) {
+    if (times !== Number.POSITIVE_INFINITY &&
+        (!Number.isInteger(times) || times < 0)) {
+        throw new RangeError("cycle times must be a non-negative integer or Infinity");
+    }
+    if (times === 0) {
+        return;
+    }
+    const buffer = [];
+    for (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/cycle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cycle.js","sourceRoot":"","sources":["../../src/iterable/cycle.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,SAAS,CAAC,CAAC,KAAK,CACrB,QAAqB,EACrB,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,wDAAwD,CACxD,CAAC;IACH,CAAC;IAED,IAAI,KAAK,KAAK,CAAC,EAAE,CAAC;QACjB,OAAO;IACR,CAAC;IAED,MAAM,MAAM,GAAQ,EAAE,CAAC;IAEvB,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC7B,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/deltas.d.ts

@@ -0,0 +1,23 @@
+import type { Callable } from "../types/callable.js";
+/**
+ * Yields the difference between each element and the one before it.
+ *
+ * `subtract` is required rather than defaulting to numeric subtraction: the
+ * operation is the caller's, which is what keeps this out of the math packages
+ * — nothing here computes on numbers, it only applies what it is given.
+ *
+ * Arguments reach `subtract` as `(current, previous)`, so numeric subtraction
+ * makes an increase positive.
+ *
+ * An input of fewer than two elements yields nothing, so there is always one
+ * fewer delta than there are elements.
+ *
+ * Time complexity: O(1) per element, plus whatever `subtract` costs.
+ *
+ * @param iterable The input iterable.
+ * @param subtract Computes the difference between an element and its
+ *   predecessor.
+ * @returns An iterator over the consecutive differences.
+ */
+export declare function deltas<T, D>(iterable: Iterable<T>, subtract: Callable<[T, T], D>): IterableIterator<D>;
+//# sourceMappingURL=deltas.d.ts.map

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

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

package/dist/iterable/deltas.js

@@ -0,0 +1,32 @@
+/**
+ * Yields the difference between each element and the one before it.
+ *
+ * `subtract` is required rather than defaulting to numeric subtraction: the
+ * operation is the caller's, which is what keeps this out of the math packages
+ * — nothing here computes on numbers, it only applies what it is given.
+ *
+ * Arguments reach `subtract` as `(current, previous)`, so numeric subtraction
+ * makes an increase positive.
+ *
+ * An input of fewer than two elements yields nothing, so there is always one
+ * fewer delta than there are elements.
+ *
+ * Time complexity: O(1) per element, plus whatever `subtract` costs.
+ *
+ * @param iterable The input iterable.
+ * @param subtract Computes the difference between an element and its
+ *   predecessor.
+ * @returns An iterator over the consecutive differences.
+ */
+export function* deltas(iterable, subtract) {
+    let previous;
+    let hasPrevious = false;
+    for (const item of iterable) {
+        if (hasPrevious) {
+            yield subtract(item, previous);
+        }
+        previous = item;
+        hasPrevious = true;
+    }
+}
+//# sourceMappingURL=deltas.js.map

package/dist/iterable/deltas.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deltas.js","sourceRoot":"","sources":["../../src/iterable/deltas.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,SAAS,CAAC,CAAC,MAAM,CACtB,QAAqB,EACrB,QAA6B;IAE7B,IAAI,QAAW,CAAC;IAChB,IAAI,WAAW,GAAG,KAAK,CAAC;IAExB,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC7B,IAAI,WAAW,EAAE,CAAC;YACjB,MAAM,QAAQ,CAAC,IAAI,EAAE,QAAS,CAAC,CAAC;QACjC,CAAC;QAED,QAAQ,GAAG,IAAI,CAAC;QAChB,WAAW,GAAG,IAAI,CAAC;IACpB,CAAC;AACF,CAAC"}

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

@@ -0,0 +1,18 @@
+import type { Predicate } from "../types/callable.js";
+/**
+ * Skips elements from the start for as long as `predicate` holds, then yields
+ * everything from the first rejected element onwards.
+ *
+ * The predicate is not consulted again once it has rejected, so a later element
+ * that would satisfy it is still yielded. That is what separates this from
+ * filtering.
+ *
+ * Time complexity: O(1) per element.
+ *
+ * @param iterable The input iterable.
+ * @param predicate Receives each element and its zero-based index. Skipping
+ *   stops the first time it returns `false`.
+ * @returns An iterator over the elements from the first rejection onwards.
+ */
+export declare function dropWhile<T>(iterable: Iterable<T>, predicate: Predicate<[T, number]>): IterableIterator<T>;
+//# sourceMappingURL=drop-while.d.ts.map

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

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

package/dist/iterable/drop-while.js

@@ -0,0 +1,27 @@
+/**
+ * Skips elements from the start for as long as `predicate` holds, then yields
+ * everything from the first rejected element onwards.
+ *
+ * The predicate is not consulted again once it has rejected, so a later element
+ * that would satisfy it is still yielded. That is what separates this from
+ * filtering.
+ *
+ * Time complexity: O(1) per element.
+ *
+ * @param iterable The input iterable.
+ * @param predicate Receives each element and its zero-based index. Skipping
+ *   stops the first time it returns `false`.
+ * @returns An iterator over the elements from the first rejection onwards.
+ */
+export function* dropWhile(iterable, predicate) {
+    let index = 0;
+    let dropping = true;
+    for (const item of iterable) {
+        if (dropping && predicate(item, index++)) {
+            continue;
+        }
+        dropping = false;
+        yield item;
+    }
+}
+//# sourceMappingURL=drop-while.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"drop-while.js","sourceRoot":"","sources":["../../src/iterable/drop-while.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,MAAM,SAAS,CAAC,CAAC,SAAS,CACzB,QAAqB,EACrB,SAAiC;IAEjC,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,IAAI,QAAQ,GAAG,IAAI,CAAC;IAEpB,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC7B,IAAI,QAAQ,IAAI,SAAS,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC;YAC1C,SAAS;QACV,CAAC;QAED,QAAQ,GAAG,KAAK,CAAC;QACjB,MAAM,IAAI,CAAC;IACZ,CAAC;AACF,CAAC"}

package/dist/iterable/drop.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Yields everything after the first `count` elements.
+ *
+ * What `Array.prototype.slice(count)` does for an array, without materialising.
+ * 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.
+ * @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 drop<T>(iterable: Iterable<T>, count: number): IterableIterator<T>;
+//# sourceMappingURL=drop.d.ts.map

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

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

package/dist/iterable/drop.js

@@ -0,0 +1,28 @@
+/**
+ * Yields everything after the first `count` elements.
+ *
+ * What `Array.prototype.slice(count)` does for an array, without materialising.
+ * 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.
+ * @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 function* drop(iterable, count) {
+    if (!Number.isInteger(count) || count < 0) {
+        throw new RangeError("drop count must be a non-negative integer");
+    }
+    let dropped = 0;
+    for (const item of iterable) {
+        if (dropped < count) {
+            dropped++;
+            continue;
+        }
+        yield item;
+    }
+}
+//# sourceMappingURL=drop.js.map

package/dist/iterable/drop.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"drop.js","sourceRoot":"","sources":["../../src/iterable/drop.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,SAAS,CAAC,CAAC,IAAI,CACpB,QAAqB,EACrB,KAAa;IAEb,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;QAC3C,MAAM,IAAI,UAAU,CAAC,2CAA2C,CAAC,CAAC;IACnE,CAAC;IAED,IAAI,OAAO,GAAG,CAAC,CAAC;IAEhB,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC7B,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/filter-map.d.ts

@@ -0,0 +1,20 @@
+import type { Callable } from "../types/callable.js";
+import type { DefinedValue } from "../types/defined-value.js";
+/**
+ * Maps and filters in one pass: yields every mapped value except the ones the
+ * mapper declines to produce.
+ *
+ * `undefined` is the decline signal, and the result type cannot include it, so
+ * "no value here" is never confused with "the value is `undefined`". That is
+ * what makes this different from `.map(…).filter(…)`, which cannot tell the two
+ * apart and walks the sequence twice.
+ *
+ * Time complexity: O(1) per element, plus whatever `mapper` costs.
+ *
+ * @param iterable The input iterable.
+ * @param mapper Receives each element and its zero-based index. Returns the
+ *   mapped value, or `undefined` to drop the element.
+ * @returns An iterator over the produced values.
+ */
+export declare function filterMap<T, R extends DefinedValue>(iterable: Iterable<T>, mapper: Callable<[T, number], R | undefined>): IterableIterator<R>;
+//# sourceMappingURL=filter-map.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"filter-map.d.ts","sourceRoot":"","sources":["../../src/iterable/filter-map.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAE9D;;;;;;;;;;;;;;;GAeG;AACH,wBAAiB,SAAS,CAAC,CAAC,EAAE,CAAC,SAAS,YAAY,EACnD,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EACrB,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,CAAC,GAAG,SAAS,CAAC,GAC1C,gBAAgB,CAAC,CAAC,CAAC,CAUrB"}

package/dist/iterable/filter-map.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"filter-map.js","sourceRoot":"","sources":["../../src/iterable/filter-map.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,SAAS,CAAC,CAAC,SAAS,CACzB,QAAqB,EACrB,MAA4C;IAE5C,IAAI,KAAK,GAAG,CAAC,CAAC;IAEd,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC7B,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;QAErC,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;YAC1B,MAAM,MAAM,CAAC;QACd,CAAC;IACF,CAAC;AACF,CAAC"}

package/dist/iterable/first.d.ts

@@ -0,0 +1,14 @@
+import type { DefinedValue } from "../types/defined-value.js";
+/**
+ * Returns the first element, or `undefined` when the iterable is empty.
+ *
+ * `T` cannot itself include `undefined`, so the absent case is never ambiguous.
+ * Use `compact` first when the source may carry nullish elements.
+ *
+ * Time complexity: O(1). The iterator is closed without being drained.
+ *
+ * @param iterable The iterable to read from.
+ * @returns The first element, or `undefined` if there is none.
+ */
+export declare function first<T extends DefinedValue>(iterable: Iterable<T>): T | undefined;
+//# sourceMappingURL=first.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"first.d.ts","sourceRoot":"","sources":["../../src/iterable/first.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAE9D;;;;;;;;;;GAUG;AACH,wBAAgB,KAAK,CAAC,CAAC,SAAS,YAAY,EAC3C,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GACnB,CAAC,GAAG,SAAS,CAMf"}

package/dist/iterable/first.js

@@ -0,0 +1,18 @@
+/**
+ * Returns the first element, or `undefined` when the iterable is empty.
+ *
+ * `T` cannot itself include `undefined`, so the absent case is never ambiguous.
+ * Use `compact` first when the source may carry nullish elements.
+ *
+ * Time complexity: O(1). The iterator is closed without being drained.
+ *
+ * @param iterable The iterable to read from.
+ * @returns The first element, or `undefined` if there is none.
+ */
+export function first(iterable) {
+    for (const item of iterable) {
+        return item;
+    }
+    return undefined;
+}
+//# sourceMappingURL=first.js.map

package/dist/iterable/first.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"first.js","sourceRoot":"","sources":["../../src/iterable/first.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,MAAM,UAAU,KAAK,CACpB,QAAqB;IAErB,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC7B,OAAO,IAAI,CAAC;IACb,CAAC;IAED,OAAO,SAAS,CAAC;AAClB,CAAC"}

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

@@ -0,0 +1,25 @@
+/**
+ * An iterable whose elements are either `T` or another iterable of the same
+ * shape, to any depth.
+ */
+export type NestedIterable<T> = Iterable<T | NestedIterable<T>>;
+/**
+ * Lazily flattens nested iterables to any depth.
+ *
+ * A `string` is never descended into, even though it is an `Iterable<string>` —
+ * flattening `["ab", ["cd"]]` yields `"ab"` then `"cd"`, not six characters.
+ * That is the case every deep-flatten gets wrong, and the reason this is not
+ * just `flatten` applied repeatedly. Every other iterable is descended into,
+ * including `Set`, `Map` and typed arrays.
+ *
+ * Depth is bounded by the call stack, so a structure that contains itself
+ * overflows rather than yielding forever — the same way `Array.prototype.flat`
+ * behaves.
+ *
+ * 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 flattenDeep<T>(iterable: NestedIterable<T>): IterableIterator<T>;
+//# sourceMappingURL=flatten-deep.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flatten-deep.d.ts","sourceRoot":"","sources":["../../src/iterable/flatten-deep.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,CAAC,CAAC;AAEhE;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAiB,WAAW,CAAC,CAAC,EAC7B,QAAQ,EAAE,cAAc,CAAC,CAAC,CAAC,GACzB,gBAAgB,CAAC,CAAC,CAAC,CAQrB"}

package/dist/iterable/flatten-deep.js

@@ -0,0 +1,33 @@
+/**
+ * Lazily flattens nested iterables to any depth.
+ *
+ * A `string` is never descended into, even though it is an `Iterable<string>` —
+ * flattening `["ab", ["cd"]]` yields `"ab"` then `"cd"`, not six characters.
+ * That is the case every deep-flatten gets wrong, and the reason this is not
+ * just `flatten` applied repeatedly. Every other iterable is descended into,
+ * including `Set`, `Map` and typed arrays.
+ *
+ * Depth is bounded by the call stack, so a structure that contains itself
+ * overflows rather than yielding forever — the same way `Array.prototype.flat`
+ * behaves.
+ *
+ * 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 function* flattenDeep(iterable) {
+    for (const item of iterable) {
+        if (isNestedIterable_(item)) {
+            yield* flattenDeep(item);
+        }
+        else {
+            yield item;
+        }
+    }
+}
+// `typeof === "object"` is what excludes `string`: it is iterable but primitive.
+function isNestedIterable_(item) {
+    return typeof item === "object" && item !== null && Symbol.iterator in item;
+}
+//# sourceMappingURL=flatten-deep.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flatten-deep.js","sourceRoot":"","sources":["../../src/iterable/flatten-deep.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,SAAS,CAAC,CAAC,WAAW,CAC3B,QAA2B;IAE3B,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC7B,IAAI,iBAAiB,CAAC,IAAI,CAAC,EAAE,CAAC;YAC7B,KAAK,CAAC,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC;QAC1B,CAAC;aAAM,CAAC;YACP,MAAM,IAAI,CAAC;QACZ,CAAC;IACF,CAAC;AACF,CAAC;AAED,iFAAiF;AACjF,SAAS,iBAAiB,CACzB,IAA2B;IAE3B,OAAO,OAAO,IAAI,KAAK,QAAQ,IAAI,IAAI,KAAK,IAAI,IAAI,MAAM,CAAC,QAAQ,IAAI,IAAI,CAAC;AAC7E,CAAC"}

package/dist/iterable/flatten.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Lazily concatenates an iterable of iterables, one level deep.
+ *
+ * The counterpart of `Array.prototype.flat()`, and the same operation `concat`
+ * performs — this one takes the sources as a single iterable rather than as
+ * arguments, so it can flatten a stream of streams.
+ *
+ * A `string` is an `Iterable<string>`, so an `Iterable<string>` satisfies this
+ * signature and flattens to characters. That is what the type says; use
+ * `flattenDeep`, which never descends into a string, if that is not wanted.
+ *
+ * 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 flatten<T>(iterable: Iterable<Iterable<T>>): IterableIterator<T>;
+//# sourceMappingURL=flatten.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flatten.d.ts","sourceRoot":"","sources":["../../src/iterable/flatten.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,wBAAiB,OAAO,CAAC,CAAC,EACzB,QAAQ,EAAE,QAAQ,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,GAC7B,gBAAgB,CAAC,CAAC,CAAC,CAIrB"}

package/dist/iterable/flatten.js

@@ -0,0 +1,22 @@
+/**
+ * Lazily concatenates an iterable of iterables, one level deep.
+ *
+ * The counterpart of `Array.prototype.flat()`, and the same operation `concat`
+ * performs — this one takes the sources as a single iterable rather than as
+ * arguments, so it can flatten a stream of streams.
+ *
+ * A `string` is an `Iterable<string>`, so an `Iterable<string>` satisfies this
+ * signature and flattens to characters. That is what the type says; use
+ * `flattenDeep`, which never descends into a string, if that is not wanted.
+ *
+ * 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 function* flatten(iterable) {
+    for (const inner of iterable) {
+        yield* inner;
+    }
+}
+//# sourceMappingURL=flatten.js.map

package/dist/iterable/flatten.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flatten.js","sourceRoot":"","sources":["../../src/iterable/flatten.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,SAAS,CAAC,CAAC,OAAO,CACvB,QAA+B;IAE/B,KAAK,MAAM,KAAK,IAAI,QAAQ,EAAE,CAAC;QAC9B,KAAK,CAAC,CAAC,KAAK,CAAC;IACd,CAAC;AACF,CAAC"}

package/dist/iterable/includes.d.ts

@@ -0,0 +1,19 @@
+import { EqualityComparator } from "../object/is-equal.js";
+/**
+ * Checks whether `item` occurs in `iterable`.
+ *
+ * Named for the semantics it implements: `sameValueZero` by default, which is
+ * what `Array.prototype.includes` and `Set.prototype.has` both use, and unlike
+ * `indexOf` it finds `NaN`.
+ *
+ * Time complexity: O(n), short-circuiting on the first match.
+ *
+ * @param iterable The iterable to search.
+ * @param item The item to search for.
+ * @param comparator The equality comparison function to use (default is
+ *   `isEqual` with "sameValueZero" strategy, the same as
+ *   `Array.prototype.includes`).
+ * @returns `true` if a matching item was found, `false` otherwise.
+ */
+export declare function includes<T>(iterable: Iterable<T>, item: T, comparator?: EqualityComparator<T, T>): boolean;
+//# sourceMappingURL=includes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"includes.d.ts","sourceRoot":"","sources":["../../src/iterable/includes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAW,MAAM,uBAAuB,CAAC;AAEpE;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EACzB,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EACrB,IAAI,EAAE,CAAC,EACP,UAAU,GAAE,kBAAkB,CAAC,CAAC,EAAE,CAAC,CACJ,GAC7B,OAAO,CAQT"}

package/dist/iterable/includes.js

@@ -0,0 +1,26 @@
+import { isEqual } from "../object/is-equal.js";
+/**
+ * Checks whether `item` occurs in `iterable`.
+ *
+ * Named for the semantics it implements: `sameValueZero` by default, which is
+ * what `Array.prototype.includes` and `Set.prototype.has` both use, and unlike
+ * `indexOf` it finds `NaN`.
+ *
+ * Time complexity: O(n), short-circuiting on the first match.
+ *
+ * @param iterable The iterable to search.
+ * @param item The item to search for.
+ * @param comparator The equality comparison function to use (default is
+ *   `isEqual` with "sameValueZero" strategy, the same as
+ *   `Array.prototype.includes`).
+ * @returns `true` if a matching item was found, `false` otherwise.
+ */
+export function includes(iterable, item, comparator = (a, b) => isEqual(a, b, "sameValueZero")) {
+    for (const candidate of iterable) {
+        if (comparator(candidate, item)) {
+            return true;
+        }
+    }
+    return false;
+}
+//# sourceMappingURL=includes.js.map

package/dist/iterable/includes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"includes.js","sourceRoot":"","sources":["../../src/iterable/includes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAsB,OAAO,EAAE,MAAM,uBAAuB,CAAC;AAEpE;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,QAAQ,CACvB,QAAqB,EACrB,IAAO,EACP,UAAU,GAA6B,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAC/C,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,eAAe,CAAC;IAE/B,KAAK,MAAM,SAAS,IAAI,QAAQ,EAAE,CAAC;QAClC,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/indices-where.d.ts

@@ -0,0 +1,32 @@
+import type { Predicate } from "../types/callable.js";
+/**
+ * Yields the zero-based index of every element satisfying `predicate`, rather
+ * than the elements themselves.
+ *
+ * Time complexity: O(1) per element.
+ *
+ * @param iterable The input iterable.
+ * @param predicate Receives each element and its zero-based index.
+ * @returns An iterator over the matching indices, ascending.
+ */
+export declare function indicesWhere<T>(iterable: Iterable<T>, predicate: Predicate<[T, number]>): IterableIterator<number>;
+/**
+ * Yields the zero-based index of every element satisfying `predicate`, scanning
+ * from the end.
+ *
+ * Indices are still counted from the start — only the order they are yielded in
+ * is reversed, so the result is `indicesWhere` reversed.
+ *
+ * An iterable has no end to start from, so a non-array source is materialised
+ * first and the whole of it is held in memory. An array is walked backwards in
+ * place.
+ *
+ * Time complexity: O(n), with O(n) memory for a non-array source and O(1) for
+ * an array.
+ *
+ * @param iterable The input iterable.
+ * @param predicate Receives each element and its zero-based index.
+ * @returns An iterator over the matching indices, descending.
+ */
+export declare function lastIndicesWhere<T>(iterable: Iterable<T>, predicate: Predicate<[T, number]>): IterableIterator<number>;
+//# sourceMappingURL=indices-where.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"indices-where.d.ts","sourceRoot":"","sources":["../../src/iterable/indices-where.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AAEtD;;;;;;;;;GASG;AACH,wBAAiB,YAAY,CAAC,CAAC,EAC9B,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EACrB,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,GAC/B,gBAAgB,CAAC,MAAM,CAAC,CAU1B;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAiB,gBAAgB,CAAC,CAAC,EAClC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EACrB,SAAS,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC,GAC/B,gBAAgB,CAAC,MAAM,CAAC,CAQ1B"}

package/dist/iterable/indices-where.js

@@ -0,0 +1,46 @@
+/**
+ * Yields the zero-based index of every element satisfying `predicate`, rather
+ * than the elements themselves.
+ *
+ * Time complexity: O(1) per element.
+ *
+ * @param iterable The input iterable.
+ * @param predicate Receives each element and its zero-based index.
+ * @returns An iterator over the matching indices, ascending.
+ */
+export function* indicesWhere(iterable, predicate) {
+    let index = 0;
+    for (const item of iterable) {
+        if (predicate(item, index)) {
+            yield index;
+        }
+        index++;
+    }
+}
+/**
+ * Yields the zero-based index of every element satisfying `predicate`, scanning
+ * from the end.
+ *
+ * Indices are still counted from the start — only the order they are yielded in
+ * is reversed, so the result is `indicesWhere` reversed.
+ *
+ * An iterable has no end to start from, so a non-array source is materialised
+ * first and the whole of it is held in memory. An array is walked backwards in
+ * place.
+ *
+ * Time complexity: O(n), with O(n) memory for a non-array source and O(1) for
+ * an array.
+ *
+ * @param iterable The input iterable.
+ * @param predicate Receives each element and its zero-based index.
+ * @returns An iterator over the matching indices, descending.
+ */
+export function* lastIndicesWhere(iterable, predicate) {
+    const items = Array.isArray(iterable) ? iterable : [...iterable];
+    for (let index = items.length - 1; index >= 0; index--) {
+        if (predicate(items[index], index)) {
+            yield index;
+        }
+    }
+}
+//# sourceMappingURL=indices-where.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"indices-where.js","sourceRoot":"","sources":["../../src/iterable/indices-where.ts"],"names":[],"mappings":"AAEA;;;;;;;;;GASG;AACH,MAAM,SAAS,CAAC,CAAC,YAAY,CAC5B,QAAqB,EACrB,SAAiC;IAEjC,IAAI,KAAK,GAAG,CAAC,CAAC;IAEd,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC7B,IAAI,SAAS,CAAC,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC;YAC5B,MAAM,KAAK,CAAC;QACb,CAAC;QAED,KAAK,EAAE,CAAC;IACT,CAAC;AACF,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,SAAS,CAAC,CAAC,gBAAgB,CAChC,QAAqB,EACrB,SAAiC;IAEjC,MAAM,KAAK,GAAG,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAE,QAAgB,CAAC,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC;IAE1E,KAAK,IAAI,KAAK,GAAG,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,KAAK,IAAI,CAAC,EAAE,KAAK,EAAE,EAAE,CAAC;QACxD,IAAI,SAAS,CAAC,KAAK,CAAC,KAAK,CAAE,EAAE,KAAK,CAAC,EAAE,CAAC;YACrC,MAAM,KAAK,CAAC;QACb,CAAC;IACF,CAAC;AACF,CAAC"}