atomic-fns 1.2.0 → 2.0.0

package/dist/internal/kind.d.ts

@@ -0,0 +1,44 @@
+/**
+ * The built-in kinds a deep walk handles, including values from other realms.
+ */
+/** A native `Map`, from any realm. */
+export declare function isMap(x: unknown): x is Map<unknown, unknown>;
+/** A native `Set`, from any realm. */
+export declare function isSet(x: unknown): x is Set<unknown>;
+/** An `arguments` object, from any realm. `kindOf` calls it `other`; `isEqual` reads it like an array. */
+export declare function isArguments(x: unknown): x is IArguments;
+/** The primitive inside a wrapper object such as `new Number(1)`; ordinary non-wrappers unchanged. */
+export declare function unbox(x: unknown): unknown;
+/**
+ * The kinds a deep walk copies, compares or hashes by content. `other` covers class instances,
+ * functions, errors, `arguments`, promises, weak collections and every other object: walks keep
+ * those by reference. `isEqual` and `hash` also read errors and `arguments` by content; see
+ * {@link isError} and {@link isArguments}.
+ */
+export type Kind = 'plain' | 'array' | 'map' | 'set' | 'date' | 'regexp' | 'view' | 'buffer' | 'boxed' | 'other';
+/** The {@link Kind} of `value`. */
+export declare function kindOf(value: object): Kind;
+/** {@link Kind}, with the two `other` kinds `isEqual` and `hash` also read by content. */
+export type ContentKind = Kind | 'error' | 'arguments';
+/** The {@link ContentKind} of `value`: what `isEqual` compares and `hash` hashes it by. */
+export declare function contentKindOf(value: object): ContentKind;
+/** The bytes a view covers, without copying. Throws for a detached or out-of-bounds view. */
+export declare function viewBytes(view: ArrayBufferView): Uint8Array;
+/** The bytes of a buffer or view. A detached or out-of-bounds one has none. */
+export declare function bytesOf(value: ArrayBuffer | SharedArrayBuffer | ArrayBufferView): Uint8Array;
+/** Whether `view` holds floats, which compare by element (`0` equals `-0`) and not by byte. */
+export declare function isFloatView(view: ArrayBufferView): view is Float16Array | Float32Array | Float64Array;
+/**
+ * A typed array's type name, such as `'Float64Array'`, from any realm, or `undefined` for anything
+ * else, a `DataView` included. It never throws.
+ */
+export declare function typedArrayName(x: object): string | undefined;
+/** A typed array's element count (0 when detached), or `undefined` for other objects. */
+export declare function typedArrayLength(x: object): number | undefined;
+export declare function mapSize(map: Map<unknown, unknown>): number;
+export declare function setSize(set: Set<unknown>): number;
+/**
+ * Whether `a` and `b` share one prototype chain, or twin chains from two realms (each prototype
+ * named like its counterpart). Null-prototype objects count as `Object.prototype`.
+ */
+export declare function sameClass(a: object, b: object): boolean;

package/dist/internal/kind.js

