@oscarpalmer/atoms 0.201.0 → 0.203.0

package/dist/index.d.mts

@@ -3,30 +3,12 @@
  * A generic array or object
  */
 export type ArrayOrPlainObject = unknown[] | Record<PropertyKey, unknown>;
-/**
- * An asynchronous callback that can be canceled
- */
-export type AsyncCancelableCallback<Callback extends GenericAsyncCallback | GenericCallback> = (ReturnType<Callback> extends Promise<any> ? (...args: Parameters<Callback>) => Promise<Awaited<ReturnType<Callback>>> : (...args: Parameters<Callback>) => Promise<ReturnType<Callback>>) & {
-  /**
-   * Cancel the callback
-   */
-  cancel: () => void;
-};
 /**
  * For matching any `void`, `Date`, primitive, or `RegExp` values
  *
  * _(Thanks, type-fest!)_
  */
 export type BuiltIns = void | Date | Primitive | RegExp;
-/**
- * A synchronous callback that can be canceled
- */
-export type CancelableCallback<Callback extends GenericCallback> = Callback & {
-  /**
-   * Cancel the callback
-   */
-  cancel: () => void;
-};
 /**
  * A generic class constructor
  */
@@ -43,7 +25,23 @@ export type GenericCallback = (...args: any[]) => any;
  * A generic key type
  */
 type Key$1 = number | string;
+/**
+ * The `PropertyKey`-safe value of `Item`'s `ItemKey` property
+ */
 export type KeyedValue<Item, ItemKey extends keyof Item> = Item[ItemKey] extends PropertyKey ? Item[ItemKey] : never;
+/**
+ * A key of `Item`, or a callback returning `Return`, used to derive a value from an item
+ */
+export type KeyOrCallback<Item, Return = unknown> = ((item: Item, index: number, array: Item[]) => Return) | (Item extends PlainObject ? keyof Item : never);
+/**
+ * The `PropertyKey`-safe value resolved from a `KeyOrCallback<Item, Key>` argument, for use as a
+ * `Record` or `Map` key
+ */
+export type KeyOrCallbackKey<Item, Arg extends KeyOrCallback<Item, Key$1>> = Arg extends ((item: Item, index: number, array: Item[]) => Key$1) ? ReturnType<Arg> : Arg extends keyof Item ? KeyedValue<Item, Arg> : never;
+/**
+ * The value resolved from a `KeyOrCallback` argument against `Item`
+ */
+export type KeyOrCallbackValue<Item, Arg extends KeyOrCallback<Item>> = Arg extends ((item: Item, index: number, array: Item[]) => unknown) ? ReturnType<Arg> : Arg extends keyof Item ? Item[Arg] : never;
 /**
  * A nested array
  */
