atomic-fns 1.2.0 → 2.0.0

package/dist/decimal/internal/minor-units.js

@@ -0,0 +1,33 @@
+/**
+ * Active ISO 4217 codes by minor-unit digits, from the ISO 4217 list one published 2026-09-17.
+ * Codes the list gives no minor unit (XAU, XDR, XXX and the other funds and metals) are absent.
+ * `Intl` cannot stand in: it reports CLDR display digits, which differ from ISO 4217 (0 for IQD
+ * and HUF) and change with the runtime's ICU version.
+ */
+const CODES_BY_MINOR_UNITS = [
+    [0, 'BIF CLP DJF GNF ISK JPY KMF KRW PYG RWF UGX UYI VND VUV XAF XOF XPF'],
+    [
+        2,
+        'AED AFN ALL AMD AOA ARS AUD AWG AZN BAM BBD BDT BMD BND BOB BOV BRL BSD BTN BWP BYN ' +
+            'BZD CAD CDF CHE CHF CHW CNY COP COU CRC CUP CVE CZK DKK DOP DZD EGP ERN ETB EUR FJD ' +
+            'FKP GBP GEL GHS GIP GMD GTQ GYD HKD HNL HTG HUF IDR ILS INR IRR JMD KES KGS KHR KPW ' +
+            'KYD KZT LAK LBP LKR LRD LSL MAD MDL MGA MKD MMK MNT MOP MRU MUR MVR MWK MXN MXV MYR ' +
+            'MZN NAD NGN NIO NOK NPR NZD PAB PEN PGK PHP PKR PLN QAR RON RSD RUB SAR SBD SCR SDG ' +
+            'SEK SGD SHP SLE SOS SRD SSP STN SVC SYP SZL THB TJS TMT TOP TRY TTD TWD TZS UAH USD ' +
+            'USN UYU UZS VED VES WST XAD XCD XCG YER ZAR ZMW ZWG'
+    ],
+    [3, 'BHD IQD JOD KWD LYD OMR TND'],
+    [4, 'CLF UYW']
+];
+let minorUnits;
+/** The ISO 4217 minor-unit digits of an upper-case `code`, or undefined when it has none. */
+export function isoMinorUnits(code) {
+    if (minorUnits === undefined) {
+        minorUnits = new Map();
+        for (const [digits, codes] of CODES_BY_MINOR_UNITS) {
+            for (const listed of codes.split(' '))
+                minorUnits.set(listed, digits);
+        }
+    }
+    return minorUnits.get(code);
+}

package/dist/decimal/internal/pow10.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Lazy power-of-ten caches for Decimal arithmetic and normalization.
+ * Built on first use so importing decimal does not allocate large bigints.
+ *
+ * Bounded: linear powers below 64, blocks of 64 below 1024, and a squares table
+ * persisted through 10^16384 (15 entries) under Decimal's public bounds.
+ * Larger powers are built by binary decomposition and are never stored.
+ */
+/** Return `10^k` for a non-negative integer `k`. */
+export declare function pow10(k: number): bigint;
+/**
+ * Return the memoized `10^(2^k)` table, with at least the powers through 10^8192.
+ * Built once; subsequent calls are free.
+ */
+export declare function pow10Squares(): readonly bigint[];
+/** Length of the linear `10^k` cache (1 right after import). For tests. */
+export declare function getPow10CacheLength(): number;
+/** Length of the square `10^(2^k)` cache (0 right after import). For tests. */
+export declare function getPow10SquareCacheLength(): number;
+/**
+ * Total decimal digits across every cached power-of-ten bigint.
+ * 10^e contributes e+1 digits. For tests.
+ */
+export declare function getPow10CachedDigits(): number;

package/dist/decimal/internal/pow10.js

