atomic-fns 1.2.0 → 2.0.0

package/dist/collections/sorted-set.d.ts

@@ -0,0 +1,103 @@
+/**
+ * A set whose values stay sorted, on the same B+ tree as {@link SortedMap}. It has `Set`'s core
+ * method names (`has`, `add`, `delete`, `keys`, ...), so it can be the argument of `Set`'s ES2025
+ * set algebra (`union`, `intersection`, ...) but has none of those methods itself. It iterates in
+ * order, and adds `first`, `last`, `lower`, `higher`, `floor`, `ceiling`, `at`, `rank` and range
+ * queries in O(log n). Values the comparator calls equal are the same value: `add` of one keeps the
+ * value already there. A `-0` is stored as `+0`, as `Set` does. With the default comparator, values
+ * are numbers, bigints or strings: `NaN` throws `RangeError`, and `null`, `undefined` and other
+ * values throw `TypeError`; pass a comparator to order them.
+ *
+ * Every lookup runs the comparator, so `has` of a value it cannot order throws instead of returning
+ * `false`. The same goes for `Set` methods that call `has` on a `SortedSet` argument: with the
+ * default comparator, `new Set(['x']).isSubsetOf(new SortedSet([1]))` throws `TypeError`.
+ *
+ * @example
+ * ```ts
+ * const ids = new SortedSet([30, 10, 20, 10])
+ * ;[...ids] // [10, 20, 30]
+ * ids.higher(10) // 20
+ * ids.rank(25) // 2
+ * ```
+ */
+export declare class SortedSet<T = unknown> {
+    #private;
+    /**
+     * Create a set holding `values`; when values repeat, the first one seen is kept.
+     * @param values Initial values. `null` means none, as for `Set`.
+     * @param compareFn Comparator. Defaults to the primitive order (numbers, bigints and strings).
+     * @throws {TypeError} when `values` is not iterable or the comparator cannot order a value.
+     * @throws {RangeError} when `values` is a huge sparse array, or holds `NaN` under the default
+     * comparator.
+     */
+    constructor(values?: Iterable<T> | null, compareFn?: ((a: T, b: T) => number) | null);
+    /** The number of values. */
+    get size(): number;
+    /** `'SortedSet'`, for `Object.prototype.toString`. */
+    get [Symbol.toStringTag](): string;
+    /**
+     * Insert `value` unless an equal value is present. O(log n).
+     * @returns `this`
+     * @throws {TypeError} when the comparator cannot order `value`; the set is unchanged.
+     */
+    add(value: T): this;
+    /** Whether a value equal to `value` is present. O(log n). */
+    has(value: T): boolean;
+    /**
+     * Remove the value equal to `value`. O(log n).
+     * @returns Whether it was present.
+     */
+    delete(value: T): boolean;
+    /** Remove every value. */
+    clear(): void;
+    /** The smallest value, or `undefined` when empty. */
+    first(): T | undefined;
+    /** The largest value, or `undefined` when empty. */
+    last(): T | undefined;
+    /** The greatest value below `value`, or `undefined`. */
+    lower(value: T): T | undefined;
+    /** The least value above `value`, or `undefined`. */
+    higher(value: T): T | undefined;
+    /** The greatest value at or below `value`, or `undefined`. */
+    floor(value: T): T | undefined;
+    /** The least value at or above `value`, or `undefined`. */
+    ceiling(value: T): T | undefined;
+    /**
+     * The value at `index` in order, with `Array.prototype.at` rules, or `undefined` out of range.
+     * O(log n).
+     */
+    at(index: number): T | undefined;
+    /**
+     * How many values sort before `value`: its index when present, else where it would go. O(log n).
+     * @throws {TypeError} when the comparator cannot order `value`.
+     */
+    rank(value: T): number;
+    /**
+     * The values in `[from, to)`, or `[from, to]` with `inclusiveEnd`, in order.
+     * @param options `inclusiveEnd` includes `to` (default false); `limit` caps how many values are
+     * collected (a non-negative integer or `Infinity`, the default).
+     * @throws {TypeError} when `options` is neither `undefined` nor an object, `limit` is not a
+     * number, or the comparator cannot order `from` or `to`.
+     * @throws {RangeError} when `limit` is a number but not a non-negative integer or `Infinity`.
+     * @example
+     * ```ts
+     * new SortedSet([1, 2, 3, 4]).valuesBetween(2, 4) // [2, 3]
+     * ```
+     */
+    valuesBetween(from: T, to: T, options?: {
+        inclusiveEnd?: boolean;
+        limit?: number;
+    }): T[];
+    /** The values, largest first. */
+    valuesDescending(): IteratorObject<T>;
+    /** The values, in order. */
+    values(): IteratorObject<T>;
+    /** The values, in order, as `Set.prototype.keys` gives them. */
+    keys(): IteratorObject<T>;
+    /** `[value, value]` pairs, in order, as `Set.prototype.entries` gives them. */
+    entries(): IteratorObject<[T, T]>;
+    /** Call `callback(value, value, set)` for each value, in order. */
+    forEach(callback: (value: T, key: T, set: this) => void, thisArg?: unknown): void;
+    /** The values, in order. */
+    [Symbol.iterator](): IteratorObject<T>;
+}