@@ -77,7 +75,7 @@ export type NumericalValues<Item extends PlainObject> = { [ItemKey in keyof Item
 /**
  * An asynchronous function that can only be called once, returning the same value on subsequent calls
  */
-export type OnceAsyncCallback<Callback extends GenericAsyncCallback> = {
+type OnceAsync<Callback extends GenericAsyncCallback> = {
   /**
    * Did the callback's promise reject?
    */
@@ -86,12 +84,27 @@ export type OnceAsyncCallback<Callback extends GenericAsyncCallback> = {
    * Has the callback finished?
    */
   readonly finished: boolean;
-} & Callback & OnceCallbackProperties;
+  /**
+   * Run the callback
+   *
+   * @param parameters Callback parameters
+   * @returns Call result
+   */
+  run: (...parameters: Parameters<Callback>) => ReturnType<Callback>;
+} & OnceProperties;
 /**
  * A callback function that can only be called once, returning the same value on subsequent calls
  */
-export type OnceCallback<Callback extends GenericCallback> = Callback & OnceCallbackProperties;
-type OnceCallbackProperties = {
+type Once<Callback extends GenericCallback> = {
+  /**
+   * Run the callback
+   *
+   * @param parameters Callback parameters
+   * @returns Call result
+   */
+  run: (...parameters: Parameters<Callback>) => ReturnType<Callback>;
+} & OnceProperties;
+type OnceProperties = {
   /**
    * Has the callback been called?
    */
@@ -450,33 +463,13 @@ export declare function firstOrDefault<Item>(array: Item[], defaultValue: Item):
 //#endregion
 //#region src/array/group-by.d.ts
 /**
- * Create a record from an array of items using a specific key and value
- *
- * If multiple items have the same key, the latest item's value will be used
- *
- * @param array Array to group
- * @param key Callback to get an item's grouping key
- * @param value Callback to get an item's value
- * @returns Record of keyed values
- *
- * @example
- * ```typescript
- * groupBy(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   item => item.value,
- *   item => item,
- * ); // => {10: {id: 3, value: 10}, 20: {id: 2, value: 20}}
- * ```
- */
-export declare function groupBy<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Simplify<Record<ReturnType<KeyCallback>, ReturnType<ValueCallback>>>;
-/**
- * Create a record from an array of items using a specific key and value
+ * Create a record from an array of items using a specific key
  *
  * If multiple items have the same key, the latest item's value will be used
  *
  * @param array Array to group
- * @param key Callback to get an item's grouping key
- * @param value Key to use for value
+ * @param key Callback or key to use for grouping
+ * @param value Callback or key to use for value, defaulting to the item itself
  * @returns Record of keyed values
  *
  * @example
@@ -484,58 +477,18 @@ export declare function groupBy<Item, KeyCallback extends (item: Item, index: nu
  * groupBy(
  *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
  *   item => item.value,
- *   'id'
- * ); // => {10: 3, 20: 2}
- * ```
- */
-export declare function groupBy<Item extends PlainObject, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, ItemValue extends keyof Item>(array: Item[], key: KeyCallback, value: ItemValue): Record<ReturnType<KeyCallback>, Item[ItemValue]>;
-/**
- * Create a record from an array of items using a specific key and value
- *
- * If multiple items have the same key, the latest item's value will be used
- *
- * @param array Array to group
- * @param key Key to use for grouping
- * @param value Callback to get an item's value
- * @returns Record of keyed values
- *
- * @example
- * ```typescript
- * groupBy(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
  *   item => item,
  * ); // => {10: {id: 3, value: 10}, 20: {id: 2, value: 20}}
  * ```
  */
-export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ValueCallback): Simplify<Record<KeyedValue<Item, ItemKey>, ReturnType<ValueCallback>>>;
-/**
- * Create a record from an array of items using a specific key and value
- *
- * If multiple items have the same key, the latest item's value will be used
- *
- * @param array Array to group
- * @param key Key to use for grouping
- * @param value Key to use for value
- * @returns Record of keyed values
- *
- * @example
- * ```typescript
- * groupBy(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- *   'id'
- * ); // => {10: 3, 20: 2}
- * ```
- */
-export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Simplify<Record<KeyedValue<Item, ItemKey>, Item[ItemValue]>>;
+export declare function groupBy<Item, KeyArg extends KeyOrCallback<Item, Key$1>, ValueArg extends KeyOrCallback<Item>>(array: Item[], key: KeyArg, value: ValueArg): Simplify<Record<KeyOrCallbackKey<Item, KeyArg>, KeyOrCallbackValue<Item, ValueArg>>>;
 /**
  * Create a record from an array of items using a specific key
  *
  * If multiple items have the same key, the latest item will be used
  *
  * @param array Array to group
- * @param callback Callback to get an item's grouping key
+ * @param key Callback or key to use for grouping
  * @returns Record of keyed items
  *
  * @example
@@ -546,25 +499,7 @@ export declare function groupBy<Item extends PlainObject, ItemKey extends keyof
  * ); // => {10: {id: 3, value: 10}, 20: {id: 2, value: 20}}
  * ```
  */
-export declare function groupBy<Item, Callback extends (item: Item, index: number, array: Item[]) => Key$1>(array: Item[], callback: Callback): Record<ReturnType<Callback>, Item>;
-/**
- * Create a record from an array of items using a specific key
- *
- * If multiple items have the same key, the latest item will be used
- *
- * @param array Array to group
- * @param key Key to use for grouping
- * @returns Record of keyed items
- *
- * @example
- * ```typescript
- * groupBy(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- * ); // => {10: {id: 3, value: 10}, 20: {id: 2, value: 20}}
- * ```
- */
-export declare function groupBy<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Simplify<Record<KeyedValue<Item, ItemKey>, Item>>;
+export declare function groupBy<Item, KeyArg extends KeyOrCallback<Item, Key$1>>(array: Item[], key: KeyArg): Simplify<Record<KeyOrCallbackKey<Item, KeyArg>, Item>>;
 /**
  * Create a record from an array of items _(using indices as keys)_
  *
@@ -583,13 +518,13 @@ export declare namespace groupBy {
   var arrays: typeof groupArraysBy;
 }
 /**
- * Create a record from an array of items using a specific key and value, grouping values into arrays
+ * Create a record from an array of items using a specific key, grouping values into arrays
  *
  * _Available as `groupArraysBy` and `groupBy.arrays`_
  *
  * @param array Array to group
- * @param key Callback to get an item's grouping key
- * @param value Callback to get an item's value
+ * @param key Callback or key to use for grouping
+ * @param value Callback or key to use for value, defaulting to the item itself
  * @returns Record of keyed values
  *
  * @example
@@ -604,83 +539,14 @@ export declare namespace groupBy {
  *    // }
  * ```
  */
-export declare function groupArraysBy<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Record<ReturnType<KeyCallback>, Array<ReturnType<ValueCallback>>>;
-/**
- * Create a record from an array of items using a specific key and value, grouping values into arrays
- *
- * _Available as `groupArraysBy` and `groupBy.arrays`_
- *
- * @param array Array to group
- * @param key Callback to get an item's grouping key
- * @param value Key to use for value
- * @returns Record of keyed values
- *
- * @example
- * ```typescript
- * groupArraysBy(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   item => item.value,
- *   'id',
- * ); // => {
- *    //   10: [1, 3],
- *    //   20: [2],
- *    // }
- * ```
- */
-export declare function groupArraysBy<Item extends PlainObject, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, ItemValue extends keyof Item>(array: Item[], key: KeyCallback, value: ItemValue): Record<ReturnType<KeyCallback>, Item[ItemValue][]>;
-/**
- * Create a record from an array of items using a specific key and value, grouping values into arrays
- *
- * _Available as `groupArraysBy` and `groupBy.arrays`_
- *
- * @param array Array to group
- * @param key Key to use for grouping
- * @param value Callback to get an item's value
- * @returns Record of keyed values
- *
- * @example
- * ```typescript
- * groupArraysBy(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- *   item => item,
- * ); // => {
- *    //   10: [{id: 1, value: 10}, {id: 3, value: 10}],
- *    //   20: [{id: 2, value: 20}],
- *    // }
- * ```
- */
-export declare function groupArraysBy<Item extends PlainObject, ItemKey extends keyof Item, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ValueCallback): Simplify<Record<KeyedValue<Item, ItemKey>, Array<ReturnType<ValueCallback>>>>;
-/**
- * Create a record from an array of items using a specific key and value, grouping values into arrays
- *
- * _Available as `groupArraysBy` and `groupBy.arrays`_
- *
- * @param array Array to group
- * @param key Key to use for grouping
- * @param value Key to use for value
- * @returns Record of keyed values
- *
- * @example
- * ```typescript
- * groupArraysBy(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- *   'id',
- * ); // => {
- *    //   10: [1, 3],
- *    //   20: [2],
- *    // }
- * ```
- */
-export declare function groupArraysBy<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Simplify<Record<KeyedValue<Item, ItemKey>, Item[ItemValue][]>>;
+export declare function groupArraysBy<Item, KeyArg extends KeyOrCallback<Item, Key$1>, ValueArg extends KeyOrCallback<Item>>(array: Item[], key: KeyArg, value: ValueArg): Simplify<Record<KeyOrCallbackKey<Item, KeyArg>, Array<KeyOrCallbackValue<Item, ValueArg>>>>;
 /**
  * Create a record from an array of items using a specific key, grouping items into arrays
  *
  * _Available as `groupArraysBy` and `groupBy.arrays`_
  *
  * @param array Array to group
- * @param callback Callback to get an item's grouping key
+ * @param key Callback or key to use for grouping
  * @returns Record of keyed items
  *
  * @example
@@ -694,28 +560,7 @@ export declare function groupArraysBy<Item extends PlainObject, ItemKey extends
  *    // }
  * ```
  */
-export declare function groupArraysBy<Item, Callback extends (item: Item, index: number, array: Item[]) => Key$1>(array: Item[], callback: Callback): Record<ReturnType<Callback>, Item[]>;
-/**
- * Create a record from an array of items using a specific key, grouping items into arrays
- *
- * _Available as `groupArraysBy` and `groupBy.arrays`_
- *
- * @param array Array to group
- * @param key Key to use for grouping
- * @returns Record of keyed items
- *
- * @example
- * ```typescript
- * groupArraysBy(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- * ); // => {
- *    //   10: [{id: 1, value: 10}, {id: 3, value: 10}],
- *    //   20: [{id: 2, value: 20}],
- *    // }
- * ```
- */
-export declare function groupArraysBy<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Simplify<Record<KeyedValue<Item, ItemKey>, Item[]>>;
+export declare function groupArraysBy<Item, KeyArg extends KeyOrCallback<Item, Key$1>>(array: Item[], key: KeyArg): Simplify<Record<KeyOrCallbackKey<Item, KeyArg>, Item[]>>;
 //#endregion
 //#region src/internal/array/chunk.d.ts
 /**
@@ -2926,13 +2771,6 @@ export type SortDirection = 'ascending' | 'descending';
  * Can be used to sort an array, get the predicted index for an item, and check if an array is sorted
  */
 export type Sorter<Item> = {
-  /**
-   * Sort an array of items
-   *
-   * @param array Array to sort
-   * @returns Sorted array
-   */
-  (array: Item[]): Item[];
   /**
    * Get the index for an item _(to be inserted into an array of items)_
    *
@@ -2950,6 +2788,13 @@ export type Sorter<Item> = {
    * @returns `true` if sorted, otherwise `false`
    */
   is(array: Item[]): boolean;
+  /**
+   * Sort an array of items
+   *
+   * @param array Array to sort
+   * @returns Sorted array
+   */
+  sort(array: Item[]): Item[];
 };
 /**
  * Get the index for an item _(to be inserted into an array of items)_ based on sorters _(and an optional default direction)_
@@ -3290,33 +3135,13 @@ declare function swapIndices<Item>(array: Item[], first: number, second: number)
 //#endregion
 //#region src/array/to-map.d.ts
 /**
- * Create a _Map_ from an array of items using callbacks
- *
- * If multiple items have the same key, the latest item's value will be used
- *
- * @param array Array to convert
- * @param key Callback to get an item's grouping key
- * @param value Callback to get an item's value
- * @returns _Map_ of keyed values
- *
- * @example
- * ```typescript
- * toMap(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   item => item.value,
- *   item => item.id,
- * ); // => Map { 10 => 3, 20 => 2 }
- * ```
- */
-export declare function toMap<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Map<ReturnType<KeyCallback>, ReturnType<ValueCallback>>;
-/**
- * Create a _Map_ from an array of items using a callback and value
+ * Create a _Map_ from an array of items using a specific key
  *
  * If multiple items have the same key, the latest item's value will be used
  *
  * @param array Array to convert
- * @param key Callback to get an item's grouping key
- * @param value Key to use for value
+ * @param key Callback or key to use for grouping
+ * @param value Callback or key to use for value, defaulting to the item itself
  * @returns _Map_ of keyed values
  *
  * @example
@@ -3324,58 +3149,18 @@ export declare function toMap<Item, KeyCallback extends (item: Item, index: numb
  * toMap(
  *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
  *   item => item.value,
- *   'id',
- * ); // => Map { 10 => 3, 20 => 2 }
- * ```
- */
-export declare function toMap<Item extends PlainObject, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, ItemValue extends keyof Item>(array: Item[], key: KeyCallback, value: ItemValue): Map<ReturnType<KeyCallback>, Item[ItemValue]>;
-/**
- * Create a _Map_ from an array of items using a key and callback
- *
- * If multiple items have the same key, the latest item's value will be used
- *
- * @param array Array to convert
- * @param key Key to use for grouping
- * @param value Callback to get an item's value
- * @returns _Map_ of keyed values
- *
- * @example
- * ```typescript
- * toMap(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
  *   item => item.id,
  * ); // => Map { 10 => 3, 20 => 2 }
  * ```
  */
-export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ValueCallback): Map<Item[ItemKey], ReturnType<ValueCallback>>;
+export declare function toMap<Item, KeyArg extends KeyOrCallback<Item, Key$1>, ValueArg extends KeyOrCallback<Item>>(array: Item[], key: KeyArg, value: ValueArg): Map<KeyOrCallbackKey<Item, KeyArg>, KeyOrCallbackValue<Item, ValueArg>>;
 /**
- * Create a _Map_ from an array of items using a key and value
- *
- * If multiple items have the same key, the latest item's value will be used
- *
- * @param array Array to convert
- * @param key Key to use for grouping
- * @param value Key to use for value
- * @returns _Map_ of keyed values
- *
- * @example
- * ```typescript
- * toMap(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- *   'id',
- * ); // => Map { 10 => 3, 20 => 2 }
- * ```
- */
-export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Map<Item[ItemKey], Item[ItemValue]>;
-/**
- * Create a _Map_ from an array of items using a callback
+ * Create a _Map_ from an array of items using a specific key
  *
  * If multiple items have the same key, the latest item will be used
  *
  * @param array Array to convert
- * @param callback Callback to get an item's grouping key
+ * @param key Callback or key to use for grouping
  * @returns _Map_ of keyed items
  *
  * @example
@@ -3386,25 +3171,7 @@ export declare function toMap<Item extends PlainObject, ItemKey extends keyof It
  * ); // => Map { 10 => {id: 3, value: 10}, 20 => {id: 2, value: 20} }
  * ```
  */
-export declare function toMap<Item, Callback extends (item: Item, index: number, array: Item[]) => Key$1>(array: Item[], callback: Callback): Map<ReturnType<Callback>, Item>;
-/**
- * Create a _Map_ from an array of items using a key
- *
- * If multiple items have the same key, the latest item will be used
- *
- * @param array Array to convert
- * @param key Key to use for grouping
- * @returns _Map_ of keyed items
- *
- * @example
- * ```typescript
- * toMap(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- * ); // => Map { 10 => {id: 3, value: 10}, 20 => {id: 2, value: 20} }
- * ```
- */
-export declare function toMap<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Map<Item[ItemKey], Item>;
+export declare function toMap<Item, KeyArg extends KeyOrCallback<Item, Key$1>>(array: Item[], key: KeyArg): Map<KeyOrCallbackKey<Item, KeyArg>, Item>;
 /**
  * Create a _Map_ from an array of items _(using indices as keys)_
  *
@@ -3423,33 +3190,13 @@ export declare namespace toMap {
   var arrays: typeof toMapArrays;
 }
 /**
- * Create a _Map_ from an array of items using callbacks, grouping values into arrays
- *
- * _Available as `toMapArrays` and `toMap.arrays`_
- *
- * @param array Array to convert
- * @param key Callback to get an item's grouping key
- * @param value Callback to get an item's value
- * @returns _Map_ of keyed arrays of values
- *
- * @example
- * ```typescript
- * toMapArrays(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   item => item.value,
- *   item => item.id,
- * ); // => Map { 10 => [1, 3], 20 => [2] }
- * ```
- */
-export declare function toMapArrays<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Map<ReturnType<KeyCallback>, Array<ReturnType<ValueCallback>>>;
-/**
- * Create a _Map_ from an array of items using a callback and value, grouping values into arrays
+ * Create a _Map_ from an array of items using a specific key, grouping values into arrays
  *
  * _Available as `toMapArrays` and `toMap.arrays`_
  *
  * @param array Array to convert
- * @param key Callback to get an item's grouping key
- * @param value Key to use for value
+ * @param key Callback or key to use for grouping
+ * @param value Callback or key to use for value, defaulting to the item itself
  * @returns _Map_ of keyed arrays of values
  *
  * @example
@@ -3457,58 +3204,18 @@ export declare function toMapArrays<Item, KeyCallback extends (item: Item, index
  * toMapArrays(
  *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
  *   item => item.value,
- *   'id',
- * ); // => Map { 10 => [1, 3], 20 => [2] }
- * ```
- */
-export declare function toMapArrays<Item extends PlainObject, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, ItemValue extends keyof Item>(array: Item[], key: KeyCallback, value: ItemValue): Map<ReturnType<KeyCallback>, Item[ItemValue][]>;
-/**
- * Create a _Map_ from an array of items using a key and callback, grouping values into arrays
- *
- * _Available as `toMapArrays` and `toMap.arrays`_
- *
- * @param array Array to convert
- * @param key Key to use for grouping
- * @param value Callback to get an item's value
- * @returns _Map_ of keyed arrays of values
- *
- * @example
- * ```typescript
- * toMapArrays(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
  *   item => item.id,
  * ); // => Map { 10 => [1, 3], 20 => [2] }
  * ```
  */
-export declare function toMapArrays<Item extends PlainObject, ItemKey extends keyof Item, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ValueCallback): Map<Item[ItemKey], Array<ReturnType<ValueCallback>>>;
-/**
- * Create a _Map_ from an array of items using a key and value, grouping values into arrays
- *
- * _Available as `toMapArrays` and `toMap.arrays`_
- *
- * @param array Array to convert
- * @param key Key to use for grouping
- * @param value Key to use for value
- * @returns _Map_ of keyed arrays of values
- *
- * @example
- * ```typescript
- * toMapArrays(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- *   'id',
- * ); // => Map { 10 => [1, 3], 20 => [2] }
- * ```
- */
-export declare function toMapArrays<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Map<Item[ItemKey], Item[ItemValue][]>;
+export declare function toMapArrays<Item, KeyArg extends KeyOrCallback<Item, Key$1>, ValueArg extends KeyOrCallback<Item>>(array: Item[], key: KeyArg, value: ValueArg): Map<KeyOrCallbackKey<Item, KeyArg>, Array<KeyOrCallbackValue<Item, ValueArg>>>;
 /**
- * Create a _Map_ from an array of items using a callback, grouping items into arrays
+ * Create a _Map_ from an array of items using a specific key, grouping items into arrays
  *
  * _Available as `toMapArrays` and `toMap.arrays`_
  *
  * @param array Array to convert
- * @param callback Callback to get an item's grouping key
+ * @param key Callback or key to use for grouping
  * @returns _Map_ of keyed arrays of items
  *
  * @example
@@ -3519,35 +3226,17 @@ export declare function toMapArrays<Item extends PlainObject, ItemKey extends ke
  * ); // => Map { 10 => [{id: 1, value: 10}, {id: 3, value: 10}], 20 => [{id: 2, value: 20}] }
  * ```
  */
-export declare function toMapArrays<Item, Callback extends (item: Item, index: number, array: Item[]) => Key$1>(array: Item[], callback: Callback): Map<ReturnType<Callback>, Item[]>;
-/**
- * Create a _Map_ from an array of items using a key, grouping items into arrays
- *
- * _Available as `toMapArrays` and `toMap.arrays`_
- *
- * @param array Array to convert
- * @param key Key to use for grouping
- * @returns _Map_ of keyed arrays of items
- *
- * @example
- * ```typescript
- * toMapArrays(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- * ); // => Map { 10 => [{id: 1, value: 10}, {id: 3, value: 10}], 20 => [{id: 2, value: 20}] }
- * ```
- */
-export declare function toMapArrays<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Map<Item[ItemKey], Item[]>;
+export declare function toMapArrays<Item, KeyArg extends KeyOrCallback<Item, Key$1>>(array: Item[], key: KeyArg): Map<KeyOrCallbackKey<Item, KeyArg>, Item[]>;
 //#endregion
 //#region src/array/to-record.d.ts
 /**
- * Create a record from an array of items using callbacks
+ * Create a record from an array of items using a specific key
  *
  * If multiple items have the same key, the latest item will be used
  *
  * @param array Array to convert
- * @param key Callback to get an item's grouping key
- * @param value Callback to get an item's value
+ * @param key Callback or key to use for grouping
+ * @param value Callback or key to use for value, defaulting to the item itself
  * @returns Record of keyed values
  *
  * @example
@@ -3559,74 +3248,14 @@ export declare function toMapArrays<Item extends PlainObject, ItemKey extends ke
  * ); // => { 10: 3, 20: 2 }
  * ```
  */
-export declare function toRecord<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Record<ReturnType<KeyCallback>, ReturnType<ValueCallback>>;
-/**
- * Create a record from an array of items using a callback and value
- *
- * If multiple items have the same key, the latest item will be used
- *
- * @param array Array to convert
- * @param callback Callback to get an item's grouping key
- * @param value Key to use for value
- * @returns Record with keys
- *
- * @example
- * ```typescript
- * toRecord(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   item => item.value,
- *   'id',
- * ); // => { 10: 3, 20: 2 }
- * ```
- */
-export declare function toRecord<Item extends PlainObject, Callback extends (item: Item, index: number, array: Item[]) => Key$1, ItemValue extends keyof Item>(array: Item[], callback: Callback, value: ItemValue): Record<ReturnType<Callback>, Item[ItemValue]>;
+export declare function toRecord<Item, KeyArg extends KeyOrCallback<Item, Key$1>, ValueArg extends KeyOrCallback<Item>>(array: Item[], key: KeyArg, value: ValueArg): Simplify<Record<KeyOrCallbackKey<Item, KeyArg>, KeyOrCallbackValue<Item, ValueArg>>>;
 /**
- * Create a record from an array of items using a key and callback
- *
- * If multiple items have the same key, the latest item will be used
- *
- * @param array Array to convert
- * @param key Key to use for grouping
- * @param callback Callback to get an item's value
- * @returns Record with keys
- *
- * @example
- * ```typescript
- * toRecord(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- *   item => item.id,
- * ); // => { 10: 3, 20: 2 }
- * ```
- */
-export declare function toRecord<Item extends PlainObject, ItemKey extends keyof Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, callback: Callback): Simplify<Record<KeyedValue<Item, ItemKey>, ReturnType<Callback>>>;
-/**
- * Create a record from an array of items using a key and value
- *
- * If multiple items have the same key, the latest item will be used
- *
- * @param array Array to convert
- * @param key Key to use for grouping
- * @param value Key to use for value
- * @returns Record of keyed values
- *
- * @example
- * ```typescript
- * toRecord(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- *   'id',
- * ); // => { 10: 3, 20: 2 }
- * ```
- */
-export declare function toRecord<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Simplify<Record<KeyedValue<Item, ItemKey>, Item[ItemValue]>>;
-/**
- * Create a record from an array of items using a callback
+ * Create a record from an array of items using a specific key
  *
  * If multiple items have the same key, the latest item will be used
  *
  * @param array Array to convert
- * @param callback Callback to get an item's grouping key
+ * @param key Callback or key to use for grouping
  * @returns Record of keyed values
  *
  * @example
@@ -3637,25 +3266,7 @@ export declare function toRecord<Item extends PlainObject, ItemKey extends keyof
  * ); // => { 10: {id: 3, value: 10}, 20: {id: 2, value: 20} }
  * ```
  */
