atomic-fns 1.1.7 → 2.0.0

package/dist/collections/internal/arrayKeys.d.ts

@@ -0,0 +1,19 @@
+import { type ArrayWalkEvent } from '../../internal/sparse.js';
+/**
+ * Walk `arr` without expanding huge hole runs index-by-index.
+ * Dense indices use `i in arr`. Once holes pass {@link HOLE_STREAK_BEFORE_KEYS} plus the elements
+ * seen so far, take `Object.keys` once and continue over remaining canonical indices only, so
+ * cost stays proportional to the elements however they are spaced.
+ * Holes are reported as a single `holeRun` event (`end` exclusive).
+ * Return `false` from `visit` to stop.
+ */
+export declare function walkArray(arr: unknown[], visit: (event: ArrayWalkEvent) => unknown): void;
+/**
+ * True when `arr.length` is above {@link HUGE_SPARSE_MIN_LENGTH} and also exceeds
+ * `2 * visitedIndexCount + 1024`, so a dense `0..length` walk would spend most of its time on holes.
+ * Below {@link HUGE_SPARSE_MIN_LENGTH}, consumers walk with their existing hole semantics.
+ * Counts the values visited by {@link walkArray}; dense arrays exit early once they cannot qualify.
+ */
+export declare function isHugeSparse(arr: unknown[]): boolean;
+/** Throw when `arr` is a huge sparse array that must not be expanded per-index. */
+export declare function assertNotHugeSparse(arr: unknown[]): void;

package/dist/collections/internal/arrayKeys.js

@@ -0,0 +1,83 @@
+import { arrayIndicesFrom, HOLE_STREAK_BEFORE_KEYS, HUGE_SPARSE_MIN_LENGTH } from '../../internal/sparse.js';
+/**
+ * Walk `arr` without expanding huge hole runs index-by-index.
+ * Dense indices use `i in arr`. Once holes pass {@link HOLE_STREAK_BEFORE_KEYS} plus the elements
+ * seen so far, take `Object.keys` once and continue over remaining canonical indices only, so
+ * cost stays proportional to the elements however they are spaced.
+ * Holes are reported as a single `holeRun` event (`end` exclusive).
+ * Return `false` from `visit` to stop.
+ */
+export function walkArray(arr, visit) {
+    const len = arr.length;
+    let i = 0;
+    let elements = 0;
+    let holes = 0;
+    while (i < len) {
+        if (i in arr) {
+            if (visit({ kind: 'value', index: i, value: arr[i] }) === false)
+                return;
+            i++;
+            elements++;
+            continue;
+        }
+        const holeStart = i;
+        while (i < len && !(i in arr) && holes < HOLE_STREAK_BEFORE_KEYS + elements) {
+            i++;
+            holes++;
+        }
+        if (holes >= HOLE_STREAK_BEFORE_KEYS + elements && i < len) {
+            const rest = arrayIndicesFrom(arr, i);
+            const holeEnd = rest.length > 0 ? rest[0] : len;
+            if (visit({ kind: 'holeRun', start: holeStart, end: holeEnd }) === false)
+                return;
+            for (let k = 0; k < rest.length; k++) {
+                const idx = rest[k];
+                if (k > 0) {
+                    const prev = rest[k - 1];
+                    if (idx > prev + 1) {
+                        if (visit({ kind: 'holeRun', start: prev + 1, end: idx }) === false)
+                            return;
+                    }
+                }
+                if (visit({ kind: 'value', index: idx, value: arr[idx] }) === false)
+                    return;
+            }
+            if (rest.length > 0) {
+                const last = rest[rest.length - 1];
+                if (last + 1 < len) {
+                    if (visit({ kind: 'holeRun', start: last + 1, end: len }) === false)
+                        return;
+                }
+            }
+            return;
+        }
+        if (visit({ kind: 'holeRun', start: holeStart, end: i }) === false)
+            return;
+    }
+}
+/**
+ * True when `arr.length` is above {@link HUGE_SPARSE_MIN_LENGTH} and also exceeds
+ * `2 * visitedIndexCount + 1024`, so a dense `0..length` walk would spend most of its time on holes.
+ * Below {@link HUGE_SPARSE_MIN_LENGTH}, consumers walk with their existing hole semantics.
+ * Counts the values visited by {@link walkArray}; dense arrays exit early once they cannot qualify.
+ */
+export function isHugeSparse(arr) {
+    const len = arr.length;
+    if (len <= HUGE_SPARSE_MIN_LENGTH)
+        return false;
+    let own = 0;
+    walkArray(arr, (event) => {
+        if (event.kind !== 'value')
+            return;
+        own++;
+        if (len <= 2 * own + 1024)
+            return false;
+    });
+    return len > 2 * own + 1024;
+}
+/** Throw when `arr` is a huge sparse array that must not be expanded per-index. */
+export function assertNotHugeSparse(arr) {
+    if (isHugeSparse(arr)) {
+        throw new RangeError('sparse array too large');
+    }
+}

