@ac-kit/core 0.1.0

package/dist/function/compare/create-reversed-comparator.d.ts

@@ -0,0 +1,4 @@
+import type { Comparator } from "./types.js";
+/** Reverses `compare`; operands it calls equivalent stay equivalent. */
+export declare function createReversedComparator<A, B = A>(compare: Comparator<A, B>): Comparator<B, A>;
+//# sourceMappingURL=create-reversed-comparator.d.ts.map

package/dist/function/compare/create-reversed-comparator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-reversed-comparator.d.ts","sourceRoot":"","sources":["../../../src/function/compare/create-reversed-comparator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,wEAAwE;AACxE,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,EAChD,OAAO,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GACvB,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAElB"}

package/dist/function/compare/create-reversed-comparator.js

@@ -0,0 +1,5 @@
+/** Reverses `compare`; operands it calls equivalent stay equivalent. */
+export function createReversedComparator(compare) {
+    return (a, b) => compare(b, a);
+}
+//# sourceMappingURL=create-reversed-comparator.js.map

package/dist/function/compare/create-reversed-comparator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-reversed-comparator.js","sourceRoot":"","sources":["../../../src/function/compare/create-reversed-comparator.ts"],"names":[],"mappings":"AAEA,wEAAwE;AACxE,MAAM,UAAU,wBAAwB,CACvC,OAAyB;IAEzB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AAChC,CAAC"}

package/dist/function/compare/types.d.ts

@@ -0,0 +1,38 @@
+import type { Callable, Predicate } from "../../types/callable.js";
+export type ComparatorResult = -1 | 0 | 1;
+/**
+ * Orders `a` against `b`: `-1` if `a` precedes `b`, `0` if the two are
+ * equivalent, `1` if `a` follows `b`.
+ *
+ * Must be a strict weak ordering — irreflexive, antisymmetric and transitive,
+ * with transitive equivalence. Sorting, bisecting, heaps and ordered ranges all
+ * assume it, and a comparator that breaks it makes their results unspecified
+ * rather than merely imprecise. An approximate comparison is therefore never a
+ * valid comparator: tolerant equivalence is not transitive.
+ *
+ * `A` and `B` differ when the search target need not share the collection's
+ * element type — bisecting an array of records by a plain numeric key, say.
+ */
+export type Comparator<A, B = A> = Callable<[A, B], ComparatorResult>;
+/**
+ * Strict weak ordering as a boolean: `true` if `a` must come before `b`.
+ *
+ * Carries exactly the same information as a {@link Comparator} — equivalence is
+ * recoverable as `!precedes(a, b) && !precedes(b, a)` — but at two calls rather
+ * than one.
+ */
+export type OrderPredicate<A, B = A> = Predicate<[A, B]>;
+/**
+ * How far apart `a` and `b` are.
+ *
+ * Must be a true metric: non-negative, symmetric, `0` exactly when the two are
+ * equivalent, and satisfying the triangle inequality. Metric-space indexes
+ * prune entire subtrees on the strength of that last property, so a distance
+ * that violates it makes their results wrong, not merely slower.
+ *
+ * Not a {@link Comparator}: it answers how far apart, never which comes first.
+ * To order candidates by closeness to a query, derive one —
+ * `createComparatorBy((item) => distance(query, item))`.
+ */
+export type Distance<T> = Callable<[T, T], number>;
+//# sourceMappingURL=types.d.ts.map

package/dist/function/compare/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/function/compare/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEnE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;AAE1C;;;;;;;;;;;;GAYG;AACH,MAAM,MAAM,UAAU,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,gBAAgB,CAAC,CAAC;AAEtE;;;;;;GAMG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AAEzD;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,QAAQ,CAAC,CAAC,IAAI,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,CAAC,CAAC"}

package/dist/function/compare/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/function/compare/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/function/compare/types.ts"],"names":[],"mappings":""}

package/dist/function/identity.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Returns the value passed as argument.
+ *
+ * @param value The value to return.
+ * @returns The same value.
+ */
+export declare function identity<T>(value: T): T;
+//# sourceMappingURL=identity.d.ts.map

package/dist/function/identity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.d.ts","sourceRoot":"","sources":["../../src/function/identity.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,CAEvC"}

package/dist/function/identity.js

@@ -0,0 +1,10 @@
+/**
+ * Returns the value passed as argument.
+ *
+ * @param value The value to return.
+ * @returns The same value.
+ */
+export function identity(value) {
+    return value;
+}
+//# sourceMappingURL=identity.js.map

package/dist/function/identity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.js","sourceRoot":"","sources":["../../src/function/identity.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,UAAU,QAAQ,CAAI,KAAQ;IACnC,OAAO,KAAK,CAAC;AACd,CAAC"}

package/dist/function/memoize.d.ts

@@ -0,0 +1,19 @@
+import { Callable } from "../types/callable.js";
+export type MemoizeOptions<A extends unknown[]> = {
+    /**
+     * A function that generates a cache key from the arguments passed to the
+     * memoized function.
+     *
+     * By default, the first argument is used as the cache key.
+     *
+     * Note: If the first argument is not a primitive value, you may want to
+     * provide a custom `keyOf` function that returns a primitive value to avoid
+     * unexpected behavior.
+     *
+     * @param args - The arguments passed to the memoized function.
+     * @returns A primitive value that can be used as a cache key.
+     */
+    keyOf?: (args: A) => unknown;
+};
+export declare function memoize<A extends unknown[], R>(fn: Callable<A, R>, options?: MemoizeOptions<A>): Callable<A, R>;
+//# sourceMappingURL=memoize.d.ts.map

package/dist/function/memoize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoize.d.ts","sourceRoot":"","sources":["../../src/function/memoize.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAEhD,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,OAAO,EAAE,IAAI;IACjD;;;;;;;;;;;;OAYG;IACH,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,OAAO,CAAC;CAC7B,CAAC;AAEF,wBAAgB,OAAO,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,CAAC,EAC7C,EAAE,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,EAClB,OAAO,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC,GACzB,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,CAoBhB"}

package/dist/function/memoize.js

@@ -0,0 +1,17 @@
+export function memoize(fn, options) {
+    const cache = new Map();
+    const keyOf = options?.keyOf ?? ((args) => args[0]);
+    return function (...args) {
+        const key = keyOf(args);
+        if (cache.has(key)) {
+            const value = cache.get(key);
+            cache.delete(key);
+            cache.set(key, value);
+            return value;
+        }
+        const result = fn(...args);
+        cache.set(key, result);
+        return result;
+    };
+}
+//# sourceMappingURL=memoize.js.map

package/dist/function/memoize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"memoize.js","sourceRoot":"","sources":["../../src/function/memoize.ts"],"names":[],"mappings":"AAmBA,MAAM,UAAU,OAAO,CACtB,EAAkB,EAClB,OAA2B;IAE3B,MAAM,KAAK,GAAG,IAAI,GAAG,EAAc,CAAC;IAEpC,MAAM,KAAK,GAAG,OAAO,EAAE,KAAK,IAAI,CAAC,CAAC,IAAO,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;IAEvD,OAAO,UAAU,GAAG,IAAO;QAC1B,MAAM,GAAG,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC;QAExB,IAAI,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;YACpB,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAE,CAAC;YAC9B,KAAK,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YAClB,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,KAAK,CAAC,CAAC;YACtB,OAAO,KAAK,CAAC;QACd,CAAC;QAED,MAAM,MAAM,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC;QAC3B,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,MAAM,CAAC,CAAC;QAEvB,OAAO,MAAM,CAAC;IACf,CAAC,CAAC;AACH,CAAC"}

package/dist/function/no-throw.d.ts