-export declare function toRecord<Item, Callback extends (item: Item, index: number, array: Item[]) => Key$1>(array: Item[], callback: Callback): Record<ReturnType<Callback>, Item>;
-/**
- * Create a record from an array of items using a key
- *
- * If multiple items have the same key, the latest item will be used
- *
- * @param array Array to convert
- * @param key Key to use for grouping
- * @returns Record of keyed values
- *
- * @example
- * ```typescript
- * toRecord(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- * ); // => { 10: {id: 3, value: 10}, 20: {id: 2, value: 20} }
- * ```
- */
-export declare function toRecord<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Simplify<Record<KeyedValue<Item, ItemKey>, Item>>;
+export declare function toRecord<Item, KeyArg extends KeyOrCallback<Item, Key$1>>(array: Item[], key: KeyArg): Simplify<Record<KeyOrCallbackKey<Item, KeyArg>, Item>>;
 /**
  * Create a record from an array of items _(using indices as keys)_
  *
@@ -3674,13 +3285,13 @@ export declare namespace toRecord {
   var arrays: typeof toRecordArrays;
 }
 /**
- * Create a record from an array of items using callbacks, grouping values into arrays
+ * Create a record from an array of items using a specific key, grouping values into arrays
  *
  * _Available as `toRecordArrays` and `toRecord.arrays`_
  *
  * @param array Array to convert
- * @param key Callback to get an item's grouping key
- * @param value Callback to get an item's value
+ * @param key Callback or key to use for grouping
+ * @param value Callback or key to use for value, defaulting to the item itself
  * @returns Record of keyed arrays of values
  *
  * @example
@@ -3692,74 +3303,14 @@ export declare namespace toRecord {
  * ); // => { 10: [1, 3], 20: [2] }
  * ```
  */
-export declare function toRecordArrays<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key$1, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Record<ReturnType<KeyCallback>, Array<ReturnType<ValueCallback>>>;
-/**
- * Create a record from an array of items using a callback and value, grouping values into arrays
- *
- * _Available as `toRecordArrays` and `toRecord.arrays`_
- *
- * @param array Array to convert
- * @param callback Callback to get an item's grouping key
- * @param value Key to use for value
- * @returns Record of keyed arrays of values
- *
- * @example
- * ```typescript
- * toRecordArrays(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   item => item.value,
- *   'id',
- * ); // => { 10: [1, 3], 20: [2] }
- * ```
- */
-export declare function toRecordArrays<Item extends PlainObject, Callback extends (item: Item, index: number, array: Item[]) => Key$1, ItemValue extends keyof Item>(array: Item[], callback: Callback, value: ItemValue): Record<ReturnType<Callback>, Item[ItemValue][]>;
+export declare function toRecordArrays<Item, KeyArg extends KeyOrCallback<Item, Key$1>, ValueArg extends KeyOrCallback<Item>>(array: Item[], key: KeyArg, value: ValueArg): Simplify<Record<KeyOrCallbackKey<Item, KeyArg>, Array<KeyOrCallbackValue<Item, ValueArg>>>>;
 /**
- * Create a record from an array of items using a key and callback, grouping values into arrays
- *
- * _Available as `toRecordArrays` and `toRecord.arrays`_
- *
- * @param array Array to convert
- * @param key Key to use for grouping
- * @param callback Callback to get an item's value
- * @returns Record of keyed arrays of values
- *
- * @example
- * ```typescript
- * toRecordArrays(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- *   item => item.id,
- * ); // => { 10: [1, 3], 20: [2] }
- * ```
- */
-export declare function toRecordArrays<Item extends PlainObject, ItemKey extends keyof Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, callback: Callback): Simplify<Record<KeyedValue<Item, ItemKey>, Array<ReturnType<Callback>>>>;
-/**
- * Create a record from an array of items using a key and value, grouping values into arrays
- *
- * _Available as `toRecordArrays` and `toRecord.arrays`_
- *
- * @param array Array to convert
- * @param key Key to use for grouping
- * @param value Key to use for value
- * @returns Record of keyed arrays of values
- *
- * @example
- * ```typescript
- * toRecordArrays(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- *   'id',
- * ); // => { 10: [1, 3], 20: [2] }
- * ```
- */
-export declare function toRecordArrays<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Simplify<Record<KeyedValue<Item, ItemKey>, Item[ItemValue][]>>;
-/**
- * Create a record from an array of items using a callback, grouping items into arrays
+ * Create a record from an array of items using a specific key, grouping items into arrays
  *
  * _Available as `toRecordArrays` and `toRecord.arrays`_
  *
  * @param array Array to convert
- * @param callback Callback to get an item's grouping key
+ * @param key Callback or key to use for grouping
  * @returns Record of keyed arrays of items
  *
  * @example
@@ -3770,25 +3321,7 @@ export declare function toRecordArrays<Item extends PlainObject, ItemKey extends
  * ); // => { 10: [{id: 1, value: 10}, {id: 3, value: 10}], 20: [{id: 2, value: 20}] }
  * ```
  */
-export declare function toRecordArrays<Item, Callback extends (item: Item, index: number, array: Item[]) => Key$1>(array: Item[], callback: Callback): Record<ReturnType<Callback>, Item[]>;
-/**
- * Create a record from an array of items using a key, grouping items into arrays
- *
- * _Available as `toRecordArrays` and `toRecord.arrays`_
- *
- * @param array Array to convert
- * @param key Key to use for grouping
- * @returns Record of keyed arrays of items
- *
- * @example
- * ```typescript
- * toRecordArrays(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- * ); // => { 10: [{id: 1, value: 10}, {id: 3, value: 10}], 20: [{id: 2, value: 20}] }
- * ```
- */
-export declare function toRecordArrays<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Simplify<Record<KeyedValue<Item, ItemKey>, Item[]>>;
+export declare function toRecordArrays<Item, KeyArg extends KeyOrCallback<Item, Key$1>>(array: Item[], key: KeyArg): Simplify<Record<KeyOrCallbackKey<Item, KeyArg>, Item[]>>;
 //#endregion
 //#region src/internal/function/misc.d.ts
 /**
@@ -3796,6 +3329,40 @@ export declare function toRecordArrays<Item extends PlainObject, ItemKey extends
  */
 export declare function noop(): void;
 //#endregion
