atomic-fns 1.2.0 → 2.0.0

package/dist/hash/stableStringify.js

@@ -0,0 +1,102 @@
+import { unbox } from '../internal/kind.js';
+import { assertNotHugeSparse } from '../internal/sparse.js';
+import { Ancestors, guardDepth } from '../internal/walk.js';
+/**
+ * The value JSON writes for `holder[key]`: through `toJSON`, then unboxed. JSON unboxes numbers,
+ * strings, booleans and bigints but writes a boxed symbol as an object.
+ */
+function jsonValue(holder, key) {
+    let value = holder[key];
+    if ((typeof value === 'object' && value !== null) ||
+        typeof value === 'function' ||
+        typeof value === 'bigint') {
+        const toJSON = value.toJSON;
+        if (typeof toJSON === 'function')
+            value = toJSON.call(value, key);
+    }
+    if (typeof value !== 'object' || value === null)
+        return value;
+    const primitive = unbox(value);
+    return typeof primitive === 'symbol' ? value : primitive;
+}
+function write(value, path, out) {
+    switch (typeof value) {
+        case 'string':
+            out.push(JSON.stringify(value));
+            return true;
+        case 'number':
+            out.push(Number.isFinite(value) ? String(value) : 'null');
+            return true;
+        case 'boolean':
+            out.push(value ? 'true' : 'false');
+            return true;
+        case 'bigint':
+            throw new TypeError('stableStringify cannot serialize a bigint');
+        case 'object':
+            if (value === null) {
+                out.push('null');
+                return true;
+            }
+            break;
+        default:
+            return false;
+    }
+    if (path.has(value))
+        throw new TypeError('stableStringify cannot serialize a cyclic structure');
+    path.enter(value);
+    try {
+        if (Array.isArray(value)) {
+            assertNotHugeSparse(value);
+            const length = value.length;
+            out.push('[');
+            for (let i = 0; i < length; i++) {
+                if (i > 0)
+                    out.push(',');
+                if (!write(jsonValue(value, String(i)), path, out)) {
+                    out.push('null');
+                }
+            }
+            out.push(']');
+            return true;
+        }
+        const record = value;
+        out.push('{');
+        let first = true;
+        for (const key of Object.keys(record).sort()) {
+            const mark = out.length;
+            out.push(first ? '' : ',', JSON.stringify(key), ':');
+            if (write(jsonValue(record, key), path, out))
+                first = false;
+            else
+                out.length = mark;
+        }
+        out.push('}');
+        return true;
+    }
+    finally {
+        path.leave(value);
+    }
+}
+/**
+ * `JSON.stringify` with every object's keys sorted, so equal data always gives the same text (for
+ * cache keys, signatures and snapshots). It follows `JSON.stringify` otherwise. A value's own or
+ * inherited `toJSON` is called with its key, as JSON's contract has it, so Dates write their ISO
+ * string and types such as `Decimal` write their JSON form. Boxed primitives unbox, `undefined`,
+ * functions and symbols are dropped from objects and become `null` in arrays, and non-finite
+ * numbers become `null`. A cycle or a bigint throws `TypeError`, nesting past 1000 levels throws
+ * `RangeError`, and so does a huge sparse array. As in JSON, a `Map`, a `Set` or a class instance
+ * without `toJSON` writes only its own enumerable keys, often `'{}'`, so equal text does not imply
+ * equal data for those kinds.
+ * @param value Any value.
+ * @returns The JSON text, or `undefined` for a value JSON cannot write (`undefined`, a function, a
+ * symbol).
+ * @example
+ * ```ts
+ * stableStringify({ b: 1, a: [true, { d: 2, c: 3 }] }) // '{"a":[true,{"c":3,"d":2}],"b":1}'
+ * ```
+ */
+export function stableStringify(value) {
+    const out = [];
+    const ok = guardDepth(() => write(jsonValue({ '': value }, ''), new Ancestors(), out));
+    return ok ? out.join('') : undefined;
+}