@@ -0,0 +1,39 @@
+import type { Callable, MaybeAsyncCallable } from "../types/callable.js";
+/**
+ * Calls a function, containing any error it throws — the error still surfaces,
+ * out of band (via `queueMicrotask`), instead of propagating to this call's
+ * caller.
+ *
+ * Note: this does not handle promise rejections. For async functions, use
+ * {@link catchOutOfBandApplyAsync}.
+ *
+ * @param func The function to call.
+ * @param args Arguments to pass to it.
+ * @returns The function's result, or `undefined` if it threw.
+ */
+export declare function catchOutOfBandApply<A extends unknown[], R>(func: Callable<A, R>, args: A): R | undefined;
+/**
+ * Calls a function, containing any error it throws or rejects with — the error
+ * still surfaces, out of band, instead of propagating to this call's caller.
+ *
+ * @param func The function to call.
+ * @param args Arguments to pass to it.
+ * @returns The function's result, or `undefined` if it threw or rejected.
+ */
+export declare function catchOutOfBandApplyAsync<A extends unknown[], R>(func: MaybeAsyncCallable<A, R>, args: A): Promise<R | undefined>;
+/**
+ * Runs `work`, containing any error it throws. See {@link catchOutOfBandApply}.
+ *
+ * @param work The action to run.
+ * @returns `work`'s result, or `undefined` if it threw.
+ */
+export declare function catchOutOfBand<T>(work: Callable<[], T>): T | undefined;
+/**
+ * Runs `work`, containing any error it throws or rejects with. See
+ * {@link catchOutOfBandApplyAsync}.
+ *
+ * @param work The action to run.
+ * @returns `work`'s result, or `undefined` if it threw or rejected.
+ */
+export declare function catchOutOfBandAsync<T>(work: MaybeAsyncCallable<[], T>): Promise<T | undefined>;
+//# sourceMappingURL=no-throw.d.ts.map

package/dist/function/no-throw.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-throw.d.ts","sourceRoot":"","sources":["../../src/function/no-throw.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAC;AAGzE;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,CAAC,EACzD,IAAI,EAAE,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,EACpB,IAAI,EAAE,CAAC,GACL,CAAC,GAAG,SAAS,CAMf;AAED;;;;;;;GAOG;AACH,wBAAsB,wBAAwB,CAAC,CAAC,SAAS,OAAO,EAAE,EAAE,CAAC,EACpE,IAAI,EAAE,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,EAC9B,IAAI,EAAE,CAAC,GACL,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAcxB;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAAE,IAAI,EAAE,QAAQ,CAAC,EAAE,EAAE,CAAC,CAAC,GAAG,CAAC,GAAG,SAAS,CAEtE;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EACpC,IAAI,EAAE,kBAAkB,CAAC,EAAE,EAAE,CAAC,CAAC,GAC7B,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAExB"}

package/dist/function/no-throw.js

@@ -0,0 +1,66 @@
+import { rejectOutOfBand } from "../error/reject-out-of-band.js";
+import { throwOutOfBand } from "../error/throw-out-of-band.js";
+/**
+ * Calls a function, containing any error it throws — the error still surfaces,
+ * out of band (via `queueMicrotask`), instead of propagating to this call's
+ * caller.
+ *
+ * Note: this does not handle promise rejections. For async functions, use
+ * {@link catchOutOfBandApplyAsync}.
+ *
+ * @param func The function to call.
+ * @param args Arguments to pass to it.
+ * @returns The function's result, or `undefined` if it threw.
+ */
+export function catchOutOfBandApply(func, args) {
+    try {
+        return func.apply(undefined, args);
+    }
+    catch (error) {
+        throwOutOfBand(error);
+    }
+}
+/**
+ * Calls a function, containing any error it throws or rejects with — the error
+ * still surfaces, out of band, instead of propagating to this call's caller.
+ *
+ * @param func The function to call.
+ * @param args Arguments to pass to it.
+ * @returns The function's result, or `undefined` if it threw or rejected.
+ */
+export async function catchOutOfBandApplyAsync(func, args) {
+    let result;
+    try {
+        result = func.apply(undefined, args);
+    }
+    catch (error) {
+        throwOutOfBand(error);
+        return;
+    }
+    try {
+        return await result;
+    }
+    catch (error) {
+        rejectOutOfBand(error);
+    }
+}
+/**
+ * Runs `work`, containing any error it throws. See {@link catchOutOfBandApply}.
+ *
+ * @param work The action to run.
+ * @returns `work`'s result, or `undefined` if it threw.
+ */
+export function catchOutOfBand(work) {
+    return catchOutOfBandApply(work, []);
+}
+/**
+ * Runs `work`, containing any error it throws or rejects with. See
+ * {@link catchOutOfBandApplyAsync}.
+ *
+ * @param work The action to run.
+ * @returns `work`'s result, or `undefined` if it threw or rejected.
+ */
+export function catchOutOfBandAsync(work) {
+    return catchOutOfBandApplyAsync(work, []);
+}
+//# sourceMappingURL=no-throw.js.map

