@oscarpalmer/atoms 0.216.0 → 0.218.0

package/dist/index.mjs

@@ -29,15 +29,47 @@ function createFindParameters(original) {
 		value: length === 1 && typeof original[0] !== "function" ? original[0] : original[1]
 	};
 }
+function findComplexValues(parameters) {
+	const { array, keyCallback, length, mapAfter, mapBefore, result, type, value } = parameters;
+	const keys = /* @__PURE__ */ new Set();
+	for (let index = 0; index < length; index += 1) {
+		const item = array[index];
+		let keyed;
+		let transformed;
+		if (mapBefore == null) {
+			keyed = keyCallback?.(item, index, array) ?? item;
+			transformed = item;
+		} else {
+			transformed = mapBefore(item, index, array);
+			keyed = keyCallback?.(transformed, index, array) ?? transformed;
+		}
+		if (type === "all" && Object.is(keyed, value) || type === "unique" && !keys.has(keyed)) {
+			keys.add(keyed);
+			result.matched.push(mapAfter?.(item, index, array) ?? transformed);
+		} else result.notMatched.push(item);
+	}
+	return result;
+}
+function findSimpleValue(array, value, findIndex, reversed) {
+	if (findIndex) return reversed ? array.lastIndexOf(value) : array.indexOf(value);
+	return reversed ? array.findLast((item) => Object.is(item, value)) : array.find((item) => Object.is(item, value));
+}
+function findSimpleValues(array, length, value, boolCallback, mapBefore, mapAfter, result) {
+	const callback = boolCallback ?? ((item) => Object.is(item, value));
+	for (let index = 0; index < length; index += 1) {
+		const item = array[index];
+		const transformed = mapBefore?.(item, index, array) ?? item;
+		if (callback(transformed, index, array)) result.matched.push(mapAfter?.(item, index, array) ?? transformed);
+		else result.notMatched.push(item);
+	}
+	return result;
+}
 function findValue(type, array, parameters, reversed) {
 	const findIndex = type === ARRAY_FIND_VALUE_INDEX;
 	if (!Array.isArray(array) || array.length === 0) return findIndex ? -1 : void 0;
 	const { bool, key, value } = createFindParameters(parameters);
 	const callbacks = getArrayCallbacks(bool, key);
-	if (callbacks?.bool == null && callbacks?.keyed == null) {
-		if (findIndex) return reversed ? array.lastIndexOf(value) : array.indexOf(value);
-		return reversed ? array.findLast((item) => Object.is(item, value)) : array.find((item) => Object.is(item, value));
-	}
+	if (callbacks?.bool == null && callbacks?.keyed == null) return findSimpleValue(array, value, findIndex, reversed);
 	if (callbacks.bool != null) {
 		const index = reversed ? array.findLastIndex(callbacks.bool) : array.findIndex(callbacks.bool);
 		return findIndex ? index : array[index];
@@ -58,7 +90,8 @@ function findAbsoluteValueOrDefault(array, parameters, defaultValue, useDefaultV
 		return useDefaultValue ? defaultValue : void 0;
 	}
 	const index = findValue(ARRAY_FIND_VALUE_INDEX, array, parameters, reversed);
-	return index > -1 ? array[index] : useDefaultValue ? defaultValue : void 0;
+	if (index === -1) return useDefaultValue ? defaultValue : void 0;
+	return array[index];
 }
 function findValues(type, array, parameters, mapper) {
 	const result = {
@@ -75,36 +108,26 @@ function findValues(type, array, parameters, mapper) {
 	}
 	const mapCallback = getArrayCallback(mapper?.callback);
 	const mapReverse = mapper?.reverse ?? false;
-	const mapAfter = mapCallback == null ? void 0 : mapReverse ? void 0 : mapCallback;
-	const mapBefore = mapCallback == null ? void 0 : mapReverse ? mapCallback : void 0;
-	if (callbacks?.bool != null || type === "all" && key == null) {
-		const callback = callbacks?.bool ?? ((item) => Object.is(item, value));
-		for (let index = 0; index < length; index += 1) {
-			const item = array[index];
-			const transformed = mapBefore?.(item, index, array) ?? item;
-			if (callback(transformed, index, array)) result.matched.push(mapAfter?.(item, index, array) ?? transformed);
-			else result.notMatched.push(item);
-		}
-		return result;
-	}
-	const keys = /* @__PURE__ */ new Set();
-	for (let index = 0; index < length; index += 1) {
-		const item = array[index];
-		let keyed;
-		let transformed;
-		if (mapBefore == null) {
-			keyed = callbacks?.keyed?.(item, index, array) ?? item;
-			transformed = item;
-		} else {
-			transformed = mapBefore(item, index, array);
-			keyed = callbacks?.keyed?.(transformed, index, array) ?? transformed;
-		}
-		if (type === "all" && Object.is(keyed, value) || type === "unique" && !keys.has(keyed)) {
-			keys.add(keyed);
-			result.matched.push(mapAfter?.(item, index, array) ?? transformed);
-		} else result.notMatched.push(item);
-	}
-	return result;
+	let mapAfter;
+	let mapBefore;
+	if (mapCallback == null) {
+		mapAfter = void 0;
+		mapBefore = void 0;
+	} else {
+		mapAfter = mapReverse ? void 0 : mapCallback;
+		mapBefore = mapReverse ? mapCallback : void 0;
+	}
+	if (callbacks?.bool != null || type === "all" && key == null) return findSimpleValues(array, length, value, callbacks?.bool, mapBefore, mapAfter, result);
+	return findComplexValues({
+		array,
+		length,
+		mapAfter,
+		mapBefore,
+		result,
+		type,
+		value,
+		keyCallback: callbacks?.keyed
+	});
 }
 //#endregion
 //#region src/array/filter.ts
@@ -431,6 +454,21 @@ const arrayMatchStarts = /* @__PURE__ */ new Set([ARRAY_MATCH_COMPARISON_START,
 function endsWithArray(haystack, needle, key) {
 	return arrayMatchEndings.has(getPosition(haystack, needle, key)[1]);
 }
+function evaluatePosition(haystack, haystackLength, needle, needleLength, key) {
+	const callback = getArrayCallback(key);
+	const limit = haystackLength - needleLength + 1;
+	let needleValues = callback == null ? needle : needle.slice();
+	if (callback != null) for (let needleIndex = 0; needleIndex < needleLength; needleIndex += 1) needleValues[needleIndex] = callback(needle[needleIndex], needleIndex, needle);
+	for (let haystackIndex = 0; haystackIndex < limit; haystackIndex += 1) {
+		if (!inHaystack(haystack, haystackIndex, needleValues, 0, callback)) continue;
+		if (needleLength === 1) return [haystackIndex, getName(haystackIndex, haystackLength, needleLength)];
+		for (let needleIndex = 1; needleIndex < needleLength; needleIndex += 1) {
+			if (!inHaystack(haystack, haystackIndex, needleValues, needleIndex, callback)) break;
+			if (needleIndex === needleLength - 1) return [haystackIndex, getName(haystackIndex, haystackLength, needleLength)];
+		}
+	}
+	return arrayMatchOutside;
+}
 function getArrayComparison(haystack, needle, key) {
 	return getPosition(haystack, needle, key)[1];
 }
@@ -444,23 +482,12 @@ function getPosition(haystack, needle, key) {
 	const needleLength = needle.length;
 	if (haystackLength === 0 || needleLength === 0) return arrayMatchOutside;
 	if (needleLength > haystackLength) return arrayMatchOutside;
-	const callback = getArrayCallback(key);
-	const limit = haystackLength - needleLength + 1;
-	let needleValues = callback == null ? needle : needle.slice();
-	if (callback != null) for (let needleIndex = 0; needleIndex < needleLength; needleIndex += 1) needleValues[needleIndex] = callback(needle[needleIndex], needleIndex, needle);
-	for (let haystackIndex = 0; haystackIndex < limit; haystackIndex += 1) {
-		let haystackItem = haystack[haystackIndex];
-		let haystackValue = callback?.(haystackItem, haystackIndex, haystack) ?? haystackItem;
-		if (!Object.is(haystackValue, needleValues[0])) continue;
-		if (needleLength === 1) return [haystackIndex, getName(haystackIndex, haystackLength, needleLength)];
-		for (let needleIndex = 1; needleIndex < needleLength; needleIndex += 1) {
-			haystackItem = haystack[haystackIndex + needleIndex];
-			haystackValue = callback?.(haystackItem, haystackIndex + needleIndex, haystack) ?? haystackItem;
-			if (!Object.is(haystackValue, needleValues[needleIndex])) break;
-			if (needleIndex === needleLength - 1) return [haystackIndex, getName(haystackIndex, haystackLength, needleLength)];
-		}
-	}
-	return arrayMatchOutside;
+	return evaluatePosition(haystack, haystackLength, needle, needleLength, key);
+}
+function inHaystack(haystack, haystackIndex, needleValues, needleIndex, callback) {
+	const haystackItem = haystack[haystackIndex + needleIndex];
+	const haystackValue = callback?.(haystackItem, haystackIndex + needleIndex, haystack) ?? haystackItem;
+	return Object.is(haystackValue, needleValues[needleIndex]);
 }
 function includesArray(haystack, needle, key) {
 	return !arrayMatchOutsides.has(getPosition(haystack, needle, key)[1]);
@@ -501,12 +528,22 @@ function roundNumber(callback, value, decimals) {
 }
 //#endregion
 //#region src/internal/random.ts
+/**
+* Get a random number between 0 _(inclusive)_ and 1 _(exclusive)_
+*
+* @returns Random number
+*/
+function getRandom() {
+	/* istanbul ignore if */
+	if (globalThis.crypto == null) return Math.random();
+	return globalThis.crypto.getRandomValues(/* @__PURE__ */ new Uint32Array(1))[0] / RANDOM_DIVISOR;
+}
 function getRandomFloatingNumberValue(inclusive, minimum, maximum) {
 	let maxFloat = isNumber(maximum) && maximum <= Number.MAX_SAFE_INTEGER ? maximum : Number.MAX_SAFE_INTEGER;
 	let minFloat = isNumber(minimum) && minimum >= Number.MIN_SAFE_INTEGER ? minimum : Number.MIN_SAFE_INTEGER;
 	if (minFloat === maxFloat) return minFloat;
 	if (minFloat > maxFloat) [minFloat, maxFloat] = [maxFloat, minFloat];
-	return Math.random() * (maxFloat + (inclusive ? 1 : 0) - minFloat) + minFloat;
+	return getRandom() * (maxFloat + (inclusive ? 1 : 0) - minFloat) + minFloat;
 }
 /**
 * Get a random floating-point number
@@ -528,6 +565,7 @@ function getRandomFloatingNumber(minimum, maximum) {
 function getRandomInteger(minimum, maximum) {
 	return floor(getRandomFloatingNumberValue(true, minimum, maximum));
 }
+const RANDOM_DIVISOR = 2 ** 32;
 //#endregion
 //#region src/internal/array/shuffle.ts
 /**
@@ -554,8 +592,14 @@ function compareSets(type, first, second, key) {
 	const isDifference = type === ARRAY_SETS_COMPARE_DIFFERENCE;
 	const isIntersection = type === ARRAY_SETS_COMPARE_INTERSECTION;
 	const isUnion = type === ARRAY_SETS_COMPARE_UNION;
-	if (first.length === 0) return isDifference ? first.slice() : isIntersection ? [] : second.slice();
+	if (first.length === 0) {
+		if (isDifference) return first.slice();
+		return isIntersection ? [] : second.slice();
+	}
 	if (!Array.isArray(second) || second.length === 0) return isIntersection ? [] : first.slice();
+	return getComparison(first, second, isIntersection, isUnion, key);
+}
+function getComparison(first, second, isIntersection, isUnion, key) {
 	const callback = getArrayCallback(key);
 	const values = isUnion ? first : second;
 	let { length } = values;
@@ -668,7 +712,10 @@ function getAggregateCallback(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.count === 0) {
+		if (aggregation.array) return aggregation.first ? void 0 : [];
+		return NaN;
+	}
 	if (aggregation.array) {
 		const array = aggregation.items[aggregation.value];
 		return aggregation.first ? array[0] : array;
@@ -696,7 +743,7 @@ const aggregators = {
 //#endregion
 //#region src/internal/array/insert.ts
 function insertChunkedValues(type, array, items, start, deleteCount) {
-	const actualDeleteCount = deleteCount < 0 ? 0 : deleteCount;
+	const actualDeleteCount = max([deleteCount, 0]);
 	const actualStart = min([max([0, start]), array.length]);
 	const chunked = chunk(items);
 	const lastIndex = chunked.length - 1;
@@ -719,7 +766,7 @@ function insertValues(type, array, items, start, deleteCount) {
 //#endregion
 //#region src/array/insert.ts
 function insert(array, indexOrItems, items) {
-	return insertValues(ARRAY_INSERT_TYPE_INSERT, array, items == null ? indexOrItems : items, typeof indexOrItems === "number" ? indexOrItems : array?.length, 0);
+	return insertValues(ARRAY_INSERT_TYPE_INSERT, array, items ?? indexOrItems, typeof indexOrItems === "number" ? indexOrItems : array?.length, 0);
 }
 //#endregion
 //#region src/array/intersection.ts
@@ -789,34 +836,47 @@ function extract(type, array, first, second) {
 	if (!Array.isArray(array)) return [];
 	const { length } = array;
 	if (length === 0) return [];
-	const isTake = type === ARRAY_SLICE_TAKE;
-	if (typeof first === "number") {
-		if (Math.abs(first) >= length) return isTake ? array.slice() : [];
-		if (first === 0) return isTake ? [] : array.slice();
-		if (isTake) return first >= 0 ? array.slice(0, first) : array.slice(array.length + first);
-		return first >= 0 ? array.slice(first) : array.slice(0, array.length + first);
-	}
-	const callbacks = second == null ? getArrayCallbacks(first) : getArrayCallbacks(void 0, void 0, first);
+	const take = type === ARRAY_SLICE_TAKE;
+	return typeof first === "number" ? getSlice(array, length, first, take) : extractSlice(array, length, first, second, take);
+}
+function extractSlice(array, length, first, second, take) {
+	const callbacks = getCallbacks(first, second);
+	if (callbacks?.bool == null && callbacks?.value == null) return take ? array.slice() : [];
 	const isBoolean = callbacks?.bool != null;
-	if (callbacks?.bool == null && callbacks?.value == null) return isTake ? array.slice() : [];
 	const extracted = [];
 	let push = false;
 	for (let index = 0; index < length; index += 1) {
 		const item = array[index];
-		const matches = isBoolean ? callbacks.bool(item, index, array) : Object.is(callbacks.value(item, index, array), second);
-		if (isTake) {
-			if (isBoolean ? !matches : matches) break;
+		const matches = isMatch(item, index, array, callbacks, second, isBoolean);
+		const reached = isBoolean ? !matches : matches;
+		if (take && reached) break;
+		if (push || take) {
 			extracted.push(item);
 			continue;
 		}
-		if (push) extracted.push(item);
-		else if (isBoolean ? !matches : matches) {
+		if (reached) {
 			push = true;
 			if (isBoolean) extracted.push(item);
 		}
 	}
 	return extracted;
 }
+function getCallbacks(first, second) {
+	let callbacks;
+	if (second == null) callbacks = getArrayCallbacks(first);
+	else callbacks = getArrayCallbacks(void 0, void 0, first);
+	return callbacks;
+}
+function getSlice(array, length, amount, take) {
+	if (Math.abs(amount) >= length) return take ? array.slice() : [];
+	if (amount === 0) return take ? [] : array.slice();
+	if (take) return amount >= 0 ? array.slice(0, amount) : array.slice(length + amount);
+	return amount >= 0 ? array.slice(amount) : array.slice(0, length + amount);
+}
+function isMatch(item, index, array, callbacks, second, isBoolean) {
+	if (isBoolean) return callbacks.bool(item, index, array);
+	return Object.is(callbacks.value(item, index, array), second);
+}
 function slice(array, first, second) {
 	if (!Array.isArray(array) || array.length === 0) return [];
 	const firstIsNumber = typeof first === "number";
@@ -1022,7 +1082,7 @@ const VALUE_MISC_NESTED_MESSAGE_UNSAFE = "Access to this property is not allowed
 //#endregion
 //#region src/models/string/string.misc.model.ts
 const STRING_EXPRESSION_IGNORED = /(^|\.)(__proto__|constructor|prototype)(\.|$)/i;
-const STRING_EXPRESSION_WORDS = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
+const STRING_EXPRESSION_WORDS = /([^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+)/g;
 const STRING_EXPRESSION_WHITESPACE_PREFIX = /^(\s+)/;
 const STRING_MATCH_ENDS_WITH = "endsWith";
 const STRING_MATCH_INCLUDES = "includes";
@@ -1079,18 +1139,11 @@ 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);
+	if (!isResult(actual)) throw new TypeError(RESULT_MESSAGE_PROMISE);
+	if (isOk(actual)) return actual.value;
+	throw actual.error;
 }
 const RESULT_MESSAGE_PROMISE = "toPromise expected to receive a Result";
 //#endregion
@@ -1102,15 +1155,15 @@ async function asyncAttempt(value, err) {
 		else result = value;
 		if (result instanceof Promise) result = await result;
 		return ok(result);
-	} catch (thrown) {
-		return getError(err ?? thrown, err == null ? void 0 : thrown);
+	} catch (error) {
+		return getError(err ?? error, err == null ? void 0 : error);
 	}
 }
 function attempt(callback, err) {
 	try {
 		return ok(callback());
-	} catch (thrown) {
-		return getError(err ?? thrown, err == null ? void 0 : thrown);
+	} catch (error) {
+		return getError(err ?? error, err == null ? void 0 : error);
 	}
 }
 attempt.async = asyncAttempt;
@@ -1189,7 +1242,8 @@ function tryEncode(value) {
 * @returns Array of words found in the string
 */
 function words(value) {
-	return typeof value === "string" ? value.match(STRING_EXPRESSION_WORDS) ?? [] : [];
+	if (typeof value === "string") return value.match(STRING_EXPRESSION_WORDS) ?? [];
+	return [];
 }
 //#endregion
 //#region src/internal/value/handlers.ts
@@ -1442,7 +1496,7 @@ function isSortedArray(array) {
 	let offset = 0;
 	if (length >= 100) {
 		offset = round(length / 10);
-		offset = offset > 100 ? 100 : offset;
+		offset = min([offset, 100]);
 		for (let index = 0; index < offset; index += 1) {
 			const [firstItem, firstOffset] = [array[index], array[index + 1]];
 			const [secondItem, secondOffset] = [array[length - index - 2], array[length - index - 1]];
@@ -2088,8 +2142,11 @@ async function asyncRetry(callback, options) {
 	if (typeof callback !== "function") throw new TypeError(RETRY_MESSAGE_EXPECTATION);
 	async function handle() {
 		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));
+		if (result.ok) {
+			resolver(result.value);
+			return;
+		}
+		if (attempts >= times || !when(result.error)) rejector(new RetryError(RETRY_MESSAGE_FAILED, result.error));
 		else {
 			attempts += 1;
 			limiter.run();
@@ -2160,7 +2217,7 @@ const EXPRESSION_WHITESPACE_ONLY = /^\s*$/;
 *
 * @param value Value to check
 * @param minimum Minimum value
-* @param maximum Maximum value
+* @param maximum Maximum value _(inclusive)_
 * @returns `true` if the value is between the minimum and maximum, otherwise `false`
 */
 function between(value, minimum, maximum) {
@@ -2170,7 +2227,8 @@ function between(value, minimum, maximum) {
 		maximum
 	].every(isNumber)) return false;
 	if (Object.is(minimum, maximum)) return Object.is(value, minimum);
-	return value >= (maximum > minimum ? minimum : maximum) && value <= (maximum > minimum ? maximum : minimum);
+	const maximumValue = max([maximum, minimum]);
+	return value >= min([maximum, minimum]) && value <= maximumValue;
 }
 /**
 * Clamp a number between a minimum and maximum value
@@ -2619,7 +2677,7 @@ function equalArray(first, second, options) {
 	let offset = 0;
 	if (length >= 100) {
 		offset = round(length / 10);
-		offset = offset > 100 ? 100 : offset;
+		offset = min([offset, 100]);
 		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;
 	}
 	const end = length - offset;
@@ -2768,57 +2826,23 @@ function setValue(data, path, value, ignoreCase) {
 }
 //#endregion
 //#region src/models/plan.model.ts
-const GENERATOR_NAME_ASYNC = "AsyncGeneratorFunction";
-const GENERATOR_NAME_SYNC = "GeneratorFunction";
+const GENERATOR_FUNCTION_TYPE_ASYNC = "[object AsyncGeneratorFunction]";
+const GENERATOR_FUNCTION_TYPE_SYNC = "[object GeneratorFunction]";
+const GENERATOR_TYPE_ASYNC = "[object AsyncGenerator]";
+const GENERATOR_TYPE_SYNC = "[object Generator]";
+const PLAN_FAILURE_ASYNC = "asyncFailure";
+const PLAN_FAILURE_SYNC = "failure";
 const PLAN_MESSAGE_PLAN_INPUT = "plan requires a generator function";
 const PLAN_MESSAGE_RUN_INPUT = "run requires a plan or a generator function";
+const PLAN_MESSAGE_USE_NESTED_FN = "Cannot use nested functions with 'use'";
+const PLAN_MESSAGE_USE_SYNC_ASYNC = "Cannot use asynchronous values with 'use'";
+const PLAN_STEP_ASYNC = "asyncStep";
+const PLAN_STEP_SYNC = "step";
+const PLAN_SUCCESS_ASYNC = "asyncSuccess";
+const PLAN_SUCCESS_SYNC = "success";
 const PLAN_SYMBOL = Symbol("plan");
-const PLAN_TYPE_PLAN_ASYNC = "asyncPlan";
-const PLAN_TYPE_PLAN_SYNC = "plan";
-//#endregion
-//#region src/plan/is.ts
-/**
-* Is the value an asynchronous generator function?
-*
-* @param value Value to check
-* @returns `true` if the value is an asynchronous generator function, otherwise `false`
-*/
-function isAsyncGenerator(value) {
-	return isGeneratorInstance(GENERATOR_NAME_ASYNC, value);
-}
-/**
-* Is the value an asynchronous plan?
-*
-* @param value Value to check
-* @returns `true` if the value is an asynchronous plan, otherwise `false`
-*/
-function isAsyncPlan(value) {
-	return isPlanInstance(PLAN_TYPE_PLAN_ASYNC, value);
-}
-/**
-* Is the value a generator function?
-*
-* @param value Value to check
-* @returns `true` if the value is a generator function, otherwise `false`
-*/
-function isGenerator(value) {
-	return isGeneratorInstance(GENERATOR_NAME_SYNC, value);
-}
-function isGeneratorInstance(name, value) {
-	return typeof value === "function" && value !== null && value.constructor.name === name && typeof value.prototype.next === "function" && typeof value.prototype.return === "function" && typeof value.prototype.throw === "function";
-}
-/**
-* Is the value a plan?
-*
-* @param value Value to check
-* @returns `true` if the value is a plan, otherwise `false`
-*/
-function isPlan(value) {
-	return isPlanInstance(PLAN_TYPE_PLAN_SYNC, value);
-}
-function isPlanInstance(type, value) {
-	return typeof value === "object" && value !== null && PLAN_SYMBOL in value && value[PLAN_SYMBOL].type === type;
-}
+const PLAN_TYPE_ASYNC = "asyncPlan";
+const PLAN_TYPE_SYNC = "plan";
 //#endregion
 //#region src/models/aborter.model.ts
 const ABORTER_EVENT = "abort";
@@ -2835,10 +2859,10 @@ function createAborter(value, onAbort) {
 	};
 }
 //#endregion
-//#region src/plan/generate.ts
+//#region src/internal/plan/plan.generate.ts
 async function asyncGenerate(input, unwrap, first, second) {
 	const aborter = createAborter(second ?? first, noop);
-	if (aborter != null && aborter.signal.aborted) throw aborter.signal.reason;
+	if (aborter?.signal.aborted) throw aborter.signal.reason;
 	const parameters = Array.isArray(first) ? first : [];
 	let generator;
 	if (typeof input === "function") generator = input(...parameters);
@@ -2847,7 +2871,7 @@ async function asyncGenerate(input, unwrap, first, second) {
 	let lastValue;
 	try {
 		while (true) {
-			if (aborter != null && aborter.signal.aborted) await generator.throw(aborter.signal.reason);
+			if (aborter?.signal.aborted) await generator.throw(aborter.signal.reason);
 			const next = await generator.next(lastValue);
 			const done = next.done === true;
 			const { value } = next;
@@ -2863,7 +2887,7 @@ async function asyncGenerate(input, unwrap, first, second) {
 		aborter?.cancel();
 		await generator.return(lastValue);
 	}
-	if (aborter != null && aborter.signal.aborted) throw aborter.signal.reason;
+	if (aborter?.signal.aborted) throw aborter.signal.reason;
 	if (success) return unwrap && isOk(lastValue) ? lastValue.value : lastValue;
 	throw lastValue;
 }
@@ -2893,114 +2917,310 @@ function generate(input, parameters, unwrap) {
 	throw lastValue;
 }
 //#endregion
+//#region src/internal/plan/index.ts
+function attemptRunPlan(...parameters) {
+	return attempt(() => generate(this[PLAN_SYMBOL], parameters, true));
+}
+function getGenerator() {
+	return this[PLAN_SYMBOL].generator();
+}
+function runAsyncPlan(first, second) {
+	return asyncGenerate(this[PLAN_SYMBOL], false, first, second);
+}
+function runPlan(...parameters) {
+	return generate(this[PLAN_SYMBOL], parameters, false);
+}
+//#endregion
+//#region src/plan/is.ts
+/**
+* Is the value an asynchronous, immediately failing plan?
+*
+* @param value Value to check
+* @returns `true` if the value is an asynchronous, immediately failing plan, otherwise `false`
+*/
+function isAsyncFailure(value) {
+	return isPlanInstance(PLAN_FAILURE_ASYNC, value);
+}
+/**
+* Is the value an asynchronous generator?
+*
+* @param value Value to check
+* @returns `true` if the value is an asynchronous generator, otherwise `false`
+*/
+function isAsyncGenerator(value) {
+	return isGeneratorInstance(GENERATOR_TYPE_ASYNC, value);
+}
+/**
+* Is the value an asynchronous generator function?
+*
+* @param value Value to check
+* @returns `true` if the value is an asynchronous generator function, otherwise `false`
+*/
+function isAsyncGeneratorFunction(value) {
+	return isGeneratorInstance(GENERATOR_FUNCTION_TYPE_ASYNC, value);
+}
+/**
+* Is the value an asynchronous plan?
+*
+* @param value Value to check
+* @returns `true` if the value is an asynchronous plan, otherwise `false`
+*/
+function isAsyncPlan(value) {
+	return isPlanInstance(PLAN_TYPE_ASYNC, value);
+}
+/**
+* Is the value an asynchronous step?
+*
+* @param value Value to check
+* @returns `true` if the value is an asynchronous step, otherwise `false`
+*/
+function isAsyncStep(value) {
+	return isPlanInstance(PLAN_STEP_ASYNC, value);
+}
+/**
+* Is the value an asynchronous, immediately successful plan?
+*
+* @param value Value to check
+* @returns `true` if the value is an asynchronous, immediately successful plan, otherwise `false`
+*/
+function isAsyncSuccess(value) {
+	return isPlanInstance(PLAN_SUCCESS_ASYNC, value);
+}
+/**
+* Is the value an immediately failing plan?
+*
+* @param value Value to check
+* @returns `true` if the value is an immediately failing plan, otherwise `false`
+*/
+function isFailure(value) {
+	return isPlanInstance(PLAN_FAILURE_SYNC, value);
+}
+/**
+* Is the value a generator?
+*
+* @param value Value to check
+* @returns `true` if the value is a generator, otherwise `false`
+*/
+function isGenerator(value) {
+	return isGeneratorInstance(GENERATOR_TYPE_SYNC, value);
+}
+/**
+* Is the value a generator function?
+*
+* @param value Value to check
+* @returns `true` if the value is a generator function, otherwise `false`
+*/
+function isGeneratorFunction(value) {
+	return isGeneratorInstance(GENERATOR_FUNCTION_TYPE_SYNC, value);
+}
+function isGeneratorInstance(type, value) {
+	return Object.prototype.toString.call(value) === type;
+}
+/**
+* Is the value a plan?
+*
+* @param value Value to check
+* @returns `true` if the value is a plan, otherwise `false`
+*/
+function isPlan(value) {
+	return isPlanInstance(PLAN_TYPE_SYNC, value);
+}
+function isPlanInstance(type, value) {
+	return typeof value === "object" && value !== null && PLAN_SYMBOL in value && value[PLAN_SYMBOL].type === type;
+}
+/**
+* Is the value a step?
+*
+* @param value Value to check
+* @returns `true` if the value is a step, otherwise `false`
+*/
+function isStep(value) {
+	return isPlanInstance(PLAN_STEP_SYNC, value);
+}
+/**
+* Is the value an immediately successful plan?
+*
+* @param value Value to check
+* @returns `true` if the value is an immediately successful plan, otherwise `false`
+*/
+function isSuccess(value) {
+	return isPlanInstance(PLAN_SUCCESS_SYNC, value);
+}
+//#endregion
 //#region src/plan/result.ts
 function asyncAttemptRun(input, first, second) {
 	let generator;
 	if (isAsyncPlan(input)) generator = input[PLAN_SYMBOL];
-	else if (isAsyncGenerator(input)) generator = input;
+	else if (isAsyncGeneratorFunction(input)) generator = input;
 	if (generator == null) throw new Error(PLAN_MESSAGE_RUN_INPUT);
 	return asyncAttempt(() => asyncGenerate(generator, true, first, second));
 }
 function attemptRun(input, ...parameters) {
 	let generator;
 	if (isPlan(input)) generator = input[PLAN_SYMBOL];
-	else if (isGenerator(input)) generator = input;
+	else if (isGeneratorFunction(input)) generator = input;
 	if (generator == null) throw new Error(PLAN_MESSAGE_RUN_INPUT);
 	return attempt(() => generate(generator, parameters, true));
 }
-function attemptRunAsyncPlan(first, second) {
-	return asyncAttemptRun(this, first, second);
-}
-function attemptRunPlan(...parameters) {
-	return attempt(() => generate(this[PLAN_SYMBOL], parameters, true));
-}
 attemptRun.async = asyncAttemptRun;
 //#endregion
-//#region src/plan/run.ts
-function asyncRun(input, first, second) {
-	if (isAsyncPlan(input)) return asyncGenerate(input[PLAN_SYMBOL], false, first, second);
-	if (isAsyncGenerator(input)) return asyncGenerate(input, false, first, second);
-	throw new Error(PLAN_MESSAGE_RUN_INPUT);
-}
-function run(input, ...parameters) {
-	if (isPlan(input)) return input.run(...parameters);
-	if (isGenerator(input)) return generate(input, parameters, false);
-	throw new Error(PLAN_MESSAGE_RUN_INPUT);
-}
-function runAsyncPlan(first, second) {
-	return asyncGenerate(this[PLAN_SYMBOL], false, first, second);
-}
-function runPlan(...parameters) {
-	return generate(this[PLAN_SYMBOL], parameters, false);
-}
-asyncRun.attempt = asyncAttemptRun;
-run.async = asyncRun;
-run.attempt = attemptRun;
-//#endregion
 //#region src/plan/index.ts
 function AsyncPlan(generator) {
 	this[PLAN_SYMBOL] = {
 		generator,
-		type: PLAN_TYPE_PLAN_ASYNC
+		type: PLAN_TYPE_ASYNC
 	};
 }
-AsyncPlan.prototype[Symbol.asyncIterator] = function() {
-	return this[PLAN_SYMBOL].generator();
-};
+AsyncPlan.prototype[Symbol.asyncIterator] = getGenerator;
 AsyncPlan.prototype.attempt = attemptRunAsyncPlan;
 AsyncPlan.prototype.run = runAsyncPlan;
 function Plan(generator) {
 	this[PLAN_SYMBOL] = {
 		generator,
-		type: PLAN_TYPE_PLAN_SYNC
+		type: PLAN_TYPE_SYNC
 	};
 }
-Plan.prototype[Symbol.iterator] = function() {
-	return this[PLAN_SYMBOL].generator();
-};
+Plan.prototype[Symbol.iterator] = getGenerator;
 Plan.prototype.attempt = attemptRunPlan;
 Plan.prototype.run = runPlan;
+function attemptRunAsyncPlan(first, second) {
+	return asyncAttemptRun(this, first, second);
+}
 function plan(generator) {
-	if (isAsyncGenerator(generator)) return new AsyncPlan(generator);
-	if (isGenerator(generator)) return new Plan(generator);
+	if (isAsyncGeneratorFunction(generator)) return new AsyncPlan(generator);
+	if (isGeneratorFunction(generator)) return new Plan(generator);
 	throw new Error(PLAN_MESSAGE_PLAN_INPUT);
 }
 //#endregion
 //#region src/plan/misc.ts
-function PlanFailure(generator) {
-	this[PLAN_SYMBOL] = { generator };
+function AsyncFailure(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_FAILURE_ASYNC
+	};
 }
-PlanFailure.prototype[Symbol.iterator] = function() {
-	return this[PLAN_SYMBOL].generator();
-};
-function PlanSuccess(generator) {
-	this[PLAN_SYMBOL] = { generator };
+AsyncFailure.prototype[Symbol.asyncIterator] = getGenerator;
+function AsyncSuccess(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_SUCCESS_ASYNC
+	};
+}
+AsyncSuccess.prototype[Symbol.asyncIterator] = getGenerator;
+function Failure(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_FAILURE_SYNC
+	};
+}
+Failure.prototype[Symbol.iterator] = getGenerator;
+function Success(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_SUCCESS_SYNC
+	};
+}
+Success.prototype[Symbol.iterator] = getGenerator;
+function asyncFail(value) {
+	return new AsyncFailure(async function* () {
+		yield error(await (typeof value === "function" ? value() : value));
+	});
+}
+function asyncSucceed(value) {
+	return new AsyncSuccess(async function* () {
+		return typeof value === "function" ? value() : value;
+	});
 }
-PlanSuccess.prototype[Symbol.iterator] = function() {
-	return this[PLAN_SYMBOL].generator();
-};
-/**
-* Create an immediately failing plan
-*
-* @param value Failure value
-* @returns Plan failure
-*/
 function fail(value) {
-	return new PlanFailure(function* () {
-		yield error(value);
+	return new Failure(function* () {
+		yield error(typeof value === "function" ? value() : value);
 	});
 }
-/**
-* Create an immediately succeeding plan
-*
-* @param value Success value
-* @returns Plan success
-*/
 function succeed(value) {
-	return new PlanSuccess(function* () {
-		return value;
+	return new Success(function* () {
+		return typeof value === "function" ? value() : value;
+	});
+}
+fail.async = asyncFail;
+succeed.async = asyncSucceed;
+//#endregion
+//#region src/plan/run.ts
+function asyncRun(input, first, second) {
+	if (isAsyncPlan(input)) return asyncGenerate(input[PLAN_SYMBOL], false, first, second);
+	if (isAsyncGeneratorFunction(input)) return asyncGenerate(input, false, first, second);
+	throw new Error(PLAN_MESSAGE_RUN_INPUT);
+}
+function run(input, ...parameters) {
+	if (isPlan(input)) return input.run(...parameters);
+	if (isGeneratorFunction(input)) return generate(input, parameters, false);
+	throw new Error(PLAN_MESSAGE_RUN_INPUT);
+}
+asyncRun.attempt = asyncAttemptRun;
+run.async = asyncRun;
+run.attempt = attemptRun;
+//#endregion
+//#region src/plan/use.ts
+function AsyncStep(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_STEP_ASYNC
+	};
+}
+AsyncStep.prototype[Symbol.asyncIterator] = getGenerator;
+function Step(generator) {
+	this[PLAN_SYMBOL] = {
+		generator,
+		type: PLAN_STEP_SYNC
+	};
+}
+Step.prototype[Symbol.iterator] = getGenerator;
+function asyncUse(value) {
+	return new AsyncStep(async function* () {
+		let actual = value;
+		if (typeof actual === "function") actual = actual();
+		actual = await actual;
+		if (typeof actual === "function") throw new TypeError(PLAN_MESSAGE_USE_NESTED_FN);
+		if (typeof actual === "object" && actual !== null && PLAN_SYMBOL in actual) return yield* actual;
+		if (isAsyncGenerator(actual) || isGenerator(actual)) return yield* actual;
+		if (isError(actual)) {
+			yield* fail(actual.error);
+			return;
+		}
+		if (isOk(actual)) return actual.value;
+		if (actual instanceof Error) {
+			yield* fail(actual);
+			return;
+		}
+		return actual;
+	});
+}
+function use(value) {
+	validateUseInput(value, false);
+	return new Step(function* () {
+		let actual = value;
+		if (typeof actual === "function") {
+			actual = actual();
+			validateUseInput(actual, true);
+		}
+		if (typeof actual === "object" && actual !== null && PLAN_SYMBOL in actual) return yield* actual;
+		if (isGenerator(actual)) return yield* actual;
+		if (isError(actual)) {
+			yield* fail(actual.error);
+			return;
+		}
+		if (isOk(actual)) return actual.value;
+		if (actual instanceof Error) {
+			yield* fail(actual);
+			return;
+		}
+		return actual;
 	});
 }
+function validateUseInput(value, resolved) {
+	if (value instanceof Promise || isAsyncFailure(value) || isAsyncGenerator(value) || isAsyncGeneratorFunction(value) || isAsyncPlan(value) || isAsyncStep(value) || isAsyncSuccess(value)) throw new Error(PLAN_MESSAGE_USE_SYNC_ASYNC);
+	if (resolved && typeof value === "function") throw new Error(PLAN_MESSAGE_USE_NESTED_FN);
+}
+use.async = asyncUse;
 //#endregion
 //#region src/models/promise.model.ts
 /**
@@ -3125,13 +3345,16 @@ function handleResult(status, parameters) {
 		handlers.reject(value);
 		return;
 	}
-	data.result[key] = !complete ? value : status === "fulfilled" ? {
+	let resultValue;
+	if (complete) resultValue = status === "fulfilled" ? {
 		status,
 		value
 	} : {
 		status,
 		reason: value
 	};
+	else resultValue = value;
+	data.result[key] = resultValue;
 	if (index === data.last) {
 		aborter?.cancel();
 		handlers.resolve(data.result);
@@ -3143,7 +3366,7 @@ function settlePromise(settler, value, aborter) {
 }
 async function toResult(value) {
 	const actual = typeof value === "function" ? value() : value;
-	if (!(actual instanceof Promise)) return Promise.reject(/* @__PURE__ */ new TypeError(PROMISE_MESSAGE_EXPECTATION_RESULT));
+	if (!(actual instanceof Promise)) throw new TypeError(PROMISE_MESSAGE_EXPECTATION_RESULT);
 	return actual.then((result) => ok(result)).catch((reason) => error(reason));
 }
 //#endregion
@@ -3185,18 +3408,18 @@ async function getTimedPromise(promise, time, signal) {
 	});
 }
 async function timed(promise, options) {
-	if (!(promise instanceof Promise)) return Promise.reject(/* @__PURE__ */ new TypeError(PROMISE_MESSAGE_EXPECTATION_TIMED));
+	if (!(promise instanceof Promise)) throw new TypeError(PROMISE_MESSAGE_EXPECTATION_TIMED);
 	const { signal, time } = createPromiseOptions(options);
-	if (signal?.aborted ?? false) return Promise.reject(signal?.reason);
+	if (signal?.aborted ?? false) throw signal?.reason;
 	return time > 0 ? getTimedPromise(promise, time, signal) : promise;
 }
 //#endregion
 //#region src/promise/index.ts
 async function attemptPromise(value, options) {
 	const isFunction = typeof value === "function";
-	if (!isFunction && !(value instanceof Promise)) return Promise.reject(/* @__PURE__ */ new TypeError(PROMISE_MESSAGE_EXPECTATION_ATTEMPT));
+	if (!isFunction && !(value instanceof Promise)) throw new TypeError(PROMISE_MESSAGE_EXPECTATION_ATTEMPT);
 	const { signal, time } = createPromiseOptions(options);
-	if (signal?.aborted ?? false) return Promise.reject(signal?.reason);
+	if (signal?.aborted ?? false) throw signal?.reason;
 	const aborter = createAborter(signal, () => {
 		rejector(signal?.reason);
 	});
@@ -3218,8 +3441,8 @@ async function attemptPromise(value, options) {
 }
 async function promises(items, options) {
 	const { signal, strategy } = createPromisesOptions(options);
-	if (signal?.aborted ?? false) return Promise.reject(signal?.reason);
-	if (!isArrayOrPlainObject(items)) return Promise.reject(PROMISE_MESSAGE_EXPECTATION_ITEMS_TYPE);
+	if (signal?.aborted ?? false) throw signal?.reason;
+	if (!isArrayOrPlainObject(items)) throw new TypeError(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 aborter = createAborter(signal, () => {
@@ -3282,10 +3505,10 @@ function handleResult$1(result, first, second) {
 		error = second;
 	}
 	if (isOk(result)) {
-		if (typeof ok !== "function") throw new Error(MATCH_MESSAGE_OK);
+		if (typeof ok !== "function") throw new TypeError(MATCH_MESSAGE_OK);
 		return ok(result.value);
 	}
-	if (typeof error !== "function") throw new Error(MATCH_MESSAGE_ERROR);
+	if (typeof error !== "function") throw new TypeError(MATCH_MESSAGE_ERROR);
 	return error(result.error, result.original);
 }
 function matchResult(result, first, second) {
@@ -3323,9 +3546,11 @@ attemptFlow.async = attemptAsyncFlow;
 //#endregion
 //#region src/result/work/pipe.ts
 async function attemptAsyncPipe(initial, first, ...seconds) {
-	return asyncAttempt(() => {
+	return asyncAttempt(async () => {
 		if (isError(initial)) throw initial.error;
-		const value = typeof initial === "function" ? initial() : isOk(initial) ? initial.value : initial;
+		let value;
+		if (typeof initial === "function") value = initial();
+		else value = isOk(initial) ? initial.value : initial;
 		if (first == null) return value;
 		return asyncPipe(value, ...[first, ...seconds]);
 	});
@@ -3333,7 +3558,9 @@ async function attemptAsyncPipe(initial, first, ...seconds) {
 function attemptPipe(initial, first, ...seconds) {
 	return attempt(() => {
 		if (isError(initial)) throw initial.error;
-		const value = typeof initial === "function" ? initial() : isOk(initial) ? initial.value : initial;
+		let value;
+		if (typeof initial === "function") value = initial();
+		else value = isOk(initial) ? initial.value : initial;
 		if (first == null) return value;
 		return pipe(value, ...[first, ...seconds]);
 	});
@@ -3408,7 +3635,7 @@ Object.defineProperties(Fuzzy.prototype, {
 	}
 });
 function createFuzzyItems(items) {
-	return items.sort((first, second) => first.haystack.localeCompare(second.haystack)).map(({ item }) => item);
+	return items.toSorted((first, second) => first.haystack.localeCompare(second.haystack)).map(({ item }) => item);
 }
 function createFuzzyOptions(input, state) {
 	const options = isPlainObject(input) ? input : {};
@@ -3591,7 +3818,7 @@ function dedent(value, ...values) {
 	}
 	if (lengths.length === 0) return actual.trim();
 	const minimum = min(lengths);
-	const pattern = new RegExp(`^\\s{0,${minimum}}`);
+	const pattern = new RegExp(String.raw`^\s{0,${minimum}}`);
 	let result = "";
 	for (let index = 0; index < length; index += 1) {
 		const line = lines[index];
@@ -3860,7 +4087,7 @@ function clone(value, options) {
 function cloneAny(value, parameters, depth, options) {
 	switch (true) {
 		case value === null || CLONE_PRIMITIVES[typeof value]: return value;
-		case value instanceof Date: return new Date(value.getTime());
+		case value instanceof Date: return new Date(value);
 		case typeof value === "function":
 			parameters.options ??= createCloneOptions(options);
 			return parameters.options.copyFunctions ? value : void 0;
@@ -4224,7 +4451,9 @@ freeze.is = isFrozen;
 //#region src/internal/value/partial.ts
 function partial(value, providedKeys, omit) {
 	if (!isPlainObject(value)) return {};
-	const keys = omit ? Object.keys(value) : Array.isArray(providedKeys) ? providedKeys : [];
+	let keys;
+	if (omit) keys = Object.keys(value);
+	else keys = Array.isArray(providedKeys) ? providedKeys : [];
 	const { length } = keys;
 	if (length === 0) return omit ? value : {};
 	const partials = {};
@@ -4397,6 +4626,12 @@ function createMergingOptions(input) {
 	actual.skipNullableInArrays = options.skipNullableInArrays === true;
 	return actual;
 }
+function getFullKey(prefix, key, options) {
+	let full;
+	if (options.replaceableObjects == null) full = void 0;
+	else full = prefix == null ? key : `${prefix}.${key}`;
+	return full;
+}
 function getReplaceableObjects(value) {
 	const items = (Array.isArray(value) ? value : [value]).filter((item) => typeof item === "string" || item instanceof RegExp);
 	if (items.length === 0) return;
@@ -4424,6 +4659,9 @@ function initializeAssigner(options) {
 function initializeMerger(options) {
 	return new Merger(createMergingOptions(options));
 }
+function isMergeable(next, previous, options, full) {
+	return isArrayOrPlainObject(next) && isArrayOrPlainObject(previous) && !(options.replaceableObjects?.(full) ?? false);
+}
 /**
 * Merge multiple arrays or objects into a single one
 *
@@ -4450,9 +4688,9 @@ function mergeObjects(values, options, destination, prefix) {
 			const key = keys[innerIndex];
 			const next = item[key];
 			const previous = merged[key];
-			if (next == null && (options.skipNullableAny || isArray && options.skipNullableInArrays)) continue;
-			const full = options.replaceableObjects == null ? void 0 : prefix == null ? key : `${prefix}.${key}`;
-			if (isArrayOrPlainObject(next) && isArrayOrPlainObject(previous) && !(options.replaceableObjects?.(full) ?? false)) merged[key] = mergeObjects([previous, next], options, destination == null ? void 0 : merged[key], full);
+			if (skipMerge(next, options, isArray)) continue;
+			const fullKey = getFullKey(prefix, key, options);
+			if (isMergeable(next, previous, options, fullKey)) merged[key] = mergeObjects([previous, next], options, destination == null ? void 0 : merged[key], fullKey);
 			else merged[key] = next;
 		}
 	}
@@ -4464,7 +4702,11 @@ function mergeValues(values, options, prefix) {
 	if (actual.length === 0) return {};
 	if (options.assignValues && actual.length === 2 && !Array.isArray(actual[0]) && Object.keys(actual[0]).length === 0) return Object.assign(actual[0], actual[1]);
 	if (actual.length > 1) return mergeObjects(actual, options, options.assignValues ? actual[0] : void 0, prefix);
-	return options.assignValues ? actual[0] : Array.isArray(actual[0]) ? actual[0].slice() : { ...actual[0] };
+	if (options.assignValues) return actual[0];
+	return Array.isArray(actual[0]) ? actual[0].slice() : { ...actual[0] };
+}
+function skipMerge(next, options, isArray) {
+	return next == null && (options.skipNullableAny || isArray && options.skipNullableInArrays);
 }
 assign.initialize = initializeAssigner;
 merge.initialize = initializeMerger;
@@ -4645,7 +4887,7 @@ function createSubscriptionsProperty(input) {
 	const values = isPlainObject(input) ? input : {};
 	return {
 		key: typeof values.key === "string" ? values.key : SUBSCRIPTION_PROPERTY,
-		value: values.value == null ? SUBSCRIPTION_NAME : values.value
+		value: values.value ?? "subscription"
 	};
 }
 function createSubscriptionsState(property, keys) {
@@ -5180,7 +5422,8 @@ function setColorAlpha(value) {
 //#endregion
 //#region src/color/misc/get.ts
 function getClampedValue(value, minimum, maximum, rounding) {
-	return typeof value === "number" && !Number.isNaN(value) ? clamp(rounding ?? false ? round(value) : value, minimum, maximum) : minimum;
+	if (typeof value !== "number" || Number.isNaN(value)) return minimum;
+	return clamp(rounding ?? false ? round(value) : value, minimum, maximum);
 }
 function getForegroundColor(value, hex) {
 	const { blue, green, red } = getColorFromState(getColorState(value), COLOR_TYPE.rgb);
@@ -5688,7 +5931,7 @@ function getHexaColor$1() {
 * @returns Normalized hex color
 */
 function getNormalizedHex(value, alpha) {
-	const includeAlpha = alpha ?? false;
+	const includeAlpha = alpha === true;
 	if (!isHexColor(value)) return `${COLOR_DEFAULTS.hexBlack}${includeAlpha ? COLOR_ALPHA.fullHexLong : ""}`;
 	const normalized = value.replace(COLOR_EXPRESSION.prefix, "");
 	if (normalized.length < COLOR_LENGTHS.hexLong) return join(`${normalized.slice(0, COLOR_LENGTHS.hexShort)}${includeAlpha ? normalized[COLOR_LENGTHS.hexShort] ?? COLOR_ALPHA.fullHexShort : ""}`.split("").map((character) => character.repeat(2)));
@@ -6968,14 +7211,13 @@ async function run$1(state) {
 	state.runners += 1;
 	let item = state.items.shift();
 	while (item != null) {
+		const next = item;
 		let error = false;
 		let result;
 		const attempted = await asyncAttempt(async () => {
-			if (item != null && !(item.aborter?.signal?.aborted ?? false)) {
-				const parameters = item.key == null ? item.parameters : [item.key, ...item.parameters];
-				return await state.callback(...parameters);
-			}
-			throw new Error();
+			if (next.aborter?.signal?.aborted) throw next.aborter.signal.reason;
+			const parameters = next.key == null ? next.parameters : [next.key, ...next.parameters];
+			return await state.callback(...parameters);
 		});
 		if (attempted.ok) result = attempted.value;
 		else {
@@ -7006,7 +7248,7 @@ const RANDOM_HEX_CHARACTERS = "0123456789ABCDEF";
 * @returns Random boolean
 */
 function getRandomBoolean() {
-	return Math.random() > RANDOM_BOOLEAN_MODIFIER;
+	return getRandom() > RANDOM_BOOLEAN_MODIFIER;
 }
 /**
 * Get a random string of characters with a specified length
@@ -7111,4 +7353,4 @@ var SizedSet = class extends Set {
 	}
 };
 //#endregion
-export { CancelablePromise, Logger, PromiseTimeoutError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, push as append, push, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncAttemptRun, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncRun, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, attemptRun, attemptRunAsyncPlan, attemptRunPlan, 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, fail, 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, isAsyncGenerator, isAsyncOnce, isAsyncPlan, isBeacon, isBeaconSubscription, isColor, isConstructor, isEmpty, isError, isFrozen, isFulfilled, isFuzzy, isGenerator, 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, isPlan, 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, plan, promises, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, run, runAsyncPlan, runPlan, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, subscriptions, succeed, 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, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, push as append, push, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncAttemptRun, asyncDebounce, asyncFail, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncRun, asyncSucceed, asyncThrottle, asyncUse, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, attemptRun, 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, fail, 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, getRandom, 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, isAsyncFailure, isAsyncGenerator, isAsyncGeneratorFunction, isAsyncOnce, isAsyncPlan, isAsyncStep, isAsyncSuccess, isBeacon, isBeaconSubscription, isColor, isConstructor, isEmpty, isError, isFailure, isFrozen, isFulfilled, isFuzzy, isGenerator, isGeneratorFunction, 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, isPlan, isPrimitive, isQueue, isQueueInstance, isRejected, isResult, isRgbColor, isRgbaColor, isSorted, isStep, isSubscription, isSubscriptions, isSuccess, 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, plan, promises, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, run, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, subscriptions, succeed, 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, use, words };