@oscarpalmer/atoms 0.222.0 → 0.223.0

package/dist/index.mjs

@@ -1,175 +1,105 @@
-// src/models/array/array.find.model.ts
-const ARRAY_FIND_VALUE_INDEX = "index";
-const ARRAY_FIND_VALUE_ITEM = "item";
-const ARRAY_FIND_VALUES_UNIQUE = "unique";
-// src/internal/array/callbacks.ts
-function getArrayCallback(value) {
-	switch (typeof value) {
-		case "function": return value;
-		case "number":
-		case "string": return (obj) => obj?.[value];
-		default: return;
-	}
-}
-function getArrayCallbacks(bool, key, value) {
-	if (typeof bool === "function") return { bool };
-	return {
-		keyed: getArrayCallback(key),
-		value: getArrayCallback(value)
-	};
-}
-// 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]);
+// src/array/filter.ts
+function exclude(array, ...parameters) {
+	return filterValues(array, parameters, false);
 }
-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 filter(array, ...parameters) {
+	return filterValues(array, parameters, true);
 }
-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 filterValues(array, parameters, include) {
+	if (!Array.isArray(array)) return [];
+	if (array.length === 0) return [];
+	const [first, second] = parameters;
+	const { length } = parameters;
+	if (length === 1) return typeof first === "function" ? array.filter((item, index, array) => first(item, index, array) === include) : array.filter((item) => Object.is(item, first) === include);
+	let callback;
+	if (typeof first === "function") callback = first;
+	else if (typeof first === "number" || typeof first === "string") callback = (item) => item[first];
+	if (callback == null) return [];
+	return array.filter((item, index, array) => Object.is(callback(item, index, array), second) === include);
 }
-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);
+filter.remove = exclude;
+// src/internal/array/find.ts
+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 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 findBareValue(array, reverse) {
+	return { values: [array[reverse ? array.length - 1 : 0]] };
 }
-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);
-		}
-	}
-	return result;
+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 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 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 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;
-	}
-	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);
-}
-// src/array/filter.ts
-function exclude(array, ...parameters) {
-	return findValues("all", array, parameters).notMatched;
-}
-function filter(array, ...parameters) {
-	return findValues("all", array, parameters).matched;
+	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$1(first, second);
+	return callback == null ? void 0 : findComplexValues(array, arrayLength, parameters, callback);
+}
+function getCallback$1(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;
+	}
 }
-filter.remove = exclude;
 // src/array/find.ts
 function find(array, ...parameters) {
-	return findValue(ARRAY_FIND_VALUE_ITEM, array, parameters, false);
+	return findValue(array, {
+		input: parameters,
+		reverse: false
+	})?.values[0];
 }
 function findLast(array, ...parameters) {
-	return findValue(ARRAY_FIND_VALUE_ITEM, array, parameters, true);
+	return findValue(array, {
+		input: parameters,
+		reverse: true
+	})?.values[0];
 }
 find.last = findLast;
 // src/array/first.ts
 function first(array, ...parameters) {
-	return findAbsoluteValueOrDefault(array, parameters, void 0, false, false);
+	return findValue(array, {
+		bare: true,
+		input: parameters
+	})?.values[0];
 }
 function firstOrDefault(array, defaultValue, ...parameters) {
-	return findAbsoluteValueOrDefault(array, parameters, defaultValue, true, false);
+	return findValue(array, {
+		bare: true,
+		input: parameters
+	})?.values[0] ?? defaultValue;
 }
 first.defaulted = firstOrDefault;