package/dist/collections/internal/invariants.d.ts

@@ -0,0 +1,4 @@
+/** Called once by `SortedMap`'s static block with access to its private structure check. */
+export declare function registerSortedMapCheck(fn: (map: object) => void): void;
+/** Throws when a `SortedMap`'s B+ tree breaks an invariant. For tests. */
+export declare function checkSortedMap(map: object): void;

package/dist/collections/internal/invariants.js

@@ -0,0 +1,12 @@
+let check;
+/** Called once by `SortedMap`'s static block with access to its private structure check. */
+export function registerSortedMapCheck(fn) {
+    check = fn;
+}
+/** Throws when a `SortedMap`'s B+ tree breaks an invariant. For tests. */
+export function checkSortedMap(map) {
+    if (check === undefined) {
+        throw new Error('no SortedMap from this module graph has registered its invariant check');
+    }
+    check(map);
+}

package/dist/collections/internal/iterable.d.ts

@@ -0,0 +1,25 @@
+/** Return `value` typed as an iterable; throw `TypeError` before allocating when it is not one. */
+export declare function requireIterable<T>(value: unknown): Iterable<T>;
+/**
+ * True when `value` is an array that iterates with the built-in array iterator, so iterating it
+ * visits every index up to `length`, holes included. An array with its own or a subclass's
+ * `[Symbol.iterator]` iterates however that method says and is treated as any other iterable.
+ */
+export declare function iteratesAsArray(value: unknown): value is unknown[];
+/**
+ * Copy an iterable into a new plain array, as iterating it yields the values (holes read as
+ * `undefined`). The copy never goes through `slice`, so an Array subclass's `Symbol.species`
+ * cannot choose its class. Non-iterables throw `TypeError` and huge sparse arrays throw
+ * `RangeError`, both before allocating.
+ */
+export declare function arrayFromIterable<T>(value: unknown): T[];
+/**
+ * Map an iterable into a new array; non-iterables throw `TypeError` and huge sparse arrays throw
+ * `RangeError`, both before allocating.
+ */
+export declare function arrayFromIterableMap<U>(value: unknown, mapFn: (item: unknown, index: number) => U): U[];
+/**
+ * Visit array elements in own-element time: each own value, and each hole run once as
+ * `undefined` at the run's start index. Return `false` from `visit` to stop.
+ */
+export declare function forEachArrayElement<T>(arr: T[], visit: (value: T, index: number) => boolean | undefined): void;

package/dist/collections/internal/iterable.js

@@ -0,0 +1,62 @@
+import { assertNotHugeSparse, walkArray } from './arrayKeys.js';
+function isIterable(x) {
+    if (x == null)
+        return false;
+    return typeof x[Symbol.iterator] === 'function';
+}
+/** Return `value` typed as an iterable; throw `TypeError` before allocating when it is not one. */
+export function requireIterable(value) {
+    if (!isIterable(value))
+        throw new TypeError('expected an iterable');
+    return value;
+}
+/**
+ * True when `value` is an array that iterates with the built-in array iterator, so iterating it
+ * visits every index up to `length`, holes included. An array with its own or a subclass's
+ * `[Symbol.iterator]` iterates however that method says and is treated as any other iterable.
+ */
+export function iteratesAsArray(value) {
+    return Array.isArray(value) && value[Symbol.iterator] === Array.prototype.values;
+}
+/**
+ * Copy an iterable into a new plain array, as iterating it yields the values (holes read as
+ * `undefined`). The copy never goes through `slice`, so an Array subclass's `Symbol.species`
+ * cannot choose its class. Non-iterables throw `TypeError` and huge sparse arrays throw
+ * `RangeError`, both before allocating.
+ */
+export function arrayFromIterable(value) {
+    const it = requireIterable(value);
+    if (iteratesAsArray(it))
+        assertNotHugeSparse(it);
+    const out = [];
+    for (const x of it)
+        out.push(x);
+    return out;
+}
+/**
+ * Map an iterable into a new array; non-iterables throw `TypeError` and huge sparse arrays throw
+ * `RangeError`, both before allocating.
+ */
+export function arrayFromIterableMap(value, mapFn) {
+    const it = requireIterable(value);
+    if (iteratesAsArray(it))
+        assertNotHugeSparse(it);
+    const out = [];
+    let i = 0;
+    for (const x of it) {
+        out.push(mapFn(x, i));
+        i++;
+    }
+    return out;
+}
+/**
+ * Visit array elements in own-element time: each own value, and each hole run once as
+ * `undefined` at the run's start index. Return `false` from `visit` to stop.
+ */
+export function forEachArrayElement(arr, visit) {
+    walkArray(arr, (ev) => {
+        if (ev.kind === 'value')
+            return visit(ev.value, ev.index);
+        return visit(undefined, ev.start);
+    });
+}

