@siteimprove/alfa-map 0.89.5

package/CHANGELOG.md

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

package/dist/index.js

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

package/dist/map.d.ts

@@ -0,0 +1,104 @@
+import { Array } from "@siteimprove/alfa-array";
+import type { Callback } from "@siteimprove/alfa-callback";
+import type { Collection } from "@siteimprove/alfa-collection";
+import type { Hash } from "@siteimprove/alfa-hash";
+import { Iterable } from "@siteimprove/alfa-iterable";
+import { Serializable } from "@siteimprove/alfa-json";
+import type { Mapper } from "@siteimprove/alfa-mapper";
+import type { 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 Map<K, V> implements Collection.Keyed<K, V> {
+    static of<K, V>(...entries: Array<readonly [K, V]>): Map<K, V>;
+    private static _empty;
+    static empty<K = never, V = never>(): Map<K, V>;
+    private readonly _root;
+    private readonly _size;
+    private constructor();
+    get size(): number;
+    isEmpty(): this is Map<K, never>;
+    forEach(callback: Callback<V, void, [key: K]>): void;
+    map<U>(mapper: Mapper<V, U, [key: K]>): Map<K, U>;
+    /**
+     * Apply a map of functions to each corresponding value of this map.
+     *
+     * @remarks
+     * Keys without a corresponding function or value are dropped from the
+     * resulting map.
+     *
+     * @example
+     * ```ts
+     * Map.of(["a", 1], ["b", 2])
+     *   .apply(Map.of(["a", (x) => x + 1], ["b", (x) => x * 2]))
+     *   .toArray();
+     * // => [["a", 2], ["b", 4]]
+     * ```
+     */
+    apply<U>(mapper: Map<K, Mapper<V, U>>): Map<K, U>;
+    /**
+     * @remarks
+     * As the order of maps is undefined, it is also undefined which keys are
+     * kept when duplicate keys are encountered.
+     */
+    flatMap<L, U>(mapper: Mapper<V, Map<L, U>, [key: K]>): Map<L, U>;
+    /**
+     * @remarks
+     * As the order of maps is undefined, it is also undefined which keys are
+     * kept when duplicate keys are encountered.
+     */
+    flatten<K, V>(this: Map<K, Map<K, V>>): Map<K, V>;
+    reduce<R>(reducer: Reducer<V, R, [key: K]>, accumulator: R): R;
+    filter<U extends V>(refinement: Refinement<V, U, [key: K]>): Map<K, U>;
+    filter(predicate: Predicate<V, [key: K]>): Map<K, V>;
+    reject<U extends V>(refinement: Refinement<V, U, [key: K]>): Map<K, Exclude<V, U>>;
+    reject(predicate: Predicate<V, [key: K]>): Map<K, V>;
+    find<U extends V>(refinement: Refinement<V, U, [key: K]>): Option<U>;
+    find(predicate: Predicate<V, [key: K]>): Option<V>;
+    includes(value: V): boolean;
+    collect<U>(mapper: Mapper<V, Option<U>, [key: K]>): Map<K, U>;
+    collectFirst<U>(mapper: Mapper<V, Option<U>, [key: K]>): Option<U>;
+    some(predicate: Predicate<V, [key: K]>): boolean;
+    none(predicate: Predicate<V, [key: K]>): boolean;
+    every(predicate: Predicate<V, [key: K]>): boolean;
+    count(predicate: Predicate<V, [key: K]>): number;
+    /**
+     * @remarks
+     * As the order of maps is undefined, it is also undefined which keys are
+     * kept when duplicate values are encountered.
+     */
+    distinct(): Map<K, V>;
+    get(key: K): Option<V>;
+    has(key: K): boolean;
+    set(key: K, value: V): Map<K, V>;
+    delete(key: K): Map<K, V>;
+    concat(iterable: Iterable<readonly [K, V]>): Map<K, V>;
+    subtract(iterable: Iterable<readonly [K, V]>): Map<K, V>;
+    intersect(iterable: Iterable<readonly [K, V]>): Map<K, V>;
+    tee<A extends Array<unknown> = []>(callback: Callback<this, void, [...args: A]>, ...args: A): this;
+    equals<K, V>(value: Map<K, V>): boolean;
+    equals(value: unknown): value is this;
+    hash(hash: Hash): void;
+    keys(): Iterable<K>;
+    values(): Iterable<V>;
+    iterator(): Iterator<[K, V]>;
+    [Symbol.iterator](): Iterator<[K, V]>;
+    toArray(): Array<[K, V]>;
+    toJSON(options?: Serializable.Options): Map.JSON<K, V>;
+    toString(): string;
+}
+/**
+ * @public
+ */
+export declare namespace Map {
+    type JSON<K, V> = Collection.Keyed.JSON<K, V>;
+    function isMap<K, V>(value: Iterable<readonly [K, V]>): value is Map<K, V>;
+    function isMap<K, V>(value: unknown): value is Map<K, V>;
+    function from<K, V>(iterable: Iterable<readonly [K, V]>): Map<K, V>;
+    function fromArray<K, V>(array: ReadonlyArray<readonly [K, V]>): Map<K, V>;
+    function fromIterable<K, V>(iterable: Iterable<readonly [K, V]>): Map<K, V>;
+}
+//# sourceMappingURL=map.d.ts.map

package/dist/map.js

@@ -0,0 +1,227 @@
+import { Array } from "@siteimprove/alfa-array";
+import { FNV } from "@siteimprove/alfa-fnv";
+import { Iterable } from "@siteimprove/alfa-iterable";
+import { Serializable } from "@siteimprove/alfa-json";
+import { Predicate } from "@siteimprove/alfa-predicate";
+import { Empty } from "./node.js";
+const { not } = Predicate;
+/**
+ * @public
+ */
+export class Map {
+    static of(...entries) {
+        return entries.reduce((map, [key, value]) => map.set(key, value), Map.empty());
+    }
+    static _empty = new Map(Empty, 0);
+    static empty() {
+        return this._empty;
+    }
+    _root;
+    _size;
+    constructor(root, size) {
+        this._root = root;
+        this._size = size;
+    }
+    get size() {
+        return this._size;
+    }
+    isEmpty() {
+        return this._size === 0;
+    }
+    forEach(callback) {
+        Iterable.forEach(this, ([key, value]) => callback(value, key));
+    }
+    map(mapper) {
+        return new Map(this._root.map(mapper), this._size);
+    }
+    /**
+     * Apply a map of functions to each corresponding value of this map.
+     *
+     * @remarks
+     * Keys without a corresponding function or value are dropped from the
+     * resulting map.
+     *
+     * @example
+     * ```ts
+     * Map.of(["a", 1], ["b", 2])
+     *   .apply(Map.of(["a", (x) => x + 1], ["b", (x) => x * 2]))
+     *   .toArray();
+     * // => [["a", 2], ["b", 4]]
+     * ```
+     */
+    apply(mapper) {
+        return this.collect((value, key) => mapper.get(key).map((mapper) => mapper(value)));
+    }
+    /**
+     * @remarks
+     * As the order of maps is undefined, it is also undefined which keys are
+     * kept when duplicate keys are encountered.
+     */
+    flatMap(mapper) {
+        return this.reduce((map, value, key) => map.concat(mapper(value, key)), Map.empty());
+    }
+    /**
+     * @remarks
+     * As the order of maps is undefined, it is also undefined which keys are
+     * kept when duplicate keys are encountered.
+     */
+    flatten() {
+        return this.flatMap((map) => map);
+    }
+    reduce(reducer, accumulator) {
+        return Iterable.reduce(this, (accumulator, [key, value]) => reducer(accumulator, value, key), accumulator);
+    }
+    filter(predicate) {
+        return this.reduce((map, value, key) => (predicate(value, key) ? map.set(key, value) : map), Map.empty());
+    }
+    reject(predicate) {
+        return this.filter(not(predicate));
+    }
+    find(predicate) {
+        return Iterable.find(this, ([key, value]) => predicate(value, key)).map(([, value]) => value);
+    }
+    includes(value) {
+        return Iterable.includes(this.values(), value);
+    }
+    collect(mapper) {
+        return Map.from(Iterable.collect(this, ([key, value]) => mapper(value, key).map((value) => [key, value])));
+    }
+    collectFirst(mapper) {
+        return Iterable.collectFirst(this, ([key, value]) => mapper(value, key));
+    }
+    some(predicate) {
+        return Iterable.some(this, ([key, value]) => predicate(value, key));
+    }
+    none(predicate) {
+        return Iterable.none(this, ([key, value]) => predicate(value, key));
+    }
+    every(predicate) {
+        return Iterable.every(this, ([key, value]) => predicate(value, key));
+    }
+    count(predicate) {
+        return Iterable.count(this, ([key, value]) => predicate(value, key));
+    }
+    /**
+     * @remarks
+     * As the order of maps is undefined, it is also undefined which keys are
+     * kept when duplicate values are encountered.
+     */
+    distinct() {
+        let seen = Map.empty();
+        // We optimize for the case where there are more distinct values than there
+        // are duplicate values by starting with the current map and removing
+        // duplicates as we find them.
+        let map = this;
+        for (const [key, value] of map) {
+            if (seen.has(value)) {
+                map = map.delete(key);
+            }
+            else {
+                seen = seen.set(value, value);
+            }
+        }
+        return map;
+    }
+    get(key) {
+        return this._root.get(key, hash(key), 0);
+    }
+    has(key) {
+        return this.get(key).isSome();
+    }
+    set(key, value) {
+        const { result: root, status } = this._root.set(key, value, hash(key), 0);
+        if (status === "unchanged") {
+            return this;
+        }
+        return new Map(root, this._size + (status === "updated" ? 0 : 1));
+    }
+    delete(key) {
+        const { result: root, status } = this._root.delete(key, hash(key), 0);
+        if (status === "unchanged") {
+            return this;
+        }
+        return new Map(root, this._size - 1);
+    }
+    concat(iterable) {
+        return Iterable.reduce(iterable, (map, [key, value]) => map.set(key, value), this);
+    }
+    subtract(iterable) {
+        return Iterable.reduce(iterable, (map, [key]) => map.delete(key), this);
+    }
+    intersect(iterable) {
+        return Map.fromIterable(Iterable.filter(iterable, ([key]) => this.has(key)));
+    }
+    tee(callback, ...args) {
+        callback(this, ...args);
+        return this;
+    }
+    equals(value) {
+        return (value instanceof Map &&
+            value._size === this._size &&
+            value._root.equals(this._root));
+    }
+    hash(hash) {
+        for (const [key, value] of this) {
+            hash.writeUnknown(key).writeUnknown(value);
+        }
+        hash.writeUint32(this._size);
+    }
+    keys() {
+        return Iterable.map(this._root, (entry) => entry[0]);
+    }
+    values() {
+        return Iterable.map(this._root, (entry) => entry[1]);
+    }
+    *iterator() {
+        yield* this._root;
+    }
+    [Symbol.iterator]() {
+        return this.iterator();
+    }
+    toArray() {
+        return [...this];
+    }
+    toJSON(options) {
+        return this.toArray().map(([key, value]) => [
+            Serializable.toJSON(key, options),
+            Serializable.toJSON(value, options),
+        ]);
+    }
+    toString() {
+        const entries = this.toArray()
+            .map(([key, value]) => `${key} => ${value}`)
+            .join(", ");
+        return `Map {${entries === "" ? "" : ` ${entries} `}}`;
+    }
+}
+/**
+ * @public
+ */
+(function (Map) {
+    function isMap(value) {
+        return value instanceof Map;
+    }
+    Map.isMap = isMap;
+    function from(iterable) {
+        if (isMap(iterable)) {
+            return iterable;
+        }
+        if (Array.isArray(iterable)) {
+            return fromArray(iterable);
+        }
+        return fromIterable(iterable);
+    }
+    Map.from = from;
+    function fromArray(array) {
+        return Array.reduce(array, (map, [key, value]) => map.set(key, value), Map.empty());
+    }
+    Map.fromArray = fromArray;
+    function fromIterable(iterable) {
+        return Iterable.reduce(iterable, (map, [key, value]) => map.set(key, value), Map.empty());
+    }
+    Map.fromIterable = fromIterable;
+})(Map || (Map = {}));
+function hash(key) {
+    return FNV.empty().writeUnknown(key).finish();
+}
+//# sourceMappingURL=map.js.map

package/dist/node.d.ts

@@ -0,0 +1,106 @@
+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";
+import { Status } from "./status.js";
+/**
+ * Maps are stored as an hash-table of keys.
+ * The hash-table is stored as a tree where each internal node is a partial
+ * match of the hashes of its subtree.
+ *
+ * Nodes in the tree can be:
+ * * empty;
+ * * a Leaf, containing one single key;
+ * * a Collision, containing several keys with the same hash, this is
+ *   effectively a leaf of the tree, even though it actually has several Leaf
+ *   children (but no other kind);
+ * * a Sparse, which is an internal node. Sparses have masks and all hashes in
+ *   this subtree share the same mask (partial hash collision). The matching of
+ *   masks is done with a shift, which essentially take slices of n (=5) bits
+ *   of the hash. The shift is automatically increased when looking down the
+ *   tree, hence the same mask cannot be used at another level of a tree.
+ */
+/**
+ * @internal
+ */
+export interface Node<K, V> extends Functor<V>, Iterable<[K, V]>, Equatable {
+    isEmpty(): this is Empty;
+    isLeaf(): this is Leaf<K, V>;
+    get(key: K, hash: number, shift: number): Option<V>;
+    set(key: K, value: V, hash: number, shift: number): Status<Node<K, V>>;
+    delete(key: K, hash: number, shift: number): Status<Node<K, V>>;
+    map<U>(mapper: Mapper<V, U, [K]>): Node<K, U>;
+}
+/**
+ * @internal
+ */
+export declare namespace Node {
+    const Bits = 5;
+    function fragment(hash: number, shift: number): number;
+    function index(fragment: number, mask: number): number;
+}
+/**
+ * @internal
+ */
+export interface Empty extends Node<never, never> {
+}
+/**
+ * @internal
+ */
+export declare const Empty: Empty;
+/**
+ * @internal
+ */
+export declare class Leaf<K, V> implements Node<K, V> {
+    static of<K, V>(hash: number, key: K, value: V): Leaf<K, V>;
+    private readonly _hash;
+    private readonly _key;
+    private readonly _value;
+    private constructor();
+    get key(): K;
+    get value(): V;
+    isEmpty(): this is Empty;
+    isLeaf(): this is Leaf<K, V>;
+    get(key: K, hash: number, shift: number): Option<V>;
+    set(key: K, value: V, hash: number, shift: number): Status<Node<K, V>>;
+    delete(key: K, hash: number): Status<Node<K, V>>;
+    map<U>(mapper: Mapper<V, U, [K]>): Leaf<K, U>;
+    equals(value: unknown): value is this;
+    [Symbol.iterator](): Iterator<[K, V]>;
+}
+/**
+ * @internal
+ */
+export declare class Collision<K, V> implements Node<K, V> {
+    static of<K, V>(hash: number, nodes: Array<Leaf<K, V>>): Collision<K, V>;
+    private readonly _hash;
+    private readonly _nodes;
+    private constructor();
+    isEmpty(): this is Empty;
+    isLeaf(): this is Leaf<K, V>;
+    get(key: K, hash: number, shift: number): Option<V>;
+    set(key: K, value: V, hash: number, shift: number): Status<Node<K, V>>;
+    delete(key: K, hash: number): Status<Node<K, V>>;
+    map<U>(mapper: Mapper<V, U, [K]>): Collision<K, U>;
+    equals(value: unknown): value is this;
+    [Symbol.iterator](): Iterator<[K, V]>;
+}
+/**
+ * @internal
+ */
+export declare class Sparse<K, V> implements Node<K, V> {
+    static of<K, V>(mask: number, nodes: Array<Node<K, V>>): Sparse<K, V>;
+    private readonly _mask;
+    private readonly _nodes;
+    private constructor();
+    isEmpty(): this is Empty;
+    isLeaf(): this is Leaf<K, V>;
+    get(key: K, hash: number, shift: number): Option<V>;
+    set(key: K, value: V, hash: number, shift: number): Status<Node<K, V>>;
+    delete(key: K, hash: number, shift: number): Status<Node<K, V>>;
+    map<U>(mapper: Mapper<V, U, [K]>): Sparse<K, U>;
+    equals(value: unknown): value is this;
+    [Symbol.iterator](): Iterator<[K, V]>;
+}
+//# sourceMappingURL=node.d.ts.map

package/dist/node.js

@@ -0,0 +1,311 @@
+import { Bits } from "@siteimprove/alfa-bits";
+import { Equatable } from "@siteimprove/alfa-equatable";
+import { None, Option } from "@siteimprove/alfa-option";
+import { Status } from "./status.js";
+const { bit, take, skip, test, set, clear, popCount } = Bits;
+/**
+ * @internal
+ */
+export var Node;
+(function (Node) {
+    Node.Bits = 5;
+    function fragment(hash, shift) {
+        return take(skip(hash, shift), Node.Bits);
+    }
+    Node.fragment = fragment;
+    function index(fragment, mask) {
+        return popCount(take(mask, fragment));
+    }
+    Node.index = index;
+})(Node || (Node = {}));
+/**
+ * @internal
+ */
+export const Empty = new (class Empty {
+    isEmpty() {
+        return true;
+    }
+    isLeaf() {
+        return false;
+    }
+    get() {
+        return None;
+    }
+    set(key, value, hash) {
+        return Status.created(Leaf.of(hash, key, value));
+    }
+    delete() {
+        return Status.unchanged(this);
+    }
+    map() {
+        return this;
+    }
+    equals(value) {
+        return value instanceof Empty;
+    }
+    *[Symbol.iterator]() { }
+})();
+/**
+ * @internal
+ */
+export class Leaf {
+    static of(hash, key, value) {
+        return new Leaf(hash, key, value);
+    }
+    _hash;
+    _key;
+    _value;
+    constructor(hash, key, value) {
+        this._hash = hash;
+        this._key = key;
+        this._value = value;
+    }
+    get key() {
+        return this._key;
+    }
+    get value() {
+        return this._value;
+    }
+    isEmpty() {
+        return false;
+    }
+    isLeaf() {
+        return true;
+    }
+    get(key, hash, shift) {
+        return hash === this._hash && Equatable.equals(key, this._key)
+            ? Option.of(this._value)
+            : None;
+    }
+    set(key, value, hash, shift) {
+        if (hash === this._hash) {
+            if (Equatable.equals(key, this._key)) {
+                if (Equatable.equals(value, this._value)) {
+                    return Status.unchanged(this);
+                }
+                return Status.updated(Leaf.of(hash, key, value));
+            }
+            return Status.created(Collision.of(hash, [this, Leaf.of(hash, key, value)]));
+        }
+        const fragment = Node.fragment(this._hash, shift);
+        return Sparse.of(bit(fragment), [this]).set(key, value, hash, shift);
+    }
+    delete(key, hash) {
+        return hash === this._hash && Equatable.equals(key, this._key)
+            ? Status.deleted(Empty)
+            : Status.unchanged(this);
+    }
+    map(mapper) {
+        return Leaf.of(this._hash, this._key, mapper(this._value, this._key));
+    }
+    equals(value) {
+        return (value instanceof Leaf &&
+            value._hash === this._hash &&
+            Equatable.equals(value._key, this._key) &&
+            Equatable.equals(value._value, this._value));
+    }
+    *[Symbol.iterator]() {
+        yield [this._key, this._value];
+    }
+}
+/**
+ * @internal
+ */
+export class Collision {
+    static of(hash, nodes) {
+        return new Collision(hash, nodes);
+    }
+    _hash;
+    _nodes;
+    constructor(hash, nodes) {
+        this._hash = hash;
+        this._nodes = nodes;
+    }
+    isEmpty() {
+        return false;
+    }
+    isLeaf() {
+        return false;
+    }
+    get(key, hash, shift) {
+        if (hash === this._hash) {
+            for (const node of this._nodes) {
+                const value = node.get(key, hash, shift);
+                if (value.isSome()) {
+                    return value;
+                }
+            }
+        }
+        return None;
+    }
+    set(key, value, hash, shift) {
+        if (hash === this._hash) {
+            for (let i = 0, n = this._nodes.length; i < n; i++) {
+                const node = this._nodes[i];
+                if (Equatable.equals(key, node.key)) {
+                    if (Equatable.equals(value, node.value)) {
+                        return Status.unchanged(this);
+                    }
+                    return Status.updated(Collision.of(this._hash, replace(this._nodes, i, Leaf.of(hash, key, value))));
+                }
+            }
+            return Status.created(Collision.of(this._hash, this._nodes.concat(Leaf.of(hash, key, value))));
+        }
+        const fragment = Node.fragment(this._hash, shift);
+        return Sparse.of(bit(fragment), [this]).set(key, value, hash, shift);
+    }
+    delete(key, hash) {
+        if (hash === this._hash) {
+            for (let i = 0, n = this._nodes.length; i < n; i++) {
+                const node = this._nodes[i];
+                if (Equatable.equals(key, node.key)) {
+                    const nodes = remove(this._nodes, i);
+                    if (nodes.length === 1) {
+                        // We just deleted the penultimate Leaf of the Collision, so we can
+                        // remove the Collision and only keep the remaining Leaf.
+                        return Status.deleted(nodes[0]);
+                    }
+                    return Status.deleted(Collision.of(this._hash, nodes));
+                }
+            }
+        }
+        return Status.unchanged(this);
+    }
+    map(mapper) {
+        return Collision.of(this._hash, this._nodes.map((node) => node.map(mapper)));
+    }
+    equals(value) {
+        return (value instanceof Collision &&
+            value._hash === this._hash &&
+            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;
+        }
+    }
+}
+/**
+ * @internal
+ */
+export class Sparse {
+    static of(mask, nodes) {
+        return new Sparse(mask, nodes);
+    }
+    _mask;
+    _nodes;
+    constructor(mask, nodes) {
+        this._mask = mask;
+        this._nodes = nodes;
+    }
+    isEmpty() {
+        return false;
+    }
+    isLeaf() {
+        return false;
+    }
+    get(key, hash, shift) {
+        const fragment = Node.fragment(hash, shift);
+        if (test(this._mask, fragment)) {
+            const index = Node.index(fragment, this._mask);
+            return this._nodes[index].get(key, hash, shift + Node.Bits);
+        }
+        return None;
+    }
+    set(key, value, hash, shift) {
+        const fragment = Node.fragment(hash, shift);
+        const index = Node.index(fragment, this._mask);
+        if (test(this._mask, fragment)) {
+            const { result: node, status } = this._nodes[index].set(key, value, hash, shift + Node.Bits);
+            if (status === "unchanged") {
+                return Status.unchanged(this);
+            }
+            const sparse = Sparse.of(this._mask, replace(this._nodes, index, node));
+            switch (status) {
+                case "created":
+                    return Status.created(sparse);
+                case "updated":
+                default:
+                    return Status.updated(sparse);
+            }
+        }
+        return Status.created(Sparse.of(set(this._mask, fragment), insert(this._nodes, index, Leaf.of(hash, key, value))));
+    }
+    delete(key, hash, shift) {
+        const fragment = Node.fragment(hash, shift);
+        if (test(this._mask, fragment)) {
+            const index = Node.index(fragment, this._mask);
+            const { result: node, status } = this._nodes[index].delete(key, hash, shift + Node.Bits);
+            if (status === "unchanged") {
+                return Status.unchanged(this);
+            }
+            if (node.isEmpty()) {
+                const nodes = remove(this._nodes, index);
+                if (nodes.length === 1) {
+                    // We deleted the penultimate child of the Sparse, we may be able to
+                    // simplify the tree.
+                    if (nodes[0].isLeaf() || nodes[0] instanceof Collision) {
+                        // The last child is leaf-like, hence hashes will be fully matched
+                        // against its key(s) and we can remove the current Sparse
+                        return Status.deleted(nodes[0]);
+                    }
+                    // Otherwise, the last child is a Sparse. We can't simply collapse the
+                    // tree by removing the current Sparse, since it will cause the child
+                    // mask to be tested with the wrong shift (its depth in the tree would
+                    // be different).
+                    // We could do some further optimisations (e.g., if the child's
+                    // children are all leaf-like, we could instead delete the lone child
+                    // and connect directly to the grandchildren). This is, however,
+                    // getting hairy to make all cases working fine, and we assume this
+                    // kind of situation is not too frequent. So we pay the price of
+                    // keeping a non-branching Sparse until we need to optimise that.
+                }
+                return Status.deleted(Sparse.of(clear(this._mask, fragment), nodes));
+            }
+            return Status.deleted(Sparse.of(this._mask, replace(this._nodes, index, node)));
+        }
+        return Status.unchanged(this);
+    }
+    map(mapper) {
+        return Sparse.of(this._mask, this._nodes.map((node) => node.map(mapper)));
+    }
+    equals(value) {
+        return (value instanceof Sparse &&
+            value._mask === this._mask &&
+            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;
+        }
+    }
+}
+function insert(array, index, value) {
+    const result = new Array(array.length + 1);
+    result[index] = value;
+    for (let i = 0, n = index; i < n; i++) {
+        result[i] = array[i];
+    }
+    for (let i = index, n = array.length; i < n; i++) {
+        result[i + 1] = array[i];
+    }
+    return result;
+}
+function remove(array, index) {
+    const result = new Array(array.length - 1);
+    for (let i = 0, n = index; i < n; i++) {
+        result[i] = array[i];
+    }
+    for (let i = index, n = result.length; i < n; i++) {
+        result[i] = array[i + 1];
+    }
+    return result;
+}
+function replace(array, index, value) {
+    const result = array.slice(0);
+    result[index] = value;
+    return result;
+}
+//# sourceMappingURL=node.js.map

package/dist/status.d.ts

@@ -0,0 +1,41 @@
+/**
+ * @internal
+ */
+export type Status<T> = Status.Created<T> | Status.Updated<T> | Status.Deleted<T> | Status.Unchanged<T>;
+/**
+ * @internal
+ */
+export declare namespace Status {
+    abstract class Status<T> {
+        protected readonly _result: T;
+        protected constructor(result: T);
+        get result(): T;
+        abstract get status(): string;
+    }
+    export class Created<T> extends Status<T> {
+        static of<T>(result: T): Created<T>;
+        private constructor();
+        get status(): "created";
+    }
+    export const created: typeof Created.of;
+    export class Updated<T> extends Status<T> {
+        static of<T>(result: T): Updated<T>;
+        private constructor();
+        get status(): "updated";
+    }
+    export const updated: typeof Updated.of;
+    export class Deleted<T> extends Status<T> {
+        static of<T>(result: T): Deleted<T>;
+        private constructor();
+        get status(): "deleted";
+    }
+    export const deleted: typeof Deleted.of;
+    export class Unchanged<T> extends Status<T> {
+        static of<T>(result: T): Unchanged<T>;
+        private constructor();
+        get status(): "unchanged";
+    }
+    export const unchanged: typeof Unchanged.of;
+    export {};
+}
+//# sourceMappingURL=status.d.ts.map

package/dist/status.js

@@ -0,0 +1,68 @@
+/**
+ * @internal
+ */
+export var Status;
+(function (Status_1) {
+    class Status {
+        _result;
+        constructor(result) {
+            this._result = result;
+        }
+        get result() {
+            return this._result;
+        }
+    }
+    class Created extends Status {
+        static of(result) {
+            return new Created(result);
+        }
+        constructor(result) {
+            super(result);
+        }
+        get status() {
+            return "created";
+        }
+    }
+    Status_1.Created = Created;
+    Status_1.created = Created.of;
+    class Updated extends Status {
+        static of(result) {
+            return new Updated(result);
+        }
+        constructor(result) {
+            super(result);
+        }
+        get status() {
+            return "updated";
+        }
+    }
+    Status_1.Updated = Updated;
+    Status_1.updated = Updated.of;
+    class Deleted extends Status {
+        static of(result) {
+            return new Deleted(result);
+        }
+        constructor(result) {
+            super(result);
+        }
+        get status() {
+            return "deleted";
+        }
+    }
+    Status_1.Deleted = Deleted;
+    Status_1.deleted = Deleted.of;
+    class Unchanged extends Status {
+        static of(result) {
+            return new Unchanged(result);
+        }
+        constructor(result) {
+            super(result);
+        }
+        get status() {
+            return "unchanged";
+        }
+    }
+    Status_1.Unchanged = Unchanged;
+    Status_1.unchanged = Unchanged.of;
+})(Status || (Status = {}));
+//# sourceMappingURL=status.js.map

package/package.json

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