@@ -0,0 +1,96 @@
+/**
+ * Lazy power-of-ten caches for Decimal arithmetic and normalization.
+ * Built on first use so importing decimal does not allocate large bigints.
+ *
+ * Bounded: linear powers below 64, blocks of 64 below 1024, and a squares table
+ * persisted through 10^16384 (15 entries) under Decimal's public bounds.
+ * Larger powers are built by binary decomposition and are never stored.
+ */
+const LINEAR_BITS = 6;
+const LINEAR_MAX = 1 << LINEAR_BITS;
+const BLOCK_MAX = 1024;
+/** Cached `10^k` for k < LINEAR_MAX. Index 0 is always `1n`. Grows on demand. */
+const POW10_TABLE = [1n];
+const POW10_BLOCK_TABLE = [1n];
+const POW10_SQUARE_TABLE = [];
+/**
+ * Ensure the persisted square table has at least `minLength` entries.
+ * First entry is `10n` (10^(2^0)); each further entry squares the previous.
+ */
+function ensureSquares(minLength) {
+    if (POW10_SQUARE_TABLE.length === 0 && minLength > 0) {
+        POW10_SQUARE_TABLE.push(10n);
+    }
+    while (POW10_SQUARE_TABLE.length < minLength) {
+        const last = POW10_SQUARE_TABLE[POW10_SQUARE_TABLE.length - 1];
+        POW10_SQUARE_TABLE.push(last * last);
+    }
+}
+function squareAt(bit) {
+    ensureSquares(bit + 1);
+    return POW10_SQUARE_TABLE[bit];
+}
+/** Return `10^k` for a non-negative integer `k`. */
+export function pow10(k) {
+    if (k < BLOCK_MAX) {
+        const block = k >> LINEAR_BITS;
+        const remainder = k & (LINEAR_MAX - 1);
+        while (POW10_TABLE.length <= remainder) {
+            const last = POW10_TABLE[POW10_TABLE.length - 1];
+            POW10_TABLE.push(last * 10n);
+        }
+        if (block === 0)
+            return POW10_TABLE[remainder];
+        while (POW10_BLOCK_TABLE.length <= block) {
+            const last = POW10_BLOCK_TABLE[POW10_BLOCK_TABLE.length - 1];
+            POW10_BLOCK_TABLE.push(last * squareAt(LINEAR_BITS));
+        }
+        return POW10_BLOCK_TABLE[block] * POW10_TABLE[remainder];
+    }
+    // Binary decomposition: 10^k = product of 10^(2^i) for each set bit i of k.
+    let result = 1n;
+    let bit = 0;
+    let rem = k;
+    while (rem > 0) {
+        if (rem & 1) {
+            result *= squareAt(bit);
+        }
+        rem >>= 1;
+        bit++;
+    }
+    return result;
+}
+/**
+ * Return the memoized `10^(2^k)` table, with at least the powers through 10^8192.
+ * Built once; subsequent calls are free.
+ */
+export function pow10Squares() {
+    // Stripping up to 10000 trailing zeros (Decimal's digit bound) needs squares through 2^13 = 8192.
+    ensureSquares(14);
+    return POW10_SQUARE_TABLE;
+}
+/** Length of the linear `10^k` cache (1 right after import). For tests. */
+export function getPow10CacheLength() {
+    return POW10_TABLE.length;
+}
+/** Length of the square `10^(2^k)` cache (0 right after import). For tests. */
+export function getPow10SquareCacheLength() {
+    return POW10_SQUARE_TABLE.length;
+}
+/**
+ * Total decimal digits across every cached power-of-ten bigint.
+ * 10^e contributes e+1 digits. For tests.
+ */
+export function getPow10CachedDigits() {
+    let total = 0;
+    for (let i = 0; i < POW10_TABLE.length; i++) {
+        total += i + 1;
+    }
+    for (let j = 0; j < POW10_SQUARE_TABLE.length; j++) {
+        total += (1 << j) + 1;
+    }
+    for (let i = 0; i < POW10_BLOCK_TABLE.length; i++) {
+        total += i * LINEAR_MAX + 1;
+    }
+    return total;
+}

package/dist/encoding/base64.d.ts

