@siteimprove/alfa-list 0.89.5

package/CHANGELOG.md

@@ -0,0 +1,157 @@
+# @siteimprove/alfa-list
+
+## 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,3 @@
+export * from "./list.js";
+export * from "./node.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./list.js";
+export * from "./node.js";
+//# sourceMappingURL=index.js.map

package/dist/list.d.ts

@@ -0,0 +1,111 @@
+import { Array } from "@siteimprove/alfa-array";
+import type { Callback } from "@siteimprove/alfa-callback";
+import type { Collection } from "@siteimprove/alfa-collection";
+import { Comparable, type Comparer, type Comparison } from "@siteimprove/alfa-comparable";
+import type { Hash } from "@siteimprove/alfa-hash";
+import { Iterable } from "@siteimprove/alfa-iterable";
+import { Serializable } from "@siteimprove/alfa-json";
+import { Map } from "@siteimprove/alfa-map";
+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 type { Refinement } from "@siteimprove/alfa-refinement";
+/**
+ * @public
+ */
+export declare class List<T> implements Collection.Indexed<T> {
+    static of<T>(...values: Array<T>): List<T>;
+    private static _empty;
+    static empty<T = never>(): List<T>;
+    private readonly _head;
+    private readonly _tail;
+    private readonly _shift;
+    private readonly _size;
+    private constructor();
+    get size(): number;
+    isEmpty(): this is List<never>;
+    forEach(callback: Callback<T, void, [index: number]>): void;
+    map<U>(mapper: Mapper<T, U, [index: number]>): List<U>;
+    apply<U>(mapper: List<Mapper<T, U>>): List<U>;
+    flatMap<U>(mapper: Mapper<T, List<U>, [index: number]>): List<U>;
+    flatten<T>(this: List<List<T>>): List<T>;
+    reduce<U>(reducer: Reducer<T, U, [index: number]>, accumulator: U): U;
+    reduceWhile<U>(predicate: Predicate<T, [index: number]>, reducer: Reducer<T, U, [index: number]>, accumulator: U): U;
+    reduceUntil<U>(predicate: Predicate<T, [index: number]>, reducer: Reducer<T, U, [index: number]>, accumulator: U): U;
+    filter<U extends T>(refinement: Refinement<T, U, [index: number]>): List<U>;
+    filter(predicate: Predicate<T, [index: number]>): List<T>;
+    reject<U extends T>(refinement: Refinement<T, U, [index: number]>): List<Exclude<T, U>>;
+    reject(predicate: Predicate<T, [index: number]>): List<T>;
+    find<U extends T>(refinement: Refinement<T, U, [index: number]>): Option<U>;
+    find(predicate: Predicate<T, [index: number]>): Option<T>;
+    includes(value: T): boolean;
+    collect<U>(mapper: Mapper<T, Option<U>, [index: number]>): List<U>;
+    collectFirst<U>(mapper: Mapper<T, Option<U>, [index: number]>): Option<U>;
+    some(predicate: Predicate<T, [index: number]>): boolean;
+    none(predicate: Predicate<T, [index: number]>): boolean;
+    every(predicate: Predicate<T, [index: number]>): boolean;
+    count(predicate: Predicate<T, [index: number]>): number;
+    distinct(): List<T>;
+    get(index: number): Option<T>;
+    has(index: number): boolean;
+    set(index: number, value: T): List<T>;
+    insert(index: number, value: T): List<T>;
+    append(value: T): List<T>;
+    prepend(value: T): List<T>;
+    concat(iterable: Iterable<T>): List<T>;
+    subtract(iterable: Iterable<T>): List<T>;
+    intersect(iterable: Iterable<T>): List<T>;
+    tee<A extends Array<unknown> = []>(callback: Callback<this, void, [...args: A]>, ...args: A): this;
+    zip<U>(iterable: Iterable<U>): List<[T, U]>;
+    first(): Option<T>;
+    last(): Option<T>;
+    take(count: number): List<T>;
+    takeWhile<U extends T>(refinement: Refinement<T, U, [index: number]>): List<U>;
+    takeWhile(predicate: Predicate<T, [index: number]>): List<T>;
+    takeUntil(predicate: Predicate<T, [index: number]>): List<T>;
+    takeLast(count?: number): List<T>;
+    takeLastWhile<U extends T>(refinement: Refinement<T, U, [index: number]>): List<U>;
+    takeLastWhile(predicate: Predicate<T, [index: number]>): List<T>;
+    takeLastUntil(predicate: Predicate<T, [index: number]>): List<T>;
+    skip(count: number): List<T>;
+    skipWhile(predicate: Predicate<T, [index: number]>): List<T>;
+    skipUntil(predicate: Predicate<T, [index: number]>): List<T>;
+    skipLast(count?: number): List<T>;
+    skipLastWhile(predicate: Predicate<T, [index: number]>): List<T>;
+    skipLastUntil(predicate: Predicate<T, [index: number]>): List<T>;
+    trim(predicate: Predicate<T, [index: number]>): List<T>;
+    trimLeading(predicate: Predicate<T, [index: number]>): List<T>;
+    trimTrailing(predicate: Predicate<T, [index: number]>): List<T>;
+    rest(): List<T>;
+    slice(start: number, end?: number): List<T>;
+    reverse(): List<T>;
+    join(separator: string): string;
+    sort<T extends Comparable<T>>(this: List<T>): List<T>;
+    sortWith(comparer: Comparer<T>): List<T>;
+    sortWith<T, U extends T = T>(this: List<U>, comparer: Comparer<T>): List<U>;
+    compare<T>(this: List<Comparable<T>>, iterable: Iterable<T>): Comparison;
+    compareWith<U = T>(iterable: Iterable<U>, comparer: Comparer<T, U, [index: number]>): Comparison;
+    groupBy<K>(grouper: Mapper<T, K>): Map<K, List<T>>;
+    equals<T>(value: List<T>): boolean;
+    equals(value: unknown): value is this;
+    hash(hash: Hash): void;
+    [Symbol.iterator](): Iterator<T>;
+    toArray(): Array<T>;
+    toJSON(options?: Serializable.Options): List.JSON<T>;
+    toString(): string;
+    private _push;
+    private _pop;
+}
+/**
+ * @public
+ */
+export declare namespace List {
+    type JSON<T> = Collection.Indexed.JSON<T>;
+    function isList<T>(value: Iterable<T>): value is List<T>;
+    function isList<T>(value: unknown): value is List<T>;
+    function from<T>(iterable: Iterable<T>): List<T>;
+    function fromArray<T>(array: ReadonlyArray<T>): List<T>;
+    function fromIterable<T>(iterable: Iterable<T>): List<T>;
+}
+//# sourceMappingURL=list.d.ts.map

