atomic-fns 1.2.0 → 2.0.0

package/dist/function/wrap.d.ts

@@ -0,0 +1,130 @@
+/**
+ * A curried function over the parameters `A`: each call takes any leading slice of the parameters
+ * still missing and returns the result once no required parameter is left, else another `Curried`.
+ */
+export type Curried<A extends unknown[], R> = <P extends Partial<A>>(...args: P) => A extends [...Extract<{
+    [K in keyof P]: unknown;
+}, unknown[]>, ...infer Rest] ? [] extends Rest ? R : Curried<Rest, R> : R;
+/**
+ * A function curried to an explicit arity, which the type system does not track: every call is
+ * typed as returning another `LooseFunction`, so narrow the final result yourself.
+ */
+export type LooseFunction = (...args: unknown[]) => LooseFunction;
+/**
+ * Creates a function that collects arguments until it has `arity` of them (default `fn.length`),
+ * then calls `fn` with them and the `this` of the latest call. Each partial application can be
+ * reused. Throws `RangeError` unless `arity` is a non-negative safe integer.
+ * @param fn The function to curry.
+ * @param arity How many arguments to wait for.
+ * @returns The curried function.
+ * @example
+ * ```ts
+ * const add = curry((a: number, b: number, c: number) => a + b + c)
+ * add(1)(2)(3) // 6
+ * add(1, 2, 3) // 6
+ * ```
+ */
+export declare function curry<A extends unknown[], R>(fn: (...args: A) => R, arity?: undefined): Curried<A, R>;
+/** Curries to an explicit arity, typed loosely. */
+export declare function curry(fn: (...args: never[]) => unknown, arity: number): LooseFunction;
+/**
+ * Composes functions left to right: the first receives every argument, each later one the
+ * previous result, and all run with the caller's `this`. With no functions it returns its first
+ * argument. Arrays of functions flatten one level, as in lodash.
+ * @returns The composed function.
+ * @example
+ * ```ts
+ * const shout = flow((s: string) => s.trim(), (s: string) => s.toUpperCase())
+ * shout(' hi ') // 'HI'
+ * ```
+ */
+export declare function flow(): <T>(value: T) => T;
+/** Flow over these functions, typed from first to last. */
+export declare function flow<A extends unknown[], R>(fn: (...a: A) => R): (...a: A) => R;
+/** Flow over these functions, typed from first to last. */
+export declare function flow<A extends unknown[], B, C>(f1: (...a: A) => B, f2: (b: B) => C): (...a: A) => C;
+/** Flow over these functions, typed from first to last. */
+export declare function flow<A extends unknown[], B, C, D>(f1: (...a: A) => B, f2: (b: B) => C, f3: (c: C) => D): (...a: A) => D;
+/** Flow over these functions, typed from first to last. */
+export declare function flow<A extends unknown[], B, C, D, E>(f1: (...a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E): (...a: A) => E;
+/** Flow over these functions, typed from first to last. */
+export declare function flow<A extends unknown[], B, C, D, E, F>(f1: (...a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E, f5: (e: E) => F): (...a: A) => F;
+/** Flow over these functions, typed from first to last. */
+export declare function flow<A extends unknown[], B, C, D, E, F, G>(f1: (...a: A) => B, f2: (b: B) => C, f3: (c: C) => D, f4: (d: D) => E, f5: (e: E) => F, f6: (f: F) => G): (...a: A) => G;
+/** Flow over any number of functions of one type, or arrays of them. */
+export declare function flow<T>(...fns: (((value: T) => T) | readonly ((value: T) => T)[])[]): (value: T) => T;
+/**
+ * Composes functions right to left, as {@link flow} does left to right. Does not reverse an array
+ * passed to it.
+ * @returns The composed function.
+ * @example
+ * ```ts
+ * const shout = compose((s: string) => s.toUpperCase(), (s: string) => s.trim())
+ * shout(' hi ') // 'HI'
+ * ```
+ */
+export declare function compose(): <T>(value: T) => T;
+/** Compose these functions, typed from last to first. */
+export declare function compose<A extends unknown[], R>(fn: (...a: A) => R): (...a: A) => R;
+/** Compose these functions, typed from last to first. */
+export declare function compose<A extends unknown[], B, C>(f2: (b: B) => C, f1: (...a: A) => B): (...a: A) => C;
+/** Compose these functions, typed from last to first. */
+export declare function compose<A extends unknown[], B, C, D>(f3: (c: C) => D, f2: (b: B) => C, f1: (...a: A) => B): (...a: A) => D;
+/** Compose these functions, typed from last to first. */
+export declare function compose<A extends unknown[], B, C, D, E>(f4: (d: D) => E, f3: (c: C) => D, f2: (b: B) => C, f1: (...a: A) => B): (...a: A) => E;
+/** Compose these functions, typed from last to first. */
+export declare function compose<A extends unknown[], B, C, D, E, F>(f5: (e: E) => F, f4: (d: D) => E, f3: (c: C) => D, f2: (b: B) => C, f1: (...a: A) => B): (...a: A) => F;
+/** Compose these functions, typed from last to first. */
+export declare function compose<A extends unknown[], B, C, D, E, F, G>(f6: (f: F) => G, f5: (e: E) => F, f4: (d: D) => E, f3: (c: C) => D, f2: (b: B) => C, f1: (...a: A) => B): (...a: A) => G;
+/** Compose any number of functions of one type, or arrays of them. */
+export declare function compose<T>(...fns: (((value: T) => T) | readonly ((value: T) => T)[])[]): (value: T) => T;
+/** The store a memoized function reads and writes; a `Map` or anything with its interface. */
+export interface MemoizeCache<K, V> {
+    /** Returns the stored value for `key`. */
+    get(key: K): V | undefined;
+    /** Stores `value` under `key`. */
+    set(key: K, value: V): unknown;
+    /** Whether `key` is stored. */
+    has(key: K): boolean;
+    /** Removes `key`. */
+    delete(key: K): boolean;
+    /** Removes every key. */
+    clear(): void;
+    /** How many keys are stored. */
+    readonly size: number;
+}
+/** A memoized function and its replaceable `cache`. */
+export type Memoized<F extends (...args: never[]) => unknown> = ((this: ThisParameterType<F>, ...args: Parameters<F>) => ReturnType<F>) & {
+    /** The store lookups read; assign another `Map`-like store to replace it. */
+    cache: MemoizeCache<unknown, ReturnType<F>>;
+};
+/**
+ * Creates a function that caches the result of `fn` per key. The key is the first argument, or
+ * what `resolver` returns for the arguments. Both run with the caller's `this`. Lookups use `has`,
+ * so `undefined` results are cached too. The cache never evicts: clear it with
+ * `memoized.cache.clear()` or assign a bounded store to `memoized.cache`.
+ * @param fn The function to memoize.
+ * @param resolver Computes the cache key from the arguments.
+ * @returns The memoized function.
+ * @example
+ * ```ts
+ * const square = memoize((n: number) => n * n)
+ * square(4) // 16, computed
+ * square(4) // 16, from square.cache
+ * ```
+ */
+export declare function memoize<F extends (...args: never[]) => unknown>(fn: F, resolver?: (...args: Parameters<F>) => unknown): Memoized<F>;
+/**
+ * Creates a function that calls `fn` once and returns that result on every later call. A call
+ * made while `fn` is still running, or after it threw, returns `undefined` without calling it.
+ * `fn` is released after its call.
+ * @param fn The function to restrict.
+ * @returns The restricted function.
+ * @example
+ * ```ts
+ * const init = once(() => console.log('ready'))
+ * init() // logs 'ready'
+ * init() // does nothing
+ * ```
+ */
+export declare function once<A extends unknown[], R>(fn: (...args: A) => R): (...args: A) => R | undefined;

package/dist/function/wrap.js

@@ -0,0 +1,113 @@
+import { assertFunction } from './shared.js';
+export function curry(fn, arity) {
+    assertFunction(fn, 'fn');
+    const required = arity ?? fn.length;
+    if (!Number.isSafeInteger(required) || required < 0) {
+        throw new RangeError('arity must be a non-negative safe integer');
+    }
+    const curried = function (...args) {
+        if (args.length >= required)
+            return Reflect.apply(fn, this, args);
+        return function (...more) {
+            return Reflect.apply(curried, this, args.concat(more));
+        };
+    };
+    return curried;
+}
+/**
+ * Flattens one level, as lodash `flow` does, and refuses anything but functions. Holes in a nested
+ * array count as `undefined`, so they are refused too.
+ */
+function pipelineOf(fns) {
+    const pipeline = [];
+    for (const entry of fns) {
+        if (Array.isArray(entry))
+            pipeline.push(...Array.from(entry));
+        // `Array.isArray` does not narrow a readonly array out of the union
+        else
+            pipeline.push(entry);
+    }
+    for (const fn of pipeline)
+        assertFunction(fn, 'each argument');
+    return pipeline;
+}
+function pipeThrough(thisArg, fns, args) {
+    if (fns.length === 0)
+        return args[0];
+    let result = Reflect.apply(fns[0], thisArg, args);
+    for (let i = 1; i < fns.length; i++)
+        result = Reflect.apply(fns[i], thisArg, [result]);
+    return result;
+}
+/** @param fns The functions to apply, left to right. */
+export function flow(...fns) {
+    const pipeline = pipelineOf(fns);
+    return function (...args) {
+        return pipeThrough(this, pipeline, args);
+    };
+}
+/** @param fns The functions to apply, right to left. */
+export function compose(...fns) {
+    const reversed = pipelineOf(fns).reverse();
+    return function (...args) {
+        return pipeThrough(this, reversed, args);
+    };
+}
+/**
+ * Creates a function that caches the result of `fn` per key. The key is the first argument, or
+ * what `resolver` returns for the arguments. Both run with the caller's `this`. Lookups use `has`,
+ * so `undefined` results are cached too. The cache never evicts: clear it with
+ * `memoized.cache.clear()` or assign a bounded store to `memoized.cache`.
+ * @param fn The function to memoize.
+ * @param resolver Computes the cache key from the arguments.
+ * @returns The memoized function.
+ * @example
+ * ```ts
+ * const square = memoize((n: number) => n * n)
+ * square(4) // 16, computed
+ * square(4) // 16, from square.cache
+ * ```
+ */
+export function memoize(fn, resolver) {
+    assertFunction(fn, 'fn');
+    if (resolver != null)
+        assertFunction(resolver, 'resolver');
+    const cache = new Map();
+    const memoized = Object.assign(function (...args) {
+        const key = resolver ? Reflect.apply(resolver, this, args) : args[0];
+        const store = memoized.cache;
+        // `has` said the key is stored, so `get` returns a stored `ReturnType<F>`
+        if (store.has(key))
+            return store.get(key);
+        const value = Reflect.apply(fn, this, args);
+        store.set(key, value);
+        return value;
+    }, { cache });
+    return memoized;
+}
+/**
+ * Creates a function that calls `fn` once and returns that result on every later call. A call
+ * made while `fn` is still running, or after it threw, returns `undefined` without calling it.
+ * `fn` is released after its call.
+ * @param fn The function to restrict.
+ * @returns The restricted function.
+ * @example
+ * ```ts
+ * const init = once(() => console.log('ready'))
+ * init() // logs 'ready'
+ * init() // does nothing
+ * ```
+ */
+export function once(fn) {
+    assertFunction(fn, 'fn');
+    let pending = fn;
+    let value;
+    return function (...args) {
+        if (pending) {
+            const target = pending;
+            pending = undefined;
+            value = Reflect.apply(target, this, args);
+        }
+        return value;
+    };
+}

package/dist/hash/digest.d.ts

@@ -0,0 +1,18 @@
+/** The digest algorithms every `crypto.subtle` implementation supports. */
+export type DigestAlgorithm = 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512';
+/**
+ * Cryptographic digest of `data` as a lowercase hex string, through `crypto.subtle.digest`. A
+ * string is hashed as UTF-8, with each lone surrogate as U+FFFD as `TextEncoder` writes it, so
+ * `'\uD800'` and `'\uDFFF'` hash alike; bytes on shared memory are copied first, since
+ * `crypto.subtle` refuses them. Rejects with `TypeError` where `crypto.subtle` is missing (insecure
+ * browser contexts) and for data that is neither a string nor bytes.
+ * @param algorithm `'SHA-1'`, `'SHA-256'`, `'SHA-384'` or `'SHA-512'`.
+ * @param data A string, an `ArrayBuffer` or `SharedArrayBuffer`, or a typed array or `DataView`.
+ * @returns A promise of the hex digest.
+ * @example
+ * ```ts
+ * await digest('SHA-256', 'abc')
+ * // 'ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad'
+ * ```
+ */
+export declare function digest(algorithm: DigestAlgorithm, data: string | ArrayBuffer | SharedArrayBuffer | ArrayBufferView): Promise<string>;

package/dist/hash/digest.js

@@ -0,0 +1,26 @@
+import { bytesToHex, isArrayBuffer, toBytes } from '../internal/bytes.js';
+/**
+ * Cryptographic digest of `data` as a lowercase hex string, through `crypto.subtle.digest`. A
+ * string is hashed as UTF-8, with each lone surrogate as U+FFFD as `TextEncoder` writes it, so
+ * `'\uD800'` and `'\uDFFF'` hash alike; bytes on shared memory are copied first, since
+ * `crypto.subtle` refuses them. Rejects with `TypeError` where `crypto.subtle` is missing (insecure
+ * browser contexts) and for data that is neither a string nor bytes.
+ * @param algorithm `'SHA-1'`, `'SHA-256'`, `'SHA-384'` or `'SHA-512'`.
+ * @param data A string, an `ArrayBuffer` or `SharedArrayBuffer`, or a typed array or `DataView`.
+ * @returns A promise of the hex digest.
+ * @example
+ * ```ts
+ * await digest('SHA-256', 'abc')
+ * // 'ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad'
+ * ```
+ */
+export async function digest(algorithm, data) {
+    const subtle = globalThis.crypto?.subtle;
+    if (subtle === undefined)
+        throw new TypeError('crypto.subtle is not available');
+    const view = toBytes(data);
+    const bytes = isArrayBuffer(view.buffer)
+        ? new Uint8Array(view.buffer, view.byteOffset, view.byteLength)
+        : view.slice();
+    return bytesToHex(new Uint8Array(await subtle.digest(algorithm, bytes)));
+}

package/dist/hash/hash.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Structural hash, consistent with `isEqual`: whenever `isEqual(a, b)` is true, `hash(a)` equals
+ * `hash(b)`, so values can be bucketed before they are compared. It reads the kinds `isEqual`
+ * compares by content (plain objects, arrays, `Map`, `Set`, Dates, RegExps, buffers, typed arrays,
+ * boxed primitives, errors, `arguments`), key order aside; class instances, functions,
+ * unregistered symbols and `Map` keys or `Set` members that are objects hash by identity, which
+ * holds only for the life of the process. Not cryptographic, and not resistant to keys crafted to
+ * collide.
+ *
+ * It reads at most 8 levels below the root, and structure deeper than that counts only by its
+ * kind. So cyclic values that `isEqual` equates hash alike, and `hash`, unlike the other deep walks,
+ * never throws on deep input.
+ * @param value Any value.
+ * @returns An unsigned 32-bit integer.
+ * @example
+ * ```ts
+ * hash({ a: [1, 2], b: 'x' }) === hash({ b: 'x', a: [1, 2] }) // true
+ * hash(new Map([[1, NaN]])) === hash(new Map([[1, NaN]])) // true
+ * hash(0) === hash(-0) // true
+ * ```
+ */
+export declare function hash(value: unknown): number;

package/dist/hash/hash.js

@@ -0,0 +1,252 @@
+import { enumerableKeys, ERROR_LOCATION_KEYS } from '../internal/keys.js';
+import { bytesOf, contentKindOf, isFloatView, typedArrayName, unbox } from '../internal/kind.js';
+import { walkArrayIndices } from '../internal/sparse.js';
+import { hashString } from './hashString.js';
+/** Levels below the root a hash reads; deeper structure counts only by its kind. */
+const UNFOLD_DEPTH = 8;
+/** Past this many objects a hash stops remembering them; only time grows, not memory. */
+const MAX_TRACKED_OBJECTS = 2 ** 24;
+/** Seeds that keep the hash of one kind apart from another's. */
+const Tag = {
+    Undefined: 4097,
+    Null: 4098,
+    True: 4099,
+    False: 4100,
+    NaN: 4101,
+    Number: 4102,
+    BigInt: 4103,
+    String: 4104,
+    Symbol: 4105,
+    Plain: 4106,
+    Array: 4107,
+    Map: 4108,
+    Set: 4109,
+    Date: 4110,
+    RegExp: 4111,
+    Buffer: 4112,
+    View: 4113,
+    Boxed: 4114,
+    Error: 4115,
+    Arguments: 4116,
+    NoCause: 4117
+};
+function mix(state, value) {
+    const h = Math.imul(state ^ value, 0x5bd1e995);
+    return h ^ (h >>> 15);
+}
+function finish(state) {
+    let h = state ^ (state >>> 16);
+    h = Math.imul(h, 0x85ebca6b);
+    h ^= h >>> 13;
+    h = Math.imul(h, 0xc2b2ae35);
+    return (h ^ (h >>> 16)) >>> 0;
+}
+function canHoldSymbols() {
+    try {
+        new WeakMap().set(Symbol(), 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const ids = new WeakMap();
+const symbolsAreWeakKeys = canHoldSymbols();
+let nextId = 1;
+function identityOf(value) {
+    let id = ids.get(value);
+    if (id === undefined)
+        ids.set(value, (id = nextId++));
+    return id;
+}
+/**
+ * A registered symbol by its key; any other by identity where the runtime can hold it weakly, and
+ * by its description where it cannot, so that hashing never keeps a symbol alive.
+ */
+function symbolHash(value) {
+    const key = Symbol.keyFor(value);
+    if (key !== undefined)
+        return mix(Tag.Symbol, hashString(key));
+    if (!symbolsAreWeakKeys)
+        return mix(Tag.Symbol, hashString(value.description ?? ''));
+    return mix(Tag.Symbol, identityOf(value));
+}
+/** By SameValueZero: `0` and `-0` share a hash, and so do all NaNs. */
+function numberHash(value) {
+    if (value !== value)
+        return Tag.NaN;
+    return mix(Tag.Number, hashString(String(value === 0 ? 0 : value)));
+}
+/** Hash of a value compared by SameValueZero: a primitive by value, an object by identity. */
+function memberHash(value) {
+    switch (typeof value) {
+        case 'undefined':
+            return Tag.Undefined;
+        case 'boolean':
+            return value ? Tag.True : Tag.False;
+        case 'number':
+            return numberHash(value);
+        case 'bigint':
+            return mix(Tag.BigInt, hashString(value.toString(16)));
+        case 'string':
+            return mix(Tag.String, hashString(value));
+        case 'symbol':
+            return symbolHash(value);
+        default:
+            return value === null ? Tag.Null : identityOf(value);
+    }
+}
+function bytesHash(bytes) {
+    let state = bytes.length;
+    for (const byte of bytes)
+        state = mix(state, byte);
+    return state;
+}
+/** What a container hashes to once the levels a hash reads run out. */
+const CONTAINER_TAGS = {
+    plain: Tag.Plain,
+    array: Tag.Array,
+    arguments: Tag.Arguments,
+    map: Tag.Map,
+    error: Tag.Error
+};
+/** One `hash` call: hashes of shared objects, by how many levels were left below them. */
+class Unfolding {
+    #memo = new Map();
+    of(value, levels) {
+        if (typeof value !== 'object' || value === null)
+            return memberHash(value);
+        let byLevel = this.#memo.get(value);
+        const known = byLevel?.[levels];
+        if (known !== undefined)
+            return known;
+        const hashed = this.#object(value, levels);
+        if (byLevel === undefined && this.#memo.size < MAX_TRACKED_OBJECTS) {
+            this.#memo.set(value, (byLevel = []));
+        }
+        if (byLevel !== undefined)
+            byLevel[levels] = hashed;
+        return hashed;
+    }
+    #object(value, levels) {
+        const kind = contentKindOf(value);
+        switch (kind) {
+            case 'other':
+                return identityOf(value);
+            case 'set': {
+                let sum = 0;
+                for (const v of Set.prototype.values.call(value))
+                    sum = (sum + finish(memberHash(v))) | 0;
+                return mix(mix(Tag.Set, value.size), sum);
+            }
+            case 'date':
+                return mix(Tag.Date, numberHash(Date.prototype.getTime.call(value)));
+            case 'regexp':
+                return mix(mix(Tag.RegExp, hashString(value.source)), hashString(value.flags));
+            case 'buffer':
+                return mix(Tag.Buffer, bytesHash(bytesOf(value)));
+            case 'view':
+                return this.#view(value);
+            case 'boxed':
+                return mix(Tag.Boxed, memberHash(unbox(value)));
+            default:
+                return levels === 0 ? CONTAINER_TAGS[kind] : this.#container(value, kind, levels - 1);
+        }
+    }
+    /** The kinds that hold other values, read one level further down. */
+    #container(value, kind, below) {
+        switch (kind) {
+            case 'plain':
+                return this.#record(value, below);
+            case 'array':
+                return this.#array(value, below, Tag.Array);
+            case 'arguments':
+                return this.#array(value, below, Tag.Arguments);
+            case 'map': {
+                let sum = 0;
+                for (const [k, v] of Map.prototype.entries.call(value)) {
+                    sum = (sum + finish(mix(memberHash(k), this.of(v, below)))) | 0;
+                }
+                return mix(mix(Tag.Map, value.size), sum);
+            }
+            case 'error':
+                return this.#error(value, below);
+        }
+    }
+    /** Name, message, an own `cause` and own enumerable properties, as `isEqual` compares errors. */
+    #error(value, below) {
+        const cause = Object.hasOwn(value, 'cause') ? this.of(value.cause, below) : Tag.NoCause;
+        let state = mix(Tag.Error, this.of(value.name, below));
+        state = mix(mix(state, this.of(value.message, below)), cause);
+        return mix(state, this.#record(value, below, ERROR_LOCATION_KEYS));
+    }
+    #record(value, below, ignored) {
+        const record = value;
+        let sum = 0;
+        let count = 0;
+        for (const key of enumerableKeys(value)) {
+            if (ignored?.has(key))
+                continue;
+            sum = (sum + finish(mix(memberHash(key), this.of(record[key], below)))) | 0;
+            count++;
+        }
+        return mix(mix(Tag.Plain, count), sum);
+    }
+    /** `undefined` and holes add nothing, since `isEqual` takes a hole to equal `undefined`. */
+    #array(value, below, tag) {
+        let sum = 0;
+        let i = 0;
+        for (; i < value.length && i in value; i++) {
+            const item = value[i];
+            if (item !== undefined)
+                sum = (sum + finish(mix(i, this.of(item, below)))) | 0;
+        }
+        if (i === value.length)
+            return mix(mix(tag, value.length), sum);
+        walkArrayIndices(value, (ev) => {
+            if (ev.kind !== 'index' || ev.index < i)
+                return;
+            const item = value[ev.index];
+            if (item !== undefined)
+                sum = (sum + finish(mix(ev.index, this.of(item, below)))) | 0;
+        });
+        return mix(mix(tag, value.length), sum);
+    }
+    #view(value) {
+        const tag = mix(Tag.View, hashString(typedArrayName(value) ?? 'DataView'));
+        if (!isFloatView(value))
+            return mix(tag, bytesHash(bytesOf(value)));
+        const floats = value;
+        const length = floats.length;
+        let state = mix(tag, length);
+        for (let i = 0; i < length; i++)
+            state = mix(state, numberHash(floats[i]));
+        return state;
+    }
+}
+/**
+ * Structural hash, consistent with `isEqual`: whenever `isEqual(a, b)` is true, `hash(a)` equals
+ * `hash(b)`, so values can be bucketed before they are compared. It reads the kinds `isEqual`
+ * compares by content (plain objects, arrays, `Map`, `Set`, Dates, RegExps, buffers, typed arrays,
+ * boxed primitives, errors, `arguments`), key order aside; class instances, functions,
+ * unregistered symbols and `Map` keys or `Set` members that are objects hash by identity, which
+ * holds only for the life of the process. Not cryptographic, and not resistant to keys crafted to
+ * collide.
+ *
+ * It reads at most 8 levels below the root, and structure deeper than that counts only by its
+ * kind. So cyclic values that `isEqual` equates hash alike, and `hash`, unlike the other deep walks,
+ * never throws on deep input.
+ * @param value Any value.
+ * @returns An unsigned 32-bit integer.
+ * @example
+ * ```ts
+ * hash({ a: [1, 2], b: 'x' }) === hash({ b: 'x', a: [1, 2] }) // true
+ * hash(new Map([[1, NaN]])) === hash(new Map([[1, NaN]])) // true
+ * hash(0) === hash(-0) // true
+ * ```
+ */
+export function hash(value) {
+    if (typeof value !== 'object' || value === null)
+        return finish(memberHash(value));
+    return finish(new Unfolding().of(value, UNFOLD_DEPTH));
+}