@@ -0,0 +1,139 @@
+/**
+ * The built-in kinds a deep walk handles, including values from other realms.
+ */
+import { isError } from '../is/isError.js';
+import { isPlainObject } from '../is/isPlainObject.js';
+function getterOf(prototype, key) {
+    const get = Object.getOwnPropertyDescriptor(prototype, key)?.get;
+    if (get === undefined)
+        throw new TypeError(`no getter for ${String(key)}`);
+    return get;
+}
+/** A native `Map`, from any realm. */
+export function isMap(x) {
+    return Object.prototype.toString.call(x) === '[object Map]';
+}
+/** A native `Set`, from any realm. */
+export function isSet(x) {
+    return Object.prototype.toString.call(x) === '[object Set]';
+}
+/** An `arguments` object, from any realm. `kindOf` calls it `other`; `isEqual` reads it like an array. */
+export function isArguments(x) {
+    return Object.prototype.toString.call(x) === '[object Arguments]';
+}
+const UNBOXERS = new Map([
+    ['[object Number]', (box) => Reflect.apply(Number.prototype.valueOf, box, [])],
+    ['[object String]', (box) => Reflect.apply(String.prototype.valueOf, box, [])],
+    ['[object Boolean]', (box) => Reflect.apply(Boolean.prototype.valueOf, box, [])],
+    ['[object BigInt]', (box) => Reflect.apply(BigInt.prototype.valueOf, box, [])],
+    ['[object Symbol]', (box) => Reflect.apply(Symbol.prototype.valueOf, box, [])]
+]);
+/** The primitive inside a wrapper object such as `new Number(1)`; ordinary non-wrappers unchanged. */
+export function unbox(x) {
+    if (typeof x !== 'object' || x === null)
+        return x;
+    return UNBOXERS.get(Object.prototype.toString.call(x))?.(x) ?? x;
+}
+/** The {@link Kind} of `value`. */
+export function kindOf(value) {
+    if (Array.isArray(value))
+        return 'array';
+    if (isPlainObject(value))
+        return 'plain';
+    if (ArrayBuffer.isView(value))
+        return 'view';
+    const tag = Object.prototype.toString.call(value);
+    switch (tag) {
+        case '[object Date]':
+            return 'date';
+        case '[object RegExp]':
+            return 'regexp';
+        case '[object Map]':
+            return 'map';
+        case '[object Set]':
+            return 'set';
+        case '[object ArrayBuffer]':
+        case '[object SharedArrayBuffer]':
+            return 'buffer';
+    }
+    if (UNBOXERS.has(tag))
+        return 'boxed';
+    return 'other';
+}
+/** The {@link ContentKind} of `value`: what `isEqual` compares and `hash` hashes it by. */
+export function contentKindOf(value) {
+    const kind = kindOf(value);
+    if (kind !== 'other')
+        return kind;
+    if (isError(value))
+        return 'error';
+    return isArguments(value) ? 'arguments' : 'other';
+}
+/** `%TypedArray%.prototype`, which holds the getters every typed array shares. */
+const TYPED_ARRAY_PROTOTYPE = Object.getPrototypeOf(Uint8Array.prototype);
+/** `%TypedArray%.prototype[Symbol.toStringTag]`: a typed array's type name, else `undefined`. */
+const TYPED_ARRAY_NAME = getterOf(TYPED_ARRAY_PROTOTYPE, Symbol.toStringTag);
+/** The bytes a view covers, without copying. Throws for a detached or out-of-bounds view. */
+export function viewBytes(view) {
+    return new Uint8Array(view.buffer, view.byteOffset, view.byteLength);
+}
+/** The bytes of a buffer or view. A detached or out-of-bounds one has none. */
+export function bytesOf(value) {
+    try {
+        return ArrayBuffer.isView(value) ? viewBytes(value) : new Uint8Array(value);
+    }
+    catch {
+        return new Uint8Array(0);
+    }
+}
+const FLOAT_ARRAY_NAMES = new Set([
+    'Float16Array',
+    'Float32Array',
+    'Float64Array'
+]);
+/** Whether `view` holds floats, which compare by element (`0` equals `-0`) and not by byte. */
+export function isFloatView(view) {
+    return FLOAT_ARRAY_NAMES.has(Reflect.apply(TYPED_ARRAY_NAME, view, []));
+}
+/**
+ * A typed array's type name, such as `'Float64Array'`, from any realm, or `undefined` for anything
+ * else, a `DataView` included. It never throws.
+ */
+export function typedArrayName(x) {
+    return Reflect.apply(TYPED_ARRAY_NAME, x, []);
+}
+/** A typed array's element count (0 when detached), or `undefined` for other objects. */
+export function typedArrayLength(x) {
+    if (typedArrayName(x) === undefined)
+        return undefined;
+    return x.length;
+}
+export function mapSize(map) {
+    return map.size;
+}
+export function setSize(set) {
+    return set.size;
+}
+function classNameOf(prototype) {
+    const name = prototype.constructor?.name;
+    return typeof name === 'string' ? name : undefined;
+}
+function areTwins(x, y) {
+    const name = classNameOf(x);
+    return x !== y && name !== undefined && name === classNameOf(y);
+}
+/**
+ * Whether `a` and `b` share one prototype chain, or twin chains from two realms (each prototype
+ * named like its counterpart). Null-prototype objects count as `Object.prototype`.
+ */
+export function sameClass(a, b) {
+    let x = Object.getPrototypeOf(a) ?? Object.prototype;
+    let y = Object.getPrototypeOf(b) ?? Object.prototype;
+    if (x === y)
+        return true;
+    while (x !== null && y !== null && areTwins(x, y)) {
+        x = Object.getPrototypeOf(x);
+        y = Object.getPrototypeOf(y);
+    }
+    return x === null && y === null;
+}