package/dist/list.js

@@ -0,0 +1,475 @@
+import { Array } from "@siteimprove/alfa-array";
+import { Comparable } from "@siteimprove/alfa-comparable";
+import { Iterable } from "@siteimprove/alfa-iterable";
+import { Serializable } from "@siteimprove/alfa-json";
+import { Map } from "@siteimprove/alfa-map";
+import { None, Option } from "@siteimprove/alfa-option";
+import { Predicate } from "@siteimprove/alfa-predicate";
+import { Set } from "@siteimprove/alfa-set";
+import { Branch, Empty, Leaf, Node } from "./node.js";
+const { not } = Predicate;
+const { compareComparable } = Comparable;
+/**
+ * @public
+ */
+export class List {
+    static of(...values) {
+        const size = values.length;
+        // Fast path: The values fit within the tail.
+        if (size <= Node.Capacity) {
+            return new List(Empty, Leaf.of(values), 0, size);
+        }
+        return values.reduce((list, value) => list._push(value), List.empty());
+    }
+    static _empty = new List(Empty, Empty, 0, 0);
+    static empty() {
+        return this._empty;
+    }
+    _head;
+    _tail;
+    _shift;
+    _size;
+    constructor(head, tail, shift, size) {
+        this._head = head;
+        this._tail = tail;
+        this._shift = shift;
+        this._size = size;
+    }
+    get size() {
+        return this._size;
+    }
+    isEmpty() {
+        return this._tail.isEmpty();
+    }
+    forEach(callback) {
+        Iterable.forEach(this, callback);
+    }
+    map(mapper) {
+        let index = 0;
+        const tail = this._tail.map((value) => mapper(value, index++));
+        const head = this._head.map((value) => mapper(value, index++));
+        return new List(head, tail, this._shift, this._size);
+    }
+    apply(mapper) {
+        return mapper.flatMap((mapper) => this.map(mapper));
+    }
+    flatMap(mapper) {
+        return this.reduce((list, value, index) => list.concat(mapper(value, index)), List.empty());
+    }
+    flatten() {
+        return this.flatMap((list) => list);
+    }
+    reduce(reducer, accumulator) {
+        return Iterable.reduce(this, reducer, accumulator);
+    }
+    reduceWhile(predicate, reducer, accumulator) {
+        return Iterable.reduceWhile(this, predicate, reducer, accumulator);
+    }
+    reduceUntil(predicate, reducer, accumulator) {
+        return Iterable.reduceUntil(this, predicate, reducer, accumulator);
+    }
+    filter(predicate) {
+        return List.from(Iterable.filter(this, predicate));
+    }
+    reject(predicate) {
+        return this.filter(not(predicate));
+    }
+    find(predicate) {
+        return Iterable.find(this, predicate);
+    }
+    includes(value) {
+        return Iterable.includes(this, value);
+    }
+    collect(mapper) {
+        return List.from(Iterable.collect(this, mapper));
+    }
+    collectFirst(mapper) {
+        return Iterable.collectFirst(this, mapper);
+    }
+    some(predicate) {
+        return Iterable.some(this, predicate);
+    }
+    none(predicate) {
+        return Iterable.none(this, predicate);
+    }
+    every(predicate) {
+        return Iterable.every(this, predicate);
+    }
+    count(predicate) {
+        return Iterable.count(this, predicate);
+    }
+    distinct() {
+        let seen = Set.empty();
+        let list = List.empty();
+        for (const value of this) {
+            if (seen.has(value)) {
+                continue;
+            }
+            seen = seen.add(value);
+            list = list.append(value);
+        }
+        return list;
+    }
+    get(index) {
+        if (index < 0 || index >= this._size || this._tail.isEmpty()) {
+            return None;
+        }
+        const offset = this._size - this._tail.values.length;
+        let value;
+        if (index < offset) {
+            value = this._head.get(index, this._shift - Node.Bits);
+        }
+        else {
+            value = this._tail.get(index - offset);
+        }
+        return value;
+    }
+    has(index) {
+        return index >= 0 && index < this._size;
+    }
+    set(index, value) {
+        if (index < 0 || index >= this._size || this._tail.isEmpty()) {
+            return this;
+        }
+        const offset = this._size - this._tail.values.length;
+        let head = this._head;
+        let tail = this._tail;
+        if (index < offset) {
+            if (head.isEmpty()) {
+                return this;
+            }
+            head = head.set(index, value, this._shift);
+            if (head === this._head) {
+                return this;
+            }
+        }
+        else {
+            tail = tail.set(index - offset, value);
+            if (tail === this._tail) {
+                return this;
+            }
+        }
+        return new List(head, tail, this._shift, this._size);
+    }
+    insert(index, value) {
+        if (index < 0 || index > this.size) {
+            return this;
+        }
+        if (index === 0) {
+            return this.prepend(value);
+        }
+        if (index === this.size) {
+            return this.append(value);
+        }
+        return List.from(Iterable.concat(Iterable.take(this, index), Iterable.from([value]), Iterable.skip(this, index)));
+    }
+    append(value) {
+        return this._push(value);
+    }
+    prepend(value) {
+        return List.of(value).concat(this);
+    }
+    concat(iterable) {
+        return Iterable.reduce(iterable, (list, value) => list._push(value), this);
+    }
+    subtract(iterable) {
+        return List.from(Iterable.subtract(this, iterable));
+    }
+    intersect(iterable) {
+        return List.from(Iterable.intersect(this, iterable));
+    }
+    tee(callback, ...args) {
+        callback(this, ...args);
+        return this;
+    }
+    zip(iterable) {
+        return List.from(Iterable.zip(this, iterable));
+    }
+    first() {
+        return this._tail.isEmpty() ? None : Option.of(this._tail.values[0]);
+    }
+    last() {
+        return Iterable.last(this);
+    }
+    take(count) {
+        return List.from(Iterable.take(this, count));
+    }
+    takeWhile(predicate) {
+        return List.from(Iterable.takeWhile(this, predicate));
+    }
+    takeUntil(predicate) {
+        return this.takeWhile(not(predicate));
+    }
+    takeLast(count = 1) {
+        return List.from(Iterable.takeLast(this, count));
+    }
+    takeLastWhile(predicate) {
+        return List.from(Iterable.takeLastWhile(this, predicate));
+    }
+    takeLastUntil(predicate) {
+        return this.takeLastWhile(not(predicate));
+    }
+    skip(count) {
+        return List.from(Iterable.skip(this, count));
+    }
+    skipWhile(predicate) {
+        return List.from(Iterable.skipWhile(this, predicate));
+    }
+    skipUntil(predicate) {
+        return this.skipWhile(not(predicate));
+    }
+    skipLast(count = 1) {
+        let list = this;
+        while (count-- > 0) {
+            list = list._pop();
+        }
+        return list;
+    }
+    skipLastWhile(predicate) {
+        return List.from(Iterable.skipLastWhile(this, predicate));
+    }
+    skipLastUntil(predicate) {
+        return this.skipLastWhile(not(predicate));
+    }
+    trim(predicate) {
+        return this.trimLeading(predicate).trimTrailing(predicate);
+    }
+    trimLeading(predicate) {
+        return this.skipWhile(predicate);
+    }
+    trimTrailing(predicate) {
+        return this.skipLastWhile(predicate);
+    }
+    rest() {
+        return this.skip(1);
+    }
+    slice(start, end) {
+        return List.from(Iterable.slice(this, start, end));
+    }
+    reverse() {
+        return List.from(Iterable.reverse(this));
+    }
+    join(separator) {
+        return Iterable.join(this, separator);
+    }
+    sort() {
+        return this.sortWith(compareComparable);
+    }
+    sortWith(comparer) {
+        return List.from(Iterable.sortWith(this, comparer));
+    }
+    compare(iterable) {
+        return this.compareWith(iterable, compareComparable);
+    }
+    compareWith(iterable, comparer) {
+        return Iterable.compareWith(this, iterable, comparer);
+    }
+    groupBy(grouper) {
+        return this.reduce((groups, value) => {
+            const group = grouper(value);
+            return groups.set(group, groups
+                .get(group)
+                .getOrElse(() => List.empty())
+                ._push(value));
+        }, Map.empty());
+    }
+    equals(value) {
+        return (value instanceof List &&
+            value._size === this._size &&
+            value._head.equals(this._head) &&
+            value._tail.equals(this._tail));
+    }
+    hash(hash) {
+        for (const value of this) {
+            hash.writeUnknown(value);
+        }
+        hash.writeUint32(this._size);
+    }
+    *[Symbol.iterator]() {
+        yield* this._head;
+        yield* this._tail;
+    }
+    toArray() {
+        return [...this];
+    }
+    toJSON(options) {
+        return this.toArray().map((value) => Serializable.toJSON(value, options));
+    }
+    toString() {
+        const values = this.join(", ");
+        return `List [${values === "" ? "" : ` ${values} `}]`;
+    }
+    _push(value) {
+        // If no tail exists yet, this means that the list is empty. We therefore
+        // create a new tail with the pushed value. As the current list is empty,
+        // it won't have a head. As such, there's no need to pass the head along.
+        //
+        // In:  List { head: Empty, tail: Empty }
+        // Out: List { head: Empty, tail: Leaf(value) }
+        //
+        if (this._tail.isEmpty()) {
+            return new List(Empty, Leaf.of([value]), 0, 1);
+        }
+        // If the tail has capacity for another value, we concatenate the pushed
+        // value onto the current tail. The current list may or may not have a head,
+        // so we pass the head along as-is.
+        //
+        // In:  List { head, tail }
+        // Out: List { head, tail: Leaf(...tail, value) }
+        //
+        if (this._tail.hasCapacity()) {
+            return new List(this._head, Leaf.of([...this._tail.values, value]), this._shift, this._size + 1);
+        }
+        // If the tail does not have capacity for another value, we need to add it
+        // to the head to make room for a new tail. If the current list does not
+        // have a head, we use the current tail as the new head and create a new
+        // tail with the pushed value.
+        //
+        // In:  List { head: Empty, tail }
+        // Out: List { head: tail, tail: Leaf(value) }
+        //
+        if (this._head.isEmpty()) {
+            return new List(this._tail, Leaf.of([value]), this._shift + Node.Bits, this._size + 1);
+        }
+        const index = this._size - Node.Capacity;
+        let head = this._head;
+        let shift = this._shift;
+        // If the head has overflown, we need to split it which in turn increases
+        // the depth of the list.
+        if (head.isLeaf() || index === Node.overflow(shift)) {
+            head = Branch.of([head]);
+            shift += Node.Bits;
+        }
+        else {
+            head = head.clone();
+        }
+        let prev = head;
+        let level = shift - Node.Bits;
+        // We now add the tail to the head in order to make room for a new tail.
+        while (level > 0) {
+            const i = Node.fragment(index, level);
+            level -= Node.Bits;
+            const next = prev.nodes[i];
+            if (next === undefined) {
+                if (level === 0) {
+                    prev.nodes[i] = this._tail;
+                }
+                else {
+                    prev.nodes[i] = prev = Branch.empty();
+                }
+            }
+            else {
+                prev.nodes[i] = prev = next.clone();
+            }
+        }
+        // With the current tail inserted into the new head, we can now make a new
+        // tail with the pushed value. Do note that the spread syntax is only used
+        // for illustrative purposes here; the tail is actually inserted in the
+        // rightmost branch of the head.
+        //
+        // In:  List { head, tail }
+        // Out: List { head: Branch(...head, ...tail), tail: Leaf(value) }
+        //
+        return new List(head, Leaf.of([value]), shift, this._size + 1);
+    }
+    _pop() {
+        // If the list has no tail then it is empty. We therefore return the list
+        // itself as the pop has no effect.
+        if (this._tail.isEmpty()) {
+            return this;
+        }
+        // If the list has a size of 1 then the result of the popping its last
+        // element will be an empty list.
+        //
+        // In:  List { head: Empty, tail: Leaf(value) }
+        // Out: List { head: Empty, tail: Empty }
+        //
+        if (this._size === 1) {
+            return List.empty();
+        }
+        // If the tail has more than one element, it will have a non-zero size after
+        // popping the last element. We can therefore get away with removing the
+        // last element from the tail and reuse the head.
+        //
+        // In:  List { head, tail: Leaf(...tail, value) }
+        // Out: List { head, tail }
+        //
+        if (this._tail.values.length > 1) {
+            return new List(this._head, Leaf.of(this._tail.values.slice(0, this._tail.values.length - 1)), this._shift, this._size - 1);
+        }
+        if (this._head.isLeaf() || this._head.isEmpty()) {
+            return new List(Empty, this._head, this._shift - Node.Bits, this._size - 1);
+        }
+        let head = this._head.clone();
+        let tail = this._tail;
+        let shift = this._shift;
+        const index = this._size - Node.Capacity - 1;
+        let prev = head;
+        let level = shift - Node.Bits;
+        // We now remove the rightmost leaf of the head as this will be used as the
+        // new tail.
+        while (level > 0) {
+            const fragment = Node.fragment(index, level);
+            level -= Node.Bits;
+            const next = prev.nodes[fragment];
+            // Once we reach the rightmost leaf node, remove it as it will be used as
+            // the new tail.
+            if (next.isLeaf()) {
+                prev.nodes.pop();
+                tail = next;
+            }
+            else {
+                prev = prev.nodes[fragment] = next.clone();
+            }
+        }
+        // If the head has underflown, we unwrap its first child and use that as the
+        // new head which in turn decreases the depth of the list. If the head is a
+        // leaf node, we instead set the new head to null.
+        if (index === Node.underflow(shift)) {
+            head = head.nodes[0];
+            shift -= Node.Bits;
+        }
+        // With the rightmost branch of the head removed, we can now use it as the
+        // new tail and discard the old. Do note that the spread syntax is only used
+        // for illustrative purposes here; the tail is actually removed from the
+        // rightmost branch of the head.
+        //
+        // In:  List { head: Branch(...head, tail), tail: Leaf(value) }
+        // Out: List { head, tail }
+        //
+        return new List(head, tail, shift, this._size - 1);
+    }
+}
+/**
+ * @public
+ */
+(function (List) {
+    function isList(value) {
+        return value instanceof List;
+    }
+    List.isList = isList;
+    function from(iterable) {
+        if (isList(iterable)) {
+            return iterable;
+        }
+        if (Array.isArray(iterable)) {
+            return fromArray(iterable);
+        }
+        return fromIterable(iterable);
+    }
+    List.from = from;
+    function fromArray(array) {
+        const size = array.length;
+        // Fast path: The array fits within the tail.
+        if (size <= Node.Capacity) {
+            return List.of(...array);
+        }
+        return Array.reduce(array, (list, value) => list.append(value), List.empty());
+    }
+    List.fromArray = fromArray;
+    function fromIterable(iterable) {
+        return Iterable.reduce(iterable, (list, value) => list.append(value), List.empty());
+    }
+    List.fromIterable = fromIterable;
+})(List || (List = {}));
+//# sourceMappingURL=list.js.map