@@ -0,0 +1,39 @@
+/** Options for {@link toBase64}. */
+export interface ToBase64Options {
+    /** `'base64'` (`+` and `/`, the default) or `'base64url'` (`-` and `_`). */
+    alphabet?: 'base64' | 'base64url';
+    /** Leave out the trailing `=` padding (default `false`). */
+    omitPadding?: boolean;
+}
+/** Options for {@link fromBase64}. */
+export interface FromBase64Options {
+    /** `'base64'` (`+` and `/`, the default) or `'base64url'` (`-` and `_`). */
+    alphabet?: 'base64' | 'base64url';
+}
+/**
+ * Base64 of a byte array, a buffer, or a string's UTF-8 bytes, with the `base64url` alphabet as an
+ * option. Uses the native `Uint8Array.prototype.toBase64` where present.
+ * @param data A `Uint8Array` (or other typed array or `DataView`), an `ArrayBuffer`, or a string.
+ * @param options `alphabet` and `omitPadding`.
+ * @returns The base64 text.
+ * @example
+ * ```ts
+ * toBase64('hi') // 'aGk='
+ * toBase64(new Uint8Array([251, 255]), { alphabet: 'base64url', omitPadding: true }) // '-_8'
+ * ```
+ */
+export declare function toBase64(data: string | ArrayBuffer | ArrayBufferView, options?: ToBase64Options): string;
+/**
+ * Bytes of base64 text, as `Uint8Array.fromBase64` reads it (native where present): ASCII
+ * whitespace is skipped and padding is optional, but a character outside the alphabet or a broken
+ * last chunk throws `SyntaxError`, as the native method does. Decode text with `TextDecoder`.
+ * @param text Base64 text.
+ * @param options `alphabet`.
+ * @returns The decoded bytes.
+ * @example
+ * ```ts
+ * fromBase64('aGk=') // Uint8Array [104, 105]
+ * new TextDecoder().decode(fromBase64('aGk')) // 'hi'
+ * ```
+ */
+export declare function fromBase64(text: string, options?: FromBase64Options): Uint8Array;

package/dist/encoding/base64.js

@@ -0,0 +1,53 @@
+import { toBytes } from '../internal/bytes.js';
+import { decodeBase64, encodeBase64 } from '../internal/codec.js';
+const nativeToBase64 = Uint8Array.prototype.toBase64;
+const nativeFromBase64 = Uint8Array.fromBase64;
+function alphabetOf(options) {
+    const alphabet = options?.alphabet ?? 'base64';
+    if (alphabet === 'base64' || alphabet === 'base64url')
+        return alphabet;
+    throw new TypeError(`unknown base64 alphabet: ${String(alphabet)}`);
+}
+/**
+ * Base64 of a byte array, a buffer, or a string's UTF-8 bytes, with the `base64url` alphabet as an
+ * option. Uses the native `Uint8Array.prototype.toBase64` where present.
+ * @param data A `Uint8Array` (or other typed array or `DataView`), an `ArrayBuffer`, or a string.
+ * @param options `alphabet` and `omitPadding`.
+ * @returns The base64 text.
+ * @example
+ * ```ts
+ * toBase64('hi') // 'aGk='
+ * toBase64(new Uint8Array([251, 255]), { alphabet: 'base64url', omitPadding: true }) // '-_8'
+ * ```
+ */
+export function toBase64(data, options) {
+    const alphabet = alphabetOf(options);
+    const bytes = toBytes(data);
+    const omitPadding = options?.omitPadding === true;
+    if (nativeToBase64 !== undefined) {
+        return nativeToBase64.call(bytes, { alphabet, omitPadding });
+    }
+    return encodeBase64(bytes, alphabet, omitPadding);
+}
+/**
+ * Bytes of base64 text, as `Uint8Array.fromBase64` reads it (native where present): ASCII
+ * whitespace is skipped and padding is optional, but a character outside the alphabet or a broken
+ * last chunk throws `SyntaxError`, as the native method does. Decode text with `TextDecoder`.
+ * @param text Base64 text.
+ * @param options `alphabet`.
+ * @returns The decoded bytes.
+ * @example
+ * ```ts
+ * fromBase64('aGk=') // Uint8Array [104, 105]
+ * new TextDecoder().decode(fromBase64('aGk')) // 'hi'
+ * ```
+ */
+export function fromBase64(text, options) {
+    if (typeof text !== 'string')
+        throw new TypeError('fromBase64 expects a string');
+    const alphabet = alphabetOf(options);
+    if (nativeFromBase64 !== undefined) {
+        return nativeFromBase64(text, { alphabet });
+    }
+    return decodeBase64(text, alphabet);
+}

