@oscarpalmer/atoms 0.222.0 → 0.223.0

package/dist/internal/array/callbacks.d.mts

@@ -1,4 +1,4 @@
-import { GenericCallback } from "../../models/index.mjs";
 import { ArrayGetCallbacks } from "../../models/array/array.misc.model.mjs";
+import { GenericCallback } from "../../models/index.mjs";
 export declare function getArrayCallback(value: unknown): GenericCallback | undefined;
 export declare function getArrayCallbacks(bool?: unknown, key?: unknown, value?: unknown): ArrayGetCallbacks | undefined;

package/dist/internal/array/find.d.mts

@@ -1,6 +1,2 @@
-import { ArrayFindOptions, ArrayFindValueType, ArrayFindValuesResult, ArrayFindValuesType, ArrayParameters } from "../../models/array/array.find.model.mjs";
-export declare function createFindParameters(original: unknown[]): ArrayParameters;
-export declare function findAbsoluteValueOrDefault(array: unknown[], parameters: unknown[], defaultValue: unknown, useDefaultValue: boolean, reversed: boolean): unknown;
-export declare function findValue(type: Exclude<ArrayFindValueType, "item">, array: unknown[], parameters: unknown[], reversed: boolean): number;
-export declare function findValue(type: Exclude<ArrayFindValueType, "index">, array: unknown[], parameters: unknown[], reversed: boolean): unknown;
-export declare function findValues(type: ArrayFindValuesType, array: unknown[], parameters: unknown[], options?: ArrayFindOptions): ArrayFindValuesResult;
+import { ArrayFindParameters, ArrayFindResult } from "../../models/array/array.misc.model.mjs";
+export declare function findValue(array: unknown[], parameters: ArrayFindParameters): ArrayFindResult | undefined;

package/dist/internal/array/find.mjs

@@ -1,131 +1,39 @@
-import { ARRAY_FIND_VALUE_INDEX } from "../../models/array/array.find.model.mjs";
-import { getArrayCallback, getArrayCallbacks } from "./callbacks.mjs";
 // src/internal/array/find.ts
-function addResult(result, mapped, flat) {
-	if (!flat) {
-		result.matched.push(mapped);
-		return;
-	}
-	const array = Array.isArray(mapped) ? mapped : [mapped];
-	const { length } = array;
-	for (let index = 0; index < length; index += 1) result.matched.push(array[index]);
-}
-function createFindParameters(original) {
-	const { length } = original;
-	return {
-		bool: length === 1 && typeof original[0] === "function" ? original[0] : void 0,
-		key: length === 2 ? original[0] : void 0,
-		value: length === 1 && typeof original[0] !== "function" ? original[0] : original[1]
-	};
-}
-function findAbsoluteValueOrDefault(array, parameters, defaultValue, useDefaultValue, reversed) {
-	if (parameters.length === 0) {
-		if (Array.isArray(array) && array.length > 0) return reversed ? array.at(-1) : array[0];
-		return useDefaultValue ? defaultValue : void 0;
-	}
-	const index = findValue(ARRAY_FIND_VALUE_INDEX, array, parameters, reversed);
-	if (index === -1) return useDefaultValue ? defaultValue : void 0;
-	return array[index];
-}
-function findComplexValues(parameters) {
-	const { array, arrayLength, callback, limit, result, type, value } = parameters;
-	const keys = /* @__PURE__ */ new Set();
-	for (let arrayIndex = 0; arrayIndex < arrayLength; arrayIndex += 1) {
-		const arrayItem = array[arrayIndex];
-		const keyed = callback == null ? arrayItem : callback(arrayItem, arrayIndex, array);
-		const mapped = arrayItem;
-		if (type === "all" && Object.is(keyed, value) || type === "unique" && !keys.has(keyed)) {
-			keys.add(keyed);
-			result.matched.push(mapped);
-			if (result.matched.length >= limit) return result;
-		} else result.notMatched.push(arrayItem);
-	}
-	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(parameters) {
-	const { array, arrayLength, callback, flat, limit, map, result, value } = parameters;
-	const { after, before } = map ?? {};
-	const handler = callback ?? ((item) => Object.is(item, value));
-	for (let arrayIndex = 0; arrayIndex < arrayLength; arrayIndex += 1) {
-		const arrayItem = array[arrayIndex];
-		let mapped = before == null ? arrayItem : before(arrayItem, arrayIndex, array);
-		if (!flat || after != null) {
-			if (handler(mapped, arrayIndex, array)) {
-				mapped = after == null ? mapped : after(arrayItem, arrayIndex, array);
-				addResult(result, mapped, flat);
-				if (result.matched.length >= limit) return result;
-			} else result.notMatched.push(arrayItem);
-			continue;
-		}
-		const flatItems = Array.isArray(mapped) ? mapped : [mapped];
-		const flatLength = flatItems.length;
-		for (let flatIndex = 0; flatIndex < flatLength; flatIndex += 1) {
-			const flatItem = flatItems[flatIndex];
-			if (handler(flatItem, arrayIndex, array)) result.matched.push(flatItem);
-			else result.notMatched.push(flatItem);
-		}
+function findComplexValues(array, length, parameters, callback) {
+	let result;
+	for (let index = 0; index < length; index += 1) {
+		const item = array[parameters.reverse ? length - 1 - index : index];
+		if (!callback(item, index, array)) continue;
+		result ??= { values: [] };
+		result.values.push(parameters.indiced ? index : item);
+		if (parameters.limit == null || result.values.length === parameters.limit) return result;
 	}
 	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) 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];
-	}
-	return findValueInArray(array, callbacks.keyed, value, findIndex, reversed);
+function findBareValue(array, reverse) {
+	return { values: [array[reverse ? array.length - 1 : 0]] };
 }
-function findValueInArray(array, callback, value, findIndex, reversed) {
-	const { length } = array;
-	for (let index = 0; index < length; index += 1) {
-		const item = reversed ? array.at(-(index + 1)) : array[index];
-		if (Object.is(callback?.(item, index, array), value)) return findIndex ? index : item;
-	}
-	return findIndex ? -1 : void 0;
+function findSimpleValue(array, first, indiced, reverse) {
+	const method = reverse ? "findLastIndex" : "findIndex";
+	const index = typeof first === "function" ? array[method](first) : array[method]((item) => Object.is(item, first));
+	return index === -1 ? void 0 : { values: [indiced ? index : array[index]] };
 }
-function findValues(type, array, parameters, options) {
-	const result = {
-		matched: [],
-		notMatched: []
-	};
-	if (!Array.isArray(array)) return result;
+function findValue(array, parameters) {
+	if (!Array.isArray(array)) return;
 	const arrayLength = array.length;
-	if (arrayLength === 0) return result;
-	const { bool, key, value } = createFindParameters(parameters);
-	const callbacks = getArrayCallbacks(bool, key);
-	if (type === "unique" && callbacks?.keyed == null && arrayLength >= 100) {
-		result.matched = [...new Set(array)];
-		return result;
+	if (arrayLength === 0) return;
+	const inputLength = parameters.input.length;
+	if (inputLength === 0 && parameters.bare) return findBareValue(array, parameters.reverse ?? false);
+	const [first, second] = parameters.input;
+	if (inputLength === 1 && !parameters.limit) return findSimpleValue(array, first, parameters.indiced ?? false, parameters.reverse ?? false);
+	const callback = inputLength === 1 && typeof first === "function" ? first : getCallback(first, second);
+	return callback == null ? void 0 : findComplexValues(array, arrayLength, parameters, callback);
+}
+function getCallback(first, second) {
+	switch (true) {
+		case typeof first === "function": return (item, index, array) => Object.is(first(item, index, array), second);
+		case typeof first === "number" || typeof first === "string": return (item) => Object.is(item[first], second);
+		default: return;
 	}
-	const limit = options?.limit ?? Number.POSITIVE_INFINITY;
-	const flat = options?.map?.flat ?? false;
-	const mapCallback = getArrayCallback(options?.map?.callback);
-	const mapReverse = options?.map?.reverse ?? false;
-	let map;
-	if (mapCallback != null) map = {
-		before: mapReverse ? mapCallback : void 0,
-		after: mapReverse ? void 0 : mapCallback
-	};
-	const simple = callbacks?.bool != null || type === "all" && key == null;
-	const findParameters = {
-		array,
-		arrayLength,
-		flat,
-		limit,
-		map,
-		result,
-		type,
-		value,
-		callback: simple ? callbacks?.bool : callbacks?.keyed
-	};
-	return simple ? findSimpleValues(findParameters) : findComplexValues(findParameters);
 }
-export { createFindParameters, findAbsoluteValueOrDefault, findValue, findValues };
+export { findValue };

package/dist/internal/array/index-of.mjs

@@ -1,11 +1,17 @@
-import { ARRAY_FIND_VALUE_INDEX } from "../../models/array/array.find.model.mjs";
 import { findValue } from "./find.mjs";
 // src/internal/array/index-of.ts
 function indexOf(array, ...parameters) {
-	return findValue(ARRAY_FIND_VALUE_INDEX, array, parameters, false);
+	return findValue(array, {
+		indiced: true,
+		input: parameters
+	})?.values[0] ?? -1;
 }
 function lastIndexOf(array, ...parameters) {
-	return findValue(ARRAY_FIND_VALUE_INDEX, array, parameters, true);
+	return findValue(array, {
+		indiced: true,
+		input: parameters,
+		reverse: true
+	})?.values[0] ?? -1;
 }
 indexOf.last = lastIndexOf;
 export { indexOf, lastIndexOf };

package/dist/internal/array/insert.mjs

@@ -1,6 +1,6 @@
 import "../../models/array/array.misc.model.mjs";
-import { chunk } from "./chunk.mjs";
 import { max, min } from "../math/aggregate.mjs";
+import { chunk } from "./chunk.mjs";
 // src/internal/array/insert.ts
 function insertChunkedValues(type, array, items, start, deleteCount) {
 	const actualDeleteCount = max([deleteCount, 0]);

package/dist/internal/array/match.d.mts

@@ -1,5 +1,5 @@
-import { PlainObject } from "../../models/index.mjs";
 import { ArrayComparison } from "../../models/array/array.misc.model.mjs";
+import { PlainObject } from "../../models/index.mjs";
 /**
  * Is the needle array at the end of the haystack array?
  *

package/dist/internal/array/match.mjs

@@ -1,5 +1,5 @@
-import { getArrayCallback } from "./callbacks.mjs";
 import { ARRAY_MATCH_COMPARISON_INSIDE, ARRAY_MATCH_COMPARISON_SAME, ARRAY_MATCH_COMPARISON_START, arrayMatchEndings, arrayMatchInvalid, arrayMatchOutside, arrayMatchOutsides, arrayMatchStarts } from "../../models/array/array.match.model.mjs";
+import { getArrayCallback } from "./callbacks.mjs";
 // src/internal/array/match.ts
 function endsWithArray(haystack, needle, key) {
 	return arrayMatchEndings.has(getPosition(haystack, needle, key)[1]);

package/dist/internal/array/sets.mjs

@@ -1,5 +1,5 @@
-import { getArrayCallback } from "./callbacks.mjs";
 import { ARRAY_SETS_COMPARE_DIFFERENCE, ARRAY_SETS_COMPARE_INTERSECTION, ARRAY_SETS_COMPARE_UNION } from "../../models/array/array.misc.model.mjs";
+import { getArrayCallback } from "./callbacks.mjs";
 // src/internal/array/sets.ts
 function compareSets(type, first, second, key) {
 	if (!Array.isArray(first)) return [];
@@ -24,12 +24,12 @@ function getComparison(first, second, isIntersection, isUnion, key) {
 	}
 	const source = isUnion ? second : first;
 	length = source.length;
-	const result = isUnion ? first.slice() : [];
+	const compared = isUnion ? first.slice() : [];
 	for (let index = 0; index < length; index += 1) {
 		const item = source[index];
 		const value = callback?.(item, index, source) ?? item;
-		if (isIntersection ? set.has(value) : !set.has(value)) result.push(item);
+		if (isIntersection ? set.has(value) : !set.has(value)) compared.push(item);
 	}
-	return result;
+	return compared;
 }
 export { compareSets };

package/dist/internal/function/assert.d.mts

@@ -1,5 +1,5 @@
-import { Constructor, NestedKeys, NestedValue, PlainObject } from "../../models/index.mjs";
 import { AssertNestedPick, Asserter } from "../../models/function/assert.model.mjs";
+import { Constructor, NestedKeys, NestedValue, PlainObject } from "../../models/index.mjs";
 /**
  * Asserts that a condition is true, throwing an error if it is not
  *

package/dist/internal/function/limit.d.mts

@@ -1,4 +1,4 @@
-import { GenericAsyncCallback, GenericCallback } from "../../models/index.mjs";
 import { AsyncLimiter, Limiter, LimiterType } from "../../models/function/limiter.model.mjs";
+import { GenericAsyncCallback, GenericCallback } from "../../models/index.mjs";
 export declare function getAsyncLimiter<Callback extends GenericAsyncCallback | GenericCallback>(type: LimiterType, callback: Callback, time?: number): AsyncLimiter<Callback>;
 export declare function getLimiter<Callback extends GenericCallback>(type: LimiterType, callback: Callback, time?: number): Limiter<Callback>;

package/dist/internal/function/limit.mjs

@@ -1,17 +1,17 @@
-import { asyncAttempt } from "../result/attempt.mjs";
-import { LIMITER_NAME_ASYNC, LIMITER_NAME_SYNC, LIMITER_PROPERTY, LIMITER_SYMBOL, LIMITER_THROTTLE, clearTimer, startTimer } from "../../models/function/limiter.model.mjs";
+import { LIMITER_NAME_ASYNC, LIMITER_NAME_SYNC, LIMITER_SYMBOL, LIMITER_THROTTLE, clearTimer, startTimer } from "../../models/function/limiter.model.mjs";
 import { getNumberOrDefault } from "../defaults.mjs";
+import { asyncAttempt } from "../result/attempt.mjs";
 // src/internal/function/limit.ts
 function AsyncLimiter(type, callback, time) {
 	this[LIMITER_SYMBOL] = {
 		callback,
 		type,
 		interval: getNumberOrDefault(time, 0),
+		name: LIMITER_NAME_ASYNC,
 		parameters: [],
 		throttle: type === LIMITER_THROTTLE
 	};
 }
-AsyncLimiter.prototype[LIMITER_PROPERTY] = LIMITER_NAME_ASYNC;
 AsyncLimiter.prototype.cancel = cancelAsyncLimiter;
 AsyncLimiter.prototype.run = runAsyncLimiter;
 function Limiter(type, callback, time) {
@@ -19,11 +19,11 @@ function Limiter(type, callback, time) {
 		callback,
 		type,
 		interval: getNumberOrDefault(time, 0),
+		name: LIMITER_NAME_SYNC,
 		parameters: [],
 		throttle: type === LIMITER_THROTTLE
 	};
 }
-Limiter.prototype[LIMITER_PROPERTY] = LIMITER_NAME_SYNC;
 Limiter.prototype.cancel = cancelLimiter;
 Limiter.prototype.run = runLimiter;
 function cancelAsyncLimiter() {
@@ -50,13 +50,13 @@ async function handleAsyncLimiter(state, item) {
 	if (state.interval === 0 || now - state.start >= state.interval - 5) {
 		state.start = state.throttle ? now : void 0;
 		item.running = true;
-		const result = await asyncAttempt(async () => {
+		const attempted = 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);
+		if (attempted.ok) item.resolve(attempted.value);
+		else item.reject(attempted.error);
 		item.running = false;
 	} else state.timer = startTimer(() => handleAsyncLimiter(state, item));
 }

package/dist/internal/function/memoize.d.mts

@@ -1,5 +1,5 @@
-import { GenericCallback } from "../../models/index.mjs";
 import { Memoized, MemoizedOptions, MemoizedStateOptions } from "../../models/function/memoize.model.mjs";
+import { GenericCallback } from "../../models/index.mjs";
 declare function Memoized(this: any, callback: GenericCallback, options: MemoizedStateOptions): void;
 /**
  * Memoize a function, caching and retrieving results based on the first parameter

package/dist/internal/function/memoize.mjs

@@ -1,8 +1,8 @@
-import { isPlainObject } from "../is.mjs";
-import { getString, join } from "../string/misc.mjs";
-import { getNumberOrDefault } from "../defaults.mjs";
 import { MEMOIZED_CACHE_SIZE_DEFAULT, MEMOIZED_CALLBACK, MEMOIZED_SYMBOL } from "../../models/function/memoize.model.mjs";
+import { getNumberOrDefault } from "../defaults.mjs";
+import { isPlainObject } from "../is.mjs";
 import { SizedMap } from "../sized/map.mjs";
+import { getString, join } from "../string/misc.mjs";
 // src/internal/function/memoize.ts
 function Memoized(callback, options) {
 	this[MEMOIZED_SYMBOL] = {

package/dist/internal/function/work.d.mts

@@ -1,6 +1,6 @@
+import { AsyncFlow, Flow } from "../../models/function/work.model.mjs";
 import { GenericCallback } from "../../models/index.mjs";
 import { UnwrapValue } from "../../models/result.model.mjs";
-import { AsyncFlow, Flow } from "../../models/function/work.model.mjs";
 /**
  * Create an asynchronous _Flow_, a function that pipes values through a function
  *

package/dist/internal/function/work.mjs

@@ -1,5 +1,5 @@
-import { unwrapWork } from "./misc.mjs";
 import { WORK_MESSAGE_FLOW_PROMISE, WORK_MESSAGE_NESTING, WORK_MESSAGE_PIPE_PROMISE, assertFlowFunctions, assertPipeFunctions } from "../../models/function/work.model.mjs";
+import { unwrapWork } from "./misc.mjs";
 // src/internal/function/work.ts
 function asyncFlow(...fns) {
 	assertFlowFunctions(fns);

package/dist/internal/herald.d.mts

@@ -1,6 +1,5 @@
-import { GenericCallback } from "../models/index.mjs";
-import { Subscription } from "../models/subscription.model.mjs";
 import { Herald, HeraldEvents, HeraldOptions } from "../models/herald.model.mjs";
+import { GenericCallback } from "../models/index.mjs";
 /**
  * Create a _Herald_ for announcing named events
  *
@@ -22,11 +21,4 @@ export declare function isHerald<Events extends Record<string, GenericCallback>
  * @param value Value to check
  * @returns `true` if the value is events for a herald, otherwise `false`
  */
-export declare function isHeraldEvents<Events extends Record<string, GenericCallback> = Record<string, GenericCallback>>(value: unknown): value is HeraldEvents<Events>;
-/**
- * Is the value a herald subscription?
- *
- * @param value Value to check
- * @returns `true` if the value is a herald subscription, otherwise `false`
- */
-export declare function isHeraldSubscription(value: unknown): value is Subscription;
+export declare function isHeraldEvents<Events extends Record<string, GenericCallback> = Record<string, GenericCallback>>(value: unknown): value is HeraldEvents<Events>;

package/dist/internal/herald.mjs

@@ -1,19 +1,18 @@
+import { HERALD_MESSAGE_ARRAY, HERALD_MESSAGE_ONCREATE, HERALD_NAME_EVENTS, HERALD_NAME_HERALD, HERALD_SYMBOL } from "../models/herald.model.mjs";
 import { isPlainObject } from "./is.mjs";
-import "../models/subscription.model.mjs";
-import { isSubscription, subscriptions } from "./subscription.mjs";
-import { HERALD_MESSAGE_ARRAY, HERALD_MESSAGE_ONCREATE, HERALD_MESSAGE_PROPERTY, HERALD_NAME_EVENTS, HERALD_NAME_HERALD, HERALD_PROPERTY, HERALD_SYMBOL, heraldSubscription } from "../models/herald.model.mjs";
+import { subscriptions } from "./subscription.mjs";
 // src/internal/herald.ts
 function Events(herald, state) {
+	this[HERALD_SYMBOL] = { name: HERALD_NAME_EVENTS };
 	for (const key of state.keys) Object.defineProperty(this, key, { value: (callback, signal) => herald.subscribe(key, callback, signal) });
 }
-Events.prototype[HERALD_PROPERTY] = HERALD_NAME_EVENTS;
 function Herald(state) {
 	this[HERALD_SYMBOL] = {
 		state,
-		events: new Events(this, state)
+		events: new Events(this, state),
+		name: HERALD_NAME_HERALD
 	};
 }
-Herald.prototype[HERALD_PROPERTY] = HERALD_NAME_HERALD;
 Herald.prototype.clear = clearHerald;
 Herald.prototype.emit = emitForHerald;
 Herald.prototype.observed = eventIsObserved;
@@ -30,25 +29,12 @@ function createHeraldState(input) {
 	if (!Array.isArray(options.names) || options.names.length === 0 || !options.names.every((name) => typeof name === "string")) throw new Error(HERALD_MESSAGE_ARRAY);
 	if (options.onCreate != null && typeof options.onCreate !== "function") throw new Error(HERALD_MESSAGE_ONCREATE);
 	const keys = new Set(options.names);
-	const property = createHeraldSubscriptionProperty(options.property);
 	return {
 		keys,
-		store: subscriptions({
-			keys,
-			property
-		}),
+		store: subscriptions({ keys }),
 		onCreate: options.onCreate
 	};
 }
-function createHeraldSubscriptionProperty(input) {
-	if (input == null) return heraldSubscription;
-	const property = isPlainObject(input) ? input : {};
-	if (typeof property.key !== "string" || property.value != null && typeof property.value !== "string") throw new Error(HERALD_MESSAGE_PROPERTY);
-	return {
-		key: property.key,
-		value: property.value
-	};
-}
 function emitForHerald(event, ...parameters) {
 	const { state } = this[HERALD_SYMBOL];
 	const items = state.store.values.from.keyed?.get(event);
@@ -90,16 +76,7 @@ function isHeraldEvents(value) {
 	return isHeraldInstance(HERALD_NAME_EVENTS, value);
 }
 function isHeraldInstance(name, value) {
-	return typeof value === "object" && value !== null && "$herald" in value && value["$herald"] === name;
-}
-/**
-* Is the value a herald subscription?
-*
-* @param value Value to check
-* @returns `true` if the value is a herald subscription, otherwise `false`
-*/
-function isHeraldSubscription(value) {
-	return isSubscription(value) && "$herald" in value && value["$herald"] === "subscription";
+	return typeof value === "object" && value !== null && HERALD_SYMBOL in value && value[HERALD_SYMBOL].name === name;
 }
 function subscribeToHerald(key, callback, signal) {
 	const { state } = this[HERALD_SYMBOL];
@@ -111,4 +88,4 @@ function subscribeToHerald(key, callback, signal) {
 	if (!existing) state.onCreate?.(key, callback, subscription);
 	return subscription;
 }
-export { herald, isHerald, isHeraldEvents, isHeraldSubscription };
+export { herald, isHerald, isHeraldEvents };

package/dist/internal/math/aggregate.mjs

@@ -1,5 +1,5 @@
-import { isNonNumber } from "../is.mjs";
 import "../../models/math.model.mjs";
+import { isNonNumber } from "../is.mjs";
 // src/internal/math/aggregate.ts
 function aggregate(type, array, key, first) {
 	const length = Array.isArray(array) ? array.length : 0;

package/dist/internal/number.mjs

@@ -1,6 +1,6 @@
+import { EXPRESSION_NUMBER_BINARY, EXPRESSION_NUMBER_OCTAL, EXPRESSION_NUMBER_ZEROISH } from "../models/misc.model.mjs";
 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";
 // src/internal/number.ts
 /**
 * Is the number between a minimum and maximum value?

package/dist/internal/plan/index.mjs

@@ -1,5 +1,5 @@
-import { attempt } from "../result/attempt.mjs";
 import { PLAN_SYMBOL } from "../../models/plan.model.mjs";
+import { attempt } from "../result/attempt.mjs";
 import { asyncGenerate, generate } from "./plan.generate.mjs";
 // src/internal/plan/index.ts
 function attemptRunPlan(...parameters) {

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

@@ -1,7 +1,19 @@
-import { isError, isOk } from "../result/misc.mjs";
-import { noop } from "../function/misc.mjs";
 import { createAborter } from "../aborter.mjs";
+import { noop } from "../function/misc.mjs";
+import { isError, isOk } from "../result/misc.mjs";
 // src/internal/plan/plan.generate.ts
+async function asyncCleanup(generator, input) {
+	try {
+		const returned = await generator.return(input);
+		if (returned.done) return;
+		let cleanupValue = returned.value;
+		while (true) {
+			const { done, value } = await generator.next(cleanupValue);
+			if (done) break;
+			cleanupValue = value;
+		}
+	} catch {}
+}
 async function asyncGenerate(input, unwrap, first, second) {
 	const aborter = createAborter(second ?? first, noop);
 	if (aborter?.signal.aborted) throw aborter.signal.reason;
@@ -9,53 +21,87 @@ async function asyncGenerate(input, unwrap, first, second) {
 	let generator;
 	if (typeof input === "function") generator = input(...parameters);
 	else generator = input.generator(...parameters);
+	let aborted = false;
 	let success = true;
+	let throwing = false;
+	let lastError;
 	let lastValue;
 	try {
 		while (true) {
-			if (aborter?.signal.aborted) await generator.throw(aborter.signal.reason);
-			const next = await generator.next(lastValue);
-			const done = next.done === true;
-			const { value } = next;
-			if (value instanceof Error) await generator.throw(value);
-			if (isError(value)) await generator.throw(value.error);
+			if (aborter?.signal.aborted) {
+				if (aborted) break;
+				aborted = true;
+				lastError = aborter.signal.reason;
+				throwing = true;
+			}
+			const { done, value } = await asyncResume(generator, throwing ? lastError : lastValue, throwing);
+			if (value instanceof Error || isError(value)) {
+				const errorValue = value instanceof Error ? value : value.error;
+				if (done) throw errorValue;
+				lastError = errorValue;
+				lastValue = void 0;
+				throwing = true;
+				continue;
+			}
+			lastError = void 0;
 			lastValue = value;
-			if (done === true) break;
+			throwing = false;
+			if (done) break;
 		}
 	} catch (error) {
-		lastValue = error;
+		lastError = error;
 		success = false;
 	} finally {
 		aborter?.cancel();
-		await generator.return(lastValue);
+		await asyncCleanup(generator, lastValue);
 	}
 	if (aborter?.signal.aborted) throw aborter.signal.reason;
 	if (success) return unwrap && isOk(lastValue) ? lastValue.value : lastValue;
-	throw lastValue;
+	throw lastError;
+}
+async function asyncResume(generator, input, throwing) {
+	const { done, value } = await (throwing ? generator.throw(input) : generator.next(input));
+	return {
+		value,
+		done: done === true
+	};
 }
 function generate(input, parameters, unwrap) {
 	let generator;
 	if (typeof input === "function") generator = input(...parameters);
 	else generator = input.generator(...parameters);
 	let success = true;
+	let throwing = false;
+	let lastError;
 	let lastValue;
 	try {
 		while (true) {
-			const next = generator.next(lastValue);
-			const done = next.done === true;
-			const { value } = next;
-			if (value instanceof Error) generator.throw(value);
-			if (isError(value)) generator.throw(value.error);
+			const { done, value } = resume(generator, throwing ? lastError : lastValue, throwing);
+			if (value instanceof Error || isError(value)) {
+				const errorValue = value instanceof Error ? value : value.error;
+				if (done) throw errorValue;
+				lastError = errorValue;
+				lastValue = void 0;
+				throwing = true;
+				continue;
+			}
+			lastError = void 0;
 			lastValue = value;
+			throwing = false;
 			if (done) break;
 		}
 	} catch (error) {
-		lastValue = error;
+		lastError = error;
 		success = false;
-	} finally {
-		generator.return(lastValue);
 	}
 	if (success) return unwrap && isOk(lastValue) ? lastValue.value : lastValue;
-	throw lastValue;
+	throw lastError;
+}
+function resume(generator, input, throwing) {
+	const { done, value } = throwing ? generator.throw(input) : generator.next(input);
+	return {
+		value,
+		done: done === true
+	};
 }
 export { asyncGenerate, generate };

package/dist/internal/sized/map.d.mts

@@ -9,6 +9,9 @@ export declare class SizedMap<SizedKey = unknown, SizedValue = unknown> extends
    * Is the _Map_ full?
    */
   get full(): boolean;
+  /**
+   * The maximum size of the _Map_
+   */
   get maximum(): number;
   /**
    * Create a new _SizedMap_ with entries and a maximum size _(2^20)_

package/dist/internal/sized/map.mjs

@@ -16,6 +16,9 @@ var SizedMap = class extends Map {
 	get full() {
 		return super.size >= this.#maximumSize;
 	}
+	/**
+	* The maximum size of the _Map_
+	*/
 	get maximum() {
 		return this.#maximumSize;
 	}

package/dist/internal/string/case.mjs

@@ -1,6 +1,6 @@
-import { join, words } from "./misc.mjs";
-import { memoize } from "../function/memoize.mjs";
 import { STRING_CASE_CAMEL, STRING_CASE_CAPITALIZE, STRING_CASE_KEBAB, STRING_CASE_LOWER, STRING_CASE_PASCAL, STRING_CASE_SNAKE, STRING_CASE_TITLE, STRING_CASE_UPPER, STRING_EXPRESSION_ACRONYM, STRING_EXPRESSION_CAMEL_CASE, STRING_REPLACEMENT_CAMEL_CASE, ignoreCachingCases } from "../../models/string/string.case.model.mjs";
+import { memoize } from "../function/memoize.mjs";
+import { join, words } from "./misc.mjs";
 // src/internal/string/case.ts
 /**
 * Convert a string to camel case _(thisIsCamelCase)_

package/dist/internal/string/misc.mjs

@@ -1,5 +1,5 @@
-import { unwrap } from "../result/misc.mjs";
 import { STRING_EXPRESSION_IGNORED, STRING_EXPRESSION_WORDS } from "../../models/string/string.misc.model.mjs";
+import { unwrap } from "../result/misc.mjs";
 import { attempt } from "../result/attempt.mjs";
 // src/internal/string/misc.ts
 /**