package/dist/node.d.ts

@@ -0,0 +1,70 @@
+import { Equatable } from "@siteimprove/alfa-equatable";
+import type { Functor } from "@siteimprove/alfa-functor";
+import type { Iterable } from "@siteimprove/alfa-iterable";
+import type { Mapper } from "@siteimprove/alfa-mapper";
+import { Option } from "@siteimprove/alfa-option";
+/**
+ * @internal
+ */
+export interface Node<T> extends Functor<T>, Iterable<T>, Equatable {
+    isEmpty(): this is Empty;
+    isLeaf(): this is Leaf<T>;
+    get(index: number, shift: number): Option<T>;
+    set(index: number, value: T, shift: number): Node<T>;
+    map<U>(mapper: Mapper<T, U>): Node<U>;
+}
+/**
+ * @internal
+ */
+export declare namespace Node {
+    const Bits = 5;
+    const Capacity: number;
+    function fragment(index: number, shift: number): number;
+    function overflow(shift: number): number;
+    function underflow(shift: number): number;
+}
+/**
+ * @internal
+ */
+export interface Empty extends Node<never> {
+}
+/**
+ * @internal
+ */
+export declare const Empty: Empty;
+/**
+ * @internal
+ */
+export declare class Leaf<T> implements Node<T> {
+    static of<T>(values: Array<T>): Leaf<T>;
+    private readonly _values;
+    private constructor();
+    get values(): Array<T>;
+    isEmpty(): this is Empty;
+    isLeaf(): this is Leaf<T>;
+    hasCapacity(): boolean;
+    get(index: number): Option<T>;
+    set(index: number, value: T): Leaf<T>;
+    map<U>(mapper: Mapper<T, U>): Leaf<U>;
+    equals(value: unknown): value is this;
+    [Symbol.iterator](): Iterator<T>;
+}
+/**
+ * @internal
+ */
+export declare class Branch<T> implements Node<T> {
+    static of<T>(nodes: Array<Branch<T> | Leaf<T>>): Branch<T>;
+    static empty<T>(): Branch<T>;
+    private readonly _nodes;
+    private constructor();
+    get nodes(): Array<Branch<T> | Leaf<T>>;
+    isEmpty(): this is Empty;
+    isLeaf(): this is Leaf<T>;
+    clone(): Branch<T>;
+    get(index: number, shift: number): Option<T>;
+    set(index: number, value: T, shift: number): Branch<T>;
+    map<U>(mapper: Mapper<T, U>): Branch<U>;
+    equals(value: unknown): value is this;
+    [Symbol.iterator](): Iterator<T>;
+}
+//# sourceMappingURL=node.d.ts.map

package/dist/node.js

@@ -0,0 +1,151 @@
+import { Bits } from "@siteimprove/alfa-bits";
+import { Equatable } from "@siteimprove/alfa-equatable";
+import { None, Option } from "@siteimprove/alfa-option";
+const { bit, take, skip } = Bits;
+/**
+ * @internal
+ */
+export var Node;
+(function (Node) {
+    Node.Bits = 5;
+    Node.Capacity = bit(Node.Bits);
+    function fragment(index, shift) {
+        return take(skip(index, shift), Node.Bits);
+    }
+    Node.fragment = fragment;
+    function overflow(shift) {
+        return Node.Capacity << (shift - Node.Bits);
+    }
+    Node.overflow = overflow;
+    function underflow(shift) {
+        return Node.Capacity << (shift - Node.Bits * 2);
+    }
+    Node.underflow = underflow;
+})(Node || (Node = {}));
+/**
+ * @internal
+ */
+export const Empty = new (class Empty {
+    isEmpty() {
+        return true;
+    }
+    isLeaf() {
+        return false;
+    }
+    get() {
+        return None;
+    }
+    set() {
+        return this;
+    }
+    map() {
+        return this;
+    }
+    equals(value) {
+        return value instanceof Empty;
+    }
+    *[Symbol.iterator]() { }
+})();
+/**
+ * @internal
+ */
+export class Leaf {
+    static of(values) {
+        return new Leaf(values);
+    }
+    _values;
+    constructor(values) {
+        this._values = values;
+    }
+    get values() {
+        return this._values;
+    }
+    isEmpty() {
+        return false;
+    }
+    isLeaf() {
+        return true;
+    }
+    hasCapacity() {
+        return this._values.length < Node.Capacity;
+    }
+    get(index) {
+        const fragment = take(index, Node.Bits);
+        return Option.of(this._values[fragment]);
+    }
+    set(index, value) {
+        const fragment = take(index, Node.Bits);
+        if (Equatable.equals(value, this._values[fragment])) {
+            return this;
+        }
+        const values = this._values.slice(0);
+        values[fragment] = value;
+        return Leaf.of(values);
+    }
+    map(mapper) {
+        return Leaf.of(this._values.map(mapper));
+    }
+    equals(value) {
+        return (value instanceof Leaf &&
+            value._values.length === this._values.length &&
+            value._values.every((value, i) => Equatable.equals(value, this._values[i])));
+    }
+    *[Symbol.iterator]() {
+        yield* this._values;
+    }
+}
+/**
+ * @internal
+ */
+export class Branch {
+    static of(nodes) {
+        return new Branch(nodes);
+    }
+    static empty() {
+        return new Branch([]);
+    }
+    _nodes;
+    constructor(nodes) {
+        this._nodes = nodes;
+    }
+    get nodes() {
+        return this._nodes;
+    }
+    isEmpty() {
+        return false;
+    }
+    isLeaf() {
+        return false;
+    }
+    clone() {
+        return Branch.of(this._nodes.slice(0));
+    }
+    get(index, shift) {
+        const fragment = Node.fragment(index, shift);
+        return this._nodes[fragment].get(index, shift - Node.Bits);
+    }
+    set(index, value, shift) {
+        const fragment = Node.fragment(index, shift);
+        const node = this._nodes[fragment].set(index, value, shift - Node.Bits);
+        if (node === this._nodes[fragment]) {
+            return this;
+        }
+        const nodes = this._nodes.slice(0);
+        nodes[fragment] = node;
+        return Branch.of(nodes);
+    }
+    map(mapper) {
+        return Branch.of(this._nodes.map((node) => node.map(mapper)));
+    }
+    equals(value) {
+        return (value instanceof Branch &&
+            value._nodes.length === this._nodes.length &&
+            value._nodes.every((node, i) => node.equals(this._nodes[i])));
+    }
+    *[Symbol.iterator]() {
+        for (const node of this._nodes) {
+            yield* node;
+        }
+    }
+}
+//# sourceMappingURL=node.js.map

