@oscarpalmer/atoms 0.204.1 → 0.206.0

package/dist/index.mjs

@@ -115,6 +115,15 @@ function filter(array, ...parameters) {
 }
 filter.remove = exclude;
 //#endregion
+//#region src/array/find.ts
+function find(array, ...parameters) {
+	return findValue(FIND_VALUE_ITEM, array, parameters, false);
+}
+function findLast(array, ...parameters) {
+	return findValue(FIND_VALUE_ITEM, array, parameters, true);
+}
+find.last = findLast;
+//#endregion
 //#region src/array/first.ts
 function first(array, ...parameters) {
 	return findAbsoluteValueOrDefault(array, parameters, void 0, false, false);
@@ -122,7 +131,7 @@ function first(array, ...parameters) {
 function firstOrDefault(array, defaultValue, ...parameters) {
 	return findAbsoluteValueOrDefault(array, parameters, defaultValue, true, false);
 }
-first.default = firstOrDefault;
+first.defaulted = firstOrDefault;
 //#endregion
 //#region src/internal/array/group.ts
 function groupValues(array, key, value, arrays) {
@@ -397,15 +406,6 @@ function getArray(value, indiced) {
 	return array;
 }
 //#endregion
-//#region src/internal/array/index-of.ts
-function indexOf(array, ...parameters) {
-	return findValue(FIND_VALUE_INDEX, array, parameters, false);
-}
-function lastIndexOf(array, ...parameters) {
-	return findValue(FIND_VALUE_INDEX, array, parameters, true);
-}
-indexOf.last = lastIndexOf;
-//#endregion
 //#region src/internal/array/match.ts
 function endsWithArray(haystack, needle, key) {
 	return endings.has(getPosition(haystack, needle, key)[1]);
@@ -462,6 +462,34 @@ const outside = [-1, MATCH_COMPARISON_OUTSIDE];
 const outsides = /* @__PURE__ */ new Set([MATCH_COMPARISON_INVALID, MATCH_COMPARISON_OUTSIDE]);
 const starts = /* @__PURE__ */ new Set([MATCH_COMPARISON_START, MATCH_COMPARISON_SAME]);
 //#endregion
+//#region src/internal/math/misc.ts
+/**
+* Round a number down
+*
+* @param value Number to round down
+* @param decimals Number of decimal places to round to _(defaults to `0`)_
+* @returns Rounded number, or `Number.NaN` if the value if unable to be rounded
+*/
+function floor(value, decimals) {
+	return roundNumber(Math.floor, value, decimals);
+}
+/**
+* Round a number
+*
+* @param value Number to round
+* @param decimals Number of decimal places to round to _(defaults to `0`)_
+* @returns Rounded number, or `Number.NaN` if the value if unable to be rounded
+*/
+function round(value, decimals) {
+	return roundNumber(Math.round, value, decimals);
+}
+function roundNumber(callback, value, decimals) {
+	if (typeof value !== "number") return NaN;
+	if (typeof decimals !== "number" || decimals < 1) return callback(value);
+	const mod = 10 ** decimals;
+	return callback((value + Number.EPSILON) * mod) / mod;
+}
+//#endregion
 //#region src/internal/random.ts
 function getRandomFloatingNumberValue(inclusive, minimum, maximum) {
 	let maxFloat = isNumber(maximum) && maximum <= Number.MAX_SAFE_INTEGER ? maximum : Number.MAX_SAFE_INTEGER;
@@ -488,7 +516,7 @@ function getRandomFloatingNumber(minimum, maximum) {
 * @returns Random integer
 */
 function getRandomInteger(minimum, maximum) {
-	return Math.floor(getRandomFloatingNumberValue(true, minimum, maximum));
+	return floor(getRandomFloatingNumberValue(true, minimum, maximum));
 }
 //#endregion
 //#region src/internal/array/shuffle.ts
@@ -551,15 +579,6 @@ function exists(array, ...parameters) {
 	return findValue(FIND_VALUE_INDEX, array, parameters, false) > -1;
 }
 //#endregion
-//#region src/array/find.ts
-function find(array, ...parameters) {
-	return findValue(FIND_VALUE_ITEM, array, parameters, false);
-}
-function findLast(array, ...parameters) {
-	return findValue(FIND_VALUE_ITEM, array, parameters, true);
-}
-find.last = findLast;
-//#endregion
 //#region src/array/flatten.ts
 /**
 * Flatten an array _(using native `flat` and maximum depth)_
@@ -595,10 +614,81 @@ function times(length, value) {
 	return values;
 }
 //#endregion
+//#region src/internal/math/aggregate.ts
+function aggregate(type, array, key, first) {
+	const length = Array.isArray(array) ? array.length : 0;
+	const aggregation = {
+		array: false,
+		count: 0,
+		first: first === true,
+		value: NaN
+	};
+	if (length === 0) return aggregation;
+	const aggregator = aggregators[type];
+	const callback = getAggregateCallback(key);
+	aggregation.array = callback != null && (type === "max" || type === "min");
+	let notNumber = true;
+	for (let index = 0; index < length; index += 1) {
+		const item = array[index];
+		const value = callback == null ? item : callback(item, index, array);
+		if (isNonNumber(value)) continue;
+		aggregation.value = aggregator(aggregation, value, notNumber, item);
+		aggregation.count += 1;
+		notNumber = false;
+	}
+	return aggregation;
+}
+function calculateSum(aggregation, value, notNumber) {
+	return notNumber ? value : aggregation.value + value;
+}
+function getAbsoluteValue(condition, aggregation, value, notNumber, item) {
+	if (notNumber || condition(aggregation, value)) {
+		if (aggregation.array) {
+			aggregation.items ??= {};
+			aggregation.items[value] ??= [];
+			aggregation.items[value].push(item);
+		}
+		return value;
+	}
+	return aggregation.value;
+}
+function getAggregateCallback(key) {
+	if (key == null) return;
+	return typeof key === "function" ? key : (item) => item[key];
+}
+function getAggregated(type, array, key, first) {
+	const aggregation = aggregate(type, array, key, first);
+	if (aggregation.count === 0) return aggregation.array ? aggregation.first ? void 0 : [] : NaN;
+	if (aggregation.array) {
+		const array = aggregation.items[aggregation.value];
+		return aggregation.first ? array[0] : array;
+	}
+	return aggregation.value;
+}
+function isMaxValue(aggregation, value) {
+	return aggregation.array ? value >= aggregation.value : value > aggregation.value;
+}
+function isMinValue(aggregation, value) {
+	return aggregation.array ? value <= aggregation.value : value < aggregation.value;
+}
+function max(array, key, first) {
+	return getAggregated("max", array, key, first);
+}
+function min(array, key, first) {
+	return getAggregated("min", array, key, first);
+}
+const AGGREGATION_AVERAGE = "average";
+const aggregators = {
+	average: calculateSum,
+	max: getAbsoluteValue.bind(void 0, isMaxValue),
+	min: getAbsoluteValue.bind(void 0, isMinValue),
+	sum: calculateSum
+};
+//#endregion
 //#region src/internal/array/insert.ts
 function insertChunkedValues(type, array, items, start, deleteCount) {
 	const actualDeleteCount = deleteCount < 0 ? 0 : deleteCount;
-	const actualStart = Math.min(Math.max(0, start), array.length);
+	const actualStart = min([max([0, start]), array.length]);
 	const chunked = chunk(items);
 	const lastIndex = chunked.length - 1;
 	let index = chunked.length;
@@ -667,7 +757,7 @@ function reverse(array) {
 	if (!Array.isArray(array)) return [];
 	const { length } = array;
 	if (length < 2) return array;
-	const half = Math.floor(length / 2);
+	const half = floor(length / 2);
 	for (let firstIndex = 0; firstIndex < half; firstIndex += 1) {
 		const temporaryItem = array[firstIndex];
 		const secondIndex = length - 1 - firstIndex;
@@ -677,24 +767,6 @@ function reverse(array) {
 	return array;
 }
 //#endregion
-//#region src/array/select.ts
-function reverseSelect(array, ...parameters) {
-	return findValues("all", array, parameters, {
-		callback: parameters.shift(),
-		reverse: true
-	}).matched;
-}
-function select(array, ...parameters) {
-	return selectValues(array, parameters);
-}
-function selectValues(array, parameters) {
-	return findValues("all", array, parameters, {
-		callback: parameters.pop(),
-		reverse: false
-	}).matched;
-}
-select.reverse = reverseSelect;
-//#endregion
 //#region src/array/single.ts
 function single(array, ...parameters) {
 	const { matched } = findValues("all", array, parameters);
@@ -821,7 +893,7 @@ function last(array, ...parameters) {
 function lastOrDefault(array, defaultValue, ...parameters) {
 	return findAbsoluteValueOrDefault(array, parameters, defaultValue, true, true);
 }
-last.default = lastOrDefault;
+last.defaulted = lastOrDefault;
 //#endregion
 //#region src/internal/array/overlap.ts
 function arraysOverlap(first, second) {
@@ -916,73 +988,110 @@ function moveToIndex(array, value, index, key) {
 move.indices = moveIndices;
 move.toIndex = moveToIndex;
 //#endregion
-//#region src/internal/math/aggregate.ts
-function aggregate(type, array, key, first) {
-	const length = Array.isArray(array) ? array.length : 0;
-	const aggregation = {
-		array: false,
-		count: 0,
-		first: first === true,
-		value: NaN
+//#region src/array/select.ts
+function filterAndMap(array, ...parameters) {
+	return selectValues(array, parameters);
+}
+function mapAndFilter(array, ...parameters) {
+	return findValues("all", array, parameters, {
+		callback: parameters.shift(),
+		reverse: true
+	}).matched;
+}
+function selectValues(array, parameters) {
+	return findValues("all", array, parameters, {
+		callback: parameters.pop(),
+		reverse: false
+	}).matched;
+}
+filterAndMap.reverse = mapAndFilter;
+//#endregion
+//#region src/internal/result/misc.ts
+function error(value, original) {
+	return getError(value, original);
+}
+function getError(value, original) {
+	const errorResult = {
+		error: value,
+		ok: false
 	};
-	if (length === 0) return aggregation;
-	const aggregator = aggregators[type];
-	const callback = getAggregateCallback(key);
-	aggregation.array = callback != null && (type === "max" || type === "min");
-	let notNumber = true;
-	for (let index = 0; index < length; index += 1) {
-		const item = array[index];
-		const value = callback == null ? item : callback(item, index, array);
-		if (isNonNumber(value)) continue;
-		aggregation.value = aggregator(aggregation, value, notNumber, item);
-		aggregation.count += 1;
-		notNumber = false;
-	}
-	return aggregation;
+	if (original instanceof Error) errorResult.original = original;
+	return errorResult;
 }
-function calculateSum(aggregation, value, notNumber) {
-	return notNumber ? value : aggregation.value + value;
+function isError(value, extended) {
+	return isResultValue(value, false) && (extended === true ? value.original instanceof Error : true);
 }
-function getAbsoluteValue(condition, aggregation, value, notNumber, item) {
-	if (notNumber || condition(aggregation, value)) {
-		if (aggregation.array) {
-			aggregation.items ??= {};
-			aggregation.items[value] ??= [];
-			aggregation.items[value].push(item);
-		}
-		return value;
-	}
-	return aggregation.value;
+function isOk(value) {
+	return isResultValue(value, true);
 }
-function getAggregateCallback(key) {
-	if (key == null) return;
-	return typeof key === "function" ? key : (item) => item[key];
+/**
+* Is the value a _Result_?
+*
+* @param value Value to check
+* @returns `true` if the value is a _Result_, otherwise `false`
+*/
+function isResult(value) {
+	return isResultValue(value, true) || isResultValue(value, false);
 }
-function getAggregated(type, array, key, first) {
-	const aggregation = aggregate(type, array, key, first);
-	if (aggregation.count === 0) return aggregation.array ? aggregation.first ? void 0 : [] : NaN;
-	if (aggregation.array) {
-		const array = aggregation.items[aggregation.value];
-		return aggregation.first ? array[0] : array;
-	}
-	return aggregation.value;
+function isResultValue(value, okValue) {
+	return isPlainObject(value) && value.ok === okValue && (okValue ? RESULT_PROPERTY_VALUE : RESULT_PROPERTY_ERROR) in value;
 }
-function isMaxValue(aggregation, value) {
-	return aggregation.array ? value >= aggregation.value : value > aggregation.value;
+/**
+* Creates an ok result
+*
+* @param value Value
+* @returns Ok result
+*/
+function ok(value) {
+	return {
+		ok: true,
+		value
+	};
 }
-function isMinValue(aggregation, value) {
-	return aggregation.array ? value <= aggregation.value : value < aggregation.value;
+function unwrap(value, defaultValue) {
+	return isOk(value) ? value.value : defaultValue;
 }
-function max(array, key, first) {
-	return getAggregated("max", array, key, first);
+const RESULT_PROPERTY_ERROR = "error";
+const RESULT_PROPERTY_VALUE = "value";
+error.is = isError;
+ok.is = isOk;
+//#endregion
+//#region src/result/misc.ts
+/**
+* Converts a _Result_ to a _Promise_
+*
+* Resolves if ok, rejects for error
+*
+* @param result _Result_ to convert
+* @returns Promised result
+*/
+async function toPromise(result) {
+	const actual = typeof result === "function" ? result() : result;
+	if (!isResult(actual)) return Promise.reject(new Error(RESULT_MESSAGE_PROMISE));
+	return isOk(actual) ? Promise.resolve(actual.value) : Promise.reject(actual.error);
 }
-const AGGREGATION_AVERAGE = "average";
-const aggregators = {
-	average: calculateSum,
-	max: getAbsoluteValue.bind(void 0, isMaxValue),
-	min: getAbsoluteValue.bind(void 0, isMinValue),
-	sum: calculateSum
-};
+const RESULT_MESSAGE_PROMISE = "toPromise expected to receive a Result";
+//#endregion
+//#region src/internal/result/attempt.ts
+async function asyncAttempt(value, err) {
+	try {
+		let result;
+		if (typeof value === "function") result = value();
+		else result = value;
+		if (result instanceof Promise) result = await result;
+		return ok(result);
+	} catch (thrown) {
+		return getError(err ?? thrown, err == null ? void 0 : thrown);
+	}
+}
+function attempt(callback, err) {
+	try {
+		return ok(callback());
+	} catch (thrown) {
+		return getError(err ?? thrown, err == null ? void 0 : thrown);
+	}
+}
+attempt.async = asyncAttempt;
 //#endregion
 //#region src/internal/string/misc.ts
 /**
@@ -1043,11 +1152,7 @@ function join(array, delimiter) {
 	return values.join(typeof delimiter === "string" ? delimiter : "");
 }
 function tryCallback(value, callback) {
-	try {
-		return callback(value);
-	} catch {
-		return value;
-	}
+	return unwrap(attempt(() => callback(value)), value);
 }
 function tryDecode(value) {
 	return tryCallback(value, decodeURIComponent);
@@ -1253,7 +1358,7 @@ function getSortedArrayIndex(array, item) {
 	let low = 0;
 	let high = length - 1;
 	while (low <= high) {
-		const mid = Math.floor((low + high) / 2);
+		const mid = floor((low + high) / 2);
 		if (getComparisonValue(item, array[mid], sorters, sortersLength) < 0) high = mid - 1;
 		else low = mid + 1;
 	}
@@ -1308,7 +1413,7 @@ function isSortedArray(array) {
 	const sortersLength = sorters.length;
 	let offset = 0;
 	if (length >= SORT_THRESHOLD) {
-		offset = Math.round(length / SORT_PEEK_PERCENTAGE);
+		offset = round(length / SORT_PEEK_PERCENTAGE);
 		offset = offset > SORT_THRESHOLD ? SORT_THRESHOLD : offset;
 		for (let index = 0; index < offset; index += 1) {
 			const [firstItem, firstOffset] = [array[index], array[index + 1]];
@@ -1347,6 +1452,15 @@ sort.getIndex = getSortedIndex;
 sort.initialize = initializeSorter;
 sort.is = isSorted;
 //#endregion
+//#region src/internal/array/index-of.ts
+function indexOf(array, ...parameters) {
+	return findValue(FIND_VALUE_INDEX, array, parameters, false);
+}
+function lastIndexOf(array, ...parameters) {
+	return findValue(FIND_VALUE_INDEX, array, parameters, true);
+}
+indexOf.last = lastIndexOf;
+//#endregion
 //#region src/array/swap.ts
 function swap(array, first, second, third) {
 	if (!Array.isArray(array)) return [];
@@ -1505,15 +1619,14 @@ async function handleAsyncLimiter(state, item) {
 	if (state.interval === 0 || now - state.start >= state.interval - LIMITER_OFFSET) {
 		state.start = state.throttle ? now : void 0;
 		item.running = true;
-		try {
-			let result = state.callback(...item.parameters);
-			if (result instanceof Promise) result = await result;
-			item.resolve(result);
-		} catch (error) {
-			item.reject(error);
-		} finally {
-			item.running = false;
-		}
+		const result = await asyncAttempt(async () => {
+			let value = state.callback(...item.parameters);
+			if (value instanceof Promise) value = await value;
+			return value;
+		});
+		if (result.ok) item.resolve(result.value);
+		else item.reject(result.error);
+		item.running = false;
 	} else state.timer = startTimer(() => handleAsyncLimiter(state, item));
 }
 function handleLimiter(state) {
@@ -1577,91 +1690,41 @@ function asyncDebounce(callback, time) {
 * Throttle a function, ensuring it is only called once every `time` milliseconds
 *
 * - 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
-*/
-function asyncThrottle(callback, time) {
-	return getAsyncLimiter(LIMITER_THROTTLE, callback, time);
-}
-/**
-* Debounce a function, ensuring it is only called after `time` milliseconds have passed
-*
-* On subsequent calls, the timer is reset and will wait another `time` milliseconds _(and so on...)_
-*
-* @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
-*/
-function debounce(callback, time) {
-	return getLimiter(LIMITER_DEBOUNCE, callback, time);
-}
-/**
-* Throttle a function, ensuring it is only called once every `time` milliseconds
-*
-* @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
-*/
-function throttle(callback, time) {
-	return getLimiter(LIMITER_THROTTLE, callback, time);
-}
-debounce.async = asyncDebounce;
-throttle.async = asyncThrottle;
-//#endregion
-//#region src/internal/result/misc.ts
-function error(value, original) {
-	return getError(value, original);
-}
-function getError(value, original) {
-	const errorResult = {
-		error: value,
-		ok: false
-	};
-	if (original instanceof Error) errorResult.original = original;
-	return errorResult;
-}
-function isError(value, extended) {
-	return isResultValue(value, false) && (extended === true ? value.original instanceof Error : true);
-}
-function isOk(value) {
-	return isResultValue(value, true);
+* - 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
+*/
+function asyncThrottle(callback, time) {
+	return getAsyncLimiter(LIMITER_THROTTLE, callback, time);
 }
 /**
-* Is the value a _Result_?
+* Debounce a function, ensuring it is only called after `time` milliseconds have passed
 *
-* @param value Value to check
-* @returns `true` if the value is a _Result_, otherwise `false`
+* On subsequent calls, the timer is reset and will wait another `time` milliseconds _(and so on...)_
+*
+* @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
 */
-function isResult(value) {
-	return isResultValue(value, true) || isResultValue(value, false);
-}
-function isResultValue(value, okValue) {
-	return isPlainObject(value) && value.ok === okValue && (okValue ? RESULT_PROPERTY_VALUE : RESULT_PROPERTY_ERROR) in value;
+function debounce(callback, time) {
+	return getLimiter(LIMITER_DEBOUNCE, callback, time);
 }
 /**
-* Creates an ok result
+* Throttle a function, ensuring it is only called once every `time` milliseconds
 *
-* @param value Value
-* @returns Ok result
+* @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
 */
-function ok(value) {
-	return {
-		ok: true,
-		value
-	};
-}
-function unwrap(value, defaultValue) {
-	return isOk(value) ? value.value : defaultValue;
+function throttle(callback, time) {
+	return getLimiter(LIMITER_THROTTLE, callback, time);
 }
-const RESULT_PROPERTY_ERROR = "error";
-const RESULT_PROPERTY_VALUE = "value";
-error.is = isError;
-ok.is = isOk;
+debounce.async = asyncDebounce;
+throttle.async = asyncThrottle;
 //#endregion
 //#region src/internal/value/misc.ts
 function findKey(needle, haystack) {
@@ -2005,15 +2068,12 @@ var RetryError = class extends Error {
 async function asyncRetry(callback, options) {
 	if (typeof callback !== "function") throw new TypeError(RETRY_MESSAGE_EXPECTATION);
 	async function handle() {
-		try {
-			const result = await callback();
-			resolver(result);
-		} catch (error) {
-			if (attempts >= times || !when(error)) rejector(new RetryError(RETRY_MESSAGE_FAILED, error));
-			else {
-				attempts += 1;
-				limiter.run();
-			}
+		const result = await asyncAttempt(async () => callback());
+		if (result.ok) resolver(result.value);
+		else if (attempts >= times || !when(result.error)) rejector(new RetryError(RETRY_MESSAGE_FAILED, result.error));
+		else {
+			attempts += 1;
+			limiter.run();
 		}
 	}
 	const { delay, times, when } = createRetryOptions(options);
@@ -2046,11 +2106,11 @@ function retry(callback, options) {
 	if (typeof callback !== "function") throw new TypeError(RETRY_MESSAGE_EXPECTATION);
 	const { times, when } = createRetryOptions(options);
 	let last;
-	for (let index = 0; index <= times; index += 1) try {
-		return callback();
-	} catch (error) {
-		if (index >= times || !when(error)) {
-			last = error;
+	for (let index = 0; index <= times; index += 1) {
+		const result = attempt(callback);
+		if (result.ok) return result.value;
+		if (index >= times || !when(result.error)) {
+			last = result.error;
 			break;
 		}
 	}
@@ -2064,66 +2124,6 @@ const RETRY_MESSAGE_EXPECTATION = "Retry expected a function";
 const RETRY_MESSAGE_FAILED = "Retry failed";
 retry.async = asyncRetry;
 //#endregion
-//#region src/internal/function/work.ts
-function asyncFlow(...fns) {
-	assertFlowFunctions(fns);
-	return (...args) => asyncWork(args.map((value) => {
-		if (isError(value)) throw value.error;
-		return isOk(value) ? value.value : value;
-	}), fns, true);
-}
-function flow(...fns) {
-	assertFlowFunctions(fns);
-	return (...args) => work(args.map((value) => {
-		if (isError(value)) throw value.error;
-		return isOk(value) ? value.value : value;
-	}), fns, true);
-}
-async function asyncPipe(value, ...pipes) {
-	assertPipeFunctions(pipes);
-	return asyncWork(value, pipes, false);
-}
-function pipe(value, ...pipes) {
-	assertPipeFunctions(pipes);
-	return work(value, pipes, false);
-}
-async function asyncWork(initial, functions, flow) {
-	const { length } = functions;
-	let transformed = unwrapValue(initial);
-	for (let index = 0; index < length; index += 1) {
-		const fn = functions[index];
-		transformed = unwrapValue(flow && index === 0 && Array.isArray(initial) ? await fn(...initial) : await fn(transformed));
-	}
-	return transformed;
-}
-function unwrapValue(value, flow, nested) {
-	if (typeof value === "function") {
-		if (nested != null) throw new TypeError(WORK_MESSAGE_NESTING);
-		return unwrapValue(value(), flow, true);
-	}
-	if (flow != null && value instanceof Promise) throw new TypeError(flow ? WORK_MESSAGE_FLOW_PROMISE : WORK_MESSAGE_PIPE_PROMISE);
-	if (isError(value)) throw value.error;
-	return isOk(value) ? value.value : value;
-}
-function work(initial, functions, flow) {
-	const { length } = functions;
-	let transformed = unwrapValue(initial, flow);
-	for (let index = 0; index < length; index += 1) {
-		const fn = functions[index];
-		transformed = unwrapValue(flow && index === 0 && Array.isArray(initial) ? fn(...initial) : fn(transformed), flow);
-	}
-	return transformed;
-}
-const WORK_MESSAGE_FLOW_ARRAY = "Flow expected to receive an array of functions";
-const WORK_MESSAGE_FLOW_PROMISE = "Synchronous Flow received a promise. Use `flow.async` instead.";
-const WORK_MESSAGE_NESTING = "Return values are too deeply nested.";
-const WORK_MESSAGE_PIPE_ARRAY = "Pipe expected to receive an array of functions";
-const WORK_MESSAGE_PIPE_PROMISE = "Synchronous Pipe received a promise. Use `pipe.async` instead.";
-const assertFlowFunctions = assert.condition((value) => Array.isArray(value) && value.every((item) => typeof item === "function"), WORK_MESSAGE_FLOW_ARRAY, TypeError);
-const assertPipeFunctions = assert.condition((value) => Array.isArray(value) && value.every((item) => typeof item === "function"), WORK_MESSAGE_PIPE_ARRAY, TypeError);
-flow.async = asyncFlow;
-pipe.async = asyncPipe;
-//#endregion
 //#region src/internal/number.ts
 /**
 * Is the number between a minimum and maximum value?
@@ -2336,6 +2336,66 @@ const MEMOIZED_CALLBACK = "Memoized requires a callback function";
 const MEMOIZED_KEY_SEPARATOR = "_";
 const MEMOIZED_SYMBOL = Symbol("memoized");
 //#endregion
+//#region src/internal/function/work.ts
+function asyncFlow(...fns) {
+	assertFlowFunctions(fns);
+	return (...args) => asyncWork(args.map((value) => {
+		if (isError(value)) throw value.error;
+		return isOk(value) ? value.value : value;
+	}), fns, true);
+}
+function flow(...fns) {
+	assertFlowFunctions(fns);
+	return (...args) => work(args.map((value) => {
+		if (isError(value)) throw value.error;
+		return isOk(value) ? value.value : value;
+	}), fns, true);
+}
+async function asyncPipe(value, ...pipes) {
+	assertPipeFunctions(pipes);
+	return asyncWork(value, pipes, false);
+}
+function pipe(value, ...pipes) {
+	assertPipeFunctions(pipes);
+	return work(value, pipes, false);
+}
+async function asyncWork(initial, functions, flow) {
+	const { length } = functions;
+	let transformed = unwrapValue(initial);
+	for (let index = 0; index < length; index += 1) {
+		const fn = functions[index];
+		transformed = unwrapValue(flow && index === 0 && Array.isArray(initial) ? await fn(...initial) : await fn(transformed));
+	}
+	return transformed;
+}
+function unwrapValue(value, flow, nested) {
+	if (typeof value === "function") {
+		if (nested != null) throw new TypeError(WORK_MESSAGE_NESTING);
+		return unwrapValue(value(), flow, true);
+	}
+	if (flow != null && value instanceof Promise) throw new TypeError(flow ? WORK_MESSAGE_FLOW_PROMISE : WORK_MESSAGE_PIPE_PROMISE);
+	if (isError(value)) throw value.error;
+	return isOk(value) ? value.value : value;
+}
+function work(initial, functions, flow) {
+	const { length } = functions;
+	let transformed = unwrapValue(initial, flow);
+	for (let index = 0; index < length; index += 1) {
+		const fn = functions[index];
+		transformed = unwrapValue(flow && index === 0 && Array.isArray(initial) ? fn(...initial) : fn(transformed), flow);
+	}
+	return transformed;
+}
+const WORK_MESSAGE_FLOW_ARRAY = "Flow expected to receive an array of functions";
+const WORK_MESSAGE_FLOW_PROMISE = "Synchronous Flow received a promise. Use `flow.async` instead.";
+const WORK_MESSAGE_NESTING = "Return values are too deeply nested.";
+const WORK_MESSAGE_PIPE_ARRAY = "Pipe expected to receive an array of functions";
+const WORK_MESSAGE_PIPE_PROMISE = "Synchronous Pipe received a promise. Use `pipe.async` instead.";
+const assertFlowFunctions = assert.condition((value) => Array.isArray(value) && value.every((item) => typeof item === "function"), WORK_MESSAGE_FLOW_ARRAY, TypeError);
+const assertPipeFunctions = assert.condition((value) => Array.isArray(value) && value.every((item) => typeof item === "function"), WORK_MESSAGE_PIPE_ARRAY, TypeError);
+flow.async = asyncFlow;
+pipe.async = asyncPipe;
+//#endregion
 //#region src/internal/string/case.ts
 /**
 * Convert a string to camel case _(thisIsCamelCase)_
@@ -2531,7 +2591,7 @@ function equalArray(first, second, options) {
 	if (length !== second.length) return false;
 	let offset = 0;
 	if (length >= EQUAL_ARRAY_THRESHOLD) {
-		offset = Math.round(length / EQUAL_ARRAY_PEEK_PERCENTAGE);
+		offset = round(length / EQUAL_ARRAY_PEEK_PERCENTAGE);
 		offset = offset > EQUAL_ARRAY_THRESHOLD ? EQUAL_ARRAY_THRESHOLD : offset;
 		for (let index = 0; index < offset; index += 1) if (!(equalValue(first[index], second[index], options) && equalValue(first[length - index - 1], second[length - index - 1], options))) return false;
 	}
@@ -2703,7 +2763,6 @@ const ABORT_OPTIONS = { once: true };
 //#region src/promise/constants.ts
 const PROMISE_ERROR_NAME = "PromiseTimeoutError";
 const PROMISE_MESSAGE_EXPECTATION_ATTEMPT = "Attempt expected a function or a promise";
-const PROMISE_MESSAGE_EXPECTATION_ITEMS_EMPTY = "promises expected at least one promise-function or promise in the array or object";
 const PROMISE_MESSAGE_EXPECTATION_ITEMS_TYPE = "promises expected an array or object holding promise-functions or promises";
 const PROMISE_MESSAGE_EXPECTATION_RESULT = "toResult expected a Promise";
 const PROMISE_MESSAGE_EXPECTATION_TIMED = "Timed function expected a Promise";
@@ -2808,22 +2867,6 @@ function isType(value, type) {
 	return isPlainObject(value) && "status" in value && value.status === type;
 }
 //#endregion
-//#region src/result/misc.ts
-/**
-* Converts a _Result_ to a _Promise_
-*
-* Resolves if ok, rejects for error
-*
-* @param result _Result_ to convert
-* @returns Promised result
-*/
-async function toPromise(result) {
-	const actual = typeof result === "function" ? result() : result;
-	if (!isResult(actual)) return Promise.reject(new Error(RESULT_MESSAGE_PROMISE));
-	return isOk(actual) ? Promise.resolve(actual.value) : Promise.reject(actual.error);
-}
-const RESULT_MESSAGE_PROMISE = "toPromise expected to receive a Result";
-//#endregion
 //#region src/promise/misc.ts
 /**
 * Create a cancelable _Promise_
@@ -2914,13 +2957,13 @@ async function attemptPromise(value, options) {
 		rejector(signal?.reason);
 	});
 	async function handler(resolve, reject) {
-		try {
+		const result = await asyncAttempt(async () => {
 			let result = isFunction ? value() : await value;
 			if (result instanceof Promise) result = await result;
-			settlePromise(resolve, result, aborter);
-		} catch (error) {
-			settlePromise(reject, error, aborter);
-		}
+			return result;
+		});
+		if (result.ok) settlePromise(resolve, result.value, aborter);
+		else settlePromise(reject, result.error, aborter);
 	}
 	let rejector;
 	const promise = new Promise((resolve, reject) => {
@@ -2935,12 +2978,11 @@ async function promises(items, options) {
 	if (!isArrayOrPlainObject(items)) return Promise.reject(PROMISE_MESSAGE_EXPECTATION_ITEMS_TYPE);
 	const isArray = Array.isArray(items);
 	const actual = (isArray ? items.map((item, index) => [index, item]) : Object.entries(items)).map(([key, value]) => [key, typeof value === "function" ? value() : value]).filter(([, value]) => value instanceof Promise);
-	const { length } = actual;
-	if (length === 0) return Promise.reject(PROMISE_MESSAGE_EXPECTATION_ITEMS_EMPTY);
-	const complete = strategy === PROMISE_STRATEGY_DEFAULT;
 	const aborter = createAborter(signal, () => {
 		handlers.reject(signal?.reason);
 	});
+	const complete = strategy === PROMISE_STRATEGY_DEFAULT;
+	const { length } = actual;
 	const data = {
 		last: length - 1,
 		result: isArray ? [] : {}
@@ -2976,25 +3018,6 @@ async function resultPromises(items, signal) {
 }
 promises.result = resultPromises;
 //#endregion
-//#region src/result/index.ts
-async function asyncAttempt(value, err) {
-	try {
-		let result = typeof value === "function" ? value() : await value;
-		if (result instanceof Promise) result = await result;
-		return ok(result);
-	} catch (thrown) {
-		return getError(err ?? thrown, err == null ? void 0 : thrown);
-	}
-}
-function attempt(callback, err) {
-	try {
-		return ok(callback());
-	} catch (thrown) {
-		return getError(err ?? thrown, err == null ? void 0 : thrown);
-	}
-}
-attempt.async = asyncAttempt;
-//#endregion
 //#region src/result/match.ts
 async function asyncMatchResult(result, first, error) {
 	let value;
@@ -3134,7 +3157,7 @@ function createFuzzyItems(items) {
 function createFuzzyOptions(input, state) {
 	const options = isPlainObject(input) ? input : {};
 	const limit = typeof input === "number" ? input : options.limit;
-	if (typeof limit === "number" && !Number.isNaN(limit) && limit >= 1) options.limit = Math.floor(limit);
+	if (typeof limit === "number" && !Number.isNaN(limit) && limit >= 1) options.limit = floor(limit);
 	else options.limit = state?.limit;
 	options.tolerance = getTolerance(options.tolerance, state);
 	return options;
@@ -3199,18 +3222,18 @@ function getScore(haystack, needle) {
 			if (haystackIndex === 0) score += 1;
 			if (previousMatchIndex !== -1) {
 				const gap = haystackIndex - previousMatchIndex - 1;
-				score += Math.max(0, FUZZY_PROXIMITY_THRESHOLD - gap);
+				score += max([0, FUZZY_PROXIMITY_THRESHOLD - gap]);
 			}
 			previousMatchIndex = haystackIndex;
 			needleIndex += 1;
 		}
 		if (needleIndex === needleLength) break;
 	}
-	score -= Math.floor(lowerCaseHaystack.length / FUZZY_LENGTH_DIVISOR);
-	return Math.max(0, score);
+	score -= floor(lowerCaseHaystack.length / FUZZY_LENGTH_DIVISOR);
+	return max([0, score]);
 }
 function getTolerance(input, state) {
-	if (typeof input === "number" && !Number.isNaN(input)) return input < 0 ? 0 : Math.floor(input);
+	if (typeof input === "number" && !Number.isNaN(input)) return input < 0 ? 0 : floor(input);
 	return state?.tolerance ?? FUZZY_PROXIMITY_THRESHOLD;
 }
 /**
@@ -3315,7 +3338,7 @@ function dedent(value, ...values) {
 		if (indentation != null) lengths.push(indentation.length);
 	}
 	if (lengths.length === 0) return actual.trim();
-	const minimum = Math.min(...lengths);
+	const minimum = min(lengths);
 	const pattern = new RegExp(`^\\s{0,${minimum}}`);
 	let result = "";
 	for (let index = 0; index < length; index += 1) {
@@ -3709,14 +3732,9 @@ function registerCloner(constructor, handler) {
 }
 function tryStructuredClone(value, parameters, depth) {
 	if (depth >= CLONE_MAX_DEPTH) return value;
-	try {
-		const cloned = structuredClone(value);
-		parameters.references.set(value, cloned);
-		return cloned;
-	} catch {
-		parameters.references.set(value, value);
-		return value;
-	}
+	const cloned = unwrap(attempt(() => structuredClone(value)), value);
+	parameters.references.set(value, cloned);
+	return cloned;
 }
 const CLONE_COPY_OPTIONS = {
 	copyFunctions: true,
@@ -3839,8 +3857,8 @@ function getChanges(changes, first, second, options, prefix) {
 function getDiffs(first, second, options, prefix) {
 	const changes = [];
 	if (Array.isArray(first) && Array.isArray(second)) {
-		const maximumLength = Math.max(first.length, second.length);
-		const minimumLength = Math.min(first.length, second.length);
+		const maximumLength = max([first.length, second.length]);
+		const minimumLength = min([first.length, second.length]);
 		for (let index = minimumLength; index < maximumLength; index += 1) {
 			const key = join([prefix, index], ".");
 			changes.push({
@@ -4492,7 +4510,7 @@ function Observable(beacon) {
 	};
 }
 Observable.prototype[BEACON_PROPERTY] = BEACON_OBSERVABLE;
-Observable.prototype.deactivate = deactiveateObservable;
+Observable.prototype.deactivate = deactivateObservable;
 Observable.prototype.subscribe = subscribeToObservable;
 Object.defineProperty(Observable.prototype, "active", {
 	enumerable: true,
@@ -4541,7 +4559,7 @@ function createObserver(first, second, third) {
 function deactivateBeacon() {
 	closeBeacon(this[BEACON_SYMBOL], false);
 }
-function deactiveateObservable() {
+function deactivateObservable() {
 	this[BEACON_SYMBOL].active = false;
 }
 function emitBeaconError(error, finish) {
@@ -4866,24 +4884,6 @@ const colorSubscription = {
 	value: SUBSCRIPTION_NAME
 };
 //#endregion
-//#region src/internal/math/misc.ts
-/**
-* Round a number
-*
-* @param value Number to round
-* @param decimals Number of decimal places to round to _(defaults to `0`)_
-* @returns Rounded number, or `Number.NaN` if the value if unable to be rounded
-*/
-function round(value, decimals) {
-	return roundNumber(Math.round, value, decimals);
-}
-function roundNumber(callback, value, decimals) {
-	if (typeof value !== "number") return NaN;
-	if (typeof decimals !== "number" || decimals < 1) return callback(value);
-	const mod = 10 ** decimals;
-	return callback((value + Number.EPSILON) * mod) / mod;
-}
-//#endregion
 //#region src/color/misc/alpha.ts
 function getAlpha(value, hex) {
 	if (typeof value === "number") return getAlphaFromValue(value);
@@ -5209,12 +5209,12 @@ function convertRgbToHex(rgb, alpha) {
 }
 function convertRgbToHsla(value) {
 	const values = getRgbCalculationValues(isRgbLike(value) ? getRgbValues(value) : { ...COLOR_DEFAULTS.rgb });
-	const { delta, max, min } = values;
-	const lightness = (min + max) / 2;
+	const { delta, maximum, minimum } = values;
+	const lightness = (minimum + maximum) / 2;
 	let hue = 0;
 	let saturation = 0;
 	if (delta !== 0) {
-		saturation = (max - lightness) / Math.min(lightness, 1 - lightness);
+		saturation = (maximum - lightness) / min([lightness, 1 - lightness]);
 		hue = getRgbHue(values);
 		hue *= 60;
 	}
@@ -5227,7 +5227,7 @@ function convertRgbToHsla(value) {
 }
 function convertRgbToHwba(value) {
 	const values = getRgbCalculationValues(isRgbLike(value) ? getRgbValues(value) : { ...COLOR_DEFAULTS.rgb });
-	const { delta, max, min } = values;
+	const { delta, maximum, minimum } = values;
 	let hue = 0;
 	if (delta !== 0) {
 		hue = getRgbHue(values);
@@ -5235,8 +5235,8 @@ function convertRgbToHwba(value) {
 	}
 	return {
 		hue,
-		whiteness: min * COLOR_MAX.percent,
-		blackness: (1 - max) * COLOR_MAX.percent,
+		whiteness: minimum * COLOR_MAX.percent,
+		blackness: (1 - maximum) * COLOR_MAX.percent,
 		alpha: getAlphaValue(value?.alpha ?? COLOR_MAX.percent)
 	};
 }
@@ -5256,14 +5256,22 @@ function getRgbCalculationValues(rgb) {
 	const blue = rgb.blue / COLOR_MAX.hex;
 	const green = rgb.green / COLOR_MAX.hex;
 	const red = rgb.red / COLOR_MAX.hex;
-	const max = Math.max(blue, green, red);
-	const min = Math.min(blue, green, red);
+	const maximum = max([
+		blue,
+		green,
+		red
+	]);
+	const minimum = min([
+		blue,
+		green,
+		red
+	]);
 	return {
 		blue,
-		delta: max - min,
+		delta: maximum - minimum,
 		green,
-		max,
-		min,
+		maximum,
+		minimum,
 		red
 	};
 }
@@ -5274,8 +5282,8 @@ function getRgbaColor$1() {
 	return getStateValue(this, COLOR_TYPE.rgb, true);
 }
 function getRgbHue(values) {
-	const { blue, delta, green, max, red } = values;
-	switch (max) {
+	const { blue, delta, green, maximum, red } = values;
+	switch (maximum) {
 		case blue: return (red - green) / delta + 4;
 		case green: return (blue - red) / delta + 2;
 		default: return (green - blue) / delta + (green < blue ? 6 : 0);
@@ -5524,7 +5532,7 @@ function convertHslToHwba(input) {
 	let { hue, lightness, saturation } = isHslLike(input) ? getHslValues(input) : { ...COLOR_DEFAULTS.hsl };
 	lightness /= COLOR_MAX.percent;
 	saturation /= COLOR_MAX.percent;
-	const value = lightness + saturation * Math.min(lightness, 1 - lightness);
+	const value = lightness + saturation * min([lightness, 1 - lightness]);
 	if (value === 0) saturation = 0;
 	else saturation = 2 * (1 - lightness / value);
 	const blackness = 1 - value;
@@ -5561,7 +5569,11 @@ function getColorFromHsl(state, type) {
 }
 function getHexyValue(hue, lightness, saturation, value) {
 	const part = (value + hue / 30) % 12;
-	return (lightness - saturation * Math.min(lightness, 1 - lightness) * Math.max(-1, Math.min(part - 3, 9 - part, 1))) * COLOR_MAX.hex;
+	return (lightness - saturation * min([lightness, 1 - lightness]) * max([-1, min([
+		part - 3,
+		9 - part,
+		1
+	])])) * COLOR_MAX.hex;
 }
 function getHslValue() {
 	return getStateValue(this, COLOR_TYPE.hsl, false);
@@ -5694,7 +5706,7 @@ function getColorFromHwb(state, type) {
 function getHwbSaturation(blackness, whiteness, lightness) {
 	const hue = 1 - blackness - whiteness;
 	if (hue <= 0) return 0;
-	return hue / Math.min(2 * lightness, 2 - 2 * lightness);
+	return hue / min([2 * lightness, 2 - 2 * lightness]);
 }
 function getHwbValue() {
 	return getStateValue(this, COLOR_TYPE.hwb, false);
@@ -6233,16 +6245,6 @@ function count(array, key, value) {
 	}
 	return counted;
 }
-/**
-* Round a number down
-*
-* @param value Number to round down
-* @param decimals Number of decimal places to round to _(defaults to `0`)_
-* @returns Rounded number, or `Number.NaN` if the value if unable to be rounded
-*/
-function floor(value, decimals) {
-	return roundNumber(Math.floor, value, decimals);
-}
 function median(array, key) {
 	let length = Array.isArray(array) ? array.length : 0;
 	if (!Array.isArray(array) || length === 0) return NaN;
@@ -6257,10 +6259,7 @@ function median(array, key) {
 		const second = length / 2;
 		return (numbers[first] + numbers[second]) / 2;
 	}
-	return numbers[Math.floor(length / 2)];
-}
-function min(array, key, first) {
-	return getAggregated("min", array, key, first);
+	return numbers[floor(length / 2)];
 }
 function sum(array, key) {
 	return getAggregated("sum", array, key);
@@ -6681,7 +6680,7 @@ function resumeQueue() {
 		for (let index = 0; index < length; index += 1) handled[index]();
 	}
 	state.paused = false;
-	const length = Math.min(state.options.concurrency, state.items.length);
+	const length = min([state.options.concurrency, state.items.length]);
 	for (let index = 0; index < length; index += 1) run(state);
 }
 function resumeQueues(key) {
@@ -6694,14 +6693,17 @@ async function run(state) {
 	while (item != null) {
 		let error = false;
 		let result;
-		try {
-			if (!(item.aborter?.signal?.aborted ?? false)) {
+		const attempted = await asyncAttempt(async () => {
+			if (item != null && !(item.aborter?.signal?.aborted ?? false)) {
 				const parameters = item.key == null ? item.parameters : [item.key, ...item.parameters];
-				result = await state.callback(...parameters);
+				return await state.callback(...parameters);
 			}
-		} catch (thrown) {
+			throw new Error();
+		});
+		if (attempted.ok) result = attempted.value;
+		else {
 			error = true;
-			result = thrown;
+			result = attempted.error;
 		}
 		if (state.paused) {
 			const paused = item;
@@ -6845,4 +6847,4 @@ var SizedSet = class extends Set {
 	}
 };
 //#endregion
-export { CancelablePromise, Logger, PromiseTimeoutError, QueueError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, 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, copy, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, filter, find, findLast, first, firstOrDefault, flatFreeze, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getHwbColor, getHwbaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hasValueResult, herald, hexToHsl, hexToHsla, hexToHwb, hexToHwba, hexToRgb, hexToRgba, hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba, hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeCloner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, interpolate, intersection, isArrayOrPlainObject, isAsyncOnce, isBeacon, isBeaconSubscription, isColor, isConstructor, isEmpty, isError, isFrozen, isFulfilled, isFuzzy, isHerald, isHeraldEvents, isHeraldSubscription, isHexColor, isHslColor, isHslaColor, isHwbColor, isHwbaColor, isInstanceOf, isKey, isKeyedQueue, isLogger, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTemplateStringsArray, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isObservable, isOk, isOnce, isPlainObject, isPrimitive, isQueue, isQueueInstance, isRejected, isResult, isRgbColor, isRgbaColor, isSorted, isSubscription, isSubscriptions, isTemplateStringsArray, isTimeLogger, isTypedArray, join, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, lowerCase, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, reverseSelect, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, select, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, subscriptions, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };
+export { CancelablePromise, Logger, PromiseTimeoutError, QueueError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, push as append, push, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, 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, copy, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, filter, filterAndMap, filterAndMap as select, find, findLast, first, firstOrDefault, flatFreeze, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getHwbColor, getHwbaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hasValueResult, herald, hexToHsl, hexToHsla, hexToHwb, hexToHwba, hexToRgb, hexToRgba, hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba, hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeCloner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, interpolate, intersection, isArrayOrPlainObject, isAsyncOnce, isBeacon, isBeaconSubscription, isColor, isConstructor, isEmpty, isError, isFrozen, isFulfilled, isFuzzy, isHerald, isHeraldEvents, isHeraldSubscription, isHexColor, isHslColor, isHslaColor, isHwbColor, isHwbaColor, isInstanceOf, isKey, isKeyedQueue, isLogger, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTemplateStringsArray, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isObservable, isOk, isOnce, isPlainObject, isPrimitive, isQueue, isQueueInstance, isRejected, isResult, isRgbColor, isRgbaColor, isSorted, isSubscription, isSubscriptions, isTemplateStringsArray, isTimeLogger, isTypedArray, join, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, lowerCase, mapAndFilter, mapAndFilter as reverseSelect, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, subscriptions, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };