@ac-kit/core 0.1.0

package/dist/error/traverse-error.js

@@ -0,0 +1,72 @@
+import { isAggregateErrorLike } from "../guards/is-aggregate-error.js";
+import { isErrorLike } from "../guards/is-error.js";
+import { isSuppressedErrorLike } from "../guards/is-suppressed-error.js";
+import { defaults } from "../object/defaults.js";
+/**
+ * Traverse an error and its inner errors, calling a callback for each error
+ * encountered.
+ *
+ * The traversal can be stopped at any time by returning false from the
+ * callback.
+ *
+ * @param error - The root error to traverse.
+ * @param callback - A function called for each error encountered. If it returns
+ *   false, the traversal stops.
+ * @param options - Options to control the traversal behavior.
+ */
+export function traverseError(error, callback, options) {
+    const effectiveOptions = defaults(options, {
+        traverseCause: true,
+        traverseAggregateErrors: true,
+        traverseSuppressedError: true,
+        traverseSuppressedSuppressed: true,
+        skipNullErrors: false,
+    });
+    internalTraverseError(error, callback, effectiveOptions, new Set());
+}
+function internalTraverseError(error, callback, options, visited, parent, source) {
+    if (error === undefined || (error === null && options.skipNullErrors)) {
+        return true;
+    }
+    let shouldContinue = callback(error, parent ?? null, source ?? null);
+    if (shouldContinue === false) {
+        return false;
+    }
+    if (!isErrorLike(error)) {
+        return true;
+    }
+    if (visited.has(error)) {
+        return false;
+    }
+    visited.add(error);
+    if (options.traverseAggregateErrors && isAggregateErrorLike(error)) {
+        for (const innerError of error.errors) {
+            shouldContinue = internalTraverseError(innerError, callback, options, visited, error, "aggregate-errors");
+            if (!shouldContinue) {
+                return false;
+            }
+        }
+    }
+    if (isSuppressedErrorLike(error)) {
+        if (options.traverseSuppressedError) {
+            shouldContinue = internalTraverseError(error.error, callback, options, visited, error, "suppressed-error");
+            if (!shouldContinue) {
+                return false;
+            }
+        }
+        if (options.traverseSuppressedSuppressed) {
+            shouldContinue = internalTraverseError(error.suppressed, callback, options, visited, error, "suppressed-suppressed");
+            if (!shouldContinue) {
+                return false;
+            }
+        }
+    }
+    if (options.traverseCause) {
+        shouldContinue = internalTraverseError(error.cause, callback, options, visited, error, "cause");
+        if (!shouldContinue) {
+            return false;
+        }
+    }
+    return true;
+}
+//# sourceMappingURL=traverse-error.js.map

package/dist/error/traverse-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"traverse-error.js","sourceRoot":"","sources":["../../src/error/traverse-error.ts"],"names":[],"mappings":"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"}