package/dist/id/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Unique ids: a process counter, random and time-ordered UUIDs, and nanoids.
+ * @module id
+ */
+export { nanoid } from './nanoid.js';
+export { uniqueId } from './uniqueId.js';
+export { uuid, uuidv7 } from './uuid.js';

package/dist/id/index.js

@@ -0,0 +1,7 @@
+/**
+ * Unique ids: a process counter, random and time-ordered UUIDs, and nanoids.
+ * @module id
+ */
+export { nanoid } from './nanoid.js';
+export { uniqueId } from './uniqueId.js';
+export { uuid, uuidv7 } from './uuid.js';

package/dist/id/nanoid.d.ts

@@ -0,0 +1,16 @@
+/**
+ * A random id of `size` characters from `alphabet`, as the `nanoid` package makes them: each
+ * character is drawn without bias through `crypto.getRandomValues`. The default is 21 URL-safe
+ * characters, about as collision-resistant as a v4 UUID.
+ * @param size Characters in the id, an integer from 1 to 1024 (default 21); else `TypeError` for a
+ * non-number and `RangeError` for any other value.
+ * @param alphabet Characters to draw from: a well-formed string of 2 to 256 distinct code points
+ * (default `A-Za-z0-9_-`); else `TypeError` for a non-string and `RangeError` for any other value.
+ * @returns The id.
+ * @example
+ * ```ts
+ * nanoid() // 'V1StGXR8_Z5jdHi6B-myT'
+ * nanoid(8, '0123456789') // '48105763'
+ * ```
+ */
+export declare function nanoid(size?: number, alphabet?: string): string;

package/dist/id/nanoid.js

@@ -0,0 +1,65 @@
+import { randomBytes } from '../internal/crypto.js';
+const URL_ALPHABET = 'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict';
+const URL_SYMBOLS = [...URL_ALPHABET];
+/** Longest id {@link nanoid} makes, so a size from input cannot allocate without bound. */
+const MAX_SIZE = 1024;
+/** Most code points an alphabet may hold, since each draw indexes it with one random byte. */
+const MAX_SYMBOLS = 256;
+/** The code points of `alphabet`, or an error for an alphabet {@link nanoid} cannot draw from. */
+function symbolsOf(alphabet) {
+    if (typeof alphabet !== 'string')
+        throw new TypeError('alphabet must be a string');
+    if (alphabet === URL_ALPHABET)
+        return URL_SYMBOLS;
+    if (!alphabet.isWellFormed())
+        throw new RangeError('alphabet must not hold lone surrogates');
+    const outOfRange = `alphabet must hold 2 to ${String(MAX_SYMBOLS)} distinct characters`;
+    // A code point is one or two UTF-16 units, so a longer string holds too many to spread.
+    if (alphabet.length > 2 * MAX_SYMBOLS)
+        throw new RangeError(outOfRange);
+    const symbols = [...alphabet];
+    if (symbols.length < 2 ||
+        symbols.length > MAX_SYMBOLS ||
+        new Set(symbols).size !== symbols.length) {
+        throw new RangeError(outOfRange);
+    }
+    return symbols;
+}
+/**
+ * A random id of `size` characters from `alphabet`, as the `nanoid` package makes them: each
+ * character is drawn without bias through `crypto.getRandomValues`. The default is 21 URL-safe
+ * characters, about as collision-resistant as a v4 UUID.
+ * @param size Characters in the id, an integer from 1 to 1024 (default 21); else `TypeError` for a
+ * non-number and `RangeError` for any other value.
+ * @param alphabet Characters to draw from: a well-formed string of 2 to 256 distinct code points
+ * (default `A-Za-z0-9_-`); else `TypeError` for a non-string and `RangeError` for any other value.
+ * @returns The id.
+ * @example
+ * ```ts
+ * nanoid() // 'V1StGXR8_Z5jdHi6B-myT'
+ * nanoid(8, '0123456789') // '48105763'
+ * ```
+ */
+export function nanoid(size = 21, alphabet = URL_ALPHABET) {
+    if (typeof size !== 'number')
+        throw new TypeError('size must be a number');
+    if (!Number.isInteger(size) || size < 1 || size > MAX_SIZE) {
+        throw new RangeError(`size must be an integer from 1 to ${String(MAX_SIZE)}`);
+    }
+    const symbols = symbolsOf(alphabet);
+    const mask = (2 << (31 - Math.clz32((symbols.length - 1) | 1))) - 1;
+    const batch = Math.ceil((1.6 * mask * size) / symbols.length);
+    let id = '';
+    let length = 0;
+    while (length < size) {
+        for (const byte of randomBytes(batch)) {
+            const index = byte & mask;
+            if (index < symbols.length) {
+                id += symbols[index];
+                if (++length === size)
+                    return id;
+            }
+        }
+    }
+    return id;
+}

