@oscarpalmer/atoms 0.204.0 → 0.205.0

package/dist/index.d.mts

@@ -75,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
  */
-type OnceAsync<Callback extends GenericAsyncCallback> = {
+export type OnceAsync<Callback extends GenericAsyncCallback> = {
   /**
    * Did the callback's promise reject?
    */
@@ -95,7 +95,7 @@ type OnceAsync<Callback extends GenericAsyncCallback> = {
 /**
  * A callback function that can only be called once, returning the same value on subsequent calls
  */
-type Once<Callback extends GenericCallback> = {
+export type Once<Callback extends GenericCallback> = {
   /**
    * Run the callback
    *
@@ -307,7 +307,150 @@ export declare function filter<Item>(array: Item[], filter: (item: Item, index:
  */
 export declare function filter<Item>(array: Item[], item: Item): Item[];
 export declare namespace filter {
-  var remove: typeof exclude;
+  export var remove: typeof exclude;
+}
+//#endregion
+//#region src/array/find.d.ts
+/**
+ * Get the first item matching the given value
+ *
+ * @param array Array to search in
+ * @param callback Callback to get an item's value for matching
+ * @param value Value to match against
+ * @returns First item that matches the value, or `undefined` if no match is found
+ *
+ * @example
+ * ```typescript
+ * find(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   item => item.value,
+ *   10,
+ * ); // => {id: 1, value: 10}
+ * ```
+ */
+export declare function find<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item | undefined;
+/**
+ * Get the first item matching the given value by key
+ *
+ * @param array Array to search in
+ * @param key Key to get an item's value for matching
+ * @param value Value to match against
+ * @returns First item that matches the value, or `undefined` if no match is found
+ *
+ * @example
+ * ```typescript
+ * find(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   'value',
+ *   10,
+ * ); // => {id: 1, value: 10}
+ * ```
+ */
+export declare function find<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): Item | undefined;
+/**
+ * Get the first item matching the filter
+ *
+ * @param array Array to search in
+ * @param filter Filter callback to match items
+ * @returns First item that matches the filter, or `undefined` if no match is found
+ *
+ * @example
+ * ```typescript
+ * find(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   item => item.value === 10,
+ * ); // => {id: 1, value: 10}
+ * ```
+ */
+export declare function find<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): Item | undefined;
+/**
+ * Get the first item matching the given value
+ *
+ * @param array Array to search in
+ * @param value Value to match against
+ * @returns First item that matches the value, or `undefined` if no match is found
+ *
+ * @example
+ * ```typescript
+ * find([1, 2, 3, 2, 1], 1); // => 1
+ * ```
+ */
+export declare function find<Item>(array: Item[], value: Item): Item | undefined;
+/**
+ * Get the last item matching the given value
+ *
+ * _Available as `findLast` and `find.last`_
+ *
+ * @param array Array to search in
+ * @param callback Callback to get an item's value for matching
+ * @param value Value to match against
+ * @returns Last item that matches the value, or `undefined` if no match is found
+ *
+ * @example
+ * ```typescript
+ * findLast(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   item => item.value,
+ *   10,
+ * ); // => {id: 3, value: 10}
+ * ```
+ */
+export declare function findLast<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item | undefined;
+/**
+ * Get the last item matching the given value by key
+ *
+ * _Available as `findLast` and `find.last`_
+ *
+ * @param array Array to search in
+ * @param key Key to get an item's value for matching
+ * @param value Value to match against
+ * @returns Last item that matches the value, or `undefined` if no match is found
+ *
+ * @example
+ * ```typescript
+ * findLast(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   'value',
+ *   10,
+ * ); // => {id: 3, value: 10}
+ * ```
+ */
+export declare function findLast<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): Item | undefined;
+/**
+ * Get the last item matching the filter
+ *
+ * _Available as `findLast` and `find.last`_
+ *
+ * @param array Array to search in
+ * @param filter Filter callback to match items
+ * @returns Last item that matches the filter, or `undefined` if no match is found
+ *
+ * @example
+ * ```typescript
+ * findLast(
+ *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
+ *   item => item.value === 10,
+ * ); // => {id: 3, value: 10}
+ * ```
+ */
+export declare function findLast<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): Item | undefined;
+/**
+ * Get the last item matching the given value
+ *
+ * _Available as `findLast` and `find.last`_
+ *
+ * @param array Array to search in
+ * @param value Value to match against
+ * @returns Last item that matches the value, or `undefined` if no match is found
+ *
+ * @example
+ * ```typescript
+ * findLast([1, 2, 3, 2, 1], 1); // => 1
+ * ```
+ */
+export declare function findLast<Item>(array: Item[], value: Item): Item | undefined;
+export declare namespace find {
+  export var last: typeof findLast;
 }
 //#endregion
 //#region src/array/first.d.ts
@@ -377,10 +520,6 @@ export declare function first<Item>(array: Item[], filter: (item: Item, index: n
  * ```
  */
 export declare function first<Item>(array: Item[]): Item | undefined;
-export declare namespace first {
-  var _a: typeof firstOrDefault;
-  export { _a as default };
-}
 /**
  * Get the first item matching the given value, or a default value if no match is found
  *
@@ -460,6 +599,9 @@ export declare function firstOrDefault<Item>(array: Item[], defaultValue: Item,
  * ```
  */
 export declare function firstOrDefault<Item>(array: Item[], defaultValue: Item): Item;
+export declare namespace first {
+  export var defaulted: typeof firstOrDefault;
+}
 //#endregion
 //#region src/array/group-by.d.ts
 /**
@@ -514,9 +656,6 @@ export declare function groupBy<Item, KeyArg extends KeyOrCallback<Item, Key$1>>
  * ```
  */
 export declare function groupBy<Item>(array: Item[]): Record<number, Item>;
-export declare namespace groupBy {
-  var arrays: typeof groupArraysBy;
-}
 /**
  * Create a record from an array of items using a specific key, grouping values into arrays
  *
@@ -561,6 +700,9 @@ export declare function groupArraysBy<Item, KeyArg extends KeyOrCallback<Item, K
  * ```
  */
 export declare function groupArraysBy<Item, KeyArg extends KeyOrCallback<Item, Key$1>>(array: Item[], key: KeyArg): Simplify<Record<KeyOrCallbackKey<Item, KeyArg>, Item[]>>;
+export declare namespace groupBy {
+  export var arrays: typeof groupArraysBy;
+}
 //#endregion
 //#region src/internal/array/chunk.d.ts
 /**
@@ -590,7 +732,7 @@ export declare function chunk<Item>(array: Item[], size?: number): Item[][];
  * compact([0, 1, '', 'hello', false, true, null, undefined]); // => [1, 'hello', true]
  * ```
  */
-export declare function compact<Item>(array: Item[], strict: true): Array<Exclude<Item, 0 | '' | false | null | undefined>>;
+export declare function compact<Item>(array: Item[], strict: true): Array<Exclude<Item, 0 | "" | false | null | undefined>>;
 /**
  * Compact an array _(removing all `null` and `undefined` values)_
  *
@@ -682,245 +824,102 @@ export declare function getArray<Item>(value: Item[]): Item[];
  */
 export declare function getArray<Value>(value: Value): Value[];
 //#endregion
-//#region src/internal/array/index-of.d.ts
+//#region src/internal/array/match.d.ts
 /**
- * Get the index of the first matching item by callback
+ * Comparison of an array within another array
+ */
+export type ArrayComparison = "end" | "inside" | "invalid" | "outside" | "same" | "start";
+/**
+ * Is the needle array at the end of the haystack array?
  *
- * @param array Array to search in
- * @param callback Callback to get an item's value
- * @param value Value to match against
- * @returns Index of the first matching item, or `-1` if no match is found
+ * @param haystack Haystack array
+ * @param needle Needle array
+ * @param callback Callback to get an item's value for matching
+ * @returns `true` if the haystack ends with the needle, otherwise `false`
  *
  * @example
  * ```typescript
- * indexOf(
+ * endsWithArray(
  *   [{id: 1}, {id: 2}, {id: 3}],
+ *   [{id: 2}, {id: 3}],
  *   item => item.id,
- *   2,
- * ); // => 1
+ * ); // => true
  * ```
  */
-export declare function indexOf<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): number;
+export declare function endsWithArray<Item>(haystack: Item[], needle: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): boolean;
 /**
- * Get the index of the first matching item by key
+ * Is the needle array at the end of the haystack array?
  *
- * @param array Array to search in
- * @param key Key to match items by
- * @param value Value to match against
- * @returns Index of the first matching item, or `-1` if no match is found
+ * @param haystack Haystack array
+ * @param needle Needle array
+ * @param key Key to get an item's value for matching
+ * @returns `true` if the haystack ends with the needle, otherwise `false`
  *
  * @example
  * ```typescript
- * indexOf(
+ * endsWithArray(
  *   [{id: 1}, {id: 2}, {id: 3}],
+ *   [{id: 2}, {id: 3}],
  *   'id',
- *   2,
- * ); // => 1
+ * ); // => true
  * ```
  */
-export declare function indexOf<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): number;
+export declare function endsWithArray<Item extends PlainObject>(haystack: Item[], needle: Item[], key: keyof Item): boolean;
 /**
- * Get the index of the first item matching the filter
+ * Is the needle array at the end of the haystack array?
  *
- * @param array Array to search in
- * @param filter Filter callback to match items
- * @returns Index of the first matching item, or `-1` if no match is found
+ * @param haystack Haystack array
+ * @param needle Needle array
+ * @returns `true` if the haystack ends with the needle, otherwise `false`
  *
  * @example
  * ```typescript
- * indexOf(
- *   [{id: 1}, {id: 2}, {id: 3}],
- *   item => item.id === 2,
- * ); // => 1
+ * endsWithArray([1, 2, 3], [2, 3]); // => true
  * ```
  */
-export declare function indexOf<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): number;
+export declare function endsWithArray<Item>(haystack: Item[], needle: Item[]): boolean;
 /**
- * Get the index of the first item matching the given item
+ * Get the position of an array within another array
  *
- * @param array Array to search in
- * @param item Item to match against
- * @returns Index of the first matching item, or `-1` if no match is found
+ * @param haystack Haystack array
+ * @param needle Needle array
+ * @param callback Callback to get an item's value for matching
+ * @returns Position of the needle within the haystack
  *
  * @example
  * ```typescript
- * indexOf([1, 2, 3, 4, 5], 3); // => 2
+ * getArrayComparison(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   [{id: 2}, {id: 3}],
+ *   item => item.id,
+ * ); // => 'end'
  * ```
  */
-export declare function indexOf<Item>(array: Item[], item: Item): number;
-export declare namespace indexOf {
-  var last: typeof lastIndexOf;
-}
+export declare function getArrayComparison<Item>(haystack: Item[], needle: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): ArrayComparison;
 /**
- * Get the index of the last matching item by callback
- *
- * _Available as `lastIndexOf` and `indexOf.last`_
+ * Get the position of an array within another array
  *
- * @param array Array to search in
- * @param callback Callback to get an item's value
- * @param value Value to match against
- * @returns Index of the last matching item, or `-1` if no match is found
+ * @param haystack Haystack array
+ * @param needle Needle array
+ * @param key Key to get an item's value for matching
+ * @returns Position of the needle within the haystack
  *
  * @example
  * ```typescript
- * lastIndexOf(
- *   [{id: 1}, {id: 2}, {id: 3}, {id: 2}],
- *   item => item.id,
- *   2,
- * ); // => 3
+ * getArrayComparison(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   [{id: 2}, {id: 3}],
+ *   'id',
+ * ); // => 'end'
  * ```
  */
