@oscarpalmer/atoms 0.179.1 → 0.181.0

package/dist/array/sort.mjs

@@ -18,23 +18,7 @@ function getComparisonValue(first, second, sorters, length) {
 	}
 	return 0;
 }
-function getIndex(array, item, first, second) {
-	return getSortedIndex(array, item, getSorters(first, getModifier(first, second)));
-}
-function getModifier(first, second) {
-	return modifiers[first === true || second === true ? SORT_DIRECTION_DESCENDING : SORT_DIRECTION_ASCENDING];
-}
-function getObjectSorter(obj, modifier) {
-	let sorter;
-	if (typeof obj.comparison === "function") sorter = getComparisonSorter(obj.comparison, modifier);
-	else if (typeof obj.key === "string") {
-		sorter = getValueSorter(obj.key, modifier);
-		if (typeof obj.compare === "function") sorter.compare = { complex: obj.compare };
-	} else if (typeof obj.value === "function") sorter = getValueSorter(obj.value, modifier);
-	if (sorter != null && typeof obj.direction === "string") sorter.modifier = modifiers[obj.direction] ?? modifier;
-	return sorter;
-}
-function getSortedIndex(array, item, sorters) {
+function getIndex(array, item, sorters) {
 	if (!Array.isArray(array)) return -1;
 	const { length } = array;
 	if (length === 0) return 0;
@@ -50,6 +34,22 @@ function getSortedIndex(array, item, sorters) {
 	}
 	return low;
 }
+function getModifier(first, second) {
+	return modifiers[first === true || second === true ? SORT_DIRECTION_DESCENDING : SORT_DIRECTION_ASCENDING];
+}
+function getObjectSorter(obj, modifier) {
+	let sorter;
+	if (typeof obj.comparison === "function") sorter = getComparisonSorter(obj.comparison, modifier);
+	else if (typeof obj.key === "string") {
+		sorter = getValueSorter(obj.key, modifier);
+		if (typeof obj.compare === "function") sorter.compare = { complex: obj.compare };
+	} else if (typeof obj.value === "function") sorter = getValueSorter(obj.value, modifier);
+	if (sorter != null && typeof obj.direction === "string") sorter.modifier = modifiers[obj.direction] ?? modifier;
+	return sorter;
+}
+function getSortedIndex(array, item, first, second) {
+	return getIndex(array, item, getSorters(first, getModifier(first, second)));
+}
 function getSorter(value, modifier) {
 	switch (true) {
 		case typeof value === "function": return getComparisonSorter(value, modifier);
@@ -82,10 +82,10 @@ function getValueSorter(value, modifier) {
 		value: typeof value === "function" ? value : (item) => item[value]
 	};
 }
-function initializeSort(first, second) {
+function initializeSorter(first, second) {
 	const sorters = getSorters(first, getModifier(first, second));
 	const sorter = (array) => sortArray(array, sorters);
-	sorter.index = (array, item) => getSortedIndex(array, item, sorters);
+	sorter.index = (array, item) => getIndex(array, item, sorters);
 	sorter.is = (array) => isSortedArray(array, sorters);
 	return sorter;
 }
@@ -124,8 +124,8 @@ function sortArray(array, sorters) {
 	const { length } = sorters;
 	return array.length > 1 ? array.sort((first, second) => getComparisonValue(first, second, sorters, length)) : array;
 }
-sort.index = getIndex;
-sort.initialize = initializeSort;
+sort.index = getSortedIndex;
+sort.initialize = initializeSorter;
 sort.is = isSorted;
 const ARRAY_PEEK_PERCENTAGE = 10;
 const ARRAY_THRESHOLD = 100;
@@ -136,4 +136,4 @@ const modifiers = {
 	[SORT_DIRECTION_DESCENDING]: -1
 };
 //#endregion
-export { SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, sort };
+export { SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, getSortedIndex, initializeSorter, isSorted, sort };

package/dist/array/swap.d.mts

@@ -70,6 +70,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)_

package/dist/array/swap.mjs

@@ -32,6 +32,8 @@ function swapArrays(array, from, to, key) {
 * 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)_

package/dist/array/to-map.d.mts

@@ -70,6 +70,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
@@ -78,6 +80,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
@@ -86,6 +90,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
@@ -94,6 +100,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
@@ -102,6 +110,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
@@ -109,10 +119,12 @@ 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
  */
 declare function toMapArrays<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Map<Item[ItemKey], Item[]>;
 //#endregion
-export { toMap };
+export { toMap, toMapArrays };

package/dist/array/to-map.mjs

@@ -25,4 +25,4 @@ function toMapArrays(array, first, second) {
 	return getMapValues(array, first, second, true);
 }
 //#endregion
-export { toMap };
+export { toMap, toMapArrays };

package/dist/array/to-record.d.mts

@@ -70,6 +70,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
@@ -78,6 +80,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
@@ -86,6 +90,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
@@ -94,6 +100,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
@@ -102,6 +110,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
@@ -109,10 +119,12 @@ 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
  */
 declare function toRecordArrays<Item extends PlainObject, ItemKey extends keyof Item>(array: Item[], key: ItemKey): Simplify<Record<KeyedValue<Item, ItemKey>, Item[]>>;
 //#endregion
-export { toRecord };
+export { toRecord, toRecordArrays };

package/dist/array/to-record.mjs

@@ -8,4 +8,4 @@ function toRecordArrays(array, first, second) {
 	return groupValues(array, first, second, true);
 }
 //#endregion
-export { toRecord };
+export { toRecord, toRecordArrays };

package/dist/function/assert.d.mts

@@ -17,6 +17,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
@@ -25,12 +27,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
@@ -39,6 +45,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
@@ -46,4 +54,4 @@ declare function assertInstanceOf<Value>(constructor: Constructor<Value>, messag
  */
 declare function assertIs<Value>(condition: (value: unknown) => value is Value, message: string, error?: ErrorConstructor): Asserter<Value>;
 //#endregion
-export { Asserter, assert };
+export { Asserter, assert, assertCondition, assertDefined, assertInstanceOf, assertIs };

package/dist/function/assert.mjs

@@ -14,6 +14,8 @@ assert.instanceOf = assertInstanceOf;
 assert.is = assertIs;
 /**
 * 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
@@ -26,6 +28,8 @@ function assertCondition(condition, message, error) {
 }
 /**
 * 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
 */
@@ -34,6 +38,8 @@ function assertDefined(value, message) {
 }
 /**
 * 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
@@ -46,6 +52,8 @@ function assertInstanceOf(constructor, message, error) {
 }
 /**
 * 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
@@ -58,4 +66,4 @@ function assertIs(condition, message, error) {
 }
 const MESSAGE_VALUE_DEFINED = "Expected value to be defined";
 //#endregion
-export { assert };
+export { assert, assertCondition, assertDefined, assertInstanceOf, assertIs };

package/dist/function/limit.d.mts

@@ -7,6 +7,8 @@ import { AsyncCancelableCallback, CancelableCallback, GenericAsyncCallback, Gene
  * 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
@@ -18,6 +20,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
@@ -46,4 +50,4 @@ declare namespace throttle {
   var async: typeof asyncThrottle;
 }
 //#endregion
-export { debounce, throttle };
+export { asyncDebounce, asyncThrottle, debounce, throttle };

package/dist/function/limit.mjs

@@ -6,6 +6,8 @@ import { TIMER_DEBOUNCE, TIMER_THROTTLE, getAsyncTimer, getTimer } from "../inte
 * 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
@@ -19,6 +21,8 @@ function asyncDebounce(callback, time) {
 * 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
@@ -49,4 +53,4 @@ function throttle(callback, time) {
 }
 throttle.async = asyncThrottle;
 //#endregion
-export { debounce, throttle };
+export { asyncDebounce, asyncThrottle, debounce, throttle };

package/dist/function/once.d.mts

@@ -3,6 +3,8 @@ import { GenericAsyncCallback, GenericCallback, OnceAsyncCallback, OnceCallback
 //#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
  */
@@ -17,4 +19,4 @@ declare namespace once {
   var async: typeof asyncOnce;
 }
 //#endregion
-export { once };
+export { asyncOnce, once };

package/dist/function/once.mjs

@@ -2,6 +2,8 @@ import { assert } from "./assert.mjs";
 //#region src/function/once.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
 */
@@ -96,4 +98,4 @@ once.async = asyncOnce;
 const MESSAGE_CLEARED = "Once has been cleared";
 const MESSAGE_EXPECTATION = "Once expected a function";
 //#endregion
-export { once };
+export { asyncOnce, once };

package/dist/function/retry.d.mts

@@ -12,6 +12,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
@@ -19,6 +21,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

package/dist/function/retry.mjs

@@ -10,6 +10,8 @@ var RetryError = class extends Error {
 };
 /**
 * 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

package/dist/function/work.d.mts

@@ -12,61 +12,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>;
@@ -135,72 +159,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
  */
@@ -281,4 +329,4 @@ declare namespace pipe {
   var async: typeof asyncPipe;
 }
 //#endregion
-export { Flow, FlowPromise, flow, pipe };
+export { Flow, FlowPromise, asyncFlow, asyncPipe, flow, pipe };

package/dist/function/work.mjs

@@ -60,4 +60,4 @@ const MESSAGE_PIPE_PROMISE = "Synchronous Pipe received a promise. Use `pipe.asy
 const assertFlowFunctions = assert.condition((value) => Array.isArray(value) && value.every((item) => typeof item === "function"), MESSAGE_FLOW_ARRAY, TypeError);
 const assertPipeFunctions = assert.condition((value) => Array.isArray(value) && value.every((item) => typeof item === "function"), MESSAGE_PIPE_ARRAY, TypeError);
 //#endregion
-export { flow, pipe };
+export { asyncFlow, asyncPipe, flow, pipe };