@oscarpalmer/atoms 0.217.0 → 0.218.0

package/dist/internal/array/find.mjs

@@ -9,15 +9,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];
@@ -38,7 +70,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 = {
@@ -55,36 +88,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;
+	let mapAfter;
+	let mapBefore;
+	if (mapCallback == null) {
+		mapAfter = void 0;
+		mapBefore = void 0;
+	} else {
+		mapAfter = mapReverse ? void 0 : mapCallback;
+		mapBefore = mapReverse ? mapCallback : void 0;
 	}
-	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;
+	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
 export { createFindParameters, findAbsoluteValueOrDefault, findValue, findValues };

package/dist/internal/array/insert.mjs

@@ -3,7 +3,7 @@ import { chunk } from "./chunk.mjs";
 import { max, min } from "../math/aggregate.mjs";
 //#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;

package/dist/internal/array/match.mjs

@@ -4,6 +4,21 @@ import { ARRAY_MATCH_COMPARISON_INSIDE, ARRAY_MATCH_COMPARISON_SAME, ARRAY_MATCH
 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];
 }
@@ -17,23 +32,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]);

package/dist/internal/array/sets.mjs

@@ -6,8 +6,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;

package/dist/internal/math/aggregate.mjs

@@ -44,7 +44,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;

package/dist/internal/number.d.mts