-export declare function lastIndexOf<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): number;
+export declare function getArrayComparison<Item extends PlainObject>(haystack: Item[], needle: Item[], key: keyof Item): ArrayComparison;
 /**
- * Get the index of the last matching item by key
+ * Get the position of an array within another array
  *
- * _Available as `lastIndexOf` and `indexOf.last`_
- *
- * @param array Array to search in
- * @param key Key to match items by
- * @param value Value to match against
- * @returns Index of the last matching item, or `-1` if no match is found
- *
- * @example
- * ```typescript
- * lastIndexOf(
- *   [{id: 1}, {id: 2}, {id: 3}, {id: 2}],
- *   'id',
- *   2,
- * ); // => 3
- * ```
- */
-export declare function lastIndexOf<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): number;
-/**
- * Get the index of the last item matching the filter
- *
- * _Available as `lastIndexOf` and `indexOf.last`_
- *
- * @param array Array to search in
- * @param filter Filter callback to match items
- * @returns Index of the last matching item, or `-1` if no match is found
- *
- * @example
- * ```typescript
- * lastIndexOf(
- *   [{id: 1}, {id: 2}, {id: 3}, {id: 2}],
- *   item => item.id === 2,
- * ); // => 3
- * ```
- */
-export declare function lastIndexOf<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): number;
-/**
- * Get the index of the last item matching the given item
- *
- * _Available as `lastIndexOf` and `indexOf.last`_
- *
- * @param array Array to search in
- * @param item Item to match against
- * @returns Index of the last matching item, or `-1` if no match is found
- *
- * @example
- * ```typescript
- * lastIndexOf([1, 2, 3, 2, 1], 2); // => 3
- * ```
- */
-export declare function lastIndexOf<Item>(array: Item[], item: Item): number;
-//#endregion
-//#region src/internal/array/match.d.ts
-/**
- * Comparison of an array within another array
- */
-export type ArrayComparison = 'end' | 'inside' | 'invalid' | 'outside' | 'same' | 'start';
-/**
- * Is the needle array at the end of the haystack array?
- *
- * @param haystack Haystack array
- * @param needle Needle array
- * @param callback Callback to get an item's value for matching
- * @returns `true` if the haystack ends with the needle, otherwise `false`
- *
- * @example
- * ```typescript
- * endsWithArray(
- *   [{id: 1}, {id: 2}, {id: 3}],
- *   [{id: 2}, {id: 3}],
- *   item => item.id,
- * ); // => true
- * ```
- */
-export declare function endsWithArray<Item>(haystack: Item[], needle: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): boolean;
-/**
- * Is the needle array at the end of the haystack array?
- *
- * @param haystack Haystack array
- * @param needle Needle array
- * @param key Key to get an item's value for matching
- * @returns `true` if the haystack ends with the needle, otherwise `false`
- *
- * @example
- * ```typescript
- * endsWithArray(
- *   [{id: 1}, {id: 2}, {id: 3}],
- *   [{id: 2}, {id: 3}],
- *   'id',
- * ); // => true
- * ```
- */
-export declare function endsWithArray<Item extends PlainObject>(haystack: Item[], needle: Item[], key: keyof Item): boolean;
-/**
- * Is the needle array at the end of the haystack array?
- *
- * @param haystack Haystack array
- * @param needle Needle array
- * @returns `true` if the haystack ends with the needle, otherwise `false`
- *
- * @example
- * ```typescript
- * endsWithArray([1, 2, 3], [2, 3]); // => true
- * ```
- */
-export declare function endsWithArray<Item>(haystack: Item[], needle: Item[]): boolean;
-/**
- * Get the position of an array within another array
- *
- * @param haystack Haystack array
- * @param needle Needle array
- * @param callback Callback to get an item's value for matching
- * @returns Position of the needle within the haystack
- *
- * @example
- * ```typescript
- * getArrayComparison(
- *   [{id: 1}, {id: 2}, {id: 3}],
- *   [{id: 2}, {id: 3}],
- *   item => item.id,
- * ); // => 'end'
- * ```
- */
-export declare function getArrayComparison<Item>(haystack: Item[], needle: Item[], callback: (item: Item, index: number, array: Item[]) => unknown): ArrayComparison;
-/**
- * Get the position of an array within another array
- *
- * @param haystack Haystack array
- * @param needle Needle array
- * @param key Key to get an item's value for matching
- * @returns Position of the needle within the haystack
- *
- * @example
- * ```typescript
- * getArrayComparison(
- *   [{id: 1}, {id: 2}, {id: 3}],
- *   [{id: 2}, {id: 3}],
- *   'id',
- * ); // => 'end'
- * ```
- */
-export declare function getArrayComparison<Item extends PlainObject>(haystack: Item[], needle: Item[], key: keyof Item): ArrayComparison;
-/**
- * Get the position of an array within another array
- *
- * @param haystack Haystack array
- * @param needle Needle array
- * @returns Position of the needle within the haystack
+ * @param haystack Haystack array
+ * @param needle Needle array
+ * @returns Position of the needle within the haystack
  *
  * @example
  * ```typescript
@@ -1206,234 +1205,91 @@ export declare function exists<Item>(array: Item[], filter: (item: Item, index:
  */
 export declare function exists<Item>(array: Item[], item: Item): boolean;
 //#endregion
-//#region src/array/find.d.ts
+//#region src/array/flatten.d.ts
 /**
- * Get the first item matching the given value
+ * Flatten an array _(using native `flat` and maximum depth)_
  *
- * @param array Array to search in
- * @param callback Callback to get an item's value for matching
- * @param value Value to match against
- * @returns First item that matches the value, or `undefined` if no match is found
+ * @param array Array to flatten
+ * @returns Flattened array
  *
  * @example
  * ```typescript
- * find(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   item => item.value,
- *   10,
- * ); // => {id: 1, value: 10}
+ * flatten([1, [2, [3, 4], 5], 6]); // => [1, 2, 3, 4, 5, 6]
  * ```
  */
-export declare function find<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item | undefined;
+export declare function flatten<Item>(array: Item[]): Array<NestedArray<Item>>;
+//#endregion
+//#region src/array/from.d.ts
 /**
- * Get the first item matching the given value by key
+ * Get an array with a specified length, filled with indices
  *
- * @param array Array to search in
- * @param key Key to get an item's value for matching
- * @param value Value to match against
- * @returns First item that matches the value, or `undefined` if no match is found
+ * @param length Length of the array
+ * @returns Array of indices
  *
  * @example
  * ```typescript
- * find(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- *   10,
- * ); // => {id: 1, value: 10}
+ * range(5); // => [0, 1, 2, 3, 4]
  * ```
  */
-export declare function find<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): Item | undefined;
+export declare function range(length: number): number[];
 /**
- * Get the first item matching the filter
+ * Get an array of numbers in a specified range
  *
- * @param array Array to search in
- * @param filter Filter callback to match items
- * @returns First item that matches the filter, or `undefined` if no match is found
+ * @param start Starting number _(inclusive)_
+ * @param end Ending number _(exclusive)_
+ * @returns Array of numbers in range
  *
  * @example
  * ```typescript
- * find(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   item => item.value === 10,
- * ); // => {id: 1, value: 10}
+ * range(2, 5); // => [2, 3, 4]
  * ```
  */
-export declare function find<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): Item | undefined;
+export declare function range(start: number, end: number): number[];
 /**
- * Get the first item matching the given value
+ * Get an array of numbers in a specified range with a specified step
  *
- * @param array Array to search in
- * @param value Value to match against
- * @returns First item that matches the value, or `undefined` if no match is found
+ * @param start Starting number _(inclusive)_
+ * @param end Ending number _(exclusive)_
+ * @param step Step between numbers
+ * @returns Array of numbers in range
  *
  * @example
  * ```typescript
- * find([1, 2, 3, 2, 1], 1); // => 1
+ * range(0, 10, 2); // => [0, 2, 4, 6, 8]
  * ```
  */
-export declare function find<Item>(array: Item[], value: Item): Item | undefined;
-export declare namespace find {
-  var last: typeof findLast;
-}
+export declare function range(start: number, end: number, step: number): number[];
 /**
- * Get the last item matching the given value
- *
- * _Available as `findLast` and `find.last`_
+ * Get an array with a specified length, filled with indices
  *
- * @param array Array to search in
- * @param callback Callback to get an item's value for matching
- * @param value Value to match against
- * @returns Last item that matches the value, or `undefined` if no match is found
+ * @param length Length of the array
+ * @returns Array of indices
  *
  * @example
  * ```typescript
- * findLast(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   item => item.value,
- *   10,
- * ); // => {id: 3, value: 10}
+ * times(5); // => [0, 1, 2, 3, 4]
  * ```
  */
-export declare function findLast<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item | undefined;
+export declare function times(length: number): number[];
 /**
- * Get the last item matching the given value by key
- *
- * _Available as `findLast` and `find.last`_
+ * Get an array with a specified length, filled by values from a callback
  *
- * @param array Array to search in
- * @param key Key to get an item's value for matching
- * @param value Value to match against
- * @returns Last item that matches the value, or `undefined` if no match is found
+ * @param length Length of the array
+ * @param callback Callback function to generate values
+ * @returns Array of values generated by the callback
  *
  * @example
  * ```typescript
- * findLast(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   'value',
- *   10,
- * ); // => {id: 3, value: 10}
+ * times(5, index => index * 2); // => [0, 2, 4, 6, 8]
  * ```
  */
-export declare function findLast<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): Item | undefined;
+export declare function times<Callback extends (index: number) => unknown>(length: number, callback: Callback): Array<ReturnType<Callback>>;
 /**
- * Get the last item matching the filter
+ * Get an array with a specified length, filled with a specified value
  *
- * _Available as `findLast` and `find.last`_
- *
- * @param array Array to search in
- * @param filter Filter callback to match items
- * @returns Last item that matches the filter, or `undefined` if no match is found
- *
- * @example
- * ```typescript
- * findLast(
- *   [{id: 1, value: 10}, {id: 2, value: 20}, {id: 3, value: 10}],
- *   item => item.value === 10,
- * ); // => {id: 3, value: 10}
- * ```
- */
-export declare function findLast<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): Item | undefined;
-/**
- * Get the last item matching the given value
- *
- * _Available as `findLast` and `find.last`_
- *
- * @param array Array to search in
- * @param value Value to match against
- * @returns Last item that matches the value, or `undefined` if no match is found
- *
- * @example
- * ```typescript
- * findLast([1, 2, 3, 2, 1], 1); // => 1
- * ```
- */
-export declare function findLast<Item>(array: Item[], value: Item): Item | undefined;
-//#endregion
-//#region src/array/flatten.d.ts
-/**
- * Flatten an array _(using native `flat` and maximum depth)_
- *
- * @param array Array to flatten
- * @returns Flattened array
- *
- * @example
- * ```typescript
- * flatten([1, [2, [3, 4], 5], 6]); // => [1, 2, 3, 4, 5, 6]
- * ```
- */
-export declare function flatten<Item>(array: Item[]): Array<NestedArray<Item>>;
-//#endregion
-//#region src/array/from.d.ts
-/**
- * Get an array with a specified length, filled with indices
- *
- * @param length Length of the array
- * @returns Array of indices
- *
- * @example
- * ```typescript
- * range(5); // => [0, 1, 2, 3, 4]
- * ```
- */
-export declare function range(length: number): number[];
-/**
- * Get an array of numbers in a specified range
- *
- * @param start Starting number _(inclusive)_
- * @param end Ending number _(exclusive)_
- * @returns Array of numbers in range
- *
- * @example
- * ```typescript
- * range(2, 5); // => [2, 3, 4]
- * ```
- */
-export declare function range(start: number, end: number): number[];
-/**
- * Get an array of numbers in a specified range with a specified step
- *
- * @param start Starting number _(inclusive)_
- * @param end Ending number _(exclusive)_
- * @param step Step between numbers
- * @returns Array of numbers in range
- *
- * @example
- * ```typescript
- * range(0, 10, 2); // => [0, 2, 4, 6, 8]
- * ```
- */
-export declare function range(start: number, end: number, step: number): number[];
-/**
- * Get an array with a specified length, filled with indices
- *
- * @param length Length of the array
- * @returns Array of indices
- *
- * @example
- * ```typescript
- * times(5); // => [0, 1, 2, 3, 4]
- * ```
- */
-export declare function times(length: number): number[];
-/**
- * Get an array with a specified length, filled by values from a callback
- *
- * @param length Length of the array
- * @param callback Callback function to generate values
- * @returns Array of values generated by the callback
- *
- * @example
- * ```typescript
- * times(5, index => index * 2); // => [0, 2, 4, 6, 8]
- * ```
- */
-export declare function times<Callback extends (index: number) => unknown>(length: number, callback: Callback): Array<ReturnType<Callback>>;
-/**
- * Get an array with a specified length, filled with a specified value
- *
- * @param length Length of the array
- * @param value Value to fill the array with
- * @returns Array filled with the specified value
+ * @param length Length of the array
+ * @param value Value to fill the array with
+ * @returns Array filled with the specified value
  *
  * @example
  * ```typescript
@@ -1622,301 +1478,121 @@ export declare function push<Item>(array: Item[], pushed: Item[]): number;
  */
 export declare function reverse<Item>(array: Item[]): Item[];
 //#endregion