package/dist/error/unimplemented-error.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Error indicating that a feature is not implemented.
+ *
+ * Use this error to indicate that a particular feature or functionality is not
+ * yet implemented in the codebase.
+ *
+ * Usage example:
+ *
+ * ```ts
+ * switch (type) {
+ *  case "A":
+ * 	  // Handle type A
+ * 	  break;
+ *  default:
+ * 	  throw new UnimplementedError("type ${type}`);
+ * }
+ * ```
+ */
+export declare class UnimplementedError extends Error {
+    constructor(message?: string, options?: ErrorOptions);
+}
+//# sourceMappingURL=unimplemented-error.d.ts.map

package/dist/error/unimplemented-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unimplemented-error.d.ts","sourceRoot":"","sources":["../../src/error/unimplemented-error.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC5C,YAAY,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,EAInD;CACD"}

package/dist/error/unimplemented-error.js

@@ -0,0 +1,25 @@
+/**
+ * Error indicating that a feature is not implemented.
+ *
+ * Use this error to indicate that a particular feature or functionality is not
+ * yet implemented in the codebase.
+ *
+ * Usage example:
+ *
+ * ```ts
+ * switch (type) {
+ *  case "A":
+ * 	  // Handle type A
+ * 	  break;
+ *  default:
+ * 	  throw new UnimplementedError("type ${type}`);
+ * }
+ * ```
+ */
+export class UnimplementedError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "UnimplementedError";
+    }
+}
+//# sourceMappingURL=unimplemented-error.js.map

package/dist/error/unimplemented-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unimplemented-error.js","sourceRoot":"","sources":["../../src/error/unimplemented-error.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,OAAO,kBAAmB,SAAQ,KAAK;IAC5C,YAAY,OAAgB,EAAE,OAAsB;QACnD,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QAExB,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC;IAClC,CAAC;CACD"}

package/dist/error/unsupported-error.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Error indicating that a feature is not supported.
+ *
+ * Use this error to indicate that a particular feature or functionality is not
+ * supported in the current environment or context.
+ */
+export declare class UnsupportedError extends Error {
+    constructor(message?: string, options?: ErrorOptions);
+}
+//# sourceMappingURL=unsupported-error.d.ts.map

package/dist/error/unsupported-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unsupported-error.d.ts","sourceRoot":"","sources":["../../src/error/unsupported-error.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,qBAAa,gBAAiB,SAAQ,KAAK;IAC1C,YAAY,OAAO,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,EAInD;CACD"}

package/dist/error/unsupported-error.js

@@ -0,0 +1,13 @@
+/**
+ * Error indicating that a feature is not supported.
+ *
+ * Use this error to indicate that a particular feature or functionality is not
+ * supported in the current environment or context.
+ */
+export class UnsupportedError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "UnsupportedError";
+    }
+}
+//# sourceMappingURL=unsupported-error.js.map

package/dist/error/unsupported-error.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unsupported-error.js","sourceRoot":"","sources":["../../src/error/unsupported-error.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,MAAM,OAAO,gBAAiB,SAAQ,KAAK;IAC1C,YAAY,OAAgB,EAAE,OAAsB;QACnD,KAAK,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;QAExB,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAC;IAChC,CAAC;CACD"}

package/dist/error/v8-stack-trace.d.ts

@@ -0,0 +1,27 @@
+import type { V8CallSite } from "../types/v8-call-site.js";
+export type V8StackFrame = {
+    this: unknown;
+    typeName: string | null;
+    function: Function | undefined;
+    functionName: string | null;
+    methodName: string | null;
+    fileName: string | null;
+    lineNumber: number | null;
+    columnNumber: number | null;
+    evalOrigin: string | undefined;
+    toplevel: boolean;
+    eval: boolean;
+    native: boolean;
+    constructor: boolean;
+    async: boolean;
+    promiseAll: boolean;
+    promiseIndex: number | null;
+    enclosingColumnNumber: number | null;
+    enclosingLineNumber: number | null;
+    position: number;
+    scriptHash: string;
+    scriptNameOrSourceURL: string | null;
+};
+export type V8StackTrace = V8StackFrame[];
+export declare function composeV8StackFrameFromV8CallSite(callSite: V8CallSite): V8StackFrame;
+//# sourceMappingURL=v8-stack-trace.d.ts.map

package/dist/error/v8-stack-trace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v8-stack-trace.d.ts","sourceRoot":"","sources":["../../src/error/v8-stack-trace.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAE3D,MAAM,MAAM,YAAY,GAAG;IAE1B,IAAI,EAAE,OAAO,CAAC;IAEd,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAExB,QAAQ,EAAE,QAAQ,GAAG,SAAS,CAAC;IAE/B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAE5B,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAG1B,QAAQ,EAAE,MAAM,GAAG,IAAI,CAAC;IAExB,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IAE1B,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAE5B,UAAU,EAAE,MAAM,GAAG,SAAS,CAAC;IAG/B,QAAQ,EAAE,OAAO,CAAC;IAElB,IAAI,EAAE,OAAO,CAAC;IAEd,MAAM,EAAE,OAAO,CAAC;IAEhB,WAAW,EAAE,OAAO,CAAC;IAErB,KAAK,EAAE,OAAO,CAAC;IAEf,UAAU,EAAE,OAAO,CAAC;IAEpB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAG5B,qBAAqB,EAAE,MAAM,GAAG,IAAI,CAAC;IACrC,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;IACnB,qBAAqB,EAAE,MAAM,GAAG,IAAI,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG,YAAY,EAAE,CAAC;AAG1C,wBAAgB,iCAAiC,CAChD,QAAQ,EAAE,UAAU,GAClB,YAAY,CAwBd"}

package/dist/error/v8-stack-trace.js

@@ -0,0 +1,27 @@
+// https://v8.dev/docs/stack-trace-api#customizing-stack-traces
+export function composeV8StackFrameFromV8CallSite(callSite) {
+    return {
+        this: callSite.getThis(),
+        typeName: callSite.getTypeName(),
+        function: callSite.getFunction(),
+        functionName: callSite.getFunctionName(),
+        methodName: callSite.getMethodName(),
+        fileName: callSite.getFileName(),
+        lineNumber: callSite.getLineNumber(),
+        columnNumber: callSite.getColumnNumber(),
+        evalOrigin: callSite.getEvalOrigin(),
+        toplevel: callSite.isToplevel(),
+        eval: callSite.isEval(),
+        native: callSite.isNative(),
+        constructor: callSite.isConstructor(),
+        async: callSite.isAsync(),
+        promiseAll: callSite.isPromiseAll(),
+        promiseIndex: callSite.getPromiseIndex(),
+        enclosingColumnNumber: callSite.getEnclosingColumnNumber(),
+        enclosingLineNumber: callSite.getEnclosingLineNumber(),
+        position: callSite.getPosition(),
+        scriptHash: callSite.getScriptHash(),
+        scriptNameOrSourceURL: callSite.getScriptNameOrSourceURL(),
+    };
+}
+//# sourceMappingURL=v8-stack-trace.js.map

package/dist/error/v8-stack-trace.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"v8-stack-trace.js","sourceRoot":"","sources":["../../src/error/v8-stack-trace.ts"],"names":[],"mappings":"AAgDA,+DAA+D;AAC/D,MAAM,UAAU,iCAAiC,CAChD,QAAoB;IAEpB,OAAO;QACN,IAAI,EAAE,QAAQ,CAAC,OAAO,EAAE;QACxB,QAAQ,EAAE,QAAQ,CAAC,WAAW,EAAE;QAChC,QAAQ,EAAE,QAAQ,CAAC,WAAW,EAAE;QAChC,YAAY,EAAE,QAAQ,CAAC,eAAe,EAAE;QACxC,UAAU,EAAE,QAAQ,CAAC,aAAa,EAAE;QACpC,QAAQ,EAAE,QAAQ,CAAC,WAAW,EAAE;QAChC,UAAU,EAAE,QAAQ,CAAC,aAAa,EAAE;QACpC,YAAY,EAAE,QAAQ,CAAC,eAAe,EAAE;QACxC,UAAU,EAAE,QAAQ,CAAC,aAAa,EAAE;QACpC,QAAQ,EAAE,QAAQ,CAAC,UAAU,EAAE;QAC/B,IAAI,EAAE,QAAQ,CAAC,MAAM,EAAE;QACvB,MAAM,EAAE,QAAQ,CAAC,QAAQ,EAAE;QAC3B,WAAW,EAAE,QAAQ,CAAC,aAAa,EAAE;QACrC,KAAK,EAAE,QAAQ,CAAC,OAAO,EAAE;QACzB,UAAU,EAAE,QAAQ,CAAC,YAAY,EAAE;QACnC,YAAY,EAAE,QAAQ,CAAC,eAAe,EAAE;QACxC,qBAAqB,EAAE,QAAQ,CAAC,wBAAwB,EAAE;QAC1D,mBAAmB,EAAE,QAAQ,CAAC,sBAAsB,EAAE;QACtD,QAAQ,EAAE,QAAQ,CAAC,WAAW,EAAE;QAChC,UAAU,EAAE,QAAQ,CAAC,aAAa,EAAE;QACpC,qBAAqB,EAAE,QAAQ,CAAC,wBAAwB,EAAE;KAC1D,CAAC;AACH,CAAC"}

package/dist/function/compare/compare-natural.d.ts

@@ -0,0 +1,20 @@
+import type { ComparatorResult } from "./types.js";
+/**
+ * Ascending natural order, using the `<` and `>` operators.
+ *
+ * Exact — no tolerance of any kind. Two `number`s compare equivalent only when
+ * `===` says so, which is what keeps this a strict weak ordering; an
+ * approximate comparison is not transitive and would corrupt every sort, bisect
+ * and heap it reached. Use {@link isCloseTo} for approximate tests, and never
+ * as a comparator.
+ *
+ * `NaN` sorts after every other value and is equivalent to itself, so the
+ * ordering stays total. `-0` and `+0` are equivalent, matching `===` and
+ * therefore agreeing with exact equality — deliberately unlike
+ * `%TypedArray%.prototype.sort`, which orders `-0` before `+0` and so cannot
+ * agree with an `===`-based equality.
+ */
+export declare function compareNaturalAscending<T>(a: T, b: T): ComparatorResult;
+/** Descending natural order — the reverse of {@link compareNaturalAscending}. */
+export declare function compareNaturalDescending<T>(a: T, b: T): ComparatorResult;
+//# sourceMappingURL=compare-natural.d.ts.map

package/dist/function/compare/compare-natural.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"compare-natural.d.ts","sourceRoot":"","sources":["../../../src/function/compare/compare-natural.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAC;AAEnD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,gBAAgB,CAiBvE;AAED,iFAAiF;AACjF,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,gBAAgB,CAExE"}

package/dist/function/compare/compare-natural.js

@@ -0,0 +1,37 @@
+/**
+ * Ascending natural order, using the `<` and `>` operators.
+ *
+ * Exact — no tolerance of any kind. Two `number`s compare equivalent only when
+ * `===` says so, which is what keeps this a strict weak ordering; an
+ * approximate comparison is not transitive and would corrupt every sort, bisect
+ * and heap it reached. Use {@link isCloseTo} for approximate tests, and never
+ * as a comparator.
+ *
+ * `NaN` sorts after every other value and is equivalent to itself, so the
+ * ordering stays total. `-0` and `+0` are equivalent, matching `===` and
+ * therefore agreeing with exact equality — deliberately unlike
+ * `%TypedArray%.prototype.sort`, which orders `-0` before `+0` and so cannot
+ * agree with an `===`-based equality.
+ */
+export function compareNaturalAscending(a, b) {
+    if (a < b) {
+        return -1;
+    }
+    if (a > b) {
+        return 1;
+    }
+    // Only reachable when equivalent or NaN is involved, so the self-comparison
+    // never costs anything on the ordered path.
+    if (a !== a) {
+        return b !== b ? 0 : 1;
+    }
+    if (b !== b) {
+        return -1;
+    }
+    return 0;
+}
+/** Descending natural order — the reverse of {@link compareNaturalAscending}. */
+export function compareNaturalDescending(a, b) {
+    return compareNaturalAscending(b, a);
+}
+//# sourceMappingURL=compare-natural.js.map

package/dist/function/compare/compare-natural.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"compare-natural.js","sourceRoot":"","sources":["../../../src/function/compare/compare-natural.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,uBAAuB,CAAI,CAAI,EAAE,CAAI;IACpD,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;QACX,OAAO,CAAC,CAAC,CAAC;IACX,CAAC;IACD,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;QACX,OAAO,CAAC,CAAC;IACV,CAAC;IAED,4EAA4E;IAC5E,4CAA4C;IAC5C,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACb,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IACxB,CAAC;IACD,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;QACb,OAAO,CAAC,CAAC,CAAC;IACX,CAAC;IACD,OAAO,CAAC,CAAC;AACV,CAAC;AAED,iFAAiF;AACjF,MAAM,UAAU,wBAAwB,CAAI,CAAI,EAAE,CAAI;IACrD,OAAO,uBAAuB,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;AACtC,CAAC"}

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

@@ -0,0 +1,12 @@
+import type { Comparator } from "./types.js";
+/**
+ * Chains comparators, each breaking the ties left by the one before it.
+ *
+ * Variadic rather than a `traits` object because the comparators are
+ * homogeneous and their order _is_ the priority; named fields would lose it.
+ *
+ * @param compares Comparators in priority order. At least one is required.
+ * @returns A comparator calling as few of them as the first difference allows.
+ */
+export declare function createChainedComparator<A, B = A>(...compares: readonly [Comparator<A, B>, ...Comparator<A, B>[]]): Comparator<A, B>;
+//# sourceMappingURL=create-chained-comparator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create-chained-comparator.d.ts","sourceRoot":"","sources":["../../../src/function/compare/create-chained-comparator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,EAC/C,GAAG,QAAQ,EAAE,SAAS,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,GAAG,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC,GAC7D,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,CAmBlB"}

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

@@ -0,0 +1,28 @@
+/**
+ * Chains comparators, each breaking the ties left by the one before it.
+ *
+ * Variadic rather than a `traits` object because the comparators are
+ * homogeneous and their order _is_ the priority; named fields would lose it.
+ *
+ * @param compares Comparators in priority order. At least one is required.
+ * @returns A comparator calling as few of them as the first difference allows.
+ */
+export function createChainedComparator(...compares) {
+    const [first, second] = compares;
+    if (compares.length === 1) {
+        return first;
+    }
+    if (compares.length === 2) {
+        return (a, b) => first(a, b) || second(a, b);
+    }
+    return (a, b) => {
+        for (let index = 0; index < compares.length; index++) {
+            const result = compares[index](a, b);
+            if (result !== 0) {
+                return result;
+            }
+        }
+        return 0;
+    };
+}
+//# sourceMappingURL=create-chained-comparator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create-chained-comparator.js","sourceRoot":"","sources":["../../../src/function/compare/create-chained-comparator.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,MAAM,UAAU,uBAAuB,CACtC,GAAG,QAA4D;IAE/D,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,QAAQ,CAAC;IAEjC,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC3B,OAAO,KAAK,CAAC;IACd,CAAC;IACD,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC3B,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,MAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC/C,CAAC;IAED,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;QACf,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;YACtD,MAAM,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAE,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;YACtC,IAAI,MAAM,KAAK,CAAC,EAAE,CAAC;gBAClB,OAAO,MAAM,CAAC;YACf,CAAC;QACF,CAAC;QACD,OAAO,CAAC,CAAC;IACV,CAAC,CAAC;AACH,CAAC"}

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

@@ -0,0 +1,26 @@
+import type { Callable } from "../../types/callable.js";
+import type { Comparator, OrderPredicate } from "./types.js";
+/**
+ * Adapts an {@link OrderPredicate} into a {@link Comparator}.
+ *
+ * Costs two predicate calls per comparison to synthesise the equivalent case —
+ * neither `a` precedes `b` nor `b` precedes `a`. Write a comparator directly
+ * rather than deriving one for a hot loop.
+ */
+export declare function createComparator<T>(precedes: OrderPredicate<T>): Comparator<T>;
+/**
+ * Builds a {@link Comparator} ordering items by one or more derived keys, each
+ * in ascending natural order, earlier keys taking priority over later ones.
+ *
+ * Variadic rather than a `traits` object because the keys are homogeneous and
+ * their order _is_ the priority; named fields would lose it.
+ *
+ * For a key that needs its own ordering — descending, or anything but natural —
+ * compose instead: `createChainedComparator(createComparatorBy(keyOf),
+ * createReversedComparator(createComparatorBy(otherKeyOf)))`.
+ *
+ * @param valueOfs Key accessors, in priority order. At least one is required.
+ * @returns A comparator calling one accessor per operand per key, at worst.
+ */
+export declare function createComparatorBy<T>(...valueOfs: readonly [Callable<[T], unknown>, ...Callable<[T], unknown>[]]): Comparator<T>;
+//# sourceMappingURL=create-comparator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create-comparator.d.ts","sourceRoot":"","sources":["../../../src/function/compare/create-comparator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE7D;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EACjC,QAAQ,EAAE,cAAc,CAAC,CAAC,CAAC,GACzB,UAAU,CAAC,CAAC,CAAC,CAUf;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EACnC,GAAG,QAAQ,EAAE,SAAS,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,GAAG,QAAQ,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,CAAC,GACzE,UAAU,CAAC,CAAC,CAAC,CAsBf"}

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

@@ -0,0 +1,54 @@
+import { compareNaturalAscending } from "./compare-natural.js";
+/**
+ * Adapts an {@link OrderPredicate} into a {@link Comparator}.
+ *
+ * Costs two predicate calls per comparison to synthesise the equivalent case —
+ * neither `a` precedes `b` nor `b` precedes `a`. Write a comparator directly
+ * rather than deriving one for a hot loop.
+ */
+export function createComparator(precedes) {
+    return (a, b) => {
+        if (precedes(a, b)) {
+            return -1;
+        }
+        if (precedes(b, a)) {
+            return 1;
+        }
+        return 0;
+    };
+}
+/**
+ * Builds a {@link Comparator} ordering items by one or more derived keys, each
+ * in ascending natural order, earlier keys taking priority over later ones.
+ *
+ * Variadic rather than a `traits` object because the keys are homogeneous and
+ * their order _is_ the priority; named fields would lose it.
+ *
+ * For a key that needs its own ordering — descending, or anything but natural —
+ * compose instead: `createChainedComparator(createComparatorBy(keyOf),
+ * createReversedComparator(createComparatorBy(otherKeyOf)))`.
+ *
+ * @param valueOfs Key accessors, in priority order. At least one is required.
+ * @returns A comparator calling one accessor per operand per key, at worst.
+ */
+export function createComparatorBy(...valueOfs) {
+    const [first, second] = valueOfs;
+    if (valueOfs.length === 1) {
+        return (a, b) => compareNaturalAscending(first(a), first(b));
+    }
+    if (valueOfs.length === 2) {
+        return (a, b) => compareNaturalAscending(first(a), first(b)) ||
+            compareNaturalAscending(second(a), second(b));
+    }
+    return (a, b) => {
+        for (let index = 0; index < valueOfs.length; index++) {
+            const valueOf = valueOfs[index];
+            const result = compareNaturalAscending(valueOf(a), valueOf(b));
+            if (result !== 0) {
+                return result;
+            }
+        }
+        return 0;
+    };
+}
+//# sourceMappingURL=create-comparator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create-comparator.js","sourceRoot":"","sources":["../../../src/function/compare/create-comparator.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,uBAAuB,EAAE,MAAM,sBAAsB,CAAC;AAG/D;;;;;;GAMG;AACH,MAAM,UAAU,gBAAgB,CAC/B,QAA2B;IAE3B,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;QACf,IAAI,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;YACpB,OAAO,CAAC,CAAC,CAAC;QACX,CAAC;QACD,IAAI,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,CAAC;YACpB,OAAO,CAAC,CAAC;QACV,CAAC;QACD,OAAO,CAAC,CAAC;IACV,CAAC,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,kBAAkB,CACjC,GAAG,QAAwE;IAE3E,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,GAAG,QAAQ,CAAC;IAEjC,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC3B,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,uBAAuB,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAC9D,CAAC;IACD,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QAC3B,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CACf,uBAAuB,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;YAC3C,uBAAuB,CAAC,MAAO,CAAC,CAAC,CAAC,EAAE,MAAO,CAAC,CAAC,CAAC,CAAC,CAAC;IAClD,CAAC;IAED,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;QACf,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,QAAQ,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;YACtD,MAAM,OAAO,GAAG,QAAQ,CAAC,KAAK,CAAE,CAAC;YACjC,MAAM,MAAM,GAAG,uBAAuB,CAAC,OAAO,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;YAC/D,IAAI,MAAM,KAAK,CAAC,EAAE,CAAC;gBAClB,OAAO,MAAM,CAAC;YACf,CAAC;QACF,CAAC;QACD,OAAO,CAAC,CAAC;IACV,CAAC,CAAC;AACH,CAAC"}

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

@@ -0,0 +1,16 @@
+import type { EqualityComparator } from "../../object/is-equal.js";
+import type { Comparator } from "./types.js";
+/**
+ * Adapts a {@link Comparator} into an {@link EqualityComparator}, treating
+ * equivalent operands as equal.
+ *
+ * Only this direction is derivable: an equality answers one bit and says
+ * nothing about which operand comes first, so no comparator can be recovered
+ * from one.
+ *
+ * The result is transitive only because the comparator is exact — deriving one
+ * from an approximate comparison would produce an "equality" unusable as a set
+ * or map key.
+ */
+export declare function createEqualityComparator<A, B = A>(compare: Comparator<A, B>): EqualityComparator<A, B>;
+//# sourceMappingURL=create-equality-comparator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create-equality-comparator.d.ts","sourceRoot":"","sources":["../../../src/function/compare/create-equality-comparator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AACnE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C;;;;;;;;;;;GAWG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,EAChD,OAAO,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GACvB,kBAAkB,CAAC,CAAC,EAAE,CAAC,CAAC,CAE1B"}

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

@@ -0,0 +1,16 @@
+/**
+ * Adapts a {@link Comparator} into an {@link EqualityComparator}, treating
+ * equivalent operands as equal.
+ *
+ * Only this direction is derivable: an equality answers one bit and says
+ * nothing about which operand comes first, so no comparator can be recovered
+ * from one.
+ *
+ * The result is transitive only because the comparator is exact — deriving one
+ * from an approximate comparison would produce an "equality" unusable as a set
+ * or map key.
+ */
+export function createEqualityComparator(compare) {
+    return (a, b) => compare(a, b) === 0;
+}
+//# sourceMappingURL=create-equality-comparator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create-equality-comparator.js","sourceRoot":"","sources":["../../../src/function/compare/create-equality-comparator.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,wBAAwB,CACvC,OAAyB;IAEzB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC;AACtC,CAAC"}

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

@@ -0,0 +1,11 @@
+import type { Comparator } from "./types.js";
+/**
+ * Lifts `compare` to sequences, comparing element by element and ordering a
+ * proper prefix before the sequence that extends it.
+ *
+ * Consumes both operands lazily and stops at the first difference, so it costs
+ * one `compare` call per element only when the two share a full prefix. Both
+ * iterators are closed on the way out.
+ */
+export declare function createLexicographicalComparator<T>(compare: Comparator<T>): Comparator<Iterable<T>>;
+//# sourceMappingURL=create-lexicographical-comparator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create-lexicographical-comparator.d.ts","sourceRoot":"","sources":["../../../src/function/compare/create-lexicographical-comparator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAoB,MAAM,YAAY,CAAC;AAE/D;;;;;;;GAOG;AACH,wBAAgB,+BAA+B,CAAC,CAAC,EAChD,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC,GACpB,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CA6BzB"}

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

@@ -0,0 +1,35 @@
+/**
+ * Lifts `compare` to sequences, comparing element by element and ordering a
+ * proper prefix before the sequence that extends it.
+ *
+ * Consumes both operands lazily and stops at the first difference, so it costs
+ * one `compare` call per element only when the two share a full prefix. Both
+ * iterators are closed on the way out.
+ */
+export function createLexicographicalComparator(compare) {
+    return (a, b) => {
+        const left = a[Symbol.iterator]();
+        const right = b[Symbol.iterator]();
+        let result;
+        for (;;) {
+            const x = left.next();
+            const y = right.next();
+            if (x.done === true) {
+                result = y.done === true ? 0 : -1;
+                break;
+            }
+            if (y.done === true) {
+                result = 1;
+                break;
+            }
+            result = compare(x.value, y.value);
+            if (result !== 0) {
+                break;
+            }
+        }
+        left.return?.();
+        right.return?.();
+        return result;
+    };
+}
+//# sourceMappingURL=create-lexicographical-comparator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create-lexicographical-comparator.js","sourceRoot":"","sources":["../../../src/function/compare/create-lexicographical-comparator.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,MAAM,UAAU,+BAA+B,CAC9C,OAAsB;IAEtB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;QACf,MAAM,IAAI,GAAG,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;QAClC,MAAM,KAAK,GAAG,CAAC,CAAC,MAAM,CAAC,QAAQ,CAAC,EAAE,CAAC;QACnC,IAAI,MAAwB,CAAC;QAE7B,SAAS,CAAC;YACT,MAAM,CAAC,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;YACtB,MAAM,CAAC,GAAG,KAAK,CAAC,IAAI,EAAE,CAAC;YAEvB,IAAI,CAAC,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;gBACrB,MAAM,GAAG,CAAC,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;gBAClC,MAAM;YACP,CAAC;YACD,IAAI,CAAC,CAAC,IAAI,KAAK,IAAI,EAAE,CAAC;gBACrB,MAAM,GAAG,CAAC,CAAC;gBACX,MAAM;YACP,CAAC;YAED,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC;YACnC,IAAI,MAAM,KAAK,CAAC,EAAE,CAAC;gBAClB,MAAM;YACP,CAAC;QACF,CAAC;QAED,IAAI,CAAC,MAAM,EAAE,EAAE,CAAC;QAChB,KAAK,CAAC,MAAM,EAAE,EAAE,CAAC;QACjB,OAAO,MAAM,CAAC;IACf,CAAC,CAAC;AACH,CAAC"}

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

@@ -0,0 +1,12 @@
+import type { Comparator } from "./types.js";
+/**
+ * Widens `compare` to accept `null` and `undefined`, ordering both before every
+ * other value and treating them as equivalent to each other.
+ */
+export declare function createNullishFirstComparator<T>(compare: Comparator<T>): Comparator<T | null | undefined>;
+/**
+ * Widens `compare` to accept `null` and `undefined`, ordering both after every
+ * other value and treating them as equivalent to each other.
+ */
+export declare function createNullishLastComparator<T>(compare: Comparator<T>): Comparator<T | null | undefined>;
+//# sourceMappingURL=create-nullish-comparator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create-nullish-comparator.d.ts","sourceRoot":"","sources":["../../../src/function/compare/create-nullish-comparator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C;;;GAGG;AACH,wBAAgB,4BAA4B,CAAC,CAAC,EAC7C,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC,GACpB,UAAU,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,CAUlC;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,CAAC,EAC5C,OAAO,EAAE,UAAU,CAAC,CAAC,CAAC,GACpB,UAAU,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,CAAC,CAUlC"}

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

@@ -0,0 +1,31 @@
+/**
+ * Widens `compare` to accept `null` and `undefined`, ordering both before every
+ * other value and treating them as equivalent to each other.
+ */
+export function createNullishFirstComparator(compare) {
+    return (a, b) => {
+        if (a === null || a === undefined) {
+            return b === null || b === undefined ? 0 : -1;
+        }
+        if (b === null || b === undefined) {
+            return 1;
+        }
+        return compare(a, b);
+    };
+}
+/**
+ * Widens `compare` to accept `null` and `undefined`, ordering both after every
+ * other value and treating them as equivalent to each other.
+ */
+export function createNullishLastComparator(compare) {
+    return (a, b) => {
+        if (a === null || a === undefined) {
+            return b === null || b === undefined ? 0 : 1;
+        }
+        if (b === null || b === undefined) {
+            return -1;
+        }
+        return compare(a, b);
+    };
+}
+//# sourceMappingURL=create-nullish-comparator.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"create-nullish-comparator.js","sourceRoot":"","sources":["../../../src/function/compare/create-nullish-comparator.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,UAAU,4BAA4B,CAC3C,OAAsB;IAEtB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;QACf,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,SAAS,EAAE,CAAC;YACnC,OAAO,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC/C,CAAC;QACD,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,SAAS,EAAE,CAAC;YACnC,OAAO,CAAC,CAAC;QACV,CAAC;QACD,OAAO,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACtB,CAAC,CAAC;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,2BAA2B,CAC1C,OAAsB;IAEtB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;QACf,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,SAAS,EAAE,CAAC;YACnC,OAAO,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAC9C,CAAC;QACD,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,SAAS,EAAE,CAAC;YACnC,OAAO,CAAC,CAAC,CAAC;QACX,CAAC;QACD,OAAO,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IACtB,CAAC,CAAC;AACH,CAAC"}

package/dist/function/compare/create-order-predicate.d.ts

@@ -0,0 +1,8 @@
+import type { Comparator, OrderPredicate } from "./types.js";
+/**
+ * Adapts a {@link Comparator} into an {@link OrderPredicate}.
+ *
+ * Free — a single comparison call.
+ */
+export declare function createOrderPredicate<A, B = A>(compare: Comparator<A, B>): OrderPredicate<A, B>;
+//# sourceMappingURL=create-order-predicate.d.ts.map

package/dist/function/compare/create-order-predicate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-order-predicate.d.ts","sourceRoot":"","sources":["../../../src/function/compare/create-order-predicate.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE7D;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,EAC5C,OAAO,EAAE,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC,GACvB,cAAc,CAAC,CAAC,EAAE,CAAC,CAAC,CAEtB"}

package/dist/function/compare/create-order-predicate.js

@@ -0,0 +1,9 @@
+/**
+ * Adapts a {@link Comparator} into an {@link OrderPredicate}.
+ *
+ * Free — a single comparison call.
+ */
+export function createOrderPredicate(compare) {
+    return (a, b) => compare(a, b) < 0;
+}
+//# sourceMappingURL=create-order-predicate.js.map

package/dist/function/compare/create-order-predicate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-order-predicate.js","sourceRoot":"","sources":["../../../src/function/compare/create-order-predicate.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,UAAU,oBAAoB,CACnC,OAAyB;IAEzB,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC;AACpC,CAAC"}