package/dist/id/uniqueId.d.ts

@@ -0,0 +1,14 @@
+/**
+ * The next id from one realm-wide counter, as a decimal string: '1', '2', and so on.
+ * Every copy of atomic-fns loaded in this realm shares the counter. Each worker and each
+ * process counts on its own, so ids repeat across them; use {@link uuid} for that.
+ * Takes no parameters. Like `crypto.randomUUID`, it ignores any arguments passed at runtime,
+ * including a lodash-style prefix argument. Add a prefix with a template string instead.
+ * @returns The next id as a decimal string.
+ * @example
+ * ```ts
+ * uniqueId() // '1'
+ * `user_${uniqueId()}` // 'user_2'
+ * ```
+ */
+export declare function uniqueId(): string;

package/dist/id/uniqueId.js

@@ -0,0 +1,20 @@
+const slot = Symbol.for('atomic-fns.uniqueId');
+const realm = globalThis;
+/**
+ * The next id from one realm-wide counter, as a decimal string: '1', '2', and so on.
+ * Every copy of atomic-fns loaded in this realm shares the counter. Each worker and each
+ * process counts on its own, so ids repeat across them; use {@link uuid} for that.
+ * Takes no parameters. Like `crypto.randomUUID`, it ignores any arguments passed at runtime,
+ * including a lodash-style prefix argument. Add a prefix with a template string instead.
+ * @returns The next id as a decimal string.
+ * @example
+ * ```ts
+ * uniqueId() // '1'
+ * `user_${uniqueId()}` // 'user_2'
+ * ```
+ */
+export function uniqueId() {
+    const state = (realm[slot] ??= { counter: 0 });
+    state.counter++;
+    return String(state.counter);
+}

package/dist/id/uuid.d.ts

@@ -0,0 +1,25 @@
+/**
+ * A random (version 4) UUID, from `crypto.randomUUID` where the runtime has it (secure contexts) and
+ * from `crypto.getRandomValues` elsewhere. Throws `TypeError` where neither exists.
+ * @returns A lowercase UUID string.
+ * @example
+ * ```ts
+ * uuid() // '0b5e1f9c-8a5d-4f8e-9b8a-2a8f6a1c3d4e'
+ * ```
+ */
+export declare function uuid(): string;
+/**
+ * A time-ordered (version 7) UUID, RFC 9562: 48 bits of Unix milliseconds, then a 12-bit sequence
+ * and 62 random bits, so ids sort by creation time as strings and as bytes. Ids made in one
+ * millisecond, or while the clock steps back, count up the sequence from a random start, so they
+ * still sort in the order this process made them: they keep the last timestamp, and when its
+ * sequence runs out they borrow the next millisecond (RFC 9562 section 6.2), so the timestamp can
+ * run ahead of the clock. Throws `TypeError` without Web Crypto.
+ * @returns A lowercase UUID string.
+ * @example
+ * ```ts
+ * const [a, b] = [uuidv7(), uuidv7()]
+ * a < b // true
+ * ```
+ */
+export declare function uuidv7(): string;