-//#region src/array/select.d.ts
-type MapKeyOrCallback<Item> = ((item: Item, index: number, array: Item[]) => unknown) | (Item extends PlainObject ? keyof Item : never);
-type Mapped<Item, Map extends MapKeyOrCallback<Item>> = Map extends ((item: Item, index: number, array: Item[]) => unknown) ? ReturnType<Map> : Map extends keyof Item ? Item[Map] : never;
-type ObjectKeysOf<Item> = { [Key in keyof Item]: Item[Key] extends PlainObject ? Key : never; }[keyof Item];
+//#region src/array/single.d.ts
 /**
- * Get a mapped and filtered array of items
+ * Get the _only_ item matching the given value
+ *
+ * Throws an error if multiple items match the value
  *
  * @param array Array to search in
- * @param map Callback or key to map the items
- * @param filterCallback Callback to get a mapped value's value for matching
- * @param filterValue Value to match against
- * @returns Mapped and filtered array of items
+ * @param callback Callback to get an item's value for matching
+ * @param value Value to match against
+ * @returns Only item that matches the value, or `undefined` if no match is found
  *
  * @example
  * ```typescript
- * reverseSelect(
- *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
- *   item => item.name,
- *   value => value.length,
- *   3,
- * ); // => ['Bob']
+ * single(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   item => item.id,
+ *   2
+ * ); // => {id: 2}
  * ```
  */
-export declare function reverseSelect<Item, Map extends MapKeyOrCallback<Item>, FilterCallback extends (item: Mapped<Item, Map>, index: number, array: Item[]) => unknown>(array: Item[], map: Map, filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>): Array<Mapped<Item, Map>>;
+export declare function single<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item | undefined;
 /**
- * Get a mapped and filtered array of items
+ * Get the _only_ item matching the given value by key
+ *
+ * Throws an error if multiple items match the value
  *
  * @param array Array to search in
- * @param map Callback to map the items
- * @param filterKey Key to get a mapped value's value for matching
- * @param filterValue Value to match against
- * @returns Mapped and filtered array of items
+ * @param key Key to get an item's value for matching
+ * @param value Value to match against
+ * @returns Only item that matches the value, or `undefined` if no match is found
  *
  * @example
  * ```typescript
- * reverseSelect(
- *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
- *   item => ({label: item.name}),
- *   'label',
- *   'Bob',
- * ); // => [{label: 'Bob'}]
+ * single(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   'id',
+ *   2
+ * ); // => {id: 2}
  * ```
  */
-export declare function reverseSelect<Item, MapCallback extends (item: Item, index: number, array: Item[]) => PlainObject, ItemKey extends keyof ReturnType<MapCallback>>(array: Item[], map: MapCallback, filterKey: ItemKey, filterValue: ReturnType<MapCallback>[ItemKey]): Array<ReturnType<MapCallback>>;
+export declare function single<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): Item | undefined;
 /**
- * Get a mapped and filtered array of items
+ * Get the _only_ item matching the filter
+ *
+ * Throws an error if multiple items match the filter
  *
  * @param array Array to search in
- * @param map Key to map the items
- * @param filterKey Key to get a mapped value's value for matching
- * @param filterValue Value to match against
- * @returns Mapped and filtered array of items
+ * @param filter Filter callback to match items
+ * @returns Only item that matches the filter, or `undefined` if no match is found
  *
  * @example
  * ```typescript
- * reverseSelect(
- *   [{meta: {tag: 'a'}}, {meta: {tag: 'b'}}],
- *   'meta',
- *   'tag',
- *   'b',
- * ); // => [{tag: 'b'}]
+ * single(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   item => item.id === 2
+ * ); // => {id: 2}
  * ```
  */
-export declare function reverseSelect<Item, MapKey extends ObjectKeysOf<Item>, ItemKey extends keyof Item[MapKey]>(array: Item[], map: MapKey, filterKey: ItemKey, filterValue: Item[MapKey][ItemKey]): Array<Item[MapKey]>;
+export declare function single<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): Item | undefined;
+//#endregion
+//#region src/array/slice.d.ts
 /**
- * Get a mapped and filtered array of items
+ * Drop items from the start of an array until they match a value
  *
- * @param array Array to search in
- * @param map Callback or key to map the items
- * @param filter Filter callback to match mapped values
- * @returns Mapped and filtered array of items
+ * @param array Original array
+ * @param callback Callback to get an item's value for matching
+ * @param value Value to match against
+ * @returns New array with items dropped
  *
  * @example
  * ```typescript
- * reverseSelect(
- *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
- *   item => item.name,
- *   value => value.startsWith('B'),
- * ); // => ['Bob']
+ * drop(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   item => item.id,
+ *   2,
+ * ); // => [{id: 2}, {id: 3}]
  * ```
  */
-export declare function reverseSelect<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], map: Map, filter: (item: Mapped<Item, Map>, index: number, array: Item[]) => boolean): Array<Mapped<Item, Map>>;
+export declare function drop<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item[];
 /**
- * Get a mapped and filtered array of items
+ * Drop items from the start of an array until they match a value
  *
- * @param array Array to search in
- * @param map Callback or key to map the items
- * @param value Mapped value to match against
- * @returns Mapped and filtered array of items
+ * @param array Original array
+ * @param key Key to get an item's value for matching
+ * @param value Value to match against
+ * @returns New array with items dropped
  *
  * @example
  * ```typescript
- * reverseSelect(
- *   [1, 2, 3, 2, 1],
- *   value => value ** 2,
- *   4,
- * ); // => [4, 4]
+ * drop(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   'id',
+ *   2,
+ * ); // => [{id: 2}, {id: 3}]
  * ```
  */
-export declare function reverseSelect<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], map: Map, value: Mapped<Item, Map>): Array<Mapped<Item, Map>>;
+export declare function drop<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): Item[];
 /**
- * Get a filtered and mapped array of items
+ * Drop items from the start of an array while they match a filter
  *
- * @param array Array to search in
- * @param filterCallback Callback to get an item's value for matching
- * @param filterValue Value to match against
- * @param map Callback or key to map the matched items
- * @returns Filtered and mapped array of items
+ * @param array Original array
+ * @param callback Filter callback to match items
+ * @returns New array with items dropped
  *
  * @example
  * ```typescript
- * select(
- *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
- *   item => item.id,
- *   2,
- *   item => item.name,
- * ); // => ['Bob']
+ * drop(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   item => item.id === 2,
+ * ); // => [{id: 2}, {id: 3}]
  * ```
  */
-export declare function select<Item, FilterCallback extends (item: Item, index: number, array: Item[]) => unknown, Map extends MapKeyOrCallback<Item>>(array: Item[], filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>, map: Map): Array<Mapped<Item, Map>>;
+export declare function drop<Item extends PlainObject>(array: Item[], callback: (item: Item, index: number, array: Item[]) => boolean): Item[];
 /**
- * Get a filtered and mapped array of items
- *
- * @param array Array to search in
- * @param filterKey Key to get an item's value for matching
- * @param filterValue Value to match against
- * @param map Callback or key to map the matched items
- * @returns Filtered and mapped array of items
- *
- * @example
- * ```typescript
- * select(
- *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
- *   'id',
- *   2,
- *   'name',
- * ); // => ['Bob']
- * ```
- */
-export declare function select<Item extends PlainObject, ItemKey extends keyof Item, Map extends MapKeyOrCallback<Item>>(array: Item[], filterKey: ItemKey, filterValue: Item[ItemKey], map: Map): Array<Mapped<Item, Map>>;
-/**
- * Get a filtered and mapped array of items
- *
- * @param array Array to search in
- * @param filter Filter callback to match items
- * @param map Callback or key to map the matched items
- * @returns Filtered and mapped array of items
- *
- * @example
- * ```typescript
- * select(
- *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
- *   item => item.id === 2,
- *   item => item.name,
- * ); // => ['Bob']
- * ```
- */
-export declare function select<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean, map: Map): Array<Mapped<Item, Map>>;
-/**
- * Get a filtered and mapped array of items
- *
- * @param array Array to search in
- * @param item Item to match against
- * @param map Callback or key to map the matched items
- * @returns Filtered and mapped array of items
- *
- * @example
- * ```typescript
- * select(
- *   [1, 2, 3, 2, 1],
- *   3,
- *   value => value ** 2,
- * ); // => [9]
- * ```
- */
-export declare function select<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], item: Item, map: Map): Array<Mapped<Item, Map>>;
-export declare namespace select {
-  var reverse: typeof reverseSelect;
-}
-//#endregion
-//#region src/array/single.d.ts
-/**
- * Get the _only_ item matching the given value
- *
- * Throws an error if multiple items match the value
- *
- * @param array Array to search in
- * @param callback Callback to get an item's value for matching
- * @param value Value to match against
- * @returns Only item that matches the value, or `undefined` if no match is found
- *
- * @example
- * ```typescript
- * single(
- *   [{id: 1}, {id: 2}, {id: 3}],
- *   item => item.id,
- *   2
- * ); // => {id: 2}
- * ```
- */
-export declare function single<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item | undefined;
-/**
- * Get the _only_ item matching the given value by key
- *
- * Throws an error if multiple items match the value
- *
- * @param array Array to search in
- * @param key Key to get an item's value for matching
- * @param value Value to match against
- * @returns Only item that matches the value, or `undefined` if no match is found
- *
- * @example
- * ```typescript
- * single(
- *   [{id: 1}, {id: 2}, {id: 3}],
- *   'id',
- *   2
- * ); // => {id: 2}
- * ```
- */
-export declare function single<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): Item | undefined;
-/**
- * Get the _only_ item matching the filter
- *
- * Throws an error if multiple items match the filter
- *
- * @param array Array to search in
- * @param filter Filter callback to match items
- * @returns Only item that matches the filter, or `undefined` if no match is found
- *
- * @example
- * ```typescript
- * single(
- *   [{id: 1}, {id: 2}, {id: 3}],
- *   item => item.id === 2
- * ); // => {id: 2}
- * ```
- */
-export declare function single<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): Item | undefined;
-//#endregion
-//#region src/array/slice.d.ts
-/**
- * Drop items from the start of an array until they match a value
- *
- * @param array Original array
- * @param callback Callback to get an item's value for matching
- * @param value Value to match against
- * @returns New array with items dropped
- *
- * @example
- * ```typescript
- * drop(
- *   [{id: 1}, {id: 2}, {id: 3}],
- *   item => item.id,
- *   2,
- * ); // => [{id: 2}, {id: 3}]
- * ```
- */
-export declare function drop<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item[];
-/**
- * Drop items from the start of an array until they match a value
- *
- * @param array Original array
- * @param key Key to get an item's value for matching
- * @param value Value to match against
- * @returns New array with items dropped
- *
- * @example
- * ```typescript
- * drop(
- *   [{id: 1}, {id: 2}, {id: 3}],
- *   'id',
- *   2,
- * ); // => [{id: 2}, {id: 3}]
- * ```
- */
-export declare function drop<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): Item[];
-/**
- * Drop items from the start of an array while they match a filter
- *
- * @param array Original array
- * @param callback Filter callback to match items
- * @returns New array with items dropped
- *
- * @example
- * ```typescript
- * drop(
- *   [{id: 1}, {id: 2}, {id: 3}],
- *   item => item.id === 2,
- * ); // => [{id: 2}, {id: 3}]
- * ```
- */
-export declare function drop<Item extends PlainObject>(array: Item[], callback: (item: Item, index: number, array: Item[]) => boolean): Item[];
-/**
- * Drop a specified number of items, from the start if `>= 0`, or from the end if `< 0`
+ * Drop a specified number of items, from the start if `>= 0`, or from the end if `< 0`
  *
  * @param array Original array
  * @param count Number of items to drop
@@ -2448,10 +2124,6 @@ export declare function last<Item>(array: Item[], filter: (item: Item, index: nu
  * ```
  */
 export declare function last<Item>(array: Item[]): Item | undefined;
