@oscarpalmer/atoms 0.179.0 → 0.180.0

package/dist/index.d.mts

@@ -146,68 +146,76 @@ type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint
 //#endregion
 //#region src/array/filter.d.ts
 /**
- * Get a filtered array of items
+ * Get a filtered array of items that do not match the filter
+ *
+ * Available as `exclude` and `filter.remove`
  * @param array Array to search in
  * @param callback Callback to get an item's value for matching
  * @param value Value to match against
- * @returns Filtered array of items
+ * @returns Filtered array of items that do not match the filter
  */
-declare function filter<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item[];
+declare function exclude<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): unknown[];
 /**
- * Get a filtered array of items
+ * Get a filtered array of items that do not match the filter
+ *
+ * Available as `exclude` and `filter.remove`
  * @param array Array to search in
  * @param key Key to get an item's value for matching
  * @param value Value to match against
- * @returns Filtered array of items
+ * @returns Filtered array of items that do not match the filter
  */
-declare function filter<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): Item[];
+declare function exclude<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): unknown[];
 /**
- * Get a filtered array of items matching the filter
+ * Get a filtered array of items that do not match the filter
+ *
+ * Available as `exclude` and `filter.remove`
  * @param array Array to search in
  * @param filter Filter callback to match items
- * @returns Filtered array of items
+ * @returns Filtered array of items that do not match the filter
  */
-declare function filter<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): Item[];
+declare function exclude<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): unknown[];
 /**
- * Get a filtered array of items matching the given item
+ * Get a filtered array of items that do not match the given item
+ *
+ * Available as `exclude` and `filter.remove`
  * @param array Array to search in
  * @param item Item to match against
- * @returns Filtered array of items
+ * @returns Filtered array of items that do not match the given item
  */
-declare function filter<Item>(array: Item[], item: Item): Item[];
-declare namespace filter {
-  var remove: typeof removeFiltered;
-}
+declare function exclude<Item>(array: Item[], item: Item): unknown[];
 /**
- * Get a filtered array of items that do not match the filter
+ * Get a filtered array of items
  * @param array Array to search in
  * @param callback Callback to get an item's value for matching
  * @param value Value to match against
- * @returns Filtered array of items that do not match the filter
+ * @returns Filtered array of items
  */
-declare function removeFiltered<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): unknown[];
+declare function filter<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], callback: Callback, value: ReturnType<Callback>): Item[];
 /**
- * Get a filtered array of items that do not match the filter
+ * Get a filtered array of items
  * @param array Array to search in
  * @param key Key to get an item's value for matching
  * @param value Value to match against
- * @returns Filtered array of items that do not match the filter
+ * @returns Filtered array of items
  */
-declare function removeFiltered<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): unknown[];
+declare function filter<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey, value: Item[ItemKey]): Item[];
 /**
- * Get a filtered array of items that do not match the filter
+ * Get a filtered array of items matching the filter
  * @param array Array to search in
  * @param filter Filter callback to match items
- * @returns Filtered array of items that do not match the filter
+ * @returns Filtered array of items
  */
-declare function removeFiltered<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): unknown[];
+declare function filter<Item>(array: Item[], filter: (item: Item, index: number, array: Item[]) => boolean): Item[];
 /**
- * Get a filtered array of items that do not match the given item
+ * Get a filtered array of items matching the given item
  * @param array Array to search in
  * @param item Item to match against
- * @returns Filtered array of items that do not match the given item
+ * @returns Filtered array of items
  */
-declare function removeFiltered<Item>(array: Item[], item: Item): unknown[];
+declare function filter<Item>(array: Item[], item: Item): Item[];
+declare namespace filter {
+  var remove: typeof exclude;
+}
 //#endregion
 //#region src/array/first.d.ts
 /**
@@ -244,7 +252,9 @@ declare namespace first {
   export { _a as default };
 }
 /**
- * Get the first item matching the given value
+ * Get the first item matching the given value, or a default value if no match is found
+ *
+ * Available as `firstOrDefault` and `first.default`
  * @param array Array to search in
  * @param defaultValue Default value to return if no match is found
  * @param callback Callback to get an item's value for matching
@@ -253,7 +263,9 @@ declare namespace first {
  */
 declare function firstOrDefault<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], defaultValue: Item, callback: Callback, value: ReturnType<Callback>): Item;
 /**
- * Get the first item matching the given value by key
+ * Get the first item matching the given value by key, or a default value if no match is found
+ *
+ * Available as `firstOrDefault` and `first.default`
  * @param array Array to search in
  * @param defaultValue Default value to return if no match is found
  * @param key Key to get an item's value for matching
@@ -262,7 +274,9 @@ declare function firstOrDefault<Item, Callback extends (item: Item, index: numbe
  */
 declare function firstOrDefault<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], defaultValue: Item, key: ItemKey, value: Item[ItemKey]): Item;
 /**
- * Get the first item matching the filter
+ * Get the first item matching the filter, or a default value if no match is found
+ *
+ * Available as `firstOrDefault` and `first.default`
  * @param array Array to search in
  * @param defaultValue Default value to return if no match is found
  * @param filter Filter callback to match items
@@ -270,7 +284,9 @@ declare function firstOrDefault<Item extends PlainObject, ItemKey extends keyof
  */
 declare function firstOrDefault<Item>(array: Item[], defaultValue: Item, filter: (item: Item, index: number, array: Item[]) => boolean): Item;
 /**
- * Get the first item from an array
+ * Get the first item from an array, or a default value if the array is empty
+ *
+ * Available as `firstOrDefault` and `first.default`
  * @param array Array to get from
  * @param defaultValue Default value to return if the array is empty
  * @return First item from the array, or the default value if the array is empty
@@ -347,6 +363,8 @@ declare namespace groupBy {
 }
 /**
  * Create a record from an array of items using a specific key and value, grouping values into arrays
+ *
+ * Available as `groupArraysBy` and `groupBy.arrays`
  * @param array Array to group
  * @param key Callback to get an item's grouping key
  * @param value Callback to get an item's value
@@ -355,6 +373,8 @@ declare namespace groupBy {
 declare function groupArraysBy<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Record<ReturnType<KeyCallback>, ReturnType<ValueCallback>[]>;
 /**
  * Create a record from an array of items using a specific key and value, grouping values into arrays
+ *
+ * Available as `groupArraysBy` and `groupBy.arrays`
  * @param array Array to group
  * @param key Callback to get an item's grouping key
  * @param value Key to use for value
@@ -363,6 +383,8 @@ declare function groupArraysBy<Item, KeyCallback extends (item: Item, index: num
 declare function groupArraysBy<Item extends PlainObject, KeyCallback extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: KeyCallback, value: ItemValue): Record<ReturnType<KeyCallback>, Item[ItemValue][]>;
 /**
  * Create a record from an array of items using a specific key and value, grouping values into arrays
+ *
+ * Available as `groupArraysBy` and `groupBy.arrays`
  * @param array Array to group
  * @param key Key to use for grouping
  * @param value Callback to get an item's value
@@ -371,6 +393,8 @@ declare function groupArraysBy<Item extends PlainObject, KeyCallback extends (it
 declare function groupArraysBy<Item extends PlainObject, ItemKey extends keyof Item, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ValueCallback): Simplify<Record<KeyedValue<Item, ItemKey>, ReturnType<ValueCallback>[]>>;
 /**
  * Create a record from an array of items using a specific key and value, grouping values into arrays
+ *
+ * Available as `groupArraysBy` and `groupBy.arrays`
  * @param array Array to group
  * @param key Key to use for grouping
  * @param value Key to use for value
@@ -379,6 +403,8 @@ declare function groupArraysBy<Item extends PlainObject, ItemKey extends keyof I
 declare function groupArraysBy<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Simplify<Record<KeyedValue<Item, ItemKey>, Item[ItemValue][]>>;
 /**
  * Create a record from an array of items using a specific key, grouping items into arrays
+ *
+ * Available as `groupArraysBy` and `groupBy.arrays`
  * @param array Array to group
  * @param callback Callback to get an item's grouping key
  * @returns Record of keyed items
@@ -386,6 +412,8 @@ declare function groupArraysBy<Item extends PlainObject, ItemKey extends keyof I
 declare function groupArraysBy<Item, Callback extends (item: Item, index: number, array: Item[]) => Key>(array: Item[], callback: Callback): Record<ReturnType<Callback>, Item[]>;
 /**
  * Create a record from an array of items using a specific key, grouping items into arrays
+ *
+ * Available as `groupArraysBy` and `groupBy.arrays`
  * @param array Array to group
  * @param key Key to use for grouping
  * @returns Record of keyed items
@@ -830,6 +858,11 @@ declare function startsWithArray<Item>(haystack: Item[], needle: Item[]): boolea
 declare function push<Item>(array: Item[], pushed: Item[]): number;
 //#endregion
 //#region src/array/reverse.d.ts
+/**
+ * Reverse the order of items in an array
+ * @param array Array to reverse
+ * @returns Reversed array
+ */
 declare function reverse<Item>(array: Item[]): Item[];
 //#endregion
 //#region src/array/select.d.ts
@@ -908,7 +941,7 @@ declare function select<Item extends PlainObject, MapKey extends keyof Item>(arr
  * @param map Callback to map the matched items
  * @returns Filtered and mapped array of items
  */
-declare function select<Item, MapCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], filter: Item, map: MapCallback): Array<ReturnType<MapCallback>>;
+declare function select<Item, MapCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], item: Item, map: MapCallback): Array<ReturnType<MapCallback>>;
 /**
  * Get a filtered and mapped array of items
  * @param array Array to search in
@@ -916,7 +949,7 @@ declare function select<Item, MapCallback extends (item: Item, index: number, ar
  * @param map Key to get an item's value for mapping
  * @returns Filtered and mapped array of items
  */