package/dist/collections/iterate.d.ts

@@ -0,0 +1,162 @@
+/**
+ * Iteration over every shape: `forEach`, `map`, `filter`, `find`, `some`, `reduce` and friends.
+ */
+import { type Collection, type CollectionCallback, type CollectionKey, type CollectionValue } from './shape.js';
+/**
+ * Call `callback` with `(value, key, collection)` for every entry of `collection`, in order. Like
+ * the native `forEach`, it visits every entry and ignores what the callback returns; use
+ * {@link some}, {@link every} or `for...of` to stop early.
+ * @param collection The collection to walk.
+ * @param callback Called once per entry.
+ * @example
+ * ```ts
+ * forEach({ a: 1, b: 2 }, (value, key) => console.log(key, value))
+ * // a 1
+ * // b 2
+ * ```
+ */
+export declare function forEach<C extends Collection>(collection: C, callback: CollectionCallback<C, unknown>): void;
+/**
+ * {@link forEach} from the last entry to the first.
+ * @param collection The collection to walk.
+ * @param callback Called once per entry.
+ * @example
+ * ```ts
+ * forEachRight([1, 2], (value) => console.log(value))
+ * // 2
+ * // 1
+ * ```
+ */
+export declare function forEachRight<C extends Collection>(collection: C, callback: CollectionCallback<C, unknown>): void;
+/**
+ * The results of `callback` for every entry of `collection`, as an array.
+ * @param collection The collection to walk.
+ * @param callback Maps one entry.
+ * @returns A new array with one result per entry.
+ * @example
+ * ```ts
+ * map({ a: 1, b: 2 }, (value) => value * 2) // [2, 4]
+ * map(new Map([['x', 1]]), (value, key) => `${key}=${value}`) // ['x=1']
+ * ```
+ */
+export declare function map<C extends Collection, R>(collection: C, callback: CollectionCallback<C, R>): R[];
+/**
+ * {@link map}, then one level of flattening, as `Array.prototype.flatMap` does: an array result
+ * is spread, anything else is kept as one element.
+ * @param collection The collection to walk.
+ * @param callback Maps one entry to an array or a value.
+ * @returns A new flat array.
+ * @example
+ * ```ts
+ * flatMap({ a: 1, b: 2 }, (value, key) => [key, value]) // ['a', 1, 'b', 2]
+ * ```
+ */
+export declare function flatMap<C extends Collection, R>(collection: C, callback: CollectionCallback<C, R | readonly R[]>): R[];
+/**
+ * The values of `collection` for which `predicate` is truthy, in order.
+ * @param collection The collection to walk.
+ * @param predicate Tests one entry.
+ * @returns A new array of values.
+ * @example
+ * ```ts
+ * filter({ a: 1, b: 2, c: 3 }, (value) => value % 2 === 1) // [1, 3]
+ * filter(new Set(['x', 'yy']), (value) => value.length > 1) // ['yy']
+ * ```
+ */
+export declare function filter<C extends Collection, S extends CollectionValue<C>>(collection: C, predicate: (value: CollectionValue<C>, key: CollectionKey<C>, collection: C) => value is S): S[];
+/** {@link filter} with a predicate that is not a type guard. */
+export declare function filter<C extends Collection>(collection: C, predicate: CollectionCallback<C, unknown>): CollectionValue<C>[];
+/**
+ * The values of `collection` for which `predicate` is falsy: the complement of {@link filter}.
+ * @param collection The collection to walk.
+ * @param predicate Tests one entry.
+ * @returns A new array of values.
+ * @example
+ * ```ts
+ * reject([1, 2, 3], (value) => value > 1) // [1]
+ * ```
+ */
+export declare function reject<C extends Collection>(collection: C, predicate: CollectionCallback<C, unknown>): CollectionValue<C>[];
+/**
+ * The first value of `collection` for which `predicate` is truthy, or `undefined`. It stops at
+ * that entry, so it works on an endless iterable that has a match.
+ * @param collection The collection to search.
+ * @param predicate Tests one entry.
+ * @returns The value found, or `undefined`.
+ * @example
+ * ```ts
+ * find({ a: 1, b: 2 }, (value) => value > 1) // 2
+ * ```
+ */
+export declare function find<C extends Collection, S extends CollectionValue<C>>(collection: C, predicate: (value: CollectionValue<C>, key: CollectionKey<C>, collection: C) => value is S): S | undefined;
+/** {@link find} with a predicate that is not a type guard. */
+export declare function find<C extends Collection>(collection: C, predicate: CollectionCallback<C, unknown>): CollectionValue<C> | undefined;
+/**
+ * {@link find} from the last entry to the first.
+ * @param collection The collection to search.
+ * @param predicate Tests one entry.
+ * @returns The value found, or `undefined`.
+ * @example
+ * ```ts
+ * findLast([1, 2, 3], (value) => value < 3) // 2
+ * ```
+ */
+export declare function findLast<C extends Collection, S extends CollectionValue<C>>(collection: C, predicate: (value: CollectionValue<C>, key: CollectionKey<C>, collection: C) => value is S): S | undefined;
+/** {@link findLast} with a predicate that is not a type guard. */
+export declare function findLast<C extends Collection>(collection: C, predicate: CollectionCallback<C, unknown>): CollectionValue<C> | undefined;
+/**
+ * True when `predicate` is truthy for some entry; stops at the first one.
+ * @param collection The collection to test.
+ * @param predicate Tests one entry.
+ * @returns Whether any entry passes. `false` for an empty collection.
+ * @example
+ * ```ts
+ * some({ a: 1, b: -1 }, (value) => value < 0) // true
+ * ```
+ */
+export declare function some<C extends Collection>(collection: C, predicate: CollectionCallback<C, unknown>): boolean;
+/**
+ * True when `predicate` is truthy for every entry; stops at the first that fails.
+ * @param collection The collection to test.
+ * @param predicate Tests one entry.
+ * @returns Whether every entry passes. `true` for an empty collection.
+ * @example
+ * ```ts
+ * every(new Set([2, 4]), (value) => value % 2 === 0) // true
+ * ```
+ */
+export declare function every<C extends Collection>(collection: C, predicate: CollectionCallback<C, unknown>): boolean;
+/** `(accumulator, value, key, collection)`, as `Array.prototype.reduce` passes them plus the key. */
+export type CollectionReducer<C, A> = (accumulator: A, value: CollectionValue<C>, key: CollectionKey<C>, collection: C) => A;
+/**
+ * Fold the entries of `collection` into one value, as `Array.prototype.reduce` does. Without
+ * `initial`, the first value starts the fold.
+ * @param collection The collection to fold.
+ * @param reducer Combines the accumulator with one entry.
+ * @param initial The starting accumulator.
+ * @returns The final accumulator.
+ * @throws {TypeError} when `collection` is empty and no `initial` is given, as the native method does.
+ * @example
+ * ```ts
+ * reduce({ a: 1, b: 2 }, (sum, value) => sum + value, 0) // 3
+ * reduce(new Map([['x', 1]]), (out, value, key) => `${out}${key}${value}`, '') // 'x1'
+ * ```
+ */
+export declare function reduce<C extends Collection, A>(collection: C, reducer: CollectionReducer<C, A>, initial: A): A;
+/** {@link reduce} without `initial`: the first value starts the fold. */
+export declare function reduce<C extends Collection>(collection: C, reducer: CollectionReducer<C, CollectionValue<C>>): CollectionValue<C>;
+/**
+ * {@link reduce} from the last entry to the first, as `Array.prototype.reduceRight` does.
+ * @param collection The collection to fold.
+ * @param reducer Combines the accumulator with one entry.
+ * @param initial The starting accumulator.
+ * @returns The final accumulator.
+ * @throws {TypeError} when `collection` is empty and no `initial` is given.
+ * @example
+ * ```ts
+ * reduceRight(['a', 'b', 'c'], (out, value) => out + value, '') // 'cba'
+ * ```
+ */
+export declare function reduceRight<C extends Collection, A>(collection: C, reducer: CollectionReducer<C, A>, initial: A): A;
+/** {@link reduceRight} without `initial`: the last value starts the fold. */
+export declare function reduceRight<C extends Collection>(collection: C, reducer: CollectionReducer<C, CollectionValue<C>>): CollectionValue<C>;