-export declare namespace last {
-  var _a: typeof lastOrDefault;
-  export { _a as default };
-}
 /**
  * Get the last item matching the given value
  *
@@ -2531,6 +2203,9 @@ export declare function lastOrDefault<Item>(array: Item[], defaultValue: Item, f
  * ```
  */
 export declare function lastOrDefault<Item>(array: Item[], defaultValue: Item): Item;
+export declare namespace last {
+  export var defaulted: typeof lastOrDefault;
+}
 //#endregion
 //#region src/array/move.d.ts
 /**
@@ -2601,10 +2276,6 @@ export declare function move<Item extends PlainObject, ItemKey extends keyof Ite
  * ```
  */
 export declare function move<Item>(array: Item[], from: Item | Item[], to: Item | Item[]): Item[];
-export declare namespace move {
-  var indices: typeof moveIndices;
-  var toIndex: typeof moveToIndex;
-}
 /**
  * Move an item from one index to another within an array
  *
@@ -2695,46 +2366,240 @@ export declare function moveToIndex<Item extends PlainObject, ItemKey extends ke
  * ```
  */
 export declare function moveToIndex<Item>(array: Item[], value: Item | Item[], index: number): Item[];
+export declare namespace move {
+  export var indices: typeof moveIndices;
+  export var toIndex: typeof moveToIndex;
+}
 //#endregion
-//#region src/array/sort.d.ts
+//#region src/array/select.d.ts
+type MapKeyOrCallback<Item> = ((item: Item, index: number, array: Item[]) => unknown) | (Item extends PlainObject ? keyof Item : never);
+type Mapped<Item, Map extends MapKeyOrCallback<Item>> = Map extends ((item: Item, index: number, array: Item[]) => unknown) ? ReturnType<Map> : Map extends keyof Item ? Item[Map] : never;
+type ObjectKeysOf<Item> = { [Key in keyof Item]: Item[Key] extends PlainObject ? Key : never; }[keyof Item];
 /**
- * Sorting information for arrays _(using a comparison callback)_
+ * Get a filtered and mapped array of items
+ *
+ * @param array Array to search in
+ * @param filterCallback Callback to get an item's value for matching
+ * @param filterValue Value to match against
+ * @param map Callback or key to map the matched items
+ * @returns Filtered and mapped array of items
+ *
+ * @example
+ * ```typescript
+ * select(
+ *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
+ *   item => item.id,
+ *   2,
+ *   item => item.name,
+ * ); // => ['Bob']
+ * ```
  */
-export type ArrayComparisonSorter<Item> = {
-  /**
-   * Callback to use when comparing items and values
-   */
-  comparison: ComparisonSorter<Item>;
-  /**
-   * Direction to sort by
-   */
-  direction?: SortDirection;
-};
+export declare function filterAndMap<Item, FilterCallback extends (item: Item, index: number, array: Item[]) => unknown, Map extends MapKeyOrCallback<Item>>(array: Item[], filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>, map: Map): Array<Mapped<Item, Map>>;
 /**
- * Sorting information for arrays _(using a key)_
+ * Get a filtered and mapped array of items
+ *
+ * @param array Array to search in
+ * @param filterKey Key to get an item's value for matching
+ * @param filterValue Value to match against
+ * @param map Callback or key to map the matched items
+ * @returns Filtered and mapped array of items
+ *
+ * @example
+ * ```typescript
+ * select(
+ *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
+ *   'id',
+ *   2,
+ *   'name',
+ * ); // => ['Bob']
+ * ```
  */
-export type ArrayKeySorter<Item extends PlainObject, ItemKey extends keyof Item> = {
-  /**
-   * Comparator to use when comparing items and values
-   */
-  compare?: CompareCallback<Item, Item[ItemKey]>;
-  /**
-   * Direction to sort by
-   */
-  direction?: SortDirection;
-  /**
-   * Key to sort by
-   */
-  key: ItemKey;
-};
+export declare function filterAndMap<Item extends PlainObject, ItemKey extends keyof Item, Map extends MapKeyOrCallback<Item>>(array: Item[], filterKey: ItemKey, filterValue: Item[ItemKey], map: Map): Array<Mapped<Item, Map>>;
 /**
- * Sorters based on keys in an object
+ * Get a filtered and mapped array of items
+ *
+ * @param array Array to search in
+ * @param filter Filter callback to match items
+ * @param map Callback or key to map the matched items
+ * @returns Filtered and mapped array of items
+ *
+ * @example
+ * ```typescript
+ * select(
+ *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
+ *   item => item.id === 2,
+ *   item => item.name,
+ * ); // => ['Bob']
+ * ```
  */
-type ArrayKeySorters<Item extends PlainObject> = { [ItemKey in keyof Item]: ArrayKeySorter<Item, ItemKey>; }[keyof Item];
+export declare function filterAndMap<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean, map: Map): Array<Mapped<Item, Map>>;
 /**
- * Sorter to use for sorting
- */
-export type ArraySorter<Item> = Item extends PlainObject ? keyof Item | ArrayComparisonSorter<Item> | ArrayKeySorters<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item> : ArrayComparisonSorter<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item>;
+ * Get a filtered and mapped array of items
+ *
+ * @param array Array to search in
+ * @param item Item to match against
+ * @param map Callback or key to map the matched items
+ * @returns Filtered and mapped array of items
+ *
+ * @example
+ * ```typescript
+ * select(
+ *   [1, 2, 3, 2, 1],
+ *   3,
+ *   value => value ** 2,
+ * ); // => [9]
+ * ```
+ */
+export declare function filterAndMap<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], item: Item, map: Map): Array<Mapped<Item, Map>>;
+/**
+ * Get a mapped and filtered array of items
+ *
+ * _Available as `reverseSelect`_ and `select.reverse`_
+ *
+ * @param array Array to search in
+ * @param map Callback or key to map the items
+ * @param filterCallback Callback to get a mapped value's value for matching
+ * @param filterValue Value to match against
+ * @returns Mapped and filtered array of items
+ *
+ * @example
+ * ```typescript
+ * reverseSelect(
+ *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
+ *   item => item.name,
+ *   value => value.length,
+ *   3,
+ * ); // => ['Bob']
+ * ```
+ */
+export declare function mapAndFilter<Item, Map extends MapKeyOrCallback<Item>, FilterCallback extends (item: Mapped<Item, Map>, index: number, array: Item[]) => unknown>(array: Item[], map: Map, filterCallback: FilterCallback, filterValue: ReturnType<FilterCallback>): Array<Mapped<Item, Map>>;
+/**
+ * Get a mapped and filtered array of items
+ *
+ * _Available as `reverseSelect`_ and `select.reverse`_
+ *
+ * @param array Array to search in
+ * @param map Callback to map the items
+ * @param filterKey Key to get a mapped value's value for matching
+ * @param filterValue Value to match against
+ * @returns Mapped and filtered array of items
+ *
+ * @example
+ * ```typescript
+ * reverseSelect(
+ *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
+ *   item => ({label: item.name}),
+ *   'label',
+ *   'Bob',
+ * ); // => [{label: 'Bob'}]
+ * ```
+ */
+export declare function mapAndFilter<Item, MapCallback extends (item: Item, index: number, array: Item[]) => PlainObject, ItemKey extends keyof ReturnType<MapCallback>>(array: Item[], map: MapCallback, filterKey: ItemKey, filterValue: ReturnType<MapCallback>[ItemKey]): Array<ReturnType<MapCallback>>;
+/**
+ * Get a mapped and filtered array of items
+ *
+ * _Available as `reverseSelect`_ and `select.reverse`_
+ *
+ * @param array Array to search in
+ * @param map Key to map the items
+ * @param filterKey Key to get a mapped value's value for matching
+ * @param filterValue Value to match against
+ * @returns Mapped and filtered array of items
+ *
+ * @example
+ * ```typescript
+ * reverseSelect(
+ *   [{meta: {tag: 'a'}}, {meta: {tag: 'b'}}],
+ *   'meta',
+ *   'tag',
+ *   'b',
+ * ); // => [{tag: 'b'}]
+ * ```
+ */
+export declare function mapAndFilter<Item, MapKey extends ObjectKeysOf<Item>, ItemKey extends keyof Item[MapKey]>(array: Item[], map: MapKey, filterKey: ItemKey, filterValue: Item[MapKey][ItemKey]): Array<Item[MapKey]>;
+/**
+ * Get a mapped and filtered array of items
+ *
+ * _Available as `reverseSelect`_ and `select.reverse`_
+ *
+ * @param array Array to search in
+ * @param map Callback or key to map the items
+ * @param filter Filter callback to match mapped values
+ * @returns Mapped and filtered array of items
+ *
+ * @example
+ * ```typescript
+ * reverseSelect(
+ *   [{id: 1, name: 'Alice'}, {id: 2, name: 'Bob'}, {id: 3, name: 'Charlie'}],
+ *   item => item.name,
+ *   value => value.startsWith('B'),
+ * ); // => ['Bob']
+ * ```
+ */
+export declare function mapAndFilter<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], map: Map, filter: (item: Mapped<Item, Map>, index: number, array: Item[]) => boolean): Array<Mapped<Item, Map>>;
+/**
+ * Get a mapped and filtered array of items
+ *
+ * _Available as `reverseSelect`_ and `select.reverse`_
+ *
+ * @param array Array to search in
+ * @param map Callback or key to map the items
+ * @param value Mapped value to match against
+ * @returns Mapped and filtered array of items
+ *
+ * @example
+ * ```typescript
+ * reverseSelect(
+ *   [1, 2, 3, 2, 1],
+ *   value => value ** 2,
+ *   4,
+ * ); // => [4, 4]
+ * ```
+ */
+export declare function mapAndFilter<Item, Map extends MapKeyOrCallback<Item>>(array: Item[], map: Map, value: Mapped<Item, Map>): Array<Mapped<Item, Map>>;
+export declare namespace filterAndMap {
+  export var reverse: typeof mapAndFilter;
+}
+//#endregion
+//#region src/array/sort.d.ts
+/**
+ * Sorting information for arrays _(using a comparison callback)_
+ */
+export type ArrayComparisonSorter<Item> = {
+  /**
+   * Callback to use when comparing items and values
+   */
+  comparison: ComparisonSorter<Item>;
+  /**
+   * Direction to sort by
+   */
+  direction?: SortDirection;
+};
+/**
+ * Sorting information for arrays _(using a key)_
+ */
+export type ArrayKeySorter<Item extends PlainObject, ItemKey extends keyof Item> = {
+  /**
+   * Comparator to use when comparing items and values
+   */
+  compare?: CompareCallback<Item, Item[ItemKey]>;
+  /**
+   * Direction to sort by
+   */
+  direction?: SortDirection;
+  /**
+   * Key to sort by
+   */
+  key: ItemKey;
+};
+/**
+ * Sorters based on keys in an object
+ */
+type ArrayKeySorters<Item extends PlainObject> = { [ItemKey in keyof Item]: ArrayKeySorter<Item, ItemKey>; }[keyof Item];
+/**
+ * Sorter to use for sorting
+ */
+export type ArraySorter<Item> = Item extends PlainObject ? keyof Item | ArrayComparisonSorter<Item> | ArrayKeySorters<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item> : ArrayComparisonSorter<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item>;
 /**
  * Sorters to use for sorting
  */
@@ -2764,7 +2629,7 @@ type ComparisonSorter<Item> = (first: Item, second: Item) => number;
 /**
  * Direction to sort by
  */
-export type SortDirection = 'ascending' | 'descending';
+export type SortDirection = "ascending" | "descending";
 /**
  * Sorter for an array with predefined sorters
  *
@@ -2941,13 +2806,13 @@ export declare function sort<Item>(array: Item[], sorter: ArraySorter<Item>, des
  * @returns Sorted array
  */
 export declare function sort<Item>(array: Item[], descending?: boolean): Item[];
-export declare namespace sort {
-  var getIndex: typeof getSortedIndex;
-  var initialize: typeof initializeSorter;
-  var is: typeof isSorted;
-}
 export declare const SORT_DIRECTION_ASCENDING: SortDirection;
 export declare const SORT_DIRECTION_DESCENDING: SortDirection;
+export declare namespace sort {
+  export var getIndex: typeof getSortedIndex;
+  export var initialize: typeof initializeSorter;
+  export var is: typeof isSorted;
+}
 //#endregion
 //#region src/array/swap.d.ts
 /**
@@ -3116,9 +2981,6 @@ export declare function swap<Item extends PlainObject, ItemKey extends keyof Ite
  * ```
  */
 export declare function swap<Item>(array: Item[], first: Item, second: Item): Item[];