-declare function select<Item extends PlainObject, MapKey extends keyof Item>(array: Item[], filter: Item, map: MapKey): Array<Item[MapKey]>;
+declare function select<Item extends PlainObject, MapKey extends keyof Item>(array: Item[], item: Item, map: MapKey): Array<Item[MapKey]>;
 //#endregion
 //#region src/array/single.d.ts
 /**
@@ -1221,6 +1254,8 @@ declare namespace last {
 }
 /**
  * Get the last item matching the given value
+ *
+ * Available as `lastOrDefault` and `last.default`
  * @param array Array to search in
  * @param defaultValue Default value to return if no match is found
  * @param callback Callback to get an item's value for matching
@@ -1230,6 +1265,8 @@ declare namespace last {
 declare function lastOrDefault<Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], defaultValue: Item, callback: Callback, value: ReturnType<Callback>): Item;
 /**
  * Get the last item matching the given value by key
+ *
+ * Available as `lastOrDefault` and `last.default`
  * @param array Array to search in
  * @param defaultValue Default value to return if no match is found
  * @param key Key to get an item's value for matching
@@ -1239,6 +1276,8 @@ declare function lastOrDefault<Item, Callback extends (item: Item, index: number
 declare function lastOrDefault<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], defaultValue: Item, key: ItemKey, value: Item[ItemKey]): Item;
 /**
  * Get the last item matching the filter
+ *
+ * Available as `lastOrDefault` and `last.default`
  * @param array Array to search in
  * @param defaultValue Default value to return if no match is found
  * @param filter Filter callback to match items
@@ -1247,6 +1286,8 @@ declare function lastOrDefault<Item extends PlainObject, ItemKey extends keyof I
 declare function lastOrDefault<Item>(array: Item[], defaultValue: Item, filter: (item: Item, index: number, array: Item[]) => boolean): Item;
 /**
  * Get the last item from an array
+ *
+ * Available as `lastOrDefault` and `last.default`
  * @param array Array to get from
  * @param defaultValue Default value to return if the array is empty
  * @return Last item from the array, or the default value if the array is empty
@@ -1300,6 +1341,8 @@ declare namespace move {
  * Move an item from one index to another within an array
  *
  * If the from index is out of bounds, the array will be returned unchanged
+ *
+ * Available as `moveIndices` and `move.indices`
  * @param array Array to move within
  * @param from Index to move from
  * @param to Index to move to
@@ -1310,6 +1353,8 @@ declare function moveIndices<Item>(array: Item[], from: number, to: number): Ite
  * Move an item _(or array of items)_ to an index within an array
  *
  * If the value is not present in the array, or if the index is out of bounds, the array will be returned unchanged
+ *
+ * Available as `moveToIndex` and `move.toIndex`
  * @param array Array to move within
  * @param value Item or items to move
  * @param index Index to move to
@@ -1321,6 +1366,8 @@ declare function moveToIndex<Item extends PlainObject, ItemKey extends keyof Ite
  * Move an item _(or array of items)_ to an index within an array
  *
  * If the value is not present in the array, or if the index is out of bounds, the array will be returned unchanged
+ *
+ * Available as `moveToIndex` and `move.toIndex`
  * @param array Array to move within
  * @param value Item or items to move
  * @param index Index to move to
@@ -1332,6 +1379,8 @@ declare function moveToIndex<Item>(array: Item[], value: Item | Item[], index: n
  * Move an item _(or array of items)_ to an index within an array
  *
  * If the value is not present in the array, or if the index is out of bounds, the array will be returned unchanged
+ *
+ * Available as `moveToIndex` and `move.toIndex`
  * @param array Array to move within
  * @param value Item or items to move
  * @param index Index to move to
@@ -1431,54 +1480,66 @@ type Sorter<Item> = {
  * Get the index for an item _(to be inserted into an array of items)_ based on sorters _(and an optional default direction)_
  *
  * _(If the array is not sorted, it will be treated as sorted, and the result may be inaccurate)_
+ *
+ * Available as `getSortedIndex` and `sort.index`
  * @param array Array to get the index from
  * @param item Item to get the index for
  * @param sorters Sorters to use to determine sorting
  * @param descending Sorted in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns Index for item
  */
-declare function getIndex<Item>(array: Item[], item: Item, sorters: Array<ArraySorter<Item>>, descending?: boolean): number;
+declare function getSortedIndex<Item>(array: Item[], item: Item, sorters: Array<ArraySorter<Item>>, descending?: boolean): number;
 /**
  * Get the index for an item _(to be inserted into an array of items)_ based on a sorter _(and an optional default direction)_
  *
  * _(If the array is not sorted, it will be treated as sorted, and the result may be inaccurate)_
+ *
+ * Available as `getSortedIndex` and `sort.index`
  * @param array Array to get the index from
  * @param item Item to get the index for
  * @param sorter Sorter to use to determine sorting
  * @param descending Sorted in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns Index for item
  */
-declare function getIndex<Item>(array: Item[], item: Item, sorter: ArraySorter<Item>, descending?: boolean): number;
+declare function getSortedIndex<Item>(array: Item[], item: Item, sorter: ArraySorter<Item>, descending?: boolean): number;
 /**
  * Get the index for an item _(to be inserted into an array of items)_ based on an optional default direction_
  *
  * _(If the array is not sorted, it will be treated as sorted, and the result may be inaccurate)_
+ *
+ * Available as `getSortedIndex` and `sort.index`
  * @param array Array to get the index from
  * @param item Item to get the index for
  * @param descending Sorted in descending order? _(defaults to `false`)_
  * @returns Index for item
  */
-declare function getIndex<Item>(array: Item[], item: Item, descending?: boolean): number;
+declare function getSortedIndex<Item>(array: Item[], item: Item, descending?: boolean): number;
 /**
  * Initialize a sort handler with sorters _(and an optional default direction)_
+ *
+ * Available as `initializeSorter` and `sort.initialize`
  * @param sorters Sorters to use for sorting
  * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns Sort handler
  */
-declare function initializeSort<Item>(sorters: Array<ArraySorter<Item>>, descending?: boolean): Sorter<Item>;
+declare function initializeSorter<Item>(sorters: Array<ArraySorter<Item>>, descending?: boolean): Sorter<Item>;
 /**
  * Initialize a sort handler with a sorter _(and an optional default direction)_
+ *
+ * Available as `initializeSorter` and `sort.initialize`
  * @param sorter Sorter to use for sorting
  * @param descending Sort in descending order? _(defaults to `false`; overridden by individual sorters)_
  * @returns Sort handler
  */
-declare function initializeSort<Item>(sorter: ArraySorter<Item>, descending?: boolean): Sorter<Item>;
+declare function initializeSorter<Item>(sorter: ArraySorter<Item>, descending?: boolean): Sorter<Item>;
 /**
  * Initialize a sort handler _(with an optional default direction)_
+ *
+ * Available as `initializeSorter` and `sort.initialize`
  * @param descending Sort in descending order? _(defaults to `false`)_
  * @returns Sort handler
  */
-declare function initializeSort<Item>(descending?: boolean): Sorter<Item>;
+declare function initializeSorter<Item>(descending?: boolean): Sorter<Item>;
 /**
  * Is the array sorted according to the sorters _(and the optional default direction)_?
  * @param array Array to check
@@ -1497,6 +1558,8 @@ declare function isSorted<Item>(array: Item[], sorters: Array<ArraySorter<Item>>
 declare function isSorted<Item>(array: Item[], sorter: ArraySorter<Item>, descending?: boolean): boolean;
 /**
  * Is the array sorted?
+ *
+ * Available as `isSorted` and `sort.is`
  * @param array Array to check
  * @param descending Sorted in descending order? _(defaults to `false`)_
  * @returns `true` if sorted, otherwise `false`
@@ -1526,8 +1589,8 @@ declare function sort<Item>(array: Item[], sorter: ArraySorter<Item>, descending
  */
 declare function sort<Item>(array: Item[], descending?: boolean): Item[];
 declare namespace sort {
-  var index: typeof getIndex;
-  var initialize: typeof initializeSort;
+  var index: typeof getSortedIndex;
+  var initialize: typeof initializeSorter;
   var is: typeof isSorted;
 }
 declare const SORT_DIRECTION_ASCENDING: SortDirection;