package/dist/id/uuid.js

@@ -0,0 +1,64 @@
+import { bytesToHex } from '../internal/bytes.js';
+import { randomBytes } from '../internal/crypto.js';
+function format(bytes) {
+    const hex = bytesToHex(bytes);
+    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+}
+/**
+ * A random (version 4) UUID, from `crypto.randomUUID` where the runtime has it (secure contexts) and
+ * from `crypto.getRandomValues` elsewhere. Throws `TypeError` where neither exists.
+ * @returns A lowercase UUID string.
+ * @example
+ * ```ts
+ * uuid() // '0b5e1f9c-8a5d-4f8e-9b8a-2a8f6a1c3d4e'
+ * ```
+ */
+export function uuid() {
+    const crypto = globalThis.crypto;
+    if (typeof crypto?.randomUUID === 'function')
+        return crypto.randomUUID();
+    const bytes = randomBytes(16);
+    bytes[6] = (bytes[6] & 0x0f) | 0x40;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    return format(bytes);
+}
+let lastTime = -1;
+let sequence = 0;
+/**
+ * A time-ordered (version 7) UUID, RFC 9562: 48 bits of Unix milliseconds, then a 12-bit sequence
+ * and 62 random bits, so ids sort by creation time as strings and as bytes. Ids made in one
+ * millisecond, or while the clock steps back, count up the sequence from a random start, so they
+ * still sort in the order this process made them: they keep the last timestamp, and when its
+ * sequence runs out they borrow the next millisecond (RFC 9562 section 6.2), so the timestamp can
+ * run ahead of the clock. Throws `TypeError` without Web Crypto.
+ * @returns A lowercase UUID string.
+ * @example
+ * ```ts
+ * const [a, b] = [uuidv7(), uuidv7()]
+ * a < b // true
+ * ```
+ */
+export function uuidv7() {
+    const bytes = randomBytes(16);
+    let time = Date.now();
+    if (time > lastTime) {
+        sequence = ((bytes[6] << 8) | bytes[7]) & 0x7ff;
+    }
+    else {
+        time = lastTime;
+        sequence++;
+        if (sequence > 0xfff) {
+            time++;
+            sequence = 0;
+        }
+    }
+    lastTime = time;
+    for (let i = 5; i >= 0; i--) {
+        bytes[i] = time % 256;
+        time = Math.floor(time / 256);
+    }
+    bytes[6] = 0x70 | (sequence >> 8);
+    bytes[7] = sequence & 0xff;
+    bytes[8] = (bytes[8] & 0x3f) | 0x80;
+    return format(bytes);
+}

package/dist/index.d.ts

@@ -1,10 +1,17 @@
+/**
+ * Collections, utilities and exact decimal arithmetic.
+ * @module
+ */
 export * from './collections/index.js';
-export * from './decimal/index.js';
-export * from './functools/index.js';
-export * from './globals/index.js';
-export * from './i18n/index.js';
-export * from './itertools/index.js';
-export * from './math/index.js';
-export * from './operators/index.js';
-export * from './random/index.js';
+export * from './object/index.js';
+export * from './array/index.js';
+export * from './function/index.js';
+export * from './async/index.js';
 export * from './string/index.js';
+export * from './number/index.js';
+export * from './random/index.js';
+export * from './id/index.js';
+export * from './hash/index.js';
+export * from './encoding/index.js';
+export * from './is/index.js';
+export * from './decimal/index.js';

package/dist/index.js

@@ -1,10 +1,17 @@
+/**
+ * Collections, utilities and exact decimal arithmetic.
+ * @module
+ */
 export * from './collections/index.js';