package/dist/collections/iterate.js

@@ -0,0 +1,188 @@
+/**
+ * Iteration over every shape: `forEach`, `map`, `filter`, `find`, `some`, `reduce` and friends.
+ */
+import { eachEntry, eachIndex, entryList } from './shape.js';
+/**
+ * Call `callback` with `(value, key, collection)` for every entry of `collection`, in order. Like
+ * the native `forEach`, it visits every entry and ignores what the callback returns; use
+ * {@link some}, {@link every} or `for...of` to stop early.
+ * @param collection The collection to walk.
+ * @param callback Called once per entry.
+ * @example
+ * ```ts
+ * forEach({ a: 1, b: 2 }, (value, key) => console.log(key, value))
+ * // a 1
+ * // b 2
+ * ```
+ */
+export function forEach(collection, callback) {
+    const fn = callback;
+    eachEntry(collection, (value, key) => {
+        fn(value, key, collection);
+    });
+}
+/**
+ * {@link forEach} from the last entry to the first.
+ * @param collection The collection to walk.
+ * @param callback Called once per entry.
+ * @example
+ * ```ts
+ * forEachRight([1, 2], (value) => console.log(value))
+ * // 2
+ * // 1
+ * ```
+ */
+export function forEachRight(collection, callback) {
+    const fn = callback;
+    const list = entryList(collection);
+    for (let i = list.length - 1; i >= 0; i--)
+        fn(list[i][1], list[i][0], collection);
+}
+/**
+ * The results of `callback` for every entry of `collection`, as an array.
+ * @param collection The collection to walk.
+ * @param callback Maps one entry.
+ * @returns A new array with one result per entry.
+ * @example
+ * ```ts
+ * map({ a: 1, b: 2 }, (value) => value * 2) // [2, 4]
+ * map(new Map([['x', 1]]), (value, key) => `${key}=${value}`) // ['x=1']
+ * ```
+ */
+export function map(collection, callback) {
+    const fn = callback;
+    const out = [];
+    eachEntry(collection, (value, key) => {
+        out.push(fn(value, key, collection));
+    });
+    return out;
+}
+/**
+ * {@link map}, then one level of flattening, as `Array.prototype.flatMap` does: an array result
+ * is spread, anything else is kept as one element.
+ * @param collection The collection to walk.
+ * @param callback Maps one entry to an array or a value.
+ * @returns A new flat array.
+ * @example
+ * ```ts
+ * flatMap({ a: 1, b: 2 }, (value, key) => [key, value]) // ['a', 1, 'b', 2]
+ * ```
+ */
+export function flatMap(collection, callback) {
+    const fn = callback;
+    const out = [];
+    eachEntry(collection, (value, key) => {
+        const result = fn(value, key, collection);
+        if (Array.isArray(result)) {
+            eachIndex(result, (item) => {
+                out.push(item);
+            });
+        }
+        else {
+            out.push(result);
+        }
+    });
+    return out;
+}
+export function filter(collection, predicate) {
+    const fn = predicate;
+    const out = [];
+    eachEntry(collection, (value, key) => {
+        if (fn(value, key, collection))
+            out.push(value);
+    });
+    return out;
+}
+/**
+ * The values of `collection` for which `predicate` is falsy: the complement of {@link filter}.
+ * @param collection The collection to walk.
+ * @param predicate Tests one entry.
+ * @returns A new array of values.
+ * @example
+ * ```ts
+ * reject([1, 2, 3], (value) => value > 1) // [1]
+ * ```
+ */
+export function reject(collection, predicate) {
+    return filter(collection, (value, key, c) => !predicate(value, key, c));
+}
+export function find(collection, predicate) {
+    const fn = predicate;
+    let found;
+    eachEntry(collection, (value, key) => {
+        if (!fn(value, key, collection))
+            return false;
+        found = value;
+        return true;
+    });
+    return found;
+}
+export function findLast(collection, predicate) {
+    const fn = predicate;
+    const list = entryList(collection);
+    for (let i = list.length - 1; i >= 0; i--) {
+        if (fn(list[i][1], list[i][0], collection))
+            return list[i][1];
+    }
+    return undefined;
+}
+/**
+ * True when `predicate` is truthy for some entry; stops at the first one.
+ * @param collection The collection to test.
+ * @param predicate Tests one entry.
+ * @returns Whether any entry passes. `false` for an empty collection.
+ * @example
+ * ```ts
+ * some({ a: 1, b: -1 }, (value) => value < 0) // true
+ * ```
+ */
+export function some(collection, predicate) {
+    const fn = predicate;
+    return eachEntry(collection, (value, key) => Boolean(fn(value, key, collection)));
+}
+/**
+ * True when `predicate` is truthy for every entry; stops at the first that fails.
+ * @param collection The collection to test.
+ * @param predicate Tests one entry.
+ * @returns Whether every entry passes. `true` for an empty collection.
+ * @example
+ * ```ts
+ * every(new Set([2, 4]), (value) => value % 2 === 0) // true
+ * ```
+ */
+export function every(collection, predicate) {
+    const fn = predicate;
+    return !eachEntry(collection, (value, key) => !fn(value, key, collection));
+}
+function emptyReduceError() {
+    return new TypeError('reduce of an empty collection with no initial value');
+}
+export function reduce(collection, reducer, ...initial) {
+    const fn = reducer;
+    let hasAcc = initial.length > 0;
+    let acc = initial[0];
+    eachEntry(collection, (value, key) => {
+        if (hasAcc) {
+            acc = fn(acc, value, key, collection);
+        }
+        else {
+            acc = value;
+            hasAcc = true;
+        }
+    });
+    if (!hasAcc)
+        throw emptyReduceError();
+    return acc;
+}
+export function reduceRight(collection, reducer, ...initial) {
+    const fn = reducer;
+    const list = entryList(collection);
+    const hasInitial = initial.length > 0;
+    if (!hasInitial && list.length === 0)
+        throw emptyReduceError();
+    let i = list.length - 1;
+    let acc = hasInitial ? initial[0] : list[i--][1];
+    for (; i >= 0; i--)
+        acc = fn(acc, list[i][1], list[i][0], collection);
+    return acc;
+}