@@ -1603,6 +1666,8 @@ declare namespace swap {
  * Swap two indiced items in an array
  *
  * If either index is out of bounds, the array will be returned unchanged
+ *
+ * Available as `swapIndices` and `swap.indices`
  * @param array Array of items to swap
  * @param first First index _(can be negative to count from the end)_
  * @param second Second index _(can be negative to count from the end)_
@@ -1680,6 +1745,8 @@ declare namespace toMap {
 }
 /**
  * Create a Map from an array of items using callbacks, grouping values into arrays
+ *
+ * Available as `toMapArrays` and `toMap.arrays`
  * @param array Array to convert
  * @param key Callback to get an item's grouping key
  * @param value Callback to get an item's value
@@ -1688,6 +1755,8 @@ declare namespace toMap {
 declare function toMapArrays<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Map<ReturnType<KeyCallback>, ReturnType<ValueCallback>[]>;
 /**
  * Create a Map from an array of items using a callback and value, grouping values into arrays
+ *
+ * Available as `toMapArrays` and `toMap.arrays`
  * @param array Array to convert
  * @param key Callback to get an item's grouping key
  * @param value Key to use for value
@@ -1696,6 +1765,8 @@ declare function toMapArrays<Item, KeyCallback extends (item: Item, index: numbe
 declare function toMapArrays<Item extends PlainObject, KeyCallback extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], key: KeyCallback, value: ItemValue): Map<ReturnType<KeyCallback>, Item[ItemValue][]>;
 /**
  * Create a Map from an array of items using a key and callback, grouping values into arrays
+ *
+ * Available as `toMapArrays` and `toMap.arrays`
  * @param array Array to convert
  * @param key Key to use for grouping
  * @param value Callback to get an item's value
@@ -1704,6 +1775,8 @@ declare function toMapArrays<Item extends PlainObject, KeyCallback extends (item
 declare function toMapArrays<Item extends PlainObject, ItemKey extends keyof Item, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, value: ValueCallback): Map<Item[ItemKey], ReturnType<ValueCallback>[]>;
 /**
  * Create a Map from an array of items using a key and value, grouping values into arrays
+ *
+ * Available as `toMapArrays` and `toMap.arrays`
  * @param array Array to convert
  * @param key Key to use for grouping
  * @param value Key to use for value
@@ -1712,6 +1785,8 @@ declare function toMapArrays<Item extends PlainObject, ItemKey extends keyof Ite
 declare function toMapArrays<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Map<Item[ItemKey], Item[ItemValue][]>;
 /**
  * Create a Map from an array of items using a callback, grouping items into arrays
+ *
+ * Available as `toMapArrays` and `toMap.arrays`
  * @param array Array to convert
  * @param callback Callback to get an item's grouping key
  * @returns Map of keyed arrays of items
@@ -1719,6 +1794,8 @@ declare function toMapArrays<Item extends PlainObject, ItemKey extends keyof Ite
 declare function toMapArrays<Item, Callback extends (item: Item, index: number, array: Item[]) => Key>(array: Item[], callback: Callback): Map<ReturnType<Callback>, Item[]>;
 /**
  * Create a Map from an array of items using a key, grouping items into arrays
+ *
+ * Available as `toMapArrays` and `toMap.arrays`
  * @param array Array to convert
  * @param key Key to use for grouping
  * @returns Map of keyed arrays of items
@@ -1795,6 +1872,8 @@ declare namespace toRecord {
 }
 /**
  * Create a record from an array of items using callbacks, grouping values into arrays
+ *
+ * Available as `toRecordArrays` and `toRecord.arrays`
  * @param array Array to convert
  * @param key Callback to get an item's grouping key
  * @param value Callback to get an item's value
@@ -1803,6 +1882,8 @@ declare namespace toRecord {
 declare function toRecordArrays<Item, KeyCallback extends (item: Item, index: number, array: Item[]) => Key, ValueCallback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: KeyCallback, value: ValueCallback): Record<ReturnType<KeyCallback>, ReturnType<ValueCallback>[]>;
 /**
  * Create a record from an array of items using a callback and value, grouping values into arrays
+ *
+ * Available as `toRecordArrays` and `toRecord.arrays`
  * @param array Array to convert
  * @param callback Callback to get an item's grouping key
  * @param value Key to use for value
@@ -1811,6 +1892,8 @@ declare function toRecordArrays<Item, KeyCallback extends (item: Item, index: nu
 declare function toRecordArrays<Item extends PlainObject, Callback extends (item: Item, index: number, array: Item[]) => Key, ItemValue extends keyof Item>(array: Item[], callback: Callback, value: ItemValue): Record<ReturnType<Callback>, Item[ItemValue][]>;
 /**
  * Create a record from an array of items using a key and callback, grouping values into arrays
+ *
+ * Available as `toRecordArrays` and `toRecord.arrays`
  * @param array Array to convert
  * @param key Key to use for grouping
  * @param callback Callback to get an item's value
@@ -1819,6 +1902,8 @@ declare function toRecordArrays<Item extends PlainObject, Callback extends (item
 declare function toRecordArrays<Item extends PlainObject, ItemKey extends keyof Item, Callback extends (item: Item, index: number, array: Item[]) => unknown>(array: Item[], key: ItemKey, callback: Callback): Simplify<Record<KeyedValue<Item, ItemKey>, ReturnType<Callback>[]>>;
 /**
  * Create a record from an array of items using a key and value, grouping values into arrays
+ *
+ * Available as `toRecordArrays` and `toRecord.arrays`
  * @param array Array to convert
  * @param key Key to use for grouping
  * @param value Key to use for value
@@ -1827,6 +1912,8 @@ declare function toRecordArrays<Item extends PlainObject, ItemKey extends keyof
 declare function toRecordArrays<Item extends PlainObject, ItemKey extends keyof Item, ItemValue extends keyof Item>(array: Item[], key: ItemKey, value: ItemValue): Simplify<Record<KeyedValue<Item, ItemKey>, Item[ItemValue][]>>;
 /**
  * Create a record from an array of items using a callback, grouping items into arrays
+ *
+ * Available as `toRecordArrays` and `toRecord.arrays`
  * @param array Array to convert
  * @param callback Callback to get an item's grouping key
  * @returns Record of keyed arrays of items
@@ -1834,6 +1921,8 @@ declare function toRecordArrays<Item extends PlainObject, ItemKey extends keyof
 declare function toRecordArrays<Item, Callback extends (item: Item, index: number, array: Item[]) => Key>(array: Item[], callback: Callback): Record<ReturnType<Callback>, Item[]>;
 /**
  * Create a record from an array of items using a key, grouping items into arrays
+ *
+ * Available as `toRecordArrays` and `toRecord.arrays`
  * @param array Array to convert
  * @param key Key to use for grouping
  * @returns Record of keyed arrays of items
@@ -1857,6 +1946,8 @@ declare namespace assert {
 }
 /**
  * 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
@@ -1865,12 +1956,16 @@ declare namespace assert {
 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
  */
 declare function assertDefined<Value>(value: unknown, message?: string): 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
@@ -1879,6 +1974,8 @@ declare function assertDefined<Value>(value: unknown, message?: string): asserts
 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
@@ -1969,6 +2066,8 @@ declare function memoize<Callback extends GenericCallback>(callback: Callback, o
  * When called, successful _(finished)_ results will resolve and errors will reject.
  *
  * On subsequent calls, existing calls will be canceled _(rejected)_, the timer reset, and will wait another `time` milliseconds before the new call is made _(and so on...)_
+ *
+ * Available as `asyncDebounce` and `debounce.async`
  * @param callback Callback to debounce
  * @param time Time in milliseconds to wait before calling the callback _(defaults to `0`; e.g., as soon as possible)_
  * @returns Debounced callback handler with a `cancel` method
@@ -1980,6 +2079,8 @@ declare function asyncDebounce<Callback extends GenericAsyncCallback | GenericCa
  * When called, successful _(finished)_ results will resolve and errors will reject.
  *
  * On subsequent calls, existing calls will be canceled _(rejected)_ and will wait until the next valid time to call the callback again _(and so on...)_
+ *
+ * Available as `asyncThrottle` and `throttle.async`
  * @param callback Callback to throttle
  * @param time Time in milliseconds to wait before calling the callback again _(defaults to `0`; e.g., as soon as possible)_
  * @returns Throttled callback handler with a `cancel` method
@@ -2011,6 +2112,8 @@ declare namespace throttle {
 //#region src/function/once.d.ts
 /**
  * Create an asynchronous function that can only be called once, rejecting or resolving the same result on subsequent calls
+ *
+ * Available as `asyncOnce` and `once.async`
  * @param callback Callback to use once
  * @returns Once callback
  */
@@ -2037,6 +2140,8 @@ type RetryOptions = {
 };
 /**
  * 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
@@ -2044,6 +2149,8 @@ type RetryOptions = {
 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
@@ -2131,61 +2238,85 @@ type Flow<Callback extends GenericCallback, Value> = (...args: Parameters<Callba
 type FlowPromise<Callback extends GenericCallback, Value> = (...args: Parameters<Callback>) => Promise<UnwrapValue<Value>>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a function
+ *
+ * Available as `asyncFlow` and `flow.async`
  * @returns Flow function
  */
 declare function asyncFlow<Fn extends GenericCallback>(fn: Fn): FlowPromise<Fn, ReturnType<Fn>>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
+ *
+ * Available as `asyncFlow` and `flow.async`
  * @returns Flow function
  */
 declare function asyncFlow<First extends GenericCallback, Second>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second): FlowPromise<First, Second>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
+ *
+ * Available as `asyncFlow` and `flow.async`
  * @returns Flow function
  */
 declare function asyncFlow<First extends GenericCallback, Second, Third>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third): FlowPromise<First, Third>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
+ *
+ * Available as `asyncFlow` and `flow.async`
  * @returns Flow function
  */
 declare function asyncFlow<First extends GenericCallback, Second, Third, Fourth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth): FlowPromise<First, Fourth>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
+ *
+ * Available as `asyncFlow` and `flow.async`
  * @returns Flow function
  */
 declare function asyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth): FlowPromise<First, Fifth>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
+ *
+ * Available as `asyncFlow` and `flow.async`
  * @returns Flow function
  */
 declare function asyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth): FlowPromise<First, Sixth>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
+ *
+ * Available as `asyncFlow` and `flow.async`
  * @returns Flow function
  */
 declare function asyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth, seventh: (value: Awaited<UnwrapValue<Sixth>>) => Seventh): FlowPromise<First, Seventh>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
+ *
+ * Available as `asyncFlow` and `flow.async`
  * @returns Flow function
  */
 declare function asyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth, seventh: (value: Awaited<UnwrapValue<Sixth>>) => Seventh, eighth: (value: Awaited<UnwrapValue<Seventh>>) => Eighth): FlowPromise<First, Eighth>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
+ *
+ * Available as `asyncFlow` and `flow.async`
  * @returns Flow function
  */
 declare function asyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth, seventh: (value: Awaited<UnwrapValue<Sixth>>) => Seventh, eighth: (value: Awaited<UnwrapValue<Seventh>>) => Eighth, ninth: (value: Awaited<UnwrapValue<Eighth>>) => Ninth): FlowPromise<First, Ninth>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
+ *
+ * Available as `asyncFlow` and `flow.async`
  * @returns Flow function
  */
 declare function asyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth, Tenth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth, seventh: (value: Awaited<UnwrapValue<Sixth>>) => Seventh, eighth: (value: Awaited<UnwrapValue<Seventh>>) => Eighth, ninth: (value: Awaited<UnwrapValue<Eighth>>) => Ninth, tenth: (value: Awaited<UnwrapValue<Ninth>>) => Tenth): FlowPromise<First, Tenth>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
