@tstdl/base 0.92.144 → 0.92.147

package/utils/async-hook/async-hook.js

@@ -1,3 +1,70 @@
+/**
+ * Creates a new asynchronous hook.
+ *
+ * An async hook is a system that allows you to register multiple "handler" functions
+ * that will be executed in sequence when a "trigger" event occurs. This is useful
+ * for creating extensible, plugin-like architectures. Handlers can be synchronous
+ * or asynchronous.
+ *
+ * @template T The type of the primary value that the hook is triggered with.
+ * @template C The type of the optional context object passed to the hook's trigger and handlers. Defaults to `never`.
+ * @template R The return type of an individual handler. The `trigger` method will resolve with an array of these values (`R[]`). Defaults to `unknown`.
+ * @returns {AsyncHook<T, C, R>} An object with `register` and `trigger` methods.
+ *
+ * @example
+ * ```ts
+ * // Simple hook without context
+ * async function runSimpleExample() {
+ *   const onTaskStart = asyncHook<string>();
+ *
+ *   onTaskStart.register(taskName => {
+ *     console.log(`[Logger] Task started: ${taskName}`);
+ *   });
+ *
+ *   const registration = onTaskStart.register(async taskName => {
+ *     await new Promise(resolve => setTimeout(resolve, 50));
+ *     console.log(`[Notifier] Notifying that task started: ${taskName}`);
+ *   });
+ *
+ *   await onTaskStart.trigger('Process Data');
+ *   // [Logger] Task started: Process Data
+ *   // [Notifier] Notifying that task started: Process Data
+ *
+ *   registration.unregister();
+ *   console.log('Notifier unregistered.');
+ *
+ *   await onTaskStart.trigger('Finalize Report');
+ *   // [Logger] Task started: Finalize Report
+ * }
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Hook with a context object
+ * async function runContextExample() {
+ *   type TaskContext = { userId: number; transactionId: string };
+ *
+ *   const onTaskComplete = asyncHook<string, TaskContext, boolean>();
+ *
+ *   onTaskComplete.register((taskName, context) => {
+ *     console.log(`[Audit] Task '${taskName}' completed by user ${context.userId}.`);
+ *     return true; // Audit successful
+ *   });
+ *
+ *   onTaskComplete.register(async (taskName, context) => {
+ *     console.log(`[DB] Logging completion of '${taskName}' for transaction ${context.transactionId}.`);
+ *     return true; // DB update successful
+ *   });
+ *
+ *   const results = await onTaskComplete.trigger(
+ *     'SubmitOrder',
+ *     { userId: 123, transactionId: 'abc-456' }
+ *   );
+ *
+ *   console.log('Handler results:', results); // [true, true]
+ * }
+ * ```
+ */
 export function asyncHook() {
     const handlers = [];
     return {
@@ -5,13 +72,20 @@ export function asyncHook() {
             handlers.push(handler);
             return {
                 unregister() {
-                    handlers.splice(handlers.indexOf(handler));
+                    const index = handlers.indexOf(handler);
+                    if (index > -1) {
+                        handlers.splice(index, 1);
+                    }
                 },
             };
         },
+        // The implementation uses a single function body, but the public type signature
+        // is conditional, ensuring type safety for callers.
         trigger: async (value, context) => {
-            let returnValues = [];
-            for (const handler of handlers) {
+            const returnValues = [];
+            // Create a snapshot of handlers in case one of them unregisters another during its execution.
+            for (const handler of [...handlers]) {
+                // The non-null assertion `context!` is safe due to the conditional public type of `trigger`.
                 const returnValue = await handler(value, context);
                 returnValues.push(returnValue);
             }

package/utils/backoff.d.ts

@@ -1,77 +1,159 @@
 import type { CancellationSignal } from '../cancellation/token.js';
-import { CancellationToken } from '../cancellation/token.js';
 export type BackoffStrategy = 'linear' | 'exponential';
+/**
+ * Configuration for the backoff behavior.
+ */
 export type BackoffOptions = {
     /**
-     * how to increase delay
+     * The strategy to use for increasing the delay.
+     * - `linear`: Adds the `increase` value to the delay in each step.
+     * - `exponential`: Multiplies the delay by the `increase` value in each step.
+     * @default 'exponential'
      */
-    strategy: BackoffStrategy;
+    strategy?: BackoffStrategy;
     /**
-     * delay to start with
+     * The initial delay in milliseconds. Must be non-negative.
+     * @default 1000
      */
-    initialDelay: number;
+    initialDelay?: number;
     /**
-     * amount to increase/multiply delay by/with
+     * The value to increase the delay with.
+     * - For `linear` strategy, this is the number of milliseconds to add.
+     * - For `exponential` strategy, this is the multiplication factor.
+     * Must be non-negative. For exponential, should be > 1 to ensure growth.
+     * @default 2
      */
-    increase: number;
+    increase?: number;
     /**
-     * miaxmum time to back off
+     * The maximum delay in milliseconds. The backoff delay will not exceed this value.
+     * @default 30000
      */
     maximumDelay?: number;
+    /**
+     * A factor to randomize the delay, e.g., 0.1 for 10% jitter.
+     * This helps prevent the "thundering herd" problem in distributed systems.
+     * The actual delay will be `delay ± delay * jitter`.
+     * Must be a value between 0 and 1.
+     * @default 0.15
+     */
+    jitter?: number;
+};
+export type AutoBackoffLoopOptions = BackoffOptions & {
+    cancellationSignal?: CancellationSignal;
+    errorHandler?: (error: Error) => void;
+};
+export type BackoffLoopOptions = BackoffOptions & {
+    cancellationSignal?: CancellationSignal;
+};
+export type BackoffGeneratorOptions = BackoffOptions & {
+    /**
+     * An optional signal to terminate the generator.
+     * The generator can also be terminated by breaking the `for-await-of` loop.
+     */
+    cancellationSignal?: CancellationSignal;
 };
+/**
+ * Provides controls for the `backoffLoop`.
+ */
 export type BackoffLoopController = {
     /**
-     * backoff before next iteration
+     * Schedules a backoff delay before the next iteration of the loop.
+     * If this is not called, the backoff delay is reset for the next attempt.
      */
     backoff: () => void;
     /**
-     * break out of loop
+     * Immediately breaks out of the loop.
      */
     break: () => void;
 };
-export type BackoffLoopFunction = (controller: BackoffLoopController) => void | Promise<void>;
+export type BackoffLoopFunction = (controller: BackoffLoopController, cancellationSignal: CancellationSignal) => unknown;
+/**
+ * A function yielded by `backoffGenerator` to control the next iteration.
+ */
+export type BackoffGeneratorCallback = (options?: {
+    /**
+     * An optional signal that, when set, cancels the current backoff delay and proceeds
+     * to the next iteration immediately. This is useful for "continue early" scenarios.
+     */
+    continueToken?: CancellationSignal;
+}) => void;
+/**
+ * Default options for a robust backoff strategy.
+ */
+export declare const DEFAULT_BACKOFF_OPTIONS: {
+    readonly strategy: "exponential";
+    readonly initialDelay: 1000;
+    readonly increase: 2;
+    readonly maximumDelay: 30000;
+    readonly jitter: 0.15;
+};
 /**
- * @param continueToken token to continue loop immediately
+ * A helper class to manage the state of a backoff strategy.
  */
-export type BackoffGeneratorYield = (continueToken?: CancellationToken) => void;
 export declare class BackoffHelper {
-    private readonly strategy;
-    private readonly initialDelay;
-    private readonly increase;
-    private readonly maximumDelay;
-    private delay;
-    constructor({ strategy, initialDelay, increase, maximumDelay }: BackoffOptions);
+    private readonly options;
+    private currentDelay;
+    /**
+     * Creates a new BackoffHelper.
+     * @param options Partial backoff options, which will be merged with sane defaults.
+     */
+    constructor(options?: BackoffOptions);
+    /**
+     * Resets the current delay to the initial delay.
+     */
     reset(): void;
-    backoff(): number;
+    /**
+     * Calculates and returns the next backoff delay based on the configured strategy.
+     * This also updates the internal state for the subsequent call.
+     * @returns The next delay in milliseconds.
+     */
+    getNextDelay(): number;
 }
 /**
- * runs a function until token is set or controller returns and automatically backsoff if function throws. Warning: swallows errors
- * @param options backoff options
- * @param cancellationToken token to cancel loop
- * @param loopFunction function to call
+ * Runs a function in a loop, automatically backing off on errors.
+ *
+ * This function is a convenient wrapper that catches any errors from `loopFunction`,
+ * triggers a backoff, and continues the loop.
+ *
+ * @param loopFunction The asynchronous function to execute in each iteration.
+ * @param options Additional options for backoff configuration, cancellation, and error handling.
  */
-export declare function autoBackoffLoop(options: BackoffOptions, loopFunction: BackoffLoopFunction, extras?: {
-    cancellationSignal?: CancellationSignal;
-    errorHandler?: (error: Error) => void;
-}): Promise<void>;
+export declare function autoBackoffLoop(loopFunction: BackoffLoopFunction, options?: AutoBackoffLoopOptions): Promise<void>;
 /**
- * runs a function until token is set or controller returns.
- * @param options backoff options
- * @param cancellationToken signal to cancel loop
- * @param loopFunction function to call
+ * Runs a function in a loop, allowing manual control over backoff and breaking.
+ * The loop continues until it is explicitly broken via the controller or the cancellation signal is set.
+ * If `controller.backoff()` is not called in an iteration, the delay is reset for the next backoff.
+ *
+ * @param loopFunction The function to execute, receiving a controller to manage the loop.
+ * @param options Additional options for backoff configuration and cancellation.
  */
-export declare function backoffLoop(options: BackoffOptions, loopFunction: BackoffLoopFunction, extras?: {
-    cancellationSignal?: CancellationSignal;
-}): Promise<void>;
+export declare function backoffLoop(loopFunction: BackoffLoopFunction, options?: BackoffLoopOptions): Promise<void>;
 /**
- * generates endless function which, when called, backs off next iteration
- * @param options backoff options
- * @param cancellationSignal signal to cancel loop
+ * Creates an async generator that yields a callback to trigger a backoff.
+ * This is useful for `for-await-of` loops where you need fine-grained control.
+ * The generator terminates when the `cancellationSignal` is set or the loop is terminated by break.
+ *
+ * @param options Options for backoff configuration and an optional cancellation signal.
  * @example
- * for await (const backoff of backoffGenerator(options, token)) {
- *  if (iWantToBackoff) {
- *    backoff();
- *  }
+ * ```ts
+ * const token = new CancellationToken();
+ *
+ * // with a cancellation signal
+ * for await (const backoff of backoffGenerator({ cancellationSignal: token.signal })) {
+ *   const success = await doSomeWork();
+ *   if (!success) {
+ *     backoff(); // Schedule a backoff before the next iteration.
+ *   }
+ * }
+ *
+ * // without a cancellation signal (loop is broken manually)
+ * for await (const backoff of backoffGenerator()) {
+ *   const success = await doSomeWork();
+ *   if (success) {
+ *     break; // Exit the loop
+ *   }
+ *   backoff();
  * }
+ * ```
  */
-export declare function backoffGenerator(options: BackoffOptions, cancellationSignal: CancellationSignal): AsyncIterableIterator<BackoffGeneratorYield>;
+export declare function backoffGenerator(options?: BackoffGeneratorOptions): AsyncIterableIterator<BackoffGeneratorCallback>;

package/utils/backoff.js

@@ -1,101 +1,177 @@
 import { CancellationToken } from '../cancellation/token.js';
-import { noop } from './noop.js';
+import { NEVER } from 'rxjs';
+import { randomFloat } from './math.js';
 import { cancelableTimeout } from './timing.js';
 import { isDefined } from './type-guards.js';
+/**
+ * Default options for a robust backoff strategy.
+ */
+export const DEFAULT_BACKOFF_OPTIONS = {
+    strategy: 'exponential',
+    initialDelay: 1000,
+    increase: 2,
+    maximumDelay: 30_000, // 30 seconds
+    jitter: 0.15,
+};
+/**
+ * A helper class to manage the state of a backoff strategy.
+ */
 export class BackoffHelper {
-    strategy;
-    initialDelay;
-    increase;
-    maximumDelay;
-    delay;
-    constructor({ strategy, initialDelay, increase, maximumDelay }) {
-        this.strategy = strategy;
-        this.initialDelay = initialDelay;
-        this.increase = increase;
-        this.maximumDelay = maximumDelay ?? Number.MAX_SAFE_INTEGER;
-        this.reset();
+    options;
+    currentDelay;
+    /**
+     * Creates a new BackoffHelper.
+     * @param options Partial backoff options, which will be merged with sane defaults.
+     */
+    constructor(options) {
+        this.options = { ...DEFAULT_BACKOFF_OPTIONS, ...options };
+        const { initialDelay, increase, jitter, strategy } = this.options;
+        if (initialDelay < 0) {
+            throw new Error('initialDelay must be non-negative.');
+        }
+        if (increase < 0) {
+            throw new Error('increase must be non-negative.');
+        }
+        if ((jitter < 0) || (jitter > 1)) {
+            throw new Error('jitter must be between 0 and 1.');
+        }
+        if (strategy == 'exponential' && increase <= 1) {
+            console.warn('Using an exponential backoff with an increase factor <= 1 is not recommended as the delay will not grow.');
+        }
+        this.currentDelay = this.options.initialDelay;
     }
+    /**
+     * Resets the current delay to the initial delay.
+     */
     reset() {
-        this.delay = this.initialDelay;
+        this.currentDelay = this.options.initialDelay;
     }
-    backoff() {
-        this.delay = getNewDelay(this.strategy, this.delay, this.increase, this.maximumDelay);
-        return this.delay;
+    /**
+     * Calculates and returns the next backoff delay based on the configured strategy.
+     * This also updates the internal state for the subsequent call.
+     * @returns The next delay in milliseconds.
+     */
+    getNextDelay() {
+        const newDelay = getNewDelay(this.options.strategy, this.currentDelay, this.options.increase, this.options.maximumDelay);
+        this.currentDelay = newDelay;
+        if (this.options.jitter > 0) {
+            const jitterAmount = newDelay * randomFloat(-this.options.jitter, this.options.jitter); // ±jitter
+            return Math.max(0, newDelay + jitterAmount);
+        }
+        return newDelay;
     }
 }
 /**
- * runs a function until token is set or controller returns and automatically backsoff if function throws. Warning: swallows errors
- * @param options backoff options
- * @param cancellationToken token to cancel loop
- * @param loopFunction function to call
+ * Runs a function in a loop, automatically backing off on errors.
+ *
+ * This function is a convenient wrapper that catches any errors from `loopFunction`,
+ * triggers a backoff, and continues the loop.
+ *
+ * @param loopFunction The asynchronous function to execute in each iteration.
+ * @param options Additional options for backoff configuration, cancellation, and error handling.
  */
-export async function autoBackoffLoop(options, loopFunction, extras) {
-    const errorHandler = extras?.errorHandler ?? noop;
-    return backoffLoop(options, async (controller) => {
+export async function autoBackoffLoop(loopFunction, options = {}) {
+    const { errorHandler, ...loopOptions } = options;
+    await backoffLoop(async (controller, signal) => {
         try {
-            await loopFunction(controller);
+            await loopFunction(controller, signal);
         }
         catch (error) {
-            errorHandler(error);
+            errorHandler?.(error);
             controller.backoff();
         }
-    }, { cancellationSignal: extras?.cancellationSignal });
+    }, loopOptions);
 }
 /**
- * runs a function until token is set or controller returns.
- * @param options backoff options
- * @param cancellationToken signal to cancel loop
- * @param loopFunction function to call
+ * Runs a function in a loop, allowing manual control over backoff and breaking.
+ * The loop continues until it is explicitly broken via the controller or the cancellation signal is set.
+ * If `controller.backoff()` is not called in an iteration, the delay is reset for the next backoff.
+ *
+ * @param loopFunction The function to execute, receiving a controller to manage the loop.
+ * @param options Additional options for backoff configuration and cancellation.
  */
-export async function backoffLoop(options, loopFunction, extras) {
-    const backoffHelper = new BackoffHelper(options);
-    const loopCancellationToken = extras?.cancellationSignal?.createChild({ unset: false, complete: false }) ?? new CancellationToken();
-    let backoff = false;
+export async function backoffLoop(loopFunction, options = {}) {
+    const { cancellationSignal, ...backoffOptions } = options;
+    const backoffHelper = new BackoffHelper(backoffOptions);
+    const loopToken = new CancellationToken();
+    let shouldBackoff = false;
+    if (isDefined(cancellationSignal)) {
+        loopToken.inherit(cancellationSignal, { set: true, unset: false, complete: false, error: false });
+    }
     const controller = {
-        backoff: () => backoff = true,
-        break: () => loopCancellationToken.set()
+        backoff: () => shouldBackoff = true,
+        break: () => loopToken.set(),
     };
-    while (!loopCancellationToken.isSet) {
-        await loopFunction(controller);
-        if (loopCancellationToken.isSet) { // eslint-disable-line @typescript-eslint/no-unnecessary-condition
+    while (loopToken.isUnset) {
+        await loopFunction(controller, loopToken.signal);
+        // Exit immediately if the loop function requested a break.
+        if (loopToken.isSet) {
             return;
         }
-        if (backoff) {
-            backoff = false;
-            const milliseconds = backoffHelper.backoff();
-            await cancelableTimeout(milliseconds, loopCancellationToken);
+        if (shouldBackoff) {
+            shouldBackoff = false;
+            const delay = backoffHelper.getNextDelay();
+            await cancelableTimeout(delay, loopToken.signal);
         }
         else {
+            // If an iteration completes successfully without a backoff request, reset the delay.
             backoffHelper.reset();
         }
     }
 }
 /**
- * generates endless function which, when called, backs off next iteration
- * @param options backoff options
- * @param cancellationSignal signal to cancel loop
+ * Creates an async generator that yields a callback to trigger a backoff.
+ * This is useful for `for-await-of` loops where you need fine-grained control.
+ * The generator terminates when the `cancellationSignal` is set or the loop is terminated by break.
+ *
+ * @param options Options for backoff configuration and an optional cancellation signal.
  * @example
- * for await (const backoff of backoffGenerator(options, token)) {
- *  if (iWantToBackoff) {
- *    backoff();
- *  }
+ * ```ts
+ * const token = new CancellationToken();
+ *
+ * // with a cancellation signal
+ * for await (const backoff of backoffGenerator({ cancellationSignal: token.signal })) {
+ *   const success = await doSomeWork();
+ *   if (!success) {
+ *     backoff(); // Schedule a backoff before the next iteration.
+ *   }
  * }
+ *
+ * // without a cancellation signal (loop is broken manually)
+ * for await (const backoff of backoffGenerator()) {
+ *   const success = await doSomeWork();
+ *   if (success) {
+ *     break; // Exit the loop
+ *   }
+ *   backoff();
+ * }
+ * ```
  */
-export async function* backoffGenerator(options, cancellationSignal) {
-    const backoffHelper = new BackoffHelper(options);
-    while (cancellationSignal.isUnset) {
-        let backoff = false;
-        let timeoutToken = cancellationSignal;
-        const backoffFunction = (continueToken) => {
-            backoff = true;
+export async function* backoffGenerator(options = {}) {
+    const { cancellationSignal, ...backoffOptions } = options;
+    const backoffHelper = new BackoffHelper(backoffOptions);
+    // Loop indefinitely if no cancellation signal is provided.
+    // The consumer is responsible for breaking the loop.
+    while (cancellationSignal?.isUnset ?? true) {
+        let backoffTriggered = false;
+        let timeoutSignal = cancellationSignal;
+        const backoffCallback = (backoffOptions) => {
+            backoffTriggered = true;
+            const continueToken = backoffOptions?.continueToken;
             if (isDefined(continueToken)) {
-                timeoutToken = cancellationSignal.createChild().inherit(continueToken);
+                timeoutSignal = isDefined(cancellationSignal)
+                    ? cancellationSignal.createChild().inherit(continueToken)
+                    : continueToken;
             }
         };
-        yield backoffFunction;
-        if (backoff) { // eslint-disable-line @typescript-eslint/no-unnecessary-condition
-            const milliseconds = backoffHelper.backoff();
-            await cancelableTimeout(milliseconds, timeoutToken);
+        yield backoffCallback;
+        // Break immediately if the cancellation signal (if provided) is set.
+        if (cancellationSignal?.isSet == true) {
+            break;
+        }
+        if (backoffTriggered) {
+            const delay = backoffHelper.getNextDelay();
+            await cancelableTimeout(delay, timeoutSignal ?? NEVER);
         }
         else {
             backoffHelper.reset();
@@ -112,8 +188,7 @@ function getNewDelay(strategy, currentDelay, increase, maximumDelay) {
             newDelay = currentDelay * increase;
             break;
         default:
-            throw new Error('unknown backoff-strategy');
+            throw new Error(`Unknown backoff strategy: ${strategy}`);
     }
-    newDelay = Math.min(newDelay, maximumDelay);
-    return newDelay;
+    return Math.min(newDelay, maximumDelay);
 }

package/utils/base64.d.ts

@@ -1,4 +1,4 @@
-import type { BinaryData } from '../types.js';
+import type { BinaryData } from '../types/index.js';
 export declare function encodeBase64(array: BinaryData, bytesOffset?: number, bytesLength?: number): string;
 export declare function decodeBase64(base64: string): Uint8Array;
 export declare function encodeBase64Url(array: BinaryData, bytesOffset?: number, length?: number): string;

package/utils/base64.js

@@ -36,7 +36,7 @@ export function decodeBase64Url(base64Url) {
 }
 export function base64ToBase64Url(input) {
     return input
-        .replace(/=/ug, '') // eslint-disable-line no-div-regex
+        .replace(/=/ug, '')
         .replace(/\+/ug, '-')
         .replace(/\//ug, '_');
 }
@@ -98,7 +98,6 @@ export function utf8ArrayToString(bytes) {
     }
     return string;
 }
-// eslint-disable-next-line max-lines-per-function, max-statements
 export function stringToUtf8Array(string) {
     let bytesLength = 0;
     for (let i = 0; i < string.length; i++) {

package/utils/binary.d.ts

@@ -1,4 +1,4 @@
-import type { BinaryData, Type } from '../types.js';
+import type { BinaryData, Type } from '../types/index.js';
 /**
  * Get ArrayBuffer from binary data
  * @param data data to get ArrayBuffer from

package/utils/comparison.d.ts

@@ -1,8 +1,8 @@
-export declare function compareByValueSelection<T>(...selectors: ((item: T) => unknown)[]): (a: T, b: T) => number;
-export declare function compareByValueSelectionDescending<T>(...selectors: ((item: T) => unknown)[]): (a: T, b: T) => number;
-export declare function compareByValueSelectionOrdered<T>(...selectors: (readonly [(item: T) => unknown, 1 | -1])[]): (a: T, b: T) => number;
+export declare function compareByValueSelection<T, C extends string | number>(...selectors: ((item: T) => C)[]): (a: T, b: T) => number;
+export declare function compareByValueSelectionDescending<T, C extends string | number>(...selectors: ((item: T) => C)[]): (a: T, b: T) => number;
+export declare function compareByValueSelectionOrdered<T, C extends string | number>(...selectors: (readonly [(item: T) => C, 1 | -1])[]): (a: T, b: T) => number;
 export declare function compareByValueToOrder<T>(order: T[]): (a: T, b: T) => number;
 export declare const orderRest: unique symbol;
 export declare function compareByValueSelectionToOrder<T, TSelect>(order: (TSelect | typeof orderRest)[], selector: (item: T) => TSelect): (a: T, b: T) => number;
-export declare function compareByValue<T>(a: T, b: T, strict?: boolean): number;
-export declare function compareByValueDescending<T>(a: T, b: T, strict?: boolean): number;
+export declare function compareByValue<T>(a: T, b: NoInfer<T>, strict?: boolean): number;
+export declare function compareByValueDescending<T>(a: T, b: NoInfer<T>, strict?: boolean): number;

package/utils/comparison.js

@@ -1,3 +1,5 @@
+import { isNullOrUndefined } from './type-guards.js';
+import { typeOf } from './type-of.js';
 export function compareByValueSelection(...selectors) {
     return (a, b) => {
         for (const selector of selectors) {
@@ -51,7 +53,7 @@ export function compareByValueSelectionToOrder(order, selector) {
         const selectedB = selector(b);
         const indexA = indexMap.get(selectedA) ?? indexMap.get(orderRest);
         const indexB = indexMap.get(selectedB) ?? indexMap.get(orderRest);
-        if (indexA == undefined || indexB == undefined) {
+        if (isNullOrUndefined(indexA) || isNullOrUndefined(indexB)) {
             throw new Error('Value not defined in order.');
         }
         return compareByValue(indexA, indexB);
@@ -70,7 +72,7 @@ export function compareByValue(a, b, strict = true) {
     if (!strict) {
         return 0;
     }
-    throw new Error('Objects not comparable');
+    throw new Error(`Values of type ${typeOf(a)} and ${typeOf(b)} are not comparable.`);
 }
 export function compareByValueDescending(a, b, strict = true) {
     if (a === b) {
@@ -85,5 +87,5 @@ export function compareByValueDescending(a, b, strict = true) {
     if (!strict) {
         return 0;
     }
-    throw new Error('Objects not comparable');
+    throw new Error(`Values of type ${typeOf(a)} and ${typeOf(b)} are not comparable.`);
 }

package/utils/cryptography.d.ts

@@ -1,4 +1,4 @@
-import type { BinaryData, TypedExtract } from '../types.js';
+import type { BinaryData, TypedExtract } from '../types/index.js';
 import type { ReadonlyTuple } from 'type-fest';
 export type AesMode = 'CBC' | 'CTR' | 'GCM' | 'KW';
 export type EcdsaCurve = 'P-256' | 'P-384' | 'P-521';

package/utils/encoding.d.ts

@@ -1,4 +1,4 @@
-import type { BinaryData } from '../types.js';
+import type { BinaryData } from '../types/index.js';
 /**
  * Encodes text to utf8
  * @param text text to encode

package/utils/enum.d.ts

@@ -1,4 +1,4 @@
-import type { EnumerationEntries, EnumerationKey, EnumerationObject, EnumerationValue } from '../types.js';
+import type { EnumerationEntries, EnumerationKey, EnumerationObject, EnumerationValue } from '../types/index.js';
 export declare function enumValueName<T extends EnumerationObject>(enumeration: T, value: T[keyof T]): EnumerationKey<T>;
 export declare function enumEntries<T extends EnumerationObject>(enumeration: T): EnumerationEntries<T>;
 export declare function enumKeys<T extends EnumerationObject>(enumeration: T): EnumerationKey<T>[];

package/utils/equals.d.ts

@@ -1,4 +1,4 @@
-import type { BinaryData } from '../types.js';
+import type { BinaryData } from '../types/index.js';
 import type { Comparator } from './sort.js';
 export interface Equals<T = unknown> {
     [Equals.symbol](other: T): boolean;