@ac-kit/core 0.1.0

package/dist/iterable/intersperse.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Yields `separator` between consecutive elements, with none before the first
+ * or after the last.
+ *
+ * `Array.prototype.join` for values that are not strings, and lazy.
+ *
+ * Time complexity: O(1) per element.
+ *
+ * @param iterable The input iterable.
+ * @param separator The value to place between elements.
+ * @returns An iterator over the elements, separated. Empty when the input is,
+ *   and a single element is yielded alone.
+ */
+export declare function intersperse<T, S>(iterable: Iterable<T>, separator: S): IterableIterator<T | S>;
+//# sourceMappingURL=intersperse.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"intersperse.d.ts","sourceRoot":"","sources":["../../src/iterable/intersperse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAiB,WAAW,CAAC,CAAC,EAAE,CAAC,EAChC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EACrB,SAAS,EAAE,CAAC,GACV,gBAAgB,CAAC,CAAC,GAAG,CAAC,CAAC,CAWzB"}

package/dist/iterable/intersperse.js

@@ -0,0 +1,24 @@
+/**
+ * Yields `separator` between consecutive elements, with none before the first
+ * or after the last.
+ *
+ * `Array.prototype.join` for values that are not strings, and lazy.
+ *
+ * Time complexity: O(1) per element.
+ *
+ * @param iterable The input iterable.
+ * @param separator The value to place between elements.
+ * @returns An iterator over the elements, separated. Empty when the input is,
+ *   and a single element is yielded alone.
+ */
+export function* intersperse(iterable, separator) {
+    let isFirst = true;
+    for (const item of iterable) {
+        if (!isFirst) {
+            yield separator;
+        }
+        yield item;
+        isFirst = false;
+    }
+}
+//# sourceMappingURL=intersperse.js.map