package/dist/encoding/hex.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Lowercase hex of a byte array, a buffer, or a string's UTF-8 bytes. Uses the native
+ * `Uint8Array.prototype.toHex` where present.
+ * @param data A `Uint8Array` (or other typed array or `DataView`), an `ArrayBuffer`, or a string.
+ * @returns Two hex digits per byte.
+ * @example
+ * ```ts
+ * toHex(new Uint8Array([0, 255])) // '00ff'
+ * toHex('hi') // '6869'
+ * ```
+ */
+export declare function toHex(data: string | ArrayBuffer | ArrayBufferView): string;
+/**
+ * Bytes of hex text, as `Uint8Array.fromHex` reads it (native where present): digits in either case,
+ * an even count, nothing else; anything else throws `SyntaxError`, as the native method does.
+ * @param text Hex text.
+ * @returns The decoded bytes.
+ * @example
+ * ```ts
+ * fromHex('00ff') // Uint8Array [0, 255]
+ * ```
+ */
+export declare function fromHex(text: string): Uint8Array;

package/dist/encoding/hex.js

@@ -0,0 +1,34 @@
+import { bytesToHex, toBytes } from '../internal/bytes.js';
+import { decodeHex } from '../internal/codec.js';
+const nativeToHex = Uint8Array.prototype.toHex;
+const nativeFromHex = Uint8Array.fromHex;
+/**
+ * Lowercase hex of a byte array, a buffer, or a string's UTF-8 bytes. Uses the native
+ * `Uint8Array.prototype.toHex` where present.
+ * @param data A `Uint8Array` (or other typed array or `DataView`), an `ArrayBuffer`, or a string.
+ * @returns Two hex digits per byte.
+ * @example
+ * ```ts
+ * toHex(new Uint8Array([0, 255])) // '00ff'
+ * toHex('hi') // '6869'
+ * ```
+ */
+export function toHex(data) {
+    const bytes = toBytes(data);
+    return nativeToHex !== undefined ? nativeToHex.call(bytes) : bytesToHex(bytes);
+}
+/**
+ * Bytes of hex text, as `Uint8Array.fromHex` reads it (native where present): digits in either case,
+ * an even count, nothing else; anything else throws `SyntaxError`, as the native method does.
+ * @param text Hex text.
+ * @returns The decoded bytes.
+ * @example
+ * ```ts
+ * fromHex('00ff') // Uint8Array [0, 255]
+ * ```
+ */
+export function fromHex(text) {
+    if (typeof text !== 'string')
+        throw new TypeError('fromHex expects a string');
+    return nativeFromHex !== undefined ? nativeFromHex(text) : decodeHex(text);
+}

package/dist/encoding/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Base64 and hex for bytes and UTF-8 strings.
+ * @module encoding
+ */
+export { type FromBase64Options, fromBase64, type ToBase64Options, toBase64 } from './base64.js';
+export { fromHex, toHex } from './hex.js';

package/dist/encoding/index.js

@@ -0,0 +1,6 @@
+/**
+ * Base64 and hex for bytes and UTF-8 strings.
+ * @module encoding
+ */
+export { fromBase64, toBase64 } from './base64.js';
+export { fromHex, toHex } from './hex.js';

package/dist/function/debounce.d.ts