package/dist/internal/sparse.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Sparse-array helpers for own enumerable indices, with hole-run events.
+ */
+/** ECMAScript canonical array index name (0 .. 2^32-2). */
+export declare function isCanonicalArrayIndex(key: string): boolean;
+/** Own enumerable array indices at or after `start`, in `Object.keys` order. */
+export declare function arrayIndicesFrom(arr: readonly unknown[], start: number): number[];
+/** A present index, or a contiguous hole run `[start, end)`. */
+export type ArrayWalkEvent = {
+    readonly kind: 'value';
+    readonly index: number;
+    readonly value: unknown;
+} | {
+    readonly kind: 'holeRun';
+    readonly start: number;
+    readonly end: number;
+};
+export type ArrayIndexWalkEvent = {
+    readonly kind: 'index';
+    readonly index: number;
+} | {
+    readonly kind: 'holeRun';
+    readonly start: number;
+    readonly end: number;
+};
+/** Holes a walk may visit one by one, beyond one per element seen, before it takes Object.keys. */
+export declare const HOLE_STREAK_BEFORE_KEYS = 256;
+/**
+ * Walk the own enumerable indices of `arr` (the set `Object.keys` lists) without expanding huge
+ * hole runs index-by-index. Inherited and non-enumerable indices are holes.
+ * Dense indices are checked one by one. 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 walkArrayIndices(arr: readonly unknown[], visit: (event: ArrayIndexWalkEvent) => false | undefined): void;
+/** Like {@link walkArrayIndices}, with the value at each index. */
+export declare function walkArray(arr: readonly unknown[], visit: (event: ArrayWalkEvent) => false | undefined): void;
+/** Absolute length below which per-index consumers never treat an array as huge-sparse. */
+export declare const HUGE_SPARSE_MIN_LENGTH: number;
+/**
+ * True when `arr.length` is above {@link HUGE_SPARSE_MIN_LENGTH} and also exceeds
+ * `2 * ownIndexCount + 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 through {@link walkArrayIndices}; a dense array stops as soon as its own indices prove
+ * it cannot qualify.
+ */
+export declare function isHugeSparse(arr: readonly unknown[]): boolean;
+/** Throw when `arr` is a huge sparse array that must not be expanded per-index. */
+export declare function assertNotHugeSparse(arr: readonly unknown[]): void;

package/dist/internal/sparse.js