+ *
+ * Available as `asyncFlow` and `flow.async`
  * @returns Flow function
  */
 declare function asyncFlow<Fn extends GenericCallback>(fn: Fn, ...fns: Array<(value: Awaited<UnwrapValue<ReturnType<Fn>>>) => unknown>): FlowPromise<Fn, ReturnType<Fn>>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
+ *
+ * Available as `asyncFlow` and `flow.async`
  * @returns Flow function
  */
 declare function asyncFlow(...fns: GenericCallback[]): (...args: unknown[]) => Promise<unknown>;
@@ -2254,72 +2385,96 @@ declare namespace flow {
 }
 /**
  * Pipe a value through a function
+ *
+ * Available as `asyncPipe` and `pipe.async`
  * @param value Initial value
  * @returns Piped result
  */
 declare function asyncPipe<Initial, Piped>(value: Initial, pipe: (value: UnwrapValue<Initial>) => Piped): Promise<UnwrapValue<Piped>>;
 /**
  * Pipe a value through a series of functions
+ *
+ * Available as `asyncPipe` and `pipe.async`
  * @param value Initial value
  * @returns Piped result
  */
 declare function asyncPipe<Initial, First, Second>(value: Initial, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second): Promise<UnwrapValue<Second>>;
 /**
  * Pipe a value through a series of functions
+ *
+ * Available as `asyncPipe` and `pipe.async`
  * @param value Initial value
  * @returns Piped result
  */
 declare function asyncPipe<Initial, First, Second, Third>(value: Initial, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third): Promise<UnwrapValue<Third>>;
 /**
  * Pipe a value through a series of functions
+ *
+ * Available as `asyncPipe` and `pipe.async`
  * @param value Initial value
  * @returns Piped result
  */
 declare function asyncPipe<Initial, First, Second, Third, Fourth>(value: Initial, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth): Promise<UnwrapValue<Fourth>>;
 /**
  * Pipe a value through a series of functions
+ *
+ * Available as `asyncPipe` and `pipe.async`
  * @param value Initial value
  * @returns Piped result
  */
 declare function asyncPipe<Initial, First, Second, Third, Fourth, Fifth>(value: Initial, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth): Promise<UnwrapValue<Fifth>>;
 /**
  * Pipe a value through a series of functions
+ *
+ * Available as `asyncPipe` and `pipe.async`
  * @param value Initial value
  * @returns Piped result
  */
 declare function asyncPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth>(value: Initial, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth): Promise<UnwrapValue<Sixth>>;
 /**
  * Pipe a value through a series of functions
+ *
+ * Available as `asyncPipe` and `pipe.async`
  * @param value Initial value
  * @returns Piped result
  */
 declare function asyncPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth, Seventh>(value: Initial, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh): Promise<UnwrapValue<Seventh>>;
 /**
  * Pipe a value through a series of functions
+ *
+ * Available as `asyncPipe` and `pipe.async`
  * @param value Initial value
  * @returns Piped result
  */
 declare function asyncPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth>(value: Initial, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth): Promise<UnwrapValue<Eighth>>;
 /**
  * Pipe a value through a series of functions
+ *
+ * Available as `asyncPipe` and `pipe.async`
  * @param value Initial value
  * @returns Piped result
  */
 declare function asyncPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth>(value: Initial, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth, ninth: (value: UnwrapValue<Eighth>) => Ninth): Promise<UnwrapValue<Ninth>>;
 /**
  * Pipe a value through a series of functions
+ *
+ * Available as `asyncPipe` and `pipe.async`
  * @param value Initial value
  * @returns Piped result
  */
 declare function asyncPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth, Tenth>(value: Initial, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth, ninth: (value: UnwrapValue<Eighth>) => Ninth, tenth: (value: UnwrapValue<Ninth>) => Tenth): Promise<UnwrapValue<Tenth>>;
 /**
  * Pipe a value through a series of functions
+ *
+ * Available as `asyncPipe` and `pipe.async`
  * @param value Initial value
  * @returns Piped result
  */
 declare function asyncPipe<Value>(value: Value, ...pipes: Array<(value: Value) => Value>): Promise<UnwrapValue<Value>>;
 /**
  * Pipe a value through a series of functions
+ *
+ * Available as `asyncPipe` and `pipe.async`
  * @param value Initial value
  * @returns Piped result
  */
@@ -2434,24 +2589,28 @@ declare function words(value: string): string[];
 declare function compare(first: unknown, second: unknown): number;
 declare namespace compare {
   var handlers: {
-    register: (constructor: Constructor, handler?: string | GenericCallback) => void;
-    unregister: (constructor: Constructor) => void;
+    deregister(constructor: Constructor): void;
     handle(first: unknown, second: unknown, ...parameters: unknown[]): number;
+    register(constructor: Constructor, handler?: string | GenericCallback): void;
   };
+  var deregister: typeof deregisterComparator;
   var register: typeof registerComparator;
-  var unregister: typeof unregisterComparator;
 }
 /**
- * Register a custom comparison handler for a class
+ * Deregister a custom comparison handler for a class
+ *
+ * Available as `deregisterComparator` and `compare.deregister`
  * @param constructor Class constructor
- * @param handler Method name or comparison function _(defaults to `compare`)_
  */
-declare function registerComparator<Instance>(constructor: Constructor<Instance>, handler?: string | ((first: Instance, second: Instance) => number)): void;
+declare function deregisterComparator<Instance>(constructor: Constructor<Instance>): void;
 /**
- * Unregister a custom comparison handler for a class
+ * Register a custom comparison handler for a class
+ *
+ * Available as `registerComparator` and `compare.register`
  * @param constructor Class constructor
+ * @param handler Method name or comparison function _(defaults to `compare`)_
  */
-declare function unregisterComparator<Instance>(constructor: Constructor<Instance>): void;
+declare function registerComparator<Instance>(constructor: Constructor<Instance>, handler?: string | ((first: Instance, second: Instance) => number)): void;
 //#endregion
 //#region src/internal/value/equal.d.ts
 /**
@@ -2472,6 +2631,14 @@ type EqualOptions = {
   relaxedNullish?: boolean;
 };
 type Equalizer = {
+  /**
+   * Are two strings equal?
+   * @param first First string
+   * @param second Second string
+   * @param ignoreCase If `true`, comparison will be case-insensitive
+   * @returns `true` if the strings are equal, otherwise `false`
+   */
+  (first: string, second: string, ignoreCase?: boolean): boolean;
   /**
    * Are two values equal?
    * @param first First value
@@ -2480,17 +2647,24 @@ type Equalizer = {
    */
   (first: unknown, second: unknown): boolean;
   /**
-   * Register a equality comparison function for a specific class
+   * Deregister a equality comparison handler for a specific class
    * @param constructor Class constructor
-   * @param fn Comparison function
    */
-  register: <Instance>(constructor: Constructor<Instance>, handler: (first: Instance, second: Instance) => boolean) => void;
+  deregister: <Instance>(constructor: Constructor<Instance>) => void;
   /**
-   * Unregister a equality comparison handler for a specific class
+   * Register a equality comparison function for a specific class
    * @param constructor Class constructor
+   * @param handler Comparison function
    */
-  unregister: <Instance>(constructor: Constructor<Instance>) => void;
+  register: <Instance>(constructor: Constructor<Instance>, handler: (first: Instance, second: Instance) => boolean) => void;
 };
+/**
+ * Deregister a equality comparison handler for a specific class
+ *
+ * Available as `deregisterEqualizer` and `equal.deregister`
+ * @param constructor Class constructor
+ */
+declare function deregisterEqualizer<Instance>(constructor: Constructor<Instance>): void;
 /**
  * Are two strings equal?
  * @param first First string
@@ -2509,31 +2683,30 @@ declare function equal(first: string, second: string, ignoreCase?: boolean): boo
 declare function equal(first: unknown, second: unknown, options?: EqualOptions): boolean;
 declare namespace equal {
   var handlers: {
-    register: (constructor: Constructor, handler?: string | GenericCallback) => void;
-    unregister: (constructor: Constructor) => void;
+    deregister(constructor: Constructor): void;
     handle(first: unknown, second: unknown, ...parameters: unknown[]): boolean;
+    register(constructor: Constructor, handler?: string | GenericCallback): void;
   };
+  var deregister: typeof deregisterEqualizer;
   var initialize: typeof initializeEqualizer;
   var register: typeof registerEqualizer;
-  var unregister: typeof unregisterEqualizer;
 }
 /**
  * Create an equalizer with predefined options
+ *
+ * Available as `initializeEqualizer` and `equal.initialize`
  * @param options Comparison options
  * @returns Equalizer function
  */
 declare function initializeEqualizer(options?: EqualOptions): Equalizer;
 /**
  * Register a equality comparison function for a specific class
+ *
+ * Available as `registerEqualizer` and `equal.register`
  * @param constructor Class constructor
- * @param fn Comparison function
+ * @param handler Comparison function
  */
 declare function registerEqualizer<Instance>(constructor: Constructor<Instance>, handler: (first: Instance, second: Instance) => boolean): void;
-/**
- * Unregister a equality comparison handler for a specific class
- * @param constructor Class constructor
- */
-declare function unregisterEqualizer<Instance>(constructor: Constructor<Instance>): void;
 //#endregion
 //#region src/internal/value/get.d.ts
 /**
@@ -2553,10 +2726,6 @@ declare function getValue<Data extends PlainObject, Path extends NestedKeys<Data
 declare function getValue<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): unknown;
 //#endregion
 //#region src/internal/value/has.d.ts
-type HasValue<Value> = {
-  exists: boolean;
-  value: Value;
-};
 /**
  * Check if a nested property is defined in an object
  * @param data Object to check in
@@ -2573,24 +2742,28 @@ declare function hasValue<Data extends PlainObject, Path extends NestedKeys<Data
  */
 declare function hasValue<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): boolean;
 declare namespace hasValue {
-  var get: typeof getWithHasValue;
+  var get: typeof hasValueResult;
 }
 /**
  * Check if a nested property is defined in an object, and get its value if it is
+ *
+ * Available as `hasValueResult` and `hasValue.get`
  * @param data Object to check in
  * @param path Path for property
  * @param ignoreCase If `true`, the path matching is case-insensitive
  * @return Result object
  */