+//#region src/internal/function/limit.d.ts
+/**
+ * An asynchronous function that can be cancelled
+ */
+type AsyncLimiter<Callback extends GenericAsyncCallback> = {
+  /**
+   * Cancel the function
+   */
+  cancel(): void;
+  /**
+   * Call the function
+   *
+   * @param parameters Function parameters
+   * @returns Function result
+   */
+  run(...parameters: Parameters<Callback>): Promise<ReturnType<Callback>>;
+};
+/**
+ * A function that can be cancelled
+ */
+type Limiter<Callback extends GenericCallback> = {
+  /**
+   * Cancel the function
+   */
+  cancel(): void;
+  /**
+   * Call the function
+   *
+   * @param parameters Function parameters
+   * @returns Function result
+   */
+  run(...parameters: Parameters<Callback>): ReturnType<Callback>;
+};
+//#endregion
 //#region src/function/limit.d.ts
 /**
  * Debounce a function, ensuring it is only called after `time` milliseconds have passed
@@ -3809,7 +3376,7 @@ export declare function noop(): void;
  * @param time Time in milliseconds to wait before calling the callback _(defaults to `0`; e.g., as soon as possible)_
  * @returns Debounced callback handler with a `cancel` method
  */
-export declare function asyncDebounce<Callback extends GenericAsyncCallback | GenericCallback>(callback: Callback, time?: number): AsyncCancelableCallback<Callback>;
+export declare function asyncDebounce<Callback extends GenericAsyncCallback | GenericCallback>(callback: Callback, time?: number): AsyncLimiter<Callback>;
 /**
  * Throttle a function, ensuring it is only called once every `time` milliseconds
  *
@@ -3822,7 +3389,7 @@ export declare function asyncDebounce<Callback extends GenericAsyncCallback | Ge
  * @param time Time in milliseconds to wait before calling the callback again _(defaults to `0`; e.g., as soon as possible)_
  * @returns Throttled callback handler with a `cancel` method
  */
-export declare function asyncThrottle<Callback extends GenericAsyncCallback | GenericCallback>(callback: Callback, time?: number): AsyncCancelableCallback<Callback>;
+export declare function asyncThrottle<Callback extends GenericAsyncCallback | GenericCallback>(callback: Callback, time?: number): AsyncLimiter<Callback>;
 /**
  * Debounce a function, ensuring it is only called after `time` milliseconds have passed
  *
@@ -3832,7 +3399,7 @@ export declare function asyncThrottle<Callback extends GenericAsyncCallback | Ge
  * @param time Time in milliseconds to wait before calling the callback _(defaults to `0`; e.g., as soon as possible)_
  * @returns Debounced callback handler with a `cancel` method
  */
-export declare function debounce<Callback extends GenericCallback>(callback: Callback, time?: number): CancelableCallback<Callback>;
+export declare function debounce<Callback extends GenericCallback>(callback: Callback, time?: number): Limiter<Callback>;
 export declare namespace debounce {
   var async: typeof asyncDebounce;
 }