package/dist/collections/lru-cache.d.ts

@@ -0,0 +1,58 @@
+/**
+ * A fixed-capacity least-recently-used cache with `Map`'s method names. `get` refreshes recency;
+ * `has` does not. Keys compare with SameValueZero, as in `Map`. Iterators and `forEach` walk a
+ * snapshot taken when they start, so `get` and `set` inside a loop are safe.
+ *
+ * @example
+ * ```ts
+ * const cache = new LRUCache<string, number>(2)
+ * cache.set('a', 1).set('b', 2)
+ * cache.get('a') // 1, so 'b' is now the least recent
+ * cache.set('c', 3)
+ * cache.has('b') // false
+ * ```
+ */
+export declare class LRUCache<K = unknown, V = unknown> {
+    private readonly state;
+    /**
+     * Create an empty cache.
+     * @param capacity Maximum number of entries; must be an integer >= 1. Defaults to 1024.
+     * @throws {TypeError} when capacity is not a number.
+     * @throws {RangeError} when capacity is not an integer >= 1.
+     */
+    constructor(capacity?: number);
+    /**
+     * Set `key` to `value`. Setting an existing key updates its value and makes it the most recent,
+     * without evicting. Inserting a new key at capacity evicts the least recently used entry.
+     */
+    set(key: K, value: V): this;
+    /** Whether `key` is cached. Does not refresh its recency. */
+    has(key: K): boolean;
+    /**
+     * Return the value for `key`, refreshing its recency. Missing keys return `undefined`.
+     */
+    get(key: K): V | undefined;
+    /** Remove every entry. */
+    clear(): void;
+    /**
+     * Remove `key`.
+     * @returns Whether it was present.
+     */
+    delete(key: K): boolean;
+    /** The number of entries. */
+    get size(): number;
+    /** Maximum number of entries. */
+    get capacity(): number;
+    /** `'LRUCache'`, for `Object.prototype.toString`. */
+    get [Symbol.toStringTag](): string;
+    /** The keys, least to most recently used. */
+    keys(): IteratorObject<K>;
+    /** The values, least to most recently used. */
+    values(): IteratorObject<V>;
+    /** `[key, value]` pairs, least to most recently used. */
+    entries(): IteratorObject<[K, V]>;
+    /** Call `callback(value, key, cache)` for each entry, least to most recently used. */
+    forEach(callback: (value: V, key: K, cache: this) => void, thisArg?: unknown): void;
+    /** `[key, value]` pairs, least to most recently used. */
+    [Symbol.iterator](): IteratorObject<[K, V]>;
+}