-export declare namespace swap {
-  var indices: typeof swapIndices;
-}
 /**
  * Swap two indiced items in an array
  *
@@ -3132,6 +2994,9 @@ export declare namespace swap {
  * @returns Original array with items swapped _(or unchanged if unable to swap)_
  */
 declare function swapIndices<Item>(array: Item[], first: number, second: number): Item[];
+export declare namespace swap {
+  export var indices: typeof swapIndices;
+}
 //#endregion
 //#region src/array/to-map.d.ts
 /**
@@ -3186,9 +3051,6 @@ export declare function toMap<Item, KeyArg extends KeyOrCallback<Item, Key$1>>(a
  * ```
  */
 export declare function toMap<Item>(array: Item[]): Map<number, Item>;
-export declare namespace toMap {
-  var arrays: typeof toMapArrays;
-}
 /**
  * Create a _Map_ from an array of items using a specific key, grouping values into arrays
  *
@@ -3227,6 +3089,9 @@ export declare function toMapArrays<Item, KeyArg extends KeyOrCallback<Item, Key
  * ```
  */
 export declare function toMapArrays<Item, KeyArg extends KeyOrCallback<Item, Key$1>>(array: Item[], key: KeyArg): Map<KeyOrCallbackKey<Item, KeyArg>, Item[]>;
+export declare namespace toMap {
+  export var arrays: typeof toMapArrays;
+}
 //#endregion
 //#region src/array/to-record.d.ts
 /**
@@ -3281,9 +3146,6 @@ export declare function toRecord<Item, KeyArg extends KeyOrCallback<Item, Key$1>
  * ```
  */
 export declare function toRecord<Item>(array: Item[]): Record<number, Item>;
-export declare namespace toRecord {
-  var arrays: typeof toRecordArrays;
-}
 /**
  * Create a record from an array of items using a specific key, grouping values into arrays
  *
@@ -3322,6 +3184,9 @@ export declare function toRecordArrays<Item, KeyArg extends KeyOrCallback<Item,
  * ```
  */
 export declare function toRecordArrays<Item, KeyArg extends KeyOrCallback<Item, Key$1>>(array: Item[], key: KeyArg): Simplify<Record<KeyOrCallbackKey<Item, KeyArg>, Item[]>>;
+export declare namespace toRecord {
+  export var arrays: typeof toRecordArrays;
+}
 //#endregion
 //#region src/internal/function/misc.d.ts
 /**
@@ -3400,9 +3265,6 @@ export declare function asyncThrottle<Callback extends GenericAsyncCallback | Ge
  * @returns Debounced callback handler with a `cancel` method
  */
 export declare function debounce<Callback extends GenericCallback>(callback: Callback, time?: number): Limiter<Callback>;
-export declare namespace debounce {
-  var async: typeof asyncDebounce;
-}
 /**
  * Throttle a function, ensuring it is only called once every `time` milliseconds
  *
@@ -3411,13 +3273,14 @@ export declare namespace debounce {
  * @returns Throttled callback handler with a `cancel` method
  */
 export declare function throttle<Callback extends GenericCallback>(callback: Callback, time?: number): Limiter<Callback>;
+export declare namespace debounce {
+  export var async: typeof asyncDebounce;
+}
 export declare namespace throttle {
-  var async: typeof asyncThrottle;
+  export 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
  *
@@ -3427,9 +3290,6 @@ declare function Once(this: any, callback: GenericCallback): void;
  * @returns _Once_ 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?
  *
@@ -3451,10 +3311,13 @@ export declare function isOnce(value: unknown): boolean;
  * @returns _Once_ callback
  */
 export declare function once<Callback extends GenericCallback>(callback: Callback): Once<Callback>;
+export declare namespace asyncOnce {
+  export var is: typeof isAsyncOnce;
+}
 export declare namespace once {
-  var async: typeof asyncOnce;
-  var is: typeof isOnce;
-  var isAsync: typeof isAsyncOnce;
+  export var async: typeof asyncOnce;
+  export var is: typeof isOnce;
+  export var isAsync: typeof isAsyncOnce;
 }
 //#endregion
 //#region src/function/retry.d.ts
@@ -3471,36 +3334,338 @@ export type RetryOptions = {
   when?: (error: unknown) => boolean;
 };
 /**
- * Retry a callback a specified number of times, with a delay between attempts
- *
- * _Available as `asyncRetry` and `retry.async`_
- *
- * @param callback Callback to retry
- * @param options Retry options
- * @returns Callback result
- */
-declare function asyncRetry<Callback extends GenericAsyncCallback>(callback: Callback, options?: RetryOptions): Promise<Awaited<ReturnType<Callback>>>;
-/**
- * Retry a callback a specified number of times, with a delay between attempts
- *
- * _Available as `asyncRetry` and `retry.async`_
- *
- * @param callback Callback to retry
- * @param options Retry options
- * @returns Callback result
+ * Retry a callback a specified number of times, with a delay between attempts
+ *
+ * _Available as `asyncRetry` and `retry.async`_
+ *
+ * @param callback Callback to retry
+ * @param options Retry options
+ * @returns Callback result
+ */
+declare function asyncRetry<Callback extends GenericAsyncCallback>(callback: Callback, options?: RetryOptions): Promise<Awaited<ReturnType<Callback>>>;
+/**
+ * Retry a callback a specified number of times, with a delay between attempts
+ *
+ * _Available as `asyncRetry` and `retry.async`_
+ *
+ * @param callback Callback to retry
+ * @param options Retry options
+ * @returns Callback result
+ */
+declare function asyncRetry<Callback extends GenericCallback>(callback: Callback, options?: RetryOptions): Promise<ReturnType<Callback>>;
+/**
+ * Retry a callback a specified number of times
+ *
+ * @param callback Callback to retry
+ * @param options Retry options
+ * @returns Callback result
+ */
+export declare function retry<Callback extends GenericCallback>(callback: Callback, options?: Omit<RetryOptions, "delay">): ReturnType<Callback>;
+export declare namespace retry {
+  export var async: typeof asyncRetry;
+}
+//#endregion
+//#region src/internal/array/index-of.d.ts
+/**
+ * Get the index of the first matching item by callback
+ *
+ * @param array Array to search in
+ * @param callback Callback to get an item's value
+ * @param value Value to match against
+ * @returns Index of the first matching item, or `-1` if no match is found
+ *
+ * @example
+ * ```typescript
+ * indexOf(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   item => item.id,
+ *   2,
+ * ); // => 1
+ * ```
+ */
+export declare function indexOf<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): number;
+/**
+ * Get the index of the first matching item by key
+ *
+ * @param array Array to search in
+ * @param key Key to match items by
+ * @param value Value to match against
+ * @returns Index of the first matching item, or `-1` if no match is found
+ *
+ * @example
+ * ```typescript
+ * indexOf(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   'id',
+ *   2,
+ * ); // => 1
+ * ```
+ */
+export declare function indexOf<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): number;
+/**
+ * Get the index of the first item matching the filter
+ *
+ * @param array Array to search in
+ * @param filter Filter callback to match items
+ * @returns Index of the first matching item, or `-1` if no match is found
+ *
+ * @example
+ * ```typescript
+ * indexOf(
+ *   [{id: 1}, {id: 2}, {id: 3}],
+ *   item => item.id === 2,
+ * ); // => 1
+ * ```
+ */
+export declare function indexOf<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): number;
+/**
+ * Get the index of the first item matching the given item
+ *
+ * @param array Array to search in
+ * @param item Item to match against
+ * @returns Index of the first matching item, or `-1` if no match is found
+ *
+ * @example
+ * ```typescript
+ * indexOf([1, 2, 3, 4, 5], 3); // => 2
+ * ```
+ */
+export declare function indexOf<Item>(array: Item[], item: Item): number;
+/**
+ * Get the index of the last matching item by callback
+ *
+ * _Available as `lastIndexOf` and `indexOf.last`_
+ *
+ * @param array Array to search in
+ * @param callback Callback to get an item's value
+ * @param value Value to match against
+ * @returns Index of the last matching item, or `-1` if no match is found
+ *
+ * @example
+ * ```typescript
+ * lastIndexOf(
+ *   [{id: 1}, {id: 2}, {id: 3}, {id: 2}],
+ *   item => item.id,
+ *   2,
+ * ); // => 3
+ * ```
+ */
+export declare function lastIndexOf<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): number;
+/**
+ * Get the index of the last matching item by key
+ *
+ * _Available as `lastIndexOf` and `indexOf.last`_
+ *
+ * @param array Array to search in
+ * @param key Key to match items by
+ * @param value Value to match against
+ * @returns Index of the last matching item, or `-1` if no match is found
+ *
+ * @example
+ * ```typescript
+ * lastIndexOf(
+ *   [{id: 1}, {id: 2}, {id: 3}, {id: 2}],
+ *   'id',
+ *   2,
+ * ); // => 3
+ * ```
+ */
+export declare function lastIndexOf<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): number;
+/**
+ * Get the index of the last item matching the filter
+ *
+ * _Available as `lastIndexOf` and `indexOf.last`_
+ *
+ * @param array Array to search in
+ * @param filter Filter callback to match items
+ * @returns Index of the last matching item, or `-1` if no match is found
+ *
+ * @example
+ * ```typescript
+ * lastIndexOf(
+ *   [{id: 1}, {id: 2}, {id: 3}, {id: 2}],
+ *   item => item.id === 2,
+ * ); // => 3
+ * ```
+ */
+export declare function lastIndexOf<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): number;
+/**
+ * Get the index of the last item matching the given item
+ *
+ * _Available as `lastIndexOf` and `indexOf.last`_
+ *
+ * @param array Array to search in
+ * @param item Item to match against
+ * @returns Index of the last matching item, or `-1` if no match is found
+ *
+ * @example
+ * ```typescript
+ * lastIndexOf([1, 2, 3, 2, 1], 2); // => 3
+ * ```
+ */
+export declare function lastIndexOf<Item>(array: Item[], item: Item): number;
+export declare namespace indexOf {
+  export var last: typeof lastIndexOf;
+}
+//#endregion
+//#region src/internal/function/assert.d.ts
+/**
+ * Asserter for a property of a value
+ */
+export type AssertProperty<Value extends PlainObject, Path extends NestedKeys<Value>, Asserted extends NestedPick<Value, Path> = NestedPick<Value, Path>> = Asserter<Asserted>;
+/**
+ * A function that asserts a value is of a specific type, throwing an error if it is not
+ */
+export type Asserter<Value> = (value: unknown) => asserts value is Value;
+type NestedPick<Value, Path extends string> = Value extends PlainObject ? Path extends `${infer Head}.${infer Rest}` ? Head extends keyof Value ? { [Key in Head]: NestedPick<Value[Key], Rest>; } : never : Path extends keyof Value ? { [Key in Path]: Value[Key]; } : never : never;
+/**
+ * Asserts that a condition is true, throwing an error if it is not
+ *
+ * @param condition Condition to assert
+ * @param message Error message
+ * @param error Error constructor _(defaults to `Error`)_
+ */
+export declare function assert<Condition extends () => boolean>(condition: Condition, message: string, error?: ErrorConstructor): asserts condition;
+/**
+ * Creates an _Asserter_ that asserts a condition is true, throwing an error if it is not
+ *
+ * _Available as `assertCondition` and `assert.condition`_
+ *
+ * @param condition Condition to assert
+ * @param message Error message
+ * @param error Error constructor _(defaults to `Error`)_
+ * @returns _Asserter_
+ */
+export declare function assertCondition<Value>(condition: (value: unknown) => boolean, message: string, error?: ErrorConstructor): Asserter<Value>;
+/**
+ * Asserts that a value is defined, throwing an error if it is not
+ *
+ * _Available as `assertDefined` and `assert.defined`_
+ *
+ * @param value Value to assert
+ * @param message Error message
+ * @param error Error constructor _(defaults to `Error`)_
+ */
+export declare function assertDefined<Value>(value: unknown, message?: string, error?: ErrorConstructor): asserts value is Exclude<Value, null | undefined>;
+/**
+ * Creates an _Asserter_ that asserts a value is an instance of a constructor, throwing an error if it is not
+ *
+ * _Available as `assertInstanceOf` and `assert.instanceOf`_
+ *
+ * @param constructor Constructor to check against
+ * @param message Error message
+ * @param error Error constructor _(defaults to `Error`)_
+ * @returns _Asserter_
+ */
+export declare function assertInstanceOf<Value>(constructor: Constructor<Value>, message: string, error?: ErrorConstructor): Asserter<Value>;
+/**
+ * Creates an _Asserter_ that asserts a value is of a specific type, throwing an error if it is not
+ *
+ * _Available as `assertIs` and `assert.is`_
+ *
+ * @param condition Type guard function to check the value
+ * @param message Error message
+ * @param error Error constructor _(defaults to `Error`)_
+ * @returns _Asserter_
+ */
+export declare function assertIs<Value>(condition: (value: unknown) => value is Value, message: string, error?: ErrorConstructor): Asserter<Value>;
+/**
+ * Creates an _Asserter_ that asserts a property of a value exists and satisfies a condition, throwing an error if it does not
+ *
+ * _Available as `assertProperty` and `assert.property`_
+ *
+ * @param path Path to the property to check, e.g., `foo.bar.baz` for a nested property
+ * @param condition Condition to assert for the property
+ * @param message Error message
+ * @param error Error constructor _(defaults to `Error`)_
+ * @returns _Asserter_
+ */
+export declare function assertProperty<Value extends PlainObject, Path extends NestedKeys<Value>>(path: Path, condition: (value: NestedValue<Value, Path>) => boolean, message: string, error?: ErrorConstructor): Asserter<NestedPick<Value, Path>>;
+export declare namespace assert {
+  export var condition: typeof assertCondition;
+  export var defined: typeof assertDefined;
+  export var instanceOf: typeof assertInstanceOf;
+  export var is: typeof assertIs;
+  export var property: typeof assertProperty;
+}
+//#endregion
+//#region src/internal/function/memoize.d.ts
+/**
+ * A _Memoized_ function instance, caching and retrieving results based on the its parameters _(or a custom cache key)_
+ */
+export type Memoized<Callback extends GenericCallback> = {
+  /**
+   * Maximum cache size
+   *
+   * @returns Maximum cache size _(or `Number.NaN` if the instance has been destroyed)_
+   */
+  get maximum(): number;
+  /**
+   * Current cache size
+   *
+   * @returns Current cache size _(or `Number.NaN` if the instance has been destroyed)_
+   */
+  get size(): number;
+  /**
+   * Clear the cache
+   */
+  clear(): void;
+  /**
+   * Delete a result from the cache
+   *
+   * @param key Key to delete
+   * @returns `true` if the key existed and was removed, otherwise `false`
+   */
+  delete(key: unknown): boolean;
+  /**
+   * Destroy the instance
+   *
+   * _(When a Memoized instance is destroyed, its cache and callback are removed, and calls to `run` will throw an error)_
+   */
+  destroy(): void;
+  /**
+   * Get a result from the cache
+   *
+   * @param key Key to get
+   * @returns Cached result or `undefined` if it does not exist
+   */
+  get(key: unknown): ReturnType<Callback> | undefined;
+  /**
+   * Does the result exist?
+   *
+   * @param key Key to check
+   * @returns `true` if the result exists, otherwise `false`
+   */
+  has(key: unknown): boolean;
+  /**
+   * Run the callback with the provided parameters
+   *
+   * @param parameters Parameters to pass to the callback
+   * @returns Cached or computed _(then cached)_ result
+   */
+  run(...parameters: Parameters<Callback>): ReturnType<Callback>;
+};
+/**
+ * Options for a _Memoized_ function
  */