@@ -0,0 +1,68 @@
+/** A debounced or throttled function with `cancel`, `flush` and `pending`. */
+export interface Debounced<F extends (...args: never[]) => unknown> {
+    /** Schedules a call and returns the result of the last invocation, if any. */
+    (this: ThisParameterType<F>, ...args: Parameters<F>): ReturnType<F> | undefined;
+    /** Drops the pending call and ends the current wait, so the next call starts fresh. */
+    cancel(): void;
+    /** Runs the pending call now and returns its result, or the last result when none is pending. */
+    flush(): ReturnType<F> | undefined;
+    /** Whether a call is waiting to run. */
+    pending(): boolean;
+}
+/** Options for {@link debounce}. */
+export interface DebounceOptions {
+    /** Invoke on the first call of a burst (default `false`). */
+    leading?: boolean;
+    /** Invoke after the last call of a burst (default `true`). When `false`, held calls never run. */
+    trailing?: boolean;
+    /**
+     * Longest time the trailing call may be held, counted from the first call of the burst or the
+     * first call after `maxWait` last ran it. Has no effect when `trailing` is `false`.
+     */
+    maxWait?: number | null;
+}
+/** Options for {@link throttle}. */
+export interface ThrottleOptions {
+    /** Invoke when a window opens (default `true`). */
+    leading?: boolean;
+    /** Invoke at the end of a window with the latest arguments (default `true`). */
+    trailing?: boolean;
+}
+/**
+ * Creates a function that delays invoking `fn` until `wait` milliseconds have passed since the
+ * last call, with the latest arguments and `this`. With `maxWait`, a burst of calls also runs `fn`
+ * at least once per `maxWait`. `wait` defaults to 0; negative waits clamp to 0, and NaN, infinite
+ * or past-2147483647 waits throw `RangeError`, and a non-number wait throws `TypeError`. A
+ * `maxWait` below `wait` is raised to `wait`. Idle windows use `performance.now()` (faked by
+ * default in Vitest 5 and Jest) and hold no timer when `wait > 0`. Held trailing calls use timers;
+ * `wait === 0` keeps a timer until the next macrotask.
+ * @param fn The function to debounce.
+ * @param wait Milliseconds to wait after the last call.
+ * @param options `leading`, `trailing` and `maxWait`.
+ * @returns The debounced function with `cancel`, `flush` and `pending`.
+ * @example
+ * ```ts
+ * const save = debounce((text: string) => console.log(text), 100)
+ * save('h')
+ * save('hi') // logs 'hi' once, 100 ms later
+ * ```
+ */
+export declare function debounce<F extends (...args: never[]) => unknown>(fn: F, wait?: number | null, options?: DebounceOptions): Debounced<F>;
+/**
+ * Creates a function that invokes `fn` at most once per `wait` milliseconds: on the leading edge,
+ * and once more at the end of the window with the latest arguments when calls arrived during it
+ * (Lodash's leading and trailing defaults). The window opens before `fn` runs, so a reentrant
+ * call or a throw from `fn` stays throttled. Idle windows use `performance.now()` (faked by
+ * default in Vitest 5 and Jest) and hold no timer when `wait > 0`. Held trailing calls use timers;
+ * `wait === 0` keeps one trailing invocation per macrotask. Waits are checked as in {@link debounce}.
+ * @param fn The function to throttle.
+ * @param wait Milliseconds per window.
+ * @param options `leading` and `trailing`.
+ * @returns The throttled function with `cancel`, `flush` and `pending`.
+ * @example
+ * ```ts
+ * const onScroll = throttle(() => console.log(window.scrollY), 100)
+ * addEventListener('scroll', onScroll)
+ * ```
+ */
+export declare function throttle<F extends (...args: never[]) => unknown>(fn: F, wait?: number | null, options?: ThrottleOptions): Debounced<F>;

package/dist/function/debounce.js

@@ -0,0 +1,203 @@
+import { timerWait } from '../internal/timer.js';
+import { assertFunction } from './shared.js';
+/**
+ * Creates a function that delays invoking `fn` until `wait` milliseconds have passed since the
+ * last call, with the latest arguments and `this`. With `maxWait`, a burst of calls also runs `fn`
+ * at least once per `maxWait`. `wait` defaults to 0; negative waits clamp to 0, and NaN, infinite
+ * or past-2147483647 waits throw `RangeError`, and a non-number wait throws `TypeError`. A
+ * `maxWait` below `wait` is raised to `wait`. Idle windows use `performance.now()` (faked by
+ * default in Vitest 5 and Jest) and hold no timer when `wait > 0`. Held trailing calls use timers;
+ * `wait === 0` keeps a timer until the next macrotask.
+ * @param fn The function to debounce.
+ * @param wait Milliseconds to wait after the last call.
+ * @param options `leading`, `trailing` and `maxWait`.
+ * @returns The debounced function with `cancel`, `flush` and `pending`.
+ * @example
+ * ```ts
+ * const save = debounce((text: string) => console.log(text), 100)
+ * save('h')
+ * save('hi') // logs 'hi' once, 100 ms later
+ * ```
+ */
+export function debounce(fn, wait, options) {
+    assertFunction(fn, 'fn');
+    const delay = timerWait(wait ?? 0, 'wait');
+    const leading = options?.leading ?? false;
+    const trailing = options?.trailing ?? true;
+    const maxWait = options?.maxWait == null ? undefined : Math.max(timerWait(options.maxWait, 'maxWait'), delay);
+    // Only timers run the held call, and only with `trailing`: without it maxWait bounds nothing.
+    const maxDelay = trailing ? maxWait : undefined;
+    let timer;
+    let maxTimer;
+    let deadline = -Infinity;
+    let maxDeadline;
+    let activeCalls = 0;
+    let lastCall;
+    let lastResult;
+    function invokeLastCall() {
+        if (lastCall === undefined)
+            return lastResult;
+        const call = lastCall;
+        lastCall = undefined;
+        activeCalls++;
+        try {
+            lastResult = fn.apply(call.thisArg, call.args);
+            return lastResult;
+        }
+        finally {
+            activeCalls--;
+        }
+    }
+    function clearTimers() {
+        clearTimeout(timer);
+        clearTimeout(maxTimer);
+        timer = maxTimer = undefined;
+    }
+    /** Whether the held call will run: both timers that run it need `trailing`. */
+    function willRun() {
+        return trailing && lastCall !== undefined;
+    }
+    function debounced(...args) {
+        const now = performance.now();
+        const startsBurst = timer === undefined && (deadline === -Infinity || (activeCalls === 0 && now >= deadline));
+        const invokeLeading = leading && startsBurst;
+        if (startsBurst)
+            maxDeadline = undefined;
+        deadline = now + delay;
+        lastCall = trailing || invokeLeading ? { thisArg: this, args } : undefined;
+        clearTimeout(timer);
+        timer = undefined;
+        const needsTimer = delay === 0 || (trailing && !invokeLeading);
+        if (needsTimer) {
+            timer = setTimeout(() => {
+                clearTimers();
+                deadline = -Infinity;
+                maxDeadline = undefined;
+                if (trailing)
+                    invokeLastCall();
+                else
+                    lastCall = undefined;
+            }, delay);
+        }
+        if (maxDelay !== undefined) {
+            maxDeadline ??= now + maxDelay;
+            if (needsTimer && maxTimer === undefined) {
+                maxTimer = setTimeout(() => {
+                    maxTimer = undefined;
+                    maxDeadline = undefined;
+                    if (delay > 0)
+                        clearTimers();
+                    invokeLastCall();
+                }, Math.max(0, Math.min(maxDelay, Math.ceil(maxDeadline - now))));
+            }
+        }
+        return invokeLeading ? invokeLastCall() : lastResult;
+    }
+    debounced.cancel = () => {
+        clearTimers();
+        deadline = -Infinity;
+        maxDeadline = undefined;
+        lastCall = undefined;
+    };
+    debounced.flush = () => {
+        if (!willRun())
+            return lastResult;
+        clearTimers();
+        deadline = -Infinity;
+        maxDeadline = undefined;
+        return invokeLastCall();
+    };
+    debounced.pending = willRun;
+    return debounced;
+}
+/**
+ * Creates a function that invokes `fn` at most once per `wait` milliseconds: on the leading edge,
+ * and once more at the end of the window with the latest arguments when calls arrived during it
+ * (Lodash's leading and trailing defaults). The window opens before `fn` runs, so a reentrant
+ * call or a throw from `fn` stays throttled. Idle windows use `performance.now()` (faked by
+ * default in Vitest 5 and Jest) and hold no timer when `wait > 0`. Held trailing calls use timers;
+ * `wait === 0` keeps one trailing invocation per macrotask. Waits are checked as in {@link debounce}.
+ * @param fn The function to throttle.
+ * @param wait Milliseconds per window.
+ * @param options `leading` and `trailing`.
+ * @returns The throttled function with `cancel`, `flush` and `pending`.
+ * @example
+ * ```ts
+ * const onScroll = throttle(() => console.log(window.scrollY), 100)
+ * addEventListener('scroll', onScroll)
+ * ```
+ */
+export function throttle(fn, wait, options) {
+    assertFunction(fn, 'fn');
+    const delay = timerWait(wait ?? 0, 'wait');
+    const leading = options?.leading ?? true;
+    const trailing = options?.trailing ?? true;
+    let lastResult;
+    let trailingCall;
+    let timer;
+    let deadline = -Infinity;
+    let activeCalls = 0;
+    function scheduleWindowEnd(ms) {
+        timer = setTimeout(() => {
+            timer = undefined;
+            deadline = -Infinity;
+            const call = trailingCall;
+            trailingCall = undefined;
+            if (call)
+                invoke(call);
+        }, ms);
+    }
+    function startWindow() {
+        deadline = performance.now() + delay;
+        if (delay === 0)
+            scheduleWindowEnd(delay);
+    }
+    function invoke(call) {
+        startWindow();
+        activeCalls++;
+        try {
+            lastResult = fn.apply(call.thisArg, call.args);
+            return lastResult;
+        }
+        finally {
+            activeCalls--;
+        }
+    }
+    function clearWindow() {
+        deadline = -Infinity;
+        if (timer !== undefined) {
+            clearTimeout(timer);
+            timer = undefined;
+        }
+    }
+    function throttled(...args) {
+        const call = { thisArg: this, args };
+        if (timer === undefined &&
+            (deadline === -Infinity || (activeCalls === 0 && performance.now() >= deadline))) {
+            if (leading)
+                return invoke(call);
+            startWindow();
+        }
+        if (trailing) {
+            trailingCall = call;
+            if (timer === undefined) {
+                scheduleWindowEnd(Math.max(0, Math.min(delay, Math.ceil(deadline - performance.now()))));
+            }
+        }
+        return lastResult;
+    }
+    throttled.cancel = () => {
+        clearWindow();
+        trailingCall = undefined;
+    };
+    throttled.flush = () => {
+        if (trailingCall === undefined)
+            return lastResult;
+        const call = trailingCall;
+        trailingCall = undefined;
+        clearWindow();
+        return invoke(call);
+    };
+    throttled.pending = () => trailingCall !== undefined;
+    return throttled;
+}

package/dist/function/index.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Function wrappers: `debounce`, `throttle`, `memoize`, `once`, `curry`, `flow` and `compose`.
+ * @module function
+ */
+export { type DebounceOptions, type Debounced, debounce, type ThrottleOptions, throttle } from './debounce.js';
+export { compose, type Curried, curry, flow, type LooseFunction, type MemoizeCache, type Memoized, memoize, once } from './wrap.js';

package/dist/function/index.js

@@ -0,0 +1,6 @@
+/**
+ * Function wrappers: `debounce`, `throttle`, `memoize`, `once`, `curry`, `flow` and `compose`.
+ * @module function
+ */
+export { debounce, throttle } from './debounce.js';
+export { compose, curry, flow, memoize, once } from './wrap.js';

package/dist/function/shared.d.ts

@@ -0,0 +1,2 @@
+/** Throws `TypeError('<name> must be a function')` unless `fn` is callable. */
+export declare function assertFunction(fn: unknown, name: string): void;

package/dist/function/shared.js

@@ -0,0 +1,5 @@
+/** Throws `TypeError('<name> must be a function')` unless `fn` is callable. */
+export function assertFunction(fn, name) {
+    if (typeof fn !== 'function')
+        throw new TypeError(`${name} must be a function`);
+}