package/package.json

@@ -0,0 +1,50 @@
+{
+  "$schema": "http://json.schemastore.org/package",
+  "name": "@siteimprove/alfa-list",
+  "homepage": "https://alfa.siteimprove.com",
+  "version": "0.89.5",
+  "license": "MIT",
+  "description": "An implementation of an immutable list structure, based on a bit-partitioned vector trie",
+  "repository": {
+    "type": "git",
+    "url": "github:Siteimprove/alfa",
+    "directory": "packages/alfa-list"
+  },
+  "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-array": "^0.89.5",
+    "@siteimprove/alfa-bits": "^0.89.5",
+    "@siteimprove/alfa-callback": "^0.89.5",
+    "@siteimprove/alfa-collection": "^0.89.5",
+    "@siteimprove/alfa-comparable": "^0.89.5",
+    "@siteimprove/alfa-equatable": "^0.89.5",
+    "@siteimprove/alfa-functor": "^0.89.5",
+    "@siteimprove/alfa-hash": "^0.89.5",
+    "@siteimprove/alfa-iterable": "^0.89.5",
+    "@siteimprove/alfa-json": "^0.89.5",
+    "@siteimprove/alfa-map": "^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",
+    "@siteimprove/alfa-set": "^0.89.5"
+  },
+  "devDependencies": {
+    "@siteimprove/alfa-test": "^0.89.5"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://npm.pkg.github.com/"
+  }
+}