package/dist/function/no-throw.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-throw.js","sourceRoot":"","sources":["../../src/function/no-throw.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,gCAAgC,CAAC;AACjE,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAI/D;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,mBAAmB,CAClC,IAAoB,EACpB,IAAO;IAEP,IAAI,CAAC;QACJ,OAAO,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IACpC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QAChB,cAAc,CAAC,KAAK,CAAC,CAAC;IACvB,CAAC;AACF,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,wBAAwB,CAC7C,IAA8B,EAC9B,IAAO;IAEP,IAAI,MAA2B,CAAC;IAChC,IAAI,CAAC;QACJ,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,IAAI,CAAC,CAAC;IACtC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QAChB,cAAc,CAAC,KAAK,CAAC,CAAC;QACtB,OAAO;IACR,CAAC;IAED,IAAI,CAAC;QACJ,OAAO,MAAM,MAAM,CAAC;IACrB,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QAChB,eAAe,CAAC,KAAK,CAAC,CAAC;IACxB,CAAC;AACF,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAAI,IAAqB;IACtD,OAAO,mBAAmB,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;AACtC,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,mBAAmB,CAClC,IAA+B;IAE/B,OAAO,wBAAwB,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;AAC3C,CAAC"}

package/dist/function/serialize-queue-next.d.ts

@@ -0,0 +1,21 @@
+import type { AsyncCallable, MaybeAsyncCallableNoArgs } from "../types/callable.js";
+/**
+ * Wraps an asynchronous function to ensure that only one instance runs at a
+ * time, and if called again while running, only one additional call is queued
+ * to run immediately after the current one completes.
+ *
+ * This pattern serializes async operations and queues at most one next call. If
+ * multiple calls are made while an operation is in progress, they all share the
+ * same promise for the next execution.
+ *
+ * Useful for preventing overlapping async operations (such as network or file
+ * requests) while ensuring that the latest requested operation is not lost.
+ *
+ * This is a specialized form of serialization with a single-call queue, zero
+ * wait time, and no arguments.
+ *
+ * @param func The asynchronous function to wrap.
+ * @returns The wrapped function.
+ */
+export declare function serializeQueueNext<T>(func: MaybeAsyncCallableNoArgs<T>): AsyncCallable<[signal?: AbortSignal | null], T>;
+//# sourceMappingURL=serialize-queue-next.d.ts.map

package/dist/function/serialize-queue-next.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize-queue-next.d.ts","sourceRoot":"","sources":["../../src/function/serialize-queue-next.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,aAAa,EACb,wBAAwB,EACxB,MAAM,sBAAsB,CAAC;AAE9B;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EACnC,IAAI,EAAE,wBAAwB,CAAC,CAAC,CAAC,GAC/B,aAAa,CAAC,CAAC,MAAM,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC,EAAE,CAAC,CAAC,CA0CjD"}

package/dist/function/serialize-queue-next.js

@@ -0,0 +1,56 @@
+/**
+ * Wraps an asynchronous function to ensure that only one instance runs at a
+ * time, and if called again while running, only one additional call is queued
+ * to run immediately after the current one completes.
+ *
+ * This pattern serializes async operations and queues at most one next call. If
+ * multiple calls are made while an operation is in progress, they all share the
+ * same promise for the next execution.
+ *
+ * Useful for preventing overlapping async operations (such as network or file
+ * requests) while ensuring that the latest requested operation is not lost.
+ *
+ * This is a specialized form of serialization with a single-call queue, zero
+ * wait time, and no arguments.
+ *
+ * @param func The asynchronous function to wrap.
+ * @returns The wrapped function.
+ */
+export function serializeQueueNext(func) {
+    let currentDeferred;
+    let nextDeferred;
+    const execute = (deferred) => {
+        currentDeferred = deferred;
+        Promise.try(func)
+            .then(deferred.resolve, deferred.reject)
+            .finally(() => {
+            currentDeferred = undefined;
+            // If there's a queued call, execute it next
+            if (nextDeferred) {
+                const next = nextDeferred;
+                nextDeferred = undefined;
+                execute(next);
+            }
+        });
+    };
+    return () => {
+        let deferred = Promise.withResolvers();
+        // If there's already a call in progress, queue this one
+        if (currentDeferred) {
+            // If there's already a next call queued, use its deferred
+            if (nextDeferred) {
+                deferred = nextDeferred;
+            }
+            // Else, queue this call as the next one
+            else {
+                nextDeferred = deferred;
+            }
+        }
+        // No call in progress, execute immediately
+        else {
+            execute(deferred);
+        }
+        return deferred.promise;
+    };
+}
+//# sourceMappingURL=serialize-queue-next.js.map