-export * from './decimal/index.js';
-export * from './functools/index.js';
-export * from './globals/index.js';
-export * from './i18n/index.js';
-export * from './itertools/index.js';
-export * from './math/index.js';
-export * from './operators/index.js';
-export * from './random/index.js';
+export * from './object/index.js';
+export * from './array/index.js';
+export * from './function/index.js';
+export * from './async/index.js';
 export * from './string/index.js';
+export * from './number/index.js';
+export * from './random/index.js';
+export * from './id/index.js';
+export * from './hash/index.js';
+export * from './encoding/index.js';
+export * from './is/index.js';
+export * from './decimal/index.js';

package/dist/internal/bytes.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Byte and text helpers shared by hashing, ids and encoding.
+ */
+/** Lowercase hex of `bytes`, two digits per byte. */
+export declare function bytesToHex(bytes: Uint8Array): string;
+/** UTF-8 bytes of `text`, with lone surrogates as U+FFFD, as `TextEncoder` writes them. */
+export declare function utf8(text: string): Uint8Array;
+/** An `ArrayBuffer`, from any realm. */
+export declare function isArrayBuffer(value: unknown): value is ArrayBuffer;
+/** The bytes of a string (UTF-8), a buffer or a view, without copying a buffer or view. */
+export declare function toBytes(data: string | ArrayBuffer | SharedArrayBuffer | ArrayBufferView): Uint8Array;

package/dist/internal/bytes.js

@@ -0,0 +1,33 @@
+/**
+ * Byte and text helpers shared by hashing, ids and encoding.
+ */
+import { viewBytes } from './kind.js';
+const HEX = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, '0'));
+/** Lowercase hex of `bytes`, two digits per byte. */
+export function bytesToHex(bytes) {
+    let out = '';
+    for (const byte of bytes)
+        out += HEX[byte];
+    return out;
+}
+/** UTF-8 bytes of `text`, with lone surrogates as U+FFFD, as `TextEncoder` writes them. */
+export function utf8(text) {
+    return new TextEncoder().encode(text);
+}
+/** An `ArrayBuffer`, from any realm. */
+export function isArrayBuffer(value) {
+    return Object.prototype.toString.call(value) === '[object ArrayBuffer]';
+}
+function isSharedArrayBuffer(value) {
+    return Object.prototype.toString.call(value) === '[object SharedArrayBuffer]';
+}
+/** The bytes of a string (UTF-8), a buffer or a view, without copying a buffer or view. */
+export function toBytes(data) {
+    if (typeof data === 'string')
+        return utf8(data);
+    if (ArrayBuffer.isView(data))
+        return viewBytes(data);
+    if (isArrayBuffer(data) || isSharedArrayBuffer(data))
+        return new Uint8Array(data);
+    throw new TypeError('expected a string, an ArrayBuffer or a typed array');
+}

package/dist/internal/codec.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Portable base64 and hex codecs, for runtimes without the native `Uint8Array` methods.
+ */
+/** The base64 alphabets, by the names the native methods take. */
+export type Base64Alphabet = 'base64' | 'base64url';
+/** Base64 of `bytes` in `alphabet`. */
+export declare function encodeBase64(bytes: Uint8Array, alphabet: Base64Alphabet, omitPadding: boolean): string;
+/** Bytes of base64 `text` in `alphabet`, read as `Uint8Array.fromBase64` reads it. */
+export declare function decodeBase64(text: string, alphabet: Base64Alphabet): Uint8Array;
+/** Bytes of hex `text`, read as `Uint8Array.fromHex` reads it. */
+export declare function decodeHex(text: string): Uint8Array;

package/dist/internal/codec.js