+// src/internal/array/callbacks.ts
+function getArrayCallback(value) {
+	switch (typeof value) {
+		case "function": return value;
+		case "number":
+		case "string": return (obj) => obj?.[value];
+		default: return;
+	}
+}
+function getArrayCallbacks(bool, key, value) {
+	if (typeof bool === "function") return { bool };
+	return {
+		keyed: getArrayCallback(key),
+		value: getArrayCallback(value)
+	};
+}
 // src/internal/array/group.ts
 function groupValues(array, key, value, arrays) {
 	if (!Array.isArray(array) || array.length === 0) return {};
@@ -631,13 +561,13 @@ 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;
 }
 // src/array/difference.ts
 function difference(first, second, key) {
@@ -645,8 +575,16 @@ function difference(first, second, key) {
 }
 // src/array/exists.ts
 function exists(array, ...parameters) {
-	if (parameters.length === 1 && typeof parameters[0] !== "function") return Array.isArray(array) ? array.includes(parameters[0]) : false;
-	return findValue(ARRAY_FIND_VALUE_INDEX, array, parameters, false) > -1;
+	if (!Array.isArray(array)) return false;
+	if (array.length === 0) return false;
+	const [first, second] = parameters;
+	const { length } = parameters;
+	if (length === 1) return typeof first === "function" ? array.some((item, index, array) => first(item, index, array)) : array.includes(first);
+	let callback;
+	if (typeof first === "function") callback = first;
+	else if (typeof first === "number" || typeof first === "string") callback = (item) => item[first];
+	if (callback == null) return false;
+	return array.some((item, index, array) => Object.is(callback(item, index, array), second));
 }
 // src/array/flatten.ts
 /**
@@ -786,8 +724,30 @@ function intersection(first, second, key) {
 	return compareSets(ARRAY_SETS_COMPARE_INTERSECTION, first, second, key);
 }
 // src/array/partition.ts
+function getCallback(first, second, length) {
+	if (length === 1 && typeof first === "function") return first;
+	switch (true) {
+		case length === 1: return (item) => Object.is(item, first);
+		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;
+	}
+}
 function partition(array, ...parameters) {
-	const { matched, notMatched } = findValues("all", array, parameters);
+	if (!Array.isArray(array)) return [[], []];
+	const arrayLength = array.length;
+	if (arrayLength === 0) return [[], []];
+	const parametersLength = parameters.length;
+	const [first, second] = parameters;
+	const callback = getCallback(first, second, parametersLength);
+	if (callback == null) return [[], []];
+	const matched = [];
+	const notMatched = [];
+	for (let index = 0; index < arrayLength; index += 1) {
+		const item = array[index];
+		if (callback(item, index, array)) matched.push(item);
+		else notMatched.push(item);
+	}
 	return [matched, notMatched];
 }
 // src/array/push.ts
@@ -836,9 +796,13 @@ function reverse(array) {
 }
 // src/array/single.ts
 function single(array, ...parameters) {
-	const { matched } = findValues("all", array, parameters, { limit: 2 });
-	if (matched.length > 1) throw new Error(SINGLE_MESSAGE);
-	return matched[0];
+	const result = findValue(array, {
+		input: parameters,
+		limit: 2
+	});
+	if (result == null) return;
+	if (result.values.length > 1) throw new Error(SINGLE_MESSAGE);
+	return result.values[0];
 }
 const SINGLE_MESSAGE = "Multiple items were found";
 // src/array/slice.ts
@@ -949,7 +913,21 @@ function union(first, second, key) {
 // src/array/unique.ts
 function unique(array, key) {
 	if (!Array.isArray(array)) return [];
-	return array.length > 1 ? findValues(ARRAY_FIND_VALUES_UNIQUE, array, [key, void 0]).matched : array;
+	const { length } = array;
+	if (length < 2) return array.slice();
+	const callback = getArrayCallback(key);
+	if (callback == null && length >= 100) return [...new Set(array)];
+	const keyed = /* @__PURE__ */ new Set();
+	const uniques = [];
+	for (let index = 0; index < length; index += 1) {
+		const item = array[index];
+		const value = callback == null ? item : callback(item, index, array);
+		if (!keyed.has(value)) {
+			keyed.add(value);
+			uniques.push(item);
+		}
+	}
+	return uniques;
 }
 // src/array/update.ts
 function update(array, values, key) {
@@ -957,10 +935,18 @@ function update(array, values, key) {
 }
 // src/array/last.ts
 function last(array, ...parameters) {
-	return findAbsoluteValueOrDefault(array, parameters, void 0, false, true);
+	return findValue(array, {
+		bare: true,
+		input: parameters,
+		reverse: true
+	})?.values[0];
 }
 function lastOrDefault(array, defaultValue, ...parameters) {
-	return findAbsoluteValueOrDefault(array, parameters, defaultValue, true, true);
+	return findValue(array, {
+		bare: true,
+		input: parameters,
+		reverse: true
+	})?.values[0] ?? defaultValue;
 }
 last.defaulted = lastOrDefault;
 // src/internal/array/overlap.ts
@@ -1067,12 +1053,46 @@ function flatMapAndFilter(array, mapper, filter) {
 function mapAndFilter(array, mapper, filter) {
 	return selectValues(array, filter, mapper, false, true);
 }
+function selectBareValues(array, length, filter, mapper, reverse) {
+	const selected = [];
+	for (let index = 0; index < length; index += 1) {
+		const item = array[index];
+		const mapped = reverse ? mapper(item, index, array) : item;
+		if (filter(mapped, index, array)) selected.push(reverse ? mapped : mapper(item, index, array));
+	}
+	return selected;
+}
+function selectFlatValues(array, arrayLength, filter, mapper, reverse) {
+	if (reverse) return selectFlatValuesReversed(array, arrayLength, filter, mapper);
+	const selected = [];
+	for (let arrayIndex = 0; arrayIndex < arrayLength; arrayIndex += 1) {
+		const item = array[arrayIndex];
+		if (!filter(item, arrayIndex, array)) continue;
+		const mapped = mapper(item, arrayIndex, array);
+		if (Array.isArray(mapped)) selected.push(...mapped);
+		else selected.push(mapped);
+	}
+	return selected;
+}
+function selectFlatValuesReversed(array, arrayLength, filter, mapper) {
+	const selected = [];
+	for (let arrayIndex = 0; arrayIndex < arrayLength; arrayIndex += 1) {
+		const item = array[arrayIndex];
+		const mapped = mapper(item, arrayIndex, array);
+		const items = Array.isArray(mapped) ? mapped : [mapped];
+		const itemsLength = items.length;
+		for (let itemsIndex = 0; itemsIndex < itemsLength; itemsIndex += 1) {
+			const item = items[itemsIndex];
+			if (filter(item, arrayIndex, array)) selected.push(item);
+		}
+	}
+	return selected;
+}
 function selectValues(array, filter, mapper, flat, reverse) {
-	return findValues("all", array, [filter], { map: {
-		flat,
-		reverse,
-		callback: mapper
-	} }).matched;
+	if (!Array.isArray(array) || typeof filter !== "function" || typeof mapper !== "function") return [];
+	const { length } = array;
+	if (length === 0) return [];
+	return flat ? selectFlatValues(array, length, filter, mapper, reverse) : selectBareValues(array, length, filter, mapper, reverse);
 }
 filterAndMap.flat = filterAndFlatMap;
 filterAndMap.reverse = mapAndFilter;
@@ -1544,10 +1564,17 @@ sort.initialize = initializeSorter;
 sort.is = isSorted;
 // 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;
 // src/array/swap.ts
@@ -1652,7 +1679,6 @@ function unwrapWork(value) {
 const LIMITER_DEBOUNCE = "debounce";
 const LIMITER_NAME_ASYNC = "asyncLimiter";
 const LIMITER_NAME_SYNC = "limiter";
-const LIMITER_PROPERTY = "$limiter";
 const LIMITER_SYMBOL = Symbol("limiter");
 const LIMITER_THROTTLE = "throttle";
 const LIMITER_WAIT = "wait";
@@ -1673,11 +1699,11 @@ function AsyncLimiter(type, callback, time) {
 		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) {
@@ -1685,11 +1711,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() {
@@ -1716,13 +1742,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));
 }
@@ -1950,10 +1976,9 @@ assert.property = assertProperty;
 // src/models/function/once.model.ts
 const ONCE_NAME_ASYNC = "asyncOnce";
 const ONCE_NAME_SYNC = "once";
-const ONCE_PROPERTY = "$once";
 const ONCE_MESSAGE_CLEARED = "Once has been cleared";
 const ONCE_MESSAGE_EXPECTATION = "Once expected a function";
-const ONCE_SYMBOL = Symbol(ONCE_PROPERTY);
+const ONCE_SYMBOL = Symbol("once");
 // src/function/once.ts
 function AsyncOnce(callback) {
 	this[ONCE_SYMBOL] = {
@@ -1963,10 +1988,10 @@ function AsyncOnce(callback) {
 		error: false,
 		finished: false,
 		items: [],
+		type: ONCE_NAME_ASYNC,
 		value: void 0
 	};
 }
-AsyncOnce.prototype[ONCE_PROPERTY] = ONCE_NAME_ASYNC;
 AsyncOnce.prototype.clear = clearOnce;
 AsyncOnce.prototype.run = runOnceAsync;
 Object.defineProperties(AsyncOnce.prototype, {
@@ -1992,10 +2017,10 @@ function Once(callback) {
 		callback,
 		called: false,
 		cleared: false,
+		type: ONCE_NAME_SYNC,
 		value: void 0
 	};
 }
-Once.prototype[ONCE_PROPERTY] = ONCE_NAME_SYNC;
 Once.prototype.clear = clearOnce;
 Once.prototype.run = runOnce;
 Object.defineProperties(Once.prototype, {
@@ -2058,7 +2083,7 @@ function handleOnceResult(state, value, error) {
 * @returns `true` if the value is an asynchronous once callback, otherwise `false`
 */
 function isAsyncOnce(value) {
-	return isOnceInstance(value, ONCE_NAME_ASYNC);
+	return isOnceInstance(ONCE_NAME_ASYNC, value);
 }
 /**
 * Is the value a once callback?
@@ -2067,10 +2092,10 @@ function isAsyncOnce(value) {
 * @returns `true` if the value is a once callback, otherwise `false`
 */
 function isOnce(value) {
-	return isOnceInstance(value, ONCE_NAME_SYNC);
+	return isOnceInstance(ONCE_NAME_SYNC, value);
 }
-function isOnceInstance(value, name) {
-	return typeof value === "object" && value !== null && "$once" in value && value["$once"] === name;
+function isOnceInstance(type, value) {
+	return typeof value === "object" && value !== null && ONCE_SYMBOL in value && value[ONCE_SYMBOL].type === type;
 }
 /**
 * Create a function that can only be called once, returning the same value on subsequent calls
@@ -2145,12 +2170,12 @@ const RETRY_MESSAGE_FAILED = "Retry failed";
 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);
+		const attempted = await asyncAttempt(async () => callback());
+		if (attempted.ok) {
+			resolver(attempted.value);
 			return;
 		}
-		if (attempts >= times || !when(result.error)) rejector(new RetryError(RETRY_MESSAGE_FAILED, result.error));
+		if (attempts >= times || !when(attempted.error)) rejector(new RetryError(RETRY_MESSAGE_FAILED, attempted.error));
 		else {
 			attempts += 1;
 			limiter.run();
@@ -2187,10 +2212,10 @@ function retry(callback, options) {
 	const { times, when } = createRetryOptions(options);
 	let last;
 	for (let index = 0; index <= times; index += 1) {
-		const result = attempt(callback);
-		if (result.ok) return result.value;
-		if (index >= times || !when(result.error)) {
-			last = result.error;
+		const attempted = attempt(callback);
+		if (attempted.ok) return attempted.value;
+		if (index >= times || !when(attempted.error)) {
+			last = attempted.error;
 			break;
 		}
 	}
@@ -2322,6 +2347,9 @@ var SizedMap = class extends Map {
 	get full() {
 		return super.size >= this.#maximumSize;
 	}
+	/**
+	* The maximum size of the _Map_
+	*/
 	get maximum() {
 		return this.#maximumSize;
 	}
@@ -2932,6 +2960,18 @@ function createAborter(value, onAbort) {
 	};
 }
 // 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;
@@ -2939,54 +2979,88 @@ 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
+	};
 }
 // src/internal/plan/index.ts
 function attemptRunPlan(...parameters) {
@@ -3240,7 +3314,10 @@ function Step(generator) {
 }
 Step.prototype[Symbol.iterator] = getGenerator;
 function asyncUse(value) {
-	return new AsyncStep(async function* () {
+	return new AsyncStep(getAsyncUseStep(value));
+}
+function getAsyncUseStep(value) {
+	return async function* () {
 		let actual = value;
 		if (typeof actual === "function") actual = actual();
 		actual = await actual;
@@ -3257,11 +3334,10 @@ function asyncUse(value) {
 			return;
 		}
 		return actual;
-	});
+	};
 }
-function use(value) {
-	validateUseInput(value, false);
-	return new Step(function* () {
+function getUseStep(value) {
+	return function* () {
 		let actual = value;
 		if (typeof actual === "function") {
 			actual = actual();
@@ -3279,7 +3355,11 @@ function use(value) {
 			return;
 		}
 		return actual;
-	});
+	};
+}
+function use(value) {
+	validateUseInput(value, false);
+	return new Step(getUseStep(value));
 }
 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);
@@ -3313,13 +3393,13 @@ var CancelablePromise = class extends Promise {
 /**
 * An error thrown when a promise times out
 */
-var PromiseTimeoutError = class extends Error {
+var TimedError = class extends Error {
 	constructor() {
 		super(PROMISE_MESSAGE_TIMEOUT);
 		this.name = PROMISE_ERROR_NAME;
 	}
 };
-const PROMISE_ERROR_NAME = "PromiseTimeoutError";
+const PROMISE_ERROR_NAME = "TimedError";
 const PROMISE_MESSAGE_EXPECTATION_ATTEMPT = "Attempt expected a function or a promise";
 const PROMISE_MESSAGE_EXPECTATION_ITEMS_TYPE = "promises expected an array or object holding promise-functions or promises";
 const PROMISE_MESSAGE_EXPECTATION_RESULT = "toResult expected a Promise";
@@ -3464,7 +3544,7 @@ async function getTimedPromise(promise, time, signal) {
 		limiter.cancel();
 		rejector(signal?.reason);
 	});
-	const limiter = getLimiter(LIMITER_WAIT, () => settlePromise(rejector, new PromiseTimeoutError(), aborter), time);
+	const limiter = getLimiter(LIMITER_WAIT, () => settlePromise(rejector, new TimedError(), aborter), time);
 	let rejector;
 	return Promise.race([promise, new Promise((_, reject) => {
 		rejector = reject;
@@ -3492,13 +3572,13 @@ async function attemptPromise(value, options) {
 		rejector(signal?.reason);
 	});
 	async function handler(resolve, reject) {
-		const result = await asyncAttempt(async () => {
+		const attempted = await asyncAttempt(async () => {
 			let result = isFunction ? value() : await value;
 			if (result instanceof Promise) result = await result;
 			return result;
 		});
-		if (result.ok) settlePromise(resolve, result.value, aborter);
-		else settlePromise(reject, result.error, aborter);
+		if (attempted.ok) settlePromise(resolve, attempted.value, aborter);
+		else settlePromise(reject, attempted.error, aborter);
 	}
 	let rejector;
 	const promise = new Promise((resolve, reject) => {
@@ -3629,13 +3709,11 @@ attemptPipe.async = attemptAsyncPipe;
 const FUZZY_BOUNDARY_SEPARATOR = /[\s./:\\_-]/;
 const FUZZY_MESSAGE_ARRAY = "Fuzzy requires an array of items";
 const FUZZY_MESSAGE_HANDLER = "Fuzzy requires a key or function to stringify items";
-const FUZZY_PROPERTY = "$fuzzy";
-const FUZZY_SYMBOL = Symbol(FUZZY_PROPERTY);
+const FUZZY_SYMBOL = Symbol("fuzzy");
 // src/string/fuzzy.ts
 function Fuzzy(state) {
 	this[FUZZY_SYMBOL] = state;
 }
-Fuzzy.prototype[FUZZY_PROPERTY] = true;
 Fuzzy.prototype.search = search;
 Object.defineProperties(Fuzzy.prototype, {
 	items: {
@@ -3843,7 +3921,7 @@ function isBoundary(string, index) {
 * @returns `true` if the value is a fuzzy searcher, otherwise `false`
 */
 function isFuzzy(value) {
-	return typeof value === "object" && value !== null && "$fuzzy" in value && value["$fuzzy"] === true;
+	return typeof value === "object" && value !== null && FUZZY_SYMBOL in value;
 }
 function search(input, option) {
 	const state = this[FUZZY_SYMBOL];
@@ -4907,27 +4985,23 @@ const SUBSCRIPTION_DISALLOWED_KEY = "Disallowed key for subscription";
 const SUBSCRIPTION_INVALID_KEY = "Invalid key for subscription";
 const SUBSCRIPTION_INVALID_VALUE = "A subscription requires a non-null value to identify it";
 const SUBSCRIPTION_NAME = "subscription";
-const SUBSCRIPTION_PROPERTY = "$subscription";
 const SUBSCRIPTION_STORE = "subscriptions";
-const SUBSCRIPTION_SYMBOL = Symbol(SUBSCRIPTION_PROPERTY);
+const SUBSCRIPTION_SYMBOL = Symbol("subscription");
 // src/internal/subscription.ts
-function Subscription(state, property, parameters) {
+function Subscription(state, parameters) {
 	this[SUBSCRIPTION_SYMBOL] = state;
-	this[property.key] = property.value;
 	state.aborter = createAborter(parameters.signal, () => this.unsubscribe(subscriptions, this, state));
 	addSubscription(this);
 }
-Subscription.prototype[SUBSCRIPTION_PROPERTY] = SUBSCRIPTION_NAME;
 Subscription.prototype.unsubscribe = removeSubscription;
 Object.defineProperty(Subscription.prototype, "active", {
 	enumerable: true,
 	get: getSubscriptionActive
 });
 function Subscriptions(parameters) {
-	const { keys, property } = createSubscriptionsParameters(parameters);
-	this[SUBSCRIPTION_SYMBOL] = createSubscriptionsState(property, keys);
+	const { keys } = createSubscriptionsParameters(parameters);
+	this[SUBSCRIPTION_SYMBOL] = createSubscriptionsState(keys);
 }
-Subscriptions.prototype[SUBSCRIPTION_PROPERTY] = SUBSCRIPTION_STORE;
 Subscriptions.prototype.clear = clearSubscriptions;
 Subscriptions.prototype.create = createSubscription;
 Object.defineProperties(Subscriptions.prototype, {
@@ -4983,7 +5057,8 @@ function createSubscription(params) {
 	const state = {
 		parameters,
 		subscriptions,
-		active: true
+		active: true,
+		name: SUBSCRIPTION_NAME
 	};
 	const existing = getExistingSubscription(subscriptions, state);
 	if (existing != null) return [existing, true];
@@ -4991,7 +5066,7 @@ function createSubscription(params) {
 		if (subscriptions.keys === false) throw new Error(SUBSCRIPTION_DISALLOWED_KEY);
 		else if (subscriptions.keys !== true && !subscriptions.keys.has(parameters.key)) throw new Error(SUBSCRIPTION_INVALID_KEY);
 	}
-	return [new Subscription(state, subscriptions.property, parameters), false];
+	return [new Subscription(state, parameters), false];
 }
 function getExistingSubscription(subscriptions, state) {
 	const { values } = subscriptions;
@@ -5023,26 +5098,16 @@ function createSubscriptionsParameters(input) {
 	let keys;
 	if (values.keys instanceof Set) keys = values.keys;
 	else keys = typeof values.keys === "boolean" ? values.keys : false;
-	return {
-		keys,
-		property: createSubscriptionsProperty(values.property)
-	};
+	return { keys };
 }
-function createSubscriptionsProperty(input) {
-	const values = isPlainObject(input) ? input : {};
-	return {
-		key: typeof values.key === "string" ? values.key : SUBSCRIPTION_PROPERTY,
-		value: values.value ?? "subscription"
-	};
-}
-function createSubscriptionsState(property, keys) {
+function createSubscriptionsState(keys) {
 	return {
 		keys,
-		property,
 		items: {
 			any: /* @__PURE__ */ new Set(),
 			keyed: keys === false ? void 0 : /* @__PURE__ */ new Map()
 		},
+		name: SUBSCRIPTION_STORE,
 		values: {
 			from: {
 				any: /* @__PURE__ */ new Map(),
@@ -5062,10 +5127,10 @@ function createSubscriptionsState(property, keys) {
 * @returns `true` if the value is a subscription, otherwise `false`
 */
 function isSubscription(value) {
-	return isSubscriptionInstance(value, SUBSCRIPTION_NAME);
+	return isSubscriptionInstance(SUBSCRIPTION_NAME, value);
 }
-function isSubscriptionInstance(value, name) {
-	return typeof value === "object" && value !== null && "$subscription" in value && value["$subscription"] === name;
+function isSubscriptionInstance(type, value) {
+	return typeof value === "object" && value !== null && SUBSCRIPTION_SYMBOL in value && value[SUBSCRIPTION_SYMBOL].name === type;
 }
 /**
 * Is the value a subscriptions store?
@@ -5074,7 +5139,7 @@ function isSubscriptionInstance(value, name) {
 * @returns `true` if the value is a subscriptions store, otherwise `false`
 */
 function isSubscriptions(value) {
-	return isSubscriptionInstance(value, SUBSCRIPTION_STORE);
+	return isSubscriptionInstance(SUBSCRIPTION_STORE, value);
 }
 function removeFromStore(items, values, subscription, value, key) {
 	items.delete(subscription);
@@ -5117,25 +5182,20 @@ function subscriptions(parameters) {
 // src/models/beacon.model.ts
 const BEACON_MESSAGE_RETRIEVE = "Cannot retrieve observable from a closed beacon";
 const BEACON_MESSAGE_SUBSCRIBE = "Cannot subscribe to a closed observable";
-const BEACON_PROPERTY = "$beacon";
 const BEACON_NAME = "beacon";
 const BEACON_OBSERVABLE = "observable";
-const BEACON_SYMBOL = Symbol(BEACON_PROPERTY);
+const BEACON_SYMBOL = Symbol("beacon");
 const BEACON_TYPE_ERROR = "error";
 const BEACON_TYPE_NEXT = "next";
-const beaconSubscription = {
-	key: BEACON_PROPERTY,
-	value: SUBSCRIPTION_NAME
-};
 // src/beacon.ts
 function Beacon(value, options) {
 	this[BEACON_SYMBOL] = {
 		value,
 		active: true,
-		options: createBeaconOptions(options)
+		options: createBeaconOptions(options),
+		name: BEACON_NAME
 	};
 }
-Beacon.prototype[BEACON_PROPERTY] = BEACON_NAME;
 Beacon.prototype.deactivate = deactivateBeacon;
 Beacon.prototype.emit = emitBeaconValue;
 Beacon.prototype.error = emitBeaconError;
@@ -5157,10 +5217,10 @@ Object.defineProperties(Beacon.prototype, {
 function Observable(beacon) {
 	this[BEACON_SYMBOL] = {
 		beacon,
-		active: beacon.active
+		active: beacon.active,
+		name: BEACON_OBSERVABLE
 	};
 }
-Observable.prototype[BEACON_PROPERTY] = BEACON_OBSERVABLE;
 Observable.prototype.deactivate = deactivateObservable;
 Observable.prototype.subscribe = subscribeToObservable;
 Object.defineProperty(Observable.prototype, "active", {
@@ -5251,16 +5311,7 @@ function isBeacon(value) {
 	return isBeaconInstance(BEACON_NAME, value);
 }
 function isBeaconInstance(name, value) {
-	return typeof value === "object" && value !== null && "$beacon" in value && value["$beacon"] === name;
-}
-/**
-* Is the value a beacon subscription?
-*
-* @param value Value to check
-* @returns `true` if the value is a beacon subscription, otherwise `false`
-*/
-function isBeaconSubscription(value) {
-	return isSubscription(value) && value["$beacon"] === "subscription";
+	return typeof value === "object" && value !== null && BEACON_SYMBOL in value && value[BEACON_SYMBOL].name === name;
 }
 /**
 * Is the value an observable?
@@ -5274,7 +5325,7 @@ function isObservable(value) {
 function subscribeToObservable(first, second, third) {
 	const state = this[BEACON_SYMBOL];
 	if (!state.beacon.active || !state.active) throw new Error(BEACON_MESSAGE_SUBSCRIBE);
-	state.beacon.subscriptions ??= subscriptions({ property: beaconSubscription });
+	state.beacon.subscriptions ??= subscriptions();
 	const observer = createObserver(first, second, third);
 	const [subscription] = state.beacon.subscriptions.create({
 		isActive: () => state.beacon.active && state.active,
@@ -5297,27 +5348,21 @@ function updateBeacon(instance, type, value, finish) {
 // src/models/herald.model.ts
 const HERALD_MESSAGE_ARRAY = "Herald requires an array of event names.";
 const HERALD_MESSAGE_ONCREATE = `Herald requires a valid onCreate callback for subscription creation`;
-const HERALD_MESSAGE_PROPERTY = `Herald requires valid property information for subscription identification`;
 const HERALD_NAME_EVENTS = "events";
 const HERALD_NAME_HERALD = "herald";
-const HERALD_PROPERTY = "$herald";
-const HERALD_SYMBOL = Symbol(HERALD_PROPERTY);
-const heraldSubscription = {
-	key: HERALD_PROPERTY,
-	value: SUBSCRIPTION_NAME
-};
+const HERALD_SYMBOL = Symbol("herald");
 // 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;
@@ -5336,22 +5381,10 @@ function createHeraldState(input) {
 	const keys = new Set(options.names);
 	return {
 		keys,
-		store: subscriptions({
-			keys,
-			property: createHeraldSubscriptionProperty(options.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);
@@ -5393,16 +5426,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];
@@ -5483,9 +5507,7 @@ const COLOR_MAX = {
 	hex: 255,
 	percent: 100
 };
-const COLOR_NAME = "color";
-const COLOR_PROPERTY = "$color";
-const COLOR_SYMBOL = Symbol(COLOR_PROPERTY);
+const COLOR_SYMBOL = Symbol("color");
 const COLOR_TYPE = {
 	all: void 0,
 	hex: "hex",
@@ -5520,10 +5542,6 @@ const COLOR_SRGB = {
 	luminanceRed: .2126,
 	luminanceThreshold: .625
 };
-const colorSubscription = {
-	key: COLOR_PROPERTY,
-	value: SUBSCRIPTION_NAME
-};
 // src/color/misc/alpha.ts
 function getAlpha(value, hex) {
 	if (typeof value === "number") return getAlphaFromValue(value);
@@ -5712,7 +5730,7 @@ function isBytey(value) {
 * @returns `true` if the value is a _Color_, otherwise `false`
 */
 function isColor(value) {
-	return typeof value === "object" && value !== null && "$color" in value && value["$color"] === "color";
+	return typeof value === "object" && value !== null && COLOR_SYMBOL in value;
 }
 function isColorValue(value, properties) {
 	if (typeof value !== "object" || value === null) return false;
@@ -6546,13 +6564,11 @@ function Color(value) {
 	this[COLOR_SYMBOL] = {
 		changes: herald({
 			names: [COLOR_TYPE.wildcard, ...COLOR_TYPE.all],
-			property: colorSubscription,
 			onCreate: (event, callback) => onCreateSubscription(this, event, callback)
 		}),
 		values: getColorState(value)
 	};
 }
-Color.prototype[COLOR_PROPERTY] = COLOR_NAME;
 Color.prototype.subscribe = subscribeToColor;
 Color.prototype.toHexString = formatHexColor;
 Color.prototype.toHslString = formatHslColor;
@@ -6770,11 +6786,11 @@ function isObject(value) {
 // src/models/logger.model.ts
 const LOGGER_NAME = "Logger";
 const LOGGER_NAME_TIMED = "TimedLogger";
-const LOGGER_PROPERTY = "$logger";
-const LOGGER_SYMBOL = Symbol(LOGGER_PROPERTY);
+const LOGGER_SYMBOL = Symbol("logger");
 // src/logger.ts
-function Lumberjack() {}
-Lumberjack.prototype[LOGGER_PROPERTY] = LOGGER_NAME;
+function Lumberjack() {
+	this[LOGGER_SYMBOL] = { name: LOGGER_NAME };
+}
 Lumberjack.prototype.time = getTimeLogger;
 Object.defineProperties(Lumberjack.prototype, {
 	debug: { get: getLoggerCallback.bind("debug") },
@@ -6794,6 +6810,7 @@ Object.defineProperties(Lumberjack.prototype, {
 function TimeLogger(label) {
 	this[LOGGER_SYMBOL] = {
 		label,
+		name: LOGGER_NAME_TIMED,
 		started: enabled,
 		stopped: false
 	};
@@ -6802,7 +6819,6 @@ function TimeLogger(label) {
 	};
 	if (this[LOGGER_SYMBOL].started) console.time(label);
 }
-TimeLogger.prototype[LOGGER_PROPERTY] = LOGGER_NAME_TIMED;
 Object.defineProperties(TimeLogger.prototype, {
 	active: {
 		enumerable: true,
@@ -6845,7 +6861,7 @@ function isLogger(value) {
 	return isLoggerInstance(LOGGER_NAME, value);
 }
 function isLoggerInstance(name, value) {
-	return typeof value === "object" && value !== null && "$logger" in value && value["$logger"] === name;
+	return typeof value === "object" && value !== null && LOGGER_SYMBOL in value && value[LOGGER_SYMBOL].name === name;
 }
 /**
 * Is the value a _TimeLogger_?
@@ -7019,21 +7035,20 @@ const QUEUE_MESSAGE_MAXIMUM = "Queue has reached its maximum size";
 const QUEUE_MESSAGE_REMOVE = "Item removed from queue";
 const QUEUE_NAME_KEYED = "keyedQueue";
 const QUEUE_NAME_QUEUE = "queue";
-const QUEUE_PROPERTY = "$queue";
 const QUEUE_STATUS_ACTIVE = "active";
 const QUEUE_STATUS_EMPTY = "empty";
 const QUEUE_STATUS_FULL = "full";
 const QUEUE_STATUS_PAUSED = "paused";
-const QUEUE_SYMBOL = Symbol(QUEUE_PROPERTY);
+const QUEUE_SYMBOL = Symbol("queue");
 // src/queue.ts
 function KeyedQueue(callback, options) {
 	this[QUEUE_SYMBOL] = {
 		callback,
 		options: createQueueOptions(options),
-		queues: /* @__PURE__ */ new Map()
+		queues: /* @__PURE__ */ new Map(),
+		type: QUEUE_NAME_KEYED
 	};
 }
-KeyedQueue.prototype[QUEUE_PROPERTY] = QUEUE_NAME_KEYED;
 KeyedQueue.prototype.add = addKeyedQueue;
 KeyedQueue.prototype.clear = clearQueues;
 KeyedQueue.prototype.get = getQueue;
@@ -7091,10 +7106,10 @@ function Queue(callback, options, key) {
 		id: 0,
 		items: [],
 		paused: !options.autostart,
-		runners: 0
+		runners: 0,
+		type: QUEUE_NAME_QUEUE
 	};
 }
-Queue.prototype[QUEUE_PROPERTY] = QUEUE_NAME_QUEUE;
 Queue.prototype.add = addToQueue;
 Queue.prototype.clear = clearQueue;
 Queue.prototype.pause = pauseQueue;
@@ -7251,9 +7266,9 @@ function getQueueSize() {
 }
 function getStatus(state, status) {
 	const queues = state.queues.entries();
-	const result = [];
-	for (const [key, queue] of queues) if (queue[status]) result.push(key);
-	return result;
+	const queued = [];
+	for (const [key, queue] of queues) if (queue[status]) queued.push(key);
+	return queued;
 }
 function handleQueuedResult(item, error, result) {
 	item.aborter?.cancel();
@@ -7298,7 +7313,7 @@ function isQueue(value) {
 	return isQueueInstance(QUEUE_NAME_QUEUE, value);
 }
 function isQueueInstance(name, value) {
-	return typeof value === "object" && value != null && "$queue" in value && value["$queue"] === name;
+	return typeof value === "object" && value != null && QUEUE_SYMBOL in value && value[QUEUE_SYMBOL].type === name;
 }
 function keyedQueue(callback, options) {
 	if (typeof callback !== "function") throw new TypeError(QUEUE_MESSAGE_CALLBACK);
@@ -7458,6 +7473,9 @@ var SizedSet = class extends Set {
 	get full() {
 		return this.size >= this.#maximumSize;
 	}
+	/**
+	* The maximum size of the _Set_
+	*/
 	get maximum() {
 		return this.#maximumSize;
 	}
@@ -7495,4 +7513,4 @@ var SizedSet = class extends Set {
 		return value;
 	}
 };
-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, filterAndFlatMap, filterAndMap, filterAndMap as select, find, findLast, first, firstOrDefault, flatFreeze, flatMapAndFilter, 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, 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, toCaseCallback, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, unwrapWork, update, upperCase, use, words };
+export { CancelablePromise, Logger, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, TimedError, 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, filterAndFlatMap, filterAndMap, filterAndMap as select, find, findLast, first, firstOrDefault, flatFreeze, flatMapAndFilter, 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, isColor, isConstructor, isEmpty, isError, isFailure, isFrozen, isFulfilled, isFuzzy, isGenerator, isGeneratorFunction, isHerald, isHeraldEvents, 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, 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, toCaseCallback, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, unwrapWork, update, upperCase, use, words };