@@ -3843,12 +3410,14 @@ export declare namespace debounce {
  * @param time Time in milliseconds to wait before calling the callback again _(defaults to `0`; e.g., as soon as possible)_
  * @returns Throttled callback handler with a `cancel` method
  */
-export declare function throttle<Callback extends GenericCallback>(callback: Callback, time?: number): CancelableCallback<Callback>;
+export declare function throttle<Callback extends GenericCallback>(callback: Callback, time?: number): Limiter<Callback>;
 export declare namespace throttle {
   var async: typeof asyncThrottle;
 }
 //#endregion
 //#region src/function/once.d.ts
+declare function OnceAsync(this: any, callback: GenericAsyncCallback): void;
+declare function Once(this: any, callback: GenericCallback): void;
 /**
  * Create an asynchronous function that can only be called once, rejecting or resolving the same result on subsequent calls
  *
@@ -3857,16 +3426,35 @@ export declare namespace throttle {
  * @param callback Callback to use once
  * @returns _Once_ callback
  */
-export declare function asyncOnce<Callback extends GenericAsyncCallback>(callback: Callback): OnceAsyncCallback<Callback>;
+export declare function asyncOnce<Callback extends GenericAsyncCallback>(callback: Callback): OnceAsync<Callback>;
+export declare namespace asyncOnce {
+  var is: typeof isAsyncOnce;
+}
+/**
+ * Is the value an asynchronous once callback?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is an asynchronous once callback, otherwise `false`
+ */
+export declare function isAsyncOnce(value: unknown): boolean;
+/**
+ * Is the value a once callback?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is a once callback, otherwise `false`
+ */
+export declare function isOnce(value: unknown): boolean;
 /**
  * Create a function that can only be called once, returning the same value on subsequent calls
  *
  * @param callback Callback to use once
  * @returns _Once_ callback
  */
-export declare function once<Callback extends GenericCallback>(callback: Callback): OnceCallback<Callback>;
+export declare function once<Callback extends GenericCallback>(callback: Callback): Once<Callback>;
 export declare namespace once {
   var async: typeof asyncOnce;
+  var is: typeof isOnce;
+  var isAsync: typeof isAsyncOnce;
 }
 //#endregion
 //#region src/function/retry.d.ts
@@ -4670,10 +4258,19 @@ type Comparator<Value = any> = (first: Value, second: Value) => number;
 export declare function compare(first: unknown, second: unknown): number;
 export declare namespace compare {
   var deregister: typeof deregisterComparator;
-  var handlers: {
-    deregister(constructor: Constructor): void;
+  var handler: {
+    base: {
+      handlers: WeakMap<Constructor, string | GenericCallback>;
+      options: {
+        callback: GenericCallback;
+        method?: string;
+      };
+      owner: GenericCallback;
+      deregister: (constructor: Constructor) => void;
+      get: (first: unknown, second: unknown) => string | GenericCallback | undefined;
+      register: (constructor: Constructor, handler?: string | GenericCallback) => void;
+    };
     handle(first: unknown, second: unknown, ...parameters: unknown[]): number;
-    register(constructor: Constructor, handler?: string | GenericCallback): void;
   };
   var register: typeof registerComparator;
 }
@@ -4727,7 +4324,7 @@ type Equalizer = {
    * @param ignoreCase If `true`, comparison will be case-insensitive
    * @returns `true` if the strings are equal, otherwise `false`
    */
-  (first: string, second: string, ignoreCase?: boolean): boolean;
+  compare(first: string, second: string, ignoreCase?: boolean): boolean;
   /**
    * Are two values equal?
    *
@@ -4735,7 +4332,7 @@ type Equalizer = {
    * @param second Second value
    * @returns `true` if the values are equal, otherwise `false`
    */
-  (first: unknown, second: unknown): boolean;
+  compare(first: unknown, second: unknown): boolean;
   /**
    * Deregister a equality comparison handler for a specific class
    *
@@ -4750,6 +4347,17 @@ type Equalizer = {
    */
   register: <Instance>(constructor: Constructor<Instance>, handler: (first: Instance, second: Instance) => boolean) => void;
 };
+type Options = {
+  ignoreCase: boolean;
+  ignoreExpressions: OptionsKeys<RegExp[]>;
+  ignoreKeys: OptionsKeys<Set<string>>;
+  relaxedNullish: boolean;
+};
+type OptionsKeys<Values> = {
+  enabled: boolean;
+  values: Values;
+};
+declare function Equalizer(this: any, options: Options): void;
 /**
  * Deregister a equality comparison handler for a specific class
  *
@@ -4777,12 +4385,21 @@ export declare function equal(first: string, second: string, ignoreCase?: boolea
  */
 export declare function equal(first: unknown, second: unknown, options?: EqualOptions): boolean;
 export declare namespace equal {
-  var handlers: {
-    deregister(constructor: Constructor): void;
+  var deregister: typeof deregisterEqualizer;
+  var handler: {
+    base: {
+      handlers: WeakMap<Constructor, string | GenericCallback>;
+      options: {
+        callback: GenericCallback;
+        method?: string;
+      };
+      owner: GenericCallback;
+      deregister: (constructor: Constructor) => void;
+      get: (first: unknown, second: unknown) => string | GenericCallback | undefined;
+      register: (constructor: Constructor, handler?: string | GenericCallback) => void;
+    };
     handle(first: unknown, second: unknown, ...parameters: unknown[]): boolean;
-    register(constructor: Constructor, handler?: string | GenericCallback): void;
   };
-  var deregister: typeof deregisterEqualizer;
   var initialize: typeof initializeEqualizer;
   var register: typeof registerEqualizer;
 }
@@ -5231,9 +4848,14 @@ export declare function error<E>(value: E, original: Error): ExtendedErr<E>;
  * @returns Error result
  */
 export declare function error<E>(value: E): Err<E>;
+export declare namespace error {
+  var is: typeof isError;
+}
 /**
  * Is the _Result_ an extended error?
  *
+ * _Available as `isError` and `error.is`_
+ *
  * @param result _Result_ to check
  * @returns `true` if the _Result_ is an extended error, otherwise `false`
  */
@@ -5241,6 +4863,8 @@ export declare function isError<Value, E = Error>(result: ExtendedErr<E> | Resul
 /**
  * Is the _Result_ an error?
  *
+ * _Available as `isError` and `error.is`_
+ *
  * @param result _Result_ to check
  * @returns `true` if the _Result_ is an error, otherwise `false`
  */
@@ -5248,6 +4872,8 @@ export declare function isError<Value, E = Error>(result: Result<Value, E>): res
 /**
  * Is the value an error?
  *
+ * _Available as `isError` and `error.is`_
+ *
  * @param value Value to check
  * @returns `true` if the value is an error, otherwise `false`
  */
@@ -5255,6 +4881,8 @@ export declare function isError(value: unknown): value is Err<unknown> | Extende
 /**
  * Is the _Result_ ok?
  *
+ * _Available as `isOk` and `ok.is`_
+ *
  * @param value _Result_ to check
  * @returns `true` if the _Result_ is ok, otherwise `false`
  */
@@ -5262,6 +4890,8 @@ export declare function isOk<Value, E = Error>(value: Result<Value, E>): value i
 /**
  * Is the value ok?
  *
+ * _Available as `isOk` and `ok.is`_
+ *
  * @param value Value to check
  * @returns `true` if the value is ok, otherwise `false`
  */
@@ -5280,6 +4910,9 @@ export declare function isResult(value: unknown): value is ExtendedErr<unknown>
  * @returns Ok result
  */
 export declare function ok<Value>(value: Value): Ok<Value>;
+export declare namespace ok {
+  var is: typeof isOk;
+}
 /**
  * Gets the value of an ok result _(or a default value)_
  *
@@ -5952,6 +5585,7 @@ export declare function fuzzy<Item>(items: Item[], handler?: (item: Item) => str
  */
 export declare function fuzzy<Item>(items: Item[], configuration?: FuzzyConfiguration<Item>): Fuzzy<Item>;
 export declare namespace fuzzy {
+  var is: typeof isFuzzy;
   var match: typeof fuzzyMatch;
 }
 /**
@@ -5964,6 +5598,15 @@ export declare namespace fuzzy {
  * @returns `true` if the needle matches the haystack in a fuzzy way, otherwise `false`
  */
 export declare function fuzzyMatch(haystack: string, needle: string): boolean;
+/**
+ * Is the value a fuzzy searcher?
+ *
+ * _Available as `isFuzzy` and `fuzzy.is`_
+ *
+ * @param value Value to check
+ * @returns `true` if the value is a fuzzy searcher, otherwise `false`
+ */
+export declare function isFuzzy<Item = unknown>(value: unknown): value is Fuzzy<Item>;
 //#endregion
 //#region src/string/index.d.ts
 /**
@@ -6084,7 +5727,7 @@ export type Normalizer = {
    * @param value String to normalize
    * @returns Normalized string
    */
-  (value: string): string;
+  normalize(value: string): string;
 };
 /**
  * Deburr a string, removing diacritical marks
@@ -6144,7 +5787,7 @@ type Templater = {
    *
    * @returns Templated string
    */
-  (strings: TemplateStringsArray, ...values: unknown[]): TemplaterRenderer;
+  render(strings: TemplateStringsArray, ...values: unknown[]): TemplaterRenderer;
   /**
    * Render a string from a template with variables
    *
@@ -6152,12 +5795,13 @@ type Templater = {
    * @param variables Variables to use
    * @returns Templated string
    */
-  (value: string, variables?: PlainObject): string;
+  render(value: string, variables?: PlainObject): string;
 };
 /**
  * Render a template string with variables
  */
 type TemplaterRenderer = (variables?: PlainObject) => string;
+declare function Templater(this: any, options: Required<TemplateOptions>): void;
 /**
  * Create a _Templater_ with predefined options
  *
@@ -6207,7 +5851,7 @@ export type Cloner = {
    * @param value Value to clone
    * @returns Cloned value
    */
-  <Value>(value: Value): Value;
+  clone<Value>(value: Value): Value;
   /**
    * Deregister a clone handler for a specific class
    *
@@ -6237,9 +5881,18 @@ export declare function clone<Value>(value: Value, options?: CloneOptions): Valu
 export declare namespace clone {
   var deregister: typeof deregisterCloner;
   var handlers: {
-    deregister(constructor: Constructor): void;
+    base: {
+      handlers: WeakMap<Constructor, string | GenericCallback>;
+      options: {
+        callback: GenericCallback;
+        method?: string;
+      };
+      owner: GenericCallback;
+      deregister: (constructor: Constructor) => void;
+      get: (first: unknown, second: unknown) => string | GenericCallback | undefined;
+      register: (constructor: Constructor, handler?: string | GenericCallback) => void;
+    };
     handle(value: unknown, ...parameters: unknown[]): unknown;
-    register(constructor: Constructor, handler?: string | GenericCallback): void;
   };
   var initialize: typeof initializeCloner;
   var register: typeof registerCloner;
@@ -6584,7 +6237,7 @@ export type Assigner = {
    * @param from Values to assign
    * @returns Assigned value
    */
-  <To extends PlainObject, From extends PlainObject[]>(to: To, from: [...From]): To & UnionToIntersection<From[number]>;
+  assign<To extends PlainObject, From extends PlainObject[]>(to: To, from: [...From]): To & UnionToIntersection<From[number]>;
 };
 /**
  * Options for merging values
@@ -6629,7 +6282,7 @@ export type Merger = {
    * @param values Values to merge
    * @returns Merged value
    */
-  <Values extends ArrayOrPlainObject[]>(values: Array<NestedPartial<Values[number]>>): UnionToIntersection<Values[number]>;
+  merge<Values extends ArrayOrPlainObject[]>(values: Array<NestedPartial<Values[number]>>): UnionToIntersection<Values[number]>;
 };
 /**
  * Assign values from one or more objects to the first one
@@ -6683,10 +6336,16 @@ type TransformCallback<Value extends PlainObject, Key extends keyof Value> = (ke
  */
 type TransformCallbacks<Value extends PlainObject> = Partial<{ [Key in keyof Value]: (value: Value[Key]) => Value[Key]; }>;
 /**
- * A transformer function for an object, with predefined callbacks for transforming its properties
+ * A transformer for an object, with predefined callbacks for transforming its properties
  */
 export type Transformer<Value extends PlainObject> = {
-  (value: Value): Value;
+  /**
+   * Transform an object's properties
+   *
+   * @param value Object to transform
+   * @returns Transformed object
+   */
+  transform(value: Value): Value;
 };
 /**
  * Initialize a transformer for an object with a transformer function
@@ -6771,7 +6430,7 @@ type SubscriptionProperty = {
    */
   value: unknown;
 };