@@ -0,0 +1,84 @@
+/**
+ * Portable base64 and hex codecs, for runtimes without the native `Uint8Array` methods.
+ */
+const CHARACTERS = {
+    base64: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
+    base64url: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_'
+};
+/** For each alphabet, the 6-bit value of every ASCII code unit, or -1 outside the alphabet. */
+const VALUES = {
+    base64: valuesOf(CHARACTERS.base64),
+    base64url: valuesOf(CHARACTERS.base64url)
+};
+function valuesOf(characters) {
+    const values = new Int8Array(128).fill(-1);
+    for (let value = 0; value < characters.length; value++) {
+        values[characters.charCodeAt(value)] = value;
+    }
+    return values;
+}
+/** Base64 of `bytes` in `alphabet`. */
+export function encodeBase64(bytes, alphabet, omitPadding) {
+    const characters = CHARACTERS[alphabet];
+    let out = '';
+    let i = 0;
+    for (; i + 2 < bytes.length; i += 3) {
+        const n = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2];
+        out +=
+            characters[n >> 18] +
+                characters[(n >> 12) & 63] +
+                characters[(n >> 6) & 63] +
+                characters[n & 63];
+    }
+    const rest = bytes.length - i;
+    if (rest === 1) {
+        const n = bytes[i] << 16;
+        out += characters[n >> 18] + characters[(n >> 12) & 63] + (omitPadding ? '' : '==');
+    }
+    else if (rest === 2) {
+        const n = (bytes[i] << 16) | (bytes[i + 1] << 8);
+        out += characters[n >> 18] + characters[(n >> 12) & 63] + characters[(n >> 6) & 63];
+        out += omitPadding ? '' : '=';
+    }
+    return out;
+}
+/** Bytes of base64 `text` in `alphabet`, read as `Uint8Array.fromBase64` reads it. */
+export function decodeBase64(text, alphabet) {
+    const values = VALUES[alphabet];
+    let chars = text.replace(/[\t\n\f\r ]/g, '');
+    if (chars.endsWith('=')) {
+        if (chars.length % 4 !== 0)
+            throw new SyntaxError('invalid base64 padding');
+        chars = chars.replace(/={1,2}$/, '');
+    }
+    if (chars.length % 4 === 1)
+        throw new SyntaxError('invalid base64 length');
+    const out = new Uint8Array(Math.floor((chars.length * 3) / 4));
+    let bits = 0;
+    let buffer = 0;
+    let written = 0;
+    for (let i = 0; i < chars.length; i++) {
+        const code = chars.charCodeAt(i);
+        const value = code < 128 ? values[code] : -1;
+        if (value < 0)
+            throw new SyntaxError(`invalid base64 character: ${JSON.stringify(chars[i])}`);
+        buffer = (buffer << 6) | value;
+        bits += 6;
+        if (bits >= 8) {
+            bits -= 8;
+            out[written++] = (buffer >> bits) & 0xff;
+        }
+    }
+    return out;
+}
+/** Bytes of hex `text`, read as `Uint8Array.fromHex` reads it. */
+export function decodeHex(text) {
+    if (text.length % 2 !== 0)
+        throw new SyntaxError('hex text must have an even length');
+    if (!/^[0-9a-fA-F]*$/.test(text))
+        throw new SyntaxError('invalid hex character');
+    const out = new Uint8Array(text.length / 2);
+    for (let i = 0; i < out.length; i++)
+        out[i] = Number.parseInt(text.slice(2 * i, 2 * i + 2), 16);
+    return out;
+}

package/dist/internal/compare.d.ts

@@ -0,0 +1,10 @@
+/** A comparator `(a, b) => number`: negative when `a` sorts first, 0 for the same key. */
+export type Comparator<T> = (a: T, b: T) => number;
+/**
+ * The default order: numbers and bigints by value (compared exactly with each other) and strings
+ * by UTF-16 code units, as `<` does. `NaN` throws `RangeError`; mixed strings and numbers, `null`,
+ * `undefined` and every other value throw `TypeError` asking for a comparator.
+ */
+export declare function defaultCompare(a: unknown, b: unknown): number;
+/** SameValueZero, as `Map`, `Set` and `includes` use. */
+export declare function sameValueZero(a: unknown, b: unknown): boolean;

package/dist/internal/compare.js

@@ -0,0 +1,26 @@
+function describe(x) {
+    return x === null ? 'null' : typeof x;
+}
+function isNumeric(x) {
+    return typeof x === 'number' || typeof x === 'bigint';
+}
+/**
+ * The default order: numbers and bigints by value (compared exactly with each other) and strings
+ * by UTF-16 code units, as `<` does. `NaN` throws `RangeError`; mixed strings and numbers, `null`,
+ * `undefined` and every other value throw `TypeError` asking for a comparator.
+ */
+export function defaultCompare(a, b) {
+    if (isNumeric(a) && isNumeric(b)) {
+        if (Number.isNaN(a) || Number.isNaN(b)) {
+            throw new RangeError('NaN has no order; pass a comparator');
+        }
+        return a < b ? -1 : a > b ? 1 : 0;
+    }
+    if (typeof a === 'string' && typeof b === 'string')
+        return a < b ? -1 : a > b ? 1 : 0;
+    throw new TypeError(`the default comparator orders numbers, bigints and strings; pass a comparator to order ${describe(a)} and ${describe(b)}`);
+}
+/** SameValueZero, as `Map`, `Set` and `includes` use. */
+export function sameValueZero(a, b) {
+    return a === b || (a !== a && b !== b);
+}

package/dist/internal/crypto.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Web Crypto access shared by the random ids.
+ */
+/** `length` bytes from `crypto.getRandomValues`, or a `TypeError` where the runtime has no Web Crypto. */
+export declare function randomBytes(length: number): Uint8Array<ArrayBuffer>;

package/dist/internal/crypto.js

@@ -0,0 +1,11 @@
+/**
+ * Web Crypto access shared by the random ids.
+ */
+/** `length` bytes from `crypto.getRandomValues`, or a `TypeError` where the runtime has no Web Crypto. */
+export function randomBytes(length) {
+    const crypto = globalThis.crypto;
+    if (typeof crypto?.getRandomValues !== 'function') {
+        throw new TypeError('crypto.getRandomValues is not available');
+    }
+    return crypto.getRandomValues(new Uint8Array(length));
+}

package/dist/internal/keys.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Key lists shared by the deep walks.
+ */
+/** Whether `key` is an own enumerable property of `value`. */
+export declare function isEnumerable(value: object, key: PropertyKey): boolean;
+/** The own enumerable keys of `value`: its string keys as `Object.keys` lists them, then symbols. */
+export declare function enumerableKeys(value: object): (string | symbol)[];
+/**
+ * Location keys JavaScriptCore puts on every error as own enumerable properties, like `stack`, so
+ * `isEqual` and `hash` leave them out of an error's content.
+ */
+export declare const ERROR_LOCATION_KEYS: ReadonlySet<PropertyKey>;

package/dist/internal/keys.js

@@ -0,0 +1,23 @@
+/**
+ * Key lists shared by the deep walks.
+ */
+/** Whether `key` is an own enumerable property of `value`. */
+export function isEnumerable(value, key) {
+    return Object.prototype.propertyIsEnumerable.call(value, key);
+}
+/** The own enumerable keys of `value`: its string keys as `Object.keys` lists them, then symbols. */
+export function enumerableKeys(value) {
+    const symbols = Object.getOwnPropertySymbols(value);
+    if (symbols.length === 0)
+        return Object.keys(value);
+    return [...Object.keys(value), ...symbols.filter((key) => isEnumerable(value, key))];
+}
+/**
+ * Location keys JavaScriptCore puts on every error as own enumerable properties, like `stack`, so
+ * `isEqual` and `hash` leave them out of an error's content.
+ */
+export const ERROR_LOCATION_KEYS = new Set([
+    'line',
+    'column',
+    'sourceURL'
+]);