-declare function asyncRetry<Callback extends GenericCallback>(callback: Callback, options?: RetryOptions): Promise<ReturnType<Callback>>;
+export type MemoizedOptions<Callback extends GenericCallback> = {
+  /**
+   * Callback for getting a cache key for the provided parameters
+   */
+  cacheKey?: (...parameters: Parameters<Callback>) => unknown;
+  /**
+   * Size of the cache
+   */
+  cacheSize?: number;
+};
 /**
- * Retry a callback a specified number of times
+ * Memoize a function, caching and retrieving results based on the first parameter
  *
- * @param callback Callback to retry
- * @param options Retry options
- * @returns Callback result
+ * @param callback Callback to memoize
+ * @param options Memoization options
+ * @returns _Memoized_ instance
  */
-export declare function retry<Callback extends GenericCallback>(callback: Callback, options?: Omit<RetryOptions, 'delay'>): ReturnType<Callback>;
-export declare namespace retry {
-  var async: typeof asyncRetry;
-}
+export declare function memoize<Callback extends GenericCallback>(callback: Callback, options?: MemoizedOptions<Callback>): Memoized<Callback>;
 //#endregion
 //#region src/internal/result/models.d.ts
 /**
@@ -3741,9 +3906,6 @@ export declare function flow<First extends GenericCallback>(first: First, ...fns
  * @returns _Flow_ function
  */
 export declare function flow(...fns: GenericCallback[]): (...args: unknown[]) => unknown;
-export declare namespace flow {
-  var async: typeof asyncFlow;
-}
 /**
  * Pipe a value through a function
  *
@@ -3936,168 +4098,12 @@ export declare function pipe<Value>(value: Value, ...pipes: Array<(value: Value)
  * @returns _Piped_ result
  */
 export declare function pipe(value: unknown, ...pipes: Array<(value: unknown) => unknown>): unknown;