package/dist/function/serialize-queue-next.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize-queue-next.js","sourceRoot":"","sources":["../../src/function/serialize-queue-next.ts"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,kBAAkB,CACjC,IAAiC;IAEjC,IAAI,eAAoD,CAAC;IACzD,IAAI,YAAiD,CAAC;IAEtD,MAAM,OAAO,GAAG,CAAC,QAAiC,EAAQ,EAAE;QAC3D,eAAe,GAAG,QAAQ,CAAC;QAE3B,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC;aACf,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,QAAQ,CAAC,MAAM,CAAC;aACvC,OAAO,CAAC,GAAG,EAAE;YACb,eAAe,GAAG,SAAS,CAAC;YAE5B,4CAA4C;YAC5C,IAAI,YAAY,EAAE,CAAC;gBAClB,MAAM,IAAI,GAAG,YAAY,CAAC;gBAC1B,YAAY,GAAG,SAAS,CAAC;gBACzB,OAAO,CAAC,IAAI,CAAC,CAAC;YACf,CAAC;QACF,CAAC,CAAC,CAAC;IACL,CAAC,CAAC;IAEF,OAAO,GAAG,EAAE;QACX,IAAI,QAAQ,GAAG,OAAO,CAAC,aAAa,EAAK,CAAC;QAE1C,wDAAwD;QACxD,IAAI,eAAe,EAAE,CAAC;YACrB,0DAA0D;YAC1D,IAAI,YAAY,EAAE,CAAC;gBAClB,QAAQ,GAAG,YAAY,CAAC;YACzB,CAAC;YACD,wCAAwC;iBACnC,CAAC;gBACL,YAAY,GAAG,QAAQ,CAAC;YACzB,CAAC;QACF,CAAC;QACD,2CAA2C;aACtC,CAAC;YACL,OAAO,CAAC,QAAQ,CAAC,CAAC;QACnB,CAAC;QAED,OAAO,QAAQ,CAAC,OAAO,CAAC;IACzB,CAAC,CAAC;AACH,CAAC"}

package/dist/function/settle.d.ts

@@ -0,0 +1,21 @@
+import { MaybePromiseLike } from "../types/promise.js";
+/**
+ * Runs `work`, discarding any error it throws or rejects with.
+ *
+ * Unlike {@link catchOutOfBandAsync}, which still surfaces the error out of band
+ * via `queueMicrotask`, this truly discards it — for a best-effort action whose
+ * failure must never be reported at all (e.g. a `catch` block's own teardown,
+ * which must not mask the failure that made it necessary in the first place).
+ *
+ * @param work Action to run. Omitted (or `null`) is a no-op.
+ * @returns The resolved value, or `undefined` if `work` threw or rejected.
+ */
+export declare function catchSilentlyAsync<T>(work?: (() => MaybePromiseLike<T>) | null): Promise<T | undefined>;
+/**
+ * Runs `work`, discarding any error it throws. See {@link catchSilentlyAsync}.
+ *
+ * @param work Action to run. Omitted (or `null`) is a no-op.
+ * @returns `work`'s result, or `undefined` if it threw.
+ */
+export declare function catchSilently<T>(work?: (() => T) | null): T | undefined;
+//# sourceMappingURL=settle.d.ts.map

package/dist/function/settle.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"settle.d.ts","sourceRoot":"","sources":["../../src/function/settle.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvD;;;;;;;;;;GAUG;AACH,wBAAsB,kBAAkB,CAAC,CAAC,EACzC,IAAI,CAAC,EAAE,CAAC,MAAM,gBAAgB,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,GACvC,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC,CAMxB;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC,MAAM,CAAC,CAAC,GAAG,IAAI,GAAG,CAAC,GAAG,SAAS,CAMvE"}

package/dist/function/settle.js

