@oscarpalmer/atoms 0.205.0 → 0.206.0

package/dist/index.mjs

@@ -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
@@ -586,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;
@@ -658,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;
@@ -907,73 +1006,92 @@ function selectValues(array, parameters) {
 }
 filterAndMap.reverse = mapAndFilter;
 //#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/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
 /**
@@ -1034,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);
@@ -1244,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;
 	}
@@ -1299,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]];
@@ -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) {
@@ -1613,56 +1726,6 @@ function 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);
-}
-/**
-* 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 isResultValue(value, okValue) {
-	return isPlainObject(value) && value.ok === okValue && (okValue ? RESULT_PROPERTY_VALUE : RESULT_PROPERTY_ERROR) in value;
-}
-/**
-* Creates an ok result
-*
-* @param value Value
-* @returns Ok result
-*/
-function ok(value) {
-	return {
-		ok: true,
-		value
-	};
-}
-function unwrap(value, defaultValue) {
-	return isOk(value) ? value.value : defaultValue;
-}
-const RESULT_PROPERTY_ERROR = "error";
-const RESULT_PROPERTY_VALUE = "value";
-error.is = isError;
-ok.is = isOk;
-//#endregion
 //#region src/internal/value/misc.ts
 function findKey(needle, haystack) {
 	const keys = Object.keys(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;
 		}
 	}
@@ -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,27 +3018,6 @@ async function resultPromises(items, signal) {
 }
 promises.result = resultPromises;
 //#endregion
-//#region src/result/index.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/result/match.ts
 async function asyncMatchResult(result, first, error) {
 	let value;
@@ -3136,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;
@@ -3201,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;
 }
 /**
@@ -3317,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) {
@@ -3711,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,
@@ -3841,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({
@@ -4868,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);
@@ -5211,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;
 	}
@@ -5229,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);
@@ -5237,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)
 	};
 }
@@ -5258,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
 	};
 }
@@ -5276,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);
@@ -5526,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;
@@ -5563,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);
@@ -5696,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);
@@ -6235,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;
@@ -6259,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);
@@ -6683,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) {
@@ -6696,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;