@@ -0,0 +1,104 @@
+/**
+ * Sparse-array helpers for own enumerable indices, with hole-run events.
+ */
+/** ECMAScript canonical array index name (0 .. 2^32-2). */
+export function isCanonicalArrayIndex(key) {
+    return /^(0|[1-9]\d*)$/.test(key) && Number(key) <= 0xffff_fffe;
+}
+/** Own enumerable array indices at or after `start`, in `Object.keys` order. */
+export function arrayIndicesFrom(arr, start) {
+    const indices = [];
+    for (const key of Object.keys(arr)) {
+        if (!isCanonicalArrayIndex(key))
+            continue;
+        const index = Number(key);
+        if (index >= start)
+            indices.push(index);
+    }
+    return indices;
+}
+/** Holes a walk may visit one by one, beyond one per element seen, before it takes Object.keys. */
+export const HOLE_STREAK_BEFORE_KEYS = 256;
+const isOwnEnumerable = Object.prototype.propertyIsEnumerable;
+/**
+ * Walk the own enumerable indices of `arr` (the set `Object.keys` lists) without expanding huge
+ * hole runs index-by-index. Inherited and non-enumerable indices are holes.
+ * Dense indices are checked one by one. 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 walkArrayIndices(arr, visit) {
+    const len = arr.length;
+    let i = 0;
+    let elements = 0;
+    let holes = 0;
+    while (i < len) {
+        if (isOwnEnumerable.call(arr, i)) {
+            if (visit({ kind: 'index', index: i }) === false)
+                return;
+            i++;
+            elements++;
+            continue;
+        }
+        const holeStart = i;
+        while (i < len && !isOwnEnumerable.call(arr, i) && holes < HOLE_STREAK_BEFORE_KEYS + elements) {
+            i++;
+            holes++;
+        }
+        if (holes >= HOLE_STREAK_BEFORE_KEYS + elements && i < len) {
+            const rest = arrayIndicesFrom(arr, i);
+            let cursor = holeStart;
+            for (const idx of rest) {
+                if (idx > cursor && visit({ kind: 'holeRun', start: cursor, end: idx }) === false)
+                    return;
+                if (visit({ kind: 'index', index: idx }) === false)
+                    return;
+                cursor = idx + 1;
+            }
+            if (cursor < len)
+                visit({ kind: 'holeRun', start: cursor, end: len });
+            return;
+        }
+        if (visit({ kind: 'holeRun', start: holeStart, end: i }) === false)
+            return;
+    }
+}
+/** Like {@link walkArrayIndices}, with the value at each index. */
+export function walkArray(arr, visit) {
+    walkArrayIndices(arr, (event) => visit(event.kind === 'index'
+        ? { kind: 'value', index: event.index, value: arr[event.index] }
+        : event));
+}
+/** Absolute length below which per-index consumers never treat an array as huge-sparse. */
+export const HUGE_SPARSE_MIN_LENGTH = 2 ** 24;
+/**
+ * True when `arr.length` is above {@link HUGE_SPARSE_MIN_LENGTH} and also exceeds
+ * `2 * ownIndexCount + 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 through {@link walkArrayIndices}; a dense array stops as soon as its own indices prove
+ * it cannot qualify.
+ */
+export function isHugeSparse(arr) {
+    const len = arr.length;
+    if (len <= HUGE_SPARSE_MIN_LENGTH)
+        return false;
+    // own > (len - 1024) / 2  =>  len < 2 * own + 1024, so the final test is false: stop there.
+    const denseOwn = (len - 1024) / 2;
+    let own = 0;
+    walkArrayIndices(arr, (ev) => {
+        if (ev.kind !== 'index')
+            return;
+        own++;
+        if (own > denseOwn)
+            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/internal/text.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Text helpers shared by the `fns/string` modules.
+ */
+/** Lodash `toString`: `null` and `undefined` become `''`, anything else goes through `String`. */
+export declare function toText(value: unknown): string;
+/** Whether every UTF-16 code unit of `s` is ASCII. */
+export declare function isAsciiString(s: string): boolean;

package/dist/internal/text.js

@@ -0,0 +1,15 @@
+/**
+ * Text helpers shared by the `fns/string` modules.
+ */
+/** Lodash `toString`: `null` and `undefined` become `''`, anything else goes through `String`. */
+export function toText(value) {
+    return value == null ? '' : String(value);
+}
+/** Whether every UTF-16 code unit of `s` is ASCII. */
+export function isAsciiString(s) {
+    for (let i = 0; i < s.length; i++) {
+        if (s.charCodeAt(i) > 0x7f)
+            return false;
+    }
+    return true;
+}

package/dist/internal/timer.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Timer waits shared by `fns/function` and `fns/async`.
+ */
+/** Inclusive max for `setTimeout` delays (signed 32-bit). */
+export declare const MAX_TIMER_WAIT_MS = 2147483647;
+/**
+ * Checks a timer wait: throws `TypeError` for a non-number, `RangeError` for NaN, infinity or
+ * values past the timer range, and clamps a negative wait to 0.
+ */
+export declare function timerWait(wait: number, name: string): number;

package/dist/internal/timer.js

@@ -0,0 +1,17 @@
+/**
+ * Timer waits shared by `fns/function` and `fns/async`.
+ */
+/** Inclusive max for `setTimeout` delays (signed 32-bit). */
+export const MAX_TIMER_WAIT_MS = 2_147_483_647;
+/**
+ * Checks a timer wait: throws `TypeError` for a non-number, `RangeError` for NaN, infinity or
+ * values past the timer range, and clamps a negative wait to 0.
+ */
+export function timerWait(wait, name) {
+    if (typeof wait !== 'number')
+        throw new TypeError(`${name} must be a number, got ${typeof wait}`);
+    if (!Number.isFinite(wait) || wait > MAX_TIMER_WAIT_MS) {
+        throw new RangeError(`${name} must be between 0 and ${MAX_TIMER_WAIT_MS} ms`);
+    }
+    return Math.max(wait, 0);
+}

package/dist/internal/truncate.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Short, bounded echoes of caller strings for error messages.
+ */
+/**
+ * `value` for an error message: its first {@link MAX_ECHO} UTF-16 code units, cut on a code point
+ * boundary, then JSON-encoded, plus `...` when cut. Only the kept prefix is encoded, so a huge
+ * string never pays a full encode. Encoding escapes control characters, so a message never embeds
+ * a raw newline from caller input; an escape takes more than one unit of the result.
+ */
+export declare function truncateForError(value: string): string;

package/dist/internal/truncate.js

@@ -0,0 +1,22 @@
+/**
+ * Short, bounded echoes of caller strings for error messages.
+ */
+/** UTF-16 units of caller input an error message repeats. */
+const MAX_ECHO = 40;
+/**
+ * `value` for an error message: its first {@link MAX_ECHO} UTF-16 code units, cut on a code point
+ * boundary, then JSON-encoded, plus `...` when cut. Only the kept prefix is encoded, so a huge
+ * string never pays a full encode. Encoding escapes control characters, so a message never embeds
+ * a raw newline from caller input; an escape takes more than one unit of the result.
+ */
+export function truncateForError(value) {
+    if (value.length <= MAX_ECHO)
+        return JSON.stringify(value);
+    let end = 0;
+    for (const ch of value) {
+        if (end + ch.length > MAX_ECHO)
+            break;
+        end += ch.length;
+    }
+    return `${JSON.stringify(value.slice(0, end))}...`;
+}

package/dist/internal/walk.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Depth and cycle guards shared by the deep walks (`isEqual`, `cloneDeep`, `merge`, `defaultsDeep`,
+ * `omit`, `flattenObject`, `stableStringify`, `isMatch`, `matches`).
+ */
+/** Deepest nesting a walk follows before it throws. */
+export declare const MAX_DEPTH = 1000;
+/** Message of the `RangeError` a walk throws past {@link MAX_DEPTH}. */
+export declare const DEPTH_ERROR: string;
+/**
+ * Go one level deeper. Throws `RangeError` past {@link MAX_DEPTH}. Pair it with {@link exitDepth}
+ * in a `finally` at the recursion site.
+ */
+export declare function enterDepth(): void;
+/** Come back up one level. Must follow its {@link enterDepth}. */
+export declare function exitDepth(): void;
+/**
+ * Run the outermost call of a walk. An engine stack overflow inside it, which a deep walk can still
+ * hit on a small stack, becomes the same `RangeError` as {@link enterDepth} throws, and the depth
+ * count is reset. A call made while another walk runs (a customizer that calls `isEqual`) just
+ * runs `fn`.
+ */
+export declare function guardDepth<T>(fn: () => T): T;
+/**
+ * The objects on the path from the root of a walk to where it is now, so a walk can tell a cycle
+ * from an object that is merely shared.
+ */
+export declare class Ancestors {
+    #private;
+    /** Whether `obj` is on the current path. */
+    has(obj: object): boolean;
+    /** Step into `obj`, one level deeper; throws `RangeError` past {@link MAX_DEPTH}. */
+    enter(obj: object): void;
+    /** Step back out of `obj`. */
+    leave(obj: object): void;
+}
+/**
+ * A budget for walks that expand shared containers again (`merge` copies a shared row once per
+ * place it appears). A first expansion of a container is free; each later one costs one unit per
+ * 16 keys, rounded up, with a minimum of one unit even for an empty container. The walk throws
+ * `RangeError(message)` once it has spent more than `limit` units.
+ */
+export declare class RevisitBudget {
+    #private;
+    constructor(limit: number, message: string);
+    /** Record that `obj`, holding `keys` own keys, is being expanded. */
+    note(obj: object, keys: number): void;
+}

package/dist/internal/walk.js

@@ -0,0 +1,100 @@
+/**
+ * Depth and cycle guards shared by the deep walks (`isEqual`, `cloneDeep`, `merge`, `defaultsDeep`,
+ * `omit`, `flattenObject`, `stableStringify`, `isMatch`, `matches`).
+ */
+/** Deepest nesting a walk follows before it throws. */
+export const MAX_DEPTH = 1000;
+/** Message of the `RangeError` a walk throws past {@link MAX_DEPTH}. */
+export const DEPTH_ERROR = `nesting deeper than ${String(MAX_DEPTH)} levels`;
+/** Shared by every running walk, so a walk that re-enters another one keeps counting. */
+let depth = 0;
+/**
+ * Go one level deeper. Throws `RangeError` past {@link MAX_DEPTH}. Pair it with {@link exitDepth}
+ * in a `finally` at the recursion site.
+ */
+export function enterDepth() {
+    if (depth >= MAX_DEPTH)
+        throw new RangeError(DEPTH_ERROR);
+    depth++;
+}
+/** Come back up one level. Must follow its {@link enterDepth}. */
+export function exitDepth() {
+    depth--;
+}
+function isStackOverflow(e) {
+    if (!(e instanceof Error))
+        return false;
+    if (e instanceof RangeError)
+        return e.message.includes('Maximum call stack size exceeded');
+    return e.name === 'InternalError' && e.message.includes('too much recursion');
+}
+/**
+ * Run the outermost call of a walk. An engine stack overflow inside it, which a deep walk can still
+ * hit on a small stack, becomes the same `RangeError` as {@link enterDepth} throws, and the depth
+ * count is reset. A call made while another walk runs (a customizer that calls `isEqual`) just
+ * runs `fn`.
+ */
+export function guardDepth(fn) {
+    if (depth !== 0)
+        return fn();
+    try {
+        return fn();
+    }
+    catch (e) {
+        if (isStackOverflow(e))
+            throw new RangeError(DEPTH_ERROR, { cause: e });
+        throw e;
+    }
+    finally {
+        depth = 0;
+    }
+}
+/**
+ * The objects on the path from the root of a walk to where it is now, so a walk can tell a cycle
+ * from an object that is merely shared.
+ */
+export class Ancestors {
+    #open = new Set();
+    /** Whether `obj` is on the current path. */
+    has(obj) {
+        return this.#open.has(obj);
+    }
+    /** Step into `obj`, one level deeper; throws `RangeError` past {@link MAX_DEPTH}. */
+    enter(obj) {
+        enterDepth();
+        this.#open.add(obj);
+    }
+    /** Step back out of `obj`. */
+    leave(obj) {
+        exitDepth();
+        this.#open.delete(obj);
+    }
+}
+/** Keys one work unit covers, so a wide container weighs what it copies. */
+const KEYS_PER_WORK_UNIT = 16;
+/**
+ * A budget for walks that expand shared containers again (`merge` copies a shared row once per
+ * place it appears). A first expansion of a container is free; each later one costs one unit per
+ * 16 keys, rounded up, with a minimum of one unit even for an empty container. The walk throws
+ * `RangeError(message)` once it has spent more than `limit` units.
+ */
+export class RevisitBudget {
+    #limit;
+    #message;
+    #seen = new WeakSet();
+    #spent = 0;
+    constructor(limit, message) {
+        this.#limit = limit;
+        this.#message = message;
+    }
+    /** Record that `obj`, holding `keys` own keys, is being expanded. */
+    note(obj, keys) {
+        if (!this.#seen.has(obj)) {
+            this.#seen.add(obj);
+            return;
+        }
+        this.#spent += Math.max(1, Math.ceil(keys / KEYS_PER_WORK_UNIT));
+        if (this.#spent > this.#limit)
+            throw new RangeError(this.#message);
+    }
+}

package/dist/is/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Type checks the platform does not have in one call.
+ * @module is
+ */
+export { isArrayLike } from './isArrayLike.js';
+export { isError } from './isError.js';
+export { isNil } from './isNil.js';
+export { isPlainObject } from './isPlainObject.js';

package/dist/is/index.js

@@ -0,0 +1,8 @@
+/**
+ * Type checks the platform does not have in one call.
+ * @module is
+ */
+export { isArrayLike } from './isArrayLike.js';
+export { isError } from './isError.js';
+export { isNil } from './isNil.js';
+export { isPlainObject } from './isPlainObject.js';

package/dist/is/isArrayLike.d.ts

@@ -0,0 +1,18 @@
+/**
+ * True for a value with a `length` that is a non-negative safe integer, as lodash's `isArrayLike`
+ * decides and the generic `Array.prototype` methods (`Array.prototype.slice.call`) read by index:
+ * arrays, strings, typed arrays, `arguments` and objects like `{ length: 2 }`. Functions are not
+ * array-like, though they have a `length`.
+ * The guard is one-sided: `false` does not rule out a `{ length: number }` type.
+ * @param value Any value.
+ * @returns Whether `value` is array-like.
+ * @example
+ * ```ts
+ * isArrayLike([1, 2]) // true
+ * isArrayLike('abc') // true
+ * isArrayLike({ length: 1, 0: 'a' }) // true
+ * isArrayLike({ length: -1 }) // false
+ * isArrayLike(() => {}) // false
+ * ```
+ */
+export declare function isArrayLike(value: unknown): value is ArrayLike<unknown>;

package/dist/is/isArrayLike.js

@@ -0,0 +1,25 @@
+/**
+ * True for a value with a `length` that is a non-negative safe integer, as lodash's `isArrayLike`
+ * decides and the generic `Array.prototype` methods (`Array.prototype.slice.call`) read by index:
+ * arrays, strings, typed arrays, `arguments` and objects like `{ length: 2 }`. Functions are not
+ * array-like, though they have a `length`.
+ * The guard is one-sided: `false` does not rule out a `{ length: number }` type.
+ * @param value Any value.
+ * @returns Whether `value` is array-like.
+ * @example
+ * ```ts
+ * isArrayLike([1, 2]) // true
+ * isArrayLike('abc') // true
+ * isArrayLike({ length: 1, 0: 'a' }) // true
+ * isArrayLike({ length: -1 }) // false
+ * isArrayLike(() => {}) // false
+ * ```
+ */
+export function isArrayLike(value) {
+    if (typeof value === 'string')
+        return true;
+    if (value === null || typeof value !== 'object' || !('length' in value))
+        return false;
+    const { length } = value;
+    return typeof length === 'number' && Number.isSafeInteger(length) && length >= 0;
+}

package/dist/is/isError.d.ts

@@ -0,0 +1,13 @@
+/**
+ * True for an error from any realm, as `Error.isError` decides. Where the runtime lacks
+ * `Error.isError`, the object tag decides; `DOMException` is not recognized by this fallback.
+ * Removed once `Error.isError` is Baseline.
+ * @param value Any value.
+ * @returns Whether `value` is an error.
+ * @example
+ * ```ts
+ * isError(new TypeError('x')) // true
+ * isError({ name: 'Error', message: 'x' }) // false
+ * ```
+ */
+export declare function isError(value: unknown): value is Error;