-export declare namespace pipe {
-  var async: typeof asyncPipe;
+export declare namespace flow {
+  export var async: typeof asyncFlow;
 }
-//#endregion
-//#region src/internal/function/assert.d.ts
-/**
- * Asserter for a property of a value
- */
-export type AssertProperty<Value extends PlainObject, Path extends NestedKeys<Value>, Asserted extends NestedPick<Value, Path> = NestedPick<Value, Path>> = Asserter<Asserted>;
-/**
- * A function that asserts a value is of a specific type, throwing an error if it is not
- */
-export type Asserter<Value> = (value: unknown) => asserts value is Value;
-type NestedPick<Value, Path extends string> = Value extends PlainObject ? Path extends `${infer Head}.${infer Rest}` ? Head extends keyof Value ? { [Key in Head]: NestedPick<Value[Key], Rest>; } : never : Path extends keyof Value ? { [Key in Path]: Value[Key]; } : never : never;
-/**
- * Asserts that a condition is true, throwing an error if it is not
- *
- * @param condition Condition to assert
- * @param message Error message
- * @param error Error constructor _(defaults to `Error`)_
- */
-export declare function assert<Condition extends () => boolean>(condition: Condition, message: string, error?: ErrorConstructor): asserts condition;
-export declare namespace assert {
-  var condition: typeof assertCondition;
-  var defined: typeof assertDefined;
-  var instanceOf: typeof assertInstanceOf;
-  var is: typeof assertIs;
-  var property: typeof assertProperty;
+export declare namespace pipe {
+  export var async: typeof asyncPipe;
 }
-/**
- * Creates an _Asserter_ that asserts a condition is true, throwing an error if it is not
- *
- * _Available as `assertCondition` and `assert.condition`_
- *
- * @param condition Condition to assert
- * @param message Error message
- * @param error Error constructor _(defaults to `Error`)_
- * @returns _Asserter_
- */
-export declare function assertCondition<Value>(condition: (value: unknown) => boolean, message: string, error?: ErrorConstructor): Asserter<Value>;
-/**
- * Asserts that a value is defined, throwing an error if it is not
- *
- * _Available as `assertDefined` and `assert.defined`_
- *
- * @param value Value to assert
- * @param message Error message
- * @param error Error constructor _(defaults to `Error`)_
- */
-export declare function assertDefined<Value>(value: unknown, message?: string, error?: ErrorConstructor): asserts value is Exclude<Value, null | undefined>;
-/**
- * Creates an _Asserter_ that asserts a value is an instance of a constructor, throwing an error if it is not
- *
- * _Available as `assertInstanceOf` and `assert.instanceOf`_
- *
- * @param constructor Constructor to check against
- * @param message Error message
- * @param error Error constructor _(defaults to `Error`)_
- * @returns _Asserter_
- */
-export declare function assertInstanceOf<Value>(constructor: Constructor<Value>, message: string, error?: ErrorConstructor): Asserter<Value>;
-/**
- * Creates an _Asserter_ that asserts a value is of a specific type, throwing an error if it is not
- *
- * _Available as `assertIs` and `assert.is`_
- *
- * @param condition Type guard function to check the value
- * @param message Error message
- * @param error Error constructor _(defaults to `Error`)_
- * @returns _Asserter_
- */
-export declare function assertIs<Value>(condition: (value: unknown) => value is Value, message: string, error?: ErrorConstructor): Asserter<Value>;
-/**
- * Creates an _Asserter_ that asserts a property of a value exists and satisfies a condition, throwing an error if it does not
- *
- * _Available as `assertProperty` and `assert.property`_
- *
- * @param path Path to the property to check, e.g., `foo.bar.baz` for a nested property
- * @param condition Condition to assert for the property
- * @param message Error message
- * @param error Error constructor _(defaults to `Error`)_
- * @returns _Asserter_
- */
-export declare function assertProperty<Value extends PlainObject, Path extends NestedKeys<Value>>(path: Path, condition: (value: NestedValue<Value, Path>) => boolean, message: string, error?: ErrorConstructor): Asserter<NestedPick<Value, Path>>;
-//#endregion
-//#region src/internal/function/memoize.d.ts
-/**
- * A _Memoized_ function instance, caching and retrieving results based on the its parameters _(or a custom cache key)_
- */
-export type Memoized<Callback extends GenericCallback> = {
-  /**
-   * Maximum cache size
-   *
-   * @returns Maximum cache size _(or `Number.NaN` if the instance has been destroyed)_
-   */
-  get maximum(): number;
-  /**
-   * Current cache size
-   *
-   * @returns Current cache size _(or `Number.NaN` if the instance has been destroyed)_
-   */
-  get size(): number;
-  /**
-   * Clear the cache
-   */
-  clear(): void;
-  /**
-   * Delete a result from the cache
-   *
-   * @param key Key to delete
-   * @returns `true` if the key existed and was removed, otherwise `false`
-   */
-  delete(key: unknown): boolean;
-  /**
-   * Destroy the instance
-   *
-   * _(When a Memoized instance is destroyed, its cache and callback are removed, and calls to `run` will throw an error)_
-   */
-  destroy(): void;
-  /**
-   * Get a result from the cache
-   *
-   * @param key Key to get
-   * @returns Cached result or `undefined` if it does not exist
-   */
-  get(key: unknown): ReturnType<Callback> | undefined;
-  /**
-   * Does the result exist?
-   *
-   * @param key Key to check
-   * @returns `true` if the result exists, otherwise `false`
-   */
-  has(key: unknown): boolean;
-  /**
-   * Run the callback with the provided parameters
-   *
-   * @param parameters Parameters to pass to the callback
-   * @returns Cached or computed _(then cached)_ result
-   */
-  run(...parameters: Parameters<Callback>): ReturnType<Callback>;
-};
-/**
- * Options for a _Memoized_ function
- */
-export type MemoizedOptions<Callback extends GenericCallback> = {
-  /**
-   * Callback for getting a cache key for the provided parameters
-   */
-  cacheKey?: (...parameters: Parameters<Callback>) => unknown;
-  /**
-   * Size of the cache
-   */
-  cacheSize?: number;
-};
-/**
- * Memoize a function, caching and retrieving results based on the first parameter
- *
- * @param callback Callback to memoize
- * @param options Memoization options
- * @returns _Memoized_ instance
- */
-export declare function memoize<Callback extends GenericCallback>(callback: Callback, options?: MemoizedOptions<Callback>): Memoized<Callback>;
 //#endregion
 //#region src/internal/sized/map.d.ts
 /**
@@ -4140,11 +4146,11 @@ export declare class SizedMap<SizedKey = unknown, SizedValue = unknown> extends
   /**
    * @inheritdoc
    */
-  get(key: SizedKey): SizedValue | undefined;
+  override get(key: SizedKey): SizedValue | undefined;
   /**
    * @inheritdoc
    */
-  set(key: SizedKey, value: SizedValue): this;
+  override set(key: SizedKey, value: SizedValue): this;
 }
 //#endregion
 //#region src/internal/string/case.d.ts
@@ -4246,6 +4252,28 @@ export declare function tryEncode(value: boolean | number | string): unknown;
  */
 export declare function words(value: string): string[];
 //#endregion
+//#region src/internal/value/handlers.d.ts
+type BaseHandler = {
+  handlers: WeakMap<WeakKey, string | GenericCallback>;
+  options: BaseHandlerOptions;
+  owner: GenericCallback;
+  deregister: (constructor: Constructor) => void;
+  get: (first: unknown, second: unknown) => string | GenericCallback | undefined;
+  register: (constructor: Constructor, handler?: string | GenericCallback) => void;
+};
+type BaseHandlerOptions = {
+  callback: GenericCallback;
+  method?: string;
+};
+type CompareHandler<Value> = {
+  base: BaseHandler;
+  handle(first: unknown, second: unknown, ...parameters: unknown[]): Value;
+};
+type ValueHandler = {
+  base: BaseHandler;
+  handle(value: unknown, ...parameters: unknown[]): unknown;
+};
+//#endregion
 //#region src/internal/value/compare.d.ts
 type Comparator<Value = any> = (first: Value, second: Value) => number;
 /**
@@ -4256,24 +4284,6 @@ type Comparator<Value = any> = (first: Value, second: Value) => number;
  * @returns `0` if equal; `-1` first comes before second; `1` first comes after second
  */
 export declare function compare(first: unknown, second: unknown): number;
-export declare namespace compare {
-  var deregister: typeof deregisterComparator;
-  var handler: {
-    base: {
-      handlers: WeakMap<WeakKey, 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;
-  };
-  var register: typeof registerComparator;
-}
 /**
  * Deregister a custom comparison handler for a class
  *
@@ -4291,6 +4301,11 @@ export declare function deregisterComparator<Instance>(constructor: Constructor<
  * @param handler Method name or comparison function _(defaults to `compare`)_
  */
 export declare function registerComparator<Instance>(constructor: Constructor<Instance>, handler?: string | Comparator<Instance>): void;
+export declare namespace compare {
+  export var deregister: typeof deregisterComparator;
+  export var handler: CompareHandler<number>;
+  export var register: typeof registerComparator;
+}
 //#endregion
 //#region src/internal/value/equal.d.ts
 /**
@@ -4347,17 +4362,6 @@ 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
  *
@@ -4384,25 +4388,6 @@ export declare function equal(first: string, second: string, ignoreCase?: boolea
  * @returns `true` if the values are equal, otherwise `false`
  */
 export declare function equal(first: unknown, second: unknown, options?: EqualOptions): boolean;
-export declare namespace equal {
-  var deregister: typeof deregisterEqualizer;
-  var handler: {
-    base: {
-      handlers: WeakMap<WeakKey, 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;
-  };
-  var initialize: typeof initializeEqualizer;
-  var register: typeof registerEqualizer;
-}
 /**
  * Create an equalizer with predefined options
  *
@@ -4421,6 +4406,12 @@ export declare function initializeEqualizer(options?: EqualOptions): Equalizer;
  * @param handler Comparison function
  */
 export declare function registerEqualizer<Instance>(constructor: Constructor<Instance>, handler: (first: Instance, second: Instance) => boolean): void;
+export declare namespace equal {
+  export var deregister: typeof deregisterEqualizer;
+  export var handler: CompareHandler<boolean>;
+  export var initialize: typeof initializeEqualizer;
+  export var register: typeof registerEqualizer;
+}
 //#endregion
 //#region src/internal/value/get.d.ts
 /**
@@ -4499,9 +4490,6 @@ export declare function hasValue<Data extends PlainObject, Path extends NestedKe
  * ```
  */
 export declare function hasValue<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): boolean;
-export declare namespace hasValue {
-  var get: typeof hasValueResult;
-}
 /**
  * Check if a property is defined in an object, and get its value if it is
  *
@@ -4544,6 +4532,9 @@ export declare function hasValueResult<Data extends PlainObject, Path extends Ne
  * ```
  */
 export declare function hasValueResult<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): Result<unknown, string>;
+export declare namespace hasValue {
+  export var get: typeof hasValueResult;
+}
 //#endregion
 //#region src/internal/value/set.d.ts
 /**
@@ -4670,7 +4661,7 @@ export type PromiseParameters = {
  * - `complete`: wait for all _Promises_ to settle, then return the results, as an array of fulfilled and/or rejected results
  * - `first`: rejects on the first rejected _Promise_, and returns an array of values
  */
-export type PromiseStrategy = 'complete' | 'first';
+export type PromiseStrategy = "complete" | "first";
 /**
  * An error thrown when a promise times out
  */
@@ -4759,7 +4750,7 @@ export declare function attemptPromise<Value>(callback: () => Value, options?: P
  * @param options Options for handling the _Promises_
  * @returns List of results
  */
-export declare function promises<Items extends unknown[], Options extends PromisesOptions>(items: [...Items], options?: Options): Promise<Options['strategy'] extends 'first' ? PromisesUnwrapped<Items> : PromisesValues<PromisesItems<Items>>>;
+export declare function promises<Items extends unknown[], Options extends PromisesOptions>(items: [...Items], options?: Options): Promise<Options["strategy"] extends "first" ? PromisesUnwrapped<Items> : PromisesValues<PromisesItems<Items>>>;
 /**
  * Handle keyed _Promises_, returning their results in a similarly keyed object
  *
@@ -4769,7 +4760,7 @@ export declare function promises<Items extends unknown[], Options extends Promis
  * @param options Options for handling the _Promises_
  * @returns Keyed object of results
  */
-export declare function promises<Items extends PlainObject, Options extends PromisesOptions>(items: Items, options?: Options): Promise<Options['strategy'] extends 'first' ? PromisesUnwrapped<Items> : PromisesValues<PromisesItems<Items>>>;
+export declare function promises<Items extends PlainObject, Options extends PromisesOptions>(items: Items, options?: Options): Promise<Options["strategy"] extends "first" ? PromisesUnwrapped<Items> : PromisesValues<PromisesItems<Items>>>;
 /**
  * Handle a list of _Promises_, returning their results in an ordered array
  *
@@ -4779,7 +4770,7 @@ export declare function promises<Items extends PlainObject, Options extends Prom
  * @param strategy Strategy for handling the _Promises_
  * @returns List of results
  */
-export declare function promises<Items extends unknown[], Strategy extends PromiseStrategy>(items: [...Items], strategy: Strategy): Promise<Strategy extends 'first' ? PromisesUnwrapped<Items> : PromisesValues<PromisesItems<Items>>>;
+export declare function promises<Items extends unknown[], Strategy extends PromiseStrategy>(items: [...Items], strategy: Strategy): Promise<Strategy extends "first" ? PromisesUnwrapped<Items> : PromisesValues<PromisesItems<Items>>>;
 /**
  * Handle keyed _Promises_, returning their results in a similarly keyed object
  *
@@ -4789,7 +4780,7 @@ export declare function promises<Items extends unknown[], Strategy extends Promi
  * @param strategy Strategy for handling the _Promises_
  * @returns Keyed object of results
  */
-export declare function promises<Items extends PlainObject, Strategy extends PromiseStrategy>(items: Items, strategy: Strategy): Promise<Strategy extends 'first' ? PromisesUnwrapped<Items> : PromisesValues<PromisesItems<Items>>>;
+export declare function promises<Items extends PlainObject, Strategy extends PromiseStrategy>(items: Items, strategy: Strategy): Promise<Strategy extends "first" ? PromisesUnwrapped<Items> : PromisesValues<PromisesItems<Items>>>;
 /**
  * Handle a list of _Promises_, returning their results in an ordered array
  *
@@ -4806,9 +4797,6 @@ export declare function promises<Items extends unknown[]>(items: [...Items], sig
  * @returns Keyed object of results
  */
 export declare function promises<Items extends PlainObject>(items: Items, signal?: AbortSignal): Promise<PromisesValues<PromisesItems<Items>>>;
-export declare namespace promises {
-  var result: typeof resultPromises;
-}
 /**
  * Handle a list of _Promises_, returning their results in an ordered array of results _({@link Result})_
  *
@@ -4831,6 +4819,9 @@ export declare function resultPromises<Items extends unknown[]>(items: [...Items
  * @returns Keyed object of results
  */
 export declare function resultPromises<Items extends PlainObject>(items: Items, signal?: AbortSignal): Promise<PromisesResult<PromisesItems<Items>>>;
+export declare namespace promises {
+  export var result: typeof resultPromises;
+}
 //#endregion
 //#region src/internal/result/misc.d.ts
 /**
@@ -4848,9 +4839,6 @@ 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?
  *
@@ -4910,9 +4898,6 @@ 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)_
  *
@@ -4929,6 +4914,12 @@ export declare function unwrap<Value, E = Error>(value: Result<Value, E>, defaul
  * @returns Value of the _Result_ _(or the default value)_
  */
 export declare function unwrap(value: unknown, defaultValue: unknown): unknown;
+export declare namespace error {
+  export var is: typeof isError;
+}
+export declare namespace ok {
+  export var is: typeof isOk;
+}
 //#endregion
 //#region src/result/misc.d.ts
 /**
@@ -5000,7 +4991,7 @@ export declare function getTimedPromise<Value>(promise: Promise<Value>, time: nu
  * @param options Timed options
  * @returns Timed _Promise_
  */
-export declare function timed<Value>(promise: Promise<Value>, options: RequiredKeys<PromiseOptions, 'time'>): Promise<Value>;
+export declare function timed<Value>(promise: Promise<Value>, options: RequiredKeys<PromiseOptions, "time">): Promise<Value>;
 /**
  * Create a _Promise_ that should be settled within a certain amount of time
  *
@@ -5065,7 +5056,7 @@ export declare function attempt<Value, E>(callback: () => Value, error: E): Exte
  */
 export declare function attempt<Value>(callback: () => Value): Result<Value, Error>;
 export declare namespace attempt {
-  var async: typeof asyncAttempt;
+  export var async: typeof asyncAttempt;
 }
 //#endregion
 //#region src/result/match.d.ts
@@ -5089,7 +5080,7 @@ export declare function asyncMatchResult<Value, Returned, E = Error>(result: Any
  * @param error Error callback
  * @returns Matched value-_Promise_
  */
-export declare function asyncMatchResult<Value, Returned, E = Error>(result: AnyResult<Value, E> | Promise<AnyResult<Value, E>> | (() => Promise<AnyResult<Value, E>>), ok: ResultMatch<Value, Returned, E>['ok'], error: ResultMatch<Value, Returned, E>['error']): Promise<Returned>;
+export declare function asyncMatchResult<Value, Returned, E = Error>(result: AnyResult<Value, E> | Promise<AnyResult<Value, E>> | (() => Promise<AnyResult<Value, E>>), ok: ResultMatch<Value, Returned, E>["ok"], error: ResultMatch<Value, Returned, E>["error"]): Promise<Returned>;
 /**
  * Handles a _Result_ with match callbacks
  *
@@ -5106,9 +5097,9 @@ export declare function matchResult<Value, Returned, E = Error>(result: AnyResul
  * @param error Error callback
  * @returns Matched value
  */
-export declare function matchResult<Value, Returned, E = Error>(result: AnyResult<Value, E> | (() => AnyResult<Value, E>), ok: ResultMatch<Value, Returned, E>['ok'], error: ResultMatch<Value, Returned, E>['error']): Returned;
+export declare function matchResult<Value, Returned, E = Error>(result: AnyResult<Value, E> | (() => AnyResult<Value, E>), ok: ResultMatch<Value, Returned, E>["ok"], error: ResultMatch<Value, Returned, E>["error"]): Returned;
 export declare namespace matchResult {
-  var async: typeof asyncMatchResult;
+  export var async: typeof asyncMatchResult;
 }
 //#endregion
 //#region src/result/work/flow.d.ts
@@ -5289,7 +5280,7 @@ export declare function attemptFlow<First extends GenericCallback>(first: First,
  */
 export declare function attemptFlow(...fns: GenericCallback[]): (...args: unknown[]) => Result<unknown>;
 export declare namespace attemptFlow {
-  var async: typeof attemptAsyncFlow;
+  export var async: typeof attemptAsyncFlow;
 }
 //#endregion
 //#region src/result/work/pipe.d.ts
@@ -5471,7 +5462,7 @@ export declare function attemptPipe<Initial, First, Second, Third, Fourth, Fifth
  */
 export declare function attemptPipe<Initial>(initial: GenericCallback | Initial | Result<Initial>, first?: (value: UnwrapValue<Initial>) => unknown, ...seconds: Array<(value: unknown) => unknown>): WrapValue<Initial>;
 export declare namespace attemptPipe {
-  var async: typeof attemptAsyncPipe;
+  export var async: typeof attemptAsyncPipe;
 }
 //#endregion
 //#region src/string/fuzzy.d.ts
@@ -5584,10 +5575,6 @@ export declare function fuzzy<Item>(items: Item[], handler?: (item: Item) => str
  * @returns Fuzzy searcher
  */
 export declare function fuzzy<Item>(items: Item[], configuration?: FuzzyConfiguration<Item>): Fuzzy<Item>;
-export declare namespace fuzzy {
-  var is: typeof isFuzzy;
-  var match: typeof fuzzyMatch;
-}
 /**
  * Does the needle match the haystack in a fuzzy way?
  *
@@ -5607,6 +5594,10 @@ export declare function fuzzyMatch(haystack: string, needle: string): boolean;
  * @returns `true` if the value is a fuzzy searcher, otherwise `false`
  */
 export declare function isFuzzy<Item = unknown>(value: unknown): value is Fuzzy<Item>;
+export declare namespace fuzzy {
+  export var is: typeof isFuzzy;
+  export var match: typeof fuzzyMatch;
+}
 //#endregion
 //#region src/string/index.d.ts
 /**
@@ -5756,7 +5747,7 @@ export declare function initializeNormalizer(options?: NormalizeOptions): Normal
  */
 export declare function normalize(value: string, options?: NormalizeOptions): string;
 export declare namespace normalize {
-  var initialize: typeof initializeNormalizer;
+  export var initialize: typeof initializeNormalizer;
 }
 //#endregion
 //#region src/string/template.d.ts
@@ -5801,7 +5792,6 @@ type Templater = {
  * 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
  *
@@ -5827,7 +5817,7 @@ export declare function template(strings: TemplateStringsArray, ...values: unkno
  */
 export declare function template(value: string, variables?: PlainObject, options?: Partial<TemplateOptions>): string;
 export declare namespace template {
-  var initialize: typeof initializeTemplater;
+  export var initialize: typeof initializeTemplater;
 }
 //#endregion
 //#region src/value/clone.d.ts
@@ -5878,25 +5868,6 @@ export type Cloner = {
  * @returns Cloned value
  */
 export declare function clone<Value>(value: Value, options?: CloneOptions): Value;
-export declare namespace clone {
-  var deregister: typeof deregisterCloner;
-  var handlers: {
-    base: {
-      handlers: WeakMap<WeakKey, 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;
-  };
-  var initialize: typeof initializeCloner;
-  var register: typeof registerCloner;
-}
 /**
  * Copy any kind of value
  *
@@ -5933,6 +5904,12 @@ export declare function initializeCloner(options?: CloneOptions): Cloner;
  * @param handler Method name or clone function _(defaults to method name `clone`)_
  */
 export declare function registerCloner<Instance>(constructor: Constructor<Instance>, handler?: string | ((value: Instance) => Instance)): void;
+export declare namespace clone {
+  export var deregister: typeof deregisterCloner;
+  export var handlers: ValueHandler;
+  export var initialize: typeof initializeCloner;
+  export var register: typeof registerCloner;
+}
 //#endregion
 //#region src/value/collection.d.ts
 /**
@@ -5991,7 +5968,7 @@ export type DiffResult<First, Second = First> = {
    */
   values: Record<string, DiffValue>;
 };
-type DiffType = 'full' | 'none' | 'partial';
+type DiffType = "full" | "none" | "partial";
 /**
  * The difference between two values
  */
@@ -6144,10 +6121,6 @@ export declare function freeze<Item>(set: Set<Item>): Frozen<Set<Item>>;
  * @returns Frozen value
  */
 export declare function freeze<Value>(value: Value): Value;
-export declare namespace freeze {
-  var flat: typeof flatFreeze;
-  var is: typeof isFrozen;
-}
 /**
  * Is the value frozen?
  *
@@ -6157,6 +6130,10 @@ export declare namespace freeze {
  * @returns `true` if the value is frozen, otherwise `false`
  */
 export declare function isFrozen(value: unknown): boolean;
+export declare namespace freeze {
+  export var flat: typeof flatFreeze;
+  export var is: typeof isFrozen;
+}
 //#endregion
 //#region src/value/omit.d.ts
 /**
@@ -6225,7 +6202,7 @@ export declare function unsmush<Value extends PlainObject>(value: Value): Unsmus
 /**
  * Options for assigning values
  */
-export type AssignOptions = Omit<MergeOptions, 'assignValues'>;
+export type AssignOptions = Omit<MergeOptions, "assignValues">;
 /**
  * An assigner function for assigning values from one or more objects to the first one
  */
@@ -6293,9 +6270,6 @@ export type Merger = {
  * @returns Assigned value
  */
 export declare function assign<To extends PlainObject, From extends PlainObject[]>(to: To, from: [...From], options?: AssignOptions): To & UnionToIntersection<From[number]>;
-export declare namespace assign {
-  var initialize: typeof initializeAssigner;
-}
 /**
  * Create an assigner with predefined options
  *
@@ -6322,8 +6296,11 @@ export declare function initializeMerger(options?: MergeOptions): Merger;
  * @returns Merged value
  */
 export declare function merge<Values extends ArrayOrPlainObject[]>(values: [...Values], options?: MergeOptions): UnionToIntersection<Values[number]>;
+export declare namespace assign {
+  export var initialize: typeof initializeAssigner;
+}
 export declare namespace merge {
-  var initialize: typeof initializeMerger;
+  export var initialize: typeof initializeMerger;
 }
 //#endregion
 //#region src/value/transform.d.ts
@@ -6382,7 +6359,7 @@ export declare function transform<Value extends PlainObject, Key extends keyof V
  */
 export declare function transform<Value extends PlainObject>(value: Value, transformers: TransformCallbacks<Value>): Value;
 export declare namespace transform {
-  var initialize: typeof initializeTransformer;
+  export var initialize: typeof initializeTransformer;
 }
 //#endregion
 //#region src/internal/subscription.d.ts
@@ -6658,7 +6635,7 @@ type Herald<Events extends Record<string, GenericCallback>> = {
    */
   subscribe<Event extends keyof Events>(event: Event, callback: Events[Event], signal?: AbortSignal): Subscription;
 };
-type HeraldEvents<Events extends Record<string, GenericCallback>> = { [Key in keyof Events]: Key extends '*' ? never : (callback: Events[Key], signal?: AbortSignal) => void; };
+type HeraldEvents<Events extends Record<string, GenericCallback>> = { [Key in keyof Events]: Key extends "*" ? never : (callback: Events[Key], signal?: AbortSignal) => void; };
 type HeraldOnCreate<Events extends Record<string, GenericCallback>> = <Event extends keyof Events>(event: Event, callback: Events[Event], subscription: Subscription) => void;
 type HeraldOptions<Events extends Record<string, GenericCallback>> = {
   names: Array<keyof Events>;
@@ -6877,7 +6854,7 @@ type Color = {
   unsubscribe(): void;
 };
 type ColorChanges = {
-  '*': (value: Color) => void;
+  "*": (value: Color) => void;
   alpha: (value: number) => void;
   hex: (value: string) => void;
   hexa: (value: string) => void;
@@ -6954,11 +6931,11 @@ type RGBColor = {
 /**
  * Base color types
  */
-type ColorType = 'hex' | 'hsl' | 'hwb' | 'rgb';
+type ColorType = "hex" | "hsl" | "hwb" | "rgb";
 /**
  * Extended color types
  */
-type ColorTypeExtended = ColorType | 'hsla' | 'hwba' | 'rgba';
+type ColorTypeExtended = ColorType | "hsla" | "hwba" | "rgba";
 /**
  * Base color values
  */
@@ -7451,6 +7428,13 @@ export declare function isNonPlainObject<Value>(value: Value): value is Exclude<
  * @returns `true` if the value is not a primitive value, otherwise `false`
  */
 export declare function isNonPrimitive<Value>(value: Value): value is Exclude<Value, Primitive>;
+/**
+ * Is the value not a template strings array?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is not a `TemplateStringsArray`, otherwise `false`
+ */
+export declare function isNonTemplateStringsArray<Value>(value: Value): value is Exclude<Value, TemplateStringsArray>;
 /**
  * Is the value not a typed array?
  *
@@ -7479,6 +7463,13 @@ export declare function isPlainObject(value: unknown): value is PlainObject;
  * @returns `true` if the value is a primitive value, otherwise `false`
  */
 export declare function isPrimitive(value: unknown): value is Primitive;
+/**
+ * Is the value a template strings array?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is a `TemplateStringsArray`, otherwise `false`
+ */
+export declare function isTemplateStringsArray(value: unknown): value is TemplateStringsArray;
 /**
  * Is the value a typed array?
  *
@@ -7515,14 +7506,14 @@ export declare function isNonNullable<Value>(value: Value): value is Exclude<Val
  * @param value Value to check
  * @returns `true` if the value is not `undefined`, `null`, or matches an empty string, otherwise `false`
  */
-export declare function isNonNullableOrEmpty<Value>(value: Value): value is Exclude<Value, undefined | null | ''>;
+export declare function isNonNullableOrEmpty<Value>(value: Value): value is Exclude<Value, undefined | null | "">;
 /**
  * Is the value not `undefined`, `null`, or stringified as a whitespace-only string?
  *
  * @param value Value to check
  * @returns `true` if the value is not `undefined`, `null`, or matches a whitespace-only string, otherwise `false`
  */
-export declare function isNonNullableOrWhitespace<Value>(value: Value): value is Exclude<Value, undefined | null | ''>;
+export declare function isNonNullableOrWhitespace<Value>(value: Value): value is Exclude<Value, undefined | null | "">;
 /**
  * Is the value not a number or a number-like string?
  *
@@ -7550,14 +7541,14 @@ export declare function isNullable(value: unknown): value is undefined | null;
  * @param value Value to check
  * @returns `true` if the value is nullable or matches an empty string, otherwise `false`
  */
-export declare function isNullableOrEmpty(value: unknown): value is undefined | null | '';
+export declare function isNullableOrEmpty(value: unknown): value is undefined | null | "";
 /**
  * Is the value `undefined`, `null`, or stringified as a whitespace-only string?
  *
  * @param value Value to check
  * @returns `true` if the value is nullable or matches a whitespace-only string, otherwise `false`
  */
-export declare function isNullableOrWhitespace(value: unknown): value is undefined | null | '';
+export declare function isNullableOrWhitespace(value: unknown): value is undefined | null | "";
 /**
  * Is the value a number or a number-like string?
  *
@@ -8205,7 +8196,7 @@ export declare function queue<Callback extends GenericAsyncCallback>(callback: C
  */
 export declare function queue<Callback extends GenericCallback>(callback: Callback, options?: QueueOptions): Queue<Callback, Parameters<Callback>>;
 export declare namespace queue {
-  var keyed: typeof keyedQueue;
+  export var keyed: typeof keyedQueue;
 }
 //#endregion
 //#region src/internal/random.d.ts
@@ -8315,7 +8306,7 @@ export declare class SizedSet<Value = unknown> extends Set<Value> {
   /**
    * @inheritdoc
    */
-  add(value: Value): this;
+  override add(value: Value): this;
   /**
    * Get a value from the _SizedSet_, if it exists _(and optionally move it to the end)_
    *
@@ -8326,4 +8317,4 @@ export declare class SizedSet<Value = unknown> extends Set<Value> {
   get(value: Value, update?: boolean): Value | undefined;
 }
 //#endregion
-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 };
+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, type RGBAColor, type RGBColor, type Shaken, type Smushed, type Subscription, type SubscriptionParameters, type SubscriptionProperty, type Subscriptions, type SubscriptionsParameters, type TimeLogger, type Unsmushed, push as append, filterAndMap as select, toPromise as fromResult, getRandomFloatingNumber as getRandomFloat, isLogger, isTimeLogger, mapAndFilter as reverseSelect };