-type Subscriptions = {
+type Subscriptions<Value = unknown> = {
   /**
    * Items of the subscriptions store
    *
@@ -6787,7 +6446,7 @@ type Subscriptions = {
    * - `to.any` - Map of subscriptions to values _(for unkeyed subscriptions)_
    * - `to.keyed` - Map of keys to maps of subscriptions to values _(for keyed subscriptions)_
    */
-  readonly values: Readonly<SubscriptionsValues>;
+  readonly values: Readonly<SubscriptionsValues<Value>>;
   /**
    * Clear all subscriptions
    */
@@ -6817,9 +6476,9 @@ type SubscriptionsItems = {
   any: Set<Subscription>;
   keyed?: Map<Key$1, Set<Subscription>>;
 };
-type SubscriptionsValues = {
-  from: SubscriptionsValuesItem<unknown, Subscription>;
-  to: SubscriptionsValuesItem<Subscription, unknown>;
+type SubscriptionsValues<Value = unknown> = {
+  from: SubscriptionsValuesItem<Value, Subscription>;
+  to: SubscriptionsValuesItem<Subscription, Value>;
 };
 type SubscriptionsValuesItem<MapKey, MapValue> = {
   any: Map<MapKey, MapValue>;
@@ -6845,7 +6504,7 @@ export declare function isSubscriptions(value: unknown): value is Subscriptions;
  * @param parameters Store parameters
  * @returns Subscription store
  */
-export declare function subscriptions(parameters?: SubscriptionsParameters): Subscriptions;
+export declare function subscriptions<Value = unknown>(parameters?: SubscriptionsParameters): Subscriptions<Value>;
 //#endregion
 //#region src/beacon.d.ts
 /**
@@ -7962,12 +7621,12 @@ type Logger = {
    * @param label Label for the logger
    * @returns _TimedLogger_ instance
    */
-  time(label: string): TimedLogger;
+  time(label: string): TimeLogger;
 };
 /**
  * A named timer that can be used to log durations to the console
  */
-type TimedLogger = {
+type TimeLogger = {
   /**
    * Is the timer active? _(i.e. has it been started and not stopped, and is logging enabled?)_
    */
@@ -7983,8 +7642,9 @@ type TimedLogger = {
    */
   get stop(): () => void;
 };
+declare function TimeLogger(this: any, label: string): void;
 declare function isLogger(value: unknown): value is Logger;
-declare function isTimedLogger(value: unknown): value is TimedLogger;
+declare function isTimeLogger(value: unknown): value is TimeLogger;
 /**
  * A logger that can be used to log messages to the console
  *
@@ -8666,4 +8326,4 @@ export declare class SizedSet<Value = unknown> extends Set<Value> {
   get(value: Value, update?: boolean): Value | undefined;
 }
 //#endregion
-export { type Color, type ColorType, type ColorTypeExtended, type ColorValue, type ColorValueExtended, type HSLAColor, type HSLColor, type HWBAColor, type HWBColor, Key$1 as Key, Logger, type RGBAColor, type RGBColor, type Shaken, type Smushed, type Subscription, type SubscriptionParameters, type SubscriptionProperty, type Subscriptions, type SubscriptionsParameters, type TimedLogger, type Unsmushed, toPromise as fromResult, getRandomFloatingNumber as getRandomFloat, isLogger, isTimedLogger };
+export { type AsyncLimiter, type Color, type ColorType, type ColorTypeExtended, type ColorValue, type ColorValueExtended, type HSLAColor, type HSLColor, type HWBAColor, type HWBColor, Key$1 as Key, type Limiter, Logger, Once, OnceAsync, type RGBAColor, type RGBColor, type Shaken, type Smushed, type Subscription, type SubscriptionParameters, type SubscriptionProperty, type Subscriptions, type SubscriptionsParameters, type TimeLogger, type Unsmushed, toPromise as fromResult, getRandomFloatingNumber as getRandomFloat, isLogger, isTimeLogger };