package/dist/hash/hashString.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 32-bit FNV-1a hash of the UTF-8 bytes of `str`, so it matches FNV-1a in other languages. Lone
+ * surrogates count as U+FFFD, as `TextEncoder` writes them. Fast and well spread, but not
+ * cryptographic.
+ * @param str The string to hash.
+ * @returns An unsigned 32-bit integer.
+ * @example
+ * ```ts
+ * hashString('') // 2166136261
+ * hashString('a') // 3826002220
+ * ```
+ */
+export declare function hashString(str: string): number;

package/dist/hash/hashString.js

@@ -0,0 +1,53 @@
+const FNV_OFFSET = 0x811c9dc5;
+const FNV_PRIME = 0x01000193;
+/** One byte into an FNV-1a state. */
+function step(state, byte) {
+    return Math.imul(state ^ byte, FNV_PRIME);
+}
+/**
+ * 32-bit FNV-1a hash of the UTF-8 bytes of `str`, so it matches FNV-1a in other languages. Lone
+ * surrogates count as U+FFFD, as `TextEncoder` writes them. Fast and well spread, but not
+ * cryptographic.
+ * @param str The string to hash.
+ * @returns An unsigned 32-bit integer.
+ * @example
+ * ```ts
+ * hashString('') // 2166136261
+ * hashString('a') // 3826002220
+ * ```
+ */
+export function hashString(str) {
+    if (typeof str !== 'string')
+        throw new TypeError('hashString expects a string');
+    let state = FNV_OFFSET;
+    // Encodes in place rather than through `TextEncoder`: `hash` calls this for every string and
+    // number it meets, and an allocation per call made it about five times slower.
+    for (let i = 0; i < str.length; i++) {
+        let code = str.charCodeAt(i);
+        if (code >= 0xd800 && code <= 0xdbff && i + 1 < str.length) {
+            const low = str.charCodeAt(i + 1);
+            if (low >= 0xdc00 && low <= 0xdfff) {
+                code = 0x10000 + ((code - 0xd800) << 10) + (low - 0xdc00);
+                i++;
+            }
+        }
+        if (code >= 0xd800 && code <= 0xdfff)
+            code = 0xfffd;
+        if (code < 0x80) {
+            state = step(state, code);
+        }
+        else if (code < 0x800) {
+            state = step(step(state, 0xc0 | (code >> 6)), 0x80 | (code & 0x3f));
+        }
+        else if (code < 0x10000) {
+            state = step(step(step(state, 0xe0 | (code >> 12)), 0x80 | ((code >> 6) & 0x3f)), 0x80 | (code & 0x3f));
+        }
+        else {
+            state = step(state, 0xf0 | (code >> 18));
+            state = step(state, 0x80 | ((code >> 12) & 0x3f));
+            state = step(state, 0x80 | ((code >> 6) & 0x3f));
+            state = step(state, 0x80 | (code & 0x3f));
+        }
+    }
+    return state >>> 0;
+}

package/dist/hash/index.d.ts

@@ -0,0 +1,8 @@
+/**
+ * String, structural and cryptographic hashes, and a stable JSON form.
+ * @module hash
+ */
+export { type DigestAlgorithm, digest } from './digest.js';
+export { hash } from './hash.js';
+export { hashString } from './hashString.js';
+export { stableStringify } from './stableStringify.js';

package/dist/hash/index.js

@@ -0,0 +1,8 @@
+/**
+ * String, structural and cryptographic hashes, and a stable JSON form.
+ * @module hash
+ */
+export { digest } from './digest.js';
+export { hash } from './hash.js';
+export { hashString } from './hashString.js';
+export { stableStringify } from './stableStringify.js';

package/dist/hash/stableStringify.d.ts

@@ -0,0 +1,19 @@
+/**
+ * `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 declare function stableStringify(value: unknown): string | undefined;