@@ -4,7 +4,7 @@
  *
  * @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`
  */
 export declare function between(value: number, minimum: number, maximum: number): boolean;

package/dist/internal/number.mjs

@@ -1,4 +1,5 @@
 import { isNumber } from "./is.mjs";
+import { max, min } from "./math/aggregate.mjs";
 import { EXPRESSION_NUMBER_BINARY, EXPRESSION_NUMBER_OCTAL, EXPRESSION_NUMBER_ZEROISH } from "../models/misc.model.mjs";
 //#region src/internal/number.ts
 /**
@@ -6,7 +7,7 @@ import { EXPRESSION_NUMBER_BINARY, EXPRESSION_NUMBER_OCTAL, EXPRESSION_NUMBER_ZE
 *
 * @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) {
@@ -16,7 +17,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

package/dist/internal/plan/plan.generate.mjs

@@ -4,7 +4,7 @@ import { isError, isOk } from "../result/misc.mjs";
 //#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);
@@ -13,7 +13,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;
@@ -29,7 +29,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;
 }

package/dist/internal/random.d.mts

@@ -1,4 +1,10 @@
 //#region src/internal/random.d.ts
+/**
+ * Get a random number between 0 _(inclusive)_ and 1 _(exclusive)_
+ *
+ * @returns Random number
+ */
+export declare function getRandom(): number;
 /**
  * Get a random floating-point number
  *

package/dist/internal/random.mjs

@@ -1,12 +1,22 @@
 import { isNumber } from "./is.mjs";
 import { floor } from "./math/misc.mjs";
 //#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
@@ -28,5 +38,6 @@ function getRandomFloatingNumber(minimum, maximum) {
 function getRandomInteger(minimum, maximum) {
 	return floor(getRandomFloatingNumberValue(true, minimum, maximum));
 }
+const RANDOM_DIVISOR = 2 ** 32;
 //#endregion
-export { getRandomFloatingNumber, getRandomInteger };
+export { getRandom, getRandomFloatingNumber, getRandomInteger };

package/dist/internal/result/attempt.mjs

@@ -7,16 +7,16 @@ 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 {
 		const value = callback();
 		return ok(value);
-	} 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;

package/dist/internal/string/misc.mjs

@@ -75,7 +75,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
 export { getString, ignoreKey, interpolate, join, tryDecode, tryEncode, words };

package/dist/internal/subscription.mjs

@@ -125,7 +125,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) {

package/dist/internal/value/equal.mjs

@@ -1,5 +1,6 @@
 import { isNonPlainObject, isPlainObject, isPrimitive, isTypedArray } from "../is.mjs";
 import { round } from "../math/misc.mjs";
+import { min } from "../math/aggregate.mjs";
 import { createCompareHandler } from "./handlers.mjs";
 import { EQUAL_ERROR_PROPERTIES, EQUAL_EXPRESSION_PROPERTIES, EQUAL_SYMBOL } from "../../models/value/value.equal.model.mjs";
 //#region src/internal/value/equal.ts
@@ -63,7 +64,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;

package/dist/internal/value/partial.mjs

@@ -2,7 +2,9 @@ import { isPlainObject } from "../is.mjs";
 //#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 = {};

package/dist/models/plan.model.d.mts

@@ -233,6 +233,8 @@ export declare const PLAN_FAILURE_ASYNC: "asyncFailure";
 export declare const PLAN_FAILURE_SYNC: "failure";
 export declare const PLAN_MESSAGE_PLAN_INPUT = "plan requires a generator function";
 export declare const PLAN_MESSAGE_RUN_INPUT = "run requires a plan or a generator function";
+export declare const PLAN_MESSAGE_USE_NESTED_FN = "Cannot use nested functions with 'use'";
+export declare const PLAN_MESSAGE_USE_SYNC_ASYNC = "Cannot use asynchronous values with 'use'";
 export declare const PLAN_STEP_ASYNC: "asyncStep";
 export declare const PLAN_STEP_SYNC: "step";
 export declare const PLAN_SUCCESS_ASYNC: "asyncSuccess";

package/dist/models/plan.model.mjs

@@ -7,6 +7,8 @@ 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";
@@ -15,4 +17,4 @@ const PLAN_SYMBOL = Symbol("plan");
 const PLAN_TYPE_ASYNC = "asyncPlan";
 const PLAN_TYPE_SYNC = "plan";
 //#endregion
-export { GENERATOR_FUNCTION_TYPE_ASYNC, GENERATOR_FUNCTION_TYPE_SYNC, GENERATOR_TYPE_ASYNC, GENERATOR_TYPE_SYNC, PLAN_FAILURE_ASYNC, PLAN_FAILURE_SYNC, PLAN_MESSAGE_PLAN_INPUT, PLAN_MESSAGE_RUN_INPUT, PLAN_STEP_ASYNC, PLAN_STEP_SYNC, PLAN_SUCCESS_ASYNC, PLAN_SUCCESS_SYNC, PLAN_SYMBOL, PLAN_TYPE_ASYNC, PLAN_TYPE_SYNC };
+export { GENERATOR_FUNCTION_TYPE_ASYNC, GENERATOR_FUNCTION_TYPE_SYNC, GENERATOR_TYPE_ASYNC, GENERATOR_TYPE_SYNC, PLAN_FAILURE_ASYNC, PLAN_FAILURE_SYNC, PLAN_MESSAGE_PLAN_INPUT, PLAN_MESSAGE_RUN_INPUT, PLAN_MESSAGE_USE_NESTED_FN, PLAN_MESSAGE_USE_SYNC_ASYNC, PLAN_STEP_ASYNC, PLAN_STEP_SYNC, PLAN_SUCCESS_ASYNC, PLAN_SUCCESS_SYNC, PLAN_SYMBOL, PLAN_TYPE_ASYNC, PLAN_TYPE_SYNC };

package/dist/models/string/string.fuzzy.model.d.mts

@@ -88,7 +88,7 @@ export type FuzzyResult<Item> = {
 /**
  * Options for fuzzy searching
  */
-export type FuzzySearchOptions = FuzzyOptions;
+export type FuzzySearchOptions = { [Key in keyof FuzzyOptions]: FuzzyOptions[Key]; };
 export type FuzzyState<Item> = {
   handler(item: Item): string;
   items: Item[];

package/dist/models/string/string.misc.model.mjs

@@ -2,7 +2,7 @@
 const STRING_DELIMITER_UUID_DEFAULT = "-";
 const STRING_DELIMITER_UUID_HTML = "_";
 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";

package/dist/models/value/value.merge.model.d.mts

@@ -3,7 +3,7 @@ import { ArrayOrPlainObject, NestedPartial, PlainObject, UnionToIntersection } f
 /**
  * Options for assigning values
  */
-export type AssignOptions = BaseOptions;
+export type AssignOptions = { [Key in keyof BaseOptions]: BaseOptions[Key]; };
 type BaseOptions = {
   /**
    * Key _(or key epxressions)_ for values that should be replaced

package/dist/plan/index.d.mts

@@ -1,6 +1,4 @@
 import { AsyncPlan, Plan } from "../models/plan.model.mjs";
-import { asyncAttemptRun, attemptRun } from "./result.mjs";
-import { asyncRun, run } from "./run.mjs";
 //#region src/plan/index.d.ts
 /**
  * Create a plan for an asynchronous generator function
@@ -16,5 +14,4 @@ export declare function plan<Yielded, Returned, Parameters extends unknown[]>(ge
  * @returns Generator plan
  */
 export declare function plan<Yielded, Returned, Parameters extends unknown[]>(generator: (...parameters: Parameters) => Generator<Yielded, Returned>): Plan<Yielded, Returned, Parameters>;
-//#endregion
-export { asyncAttemptRun, asyncRun, attemptRun, run };
+//#endregion

package/dist/plan/index.mjs

@@ -1,8 +1,7 @@
 import { PLAN_MESSAGE_PLAN_INPUT, PLAN_SYMBOL, PLAN_TYPE_ASYNC, PLAN_TYPE_SYNC } from "../models/plan.model.mjs";
 import { attemptRunPlan, getGenerator, runAsyncPlan, runPlan } from "../internal/plan/index.mjs";
 import { isAsyncGeneratorFunction, isGeneratorFunction } from "./is.mjs";
-import { asyncAttemptRun, attemptRun } from "./result.mjs";
-import { asyncRun, run } from "./run.mjs";
+import { asyncAttemptRun } from "./result.mjs";
 //#region src/plan/index.ts
 function AsyncPlan(generator) {
 	this[PLAN_SYMBOL] = {
@@ -31,4 +30,4 @@ function plan(generator) {
 	throw new Error(PLAN_MESSAGE_PLAN_INPUT);
 }
 //#endregion
-export { asyncAttemptRun, asyncRun, attemptRun, plan, run };
+export { plan };

package/dist/plan/use.mjs

@@ -1,5 +1,5 @@
 import { isError, isOk } from "../internal/result/misc.mjs";
-import { PLAN_STEP_ASYNC, PLAN_STEP_SYNC, PLAN_SYMBOL } from "../models/plan.model.mjs";
+import { PLAN_MESSAGE_USE_NESTED_FN, PLAN_MESSAGE_USE_SYNC_ASYNC, PLAN_STEP_ASYNC, PLAN_STEP_SYNC, PLAN_SYMBOL } from "../models/plan.model.mjs";
 import { getGenerator } from "../internal/plan/index.mjs";
 import { isAsyncFailure, isAsyncGenerator, isAsyncGeneratorFunction, isAsyncPlan, isAsyncStep, isAsyncSuccess, isGenerator } from "./is.mjs";
 import { fail } from "./misc.mjs";
@@ -23,7 +23,7 @@ function asyncUse(value) {
 		let actual = value;
 		if (typeof actual === "function") actual = actual();
 		actual = await actual;
-		if (typeof actual === "function") throw new Error();
+		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)) {
@@ -61,8 +61,8 @@ function use(value) {
 	});
 }
 function validateUseInput(value, resolved) {
-	if (value instanceof Promise || isAsyncFailure(value) || isAsyncGenerator(value) || isAsyncGeneratorFunction(value) || isAsyncPlan(value) || isAsyncStep(value) || isAsyncSuccess(value)) throw new Error();
-	if (resolved && typeof value === "function") throw new Error();
+	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

package/dist/promise/index.d.mts

@@ -1,6 +1,7 @@
 import { PlainObject } from "../models/index.mjs";
 import { PromiseOptions, PromiseStrategy, PromisesItems, PromisesOptions, PromisesResult, PromisesUnwrapped, PromisesValues } from "../models/promise.model.mjs";
 //#region src/promise/index.d.ts
+type AttemptPromiseOptions = PromiseOptions | AbortSignal | number;
 /**
  * Wrap a _Promise_ with safety handlers
  *
@@ -8,7 +9,7 @@ import { PromiseOptions, PromiseStrategy, PromisesItems, PromisesOptions, Promis
  * @param options Options for the _Promise_
  * @returns Wrapped _Promise_
  */
-export declare function attemptPromise<Value>(promise: Promise<Value>, options?: PromiseOptions | AbortSignal | number): Promise<Value>;
+export declare function attemptPromise<Value>(promise: Promise<Value>, options?: AttemptPromiseOptions): Promise<Value>;
 /**
  * Wrap a _Promise_-returning callback with safety handlers
  *
@@ -16,7 +17,7 @@ export declare function attemptPromise<Value>(promise: Promise<Value>, options?:
  * @param options Options for the _Promise_
  * @returns _Promise_-wrapped callback
  */
-export declare function attemptPromise<Value>(callback: () => Promise<Value>, options?: PromiseOptions | AbortSignal | number): Promise<Value>;
+export declare function attemptPromise<Value>(callback: () => Promise<Value>, options?: AttemptPromiseOptions): Promise<Value>;
 /**
  * Wrap a callback with a _Promise_ and safety handlers
  *
@@ -24,7 +25,7 @@ export declare function attemptPromise<Value>(callback: () => Promise<Value>, op
  * @param options Options for the _Promise_
  * @returns _Promise_-wrapped callback
  */
-export declare function attemptPromise<Value>(callback: () => Value, options?: PromiseOptions | AbortSignal | number): Promise<Value>;
+export declare function attemptPromise<Value>(callback: () => Value, options?: AttemptPromiseOptions): Promise<Value>;
 /**
  * Handle a list of _Promises_, returning their results in an ordered array
  *
@@ -106,4 +107,5 @@ export declare function resultPromises<Items extends PlainObject>(items: Items,
 export declare namespace promises {
   export var result: typeof resultPromises;
 }
-//#endregion
+//#endregion
+export {};

package/dist/promise/index.mjs

@@ -8,9 +8,9 @@ import { getTimedPromise } from "./timed.mjs";
 //#region src/promise/index.ts
 async function attemptPromise(value, options) {
 	const isFunction = typeof value === "function";
-	if (!isFunction && !(value instanceof Promise)) return Promise.reject(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);
 	});
@@ -32,8 +32,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, () => {

package/dist/promise/misc.mjs

@@ -20,13 +20,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);
@@ -38,7 +41,7 @@ function settlePromise(settler, value, aborter) {
 }
 async function toResult(value) {
 	const actual = typeof value === "function" ? value() : value;
-	if (!(actual instanceof Promise)) return Promise.reject(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

package/dist/promise/timed.mjs

@@ -23,9 +23,9 @@ async function getTimedPromise(promise, time, signal) {
 	});
 }
 async function timed(promise, options) {
-	if (!(promise instanceof Promise)) return Promise.reject(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

package/dist/queue.mjs

@@ -335,14 +335,13 @@ async function run(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 {