package/dist/collections/sorted-set.js

@@ -0,0 +1,147 @@
+import { createSetMap, insertIfAbsent } from './sorted-map.js';
+/**
+ * A set whose values stay sorted, on the same B+ tree as {@link SortedMap}. It has `Set`'s core
+ * method names (`has`, `add`, `delete`, `keys`, ...), so it can be the argument of `Set`'s ES2025
+ * set algebra (`union`, `intersection`, ...) but has none of those methods itself. It iterates in
+ * order, and adds `first`, `last`, `lower`, `higher`, `floor`, `ceiling`, `at`, `rank` and range
+ * queries in O(log n). Values the comparator calls equal are the same value: `add` of one keeps the
+ * value already there. A `-0` is stored as `+0`, as `Set` does. With the default comparator, values
+ * are numbers, bigints or strings: `NaN` throws `RangeError`, and `null`, `undefined` and other
+ * values throw `TypeError`; pass a comparator to order them.
+ *
+ * Every lookup runs the comparator, so `has` of a value it cannot order throws instead of returning
+ * `false`. The same goes for `Set` methods that call `has` on a `SortedSet` argument: with the
+ * default comparator, `new Set(['x']).isSubsetOf(new SortedSet([1]))` throws `TypeError`.
+ *
+ * @example
+ * ```ts
+ * const ids = new SortedSet([30, 10, 20, 10])
+ * ;[...ids] // [10, 20, 30]
+ * ids.higher(10) // 20
+ * ids.rank(25) // 2
+ * ```
+ */
+export class SortedSet {
+    #map;
+    /**
+     * Create a set holding `values`; when values repeat, the first one seen is kept.
+     * @param values Initial values. `null` means none, as for `Set`.
+     * @param compareFn Comparator. Defaults to the primitive order (numbers, bigints and strings).
+     * @throws {TypeError} when `values` is not iterable or the comparator cannot order a value.
+     * @throws {RangeError} when `values` is a huge sparse array, or holds `NaN` under the default
+     * comparator.
+     */
+    constructor(values, compareFn) {
+        this.#map = createSetMap(values, compareFn);
+    }
+    /** The number of values. */
+    get size() {
+        return this.#map.size;
+    }
+    /** `'SortedSet'`, for `Object.prototype.toString`. */
+    get [Symbol.toStringTag]() {
+        return 'SortedSet';
+    }
+    /**
+     * Insert `value` unless an equal value is present. O(log n).
+     * @returns `this`
+     * @throws {TypeError} when the comparator cannot order `value`; the set is unchanged.
+     */
+    add(value) {
+        insertIfAbsent(this.#map, value, true);
+        return this;
+    }
+    /** Whether a value equal to `value` is present. O(log n). */
+    has(value) {
+        return this.#map.has(value);
+    }
+    /**
+     * Remove the value equal to `value`. O(log n).
+     * @returns Whether it was present.
+     */
+    delete(value) {
+        return this.#map.delete(value);
+    }
+    /** Remove every value. */
+    clear() {
+        this.#map.clear();
+    }
+    /** The smallest value, or `undefined` when empty. */
+    first() {
+        return this.#map.firstKey();
+    }
+    /** The largest value, or `undefined` when empty. */
+    last() {
+        return this.#map.lastKey();
+    }
+    /** The greatest value below `value`, or `undefined`. */
+    lower(value) {
+        return this.#map.lower(value)?.[0];
+    }
+    /** The least value above `value`, or `undefined`. */
+    higher(value) {
+        return this.#map.higher(value)?.[0];
+    }
+    /** The greatest value at or below `value`, or `undefined`. */
+    floor(value) {
+        return this.#map.floor(value)?.[0];
+    }
+    /** The least value at or above `value`, or `undefined`. */
+    ceiling(value) {
+        return this.#map.ceiling(value)?.[0];
+    }
+    /**
+     * The value at `index` in order, with `Array.prototype.at` rules, or `undefined` out of range.
+     * O(log n).
+     */
+    at(index) {
+        return this.#map.at(index)?.[0];
+    }
+    /**
+     * How many values sort before `value`: its index when present, else where it would go. O(log n).
+     * @throws {TypeError} when the comparator cannot order `value`.
+     */
+    rank(value) {
+        return this.#map.rank(value);
+    }
+    /**
+     * The values in `[from, to)`, or `[from, to]` with `inclusiveEnd`, in order.
+     * @param options `inclusiveEnd` includes `to` (default false); `limit` caps how many values are
+     * collected (a non-negative integer or `Infinity`, the default).
+     * @throws {TypeError} when `options` is neither `undefined` nor an object, `limit` is not a
+     * number, or the comparator cannot order `from` or `to`.
+     * @throws {RangeError} when `limit` is a number but not a non-negative integer or `Infinity`.
+     * @example
+     * ```ts
+     * new SortedSet([1, 2, 3, 4]).valuesBetween(2, 4) // [2, 3]
+     * ```
+     */
+    valuesBetween(from, to, options) {
+        return this.#map.entriesBetween(from, to, options).map(([v]) => v);
+    }
+    /** The values, largest first. */
+    valuesDescending() {
+        return this.#map.entriesDescending().map(([v]) => v);
+    }
+    /** The values, in order. */
+    values() {
+        return this.#map.keys();
+    }
+    /** The values, in order, as `Set.prototype.keys` gives them. */
+    keys() {
+        return this.#map.keys();
+    }
+    /** `[value, value]` pairs, in order, as `Set.prototype.entries` gives them. */
+    entries() {
+        return this.#map.keys().map((v) => [v, v]);
+    }
+    /** Call `callback(value, value, set)` for each value, in order. */
+    forEach(callback, thisArg) {
+        for (const v of this.values())
+            Reflect.apply(callback, thisArg, [v, v, this]);
+    }
+    /** The values, in order. */
+    [Symbol.iterator]() {
+        return this.values();
+    }
+}

package/dist/collections/splay-tree.d.ts

@@ -0,0 +1,82 @@
+/**
+ * An ordered map on a splay tree, a self-adjusting binary search tree that moves what you read to
+ * the root, so recently used keys are quick to reach again. Insertion, lookup and removal take
+ * O(log n) amortized time. It has `Map`'s method names, iterates in key order, and treats keys the
+ * comparator calls equal as the same key. `get` and `has` splay with probability 0.5 (a randomized
+ * splay tree); `firstKey`, `lastKey`, `lower`, `higher` and iterator re-seeks always splay. With
+ * the default comparator, keys are numbers, bigints or strings: `NaN` throws `RangeError`, and
+ * `null`, `undefined` and other values throw `TypeError`; pass a comparator to order them. A
+ * comparator that returns anything but a finite number throws `TypeError`, and a comparator that
+ * throws leaves every entry in place.
+ *
+ * Iterators capture a structural version; splaying bumps it. A stale iterator re-seeks by splaying
+ * its last yielded key's successor (O(log n) amortized), and an iterator left open holds nothing
+ * that later reads or writes wait on.
+ *
+ * @see {@link https://en.wikipedia.org/wiki/Splay_tree Splay tree}
+ * @see {@link https://web.archive.org/web/20220930173835/http://www14.in.tum.de/personen/albers/papers/ipl02.pdf Randomized Splay Trees}
+ * @example
+ * ```ts
+ * const tree = new SplayTree([
+ *   [3, 'c'],
+ *   [1, 'a']
+ * ])
+ * tree.set(2, 'b')
+ * ;[...tree.keys()] // [1, 2, 3]
+ * tree.lower(2) // [1, 'a']
+ * ```
+ */
+export declare class SplayTree<K, V = unknown> {
+    #private;
+    /**
+     * Create a tree holding `entries`, inserted in order.
+     * @param entries Initial `[key, value]` pairs. `null` means none, as for `Map`.
+     * @param compareFn Key comparator. Defaults to the primitive order (numbers, bigints and strings).
+     * @throws {TypeError} when `entries` is not iterable or holds something that is not an entry.
+     */
+    constructor(entries?: Iterable<readonly [K, V]> | null, compareFn?: ((a: K, b: K) => number) | null);
+    /** The number of entries. */
+    get size(): number;
+    /** `'SplayTree'`, for `Object.prototype.toString`. */
+    get [Symbol.toStringTag](): string;
+    /** The value for `key`, or `undefined`. May splay the key to the root. */
+    get(key: K): V | undefined;
+    /** Whether `key` is present. May splay the key to the root. */
+    has(key: K): boolean;
+    /**
+     * Insert or replace `key`, splaying it to the root.
+     * @returns `this`
+     */
+    set(key: K, value: V): this;
+    /**
+     * Remove `key`.
+     * @returns Whether it was present.
+     */
+    delete(key: K): boolean;
+    /** Remove every entry. */
+    clear(): void;
+    /** The smallest key, or `undefined` when empty. Splays it to the root. */
+    firstKey(): K | undefined;
+    /** The largest key, or `undefined` when empty. Splays it to the root. */
+    lastKey(): K | undefined;
+    /** The entry with the greatest key below `key`, or `undefined`. Splays it to the root. */
+    lower(key: K): [K, V] | undefined;
+    /** The entry with the least key above `key`, or `undefined`. Splays it to the root. */
+    higher(key: K): [K, V] | undefined;
+    /**
+     * Top-down splay of `key` (Sleator and Tarjan). Bumps the structural version so open
+     * iterators re-seek from their last key. A comparator that throws leaves every entry in place.
+     * @see {@link https://doi.org/10.1145%2F3828.3835 Self-Adjusting Binary Search Trees}
+     */
+    splay(key: K): void;
+    /** The keys, in order. */
+    keys(): IteratorObject<K>;
+    /** The values, in key order. */
+    values(): IteratorObject<V>;
+    /** `[key, value]` pairs, in key order. */
+    entries(): IteratorObject<[K, V]>;
+    /** Call `callback(value, key, tree)` for each entry, in key order. */
+    forEach(callback: (value: V, key: K, tree: this) => void, thisArg?: unknown): void;
+    /** `[key, value]` pairs, in key order. */
+    [Symbol.iterator](): IteratorObject<[K, V]>;
+}

package/dist/collections/splay-tree.js

@@ -0,0 +1,354 @@
+import { defaultCompare } from '../internal/compare.js';
+import { requireIterable } from './internal/iterable.js';
+class Node {
+    key;
+    value;
+    left;
+    right;
+    constructor(key, value) {
+        this.key = key;
+        this.value = value;
+    }
+}
+/**
+ * An ordered map on a splay tree, a self-adjusting binary search tree that moves what you read to
+ * the root, so recently used keys are quick to reach again. Insertion, lookup and removal take
+ * O(log n) amortized time. It has `Map`'s method names, iterates in key order, and treats keys the
+ * comparator calls equal as the same key. `get` and `has` splay with probability 0.5 (a randomized
+ * splay tree); `firstKey`, `lastKey`, `lower`, `higher` and iterator re-seeks always splay. With
+ * the default comparator, keys are numbers, bigints or strings: `NaN` throws `RangeError`, and
+ * `null`, `undefined` and other values throw `TypeError`; pass a comparator to order them. A
+ * comparator that returns anything but a finite number throws `TypeError`, and a comparator that
+ * throws leaves every entry in place.
+ *
+ * Iterators capture a structural version; splaying bumps it. A stale iterator re-seeks by splaying
+ * its last yielded key's successor (O(log n) amortized), and an iterator left open holds nothing
+ * that later reads or writes wait on.
+ *
+ * @see {@link https://en.wikipedia.org/wiki/Splay_tree Splay tree}
+ * @see {@link https://web.archive.org/web/20220930173835/http://www14.in.tum.de/personen/albers/papers/ipl02.pdf Randomized Splay Trees}
+ * @example
+ * ```ts
+ * const tree = new SplayTree([
+ *   [3, 'c'],
+ *   [1, 'a']
+ * ])
+ * tree.set(2, 'b')
+ * ;[...tree.keys()] // [1, 2, 3]
+ * tree.lower(2) // [1, 'a']
+ * ```
+ */
+export class SplayTree {
+    #root;
+    #compareFn;
+    #size = 0;
+    #version = 0;
+    /**
+     * Create a tree holding `entries`, inserted in order.
+     * @param entries Initial `[key, value]` pairs. `null` means none, as for `Map`.
+     * @param compareFn Key comparator. Defaults to the primitive order (numbers, bigints and strings).
+     * @throws {TypeError} when `entries` is not iterable or holds something that is not an entry.
+     */
+    constructor(entries, compareFn) {
+        this.#compareFn = compareFn ?? defaultCompare;
+        if (entries == null)
+            return;
+        for (const entry of requireIterable(entries)) {
+            if (Object(entry) !== entry)
+                throw new TypeError('entries must be [key, value] pairs');
+            this.set(entry[0], entry[1]);
+        }
+    }
+    /** The number of entries. */
+    get size() {
+        return this.#size;
+    }
+    /** `'SplayTree'`, for `Object.prototype.toString`. */
+    get [Symbol.toStringTag]() {
+        return 'SplayTree';
+    }
+    /** The value for `key`, or `undefined`. May splay the key to the root. */
+    get(key) {
+        return this.#lookup(key)?.value;
+    }
+    /** Whether `key` is present. May splay the key to the root. */
+    has(key) {
+        return this.#lookup(key) !== undefined;
+    }
+    /**
+     * Insert or replace `key`, splaying it to the root.
+     * @returns `this`
+     */
+    set(key, value) {
+        if (!this.#root) {
+            this.#cmp(key, key);
+            this.#root = new Node(key, value);
+            this.#size = 1;
+            this.#version++;
+            return this;
+        }
+        this.splay(key);
+        const rank = this.#cmp(key, this.#root.key);
+        if (rank === 0) {
+            this.#root.value = value;
+            return this;
+        }
+        const node = new Node(key, value);
+        if (rank > 0) {
+            node.left = this.#root;
+            node.right = this.#root.right;
+            this.#root.right = undefined;
+        }
+        else {
+            node.right = this.#root;
+            node.left = this.#root.left;
+            this.#root.left = undefined;
+        }
+        this.#root = node;
+        this.#size++;
+        return this;
+    }
+    /**
+     * Remove `key`.
+     * @returns Whether it was present.
+     */
+    delete(key) {
+        if (!this.#root)
+            return false;
+        this.splay(key);
+        if (this.#cmp(key, this.#root.key) !== 0)
+            return false;
+        if (!this.#root.left) {
+            this.#root = this.#root.right;
+        }
+        else {
+            const max = this.#splayMax(this.#root.left);
+            max.right = this.#root.right;
+            this.#root = max;
+        }
+        this.#size--;
+        return true;
+    }
+    /** Remove every entry. */
+    clear() {
+        this.#root = undefined;
+        this.#size = 0;
+        this.#version++;
+    }
+    /** The smallest key, or `undefined` when empty. Splays it to the root. */
+    firstKey() {
+        if (!this.#root)
+            return undefined;
+        let n = this.#root;
+        while (n.left)
+            n = n.left;
+        const key = n.key;
+        this.splay(key);
+        return key;
+    }
+    /** The largest key, or `undefined` when empty. Splays it to the root. */
+    lastKey() {
+        if (!this.#root)
+            return undefined;
+        let n = this.#root;
+        while (n.right)
+            n = n.right;
+        const key = n.key;
+        this.splay(key);
+        return key;
+    }
+    /** The entry with the greatest key below `key`, or `undefined`. Splays it to the root. */
+    lower(key) {
+        if (!this.#root)
+            return undefined;
+        this.splay(key);
+        if (this.#cmp(this.#root.key, key) < 0)
+            return [this.#root.key, this.#root.value];
+        let n = this.#root.left;
+        if (!n)
+            return undefined;
+        while (n.right)
+            n = n.right;
+        this.splay(n.key);
+        return [n.key, n.value];
+    }
+    /** The entry with the least key above `key`, or `undefined`. Splays it to the root. */
+    higher(key) {
+        if (!this.#root)
+            return undefined;
+        this.splay(key);
+        if (this.#cmp(this.#root.key, key) > 0)
+            return [this.#root.key, this.#root.value];
+        let n = this.#root.right;
+        if (!n)
+            return undefined;
+        while (n.left)
+            n = n.left;
+        this.splay(n.key);
+        return [n.key, n.value];
+    }
+    /**
+     * Top-down splay of `key` (Sleator and Tarjan). Bumps the structural version so open
+     * iterators re-seek from their last key. A comparator that throws leaves every entry in place.
+     * @see {@link https://doi.org/10.1145%2F3828.3835 Self-Adjusting Binary Search Trees}
+     */
+    splay(key) {
+        if (!this.#root)
+            return;
+        const stub = {};
+        let left = stub;
+        let right = stub;
+        let root = this.#root;
+        try {
+            for (;;) {
+                const rank = this.#cmp(key, root.key);
+                if (rank < 0) {
+                    if (!root.left)
+                        break;
+                    if (this.#cmp(key, root.left.key) < 0) {
+                        const tmp = root.left;
+                        root.left = tmp.right;
+                        tmp.right = root;
+                        root = tmp;
+                        if (!root.left)
+                            break;
+                    }
+                    right.left = root;
+                    right = root;
+                    root = root.left;
+                }
+                else if (rank > 0) {
+                    if (!root.right)
+                        break;
+                    if (this.#cmp(key, root.right.key) > 0) {
+                        const tmp = root.right;
+                        root.right = tmp.left;
+                        tmp.left = root;
+                        root = tmp;
+                        if (!root.right)
+                            break;
+                    }
+                    left.right = root;
+                    left = root;
+                    root = root.right;
+                }
+                else {
+                    break;
+                }
+            }
+        }
+        finally {
+            left.right = root.left;
+            right.left = root.right;
+            root.left = stub.right;
+            root.right = stub.left;
+            this.#root = root;
+            this.#version++;
+        }
+    }
+    /** The keys, in order. */
+    keys() {
+        return this.#inorder().map((n) => n.key);
+    }
+    /** The values, in key order. */
+    values() {
+        return this.#inorder().map((n) => n.value);
+    }
+    /** `[key, value]` pairs, in key order. */
+    entries() {
+        return this.#inorder().map((n) => [n.key, n.value]);
+    }
+    /** Call `callback(value, key, tree)` for each entry, in key order. */
+    forEach(callback, thisArg) {
+        for (const [k, v] of this.entries())
+            Reflect.apply(callback, thisArg, [v, k, this]);
+    }
+    /** `[key, value]` pairs, in key order. */
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    *#inorder() {
+        let version = this.#version;
+        let lastKey;
+        let haveLast = false;
+        const stack = [];
+        let n = this.#root;
+        // Splaying or mutating restructures the tree, so the stack is stale. Splay the successor of
+        // the last yielded key to the root: a plain descent would pay O(height) at every step.
+        const reseek = () => {
+            stack.length = 0;
+            n = haveLast ? undefined : this.#root;
+            if (haveLast) {
+                this.higher(lastKey);
+                const root = this.#root;
+                if (root && this.#cmp(root.key, lastKey) > 0)
+                    stack.push(root);
+            }
+            version = this.#version;
+        };
+        for (;;) {
+            if (version !== this.#version)
+                reseek();
+            while (n) {
+                stack.push(n);
+                n = n.left;
+            }
+            const current = stack.pop();
+            if (current === undefined)
+                return;
+            lastKey = current.key;
+            haveLast = true;
+            n = current.right;
+            yield current;
+        }
+    }
+    /**
+     * Top-down splay of the largest key in the subtree at `root`, returning the new subtree root,
+     * which has no right child. It follows right links only and never calls the comparator, so it
+     * cannot throw while `delete` holds a detached subtree.
+     */
+    #splayMax(root) {
+        const stub = {};
+        let left = stub;
+        while (root.right) {
+            const tmp = root.right;
+            root.right = tmp.left;
+            tmp.left = root;
+            root = tmp;
+            if (!root.right)
+                break;
+            left.right = root;
+            left = root;
+            root = root.right;
+        }
+        left.right = root.left;
+        root.left = stub.right;
+        return root;
+    }
+    #lookup(key) {
+        if (!this.#root)
+            return undefined;
+        if (Math.random() < 0.5) {
+            this.splay(key);
+            return this.#cmp(key, this.#root.key) === 0 ? this.#root : undefined;
+        }
+        return this.#find(key);
+    }
+    #cmp(a, b) {
+        const rank = this.#compareFn(a, b);
+        if (typeof rank !== 'number' || !Number.isFinite(rank)) {
+            throw new TypeError('comparator must return a finite number');
+        }
+        return rank;
+    }
+    #find(key) {
+        let n = this.#root;
+        while (n) {
+            const c = this.#cmp(key, n.key);
+            if (c === 0)
+                return n;
+            n = c < 0 ? n.left : n.right;
+        }
+        return undefined;
+    }
+}