@siteimprove/alfa-iterable 0.89.5

package/CHANGELOG.md

@@ -0,0 +1,157 @@
+# @siteimprove/alfa-iterable
+
+## 0.89.3
+
+## 0.89.2
+
+### Patch Changes
+
+- **Changed:** Trying to fix a problem in generating provenance statements ([#1674](https://github.com/Siteimprove/alfa/pull/1674))
+
+## 0.89.1
+
+### Patch Changes
+
+- **Added:** Trying to publish Alfa packages on the npm registry ([#1673](https://github.com/Siteimprove/alfa/pull/1673))
+
+## 0.89.0
+
+## 0.88.0
+
+### Minor Changes
+
+- **Fixed:** The publish flow was updated to a new version. ([`a2f19cf9a6c7c72b8bf085597e4f1a95ac3e4eb2`](https://github.com/Siteimprove/alfa/commit/a2f19cf9a6c7c72b8bf085597e4f1a95ac3e4eb2))
+
+  Some 0.87.\* versions were generating uninstallable package. This should be fixed now.
+
+## 0.87.12
+
+## 0.87.11
+
+## 0.87.10
+
+## 0.87.7
+
+## 0.87.6
+
+## 0.87.5
+
+## 0.87.4
+
+## 0.87.3
+
+## 0.87.2
+
+## 0.87.1
+
+## 0.87.0
+
+### Minor Changes
+
+- **Breaking:** Optional serialization type parameters have been removed. ([#1651](https://github.com/Siteimprove/alfa/pull/1651))
+
+## 0.86.2
+
+## 0.86.1
+
+## 0.86.0
+
+### Minor Changes
+
+- **Breaking:** TS resolution has been changed to `Node16`, target to `es2022`. ([#1636](https://github.com/Siteimprove/alfa/pull/1636))
+
+- **Breaking:** Alfa is now distributed as ESM rather than CJS modules; projects using it must be ESM or use dynamic `import()`. ([#1636](https://github.com/Siteimprove/alfa/pull/1636))
+
+  ⚠️ This is the last of a series of changes on the internal structure and build process of distributed packages that was started with v0.85.0.
+
+## 0.85.1
+
+## 0.85.0
+
+### Minor Changes
+
+- **Breaking:** The .js files are now built in the `dist` folder rather than in `src`. ([#1628](https://github.com/Siteimprove/alfa/pull/1628))
+
+  ⚠️ This is the first of a series of changes on the internal structure and build process of distributed packages. It is probably better to not use this version and wait until more of these internal changes have been done to jump directly to the final result. We are internally releasing these changes for validation purpose only.
+
+  This should not impact consumers, the `package.json` files should be set correctly to consume these files.
+
+## 0.84.0
+
+## 0.83.1
+
+## 0.83.0
+
+## 0.82.0
+
+### Minor Changes
+
+- **Added:** Serialization options are now accepted, and passed on, by `toJSON()` on these types. ([#1622](https://github.com/Siteimprove/alfa/pull/1622))
+
+- **Breaking:** Node 18 is no longer supported. ([#1618](https://github.com/Siteimprove/alfa/pull/1618))
+
+## 0.81.0
+
+### Patch Changes
+
+- **Added:** Each package now contains its internal dependency graph in its `docs` directory. ([#1610](https://github.com/Siteimprove/alfa/pull/1610))
+
+## 0.80.0
+
+## 0.79.1
+
+## 0.79.0
+
+## 0.78.2
+
+## 0.78.1
+
+## 0.78.0
+
+## 0.77.0
+
+## 0.76.0
+
+## 0.75.2
+
+## 0.75.1
+
+## 0.75.0
+
+## 0.74.0
+
+## 0.73.0
+
+## 0.72.0
+
+## 0.71.1
+
+## 0.71.0
+
+## 0.70.0
+
+## 0.69.0
+
+## 0.68.0
+
+## 0.67.0
+
+## 0.66.0
+
+## 0.65.1
+
+## 0.65.0
+
+## 0.64.0
+
+## 0.63.3
+
+## 0.63.2
+
+## 0.63.1
+
+## 0.63.0
+
+## 0.62.2
+
+## 0.62.1

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./iterable.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from "./iterable.js";
+//# sourceMappingURL=index.js.map

package/dist/iterable.d.ts

@@ -0,0 +1,95 @@
+import type { Callback } from "@siteimprove/alfa-callback";
+import { Comparable, type Comparer, Comparison } from "@siteimprove/alfa-comparable";
+import type { Hash } from "@siteimprove/alfa-hash";
+import { Serializable } from "@siteimprove/alfa-json";
+import type { Mapper } from "@siteimprove/alfa-mapper";
+import { Option } from "@siteimprove/alfa-option";
+import { Predicate } from "@siteimprove/alfa-predicate";
+import type { Reducer } from "@siteimprove/alfa-reducer";
+import { Refinement } from "@siteimprove/alfa-refinement";
+/**
+ * @remarks
+ * This is a re-export of the global `Iterable` interface to ensure that it
+ * merges with the `Iterable` namespace.
+ *
+ * @public
+ */
+export type Iterable<T> = globalThis.Iterable<T>;
+/**
+ * @public
+ */
+export declare namespace Iterable {
+    function isIterable<T>(value: unknown): value is Iterable<T>;
+    function empty<T>(): Iterable<T>;
+    function from<T>(arrayLike: ArrayLike<T>): Iterable<T>;
+    function size<T>(iterable: Iterable<T>): number;
+    function isEmpty<T>(iterable: Iterable<T>): iterable is Iterable<never>;
+    function forEach<T>(iterable: Iterable<T>, callback: Callback<T, void, [index: number]>): void;
+    function map<T, U = T>(iterable: Iterable<T>, mapper: Mapper<T, U, [index: number]>): Iterable<U>;
+    function flatMap<T, U = T>(iterable: Iterable<T>, mapper: Mapper<T, Iterable<U>, [index: number]>): Iterable<U>;
+    function flatten<T>(iterable: Iterable<Iterable<T>>): Iterable<T>;
+    function reduce<T, U = T>(iterable: Iterable<T>, reducer: Reducer<T, U, [index: number]>, accumulator: U): U;
+    function reduceWhile<T, U = T>(iterable: Iterable<T>, predicate: Predicate<T, [index: number]>, reducer: Reducer<T, U, [index: number]>, accumulator: U): U;
+    function reduceUntil<T, U = T>(iterable: Iterable<T>, predicate: Predicate<T, [index: number]>, reducer: Reducer<T, U, [index: number]>, accumulator: U): U;
+    function apply<T, U>(iterable: Iterable<T>, mapper: Iterable<Mapper<T, U>>): Iterable<U>;
+    function filter<T, U extends T>(iterable: Iterable<T>, refinement: Refinement<T, U, [index: number]>): Iterable<U>;
+    function filter<T>(iterable: Iterable<T>, predicate: Predicate<T, [index: number]>): Iterable<T>;
+    function reject<T, U extends T>(iterable: Iterable<T>, refinement: Refinement<T, U, [index: number]>): Iterable<Exclude<T, U>>;
+    function reject<T>(iterable: Iterable<T>, predicate: Predicate<T, [index: number]>): Iterable<T>;
+    function find<T, U extends T>(iterable: Iterable<T>, refinement: Refinement<T, U, [index: number]>): Option<U>;
+    function find<T>(iterable: Iterable<T>, predicate: Predicate<T, [index: number]>): Option<T>;
+    function findLast<T, U extends T>(iterable: Iterable<T>, refinement: Refinement<T, U, [index: number]>): Option<U>;
+    function findLast<T>(iterable: Iterable<T>, predicate: Predicate<T, [index: number]>): Option<T>;
+    function includes<T>(iterable: Iterable<T>, value: T): boolean;
+    function collect<T, U>(iterable: Iterable<T>, mapper: Mapper<T, Option<U>, [index: number]>): Iterable<U>;
+    function collectFirst<T, U>(iterable: Iterable<T>, mapper: Mapper<T, Option<U>, [index: number]>): Option<U>;
+    function some<T>(iterable: Iterable<T>, predicate: Predicate<T, [index: number]>): boolean;
+    function none<T>(iterable: Iterable<T>, predicate: Predicate<T, [index: number]>): boolean;
+    function every<T>(iterable: Iterable<T>, predicate: Predicate<T, [index: number]>): boolean;
+    function count<T>(iterable: Iterable<T>, predicate: Predicate<T, [index: number]>): number;
+    function distinct<T>(iterable: Iterable<T>): Iterable<T>;
+    function get<T>(iterable: Iterable<T>, index: number): Option<T>;
+    function has<T>(iterable: Iterable<T>, index: number): boolean;
+    function set<T>(iterable: Iterable<T>, index: number, value: T): Iterable<T>;
+    function insert<T>(iterable: Iterable<T>, index: number, value: T): Iterable<T>;
+    function append<T>(iterable: Iterable<T>, value: T): Iterable<T>;
+    function prepend<T>(iterable: Iterable<T>, value: T): Iterable<T>;
+    function concat<T>(iterable: Iterable<T>, ...iterables: Array<Iterable<T>>): Iterable<T>;
+    function subtract<T>(iterable: Iterable<T>, ...iterables: Array<Iterable<T>>): Iterable<T>;
+    function intersect<T>(iterable: Iterable<T>, ...iterables: Array<Iterable<T>>): Iterable<T>;
+    function zip<T, U = T>(a: Iterable<T>, b: Iterable<U>): Iterable<[T, U]>;
+    function first<T>(iterable: Iterable<T>): Option<T>;
+    function last<T>(iterable: Iterable<T>): Option<T>;
+    function take<T>(iterable: Iterable<T>, count: number): Iterable<T>;
+    function takeWhile<T, U extends T>(iterable: Iterable<T>, refinement: Refinement<T, U, [index: number]>): Iterable<U>;
+    function takeWhile<T>(iterable: Iterable<T>, predicate: Predicate<T, [index: number]>): Iterable<T>;
+    function takeUntil<T>(iterable: Iterable<T>, predicate: Predicate<T, [index: number]>): Iterable<T>;
+    function takeLast<T>(iterable: Iterable<T>, count?: number): Iterable<T>;
+    function takeLastWhile<T, U extends T>(iterable: Iterable<T>, refinement: Refinement<T, U, [index: number]>): Iterable<U>;
+    function takeLastWhile<T>(iterable: Iterable<T>, predicate: Predicate<T, [index: number]>): Iterable<T>;
+    function takeLastUntil<T>(iterable: Iterable<T>, predicate: Predicate<T, [index: number]>): Iterable<T>;
+    function skip<T>(iterable: Iterable<T>, count: number): Iterable<T>;
+    function skipWhile<T>(iterable: Iterable<T>, predicate: Predicate<T, [index: number]>): Iterable<T>;
+    function skipUntil<T>(iterable: Iterable<T>, predicate: Predicate<T, [index: number]>): Iterable<T>;
+    function skipLast<T>(iterable: Iterable<T>, count?: number): Iterable<T>;
+    function skipLastWhile<T>(iterable: Iterable<T>, predicate: Predicate<T, [index: number]>): Iterable<T>;
+    function skipLastUntil<T>(iterable: Iterable<T>, predicate: Predicate<T, [index: number]>): Iterable<T>;
+    function trim<T>(iterable: Iterable<T>, predicate: Predicate<T, [index: number]>): Iterable<T>;
+    function trimLeading<T>(iterable: Iterable<T>, predicate: Predicate<T, [index: number]>): Iterable<T>;
+    function trimTrailing<T>(iterable: Iterable<T>, predicate: Predicate<T, [index: number]>): Iterable<T>;
+    function rest<T>(iterable: Iterable<T>): Iterable<T>;
+    function slice<T>(iterable: Iterable<T>, start: number, end?: number): Iterable<T>;
+    function reverse<T>(iterable: Iterable<T>): Iterable<T>;
+    function join<T>(iterable: Iterable<T>, separator: string): string;
+    function sort<T extends Comparable<T>>(iterable: Iterable<T>): Iterable<T>;
+    function sortWith<T>(iterable: Iterable<T>, comparer: Comparer<T>): Iterable<T>;
+    function sortWith<T, U extends T = T>(iterable: Iterable<U>, comparer: Comparer<T>): Iterable<U>;
+    function compare<T extends Comparable<U>, U = T>(a: Iterable<T>, b: Iterable<U>): Comparison;
+    function compareWith<T, U = T>(a: Iterable<T>, b: Iterable<U>, comparer: Comparer<T, U, [index: number]>): Comparison;
+    function equals<T>(a: Iterable<T>, b: Iterable<T>): boolean;
+    function hash<T>(iterable: Iterable<T>, hash: Hash): void;
+    function iterator<T>(iterable: Iterable<T>): Iterator<T>;
+    function groupBy<T, K>(iterable: Iterable<T>, grouper: Mapper<T, K, [index: number]>): Iterable<[K, Iterable<T>]>;
+    function toJSON<T>(iterable: Iterable<T>, options?: Serializable.Options): Array<Serializable.ToJSON<T>>;
+}
+//# sourceMappingURL=iterable.d.ts.map

package/dist/iterable.js

@@ -0,0 +1,545 @@
+import { Comparable, Comparison, } from "@siteimprove/alfa-comparable";
+import { Equatable } from "@siteimprove/alfa-equatable";
+import { Serializable } from "@siteimprove/alfa-json";
+import { Option, None } from "@siteimprove/alfa-option";
+import { Predicate } from "@siteimprove/alfa-predicate";
+import { Refinement } from "@siteimprove/alfa-refinement";
+const { not } = Predicate;
+const { isObject } = Refinement;
+const { compareComparable } = Comparable;
+/**
+ * @public
+ */
+export var Iterable;
+(function (Iterable) {
+    function isIterable(value) {
+        return isObject(value) && Symbol.iterator in value;
+    }
+    Iterable.isIterable = isIterable;
+    function* empty() { }
+    Iterable.empty = empty;
+    function* from(arrayLike) {
+        for (let i = 0, n = arrayLike.length; i < n; i++) {
+            yield arrayLike[i];
+        }
+    }
+    Iterable.from = from;
+    function size(iterable) {
+        return reduce(iterable, (size) => size + 1, 0);
+    }
+    Iterable.size = size;
+    function isEmpty(iterable) {
+        for (const _ of iterable) {
+            return false;
+        }
+        return true;
+    }
+    Iterable.isEmpty = isEmpty;
+    function forEach(iterable, callback) {
+        let index = 0;
+        for (const value of iterable) {
+            callback(value, index++);
+        }
+    }
+    Iterable.forEach = forEach;
+    function* map(iterable, mapper) {
+        let index = 0;
+        for (const value of iterable) {
+            yield mapper(value, index++);
+        }
+    }
+    Iterable.map = map;
+    function* flatMap(iterable, mapper) {
+        let index = 0;
+        for (const value of iterable) {
+            yield* mapper(value, index++);
+        }
+    }
+    Iterable.flatMap = flatMap;
+    function* flatten(iterable) {
+        for (const value of iterable) {
+            yield* value;
+        }
+    }
+    Iterable.flatten = flatten;
+    function reduce(iterable, reducer, accumulator) {
+        let index = 0;
+        for (const value of iterable) {
+            accumulator = reducer(accumulator, value, index++);
+        }
+        return accumulator;
+    }
+    Iterable.reduce = reduce;
+    function reduceWhile(iterable, predicate, reducer, accumulator) {
+        let index = 0;
+        for (const value of iterable) {
+            if (predicate(value, index)) {
+                accumulator = reducer(accumulator, value, index++);
+            }
+            else {
+                break;
+            }
+        }
+        return accumulator;
+    }
+    Iterable.reduceWhile = reduceWhile;
+    function reduceUntil(iterable, predicate, reducer, accumulator) {
+        return reduceWhile(iterable, not(predicate), reducer, accumulator);
+    }
+    Iterable.reduceUntil = reduceUntil;
+    function apply(iterable, mapper) {
+        return flatMap(mapper, (mapper) => map(iterable, mapper));
+    }
+    Iterable.apply = apply;
+    function* filter(iterable, predicate) {
+        let index = 0;
+        for (const value of iterable) {
+            if (predicate(value, index++)) {
+                yield value;
+            }
+        }
+    }
+    Iterable.filter = filter;
+    function reject(iterable, predicate) {
+        return filter(iterable, not(predicate));
+    }
+    Iterable.reject = reject;
+    function find(iterable, predicate) {
+        let index = 0;
+        for (const value of iterable) {
+            if (predicate(value, index++)) {
+                return Option.of(value);
+            }
+        }
+        return None;
+    }
+    Iterable.find = find;
+    function findLast(iterable, predicate) {
+        let index = 0;
+        let result = None;
+        for (const value of iterable) {
+            if (predicate(value, index++)) {
+                result = Option.of(value);
+            }
+        }
+        return result;
+    }
+    Iterable.findLast = findLast;
+    function includes(iterable, value) {
+        return some(iterable, Predicate.equals(value));
+    }
+    Iterable.includes = includes;
+    function collect(iterable, mapper) {
+        return flatMap(iterable, mapper);
+    }
+    Iterable.collect = collect;
+    function collectFirst(iterable, mapper) {
+        return first(collect(iterable, mapper));
+    }
+    Iterable.collectFirst = collectFirst;
+    function some(iterable, predicate) {
+        let index = 0;
+        for (const value of iterable) {
+            if (predicate(value, index++)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    Iterable.some = some;
+    function none(iterable, predicate) {
+        return every(iterable, not(predicate));
+    }
+    Iterable.none = none;
+    function every(iterable, predicate) {
+        let index = 0;
+        for (const value of iterable) {
+            if (!predicate(value, index++)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    Iterable.every = every;
+    function count(iterable, predicate) {
+        return reduce(iterable, (count, value, index) => (predicate(value, index) ? count + 1 : count), 0);
+    }
+    Iterable.count = count;
+    function* distinct(iterable) {
+        const seen = [];
+        for (const value of iterable) {
+            if (seen.some(Predicate.equals(value))) {
+                continue;
+            }
+            seen.push(value);
+            yield value;
+        }
+    }
+    Iterable.distinct = distinct;
+    function get(iterable, index) {
+        return index < 0 ? None : first(skip(iterable, index));
+    }
+    Iterable.get = get;
+    function has(iterable, index) {
+        return index < 0 ? false : !isEmpty(skip(iterable, index));
+    }
+    Iterable.has = has;
+    function* set(iterable, index, value) {
+        const it = iterator(iterable);
+        while (index-- > 0) {
+            const next = it.next();
+            if (next.done === true) {
+                return;
+            }
+            yield next.value;
+        }
+        const next = it.next();
+        if (next.done === true) {
+            return;
+        }
+        yield value;
+        while (true) {
+            const next = it.next();
+            if (next.done === true) {
+                return;
+            }
+            yield next.value;
+        }
+    }
+    Iterable.set = set;
+    function* insert(iterable, index, value) {
+        const it = iterator(iterable);
+        while (index-- > 0) {
+            const next = it.next();
+            if (next.done === true) {
+                return;
+            }
+            yield next.value;
+        }
+        yield value;
+        while (true) {
+            const next = it.next();
+            if (next.done === true) {
+                return;
+            }
+            yield next.value;
+        }
+    }
+    Iterable.insert = insert;
+    function* append(iterable, value) {
+        yield* iterable;
+        yield value;
+    }
+    Iterable.append = append;
+    function* prepend(iterable, value) {
+        yield value;
+        yield* iterable;
+    }
+    Iterable.prepend = prepend;
+    function* concat(iterable, ...iterables) {
+        yield* iterable;
+        for (const iterable of iterables) {
+            yield* iterable;
+        }
+    }
+    Iterable.concat = concat;
+    function subtract(iterable, ...iterables) {
+        return reject(iterable, (value) => includes(flatten(iterables), value));
+    }
+    Iterable.subtract = subtract;
+    function intersect(iterable, ...iterables) {
+        return filter(iterable, (value) => includes(flatten(iterables), value));
+    }
+    Iterable.intersect = intersect;
+    function* zip(a, b) {
+        const itA = iterator(a);
+        const itB = iterator(b);
+        while (true) {
+            const a = itA.next();
+            const b = itB.next();
+            if (a.done === true || b.done === true) {
+                return;
+            }
+            yield [a.value, b.value];
+        }
+    }
+    Iterable.zip = zip;
+    function first(iterable) {
+        for (const value of iterable) {
+            return Option.of(value);
+        }
+        return None;
+    }
+    Iterable.first = first;
+    function last(iterable) {
+        let last = null;
+        for (const value of iterable) {
+            last = value;
+        }
+        return Option.from(last);
+    }
+    Iterable.last = last;
+    function* take(iterable, count) {
+        const it = iterator(iterable);
+        while (count-- > 0) {
+            const next = it.next();
+            if (next.done === true) {
+                return;
+            }
+            yield next.value;
+        }
+    }
+    Iterable.take = take;
+    function* takeWhile(iterable, predicate) {
+        let index = 0;
+        for (const value of iterable) {
+            if (predicate(value, index++)) {
+                yield value;
+            }
+            else {
+                break;
+            }
+        }
+    }
+    Iterable.takeWhile = takeWhile;
+    function takeUntil(iterable, predicate) {
+        return takeWhile(iterable, not(predicate));
+    }
+    Iterable.takeUntil = takeUntil;
+    function* takeLast(iterable, count = 1) {
+        if (count <= 0) {
+            return;
+        }
+        const last = [];
+        for (const value of iterable) {
+            last.push(value);
+            if (last.length > count) {
+                last.shift();
+            }
+        }
+        yield* last;
+    }
+    Iterable.takeLast = takeLast;
+    function* takeLastWhile(iterable, predicate) {
+        const values = [...iterable];
+        let last = values.length - 1;
+        while (last >= 0) {
+            if (predicate(values[last], last)) {
+                last--;
+            }
+            else {
+                break;
+            }
+        }
+        for (let i = last, n = values.length - 1; i < n; i++) {
+            yield values[i];
+        }
+    }
+    Iterable.takeLastWhile = takeLastWhile;
+    function takeLastUntil(iterable, predicate) {
+        return takeLastWhile(iterable, not(predicate));
+    }
+    Iterable.takeLastUntil = takeLastUntil;
+    function* skip(iterable, count) {
+        const it = iterator(iterable);
+        while (count-- > 0) {
+            const next = it.next();
+            if (next.done === true) {
+                return;
+            }
+        }
+        while (true) {
+            const next = it.next();
+            if (next.done === true) {
+                return;
+            }
+            yield next.value;
+        }
+    }
+    Iterable.skip = skip;
+    function* skipWhile(iterable, predicate) {
+        let index = 0;
+        let skipped = false;
+        for (const value of iterable) {
+            if (!skipped && predicate(value, index++)) {
+                continue;
+            }
+            else {
+                skipped = true;
+                yield value;
+            }
+        }
+    }
+    Iterable.skipWhile = skipWhile;
+    function skipUntil(iterable, predicate) {
+        return skipWhile(iterable, not(predicate));
+    }
+    Iterable.skipUntil = skipUntil;
+    function* skipLast(iterable, count = 1) {
+        const it = iterator(iterable);
+        const first = [];
+        while (count-- > 0) {
+            const next = it.next();
+            if (next.done === true) {
+                return;
+            }
+            first.push(next.value);
+        }
+        while (true) {
+            const next = it.next();
+            if (next.done === true) {
+                return;
+            }
+            first.push(next.value);
+            yield first.shift();
+        }
+    }
+    Iterable.skipLast = skipLast;
+    function* skipLastWhile(iterable, predicate) {
+        const values = [...iterable];
+        let last = values.length - 1;
+        while (last >= 0) {
+            if (predicate(values[last], last)) {
+                last--;
+            }
+            else {
+                break;
+            }
+        }
+        for (let i = 0, n = last; i < n; i++) {
+            yield values[i];
+        }
+    }
+    Iterable.skipLastWhile = skipLastWhile;
+    function skipLastUntil(iterable, predicate) {
+        return skipLastWhile(iterable, not(predicate));
+    }
+    Iterable.skipLastUntil = skipLastUntil;
+    function trim(iterable, predicate) {
+        return trimTrailing(trimLeading(iterable, predicate), predicate);
+    }
+    Iterable.trim = trim;
+    function trimLeading(iterable, predicate) {
+        return skipWhile(iterable, predicate);
+    }
+    Iterable.trimLeading = trimLeading;
+    function trimTrailing(iterable, predicate) {
+        return skipLastWhile(iterable, predicate);
+    }
+    Iterable.trimTrailing = trimTrailing;
+    function rest(iterable) {
+        return skip(iterable, 1);
+    }
+    Iterable.rest = rest;
+    function slice(iterable, start, end) {
+        iterable = skip(iterable, start);
+        if (end !== undefined) {
+            iterable = take(iterable, end - start);
+        }
+        return iterable;
+    }
+    Iterable.slice = slice;
+    function* reverse(iterable) {
+        const array = Array.from(iterable);
+        for (let i = array.length - 1; i >= 0; i--) {
+            yield array[i];
+        }
+    }
+    Iterable.reverse = reverse;
+    function join(iterable, separator) {
+        const it = iterator(iterable);
+        let next = it.next();
+        if (next.done === true) {
+            return "";
+        }
+        let result = `${next.value}`;
+        next = it.next();
+        while (next.done !== true) {
+            result += `${separator}${next.value}`;
+            next = it.next();
+        }
+        return result;
+    }
+    Iterable.join = join;
+    function sort(iterable) {
+        return sortWith(iterable, compareComparable);
+    }
+    Iterable.sort = sort;
+    function* sortWith(iterable, comparer) {
+        yield* [...iterable].sort(comparer);
+    }
+    Iterable.sortWith = sortWith;
+    function compare(a, b) {
+        return compareWith(a, b, compareComparable);
+    }
+    Iterable.compare = compare;
+    function compareWith(a, b, comparer) {
+        const itA = iterator(a);
+        const itB = iterator(b);
+        let index = 0;
+        while (true) {
+            const a = itA.next();
+            const b = itB.next();
+            if (a.done === true) {
+                return b.done === true ? Comparison.Equal : Comparison.Less;
+            }
+            if (b.done === true) {
+                return Comparison.Greater;
+            }
+            const result = comparer(a.value, b.value, index++);
+            if (result !== 0) {
+                return result;
+            }
+        }
+    }
+    Iterable.compareWith = compareWith;
+    function equals(a, b) {
+        const itA = iterator(a);
+        const itB = iterator(b);
+        while (true) {
+            const a = itA.next();
+            const b = itB.next();
+            if (a.done === true) {
+                return b.done === true;
+            }
+            if (b.done === true || !Equatable.equals(a.value, b.value)) {
+                return false;
+            }
+        }
+    }
+    Iterable.equals = equals;
+    function hash(iterable, hash) {
+        let size = 0;
+        for (const value of iterable) {
+            hash.writeUnknown(value);
+            size++;
+        }
+        hash.writeUint32(size);
+    }
+    Iterable.hash = hash;
+    function iterator(iterable) {
+        return iterable[Symbol.iterator]();
+    }
+    Iterable.iterator = iterator;
+    function groupBy(iterable, grouper) {
+        const groups = [];
+        let index = 0;
+        for (const value of iterable) {
+            const group = grouper(value, index++);
+            const existing = groups.find(([existing]) => Equatable.equals(group, existing));
+            if (existing === undefined) {
+                groups.push([group, [value]]);
+            }
+            else {
+                existing[1].push(value);
+            }
+        }
+        return groups;
+    }
+    Iterable.groupBy = groupBy;
+    function toJSON(iterable, options) {
+        return [...map(iterable, (value) => Serializable.toJSON(value, options))];
+    }
+    Iterable.toJSON = toJSON;
+})(Iterable || (Iterable = {}));
+//# sourceMappingURL=iterable.js.map

package/package.json

@@ -0,0 +1,40 @@
+{
+  "$schema": "http://json.schemastore.org/package",
+  "name": "@siteimprove/alfa-iterable",
+  "homepage": "https://alfa.siteimprove.com",
+  "version": "0.89.5",
+  "license": "MIT",
+  "description": "Functionality for working with structures that support iteration",
+  "repository": {
+    "type": "git",
+    "url": "github:Siteimprove/alfa",
+    "directory": "packages/alfa-iterable"
+  },
+  "bugs": "https://github.com/siteimprove/alfa/issues",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "dependencies": {
+    "@siteimprove/alfa-callback": "^0.89.5",
+    "@siteimprove/alfa-comparable": "^0.89.5",
+    "@siteimprove/alfa-equatable": "^0.89.5",
+    "@siteimprove/alfa-hash": "^0.89.5",
+    "@siteimprove/alfa-json": "^0.89.5",
+    "@siteimprove/alfa-mapper": "^0.89.5",
+    "@siteimprove/alfa-option": "^0.89.5",
+    "@siteimprove/alfa-predicate": "^0.89.5",
+    "@siteimprove/alfa-reducer": "^0.89.5",
+    "@siteimprove/alfa-refinement": "^0.89.5"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://npm.pkg.github.com/"
+  }
+}