-declare function getWithHasValue<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path, ignoreCase?: boolean): HasValue<NestedValue<Data, ToString<Path>>>;
+declare function hasValueResult<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path, ignoreCase?: boolean): Result<NestedValue<Data, ToString<Path>>, undefined>;
 /**
  * Check if a nested property is defined in an object, and get its value if it is
+ *
+ * Available as `hasValueResult` and `hasValue.get`
  * @param data Object to check in
  * @param path Path for property
  * @param ignoreCase If `true`, the path matching is case-insensitive
  * @return Result object
  */
-declare function getWithHasValue<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): HasValue<unknown>;
+declare function hasValueResult<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): Result<unknown, undefined>;
 //#endregion
 //#region src/internal/value/set.d.ts
 /**
@@ -2775,6 +2948,16 @@ declare function fuzzy<Item>(items: Item[], handler?: (item: Item) => string): F
  * @returns Fuzzy searcher
  */
 declare function fuzzy<Item>(items: Item[], configuration?: FuzzyConfiguration<Item>): Fuzzy<Item>;
+declare namespace fuzzy {
+  var match: typeof fuzzyMatch;
+}
+/**
+ * Does the needle match the haystack in a fuzzy way?
+ * @param haystack Haystack to search through
+ * @param needle Needle to search for
+ * @returns `true` if the needle matches the haystack in a fuzzy way, `false` otherwise
+ */
+declare function fuzzyMatch(haystack: string, needle: string): boolean;
 //#endregion
 //#region src/string/index.d.ts
 declare function dedent(strings: TemplateStringsArray, ...values: unknown[]): string;