@@ -0,0 +1,34 @@
+/**
+ * Runs `work`, discarding any error it throws or rejects with.
+ *
+ * Unlike {@link catchOutOfBandAsync}, which still surfaces the error out of band
+ * via `queueMicrotask`, this truly discards it — for a best-effort action whose
+ * failure must never be reported at all (e.g. a `catch` block's own teardown,
+ * which must not mask the failure that made it necessary in the first place).
+ *
+ * @param work Action to run. Omitted (or `null`) is a no-op.
+ * @returns The resolved value, or `undefined` if `work` threw or rejected.
+ */
+export async function catchSilentlyAsync(work) {
+    try {
+        return await work?.();
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Runs `work`, discarding any error it throws. See {@link catchSilentlyAsync}.
+ *
+ * @param work Action to run. Omitted (or `null`) is a no-op.
+ * @returns `work`'s result, or `undefined` if it threw.
+ */
+export function catchSilently(work) {
+    try {
+        return work?.();
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=settle.js.map

package/dist/function/settle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"settle.js","sourceRoot":"","sources":["../../src/function/settle.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CACvC,IAAyC;IAEzC,IAAI,CAAC;QACJ,OAAO,MAAM,IAAI,EAAE,EAAE,CAAC;IACvB,CAAC;IAAC,MAAM,CAAC;QACR,OAAO,SAAS,CAAC;IAClB,CAAC;AACF,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAAI,IAAuB;IACvD,IAAI,CAAC;QACJ,OAAO,IAAI,EAAE,EAAE,CAAC;IACjB,CAAC;IAAC,MAAM,CAAC;QACR,OAAO,SAAS,CAAC;IAClB,CAAC;AACF,CAAC"}

package/dist/function/variadic-args.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Support for functions that accept either a single array or the values
+ * themselves.
+ *
+ * The variadic form reads well for a handful of literals — `mean(1, 2, 3)` —
+ * but it is unusable on real data: spreading builds a fresh argument list, and
+ * V8 throws `RangeError` somewhere past 100 000 arguments. Offering both shapes
+ * costs one overload and one call to {@link fromVariadicArgs}.
+ *
+ * It only works for functions that accept primitive values or objects that are
+ * not themselves arrays. The two shapes are distinguished by looking at the
+ * first argument, so `VariadicArgs<[]>` would be ambiguous.
+ *
+ * @example
+ * 	```ts
+ *      export function sum(values: readonly number[]): number;
+ *      export function sum(...values: number[]): number;
+ *      export function sum(...args: VariadicArgs<number>): number {
+ *              const values = fromVariadicArgs(args);
+ *              // …
+ *      }
+ *      ```;
+ */
+/**
+ * Rest parameter type for a function overloaded to accept an array or loose
+ * values.
+ *
+ * @template T The element type. Must not itself be an array type: the two
+ *   shapes are told apart by looking at the first argument, so
+ *   `VariadicArgs<number[]>` would be ambiguous.
+ */
+export type VariadicArgs<T> = [readonly T[]] | T[];
+/**
+ * Reduces either accepted argument shape to a single array.
+ *
+ * @param args The raw rest arguments.
+ * @returns The values. The array passed by the caller is returned as-is, not
+ *   copied, so a function that reorders its input must take its own copy.
+ */
+export declare function fromVariadicArgs<T>(args: VariadicArgs<T>): readonly T[];
+//# sourceMappingURL=variadic-args.d.ts.map

package/dist/function/variadic-args.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"variadic-args.d.ts","sourceRoot":"","sources":["../../src/function/variadic-args.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;;;;GAOG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,CAAC;AAEnD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,IAAI,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,EAAE,CAIvE"}

package/dist/function/variadic-args.js

@@ -0,0 +1,36 @@
+/**
+ * Support for functions that accept either a single array or the values
+ * themselves.
+ *
+ * The variadic form reads well for a handful of literals — `mean(1, 2, 3)` —
+ * but it is unusable on real data: spreading builds a fresh argument list, and
+ * V8 throws `RangeError` somewhere past 100 000 arguments. Offering both shapes
+ * costs one overload and one call to {@link fromVariadicArgs}.
+ *
+ * It only works for functions that accept primitive values or objects that are
+ * not themselves arrays. The two shapes are distinguished by looking at the
+ * first argument, so `VariadicArgs<[]>` would be ambiguous.
+ *
+ * @example
+ * 	```ts
+ *      export function sum(values: readonly number[]): number;
+ *      export function sum(...values: number[]): number;
+ *      export function sum(...args: VariadicArgs<number>): number {
+ *              const values = fromVariadicArgs(args);
+ *              // …
+ *      }
+ *      ```;
+ */
+/**
+ * Reduces either accepted argument shape to a single array.
+ *
+ * @param args The raw rest arguments.
+ * @returns The values. The array passed by the caller is returned as-is, not
+ *   copied, so a function that reorders its input must take its own copy.
+ */
+export function fromVariadicArgs(args) {
+    return args.length === 1 && Array.isArray(args[0])
+        ? args[0]
+        : args;
+}
+//# sourceMappingURL=variadic-args.js.map

package/dist/function/variadic-args.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"variadic-args.js","sourceRoot":"","sources":["../../src/function/variadic-args.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAYH;;;;;;GAMG;AACH,MAAM,UAAU,gBAAgB,CAAI,IAAqB;IACxD,OAAO,IAAI,CAAC,MAAM,KAAK,CAAC,IAAI,KAAK,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;QACjD,CAAC,CAAE,IAAI,CAAC,CAAC,CAAkB;QAC3B,CAAC,CAAE,IAAY,CAAC;AAClB,CAAC"}

package/dist/function/wait-for.d.ts

@@ -0,0 +1,22 @@
+import type { MaybeAsyncPredicate } from "../types/callable.js";
+export type WaitForOptions = {
+    signal?: AbortSignal | null;
+    intervalMs?: number;
+};
+export declare const WAIT_FOR_DEFAULT_OPTIONS: Required<WaitForOptions>;
+/**
+ * Waits until the provided condition function returns true.
+ *
+ * The condition function can be synchronous or asynchronous (returning a
+ * Promise). The function checks the condition at regular intervals specified by
+ * `intervalMs`.
+ *
+ * Note: This function shouldn't be used inplace of the `vi.waitFor` function
+ * from Vitest. This function is meant to be used in non-test code.
+ *
+ * @param predicate A function that returns a boolean or a Promise that resolves
+ *   to a boolean.
+ * @param options Options for configuring the wait behavior.
+ */
+export declare function waitFor(predicate: MaybeAsyncPredicate, options?: WaitForOptions): Promise<void>;
+//# sourceMappingURL=wait-for.d.ts.map

package/dist/function/wait-for.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait-for.d.ts","sourceRoot":"","sources":["../../src/function/wait-for.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAEhE,MAAM,MAAM,cAAc,GAAG;IAE5B,MAAM,CAAC,EAAE,WAAW,GAAG,IAAI,CAAC;IAG5B,UAAU,CAAC,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF,eAAO,MAAM,wBAAwB,EAAE,QAAQ,CAAC,cAAc,CAG7D,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,wBAAsB,OAAO,CAC5B,SAAS,EAAE,mBAAmB,EAC9B,OAAO,CAAC,EAAE,cAAc,GACtB,OAAO,CAAC,IAAI,CAAC,CAMf"}

package/dist/function/wait-for.js

@@ -0,0 +1,27 @@
+import { defaults } from "../object/defaults.js";
+import { sleep } from "../time/sleep.js";
+export const WAIT_FOR_DEFAULT_OPTIONS = {
+    signal: null,
+    intervalMs: 50,
+};
+/**
+ * Waits until the provided condition function returns true.
+ *
+ * The condition function can be synchronous or asynchronous (returning a
+ * Promise). The function checks the condition at regular intervals specified by
+ * `intervalMs`.
+ *
+ * Note: This function shouldn't be used inplace of the `vi.waitFor` function
+ * from Vitest. This function is meant to be used in non-test code.
+ *
+ * @param predicate A function that returns a boolean or a Promise that resolves
+ *   to a boolean.
+ * @param options Options for configuring the wait behavior.
+ */
+export async function waitFor(predicate, options) {
+    const effectiveOptions = defaults(options, WAIT_FOR_DEFAULT_OPTIONS);
+    while (!(await predicate())) {
+        await sleep(effectiveOptions.intervalMs, effectiveOptions.signal);
+    }
+}
+//# sourceMappingURL=wait-for.js.map

package/dist/function/wait-for.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait-for.js","sourceRoot":"","sources":["../../src/function/wait-for.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAWzC,MAAM,CAAC,MAAM,wBAAwB,GAA6B;IACjE,MAAM,EAAE,IAAI;IACZ,UAAU,EAAE,EAAE;CACd,CAAC;AAEF;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,KAAK,UAAU,OAAO,CAC5B,SAA8B,EAC9B,OAAwB;IAExB,MAAM,gBAAgB,GAAG,QAAQ,CAAC,OAAO,EAAE,wBAAwB,CAAC,CAAC;IAErE,OAAO,CAAC,CAAC,MAAM,SAAS,EAAE,CAAC,EAAE,CAAC;QAC7B,MAAM,KAAK,CAAC,gBAAgB,CAAC,UAAU,EAAE,gBAAgB,CAAC,MAAM,CAAC,CAAC;IACnE,CAAC;AACF,CAAC"}

package/dist/guards/is-aggregate-error.d.ts

@@ -0,0 +1,7 @@
+import { IAggregateError } from "../types/error.js";
+/**
+ * Test if value is AggregateError-like (has name, message and errors
+ * properties)
+ */
+export declare function isAggregateErrorLike(value: unknown): value is IAggregateError;
+//# sourceMappingURL=is-aggregate-error.d.ts.map

package/dist/guards/is-aggregate-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-aggregate-error.d.ts","sourceRoot":"","sources":["../../src/guards/is-aggregate-error.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAGpD;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,eAAe,CAE7E"}

package/dist/guards/is-aggregate-error.js

@@ -0,0 +1,9 @@
+import { isErrorLike } from "./is-error.js";
+/**
+ * Test if value is AggregateError-like (has name, message and errors
+ * properties)
+ */
+export function isAggregateErrorLike(value) {
+    return isErrorLike(value) && "errors" in value;
+}
+//# sourceMappingURL=is-aggregate-error.js.map

package/dist/guards/is-aggregate-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-aggregate-error.js","sourceRoot":"","sources":["../../src/guards/is-aggregate-error.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5C;;;GAGG;AACH,MAAM,UAAU,oBAAoB,CAAC,KAAc;IAClD,OAAO,WAAW,CAAC,KAAK,CAAC,IAAI,QAAQ,IAAI,KAAK,CAAC;AAChD,CAAC"}

package/dist/guards/is-array-buffer.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Check if a value is an `ArrayBuffer`.
+ *
+ * A `SharedArrayBuffer` does not pass — the two are distinct types with
+ * distinct ownership semantics. Use `isSharedArrayBuffer` for that one.
+ *
+ * Realm-bound: an `ArrayBuffer` built in another realm (worker, iframe, vm
+ * context) is not recognised.
+ *
+ * @param value The value to check
+ * @returns True if the value is an `ArrayBuffer`
+ */
+export declare function isArrayBuffer(value: unknown): value is ArrayBuffer;
+//# sourceMappingURL=is-array-buffer.d.ts.map

package/dist/guards/is-array-buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-array-buffer.d.ts","sourceRoot":"","sources":["../../src/guards/is-array-buffer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,WAAW,CAElE"}

package/dist/guards/is-array-buffer.js

@@ -0,0 +1,16 @@
+/**
+ * Check if a value is an `ArrayBuffer`.
+ *
+ * A `SharedArrayBuffer` does not pass — the two are distinct types with
+ * distinct ownership semantics. Use `isSharedArrayBuffer` for that one.
+ *
+ * Realm-bound: an `ArrayBuffer` built in another realm (worker, iframe, vm
+ * context) is not recognised.
+ *
+ * @param value The value to check
+ * @returns True if the value is an `ArrayBuffer`
+ */
+export function isArrayBuffer(value) {
+    return value instanceof ArrayBuffer;
+}
+//# sourceMappingURL=is-array-buffer.js.map

package/dist/guards/is-array-buffer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"is-array-buffer.js","sourceRoot":"","sources":["../../src/guards/is-array-buffer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,aAAa,CAAC,KAAc;IAC3C,OAAO,KAAK,YAAY,WAAW,CAAC;AACrC,CAAC"}