package/dist/iterable/intersperse.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"intersperse.js","sourceRoot":"","sources":["../../src/iterable/intersperse.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,SAAS,CAAC,CAAC,WAAW,CAC3B,QAAqB,EACrB,SAAY;IAEZ,IAAI,OAAO,GAAG,IAAI,CAAC;IAEnB,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC7B,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/is-iterable-equal.d.ts

@@ -0,0 +1,21 @@
+import { type EqualityComparisonStrategy } from "../object/is-equal.js";
+export declare const IS_ITERABLE_EQUAL_DEFAULT_COMPARISON_STRATEGY: EqualityComparisonStrategy;
+/**
+ * Checks whether two iterables yield equal elements in the same order, and the
+ * same number of them.
+ *
+ * Short-circuits on the first difference, and closes whichever iterator has not
+ * ended when it does. The comparison is exact: a tolerant predicate is not a
+ * valid equality, so pass one only where intransitivity is acceptable.
+ *
+ * Time complexity: O(n) worst case, O(1) when both are arrays of differing
+ * length.
+ *
+ * @param a The first iterable.
+ * @param b The second iterable.
+ * @param comparisonStrategy The equality comparison strategy to use (default is
+ *   "strict"). Resolved once, not re-dispatched per element.
+ * @returns `true` if both iterables yield the same elements in the same order.
+ */
+export declare function isIterableEqual<T>(a: Iterable<T>, b: Iterable<T>, comparisonStrategy?: EqualityComparisonStrategy<T, T>): boolean;
+//# sourceMappingURL=is-iterable-equal.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"is-iterable-equal.d.ts","sourceRoot":"","sources":["../../src/iterable/is-iterable-equal.ts"],"names":[],"mappings":"AAAA,OAAO,EACN,KAAK,0BAA0B,EAE/B,MAAM,uBAAuB,CAAC;AAE/B,eAAO,MAAM,6CAA6C,EAAE,0BACnD,CAAC;AAEV;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAChC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,EACd,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,EACd,kBAAkB,GAAE,0BAA0B,CAC7C,CAAC,EACD,CAAC,CAC+C,GAC/C,OAAO,CA+BT"}

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

@@ -0,0 +1,46 @@
+import { resolveEqualityComparator, } from "../object/is-equal.js";
+export const IS_ITERABLE_EQUAL_DEFAULT_COMPARISON_STRATEGY = "strict";
+/**
+ * Checks whether two iterables yield equal elements in the same order, and the
+ * same number of them.
+ *
+ * Short-circuits on the first difference, and closes whichever iterator has not
+ * ended when it does. The comparison is exact: a tolerant predicate is not a
+ * valid equality, so pass one only where intransitivity is acceptable.
+ *
+ * Time complexity: O(n) worst case, O(1) when both are arrays of differing
+ * length.
+ *
+ * @param a The first iterable.
+ * @param b The second iterable.
+ * @param comparisonStrategy The equality comparison strategy to use (default is
+ *   "strict"). Resolved once, not re-dispatched per element.
+ * @returns `true` if both iterables yield the same elements in the same order.
+ */
+export function isIterableEqual(a, b, comparisonStrategy = IS_ITERABLE_EQUAL_DEFAULT_COMPARISON_STRATEGY) {
+    if (Array.isArray(a) && Array.isArray(b) && a.length !== b.length) {
+        return false;
+    }
+    const comparator = resolveEqualityComparator(comparisonStrategy);
+    const iteratorA = a[Symbol.iterator]();
+    const iteratorB = b[Symbol.iterator]();
+    while (true) {
+        const resultA = iteratorA.next();
+        const resultB = iteratorB.next();
+        if (resultA.done === true || resultB.done === true) {
+            if (resultA.done !== true) {
+                iteratorA.return?.();
+            }
+            if (resultB.done !== true) {
+                iteratorB.return?.();
+            }
+            return resultA.done === true && resultB.done === true;
+        }
+        if (!comparator(resultA.value, resultB.value)) {
+            iteratorA.return?.();
+            iteratorB.return?.();
+            return false;
+        }
+    }
+}
+//# sourceMappingURL=is-iterable-equal.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"is-iterable-equal.js","sourceRoot":"","sources":["../../src/iterable/is-iterable-equal.ts"],"names":[],"mappings":"AAAA,OAAO,EAEN,yBAAyB,GACzB,MAAM,uBAAuB,CAAC;AAE/B,MAAM,CAAC,MAAM,6CAA6C,GACzD,QAAQ,CAAC;AAEV;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,eAAe,CAC9B,CAAc,EACd,CAAc,EACd,kBAAkB,GAGd,6CAA6C;IAEjD,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,MAAM,KAAK,CAAC,CAAC,MAAM,EAAE,CAAC;QACnE,OAAO,KAAK,CAAC;IACd,CAAC;IAED,MAAM,UAAU,GAAG,yBAAyB,CAAC,kBAAkB,CAAC,CAAC;IACjE,MAAM,SAAS,GAAG,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;IACvC,MAAM,SAAS,GAAG,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;IAEvC,OAAO,IAAI,EAAE,CAAC;QACb,MAAM,OAAO,GAAG,SAAS,CAAC,IAAI,EAAE,CAAC;QACjC,MAAM,OAAO,GAAG,SAAS,CAAC,IAAI,EAAE,CAAC;QAEjC,IAAI,OAAO,CAAC,IAAI,KAAK,IAAI,IAAI,OAAO,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;YACpD,IAAI,OAAO,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;gBAC3B,SAAS,CAAC,MAAM,EAAE,EAAE,CAAC;YACtB,CAAC;YACD,IAAI,OAAO,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;gBAC3B,SAAS,CAAC,MAAM,EAAE,EAAE,CAAC;YACtB,CAAC;YAED,OAAO,OAAO,CAAC,IAAI,KAAK,IAAI,IAAI,OAAO,CAAC,IAAI,KAAK,IAAI,CAAC;QACvD,CAAC;QAED,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC;YAC/C,SAAS,CAAC,MAAM,EAAE,EAAE,CAAC;YACrB,SAAS,CAAC,MAAM,EAAE,EAAE,CAAC;YAErB,OAAO,KAAK,CAAC;QACd,CAAC;IACF,CAAC;AACF,CAAC"}

package/dist/iterable/last.d.ts

@@ -0,0 +1,15 @@
+import type { DefinedValue } from "../types/defined-value.js";
+/**
+ * Returns the last 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) for an array, which is indexed directly; O(n) for any
+ * other iterable, which has to be drained to reach its end.
+ *
+ * @param iterable The iterable to read from.
+ * @returns The last element, or `undefined` if there is none.
+ */
+export declare function last<T extends DefinedValue>(iterable: Iterable<T>): T | undefined;
+//# sourceMappingURL=last.d.ts.map

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

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

package/dist/iterable/last.js

@@ -0,0 +1,25 @@
+/**
+ * Returns the last 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) for an array, which is indexed directly; O(n) for any
+ * other iterable, which has to be drained to reach its end.
+ *
+ * @param iterable The iterable to read from.
+ * @returns The last element, or `undefined` if there is none.
+ */
+export function last(iterable) {
+    if (Array.isArray(iterable)) {
+        // Safe: `Array.isArray` widens the element type to `any`, losing the `T`
+        // the parameter already guarantees.
+        return iterable[iterable.length - 1];
+    }
+    let result;
+    for (const item of iterable) {
+        result = item;
+    }
+    return result;
+}
+//# sourceMappingURL=last.js.map

package/dist/iterable/last.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"last.js","sourceRoot":"","sources":["../../src/iterable/last.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,IAAI,CACnB,QAAqB;IAErB,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC7B,yEAAyE;QACzE,oCAAoC;QACpC,OAAQ,QAAgB,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAC/C,CAAC;IAED,IAAI,MAAqB,CAAC;IAE1B,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC7B,MAAM,GAAG,IAAI,CAAC;IACf,CAAC;IAED,OAAO,MAAM,CAAC;AACf,CAAC"}

package/dist/iterable/map.d.ts

@@ -0,0 +1,19 @@
+import type { Callable } from "../types/callable.js";
+/**
+ * Yields `mapper(element)` for each element, lazily.
+ *
+ * The `Iterable`-shaped counterpart of `Array.prototype.map` and of
+ * `Iterator.prototype.map`, neither of which accepts a plain `Iterable` without
+ * first materializing it or wrapping it in `Iterator.from`.
+ *
+ * Use {@link filterMap} when the mapper also needs to drop elements, and
+ * {@link tap} when the callback is a side effect rather than a transform.
+ *
+ * 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 An iterator over the mapped values.
+ */
+export declare function map<T, R>(iterable: Iterable<T>, mapper: Callable<[T, number], R>): IterableIterator<R>;
+//# sourceMappingURL=map.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"map.d.ts","sourceRoot":"","sources":["../../src/iterable/map.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAErD;;;;;;;;;;;;;;;GAeG;AACH,wBAAiB,GAAG,CAAC,CAAC,EAAE,CAAC,EACxB,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EACrB,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC,GAC9B,gBAAgB,CAAC,CAAC,CAAC,CAMrB"}

package/dist/iterable/map.js

@@ -0,0 +1,23 @@
+/**
+ * Yields `mapper(element)` for each element, lazily.
+ *
+ * The `Iterable`-shaped counterpart of `Array.prototype.map` and of
+ * `Iterator.prototype.map`, neither of which accepts a plain `Iterable` without
+ * first materializing it or wrapping it in `Iterator.from`.
+ *
+ * Use {@link filterMap} when the mapper also needs to drop elements, and
+ * {@link tap} when the callback is a side effect rather than a transform.
+ *
+ * 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 An iterator over the mapped values.
+ */
+export function* map(iterable, mapper) {
+    let index = 0;
+    for (const item of iterable) {
+        yield mapper(item, index++);
+    }
+}
+//# sourceMappingURL=map.js.map

package/dist/iterable/map.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"map.js","sourceRoot":"","sources":["../../src/iterable/map.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,SAAS,CAAC,CAAC,GAAG,CACnB,QAAqB,EACrB,MAAgC;IAEhC,IAAI,KAAK,GAAG,CAAC,CAAC;IAEd,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC7B,MAAM,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,CAAC,CAAC;IAC7B,CAAC;AACF,CAAC"}

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

@@ -0,0 +1,20 @@
+/** An element together with whether it is the first and whether it is the last. */
+export type MarkedEnd<T> = [item: T, isFirst: boolean, isLast: boolean];
+/**
+ * Yields each element tagged with whether it is the first and whether it is the
+ * last.
+ *
+ * What every formatter needs to decide where separators, indentation or box
+ * corners go, and the reason it is worth having: 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.
+ *
+ * A lone element is both first and last.
+ *
+ * Time complexity: O(1) per element, allocating one tuple per yield.
+ *
+ * @param iterable The input iterable.
+ * @returns An iterator over the tagged elements.
+ */
+export declare function markEnds<T>(iterable: Iterable<T>): IterableIterator<MarkedEnd<T>>;
+//# sourceMappingURL=mark-ends.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mark-ends.d.ts","sourceRoot":"","sources":["../../src/iterable/mark-ends.ts"],"names":[],"mappings":"AAAA,mFAAmF;AACnF,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,CAAC;AAExE;;;;;;;;;;;;;;;GAeG;AACH,wBAAiB,QAAQ,CAAC,CAAC,EAC1B,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GACnB,gBAAgB,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAsBhC"}

package/dist/iterable/mark-ends.js

@@ -0,0 +1,34 @@
+/**
+ * Yields each element tagged with whether it is the first and whether it is the
+ * last.
+ *
+ * What every formatter needs to decide where separators, indentation or box
+ * corners go, and the reason it is worth having: 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.
+ *
+ * A lone element is both first and last.
+ *
+ * Time complexity: O(1) per element, allocating one tuple per yield.
+ *
+ * @param iterable The input iterable.
+ * @returns An iterator over the tagged elements.
+ */
+export function* markEnds(iterable) {
+    const iterator = iterable[Symbol.iterator]();
+    let current = iterator.next();
+    if (current.done === true) {
+        return;
+    }
+    let isFirst = true;
+    while (true) {
+        const next = 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/mark-ends.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mark-ends.js","sourceRoot":"","sources":["../../src/iterable/mark-ends.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;GAeG;AACH,MAAM,SAAS,CAAC,CAAC,QAAQ,CACxB,QAAqB;IAErB,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;IAC7C,IAAI,OAAO,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC;IAE9B,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,QAAQ,CAAC,IAAI,EAAE,CAAC;QAE7B,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/nth.d.ts

@@ -0,0 +1,21 @@
+import type { DefinedValue } from "../types/defined-value.js";
+/**
+ * Returns the element at `index`, or `undefined` when the iterable is shorter
+ * than that.
+ *
+ * `T` cannot itself include `undefined`, so the absent case is never ambiguous.
+ *
+ * Only counts forward. `Array.prototype.at`'s negative index would mean
+ * buffering the whole tail to know where the end is, so it is rejected rather
+ * than paid for silently — `last` covers the `-1` case in O(1) for an array.
+ *
+ * Time complexity: O(index). The iterator is closed as soon as the element is
+ * reached, without draining the rest.
+ *
+ * @param iterable The iterable to read from.
+ * @param index The zero-based position to read. Must be a non-negative integer.
+ * @returns The element at `index`, or `undefined` if there is none.
+ * @throws {RangeError} If `index` is not a non-negative integer.
+ */
+export declare function nth<T extends DefinedValue>(iterable: Iterable<T>, index: number): T | undefined;
+//# sourceMappingURL=nth.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nth.d.ts","sourceRoot":"","sources":["../../src/iterable/nth.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,2BAA2B,CAAC;AAE9D;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,GAAG,CAAC,CAAC,SAAS,YAAY,EACzC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EACrB,KAAK,EAAE,MAAM,GACX,CAAC,GAAG,SAAS,CAgBf"}

package/dist/iterable/nth.js

@@ -0,0 +1,32 @@
+/**
+ * Returns the element at `index`, or `undefined` when the iterable is shorter
+ * than that.
+ *
+ * `T` cannot itself include `undefined`, so the absent case is never ambiguous.
+ *
+ * Only counts forward. `Array.prototype.at`'s negative index would mean
+ * buffering the whole tail to know where the end is, so it is rejected rather
+ * than paid for silently — `last` covers the `-1` case in O(1) for an array.
+ *
+ * Time complexity: O(index). The iterator is closed as soon as the element is
+ * reached, without draining the rest.
+ *
+ * @param iterable The iterable to read from.
+ * @param index The zero-based position to read. Must be a non-negative integer.
+ * @returns The element at `index`, or `undefined` if there is none.
+ * @throws {RangeError} If `index` is not a non-negative integer.
+ */
+export function nth(iterable, index) {
+    if (!Number.isInteger(index) || index < 0) {
+        throw new RangeError("nth index must be a non-negative integer");
+    }
+    let position = 0;
+    for (const item of iterable) {
+        if (position === index) {
+            return item;
+        }
+        position++;
+    }
+    return undefined;
+}
+//# sourceMappingURL=nth.js.map

package/dist/iterable/nth.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nth.js","sourceRoot":"","sources":["../../src/iterable/nth.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,GAAG,CAClB,QAAqB,EACrB,KAAa;IAEb,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;QAC3C,MAAM,IAAI,UAAU,CAAC,0CAA0C,CAAC,CAAC;IAClE,CAAC;IAED,IAAI,QAAQ,GAAG,CAAC,CAAC;IAEjB,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC7B,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/one.d.ts

@@ -0,0 +1,18 @@
+import type { DefinedValue } from "../types/defined-value.js";
+/**
+ * Returns the single element of an iterable, or `undefined` when it is empty,
+ * rejecting any larger count.
+ *
+ * The tolerant half of the pair `only` completes: both reject two or more, and
+ * only this one accepts none. `T` cannot itself include `undefined`, so the
+ * empty case is never ambiguous.
+ *
+ * Time complexity: O(1) — at most two elements are pulled, so this is safe on
+ * an infinite iterable.
+ *
+ * @param iterable The iterable to read from.
+ * @returns The single element, or `undefined` if there is none.
+ * @throws {RangeError} If the iterable holds more than one element.
+ */
+export declare function one<T extends DefinedValue>(iterable: Iterable<T>): T | undefined;
+//# sourceMappingURL=one.d.ts.map

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

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

package/dist/iterable/one.js

@@ -0,0 +1,28 @@
+/**
+ * Returns the single element of an iterable, or `undefined` when it is empty,
+ * rejecting any larger count.
+ *
+ * The tolerant half of the pair `only` completes: both reject two or more, and
+ * only this one accepts none. `T` cannot itself include `undefined`, so the
+ * empty case is never ambiguous.
+ *
+ * Time complexity: O(1) — at most two elements are pulled, so this is safe on
+ * an infinite iterable.
+ *
+ * @param iterable The iterable to read from.
+ * @returns The single element, or `undefined` if there is none.
+ * @throws {RangeError} If the iterable holds more than one element.
+ */
+export function one(iterable) {
+    const iterator = iterable[Symbol.iterator]();
+    const first = iterator.next();
+    if (first.done === true) {
+        return undefined;
+    }
+    if (iterator.next().done !== true) {
+        iterator.return?.();
+        throw new RangeError("expected at most one item, found more");
+    }
+    return first.value;
+}
+//# sourceMappingURL=one.js.map

package/dist/iterable/one.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"one.js","sourceRoot":"","sources":["../../src/iterable/one.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,GAAG,CAClB,QAAqB;IAErB,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;IAC7C,MAAM,KAAK,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC;IAE9B,IAAI,KAAK,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;QACzB,OAAO,SAAS,CAAC;IAClB,CAAC;IAED,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;QACnC,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC;QAEpB,MAAM,IAAI,UAAU,CAAC,uCAAuC,CAAC,CAAC;IAC/D,CAAC;IAED,OAAO,KAAK,CAAC,KAAK,CAAC;AACpB,CAAC"}

package/dist/iterable/only.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Returns the single element of an iterable, rejecting any other count.
+ *
+ * Boundary validation, and the readable form of `items.length === 1 ? items[0]
+ * : throw`. Use `one` where an empty iterable is acceptable.
+ *
+ * Time complexity: O(1) — at most two elements are pulled, so this is safe on
+ * an infinite iterable.
+ *
+ * @param iterable The iterable to read from.
+ * @returns The single element.
+ * @throws {RangeError} If the iterable is empty or holds more than one element.
+ */
+export declare function only<T>(iterable: Iterable<T>): T;
+//# sourceMappingURL=only.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"only.d.ts","sourceRoot":"","sources":["../../src/iterable/only.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,CAehD"}

package/dist/iterable/only.js

@@ -0,0 +1,26 @@
+/**
+ * Returns the single element of an iterable, rejecting any other count.
+ *
+ * Boundary validation, and the readable form of `items.length === 1 ? items[0]
+ * : throw`. Use `one` where an empty iterable is acceptable.
+ *
+ * Time complexity: O(1) — at most two elements are pulled, so this is safe on
+ * an infinite iterable.
+ *
+ * @param iterable The iterable to read from.
+ * @returns The single element.
+ * @throws {RangeError} If the iterable is empty or holds more than one element.
+ */
+export function only(iterable) {
+    const iterator = iterable[Symbol.iterator]();
+    const first = iterator.next();
+    if (first.done === true) {
+        throw new RangeError("expected exactly one item, found none");
+    }
+    if (iterator.next().done !== true) {
+        iterator.return?.();
+        throw new RangeError("expected exactly one item, found more");
+    }
+    return first.value;
+}
+//# sourceMappingURL=only.js.map

package/dist/iterable/only.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"only.js","sourceRoot":"","sources":["../../src/iterable/only.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,IAAI,CAAI,QAAqB;IAC5C,MAAM,QAAQ,GAAG,QAAQ,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;IAC7C,MAAM,KAAK,GAAG,QAAQ,CAAC,IAAI,EAAE,CAAC;IAE9B,IAAI,KAAK,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;QACzB,MAAM,IAAI,UAAU,CAAC,uCAAuC,CAAC,CAAC;IAC/D,CAAC;IAED,IAAI,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;QACnC,QAAQ,CAAC,MAAM,EAAE,EAAE,CAAC;QAEpB,MAAM,IAAI,UAAU,CAAC,uCAAuC,CAAC,CAAC;IAC/D,CAAC;IAED,OAAO,KAAK,CAAC,KAAK,CAAC;AACpB,CAAC"}

package/dist/iterable/pad.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"pad.d.ts","sourceRoot":"","sources":["../../src/iterable/pad.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,wBAAiB,GAAG,CAAC,CAAC,EAAE,CAAC,EACxB,QAAQ,EAAE,QAAQ,CAAC,CAAC,CAAC,EACrB,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,CAAC,GACL,gBAAgB,CAAC,CAAC,GAAG,CAAC,CAAC,CAezB"}

package/dist/iterable/pad.js

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

package/dist/iterable/pad.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pad.js","sourceRoot":"","sources":["../../src/iterable/pad.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,MAAM,SAAS,CAAC,CAAC,GAAG,CACnB,QAAqB,EACrB,MAAc,EACd,IAAO;IAEP,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,MAAM,GAAG,CAAC,EAAE,CAAC;QAC7C,MAAM,IAAI,UAAU,CAAC,2CAA2C,CAAC,CAAC;IACnE,CAAC;IAED,IAAI,OAAO,GAAG,CAAC,CAAC;IAEhB,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC7B,OAAO,EAAE,CAAC;QACV,MAAM,IAAI,CAAC;IACZ,CAAC;IAED,OAAO,OAAO,GAAG,MAAM,EAAE,OAAO,EAAE,EAAE,CAAC;QACpC,MAAM,IAAI,CAAC;IACZ,CAAC;AACF,CAAC"}

package/dist/iterable/pairwise.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Yields each consecutive overlapping pair of elements.
+ *
+ * The `size = 2` case of `windowed`, kept separate so the result is a `[T, T]`
+ * tuple rather than a `T[]` a caller has to assert the width of.
+ *
+ * An input of fewer than two elements yields nothing.
+ *
+ * Time complexity: O(n), allocating one tuple per pair.
+ *
+ * @param iterable The input iterable.
+ * @returns An iterator over the pairs, each holding an element and the one
+ *   after it.
+ */
+export declare function pairwise<T>(iterable: Iterable<T>): IterableIterator<[T, T]>;
+//# sourceMappingURL=pairwise.d.ts.map

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

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

package/dist/iterable/pairwise.js

@@ -0,0 +1,26 @@
+/**
+ * Yields each consecutive overlapping pair of elements.
+ *
+ * The `size = 2` case of `windowed`, kept separate so the result is a `[T, T]`
+ * tuple rather than a `T[]` a caller has to assert the width of.
+ *
+ * An input of fewer than two elements yields nothing.
+ *
+ * Time complexity: O(n), allocating one tuple per pair.
+ *
+ * @param iterable The input iterable.
+ * @returns An iterator over the pairs, each holding an element and the one
+ *   after it.
+ */
+export function* pairwise(iterable) {
+    let previous;
+    let hasPrevious = false;
+    for (const item of iterable) {
+        if (hasPrevious) {
+            yield [previous, item];
+        }
+        previous = item;
+        hasPrevious = true;
+    }
+}
+//# sourceMappingURL=pairwise.js.map

package/dist/iterable/pairwise.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pairwise.js","sourceRoot":"","sources":["../../src/iterable/pairwise.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,MAAM,SAAS,CAAC,CAAC,QAAQ,CAAI,QAAqB;IACjD,IAAI,QAAW,CAAC;IAChB,IAAI,WAAW,GAAG,KAAK,CAAC;IAExB,KAAK,MAAM,IAAI,IAAI,QAAQ,EAAE,CAAC;QAC7B,IAAI,WAAW,EAAE,CAAC;YACjB,MAAM,CAAC,QAAS,EAAE,IAAI,CAAC,CAAC;QACzB,CAAC;QAED,QAAQ,GAAG,IAAI,CAAC;QAChB,WAAW,GAAG,IAAI,CAAC;IACpB,CAAC;AACF,CAAC"}

package/dist/iterable/range.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Yields the arithmetic progression from `start` towards `stop`, exclusive.
+ *
+ * Stands in for TC39's `Iterator.range`, and follows it: `start` is required,
+ * `stop` is exclusive, and a `stop` of `Infinity` (or `-Infinity` with a
+ * negative `step`) yields forever. Nothing is materialised.
+ *
+ * Each value is computed as `start + step * index` rather than accumulated, so
+ * a fractional `step` does not drift — `range(0, 1, 0.1)` ends at `0.9`, not at
+ * `0.9999999999999999`.
+ *
+ * Time complexity: O(1) to construct, O(1) per value.
+ *
+ * @param start The first value, inclusive. Must be finite.
+ * @param stop The bound to stop before, exclusive. May be infinite.
+ * @param step How much to advance by. Must be finite and non-zero; a negative
+ *   value counts down.
+ * @returns An iterator over the progression. Empty when `stop` is already on
+ *   the far side of `start`.
+ * @throws {RangeError} If `start` is not finite, `stop` is `NaN`, or `step` is
+ *   zero, `NaN` or infinite.
+ */
+export declare function range(start: number, stop: number, step?: number): IterableIterator<number>;
+//# sourceMappingURL=range.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"range.d.ts","sourceRoot":"","sources":["../../src/iterable/range.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAiB,KAAK,CACrB,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,IAAI,SAAI,GACN,gBAAgB,CAAC,MAAM,CAAC,CAoB1B"}