@@ -2855,6 +3038,8 @@ type TemplateOptions = {
 type Templater = (value: string, variables?: PlainObject) => string;
 /**
  * Create a templater with predefined options
+ *
+ * Available as `initializeTemplater` and `template.initialize`
  * @param options Templating options
  * @returns Templater function
  */
@@ -2880,24 +3065,28 @@ declare namespace template {
 declare function clone<Value>(value: Value): Value;
 declare namespace clone {
   var handlers: {
-    register: (constructor: Constructor, handler?: string | GenericCallback) => void;
-    unregister: (constructor: Constructor) => void;
+    deregister(constructor: Constructor): void;
     handle(value: unknown, ...parameters: unknown[]): any;
+    register(constructor: Constructor, handler?: string | GenericCallback): void;
   };
+  var deregister: typeof deregisterCloner;
   var register: typeof registerCloner;
-  var unregister: typeof unregisterCloner;
 }
 /**
- * Register a clone handler for a specific class
+ * Deregister a clone handler for a specific class
+ *
+ * Available as `deregisterCloner` and `template.deregister`
  * @param constructor Class constructor
- * @param handler Method name or clone function _(defaults to `clone`)_
  */
-declare function registerCloner<Instance>(constructor: Constructor<Instance>, handler?: string | ((value: Instance) => Instance)): void;
+declare function deregisterCloner<Instance>(constructor: Constructor<Instance>): void;
 /**
- * Unregister a clone handler for a specific class
+ * Register a clone handler for a specific class
+ *
+ * Available as `registerCloner` and `template.register`
  * @param constructor Class constructor
+ * @param handler Method name or clone function _(defaults to `clone`)_
  */
-declare function unregisterCloner<Instance>(constructor: Constructor<Instance>): void;
+declare function registerCloner<Instance>(constructor: Constructor<Instance>, handler?: string | ((value: Instance) => Instance)): void;
 //#endregion
 //#region src/value/collection.d.ts
 /**
@@ -3046,6 +3235,14 @@ type MergeOptions = {
  * @returns Merged value
  */
 type Merger<Model extends ArrayOrPlainObject = ArrayOrPlainObject> = (values: NestedPartial<Model>[]) => Model;
+/**
+ * Create a merger with predefined options
+ *
+ * Available as `initializeMerger` and `merge.initialize`
+ * @param options Merging options
+ * @returns Merger function
+ */
+declare function initializeMerger(options?: MergeOptions): Merger;
 /**
  * Merge multiple arrays or objects into a single one
  * @param values Values to merge
@@ -3063,12 +3260,6 @@ declare function merge(values: NestedPartial<ArrayOrPlainObject>[], options?: Me
 declare namespace merge {
   var initialize: typeof initializeMerger;
 }
-/**
- * Create a merger with predefined options
- * @param options Merging options
- * @returns Merger function
- */
-declare function initializeMerger(options?: MergeOptions): Merger;
 //#endregion
 //#region src/beacon.d.ts
 declare class Beacon<Value> {
@@ -3938,6 +4129,8 @@ declare function delay(time?: number): Promise<void>;
 //#region src/promise/index.d.ts
 /**
  * Wrap a promise with safety handlers, with optional abort capabilities and timeout
+ *
+ * Available as `attemptPromise` and `attempt.promise`
  * @param promise Promise to wrap
  * @param options Options for the promise
  * @returns Wrapped promise
@@ -3945,6 +4138,8 @@ declare function delay(time?: number): Promise<void>;
 declare function attemptPromise<Value>(promise: Promise<Value>, options?: PromiseOptions | AbortSignal | number): Promise<Value>;
 /**
  * Wrap a promise-returning callback with safety handlers, with optional abort capabilities and timeout
+ *
+ * Available as `attemptPromise` and `attempt.promise`
  * @param callback Callback to wrap
  * @param options Options for the promise
  * @returns Promise-wrapped callback
@@ -3952,6 +4147,8 @@ declare function attemptPromise<Value>(promise: Promise<Value>, options?: Promis
 declare function attemptPromise<Value>(callback: () => Promise<Value>, options?: PromiseOptions | AbortSignal | number): Promise<Value>;
 /**
  * Wrap a callback with a promise and safety handlers, with optional abort capabilities and timeout
+ *
+ * Available as `attemptPromise` and `attempt.promise`
  * @param callback Callback to wrap
  * @param options Options for the promise
  * @returns Promise-wrapped callback
@@ -4014,6 +4211,8 @@ declare namespace promises {
  * Handle a list of promises, returning their results in an ordered array of results _({@link Result})_.
  *
  * Depending on the strategy, the function will either reject on the first error encountered or return an array of rejected and resolved results
+ *
+ * Available as `resultPromises` and `promises.result`
  * @param items List of promises
  * @param signal AbortSignal for aborting the operation _(when aborted, the promise will reject with the reason of the signal)_
  * @returns List of results
@@ -4023,6 +4222,8 @@ declare function resultPromises<Items extends unknown[]>(items: [...Items], sign
  * Handle a list of promises, returning their results in an ordered array of results _({@link Result})_.
  *
  * Depending on the strategy, the function will either reject on the first error encountered or return an array of rejected and resolved results
+ *
+ * Available as `resultPromises` and `promises.result`
  * @param items List of promises
  * @param signal AbortSignal for aborting the operation _(when aborted, the promise will reject with the reason of the signal)_
  * @returns List of results
@@ -4070,14 +4271,14 @@ declare function isResult(value: unknown): value is ExtendedErr<unknown> | Resul
 //#region src/result/misc.d.ts
 /**
  * Creates an extended error result
- * @param error Error value
+ * @param value Error value
  * @param original Original error
  * @returns Error result
  */
 declare function error<E>(value: E, original: Error): ExtendedErr<E>;
 /**
  * Creates an error result
- * @param error Error value
+ * @param value Error value
  * @returns Error result
  */
 declare function error<E>(value: E): Err<E>;
@@ -4092,7 +4293,7 @@ declare function ok<Value>(value: Value): Ok<Value>;
  * Converts a result to a promise
  *
  * Resolves if ok, rejects for error
- * @param result Result to convert
+ * @param callback Callback to get the result
  * @returns Promised result
  */
 declare function toPromise<Value, E = Error>(callback: () => AnyResult<Value, E>): Promise<Value>;
@@ -4378,12 +4579,16 @@ declare function asyncMatchResult<Value, Returned, E = Error>(result: AnyResult<
 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
+ *
+ * Available as `matchResult` and `attempt.match`
  * @param result Result to handle
  * @param handler Match callbacks
  */
 declare function matchResult<Value, Returned, E = Error>(result: AnyResult<Value, E> | (() => AnyResult<Value, E>), handler: ResultMatch<Value, Returned, E>): Returned;
 /**
  * Handles a result with match callbacks
+ *
+ * Available as `matchResult` and `attempt.match`
  * @param result Result to handle
  * @param ok Ok callback
  * @param error Error callback
@@ -4404,121 +4609,169 @@ type AttemptFlow<Callback extends GenericCallback, Value> = (...args: Parameters
 type AttemptFlowPromise<Callback extends GenericCallback, Value> = (...args: Parameters<Callback>) => Promise<Result<UnwrapValue<Value>>>;
 /**
  * Create an asynchronous Flow, a function that attempts to pipe a value through a series of functions
+ *
+ * Available as `attemptAsyncFlow` and `attempt.flow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<Fn extends GenericCallback>(fn: Fn): AttemptFlowPromise<Fn, ReturnType<Fn>>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
+ *
+ * Available as `attemptAsyncFlow` and `attempt.flow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<First extends GenericCallback, Second>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second): AttemptFlowPromise<First, Second>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
+ *
+ * Available as `attemptAsyncFlow` and `attempt.flow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<First extends GenericCallback, Second, Third>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third): AttemptFlowPromise<First, Third>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
+ *
+ * Available as `attemptAsyncFlow` and `attempt.flow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth): AttemptFlowPromise<First, Fourth>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
+ *
+ * Available as `attemptAsyncFlow` and `attempt.flow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth): AttemptFlowPromise<First, Fifth>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
+ *
+ * Available as `attemptAsyncFlow` and `attempt.flow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth): AttemptFlowPromise<First, Sixth>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
+ *
+ * Available as `attemptAsyncFlow` and `attempt.flow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth, seventh: (value: Awaited<UnwrapValue<Sixth>>) => Seventh): AttemptFlowPromise<First, Seventh>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
+ *
+ * Available as `attemptAsyncFlow` and `attempt.flow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth, seventh: (value: Awaited<UnwrapValue<Sixth>>) => Seventh, eighth: (value: Awaited<UnwrapValue<Seventh>>) => Eighth): AttemptFlowPromise<First, Eighth>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
+ *
+ * Available as `attemptAsyncFlow` and `attempt.flow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth, seventh: (value: Awaited<UnwrapValue<Sixth>>) => Seventh, eighth: (value: Awaited<UnwrapValue<Seventh>>) => Eighth, ninth: (value: Awaited<UnwrapValue<Eighth>>) => Ninth): AttemptFlowPromise<First, Ninth>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
+ *
+ * Available as `attemptAsyncFlow` and `attempt.flow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth, Tenth>(first: First, second: (value: Awaited<UnwrapValue<ReturnType<First>>>) => Second, third: (value: Awaited<UnwrapValue<Second>>) => Third, fourth: (value: Awaited<UnwrapValue<Third>>) => Fourth, fifth: (value: Awaited<UnwrapValue<Fourth>>) => Fifth, sixth: (value: Awaited<UnwrapValue<Fifth>>) => Sixth, seventh: (value: Awaited<UnwrapValue<Sixth>>) => Seventh, eighth: (value: Awaited<UnwrapValue<Seventh>>) => Eighth, ninth: (value: Awaited<UnwrapValue<Eighth>>) => Ninth, tenth: (value: Awaited<UnwrapValue<Ninth>>) => Tenth): AttemptFlowPromise<First, Tenth>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
+ *
+ * Available as `attemptAsyncFlow` and `attempt.flow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow<Fn extends GenericCallback>(fn: Fn, ...fns: Array<(value: Awaited<UnwrapValue<ReturnType<Fn>>>) => unknown>): AttemptFlowPromise<Fn, ReturnType<Fn>>;
 /**
  * Create an asynchronous Flow, a function that pipes values through a series of functions
+ *
+ * Available as `attemptAsyncFlow` and `attempt.flow.async`
  * @returns Flow function
  */
 declare function attemptAsyncFlow(...fns: GenericCallback[]): (...args: unknown[]) => Promise<Result<unknown>>;
 /**
  * Create a Flow, a function that attempts to pipe values through a function
+ *
+ * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<Fn extends GenericCallback>(fn: Fn): AttemptFlow<Fn, ReturnType<Fn>>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
+ *
+ * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<First extends GenericCallback, Second>(first: First, second: (value: UnwrapValue<ReturnType<First>>) => Second): AttemptFlow<First, Second>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
+ *
+ * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<First extends GenericCallback, Second, Third>(first: First, second: (value: UnwrapValue<ReturnType<First>>) => Second, third: (value: UnwrapValue<Second>) => Third): AttemptFlow<First, Third>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
+ *
+ * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<First extends GenericCallback, Second, Third, Fourth>(first: First, second: (value: UnwrapValue<ReturnType<First>>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth): AttemptFlow<First, Fourth>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
+ *
+ * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<First extends GenericCallback, Second, Third, Fourth, Fifth>(first: First, second: (value: UnwrapValue<ReturnType<First>>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth): AttemptFlow<First, Fifth>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
+ *
+ * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth>(first: First, second: (value: UnwrapValue<ReturnType<First>>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth): AttemptFlow<First, Sixth>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
+ *
+ * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh>(first: First, second: (value: UnwrapValue<ReturnType<First>>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh): AttemptFlow<First, Seventh>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
+ *
+ * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth>(first: First, second: (value: UnwrapValue<ReturnType<First>>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth): AttemptFlow<First, Eighth>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
+ *
+ * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth>(first: First, second: (value: UnwrapValue<ReturnType<First>>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth, ninth: (value: UnwrapValue<Eighth>) => Ninth): AttemptFlow<First, Ninth>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
+ *
+ * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<First extends GenericCallback, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth, Tenth>(first: First, second: (value: UnwrapValue<ReturnType<First>>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth, ninth: (value: UnwrapValue<Eighth>) => Ninth, tenth: (value: UnwrapValue<Ninth>) => Tenth): AttemptFlow<First, Tenth>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
+ *
+ * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow<First extends GenericCallback>(first: First, ...fns: Array<(value: UnwrapValue<ReturnType<First>>) => unknown>): AttemptFlow<First, ReturnType<First>>;
 /**
  * Create a Flow, a function that attempts to pipe values through a series of functions
+ *
+ * Available as `attemptFlow` and `attempt.flow`
  * @returns Flow function
  */
 declare function attemptFlow(...fns: GenericCallback[]): (...args: unknown[]) => Result<unknown>;
@@ -4528,270 +4781,182 @@ declare namespace attemptFlow {
 //#endregion
 //#region src/result/work/pipe.d.ts
 type WrapValue<Value> = Result<UnwrapValue<Value>>;
-/**
- * Attempt to pipe a result through a function
- * @param initial Initial result
- * @returns Piped result
- */
-declare function attemptAsyncPipe<Initial, Piped>(initial: Result<Initial>, pipe: (value: UnwrapValue<Initial>) => Piped): Promise<WrapValue<Piped>>;
-/**
- * Attempt to pipe a result through a series of functions
- * @param initial Initial result
- * @returns Piped result
- */
-declare function attemptAsyncPipe<Initial, First, Second>(initial: Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second): Promise<WrapValue<Second>>;
-/**
- * Attempt to pipe a result through a series of functions
- * @param initial Initial result
- * @returns Piped result
- */
-declare function attemptAsyncPipe<Initial, First, Second, Third>(initial: Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third): Promise<WrapValue<Third>>;
-/**
- * Attempt to pipe a result through a series of functions
- * @param initial Initial result
- * @returns Piped result
- */
-declare function attemptAsyncPipe<Initial, First, Second, Third, Fourth>(initial: Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth): Promise<WrapValue<Fourth>>;
-/**
- * Attempt to pipe a result through a series of functions
- * @param initial Initial result
- * @returns Piped result
- */
-declare function attemptAsyncPipe<Initial, First, Second, Third, Fourth, Fifth>(initial: Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth): Promise<WrapValue<Fifth>>;
-/**
- * Attempt to pipe a result through a series of functions
- * @param initial Initial result
- * @returns Piped result
- */
-declare function attemptAsyncPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth>(initial: Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth): Promise<WrapValue<Sixth>>;
-/**
- * Attempt to pipe a result through a series of functions
- * @param initial Initial result
- * @returns Piped result
- */
-declare function attemptAsyncPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth, Seventh>(initial: Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh): Promise<WrapValue<Seventh>>;
-/**
- * Attempt to pipe a result through a series of functions
- * @param initial Initial result
- * @returns Piped result
- */
-declare function attemptAsyncPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth>(initial: Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth): Promise<WrapValue<Eighth>>;
-/**
- * Attempt to pipe a result through a series of functions
- * @param initial Initial result
- * @returns Piped result
- */
-declare function attemptAsyncPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth>(initial: Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth, ninth: (value: UnwrapValue<Eighth>) => Ninth): Promise<WrapValue<Ninth>>;
-/**
- * Attempt to pipe a result through a series of functions
- * @param initial Initial result
- * @returns Piped result
- */
-declare function attemptAsyncPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth, Tenth>(initial: Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth, ninth: (value: UnwrapValue<Eighth>) => Ninth, tenth: (value: UnwrapValue<Ninth>) => Tenth): Promise<WrapValue<Tenth>>;
 /**
  * Attempt to pipe a value through a function
+ *
+ * Available as `attemptAsyncPipe` and `attempt.pipe.async`
  * @param initial Initial value
  * @returns Piped result
  */
-declare function attemptAsyncPipe<Initial, Piped>(initial: GenericCallback | Initial, pipe: (value: UnwrapValue<Initial>) => Piped): Promise<WrapValue<Piped>>;
+declare function attemptAsyncPipe<Initial, Piped>(initial: GenericCallback | Initial | Promise<Initial> | Result<Initial>, pipe: (value: UnwrapValue<Initial>) => Piped): Promise<WrapValue<Piped>>;
 /**
  * Attempt to pipe a value through a series of functions
+ *
+ * Available as `attemptAsyncPipe` and `attempt.pipe.async`
  * @param initial Initial value
  * @returns Piped result
  */
-declare function attemptAsyncPipe<Initial, First, Second>(initial: GenericCallback | Initial, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second): Promise<WrapValue<Second>>;
+declare function attemptAsyncPipe<Initial, First, Second>(initial: GenericCallback | Initial | Promise<Initial> | Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second): Promise<WrapValue<Second>>;
 /**
  * Attempt to pipe a value through a series of functions
+ *
+ * Available as `attemptAsyncPipe` and `attempt.pipe.async`
  * @param initial Initial value
  * @returns Piped result
  */
-declare function attemptAsyncPipe<Initial, First, Second, Third>(initial: GenericCallback | Initial, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third): Promise<WrapValue<Third>>;
+declare function attemptAsyncPipe<Initial, First, Second, Third>(initial: GenericCallback | Initial | Promise<Initial> | Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third): Promise<WrapValue<Third>>;
 /**
  * Attempt to pipe a value through a series of functions
+ *
+ * Available as `attemptAsyncPipe` and `attempt.pipe.async`
  * @param initial Initial value
  * @returns Piped result
  */
-declare function attemptAsyncPipe<Initial, First, Second, Third, Fourth>(initial: GenericCallback | Initial, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth): Promise<WrapValue<Fourth>>;
+declare function attemptAsyncPipe<Initial, First, Second, Third, Fourth>(initial: GenericCallback | Initial | Promise<Initial> | Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth): Promise<WrapValue<Fourth>>;
 /**
  * Attempt to pipe a value through a series of functions
+ *
+ * Available as `attemptAsyncPipe` and `attempt.pipe.async`
  * @param initial Initial value
  * @returns Piped result
  */
-declare function attemptAsyncPipe<Initial, First, Second, Third, Fourth, Fifth>(initial: GenericCallback | Initial, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth): Promise<WrapValue<Fifth>>;
+declare function attemptAsyncPipe<Initial, First, Second, Third, Fourth, Fifth>(initial: GenericCallback | Initial | Promise<Initial> | Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth): Promise<WrapValue<Fifth>>;
 /**
  * Attempt to pipe a value through a series of functions
+ *
+ * Available as `attemptAsyncPipe` and `attempt.pipe.async`
  * @param initial Initial value
  * @returns Piped result
  */
-declare function attemptAsyncPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth>(initial: GenericCallback | Initial, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth): Promise<WrapValue<Sixth>>;
+declare function attemptAsyncPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth>(initial: GenericCallback | Initial | Promise<Initial> | Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth): Promise<WrapValue<Sixth>>;
 /**
  * Attempt to pipe a value through a series of functions
+ *
+ * Available as `attemptAsyncPipe` and `attempt.pipe.async`
  * @param initial Initial value
  * @returns Piped result
  */
-declare function attemptAsyncPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth, Seventh>(initial: GenericCallback | Initial, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh): Promise<WrapValue<Seventh>>;
+declare function attemptAsyncPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth, Seventh>(initial: GenericCallback | Initial | Promise<Initial> | Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh): Promise<WrapValue<Seventh>>;
 /**
  * Attempt to pipe a value through a series of functions
+ *
+ * Available as `attemptAsyncPipe` and `attempt.pipe.async`
  * @param initial Initial value
  * @returns Piped result
  */
-declare function attemptAsyncPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth>(initial: GenericCallback | Initial, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth): Promise<WrapValue<Eighth>>;
+declare function attemptAsyncPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth>(initial: GenericCallback | Initial | Promise<Initial> | Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth): Promise<WrapValue<Eighth>>;
 /**
  * Attempt to pipe a value through a series of functions
+ *
+ * Available as `attemptAsyncPipe` and `attempt.pipe.async`
  * @param initial Initial value
  * @returns Piped result
  */
-declare function attemptAsyncPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth>(initial: GenericCallback | Initial, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth, ninth: (value: UnwrapValue<Eighth>) => Ninth): Promise<WrapValue<Ninth>>;
+declare function attemptAsyncPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth>(initial: GenericCallback | Initial | Promise<Initial> | Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth, ninth: (value: UnwrapValue<Eighth>) => Ninth): Promise<WrapValue<Ninth>>;
 /**
  * Attempt to pipe a value through a series of functions
+ *
+ * Available as `attemptAsyncPipe` and `attempt.pipe.async`
  * @param initial Initial value
  * @returns Piped result
  */
-declare function attemptAsyncPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth, Tenth>(initial: GenericCallback | Initial, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth, ninth: (value: UnwrapValue<Eighth>) => Ninth, tenth: (value: UnwrapValue<Ninth>) => Tenth): Promise<WrapValue<Tenth>>;
-/**
- * Attempt to pipe a result through a series of functions
- * @param initial Initial result
- * @returns Piped result
- */
-declare function attemptAsyncPipe<Initial>(initial: Result<Initial>, first?: (value: UnwrapValue<Initial>) => unknown, ...seconds: Array<(value: unknown) => unknown>): Promise<WrapValue<Initial>>;
-/**
- * Attempt to pipe an item through a series of functions
- * @param item Initial value
- * @returns Piped result
- */
-declare function attemptAsyncPipe<Initial>(initial: GenericCallback | Initial, first?: (value: UnwrapValue<Initial>) => unknown, ...seconds: Array<(value: unknown) => unknown>): Promise<WrapValue<Initial>>;
-/**
- * Attempt to pipe a result through a function
- * @param initial Initial result
- * @returns Piped result
- */
-declare function attemptPipe<Initial, Piped>(initial: Result<Initial>, pipe: (value: UnwrapValue<Initial>) => Piped): WrapValue<Piped>;
-/**
- * Attempt to pipe a result through a series of functions
- * @param initial Initial result
- * @returns Piped result
- */
-declare function attemptPipe<Initial, First, Second>(initial: Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second): WrapValue<Second>;
-/**
- * Attempt to pipe a result through a series of functions
- * @param initial Initial result
- * @returns Piped result
- */
-declare function attemptPipe<Initial, First, Second, Third>(initial: Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third): WrapValue<Third>;
-/**
- * Attempt to pipe a result through a series of functions
- * @param initial Initial result
- * @returns Piped result
- */
-declare function attemptPipe<Initial, First, Second, Third, Fourth>(initial: Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth): WrapValue<Fourth>;
-/**
- * Attempt to pipe a result through a series of functions
- * @param initial Initial result
- * @returns Piped result
- */
-declare function attemptPipe<Initial, First, Second, Third, Fourth, Fifth>(initial: Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth): WrapValue<Fifth>;
-/**
- * Attempt to pipe a result through a series of functions
- * @param initial Initial result
- * @returns Piped result
- */
-declare function attemptPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth>(initial: Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth): WrapValue<Sixth>;
-/**
- * Attempt to pipe a result through a series of functions
- * @param initial Initial result
- * @returns Piped result
- */
-declare function attemptPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth, Seventh>(initial: Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh): WrapValue<Seventh>;
-/**
- * Attempt to pipe a result through a series of functions
- * @param initial Initial result
- * @returns Piped result
- */
-declare function attemptPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth>(initial: Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth): WrapValue<Eighth>;
-/**
- * Attempt to pipe a result through a series of functions
- * @param initial Initial result
- * @returns Piped result
- */
-declare function attemptPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth>(initial: Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth, ninth: (value: UnwrapValue<Eighth>) => Ninth): WrapValue<Ninth>;
+declare function attemptAsyncPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth, Tenth>(initial: GenericCallback | Initial | Promise<Initial> | Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth, ninth: (value: UnwrapValue<Eighth>) => Ninth, tenth: (value: UnwrapValue<Ninth>) => Tenth): Promise<WrapValue<Tenth>>;
 /**
  * Attempt to pipe a result through a series of functions
+ *
+ * Available as `attemptAsyncPipe` and `attempt.pipe.async`
  * @param initial Initial result
  * @returns Piped result
  */
-declare function attemptPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth, Tenth>(initial: Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth, ninth: (value: UnwrapValue<Eighth>) => Ninth, tenth: (value: UnwrapValue<Ninth>) => Tenth): WrapValue<Tenth>;
+declare function attemptAsyncPipe<Initial>(initial: GenericCallback | Initial | Promise<Initial> | Result<Initial>, first?: (value: UnwrapValue<Initial>) => unknown, ...seconds: Array<(value: unknown) => unknown>): Promise<WrapValue<Initial>>;
 /**
  * Attempt to pipe a value through a function
+ *
+ * Available as `attemptPipe` and `attempt.pipe`
  * @param initial Initial value
  * @returns Piped result
  */
-declare function attemptPipe<Initial, Pipe>(initial: GenericCallback | Initial, pipe: (value: UnwrapValue<Initial>) => Pipe): WrapValue<Pipe>;
+declare function attemptPipe<Initial, Pipe>(initial: GenericCallback | Initial | Result<Initial>, pipe: (value: UnwrapValue<Initial>) => Pipe): WrapValue<Pipe>;
 /**
  * Attempt to pipe a value through a series of functions
+ *
+ * Available as `attemptPipe` and `attempt.pipe`
  * @param initial Initial value
  * @returns Piped result
  */
-declare function attemptPipe<Initial, First, Second>(initial: GenericCallback | Initial, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second): WrapValue<Second>;
+declare function attemptPipe<Initial, First, Second>(initial: GenericCallback | Initial | Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second): WrapValue<Second>;
 /**
  * Attempt to pipe a value through a series of functions
+ *
+ * Available as `attemptPipe` and `attempt.pipe`
  * @param initial Initial value
  * @returns Piped result
  */
-declare function attemptPipe<Initial, First, Second, Third>(initial: GenericCallback | Initial, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third): WrapValue<Third>;
+declare function attemptPipe<Initial, First, Second, Third>(initial: GenericCallback | Initial | Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third): WrapValue<Third>;
 /**
  * Attempt to pipe a value through a series of functions
+ *
+ * Available as `attemptPipe` and `attempt.pipe`
  * @param initial Initial value
  * @returns Piped result
  */
-declare function attemptPipe<Initial, First, Second, Third, Fourth>(initial: GenericCallback | Initial, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth): WrapValue<Fourth>;
+declare function attemptPipe<Initial, First, Second, Third, Fourth>(initial: GenericCallback | Initial | Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth): WrapValue<Fourth>;
 /**
  * Attempt to pipe a value through a series of functions
+ *
+ * Available as `attemptPipe` and `attempt.pipe`
  * @param initial Initial value
  * @returns Piped result
  */
-declare function attemptPipe<Initial, First, Second, Third, Fourth, Fifth>(initial: GenericCallback | Initial, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth): WrapValue<Fifth>;
+declare function attemptPipe<Initial, First, Second, Third, Fourth, Fifth>(initial: GenericCallback | Initial | Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth): WrapValue<Fifth>;
 /**
  * Attempt to pipe a value through a series of functions
+ *
+ * Available as `attemptPipe` and `attempt.pipe`
  * @param initial Initial value
  * @returns Piped result
  */
-declare function attemptPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth>(initial: GenericCallback | Initial, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth): WrapValue<Sixth>;
+declare function attemptPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth>(initial: GenericCallback | Initial | Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth): WrapValue<Sixth>;
 /**
  * Attempt to pipe a value through a series of functions
+ *
+ * Available as `attemptPipe` and `attempt.pipe`
  * @param initial Initial value
  * @returns Piped result
  */
-declare function attemptPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth, Seventh>(initial: GenericCallback | Initial, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh): WrapValue<Seventh>;
+declare function attemptPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth, Seventh>(initial: GenericCallback | Initial | Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh): WrapValue<Seventh>;
 /**
  * Attempt to pipe a value through a series of functions
+ *
+ * Available as `attemptPipe` and `attempt.pipe`
  * @param initial Initial value
  * @returns Piped result
  */
-declare function attemptPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth>(initial: GenericCallback | Initial, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth): WrapValue<Eighth>;
+declare function attemptPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth>(initial: GenericCallback | Initial | Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth): WrapValue<Eighth>;
 /**
  * Attempt to pipe a value through a series of functions
+ *
+ * Available as `attemptPipe` and `attempt.pipe`
  * @param initial Initial value
  * @returns Piped result
  */
-declare function attemptPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth>(initial: GenericCallback | Initial, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth, ninth: (value: UnwrapValue<Eighth>) => Ninth): WrapValue<Ninth>;
+declare function attemptPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth>(initial: GenericCallback | Initial | Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth, ninth: (value: UnwrapValue<Eighth>) => Ninth): WrapValue<Ninth>;
 /**
  * Attempt to pipe a value through a series of functions
+ *
+ * Available as `attemptPipe` and `attempt.pipe`
  * @param initial Initial value
  * @returns Piped result
  */
-declare function attemptPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth, Tenth>(initial: GenericCallback | Initial, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth, ninth: (value: UnwrapValue<Eighth>) => Ninth, tenth: (value: UnwrapValue<Ninth>) => Tenth): WrapValue<Tenth>;
+declare function attemptPipe<Initial, First, Second, Third, Fourth, Fifth, Sixth, Seventh, Eighth, Ninth, Tenth>(initial: GenericCallback | Initial | Result<Initial>, first: (value: UnwrapValue<Initial>) => First, second: (value: UnwrapValue<First>) => Second, third: (value: UnwrapValue<Second>) => Third, fourth: (value: UnwrapValue<Third>) => Fourth, fifth: (value: UnwrapValue<Fourth>) => Fifth, sixth: (value: UnwrapValue<Fifth>) => Sixth, seventh: (value: UnwrapValue<Sixth>) => Seventh, eighth: (value: UnwrapValue<Seventh>) => Eighth, ninth: (value: UnwrapValue<Eighth>) => Ninth, tenth: (value: UnwrapValue<Ninth>) => Tenth): WrapValue<Tenth>;
 /**
  * Attempt to pipe a result through a series of functions
+ *
+ * Available as `attemptPipe` and `attempt.pipe`
  * @param initial Initial result
  * @returns Piped result
  */
-declare function attemptPipe<Initial>(initial: Result<Initial>, first?: (value: UnwrapValue<Initial>) => unknown, ...seconds: Array<(value: unknown) => unknown>): WrapValue<Initial>;
-/**
- * Attempt to pipe an item through a series of functions
- * @param item Initial value
- * @returns Piped result
- */
-declare function attemptPipe<Initial>(initial: GenericCallback | Initial, first?: (value: UnwrapValue<Initial>) => unknown, ...seconds: Array<(value: unknown) => unknown>): WrapValue<Initial>;
+declare function attemptPipe<Initial>(initial: GenericCallback | Initial | Result<Initial>, first?: (value: UnwrapValue<Initial>) => unknown, ...seconds: Array<(value: unknown) => unknown>): WrapValue<Initial>;
 declare namespace attemptPipe {
   var async: typeof attemptAsyncPipe;
 }
@@ -4799,6 +4964,8 @@ declare namespace attemptPipe {
 //#region src/result/index.d.ts
 /**
  * Executes a promise, catching any errors, and returns a result
+ *
+ * Available as `asyncAttempt` and `attempt.async`
  * @param promise Promise to execute
  * @param error Error value
  * @returns Callback result
@@ -4806,6 +4973,8 @@ declare namespace attemptPipe {
 declare function asyncAttempt<Value, E>(promise: Promise<Value>, error: E): Promise<ExtendedResult<Awaited<Value>, E>>;
 /**
  * Executes a callback asynchronously, catching any errors, and returns a result
+ *
+ * Available as `asyncAttempt` and `attempt.async`
  * @param callback Callback to execute
  * @param error Error value
  * @returns Callback result
@@ -4813,12 +4982,16 @@ declare function asyncAttempt<Value, E>(promise: Promise<Value>, error: E): Prom
 declare function asyncAttempt<Value, E>(callback: () => Promise<Value>, error: E): Promise<ExtendedResult<Awaited<Value>, E>>;
 /**
  * Executes a promise, catching any errors, and returns a result
+ *
+ * Available as `asyncAttempt` and `attempt.async`
  * @param promise Promise to execute
  * @returns Callback result
  */
 declare function asyncAttempt<Value>(promise: Promise<Value>): Promise<Result<Awaited<Value>>>;
 /**
  * Executes a callback asynchronously, catching any errors, and returns a result
+ *
+ * Available as `asyncAttempt` and `attempt.async`
  * @param callback Callback to execute
  * @returns Callback result
  */
@@ -4933,4 +5106,4 @@ declare class SizedSet<Value = unknown> extends Set<Value> {
   get(value: Value, update?: boolean): Value | undefined;
 }
 //#endregion
-export { AnyResult, ArrayComparisonSorter, ArrayKeySorter, ArrayOrPlainObject, ArrayPosition, ArrayValueSorter, Asserter, AsyncCancelableCallback, AttemptFlow, AttemptFlowPromise, type Beacon, type BeaconOptions, BuiltIns, CancelableCallback, CancelablePromise, type Color, Constructor, DiffOptions, DiffResult, DiffValue, EqualOptions, Err, EventPosition, ExtendedErr, ExtendedResult, Flow, FlowPromise, FulfilledPromise, FuzzyConfiguration, FuzzyOptions, FuzzyResult, FuzzySearchOptions, GenericAsyncCallback, GenericCallback, type HSLAColor, type HSLColor, HasValue, Key, KeyedValue, type Logger, type Memoized, type MemoizedOptions, MergeOptions, Merger, NestedArray, NestedKeys, NestedPartial, NestedValue, NestedValues, NumericalKeys, NumericalValues, type Observable, type Observer, Ok, OnceAsyncCallback, OnceCallback, PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, PlainObject, Primitive, PromiseData, PromiseHandlers, PromiseOptions, PromiseParameters, PromiseStrategy, PromiseTimeoutError, PromisesItems, PromisesOptions, PromisesResult, PromisesUnwrapped, PromisesValue, PromisesValues, type Queue, QueueError, type QueueOptions, type Queued, type QueuedResult, type RGBAColor, type RGBColor, RejectedPromise, RequiredKeys, Result, ResultMatch, RetryError, RetryOptions, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, Simplify, SizedMap, SizedSet, Smushed, SortDirection, Sorter, type Subscription, TemplateOptions, type Time, ToString, TypedArray, Unsmushed, UnwrapValue, assert, attempt, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, dedent, delay, diff, difference, drop, endsWith, endsWithArray, equal, error, exists, filter, find, first, flatten, floor, flow, fromQuery, toPromise as fromResult, toPromise, fuzzy, getArray, getArrayPosition, getColor, getError, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getTimedPromise, getUuid, getValue, groupBy, handleResult, hasValue, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, insert, intersection, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, last, logger, lowerCase, matchResult, max, median, memoize, merge, min, move, noop, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, settlePromise, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toQuery, toRecord, toResult, toSet, toggle, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };
+export { AnyResult, ArrayComparisonSorter, ArrayKeySorter, ArrayOrPlainObject, ArrayPosition, ArrayValueSorter, Asserter, AsyncCancelableCallback, AttemptFlow, AttemptFlowPromise, type Beacon, type BeaconOptions, BuiltIns, CancelableCallback, CancelablePromise, type Color, Constructor, DiffOptions, DiffResult, DiffValue, EqualOptions, Err, EventPosition, ExtendedErr, ExtendedResult, Flow, FlowPromise, FulfilledPromise, FuzzyConfiguration, FuzzyOptions, FuzzyResult, FuzzySearchOptions, GenericAsyncCallback, GenericCallback, type HSLAColor, type HSLColor, Key, KeyedValue, type Logger, type Memoized, type MemoizedOptions, MergeOptions, Merger, NestedArray, NestedKeys, NestedPartial, NestedValue, NestedValues, NumericalKeys, NumericalValues, type Observable, type Observer, Ok, OnceAsyncCallback, OnceCallback, PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, PlainObject, Primitive, PromiseData, PromiseHandlers, PromiseOptions, PromiseParameters, PromiseStrategy, PromiseTimeoutError, PromisesItems, PromisesOptions, PromisesResult, PromisesUnwrapped, PromisesValue, PromisesValues, type Queue, QueueError, type QueueOptions, type Queued, type QueuedResult, type RGBAColor, type RGBColor, RejectedPromise, RequiredKeys, Result, ResultMatch, RetryError, RetryOptions, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, Simplify, SizedMap, SizedSet, Smushed, SortDirection, Sorter, type Subscription, TemplateOptions, type Time, ToString, TypedArray, Unsmushed, UnwrapValue, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, filter, find, first, firstOrDefault, flatten, floor, flow, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayPosition, getColor, getError, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeEqualizer, initializeMerger, initializeSorter, initializeTemplater, insert, intersection, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isSorted, isTypedArray, join, kebabCase, last, lastOrDefault, logger, lowerCase, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, settlePromise, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };