@oscarpalmer/atoms 0.193.1 → 0.195.0

package/dist/index.mjs

@@ -55,7 +55,7 @@ function findValues(type, array, parameters, mapper) {
 	const { length } = array;
 	const { bool, key, value } = getFindParameters(parameters);
 	const callbacks = getArrayCallbacks(bool, key);
-	if (type === "unique" && callbacks?.keyed == null && length >= UNIQUE_THRESHOLD) {
+	if (type === "unique" && callbacks?.keyed == null && length >= FIND_UNIQUE_THRESHOLD) {
 		result.matched = [...new Set(array)];
 		return result;
 	}
@@ -91,7 +91,7 @@ function getFindParameters(original) {
 const FIND_VALUE_INDEX = "index";
 const FIND_VALUE_ITEM = "item";
 const FIND_VALUES_UNIQUE = "unique";
-const UNIQUE_THRESHOLD = 100;
+const FIND_UNIQUE_THRESHOLD = 100;
 //#endregion
 //#region src/array/filter.ts
 function exclude(array, ...parameters) {
@@ -156,7 +156,7 @@ function chunk(array, size) {
 	if (!Array.isArray(array)) return [];
 	if (array.length === 0) return [];
 	const { length } = array;
-	const actualSize = typeof size === "number" && size > 0 && size <= MAX_SIZE ? size : MAX_SIZE;
+	const actualSize = typeof size === "number" && size > 0 && size <= CHUNK_MAX_SIZE ? size : CHUNK_MAX_SIZE;
 	if (length <= actualSize) return [array];
 	const chunks = [];
 	let index = 0;
@@ -166,7 +166,7 @@ function chunk(array, size) {
 	}
 	return chunks;
 }
-const MAX_SIZE = 5e3;
+const CHUNK_MAX_SIZE = 5e3;
 //#endregion
 //#region src/internal/array/compact.ts
 function compact(array, strict) {
@@ -181,15 +181,6 @@ function compact(array, strict) {
 	return compacted;
 }
 //#endregion
-//#region src/internal/array/index-of.ts
-function indexOf(array, ...parameters) {
-	return findValue(FIND_VALUE_INDEX, array, parameters, false);
-}
-indexOf.last = lastIndexOf;
-function lastIndexOf(array, ...parameters) {
-	return findValue(FIND_VALUE_INDEX, array, parameters, true);
-}
-//#endregion
 //#region src/internal/is.ts
 /**
 * Is the value an array or a plain object?
@@ -365,6 +356,89 @@ function isTypedArray(value) {
 	return isTypedArray.types.has(value?.constructor);
 }
 //#endregion
+//#region src/internal/array/get.ts
+function getArray(value, indiced) {
+	if (Array.isArray(value)) return value;
+	if (value instanceof Map) return [...value.entries()];
+	if (value instanceof Set) return [...value.values()];
+	if (isNonPlainObject(value)) return [value];
+	if (indiced !== true) return Object.entries(value);
+	const keys = Object.keys(value);
+	const { length } = keys;
+	const array = [];
+	for (let index = 0; index < length; index += 1) {
+		const key = keys[index];
+		const asNumber = Number.parseInt(key, 10);
+		if (!Number.isNaN(asNumber)) array[asNumber] = value[key];
+	}
+	return array;
+}
+//#endregion
+//#region src/internal/array/index-of.ts
+function indexOf(array, ...parameters) {
+	return findValue(FIND_VALUE_INDEX, array, parameters, false);
+}
+indexOf.last = lastIndexOf;
+function lastIndexOf(array, ...parameters) {
+	return findValue(FIND_VALUE_INDEX, array, parameters, true);
+}
+//#endregion
+//#region src/internal/array/match.ts
+function endsWithArray(haystack, needle, key) {
+	return endings.has(getPosition(haystack, needle, key)[1]);
+}
+function getArrayComparison(haystack, needle, key) {
+	return getPosition(haystack, needle, key)[1];
+}
+function getName(start, haystack, needle) {
+	if (start === 0) return haystack === needle ? MATCH_COMPARISON_SAME : MATCH_COMPARISON_START;
+	return start + needle === haystack ? MATCH_COMPARISON_END : MATCH_COMPARISON_INSIDE;
+}
+function getPosition(haystack, needle, key) {
+	if (!Array.isArray(haystack) || !Array.isArray(needle)) return invalid;
+	const haystackLength = haystack.length;
+	const needleLength = needle.length;
+	if (haystackLength === 0 || needleLength === 0) return outside;
+	if (needleLength > haystackLength) return outside;
+	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 outside;
+}
+function includesArray(haystack, needle, key) {
+	return !outsides.has(getPosition(haystack, needle, key)[1]);
+}
+function indexOfArray(haystack, needle, key) {
+	return getPosition(haystack, needle, key)[0];
+}
+function startsWithArray(haystack, needle, key) {
+	return starts.has(getPosition(haystack, needle, key)[1]);
+}
+const MATCH_COMPARISON_END = "end";
+const MATCH_COMPARISON_INSIDE = "inside";
+const MATCH_COMPARISON_INVALID = "invalid";
+const MATCH_COMPARISON_OUTSIDE = "outside";
+const MATCH_COMPARISON_SAME = "same";
+const MATCH_COMPARISON_START = "start";
+const endings = /* @__PURE__ */ new Set([MATCH_COMPARISON_END, MATCH_COMPARISON_SAME]);
+const invalid = [-1, MATCH_COMPARISON_INVALID];
+const outside = [-1, MATCH_COMPARISON_OUTSIDE];
+const outsides = /* @__PURE__ */ new Set([MATCH_COMPARISON_INVALID, MATCH_COMPARISON_OUTSIDE]);
+const starts = /* @__PURE__ */ new Set([MATCH_COMPARISON_START, MATCH_COMPARISON_SAME]);
+//#endregion
 //#region src/internal/random.ts
 function getRandomFloatingNumberValue(inclusive, minimum, maximum) {
 	let maxFloat = isNumber(maximum) && maximum <= Number.MAX_SAFE_INTEGER ? maximum : Number.MAX_SAFE_INTEGER;
@@ -416,9 +490,9 @@ function shuffle(array) {
 //#region src/internal/array/sets.ts
 function compareSets(type, first, second, key) {
 	if (!Array.isArray(first)) return [];
-	const isDifference = type === COMPARE_SETS_DIFFERENCE;
-	const isIntersection = type === COMPARE_SETS_INTERSECTION;
-	const isUnion = type === COMPARE_SETS_UNION;
+	const isDifference = type === SETS_COMPARE_DIFFERENCE;
+	const isIntersection = type === SETS_COMPARE_INTERSECTION;
+	const isUnion = type === SETS_COMPARE_UNION;
 	if (first.length === 0) return isDifference ? first.slice() : isIntersection ? [] : second.slice();
 	if (!Array.isArray(second) || second.length === 0) return isIntersection ? [] : first.slice();
 	const callback = getArrayCallback(key);
@@ -439,13 +513,13 @@ function compareSets(type, first, second, key) {
 	}
 	return result;
 }
-const COMPARE_SETS_DIFFERENCE = "difference";
-const COMPARE_SETS_INTERSECTION = "intersection";
-const COMPARE_SETS_UNION = "union";
+const SETS_COMPARE_DIFFERENCE = "difference";
+const SETS_COMPARE_INTERSECTION = "intersection";
+const SETS_COMPARE_UNION = "union";
 //#endregion
 //#region src/array/difference.ts
 function difference(first, second, key) {
-	return compareSets(COMPARE_SETS_DIFFERENCE, first, second, key);
+	return compareSets(SETS_COMPARE_DIFFERENCE, first, second, key);
 }
 //#endregion
 //#region src/array/exists.ts
@@ -498,24 +572,6 @@ function times(length, value) {
 	return values;
 }
 //#endregion
-//#region src/array/get.ts
-function getArray(value, indiced) {
-	if (Array.isArray(value)) return value;
-	if (value instanceof Map) return [...value.entries()];
-	if (value instanceof Set) return [...value.values()];
-	if (isNonPlainObject(value)) return [value];
-	if (indiced !== true) return Object.entries(value);
-	const keys = Object.keys(value);
-	const { length } = keys;
-	const array = [];
-	for (let index = 0; index < length; index += 1) {
-		const key = keys[index];
-		const asNumber = Number.parseInt(key, 10);
-		if (!Number.isNaN(asNumber)) array[asNumber] = value[key];
-	}
-	return array;
-}
-//#endregion
 //#region src/internal/array/insert.ts
 function insertChunkedValues(type, array, items, start, deleteCount) {
 	const actualDeleteCount = deleteCount < 0 ? 0 : deleteCount;
@@ -549,7 +605,7 @@ function insert(array, indexOrItems, items) {
 //#endregion
 //#region src/array/intersection.ts
 function intersection(first, second, key) {
-	return compareSets(COMPARE_SETS_INTERSECTION, first, second, key);
+	return compareSets(SETS_COMPARE_INTERSECTION, first, second, key);
 }
 //#endregion
 //#region src/array/partition.ts
@@ -558,62 +614,6 @@ function partition(array, ...parameters) {
 	return [matched, notMatched];
 }
 //#endregion
-//#region src/array/match.ts
-function endsWithArray(haystack, needle, key) {
-	return endings.has(getPosition(haystack, needle, key)[1]);
-}
-function getArrayComparison(haystack, needle, key) {
-	return getPosition(haystack, needle, key)[1];
-}
-function getName(start, haystack, needle) {
-	if (start === 0) return haystack === needle ? COMPARISON_SAME : COMPARISON_START;
-	return start + needle === haystack ? COMPARISON_END : COMPARISON_INSIDE;
-}
-function getPosition(haystack, needle, key) {
-	if (!Array.isArray(haystack) || !Array.isArray(needle)) return invalid;
-	const haystackLength = haystack.length;
-	const needleLength = needle.length;
-	if (haystackLength === 0 || needleLength === 0) return outside;
-	if (needleLength > haystackLength) return outside;
-	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 outside;
-}
-function includesArray(haystack, needle, key) {
-	return !outsides.has(getPosition(haystack, needle, key)[1]);
-}
-function indexOfArray(haystack, needle, key) {
-	return getPosition(haystack, needle, key)[0];
-}
-function startsWithArray(haystack, needle, key) {
-	return starts.has(getPosition(haystack, needle, key)[1]);
-}
-const COMPARISON_END = "end";
-const COMPARISON_INSIDE = "inside";
-const COMPARISON_INVALID = "invalid";
-const COMPARISON_OUTSIDE = "outside";
-const COMPARISON_SAME = "same";
-const COMPARISON_START = "start";
-const endings = /* @__PURE__ */ new Set([COMPARISON_END, COMPARISON_SAME]);
-const invalid = [-1, COMPARISON_INVALID];
-const outside = [-1, COMPARISON_OUTSIDE];
-const outsides = /* @__PURE__ */ new Set([COMPARISON_INVALID, COMPARISON_OUTSIDE]);
-const starts = /* @__PURE__ */ new Set([COMPARISON_START, COMPARISON_SAME]);
-//#endregion
 //#region src/array/push.ts
 /**
 * Push items into an array _(at the end)_
@@ -669,13 +669,13 @@ const SINGLE_MESSAGE = "Multiple items were found";
 //#endregion
 //#region src/array/slice.ts
 function drop(array, first, second) {
-	return extract(EXTRACT_DROP, array, first, second);
+	return extract(SLICE_DROP, array, first, second);
 }
 function extract(type, array, first, second) {
 	if (!Array.isArray(array)) return [];
 	const { length } = array;
 	if (length === 0) return [];
-	const isTake = type === EXTRACT_TAKE;
+	const isTake = type === SLICE_TAKE;
 	if (typeof first === "number") {
 		if (Math.abs(first) >= length) return isTake ? array.slice() : [];
 		if (first === 0) return isTake ? [] : array.slice();
@@ -713,10 +713,10 @@ function slice(array, first, second) {
 	return first >= 0 ? array.slice(first, second) : array.slice(array.length + first, array.length + second);
 }
 function take(array, first, second) {
-	return extract(EXTRACT_TAKE, array, first, second);
+	return extract(SLICE_TAKE, array, first, second);
 }
-const EXTRACT_DROP = "drop";
-const EXTRACT_TAKE = "take";
+const SLICE_DROP = "drop";
+const SLICE_TAKE = "take";
 //#endregion
 //#region src/array/splice.ts
 function splice(array, start, deleteCountOrItems, items) {
@@ -764,7 +764,7 @@ function toggle(array, values, key) {
 //#endregion
 //#region src/array/union.ts
 function union(first, second, key) {
-	return compareSets(COMPARE_SETS_UNION, first, second, key);
+	return compareSets(SETS_COMPARE_UNION, first, second, key);
 }
 //#endregion
 //#region src/array/unique.ts
@@ -927,7 +927,7 @@ const aggregators = {
 	sum: calculateSum
 };
 //#endregion
-//#region src/internal/string.ts
+//#region src/internal/string/misc.ts
 /**
 * Get the string value from any value
 *
@@ -954,7 +954,7 @@ function getString(value) {
 	return asString.startsWith("[object ") ? JSON.stringify(value) : asString;
 }
 function ignoreKey(key) {
-	return EXPRESSION_IGNORED.test(key);
+	return STRING_EXPRESSION_IGNORED.test(key);
 }
 function interpolate(strings, values) {
 	const { length } = strings;
@@ -1005,10 +1005,10 @@ function tryEncode(value) {
 * @returns Array of words found in the string
 */
 function words(value) {
-	return typeof value === "string" ? value.match(EXPRESSION_WORDS) ?? [] : [];
+	return typeof value === "string" ? value.match(STRING_EXPRESSION_WORDS) ?? [] : [];
 }
-const EXPRESSION_IGNORED = /(^|\.)(__proto__|constructor|prototype)(\.|$)/i;
-const EXPRESSION_WORDS = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
+const STRING_EXPRESSION_IGNORED = /(^|\.)(__proto__|constructor|prototype)(\.|$)/i;
+const STRING_EXPRESSION_WORDS = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
 //#endregion
 //#region src/internal/value/handlers.ts
 function getCompareHandlers(owner, options) {
@@ -1236,8 +1236,10 @@ function getValueSorter(value, modifier) {
 function initializeSorter(first, second) {
 	const sorters = getSorters(first, getModifier(first, second));
 	const sorter = (array) => sortArray(array, sorters);
-	sorter.index = (array, item) => getIndex(array, item, sorters);
-	sorter.is = (array) => isSortedArray(array, sorters);
+	Object.defineProperties(sorter, {
+		index: { value: (array, item) => getIndex(array, item, sorters) },
+		is: { value: (array) => isSortedArray(array, sorters) }
+	});
 	return sorter;
 }
 function isSorted(array, first, second) {
@@ -1379,70 +1381,204 @@ function toRecordArrays(array, first, second) {
 	return groupValues(array, first, second, true);
 }
 //#endregion
-//#region src/internal/result.ts
-function isError(value, extended) {
-	return isResultValue(value, false) && (extended === true ? value.original instanceof Error : true);
-}
-function isOk(value) {
-	return isResultValue(value, true);
-}
+//#region src/internal/function/misc.ts
 /**
-* Is the value a _Result_?
-*
-* @param value Value to check
-* @returns `true` if the value is a _Result_, otherwise `false`
+* A function that does nothing, which can be useful, I guess…
 */
-function isResult(value) {
-	return isResultValue(value, true) || isResultValue(value, false);
-}
-function isResultValue(value, okValue) {
-	if (isNonPlainObject(value)) return false;
-	return value.ok === okValue && (okValue ? PROPERTY_VALUE : PROPERTY_ERROR) in value;
-}
-const PROPERTY_ERROR = "error";
-const PROPERTY_VALUE = "value";
+function noop() {}
 //#endregion
-//#region src/result/misc.ts
-function error(value, original) {
-	return getError(value, original);
+//#region src/internal/function/timer.ts
+function getAsyncTimer(type, callback, time) {
+	function cancel() {
+		clearTimer(id);
+		if (last != null && !last.running) {
+			last.reject();
+			last = void 0;
+		}
+	}
+	async function run(item) {
+		const now = performance.now();
+		start ??= now;
+		if (interval === 0 || now - start >= interval - TIMER_OFFSET) {
+			start = throttle ? now : void 0;
+			item.running = true;
+			try {
+				let result = callback(...item.parameters);
+				if (result instanceof Promise) result = await result;
+				item.resolve(result);
+			} catch (error) {
+				item.reject(error);
+			} finally {
+				item.running = false;
+			}
+		} else id = startTimer(() => run(item));
+	}
+	const interval = getInterval(time);
+	const throttle = type === TIMER_THROTTLE;
+	let id;
+	let last;
+	let start;
+	const timer = (...parameters) => {
+		cancel();
+		const next = {
+			parameters,
+			running: false
+		};
+		next.promise = new Promise((resolve, reject) => {
+			next.reject = reject;
+			next.resolve = resolve;
+		});
+		last = next;
+		if (throttle) run(next);
+		else id = startTimer(() => run(next));
+		return next.promise;
+	};
+	Object.defineProperty(timer, TIMER_CANCEL, { value: () => cancel() });
+	return timer;
 }
-function getError(value, original) {
-	const errorResult = {
-		error: value,
-		ok: false
+function getInterval(value) {
+	return typeof value === "number" && value > 0 ? value : 0;
+}
+function getTimer(type, callback, time) {
+	function cancel() {
+		clearTimer(id);
+	}
+	function run() {
+		const now = performance.now();
+		start ??= now;
+		if (interval === 0 || now - start >= interval - TIMER_OFFSET) {
+			start = throttle ? now : void 0;
+			callback(...args);
+		} else id = startTimer(run);
+	}
+	const interval = getInterval(time);
+	const throttle = type === TIMER_THROTTLE;
+	let args;
+	let id;
+	let start;
+	const timer = (...parameters) => {
+		cancel();
+		args = parameters;
+		if (throttle) run();
+		else id = startTimer(run);
 	};
-	if (original instanceof Error) errorResult.original = original;
-	return errorResult;
+	Object.defineProperty(timer, TIMER_CANCEL, { value: () => cancel() });
+	return timer;
 }
+const TIMER_CANCEL = "cancel";
+const TIMER_DEBOUNCE = "debounce";
+const TIMER_OFFSET = 5;
+const TIMER_THROTTLE = "throttle";
+const TIMER_WAIT = "wait";
+// istanbul ignore next
+const clearTimer = typeof cancelAnimationFrame === "function" ? cancelAnimationFrame : clearTimeout;
+// istanbul ignore next
+const startTimer = typeof requestAnimationFrame === "function" ? requestAnimationFrame : setTimeout;
+//#endregion
+//#region src/function/limit.ts
 /**
-* Creates an ok result
+* Debounce a function, ensuring it is only called after `time` milliseconds have passed
 *
-* @param value Value
-* @returns Ok result
+* - When called, successful _(finished)_ results will resolve and errors will reject
+* - On subsequent calls, existing calls will be canceled _(rejected)_, the timer reset, and will wait another `time` milliseconds before the new call is made _(and so on...)_
+*
+* _Available as `asyncDebounce` and `debounce.async`_
+*
+* @param callback Callback to debounce
+* @param time Time in milliseconds to wait before calling the callback _(defaults to `0`; e.g., as soon as possible)_
+* @returns Debounced callback handler with a `cancel` method
 */
-function ok(value) {
-	return {
-		ok: true,
-		value
-	};
+function asyncDebounce(callback, time) {
+	return getAsyncTimer(TIMER_DEBOUNCE, callback, time);
 }
 /**
-* Converts a _Result_ to a _Promise_
+* Throttle a function, ensuring it is only called once every `time` milliseconds
 *
-* Resolves if ok, rejects for error
+* - When called, successful _(finished)_ results will resolve and errors will reject
+* - On subsequent calls, existing calls will be canceled _(rejected)_ and will wait until the next valid time to call the callback again _(and so on...)_
 *
-* @param result _Result_ to convert
-* @returns Promised result
+* _Available as `asyncThrottle` and `throttle.async`_
+*
+* @param callback Callback to throttle
+* @param time Time in milliseconds to wait before calling the callback again _(defaults to `0`; e.g., as soon as possible)_
+* @returns Throttled callback handler with a `cancel` method
 */
-async function toPromise(result) {
-	const actual = typeof result === "function" ? result() : result;
-	if (!isResult(actual)) return Promise.reject(new Error(MESSAGE_PROMISE_RESULT));
-	return isOk(actual) ? Promise.resolve(actual.value) : Promise.reject(actual.error);
+function asyncThrottle(callback, time) {
+	return getAsyncTimer(TIMER_THROTTLE, callback, time);
+}
+/**
+* Debounce a function, ensuring it is only called after `time` milliseconds have passed
+*
+* On subsequent calls, the timer is reset and will wait another `time` milliseconds _(and so on...)_
+*
+* @param callback Callback to debounce
+* @param time Time in milliseconds to wait before calling the callback _(defaults to `0`; e.g., as soon as possible)_
+* @returns Debounced callback handler with a `cancel` method
+*/
+function debounce(callback, time) {
+	return getTimer(TIMER_DEBOUNCE, callback, time);
+}
+/**
+* Throttle a function, ensuring it is only called once every `time` milliseconds
+*
+* @param callback Callback to throttle
+* @param time Time in milliseconds to wait before calling the callback again _(defaults to `0`; e.g., as soon as possible)_
+* @returns Throttled callback handler with a `cancel` method
+*/
+function throttle(callback, time) {
+	return getTimer(TIMER_THROTTLE, callback, time);
+}
+Object.defineProperty(debounce, "async", { value: asyncDebounce });
+Object.defineProperty(throttle, "async", { value: asyncThrottle });
+//#endregion
+//#region src/internal/result/misc.ts
+function error(value, original) {
+	return getError(value, original);
+}
+function getError(value, original) {
+	const errorResult = {
+		error: value,
+		ok: false
+	};
+	if (original instanceof Error) errorResult.original = original;
+	return errorResult;
+}
+function isError(value, extended) {
+	return isResultValue(value, false) && (extended === true ? value.original instanceof Error : true);
+}
+function isOk(value) {
+	return isResultValue(value, true);
+}
+/**
+* Is the value a _Result_?
+*
+* @param value Value to check
+* @returns `true` if the value is a _Result_, otherwise `false`
+*/
+function isResult(value) {
+	return isResultValue(value, true) || isResultValue(value, false);
+}
+function isResultValue(value, okValue) {
+	if (isNonPlainObject(value)) return false;
+	return value.ok === okValue && (okValue ? RESULT_PROPERTY_VALUE : RESULT_PROPERTY_ERROR) in value;
+}
+/**
+* Creates an ok result
+*
+* @param value Value
+* @returns Ok result
+*/
+function ok(value) {
+	return {
+		ok: true,
+		value
+	};
 }
 function unwrap(value, defaultValue) {
 	return isOk(value) ? value.value : defaultValue;
 }
-const MESSAGE_PROMISE_RESULT = "toPromise expected to receive a Result";
+const RESULT_PROPERTY_ERROR = "error";
+const RESULT_PROPERTY_VALUE = "value";
 //#endregion
 //#region src/internal/value/misc.ts
 function findKey(needle, haystack) {
@@ -1451,8 +1587,8 @@ function findKey(needle, haystack) {
 	return index > -1 ? keys[index] : needle;
 }
 function getNestedValue(data, path, ignoreCase) {
-	if (typeof data !== "object" || data === null) return error(NESTED_MESSAGE_INPUT);
-	if (typeof path !== "string" || path.trim().length === 0) return error(NESTED_MESSAGE_PATH);
+	if (typeof data !== "object" || data === null) return error(MISC_NESTED_MESSAGE_INPUT);
+	if (typeof path !== "string" || path.trim().length === 0) return error(MISC_NESTED_MESSAGE_PATH);
 	const shouldIgnoreCase = ignoreCase === true;
 	const paths = getPaths(path, shouldIgnoreCase);
 	if (typeof paths === "string") return handleValue(data, paths, null, true, shouldIgnoreCase);
@@ -1468,25 +1604,25 @@ function getNestedValue(data, path, ignoreCase) {
 }
 function getPaths(path, lowercase) {
 	const normalized = lowercase ? path.toLowerCase() : path;
-	if (!EXPRESSION_NESTED.test(normalized)) return normalized;
-	return normalized.replace(EXPRESSION_BRACKET, ".$1").replace(EXPRESSION_DOTS, "").split(".");
+	if (!MISC_EXPRESSION_NESTED.test(normalized)) return normalized;
+	return normalized.replace(MISC_EXPRESSION_BRACKET, ".$1").replace(MISC_EXPRESSION_DOTS, "").split(".");
 }
 function handleValue(data, path, value, get, ignoreCase) {
 	if (typeof data === "object" && data !== null) {
-		if (ignoreKey(path)) return error(NESTED_MESSAGE_UNSAFE);
+		if (ignoreKey(path)) return error(MISC_NESTED_MESSAGE_UNSAFE);
 		const key = ignoreCase ? findKey(path, data) : path;
-		if (get) return key in data ? ok(data[key]) : error(NESTED_MESSAGE_MISSING);
+		if (get) return key in data ? ok(data[key]) : error(MISC_NESTED_MESSAGE_MISSING);
 		data[key] = typeof value === "function" ? value(data[key]) : value;
 	}
-	if (get) return error(NESTED_MESSAGE_MISSING);
+	if (get) return error(MISC_NESTED_MESSAGE_MISSING);
 }
-const EXPRESSION_BRACKET = /\[(\w+)\]/g;
-const EXPRESSION_DOTS = /^\.|\.$/g;
-const EXPRESSION_NESTED = /\.|\[\w+\]/;
-const NESTED_MESSAGE_INPUT = "Expected data to be an object";
-const NESTED_MESSAGE_MISSING = "Expected property to exist in object";
-const NESTED_MESSAGE_PATH = "Expected path to be a string";
-const NESTED_MESSAGE_UNSAFE = "Access to this property is not allowed";
+const MISC_EXPRESSION_BRACKET = /\[(\w+)\]/g;
+const MISC_EXPRESSION_DOTS = /^\.|\.$/g;
+const MISC_EXPRESSION_NESTED = /\.|\[\w+\]/;
+const MISC_NESTED_MESSAGE_INPUT = "Expected data to be an object";
+const MISC_NESTED_MESSAGE_MISSING = "Expected property to exist in object";
+const MISC_NESTED_MESSAGE_PATH = "Expected path to be a string";
+const MISC_NESTED_MESSAGE_UNSAFE = "Access to this property is not allowed";
 //#endregion
 //#region src/internal/value/has.ts
 function hasValue(data, path, ignoreCase) {
@@ -1497,7 +1633,7 @@ function hasValueResult(data, path, ignoreCase) {
 	return getNestedValue(data, path, ignoreCase === true);
 }
 //#endregion
-//#region src/function/assert.ts
+//#region src/internal/function/assert.ts
 /**
 * Asserts that a condition is true, throwing an error if it is not
 *
@@ -1538,7 +1674,7 @@ function assertCondition(condition, message, error) {
 * @param error Error constructor _(defaults to `Error`)_
 */
 function assertDefined(value, message, error) {
-	assert(() => value != null, message ?? MESSAGE_VALUE_DEFINED, error);
+	assert(() => value != null, message ?? ASSERT_MESSAGE_VALUE_DEFINED, error);
 }
 /**
 * Creates an _Asserter_ that asserts a value is an instance of a constructor, throwing an error if it is not
@@ -1589,108 +1725,363 @@ function assertProperty(path, condition, message, error) {
 		}, message, error);
 	};
 }
-const MESSAGE_VALUE_DEFINED = "Expected value to be defined";
-//#endregion
-//#region src/internal/function/misc.ts
-/**
-* A function that does nothing, which can be useful, I guess…
-*/
-function noop() {}
+const ASSERT_MESSAGE_VALUE_DEFINED = "Expected value to be defined";
 //#endregion
-//#region src/internal/number.ts
-/**
-* Is the number between a minimum and maximum value?
-*
-* @param value Value to check
-* @param minimum Minimum value
-* @param maximum Maximum value
-* @returns `true` if the value is between the minimum and maximum, otherwise `false`
-*/
-function between(value, minimum, maximum) {
-	if (![
-		value,
-		minimum,
-		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);
-}
+//#region src/function/once.ts
 /**
-* Clamp a number between a minimum and maximum value
+* Create an asynchronous function that can only be called once, rejecting or resolving the same result on subsequent calls
 *
-* @param value Value to clamp
-* @param minimum Minimum value
-* @param maximum Maximum value
-* @param loop If `true`, the value will loop around when smaller than the minimum or larger than the maximum _(defaults to `false`)_
-* @returns Clamped value
+* _Available as `asyncOnce` and `once.async`_
 *
-* @example
-* ```typescript
-* clamp(10, 0, 5);       // => 5
-* clamp(10, 0, 5, true); // => 0
-* ```
+* @param callback Callback to use once
+* @returns _Once_ callback
 */
-function clamp(value, minimum, maximum, loop) {
-	if (![
-		value,
-		minimum,
-		maximum
-	].every(isNumber)) return NaN;
-	if (value < minimum) return loop === true ? maximum : minimum;
-	return value > maximum ? loop === true ? minimum : maximum : value;
+function asyncOnce(callback) {
+	assert(() => typeof callback === "function", ONCE_MESSAGE_EXPECTATION);
+	const state = {
+		called: false,
+		cleared: false,
+		error: false,
+		finished: false,
+		items: [],
+		value: void 0
+	};
+	const fn = (...parameters) => {
+		if (state.cleared) return Promise.reject(new Error(ONCE_MESSAGE_CLEARED));
+		if (state.finished) return state.error ? Promise.reject(state.value) : Promise.resolve(state.value);
+		if (state.called) return new Promise((resolve, reject) => {
+			state.items.push({
+				reject,
+				resolve
+			});
+		});
+		state.called = true;
+		return new Promise((resolve, reject) => {
+			state.items.push({
+				reject,
+				resolve
+			});
+			callback(...parameters).then((value) => {
+				handleOnceResult(state, value, false);
+			}).catch((error) => {
+				handleOnceResult(state, error, true);
+			});
+		});
+	};
+	Object.defineProperties(fn, {
+		called: {
+			enumerable: true,
+			get: () => state.called
+		},
+		clear: { value: () => clearState(state) },
+		cleared: {
+			enumerable: true,
+			get: () => state.cleared
+		},
+		error: {
+			enumerable: true,
+			get: () => state.error
+		},
+		finished: {
+			enumerable: true,
+			get: () => state.finished
+		}
+	});
+	return fn;
+}
+function clearState(state) {
+	if (!state.called || state.cleared) return;
+	state.cleared = true;
+	state.value = void 0;
+}
+function handleOnceResult(state, value, error) {
+	state.error = error;
+	state.finished = true;
+	state.value = value;
+	const items = state.items.splice(0);
+	const { length } = items;
+	for (let index = 0; index < length; index += 1) {
+		const { reject, resolve } = items[index];
+		if (error) reject(value);
+		else resolve(value);
+	}
 }
 /**
-* Get the number value from an unknown value
-*
-* _(Based on Lodash)_
+* Create a function that can only be called once, returning the same value on subsequent calls
 *
-* @param value Original value
-* @returns Original value as a number, or `Number.NaN` if the value is unable to be parsed
+* @param callback Callback to use once
+* @returns _Once_ callback
 */
-function getNumber(value) {
-	if (typeof value === "number") return value;
-	if (typeof value === "bigint" || typeof value === "boolean") return Number(value);
-	if (value == null || typeof value === "symbol") return NaN;
-	if (typeof value === "function") return getNumber(value());
-	let parsed = value.valueOf();
-	if (typeof parsed === "object") parsed = parsed.toString();
-	if (typeof parsed !== "string") return getNumber(parsed);
-	const trimmed = parsed.trim();
-	if (trimmed.length === 0) return NaN;
-	if (EXPRESSION_ZEROISH.test(parsed)) return 0;
-	const isBinary = EXPRESSION_BINARY.test(trimmed);
-	if (isBinary || EXPRESSION_OCTAL.test(trimmed)) return Number.parseInt(trimmed.slice(2), isBinary ? 2 : OCTAL_VALUE);
-	return Number(trimmed);
-}
-function getNumberOrDefault(value, defaultValue, minimum) {
-	return typeof value === "number" && !Number.isNaN(value) && value >= (minimum ?? 0) ? Math.floor(value) : defaultValue;
-}
-const EXPRESSION_BINARY = /^0b[01]+$/i;
-const EXPRESSION_OCTAL = /^0o[0-7]+$/i;
-const EXPRESSION_ZEROISH = /^\s*0+\s*$/;
-const OCTAL_VALUE = 8;
-//#endregion
-//#region src/internal/sized.ts
-function getSizedMaximum(first, second) {
-	let actual;
-	if (typeof first === "number") actual = first;
-	else actual = typeof second === "number" ? second : MAXIMUM_DEFAULT;
-	return clamp(actual, 1, MAXIMUM_ABSOLUTE);
+function once(callback) {
+	assert(() => typeof callback === "function", ONCE_MESSAGE_EXPECTATION);
+	const state = {
+		called: false,
+		cleared: false,
+		value: void 0
+	};
+	const fn = (...parameters) => {
+		if (state.cleared) throw new Error(ONCE_MESSAGE_CLEARED);
+		if (state.called) return state.value;
+		state.called = true;
+		state.value = callback(...parameters);
+		return state.value;
+	};
+	Object.defineProperties(fn, {
+		called: {
+			enumerable: true,
+			get: () => state.called
+		},
+		clear: { value: () => clearState(state) },
+		cleared: {
+			enumerable: true,
+			get: () => state.cleared
+		}
+	});
+	return fn;
 }
-const MAXIMUM_ABSOLUTE = 16777216;
-const MAXIMUM_DEFAULT = 1048576;
+const ONCE_MESSAGE_CLEARED = "Once has been cleared";
+const ONCE_MESSAGE_EXPECTATION = "Once expected a function";
+Object.defineProperty(once, "async", { value: asyncOnce });
 //#endregion
-//#region src/sized/map.ts
+//#region src/function/retry.ts
 /**
-* A _Map_ with a maximum size
-*
-* Behavior is similar to a _LRU_ cache, where the least recently used entries are removed
+* An error thrown when a retry fails
 */
-var SizedMap = class extends Map {
-	/**
-	* The maximum size of the _Map_
-	*/
-	#maximumSize;
+var RetryError = class extends Error {
+	original;
+	constructor(message, original) {
+		super(message);
+		this.original = original;
+		this.name = RETRY_ERROR_NAME;
+	}
+};
+/**
+* Retry a callback a specified number of times, with a delay between attempts
+*
+* _Available as `asyncRetry` and `retry.async`_
+*
+* @param callback Callback to retry
+* @param options Retry options
+* @returns Callback result
+*/
+async function asyncRetry(callback, options) {
+	if (typeof callback !== "function") throw new TypeError(RETRY_MESSAGE_EXPECTATION);
+	async function handle() {
+		try {
+			const result = await callback();
+			resolver(result);
+		} catch (error) {
+			if (attempts >= times || !when(error)) rejector(new RetryError(RETRY_MESSAGE_FAILED, error));
+			else {
+				attempts += 1;
+				timer();
+			}
+		}
+	}
+	const { delay, times, when } = getRetryOptions(options);
+	const timer = getTimer(TIMER_WAIT, handle, delay);
+	let attempts = 0;
+	let rejector;
+	let resolver;
+	return new Promise((resolve, reject) => {
+		rejector = reject;
+		resolver = resolve;
+		handle();
+	});
+}
+function getRetryNumber(value) {
+	return typeof value === "number" && value > 0 ? value : 0;
+}
+function getRetryOptions(input) {
+	const options = isPlainObject(input) ? input : {};
+	return {
+		delay: getRetryNumber(options.delay),
+		times: getRetryNumber(options.times),
+		when: typeof options.when === "function" ? options.when : shouldRetry
+	};
+}
+/**
+* Retry a callback a specified number of times
+*
+* @param callback Callback to retry
+* @param options Retry options
+* @returns Callback result
+*/
+function retry(callback, options) {
+	if (typeof callback !== "function") throw new TypeError(RETRY_MESSAGE_EXPECTATION);
+	const { times, when } = getRetryOptions(options);
+	let last;
+	for (let index = 0; index <= times; index += 1) try {
+		return callback();
+	} catch (error) {
+		if (index >= times || !when(error)) {
+			last = error;
+			break;
+		}
+	}
+	throw new RetryError(RETRY_MESSAGE_FAILED, last);
+}
+function shouldRetry() {
+	return true;
+}
+const RETRY_ERROR_NAME = "RetryError";
+const RETRY_MESSAGE_EXPECTATION = "Retry expected a function";
+const RETRY_MESSAGE_FAILED = "Retry failed";
+Object.defineProperty(retry, "async", { value: asyncRetry });
+//#endregion
+//#region src/internal/function/work.ts
+function asyncFlow(...fns) {
+	assertFlowFunctions(fns);
+	return (...args) => asyncWork(args.map((value) => {
+		if (isError(value)) throw value.error;
+		return isOk(value) ? value.value : value;
+	}), fns, true);
+}
+function flow(...fns) {
+	assertFlowFunctions(fns);
+	return (...args) => work(args.map((value) => {
+		if (isError(value)) throw value.error;
+		return isOk(value) ? value.value : value;
+	}), fns, true);
+}
+async function asyncPipe(value, ...pipes) {
+	assertPipeFunctions(pipes);
+	return asyncWork(value, pipes, false);
+}
+function pipe(value, ...pipes) {
+	assertPipeFunctions(pipes);
+	return work(value, pipes, false);
+}
+async function asyncWork(initial, functions, flow) {
+	const { length } = functions;
+	let transformed = unwrapValue(initial);
+	for (let index = 0; index < length; index += 1) {
+		const fn = functions[index];
+		transformed = unwrapValue(flow && index === 0 && Array.isArray(initial) ? await fn(...initial) : await fn(transformed));
+	}
+	return transformed;
+}
+function unwrapValue(value, flow, nested) {
+	if (typeof value === "function") {
+		if (nested != null) throw new TypeError(WORK_MESSAGE_NESTING);
+		return unwrapValue(value(), flow, true);
+	}
+	if (flow != null && value instanceof Promise) throw new TypeError(flow ? WORK_MESSAGE_FLOW_PROMISE : WORK_MESSAGE_PIPE_PROMISE);
+	if (isError(value)) throw value.error;
+	return isOk(value) ? value.value : value;
+}
+function work(initial, functions, flow) {
+	const { length } = functions;
+	let transformed = unwrapValue(initial, flow);
+	for (let index = 0; index < length; index += 1) {
+		const fn = functions[index];
+		transformed = unwrapValue(flow && index === 0 && Array.isArray(initial) ? fn(...initial) : fn(transformed), flow);
+	}
+	return transformed;
+}
+const WORK_MESSAGE_FLOW_ARRAY = "Flow expected to receive an array of functions";
+const WORK_MESSAGE_FLOW_PROMISE = "Synchronous Flow received a promise. Use `flow.async` instead.";
+const WORK_MESSAGE_NESTING = "Return values are too deeply nested.";
+const WORK_MESSAGE_PIPE_ARRAY = "Pipe expected to receive an array of functions";
+const WORK_MESSAGE_PIPE_PROMISE = "Synchronous Pipe received a promise. Use `pipe.async` instead.";
+const assertFlowFunctions = assert.condition((value) => Array.isArray(value) && value.every((item) => typeof item === "function"), WORK_MESSAGE_FLOW_ARRAY, TypeError);
+const assertPipeFunctions = assert.condition((value) => Array.isArray(value) && value.every((item) => typeof item === "function"), WORK_MESSAGE_PIPE_ARRAY, TypeError);
+flow.async = asyncFlow;
+pipe.async = asyncPipe;
+Object.defineProperty(flow, "async", { value: asyncFlow });
+Object.defineProperty(pipe, "async", { value: asyncPipe });
+//#endregion
+//#region src/internal/number.ts
+/**
+* Is the number between a minimum and maximum value?
+*
+* @param value Value to check
+* @param minimum Minimum value
+* @param maximum Maximum value
+* @returns `true` if the value is between the minimum and maximum, otherwise `false`
+*/
+function between(value, minimum, maximum) {
+	if (![
+		value,
+		minimum,
+		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);
+}
+/**
+* Clamp a number between a minimum and maximum value
+*
+* @param value Value to clamp
+* @param minimum Minimum value
+* @param maximum Maximum value
+* @param loop If `true`, the value will loop around when smaller than the minimum or larger than the maximum _(defaults to `false`)_
+* @returns Clamped value
+*
+* @example
+* ```typescript
+* clamp(10, 0, 5);       // => 5
+* clamp(10, 0, 5, true); // => 0
+* ```
+*/
+function clamp(value, minimum, maximum, loop) {
+	if (![
+		value,
+		minimum,
+		maximum
+	].every(isNumber)) return NaN;
+	if (value < minimum) return loop === true ? maximum : minimum;
+	return value > maximum ? loop === true ? minimum : maximum : value;
+}
+/**
+* Get the number value from an unknown value
+*
+* _(Based on Lodash)_
+*
+* @param value Original value
+* @returns Original value as a number, or `Number.NaN` if the value is unable to be parsed
+*/
+function getNumber(value) {
+	if (typeof value === "number") return value;
+	if (typeof value === "bigint" || typeof value === "boolean") return Number(value);
+	if (value == null || typeof value === "symbol") return NaN;
+	if (typeof value === "function") return getNumber(value());
+	let parsed = value.valueOf();
+	if (typeof parsed === "object") parsed = parsed.toString();
+	if (typeof parsed !== "string") return getNumber(parsed);
+	const trimmed = parsed.trim();
+	if (trimmed.length === 0) return NaN;
+	if (NUMBER_EXPRESSION_ZEROISH.test(parsed)) return 0;
+	const isBinary = NUMBER_EXPRESSION_BINARY.test(trimmed);
+	if (isBinary || NUMBER_EXPRESSION_OCTAL.test(trimmed)) return Number.parseInt(trimmed.slice(2), isBinary ? 2 : NUMBER_OCTAL_VALUE);
+	return Number(trimmed);
+}
+const NUMBER_EXPRESSION_BINARY = /^0b[01]+$/i;
+const NUMBER_EXPRESSION_OCTAL = /^0o[0-7]+$/i;
+const NUMBER_EXPRESSION_ZEROISH = /^\s*0+\s*$/;
+const NUMBER_OCTAL_VALUE = 8;
+//#endregion
+//#region src/internal/sized/misc.ts
+function getSizedMaximum(first, second) {
+	let actual;
+	if (typeof first === "number") actual = first;
+	else actual = typeof second === "number" ? second : SIZED_MAXIMUM_DEFAULT;
+	return clamp(actual, 1, SIZED_MAXIMUM_ABSOLUTE);
+}
+const SIZED_MAXIMUM_ABSOLUTE = 16777216;
+const SIZED_MAXIMUM_DEFAULT = 1048576;
+//#endregion
+//#region src/internal/sized/map.ts
+/**
+* A _Map_ with a maximum size
+*
+* Behavior is similar to a _LRU_ cache, where the least recently used entries are removed
+*/
+var SizedMap = class extends Map {
+	/**
+	* The maximum size of the _Map_
+	*/
+	#maximumSize;
 	/**
 	* Is the _Map_ full?
 	*/
@@ -1734,12 +2125,12 @@ var SizedMap = class extends Map {
 	}
 };
 //#endregion
-//#region src/function/memoize.ts
+//#region src/internal/function/memoize.ts
 function getMemoizationOptions(input) {
 	const { cacheKey, cacheSize } = isPlainObject(input) ? input : {};
 	return {
 		cacheKey: typeof cacheKey === "function" ? cacheKey : void 0,
-		cacheSize: typeof cacheSize === "number" && cacheSize > 0 ? cacheSize : DEFAULT_CACHE_SIZE
+		cacheSize: typeof cacheSize === "number" && cacheSize > 0 ? cacheSize : MEMOIZED_CACHE_SIZE_DEFAULT
 	};
 }
 /**
@@ -1750,818 +2141,326 @@ function getMemoizationOptions(input) {
 * @returns _Memoized_ instance
 */
 function memoize(callback, options) {
-	if (typeof callback !== "function") throw new TypeError(MEMOIZED_ERROR_CALLBACK);
-	const state = { options: getMemoizationOptions(options) };
+	if (typeof callback !== "function") throw new TypeError(MEMOIZED_CALLBACK);
+	const state = {
+		cache: void 0,
+		getter: void 0,
+		options: getMemoizationOptions(options)
+	};
 	state.cache = new SizedMap(state.options.cacheSize);
 	state.getter = (...parameters) => {
-		const key = state.options.cacheKey?.(...parameters) ?? (parameters.length === 1 ? parameters[0] : join(parameters.map(getString), SEPARATOR));
+		const key = state.options.cacheKey?.(...parameters) ?? (parameters.length === 1 ? parameters[0] : join(parameters.map(getString), MEMOIZED_KEY_SEPARATOR));
 		if (state.cache.has(key)) return state.cache.get(key);
 		const value = callback(...parameters);
-		state.cache?.set(key, value);
+		state.cache.set(key, value);
 		return value;
 	};
 	const instance = {
-		clear: () => {
-			state.cache?.clear();
-		},
-		delete: (key) => {
-			return state.cache?.delete(key) ?? false;
-		},
-		destroy: () => {
-			state.cache?.clear();
-			state.cache = void 0;
-			state.getter = void 0;
-		},
-		get: (key) => {
-			return state.cache?.get(key);
-		},
-		has: (key) => {
-			return state.cache?.has(key) ?? false;
-		},
-		run: (...parameters) => {
-			if (state.cache == null || state.getter == null) throw new Error(MEMOIZED_ERROR_DESTROYED);
-			return state.getter(...parameters);
-		}
+		clear: () => state.cache.clear(),
+		delete: (key) => state.cache.delete(key),
+		get: (key) => state.cache.get(key),
+		has: (key) => state.cache.has(key),
+		run: (...parameters) => state.getter(...parameters)
 	};
 	Object.defineProperties(instance, {
 		maximum: {
 			enumerable: true,
-			get: () => state.cache?.maximum ?? NaN
+			get: () => state.cache.maximum
 		},
 		size: {
 			enumerable: true,
-			get: () => state.cache?.size ?? NaN
+			get: () => state.cache.size
 		}
 	});
 	return Object.freeze(instance);
 }
-const DEFAULT_CACHE_SIZE = 1024;
-const MEMOIZED_ERROR_CALLBACK = "Memoized requires a callback function";
-const MEMOIZED_ERROR_DESTROYED = "The Memoized instance has been destroyed";
-const SEPARATOR = "_";
+const MEMOIZED_CACHE_SIZE_DEFAULT = 1024;
+const MEMOIZED_CALLBACK = "Memoized requires a callback function";
+const MEMOIZED_KEY_SEPARATOR = "_";
 //#endregion
-//#region src/internal/function/timer.ts
-function getAsyncTimer(type, callback, time) {
-	async function run(item) {
-		const now = performance.now();
-		start ??= now;
-		if (interval === 0 || now - start >= interval - OFFSET) {
-			start = throttle ? now : void 0;
-			item.running = true;
-			try {
-				let result = callback(...item.parameters);
-				if (result instanceof Promise) result = await result;
-				item.resolve(result);
-			} catch (error) {
-				item.reject(error);
-			} finally {
-				item.running = false;
-			}
-		} else id = startTimer(() => run(item));
-	}
-	const interval = getInterval(time);
-	const throttle = type === TIMER_THROTTLE;
-	let id;
-	let last;
-	let start;
-	const timer = (...parameters) => {
-		timer.cancel();
-		const next = {
-			parameters,
-			running: false
-		};
-		next.promise = new Promise((resolve, reject) => {
-			next.reject = reject;
-			next.resolve = resolve;
-		});
-		last = next;
-		if (throttle) run(next);
-		else id = startTimer(() => {
-			run(next);
-		});
-		return next.promise;
-	};
-	timer.cancel = () => {
-		clearTimer(id);
-		if (last != null && !last.running) last.reject();
-	};
-	return timer;
-}
-function getInterval(value) {
-	return typeof value === "number" && value > 0 ? value : 0;
-}
-function getTimer(type, callback, time) {
-	function run() {
-		const now = performance.now();
-		start ??= now;
-		if (interval === 0 || now - start >= interval - OFFSET) {
-			start = throttle ? now : void 0;
-			callback(...args);
-		} else id = startTimer(run);
-	}
-	const interval = getInterval(time);
-	const throttle = type === TIMER_THROTTLE;
-	let args;
-	let id;
-	let start;
-	const timer = (...parameters) => {
-		timer.cancel();
-		args = parameters;
-		if (throttle) run();
-		else id = startTimer(run);
-	};
-	timer.cancel = () => {
-		clearTimer(id);
-	};
-	return timer;
-}
-const OFFSET = 5;
-const TIMER_DEBOUNCE = "debounce";
-const TIMER_THROTTLE = "throttle";
-const TIMER_WAIT = "wait";
-// istanbul ignore next
-const clearTimer = typeof cancelAnimationFrame === "function" ? cancelAnimationFrame : clearTimeout;
-// istanbul ignore next
-const startTimer = typeof requestAnimationFrame === "function" ? requestAnimationFrame : setTimeout;
-//#endregion
-//#region src/function/limit.ts
+//#region src/internal/string/case.ts
 /**
-* Debounce a function, ensuring it is only called after `time` milliseconds have passed
-*
-* - When called, successful _(finished)_ results will resolve and errors will reject
-* - On subsequent calls, existing calls will be canceled _(rejected)_, the timer reset, and will wait another `time` milliseconds before the new call is made _(and so on...)_
-*
-* _Available as `asyncDebounce` and `debounce.async`_
+* Convert a string to camel case _(thisIsCamelCase)_
 *
-* @param callback Callback to debounce
-* @param time Time in milliseconds to wait before calling the callback _(defaults to `0`; e.g., as soon as possible)_
-* @returns Debounced callback handler with a `cancel` method
+* @param value String to convert
+* @returns Camel-cased string
 */
-function asyncDebounce(callback, time) {
-	return getAsyncTimer(TIMER_DEBOUNCE, callback, time);
+function camelCase(value) {
+	return toCase(STRING_CASE_CAMEL, value, true, false);
 }
 /**
-* Throttle a function, ensuring it is only called once every `time` milliseconds
-*
-* - When called, successful _(finished)_ results will resolve and errors will reject
-* - On subsequent calls, existing calls will be canceled _(rejected)_ and will wait until the next valid time to call the callback again _(and so on...)_
-*
-* _Available as `asyncThrottle` and `throttle.async`_
+* Capitalize the first letter of a string _(and lowercase the rest)_
 *
-* @param callback Callback to throttle
-* @param time Time in milliseconds to wait before calling the callback again _(defaults to `0`; e.g., as soon as possible)_
-* @returns Throttled callback handler with a `cancel` method
+* @param value String to capitalize
+* @returns Capitalized string
 */
-function asyncThrottle(callback, time) {
-	return getAsyncTimer(TIMER_THROTTLE, callback, time);
+function capitalize(value) {
+	if (typeof value !== "string" || value.length === 0) return "";
+	memoizedCapitalize ??= memoize((v) => v.length === 1 ? v.toLocaleUpperCase() : `${v.charAt(0).toLocaleUpperCase()}${v.slice(1).toLocaleLowerCase()}`);
+	return memoizedCapitalize.run(value);
 }
 /**
-* Debounce a function, ensuring it is only called after `time` milliseconds have passed
-*
-* On subsequent calls, the timer is reset and will wait another `time` milliseconds _(and so on...)_
+* Convert a string to kebab case _(this-is-kebab-case)_
 *
-* @param callback Callback to debounce
-* @param time Time in milliseconds to wait before calling the callback _(defaults to `0`; e.g., as soon as possible)_
-* @returns Debounced callback handler with a `cancel` method
+* @param value String to convert
+* @returns Kebab-cased string
 */
-function debounce(callback, time) {
-	return getTimer(TIMER_DEBOUNCE, callback, time);
+function kebabCase(value) {
+	return toCase(STRING_CASE_KEBAB, value, false, false);
 }
-debounce.async = asyncDebounce;
 /**
-* Throttle a function, ensuring it is only called once every `time` milliseconds
+* Convert a string to lower case
 *
-* @param callback Callback to throttle
-* @param time Time in milliseconds to wait before calling the callback again _(defaults to `0`; e.g., as soon as possible)_
-* @returns Throttled callback handler with a `cancel` method
+* @param value String to convert
+* @returns Lower-cased string
 */
-function throttle(callback, time) {
-	return getTimer(TIMER_THROTTLE, callback, time);
+function lowerCase(value) {
+	if (typeof value !== "string") return "";
+	memoizedLowerCase ??= memoize((v) => v.toLocaleLowerCase());
+	return memoizedLowerCase.run(value);
 }
-throttle.async = asyncThrottle;
-//#endregion
-//#region src/function/once.ts
 /**
-* Create an asynchronous function that can only be called once, rejecting or resolving the same result on subsequent calls
-*
-* _Available as `asyncOnce` and `once.async`_
+* Convert a string to pascal case _(ThisIsPascalCase)_
 *
-* @param callback Callback to use once
-* @returns _Once_ callback
+* @param value String to convert
+* @returns Pascal-cased string
 */
-function asyncOnce(callback) {
-	assert(() => typeof callback === "function", ONCE_MESSAGE_EXPECTATION);
-	const state = {
-		called: false,
-		cleared: false,
-		error: false,
-		finished: false,
-		items: [],
-		value: void 0
-	};
-	const fn = (...parameters) => {
-		if (state.cleared) return Promise.reject(new Error(ONCE_MESSAGE_CLEARED));
-		if (state.finished) return state.error ? Promise.reject(state.value) : Promise.resolve(state.value);
-		if (state.called) return new Promise((resolve, reject) => {
-			state.items.push({
-				reject,
-				resolve
-			});
-		});
-		state.called = true;
-		return new Promise((resolve, reject) => {
-			state.items.push({
-				reject,
-				resolve
-			});
-			callback(...parameters).then((value) => {
-				handleOnceResult(state, value, false);
-			}).catch((error) => {
-				handleOnceResult(state, error, true);
-			});
-		});
-	};
-	Object.defineProperties(fn, {
-		called: {
-			enumerable: true,
-			get: () => state.called
-		},
-		cleared: {
-			enumerable: true,
-			get: () => state.cleared
-		},
-		error: {
-			enumerable: true,
-			get: () => state.error
-		},
-		finished: {
-			enumerable: true,
-			get: () => state.finished
-		}
-	});
-	fn.clear = () => {
-		if (!state.called || !state.finished || state.cleared) return;
-		state.cleared = true;
-		state.value = void 0;
-	};
-	return fn;
-}
-function handleOnceResult(state, value, error) {
-	state.error = error;
-	state.finished = true;
-	state.value = value;
-	const items = state.items.splice(0);
-	const { length } = items;
-	for (let index = 0; index < length; index += 1) {
-		const { reject, resolve } = items[index];
-		if (error) reject(value);
-		else resolve(value);
-	}
+function pascalCase(value) {
+	return toCase(STRING_CASE_PASCAL, value, true, true);
 }
 /**
-* Create a function that can only be called once, returning the same value on subsequent calls
+* Convert a string to snake case _(this_is_snake_case)_
 *
-* @param callback Callback to use once
-* @returns _Once_ callback
+* @param value String to convert
+* @returns Snake-cased string
 */
-function once(callback) {
-	assert(() => typeof callback === "function", ONCE_MESSAGE_EXPECTATION);
-	const state = {
-		called: false,
-		cleared: false,
-		value: void 0
-	};
-	const fn = (...parameters) => {
-		if (state.cleared) throw new Error(ONCE_MESSAGE_CLEARED);
-		if (state.called) return state.value;
-		state.called = true;
-		state.value = callback(...parameters);
-		return state.value;
-	};
-	Object.defineProperties(fn, {
-		called: { get: () => state.called },
-		cleared: { get: () => state.cleared }
-	});
-	fn.clear = () => {
-		if (!state.called || state.cleared) return;
-		state.cleared = true;
-		state.value = void 0;
-	};
-	return fn;
+function snakeCase(value) {
+	return toCase(STRING_CASE_SNAKE, value, false, false);
 }
-once.async = asyncOnce;
-const ONCE_MESSAGE_CLEARED = "Once has been cleared";
-const ONCE_MESSAGE_EXPECTATION = "Once expected a function";
-//#endregion
-//#region src/function/retry.ts
 /**
-* An error thrown when a retry fails
+* Convert a string to title case _(Capitalizing Every Word)_
+*
+* @param value String to convert
+* @returns Title-cased string
 */
-var RetryError = class extends Error {
-	original;
-	constructor(message, original) {
-		super(message);
-		this.original = original;
-		this.name = RETRY_ERROR_NAME;
+function titleCase(value) {
+	if (typeof value !== "string" || value.length === 0) return "";
+	memoizedTitleCase ??= memoize((v) => v.length < 2 ? capitalize(v) : join(words(v).map(capitalize), " "));
+	return memoizedTitleCase.run(value);
+}
+function toCase(type, value, capitalizeAny, capitalizeFirst) {
+	caseMemoizers[type] ??= memoize(toCaseCallback.bind({
+		type,
+		capitalizeAny,
+		capitalizeFirst
+	}));
+	return caseMemoizers[type].run(value);
+}
+function toCaseCallback(value) {
+	if (typeof value !== "string") return "";
+	if (value.length < 1) return value;
+	const { capitalizeAny, capitalizeFirst, type } = this;
+	const parts = words(value);
+	const partsLength = parts.length;
+	const cased = [];
+	for (let partIndex = 0; partIndex < partsLength; partIndex += 1) {
+		const items = parts[partIndex].replace(STRING_EXPRESSION_ACRONYM, (full, one, two, three) => three === STRING_S ? full : `${one}-${two}${three}`).replace(STRING_EXPRESSION_CAMEL_CASE, STRING_REPLACEMENT_CAMEL_CASE).split("-");
+		const itemsLength = items.length;
+		const partResult = [];
+		let itemCount = 0;
+		for (let itemIndex = 0; itemIndex < itemsLength; itemIndex += 1) {
+			const item = items[itemIndex];
+			if (item.length === 0) continue;
+			if (!capitalizeAny || itemCount === 0 && partIndex === 0 && !capitalizeFirst) partResult.push(item.toLocaleLowerCase());
+			else partResult.push(capitalize(item));
+			itemCount += 1;
+		}
+		cased.push(join(partResult, delimiters[type]));
 	}
-};
+	return join(cased, delimiters[type]);
+}
 /**
-* Retry a callback a specified number of times, with a delay between attempts
-*
-* _Available as `asyncRetry` and `retry.async`_
+* Convert a string to upper case
 *
-* @param callback Callback to retry
-* @param options Retry options
-* @returns Callback result
+* @param value String to convert
+* @returns Upper-cased string
 */
-async function asyncRetry(callback, options) {
-	if (typeof callback !== "function") throw new TypeError(RETRY_MESSAGE_EXPECTATION);
-	async function handle() {
-		try {
-			const result = await callback();
-			resolver(result);
-		} catch (error) {
-			if (attempts >= times || !when(error)) rejector(new RetryError(RETRY_MESSAGE_FAILED, error));
-			else {
-				attempts += 1;
-				timer();
-			}
-		}
-	}
-	const { delay, times, when } = getRetryOptions(options);
-	const timer = getTimer(TIMER_WAIT, handle, delay);
-	let attempts = 0;
-	let rejector;
-	let resolver;
-	return new Promise((resolve, reject) => {
-		rejector = reject;
-		resolver = resolve;
-		handle();
-	});
-}
-function getRetryNumber(value) {
-	return typeof value === "number" && value > 0 ? value : 0;
-}
-function getRetryOptions(input) {
-	const options = isPlainObject(input) ? input : {};
-	return {
-		delay: getRetryNumber(options.delay),
-		times: getRetryNumber(options.times),
-		when: typeof options.when === "function" ? options.when : shouldRetry
-	};
+function upperCase(value) {
+	if (typeof value !== "string" || value.length === 0) return "";
+	memoizedUpperCase ??= memoize((v) => v.toLocaleUpperCase());
+	return memoizedUpperCase.run(value);
 }
+const STRING_CASE_CAMEL = "camel";
+const STRING_CASE_KEBAB = "kebab";
+const STRING_CASE_PASCAL = "pascal";
+const STRING_CASE_SNAKE = "snake";
+const STRING_DELIMTER_EMPTY = "";
+const STRING_DELIMITER_HYPHEN = "-";
+const STRING_DELIMITER_UNDERSCORE = "_";
+const STRING_EXPRESSION_CAMEL_CASE = /(\p{Ll})(\p{Lu})/gu;
+const STRING_EXPRESSION_ACRONYM = /(\p{Lu}*)(\p{Lu})(\p{Ll}+)/gu;
+const STRING_REPLACEMENT_CAMEL_CASE = "$1-$2";
+const STRING_S = "s";
+const caseMemoizers = {};
+const delimiters = {
+	[STRING_CASE_CAMEL]: STRING_DELIMTER_EMPTY,
+	[STRING_CASE_KEBAB]: STRING_DELIMITER_HYPHEN,
+	[STRING_CASE_PASCAL]: STRING_DELIMTER_EMPTY,
+	[STRING_CASE_SNAKE]: STRING_DELIMITER_UNDERSCORE
+};
+let memoizedCapitalize;
+let memoizedLowerCase;
+let memoizedTitleCase;
+let memoizedUpperCase;
+//#endregion
+//#region src/internal/value/equal.ts
 /**
-* Retry a callback a specified number of times
+* Deregister a equality comparison handler for a specific class
 *
-* @param callback Callback to retry
-* @param options Retry options
-* @returns Callback result
+* _Available as `deregisterEqualizer` and `equal.deregister`_
+*
+* @param constructor Class constructor
 */
-function retry(callback, options) {
-	if (typeof callback !== "function") throw new TypeError(RETRY_MESSAGE_EXPECTATION);
-	const { times, when } = getRetryOptions(options);
-	let last;
-	for (let index = 0; index <= times; index += 1) try {
-		return callback();
-	} catch (error) {
-		if (index >= times || !when(error)) {
-			last = error;
-			break;
-		}
-	}
-	throw new RetryError(RETRY_MESSAGE_FAILED, last);
+function deregisterEqualizer(constructor) {
+	equal.handlers.deregister(constructor);
 }
-retry.async = asyncRetry;
-function shouldRetry() {
+function filterKey(key, options) {
+	if (typeof key !== "string") return true;
+	if (options.ignoreExpressions.enabled && options.ignoreExpressions.values.some((expression) => expression.test(key))) return false;
+	if (options.ignoreKeys.enabled && options.ignoreKeys.values.has(key)) return false;
 	return true;
 }
-const RETRY_ERROR_NAME = "RetryError";
-const RETRY_MESSAGE_EXPECTATION = "Retry expected a function";
-const RETRY_MESSAGE_FAILED = "Retry failed";
-//#endregion
-//#region src/function/work.ts
-function asyncFlow(...fns) {
-	assertFlowFunctions(fns);
-	return (...args) => asyncWork(args.map((value) => {
-		if (isError(value)) throw value.error;
-		return isOk(value) ? value.value : value;
-	}), fns, true);
+function equal(first, second, options) {
+	return equalValue(first, second, getEqualOptions(options));
 }
-function flow(...fns) {
-	assertFlowFunctions(fns);
-	return (...args) => work(args.map((value) => {
-		if (isError(value)) throw value.error;
-		return isOk(value) ? value.value : value;
-	}), fns, true);
+equal.handlers = getCompareHandlers(equal, { callback: Object.is });
+equal.deregister = deregisterEqualizer;
+equal.initialize = initializeEqualizer;
+equal.register = registerEqualizer;
+function equalArray(first, second, options) {
+	const { length } = first;
+	if (length !== second.length) return false;
+	let offset = 0;
+	if (length >= EQUAL_ARRAY_THRESHOLD) {
+		offset = Math.round(length / EQUAL_ARRAY_PEEK_PERCENTAGE);
+		offset = offset > EQUAL_ARRAY_THRESHOLD ? EQUAL_ARRAY_THRESHOLD : offset;
+		for (let index = 0; index < offset; index += 1) if (!(equalValue(first[index], second[index], options) && equalValue(first[length - index - 1], second[length - index - 1], options))) return false;
+	}
+	const end = length - offset;
+	for (let index = offset; index < end; index += 1) if (!equalValue(first[index], second[index], options)) return false;
+	return true;
 }
-flow.async = asyncFlow;
-async function asyncPipe(value, ...pipes) {
-	assertPipeFunctions(pipes);
-	return asyncWork(value, pipes, false);
+function equalArrayBuffer(first, second, options) {
+	return first.byteLength === second.byteLength ? equalArray(new Uint8Array(first), new Uint8Array(second), options) : false;
 }
-function pipe(value, ...pipes) {
-	assertPipeFunctions(pipes);
-	return work(value, pipes, false);
+function equalDataView(first, second, options) {
+	return first.byteOffset === second.byteOffset ? equalArrayBuffer(first.buffer, second.buffer, options) : false;
 }
-pipe.async = asyncPipe;
-async function asyncWork(initial, functions, flow) {
-	const { length } = functions;
-	let transformed = unwrapValue(initial);
-	for (let index = 0; index < length; index += 1) {
-		const fn = functions[index];
-		transformed = unwrapValue(flow && index === 0 && Array.isArray(initial) ? await fn(...initial) : await fn(transformed));
+function equalMap(first, second, options) {
+	const { size } = first;
+	if (size !== second.size) return false;
+	const firstKeys = [...first.keys()];
+	for (let index = 0; index < size; index += 1) {
+		const key = firstKeys[index];
+		if (!second.has(key) || !equalValue(first.get(key), second.get(key), options)) return false;
 	}
-	return transformed;
+	return true;
 }
-function unwrapValue(value, flow, nested) {
-	if (typeof value === "function") {
-		if (nested != null) throw new TypeError(MESSAGE_NESTING);
-		return unwrapValue(value(), flow, true);
+function equalPlainObject(first, second, options) {
+	let firstKeys = [...Object.keys(first), ...Object.getOwnPropertySymbols(first)];
+	let secondKeys = [...Object.keys(second), ...Object.getOwnPropertySymbols(second)];
+	if (options.ignoreKeys.enabled || options.ignoreExpressions.enabled) {
+		firstKeys = firstKeys.filter((key) => filterKey(key, options));
+		secondKeys = secondKeys.filter((key) => filterKey(key, options));
 	}
-	if (flow != null && value instanceof Promise) throw new TypeError(flow ? MESSAGE_FLOW_PROMISE : MESSAGE_PIPE_PROMISE);
-	if (isError(value)) throw value.error;
-	return isOk(value) ? value.value : value;
+	const secondSet = secondKeys.length >= EQUAL_MINIMUM_LENGTH_FOR_SET ? new Set(secondKeys) : void 0;
+	const { length } = firstKeys;
+	if (length !== secondKeys.length) return false;
+	for (let index = 0; index < length; index += 1) {
+		const key = firstKeys[index];
+		if (!(secondSet?.has(key) ?? secondKeys.includes(key)) || !equalValue(first[key], second[key], options)) return false;
+	}
+	return true;
 }
-function work(initial, functions, flow) {
-	const { length } = functions;
-	let transformed = unwrapValue(initial, flow);
+function equalProperties(first, second, properties, options) {
+	const { length } = properties;
 	for (let index = 0; index < length; index += 1) {
-		const fn = functions[index];
-		transformed = unwrapValue(flow && index === 0 && Array.isArray(initial) ? fn(...initial) : fn(transformed), flow);
+		const property = properties[index];
+		if (!equalValue(first[property], second[property], options)) return false;
 	}
-	return transformed;
+	return true;
 }
-const MESSAGE_FLOW_ARRAY = "Flow expected to receive an array of functions";
-const MESSAGE_FLOW_PROMISE = "Synchronous Flow received a promise. Use `flow.async` instead.";
-const MESSAGE_NESTING = "Return values are too deeply nested.";
-const MESSAGE_PIPE_ARRAY = "Pipe expected to receive an array of functions";
-const MESSAGE_PIPE_PROMISE = "Synchronous Pipe received a promise. Use `pipe.async` instead.";
-const assertFlowFunctions = assert.condition((value) => Array.isArray(value) && value.every((item) => typeof item === "function"), MESSAGE_FLOW_ARRAY, TypeError);
-const assertPipeFunctions = assert.condition((value) => Array.isArray(value) && value.every((item) => typeof item === "function"), MESSAGE_PIPE_ARRAY, TypeError);
-//#endregion
-//#region src/herald.ts
-function getEvents(herald) {
-	const events = {
-		subscribe: (event, callback) => herald.subscribe(event, callback),
-		unsubscribe: (event, callback) => herald.unsubscribe(event, callback)
-	};
-	Object.defineProperty(events, KEY_HERALD, {
-		enumerable: false,
-		value: NAME_EVENTS
-	});
-	return Object.freeze(events);
+function equalSet(first, second, options) {
+	const { size } = first;
+	if (size !== second.size) return false;
+	const firstValues = [...first];
+	const secondValues = [...second];
+	for (let index = 0; index < size; index += 1) {
+		const firstValue = firstValues[index];
+		if (isPrimitive(firstValue) ? !second.has(firstValue) : !secondValues.some((secondValue) => equalValue(firstValue, secondValue, options))) return false;
+	}
+	return true;
 }
-/**
-* Create a _Herald_ for announcing named events
-*
-* @param names Event names
-* @returns _Herald_ instance
-*/
-function herald(names) {
-	if (!Array.isArray(names) || names.length === 0 || !names.every((name) => typeof name === "string")) throw new Error(MESSAGE);
-	const set = new Set(names);
-	const subscribers = /* @__PURE__ */ new Map();
-	const instance = {
-		clear() {
-			subscribers.clear();
-		},
-		emit(event, ...parameters) {
-			const callbacks = subscribers.get(event);
-			if (callbacks == null) return;
-			for (const callback of callbacks) callback(...parameters);
+function equalTypedArray(first, second) {
+	if (first.constructor !== second.constructor) return false;
+	if (first.byteLength !== second.byteLength) return false;
+	const { length } = first;
+	for (let index = 0; index < length; index += 1) if (first[index] !== second[index]) return false;
+	return true;
+}
+function equalValue(first, second, options) {
+	if (options.relaxedNullish && first == null && second == null) return true;
+	switch (true) {
+		case Object.is(first, second): return true;
+		case first == null || second == null: return first === second;
+		case typeof first !== typeof second: return false;
+		case typeof first === "string" && options.ignoreCase === true: return Object.is(first.toLocaleLowerCase(), second.toLocaleLowerCase());
+		case first instanceof ArrayBuffer && second instanceof ArrayBuffer: return equalArrayBuffer(first, second, options);
+		case first instanceof Date && second instanceof Date: return Object.is(first.getTime(), second.getTime());
+		case first instanceof DataView && second instanceof DataView: return equalDataView(first, second, options);
+		case first instanceof Error && second instanceof Error: return equalProperties(first, second, EQUAL_ERROR_PROPERTIES, options);
+		case first instanceof Map && second instanceof Map: return equalMap(first, second, options);
+		case first instanceof RegExp && second instanceof RegExp: return equalProperties(first, second, EQUAL_EXPRESSION_PROPERTIES, options);
+		case first instanceof Set && second instanceof Set: return equalSet(first, second, options);
+		case Array.isArray(first) && Array.isArray(second): return equalArray(first, second, options);
+		case isPlainObject(first) && isPlainObject(second): return equalPlainObject(first, second, options);
+		case isTypedArray(first) && isTypedArray(second): return equalTypedArray(first, second);
+		default: return equal.handlers.handle(first, second, options);
+	}
+}
+function getEqualOptions(input) {
+	const options = {
+		ignoreCase: false,
+		ignoreExpressions: {
+			enabled: false,
+			values: []
 		},
-		subscribe(event, callback) {
-			if (!set.has(event) || typeof callback !== "function") return noop;
-			let eventSubscribers = subscribers.get(event);
-			if (eventSubscribers == null) {
-				eventSubscribers = /* @__PURE__ */ new Set();
-				subscribers.set(event, eventSubscribers);
-			}
-			eventSubscribers.add(callback);
-			return () => {
-				eventSubscribers?.delete(callback);
-			};
+		ignoreKeys: {
+			enabled: false,
+			values: /* @__PURE__ */ new Set()
 		},
-		unsubscribe(event, callback) {
-			if (!set.has(event) || (callback != null ? typeof callback !== "function" : false)) return;
-			const eventSubscribers = subscribers.get(event);
-			if (eventSubscribers == null) return;
-			if (callback == null) eventSubscribers.clear();
-			else eventSubscribers.delete(callback);
-			if (callback == null || eventSubscribers.size === 0) subscribers.delete(event);
-		}
+		relaxedNullish: false
 	};
-	Object.defineProperties(instance, {
-		[KEY_HERALD]: {
-			enumerable: false,
-			value: NAME_HERALD
-		},
-		events: {
-			enumerable: true,
-			value: getEvents(instance)
-		}
-	});
-	return Object.freeze(instance);
+	if (typeof input === "boolean") {
+		options.ignoreCase = input;
+		return options;
+	}
+	if (isNonPlainObject(input)) return options;
+	options.ignoreCase = typeof input.ignoreCase === "boolean" ? input.ignoreCase : false;
+	options.ignoreExpressions.values = (Array.isArray(input.ignoreKeys) ? input.ignoreKeys : [input.ignoreKeys]).filter((key) => key instanceof RegExp);
+	options.ignoreKeys.values = new Set((Array.isArray(input.ignoreKeys) ? input.ignoreKeys : [input.ignoreKeys]).filter((key) => typeof key === "string"));
+	options.ignoreExpressions.enabled = options.ignoreExpressions.values.length > 0;
+	options.ignoreKeys.enabled = options.ignoreKeys.values.size > 0;
+	options.relaxedNullish = input.relaxedNullish === true;
+	return options;
 }
 /**
-* Is the value events for a herald?
+* Create an equalizer with predefined options
 *
-* @param value Value to check
-* @returns `true` if the value is events for a herald, otherwise `false`
-*/
-function isEvents(value) {
-	return isHeraldInstance(NAME_EVENTS, value);
-}
-/**
-* Is the value a herald?
+* _Available as `initializeEqualizer` and `equal.initialize`_
 *
-* @param value Value to check
-* @returns `true` if the value is a herald, otherwise `false`
-*/
-function isHerald(value) {
-	return isHeraldInstance(NAME_HERALD, value);
-}
-function isHeraldInstance(name, value) {
-	return typeof value === "object" && value != null && KEY_HERALD in value && value[KEY_HERALD] === name;
-}
-const KEY_HERALD = "$herald";
-const MESSAGE = "Herald requires an array of event names.";
-const NAME_EVENTS = "events";
-const NAME_HERALD = "herald";
-//#endregion
-//#region src/internal/subscription.ts
-function addSubscription(subscription, state) {
-	const { key, subscriptions, value } = state.parameters;
-	const { items, values } = subscriptions;
-	if (key == null) {
-		items.any.add(subscription);
-		values.from.any.set(value, subscription);
-		values.to.any.set(subscription, value);
-		return;
-	}
-	if (items.keyed == null || values.from.keyed == null || values.to.keyed == null)
- // istanbul ignore next
-	return;
-	let keyedItems = items.keyed.get(key);
-	if (keyedItems == null) {
-		keyedItems = /* @__PURE__ */ new Set();
-		items.keyed.set(key, keyedItems);
-	}
-	keyedItems.add(subscription);
-	let keyedFrom = values.from.keyed.get(key);
-	if (keyedFrom == null) {
-		keyedFrom = /* @__PURE__ */ new Map();
-		values.from.keyed.set(key, keyedFrom);
-	}
-	keyedFrom.set(value, subscription);
-	let keyedTo = values.to.keyed.get(key);
-	if (keyedTo == null) {
-		keyedTo = /* @__PURE__ */ new Map();
-		values.to.keyed.set(key, keyedTo);
-	}
-	keyedTo.set(subscription, value);
-}
-function clearSubscriptions(store) {
-	for (const susbcription of store.values.to.any.keys()) susbcription.unsubscribe();
-	if (store.values.to.keyed != null) for (const values of store.values.to.keyed.values()) for (const susbcription of values.keys()) susbcription.unsubscribe();
-}
-function getExistingSubscription(state) {
-	const { parameters } = state;
-	const { values } = parameters.subscriptions;
-	return parameters.key == null ? values.from.any.get(parameters.value) : values.from.keyed?.get(parameters.key)?.get(parameters.value);
-}
-function getSubscription(parameters) {
-	const state = {
-		parameters,
-		active: true
-	};
-	const existing = getExistingSubscription(state);
-	if (existing != null) return existing;
-	if (parameters.subscriptions.keys != null && parameters.key != null && !parameters.subscriptions.keys.has(parameters.key)) throw new Error();
-	const instance = { unsubscribe: () => {
-		removeSubscription(instance, state);
-	} };
-	Object.defineProperties(instance, {
-		[PROPERTY]: {
-			enumerable: false,
-			value: true
-		},
-		[parameters.property.key]: {
-			enumerable: false,
-			value: parameters.property.value
-		},
-		active: {
-			enumerable: true,
-			get: () => (parameters.isActive?.() ?? true) && state.active
-		}
-	});
-	addSubscription(instance, state);
-	return Object.freeze(instance);
-}
-function getSubscriptions(keys) {
-	return {
-		keys,
-		items: {
-			any: /* @__PURE__ */ new Set(),
-			keyed: keys == null ? void 0 : /* @__PURE__ */ new Map()
-		},
-		values: {
-			from: {
-				any: /* @__PURE__ */ new Map(),
-				keyed: keys == null ? void 0 : /* @__PURE__ */ new Map()
-			},
-			to: {
-				any: /* @__PURE__ */ new Map(),
-				keyed: keys == null ? void 0 : /* @__PURE__ */ new Map()
-			}
-		}
-	};
-}
-/**
-* Is the value a subscription?
-*
-* @param value Value to check
-* @returns `true` if the value is a subscription, otherwise `false`
-*/
-function isSubscription(value) {
-	return isPlainObject(value) && PROPERTY in value && value[PROPERTY] === true;
-}
-function removeFromStore(items, values, subscription, value, key) {
-	items.delete(subscription);
-	if (key == null) {
-		values.from.any.delete(value);
-		values.to.any.delete(subscription);
-	} else {
-		values.from.keyed?.get(key)?.delete(value);
-		values.to.keyed?.get(key)?.delete(subscription);
-	}
-}
-function removeSubscription(subscription, state) {
-	if (!state.active) return;
-	state.active = false;
-	const { key, subscriptions, value } = state.parameters;
-	const { items, values } = subscriptions;
-	if (key == null) {
-		removeFromStore(items.any, values, subscription, value);
-		return;
-	}
-	const keyed = items.keyed?.get(key);
-	if (items.keyed == null || keyed == null)
- // istanbul ignore next
-	return;
-	removeFromStore(keyed, values, subscription, value, key);
-	if (keyed.size === 0) items.keyed.delete(key);
-}
-const PROPERTY = "$subscription";
-//#endregion
-//#region src/internal/value/equal.ts
-/**
-* Deregister a equality comparison handler for a specific class
-*
-* _Available as `deregisterEqualizer` and `equal.deregister`_
-*
-* @param constructor Class constructor
-*/
-function deregisterEqualizer(constructor) {
-	equal.handlers.deregister(constructor);
-}
-function filterKey(key, options) {
-	if (typeof key !== "string") return true;
-	if (options.ignoreExpressions.enabled && options.ignoreExpressions.values.some((expression) => expression.test(key))) return false;
-	if (options.ignoreKeys.enabled && options.ignoreKeys.values.has(key)) return false;
-	return true;
-}
-function equal(first, second, options) {
-	return equalValue(first, second, getEqualOptions(options));
-}
-equal.handlers = getCompareHandlers(equal, { callback: Object.is });
-equal.deregister = deregisterEqualizer;
-equal.initialize = initializeEqualizer;
-equal.register = registerEqualizer;
-function equalArray(first, second, options) {
-	const { length } = first;
-	if (length !== second.length) return false;
-	let offset = 0;
-	if (length >= EQUAL_ARRAY_THRESHOLD) {
-		offset = Math.round(length / EQUAL_ARRAY_PEEK_PERCENTAGE);
-		offset = offset > EQUAL_ARRAY_THRESHOLD ? EQUAL_ARRAY_THRESHOLD : offset;
-		for (let index = 0; index < offset; index += 1) if (!(equalValue(first[index], second[index], options) && equalValue(first[length - index - 1], second[length - index - 1], options))) return false;
-	}
-	const end = length - offset;
-	for (let index = offset; index < end; index += 1) if (!equalValue(first[index], second[index], options)) return false;
-	return true;
-}
-function equalArrayBuffer(first, second, options) {
-	return first.byteLength === second.byteLength ? equalArray(new Uint8Array(first), new Uint8Array(second), options) : false;
-}
-function equalDataView(first, second, options) {
-	return first.byteOffset === second.byteOffset ? equalArrayBuffer(first.buffer, second.buffer, options) : false;
-}
-function equalMap(first, second, options) {
-	const { size } = first;
-	if (size !== second.size) return false;
-	const firstKeys = [...first.keys()];
-	for (let index = 0; index < size; index += 1) {
-		const key = firstKeys[index];
-		if (!second.has(key) || !equalValue(first.get(key), second.get(key), options)) return false;
-	}
-	return true;
-}
-function equalPlainObject(first, second, options) {
-	let firstKeys = [...Object.keys(first), ...Object.getOwnPropertySymbols(first)];
-	let secondKeys = [...Object.keys(second), ...Object.getOwnPropertySymbols(second)];
-	if (options.ignoreKeys.enabled || options.ignoreExpressions.enabled) {
-		firstKeys = firstKeys.filter((key) => filterKey(key, options));
-		secondKeys = secondKeys.filter((key) => filterKey(key, options));
-	}
-	const secondSet = secondKeys.length >= MINIMUM_LENGTH_FOR_SET ? new Set(secondKeys) : void 0;
-	const { length } = firstKeys;
-	if (length !== secondKeys.length) return false;
-	for (let index = 0; index < length; index += 1) {
-		const key = firstKeys[index];
-		if (!(secondSet?.has(key) ?? secondKeys.includes(key)) || !equalValue(first[key], second[key], options)) return false;
-	}
-	return true;
-}
-function equalProperties(first, second, properties, options) {
-	const { length } = properties;
-	for (let index = 0; index < length; index += 1) {
-		const property = properties[index];
-		if (!equalValue(first[property], second[property], options)) return false;
-	}
-	return true;
-}
-function equalSet(first, second, options) {
-	const { size } = first;
-	if (size !== second.size) return false;
-	const firstValues = [...first];
-	const secondValues = [...second];
-	for (let index = 0; index < size; index += 1) {
-		const firstValue = firstValues[index];
-		if (isPrimitive(firstValue) ? !second.has(firstValue) : !secondValues.some((secondValue) => equalValue(firstValue, secondValue, options))) return false;
-	}
-	return true;
-}
-function equalTypedArray(first, second) {
-	if (first.constructor !== second.constructor) return false;
-	if (first.byteLength !== second.byteLength) return false;
-	const { length } = first;
-	for (let index = 0; index < length; index += 1) if (first[index] !== second[index]) return false;
-	return true;
-}
-function equalValue(first, second, options) {
-	if (options.relaxedNullish && first == null && second == null) return true;
-	switch (true) {
-		case Object.is(first, second): return true;
-		case first == null || second == null: return first === second;
-		case typeof first !== typeof second: return false;
-		case typeof first === "string" && options.ignoreCase === true: return Object.is(first.toLocaleLowerCase(), second.toLocaleLowerCase());
-		case first instanceof ArrayBuffer && second instanceof ArrayBuffer: return equalArrayBuffer(first, second, options);
-		case first instanceof Date && second instanceof Date: return Object.is(first.getTime(), second.getTime());
-		case first instanceof DataView && second instanceof DataView: return equalDataView(first, second, options);
-		case first instanceof Error && second instanceof Error: return equalProperties(first, second, ERROR_PROPERTIES, options);
-		case first instanceof Map && second instanceof Map: return equalMap(first, second, options);
-		case first instanceof RegExp && second instanceof RegExp: return equalProperties(first, second, EXPRESSION_PROPERTIES, options);
-		case first instanceof Set && second instanceof Set: return equalSet(first, second, options);
-		case Array.isArray(first) && Array.isArray(second): return equalArray(first, second, options);
-		case isPlainObject(first) && isPlainObject(second): return equalPlainObject(first, second, options);
-		case isTypedArray(first) && isTypedArray(second): return equalTypedArray(first, second);
-		default: return equal.handlers.handle(first, second, options);
-	}
-}
-function getEqualOptions(input) {
-	const options = {
-		ignoreCase: false,
-		ignoreExpressions: {
-			enabled: false,
-			values: []
-		},
-		ignoreKeys: {
-			enabled: false,
-			values: /* @__PURE__ */ new Set()
-		},
-		relaxedNullish: false
-	};
-	if (typeof input === "boolean") {
-		options.ignoreCase = input;
-		return options;
-	}
-	if (isNonPlainObject(input)) return options;
-	options.ignoreCase = typeof input.ignoreCase === "boolean" ? input.ignoreCase : false;
-	options.ignoreExpressions.values = (Array.isArray(input.ignoreKeys) ? input.ignoreKeys : [input.ignoreKeys]).filter((key) => key instanceof RegExp);
-	options.ignoreKeys.values = new Set((Array.isArray(input.ignoreKeys) ? input.ignoreKeys : [input.ignoreKeys]).filter((key) => typeof key === "string"));
-	options.ignoreExpressions.enabled = options.ignoreExpressions.values.length > 0;
-	options.ignoreKeys.enabled = options.ignoreKeys.values.size > 0;
-	options.relaxedNullish = input.relaxedNullish === true;
-	return options;
-}
-/**
-* Create an equalizer with predefined options
-*
-* _Available as `initializeEqualizer` and `equal.initialize`_
-*
-* @param options Comparison options
-* @returns Equalizer function
+* @param options Comparison options
+* @returns Equalizer function
 */
 function initializeEqualizer(options) {
 	const actual = getEqualOptions(options);
@@ -2583,9 +2482,9 @@ function registerEqualizer(constructor, handler) {
 }
 const EQUAL_ARRAY_PEEK_PERCENTAGE = 10;
 const EQUAL_ARRAY_THRESHOLD = 100;
-const ERROR_PROPERTIES = ["name", "message"];
-const EXPRESSION_PROPERTIES = ["source", "flags"];
-const MINIMUM_LENGTH_FOR_SET = 16;
+const EQUAL_ERROR_PROPERTIES = ["name", "message"];
+const EQUAL_EXPRESSION_PROPERTIES = ["source", "flags"];
+const EQUAL_MINIMUM_LENGTH_FOR_SET = 16;
 //#endregion
 //#region src/internal/value/get.ts
 function getValue(data, path, ignoreCase) {
@@ -2613,7 +2512,7 @@ function setValue(data, path, value, ignoreCase) {
 		let next = handleValue(target, currentPath, null, true, shouldIgnoreCase).value;
 		if (typeof next !== "object" || next === null) {
 			const nextPath = paths[index + 1];
-			if (EXPRESSION_INDEX.test(nextPath)) next = Array.from({ length: Number(nextPath) + 1 }, () => void 0);
+			if (SET_EXPRESSION_INDEX.test(nextPath)) next = Array.from({ length: Number(nextPath) + 1 }, () => void 0);
 			else next = {};
 			target[currentPath] = next;
 		}
@@ -2621,142 +2520,376 @@ function setValue(data, path, value, ignoreCase) {
 	}
 	return data;
 }
-const EXPRESSION_INDEX = /^\d+$/;
+const SET_EXPRESSION_INDEX = /^\d+$/;
 //#endregion
-//#region src/string/case.ts
-/**
-* Convert a string to camel case _(thisIsCamelCase)_
-*
-* @param value String to convert
-* @returns Camel-cased string
-*/
-function camelCase(value) {
-	return toCase(CASE_CAMEL, value, true, false);
+//#region src/internal/abort.ts
+function createAborter(value, onAbort) {
+	if (!(value instanceof AbortSignal)) return;
+	value.addEventListener(ABORT_EVENT, onAbort, ABORT_OPTIONS);
+	return {
+		callback: onAbort,
+		signal: value,
+		cancel: () => value.removeEventListener(ABORT_EVENT, onAbort)
+	};
+}
+const ABORT_EVENT = "abort";
+const ABORT_OPTIONS = { once: true };
+//#endregion
+//#region src/internal/defaults.ts
+function getBooleanOrDefault(value, defaultValue) {
+	return typeof value === "boolean" ? value : defaultValue;
+}
+function getNumberOrDefault(value, defaultValue, minimum) {
+	return typeof value === "number" && !Number.isNaN(value) && value >= (minimum ?? 0) ? value : defaultValue;
 }
+//#endregion
+//#region src/promise/constants.ts
+const PROMISE_ERROR_NAME = "PromiseTimeoutError";
+const PROMISE_MESSAGE_EXPECTATION_ATTEMPT = "Attempt expected a function or a promise";
+const PROMISE_MESSAGE_EXPECTATION_RESULT = "toResult expected a Promise";
+const PROMISE_MESSAGE_EXPECTATION_TIMED = "Timed function expected a Promise";
+const PROMISE_MESSAGE_TIMEOUT = "Promise timed out";
+const PROMISE_STRATEGY_ALL = /* @__PURE__ */ new Set(["complete", "first"]);
+const PROMISE_STRATEGY_DEFAULT = "complete";
+const PROMISE_TYPE_FULFILLED = "fulfilled";
+const PROMISE_TYPE_REJECTED = "rejected";
+//#endregion
+//#region src/promise/models.ts
 /**
-* Capitalize the first letter of a string _(and lowercase the rest)_
-*
-* @param value String to capitalize
-* @returns Capitalized string
+* A _Promise_ that can be canceled
 */
-function capitalize(value) {
-	if (typeof value !== "string" || value.length === 0) return "";
-	memoizedCapitalize ??= memoize((v) => v.length === 1 ? v.toLocaleUpperCase() : `${v.charAt(0).toLocaleUpperCase()}${v.slice(1).toLocaleLowerCase()}`);
-	return memoizedCapitalize.run(value);
+var CancelablePromise = class extends Promise {
+	#rejector;
+	constructor(executor) {
+		let rejector;
+		super((resolve, reject) => {
+			rejector = reject;
+			executor(resolve, reject);
+		});
+		this.#rejector = rejector;
+	}
+	/**
+	* Cancel the _Promise_, rejecting it with an optional reason
+	*
+	* @param reason Optional reason for canceling the _Promise_
+	*/
+	cancel(reason) {
+		this.#rejector?.(reason);
+		this.#rejector = void 0;
+	}
+};
+/**
+* An error thrown when a promise times out
+*/
+var PromiseTimeoutError = class extends Error {
+	constructor() {
+		super(PROMISE_MESSAGE_TIMEOUT);
+		this.name = PROMISE_ERROR_NAME;
+	}
+};
+//#endregion
+//#region src/promise/helpers.ts
+function getPromiseOptions(input) {
+	if (typeof input === "number") return { time: getNumberOrDefault(input, 0) };
+	if (input instanceof AbortSignal) return {
+		signal: input,
+		time: 0
+	};
+	const options = typeof input === "object" && input !== null ? input : {};
+	return {
+		signal: options.signal instanceof AbortSignal ? options.signal : void 0,
+		time: getNumberOrDefault(options.time, 0)
+	};
+}
+function getPromisesOptions(input) {
+	if (typeof input === "string") return { strategy: getStrategyOrDefault(input) };
+	if (input instanceof AbortSignal) return {
+		signal: input,
+		strategy: PROMISE_STRATEGY_DEFAULT
+	};
+	const options = typeof input === "object" && input !== null ? input : {};
+	return {
+		signal: options.signal instanceof AbortSignal ? options.signal : void 0,
+		strategy: getStrategyOrDefault(options.strategy)
+	};
+}
+function getResultsFromPromises(promised) {
+	return promised.map((result) => isFulfilled(result) ? ok(result.value) : error(result.reason));
+}
+function getStrategyOrDefault(value) {
+	return PROMISE_STRATEGY_ALL.has(value) ? value : PROMISE_STRATEGY_DEFAULT;
 }
 /**
-* Convert a string to kebab case _(this-is-kebab-case)_
+* Is the value a fulfilled _Promise_ result?
 *
-* @param value String to convert
-* @returns Kebab-cased string
+* @param value Value to check
+* @returns `true` if the value is a fulfilled _Promise_ result, otherwise `false`
 */
-function kebabCase(value) {
-	return toCase(CASE_KEBAB, value, false, false);
+function isFulfilled(value) {
+	return isType(value, PROMISE_TYPE_FULFILLED);
 }
 /**
-* Convert a string to lower case
+* Is the value a rejected _Promise_ result?
 *
-* @param value String to convert
-* @returns Lower-cased string
+* @param value Value to check
+* @returns `true` if the value is a rejected _Promise_ result, otherwise `false`
 */
-function lowerCase(value) {
-	if (typeof value !== "string") return "";
-	memoizedLowerCase ??= memoize((v) => v.toLocaleLowerCase());
-	return memoizedLowerCase.run(value);
+function isRejected(value) {
+	return isType(value, PROMISE_TYPE_REJECTED);
 }
+function isType(value, type) {
+	return typeof value === "object" && value !== null && value.status === type;
+}
+//#endregion
+//#region src/result/misc.ts
 /**
-* Convert a string to pascal case _(ThisIsPascalCase)_
+* Converts a _Result_ to a _Promise_
 *
-* @param value String to convert
-* @returns Pascal-cased string
+* Resolves if ok, rejects for error
+*
+* @param result _Result_ to convert
+* @returns Promised result
 */
-function pascalCase(value) {
-	return toCase(CASE_PASCAL, value, true, true);
+async function toPromise(result) {
+	const actual = typeof result === "function" ? result() : result;
+	if (!isResult(actual)) return Promise.reject(new Error(RESULT_MESSAGE_PROMISE));
+	return isOk(actual) ? Promise.resolve(actual.value) : Promise.reject(actual.error);
 }
+const RESULT_MESSAGE_PROMISE = "toPromise expected to receive a Result";
+//#endregion
+//#region src/promise/misc.ts
 /**
-* Convert a string to snake case _(this_is_snake_case)_
+* Create a cancelable _Promise_
 *
-* @param value String to convert
-* @returns Snake-cased string
+* @param executor Executor function for the _Promise_
+* @returns Cancelable _Promise_
 */
-function snakeCase(value) {
-	return toCase(CASE_SNAKE, value, false, false);
+function cancelable(executor) {
+	return new CancelablePromise(executor);
+}
+function handleResult(status, parameters) {
+	const { aborter, complete, data, handlers, index, value } = parameters;
+	if (aborter?.signal.aborted ?? false) return;
+	if (!complete && status === "rejected") {
+		settlePromise(handlers.reject, value, aborter);
+		return;
+	}
+	data.result[index] = !complete ? value : status === "fulfilled" ? {
+		status,
+		value
+	} : {
+		status,
+		reason: value
+	};
+	if (index === data.last) settlePromise(handlers.resolve, data.result, aborter);
+}
+function settlePromise(settler, value, aborter) {
+	aborter?.cancel();
+	settler(value);
+}
+async function toResult(value) {
+	const actual = typeof value === "function" ? value() : value;
+	if (!(actual instanceof Promise)) return Promise.reject(/* @__PURE__ */ new TypeError(PROMISE_MESSAGE_EXPECTATION_RESULT));
+	return actual.then((result) => ok(result)).catch((reason) => error(reason));
+}
+//#endregion
+//#region src/promise/delay.ts
+function delay(options) {
+	const { signal, time } = getPromiseOptions(options);
+	if (signal?.aborted ?? false) return Promise.reject(signal?.reason);
+	const aborter = createAborter(signal, () => {
+		timer.cancel();
+		rejector(signal?.reason);
+	});
+	const timer = getTimer(TIMER_WAIT, () => settlePromise(resolver, void 0, aborter), time);
+	let rejector;
+	let resolver;
+	return new Promise((resolve, reject) => {
+		rejector = reject;
+		resolver = resolve;
+		if (time === 0) settlePromise(resolver, void 0, aborter);
+		else timer();
+	});
+}
+//#endregion
+//#region src/promise/timed.ts
+async function getTimedPromise(promise, time, signal) {
+	const aborter = createAborter(signal, () => {
+		timer.cancel();
+		rejector(signal?.reason);
+	});
+	const timer = getTimer(TIMER_WAIT, () => settlePromise(rejector, new PromiseTimeoutError(), aborter), time);
+	let rejector;
+	return Promise.race([promise, new Promise((_, reject) => {
+		rejector = reject;
+		timer();
+	})]).then((value) => {
+		aborter?.cancel();
+		timer.cancel();
+		rejector(void 0);
+		return value;
+	});
+}
+async function timed(promise, options) {
+	if (!(promise instanceof Promise)) return Promise.reject(/* @__PURE__ */ new TypeError(PROMISE_MESSAGE_EXPECTATION_TIMED));
+	const { signal, time } = getPromiseOptions(options);
+	if (signal?.aborted ?? false) return Promise.reject(signal?.reason);
+	return time > 0 ? getTimedPromise(promise, time, signal) : promise;
+}
+//#endregion
+//#region src/promise/index.ts
+async function attemptPromise(value, options) {
+	const isFunction = typeof value === "function";
+	if (!isFunction && !(value instanceof Promise)) return Promise.reject(/* @__PURE__ */ new TypeError(PROMISE_MESSAGE_EXPECTATION_ATTEMPT));
+	const { signal, time } = getPromiseOptions(options);
+	if (signal?.aborted ?? false) return Promise.reject(signal?.reason);
+	const aborter = createAborter(signal, () => {
+		rejector(signal?.reason);
+	});
+	async function handler(resolve, reject) {
+		try {
+			let result = isFunction ? value() : await value;
+			if (result instanceof Promise) result = await result;
+			settlePromise(resolve, result, aborter);
+		} catch (error) {
+			settlePromise(reject, error, aborter);
+		}
+	}
+	let rejector;
+	const promise = new Promise((resolve, reject) => {
+		rejector = reject;
+		handler(resolve, reject);
+	});
+	return time > 0 ? getTimedPromise(promise, time, signal) : promise;
+}
+async function promises(items, options) {
+	const { signal, strategy } = getPromisesOptions(options);
+	if (signal?.aborted ?? false) return Promise.reject(signal?.reason);
+	if (!Array.isArray(items)) return Promise.resolve([]);
+	const actual = items.map((item) => typeof item === "function" ? item() : item).filter((item) => item instanceof Promise);
+	const { length } = actual;
+	if (length === 0) return Promise.resolve([]);
+	const complete = strategy === PROMISE_STRATEGY_DEFAULT;
+	const aborter = createAborter(signal, () => {
+		handlers.reject(signal?.reason);
+	});
+	const data = {
+		last: length - 1,
+		result: []
+	};
+	let handlers;
+	return new Promise((resolve, reject) => {
+		handlers = {
+			reject,
+			resolve
+		};
+		for (let index = 0; index < length; index += 1) actual[index].then((value) => handleResult(PROMISE_TYPE_FULFILLED, {
+			aborter,
+			complete,
+			data,
+			handlers,
+			index,
+			value
+		})).catch((reason) => handleResult(PROMISE_TYPE_REJECTED, {
+			aborter,
+			complete,
+			data,
+			handlers,
+			index,
+			value: reason
+		}));
+	});
+}
+promises.result = resultPromises;
+async function resultPromises(items, signal) {
+	return promises(items, signal).then(getResultsFromPromises);
+}
+//#endregion
+//#region src/result/index.ts
+async function asyncAttempt(value, err) {
+	try {
+		let result = typeof value === "function" ? value() : await value;
+		if (result instanceof Promise) result = await result;
+		return ok(result);
+	} catch (thrown) {
+		return getError(err ?? thrown, err == null ? void 0 : thrown);
+	}
+}
+function attempt(callback, err) {
+	try {
+		return ok(callback());
+	} catch (thrown) {
+		return getError(err ?? thrown, err == null ? void 0 : thrown);
+	}
+}
+Object.defineProperty(attempt, "async", { value: asyncAttempt });
+//#endregion
+//#region src/result/match.ts
+async function asyncMatchResult(result, first, error) {
+	let value;
+	if (typeof result === "function") value = await result();
+	else if (result instanceof Promise) value = await result;
+	else value = result;
+	if (!isResult(value)) throw new Error(MATCH_MESSAGE);
+	const hasObj = typeof first === "object" && first !== null;
+	const okHandler = hasObj ? first.ok : first;
+	const errorHandler = hasObj ? first.error : error;
+	if (isOk(value)) return okHandler(value.value);
+	return errorHandler(value.error, value.original);
 }
-/**
-* Convert a string to title case _(Capitalizing Every Word)_
-*
-* @param value String to convert
-* @returns Title-cased string
-*/
-function titleCase(value) {
-	if (typeof value !== "string" || value.length === 0) return "";
-	memoizedTitleCase ??= memoize((v) => v.length < 2 ? capitalize(v) : join(words(v).map(capitalize), " "));
-	return memoizedTitleCase.run(value);
+function matchResult(result, first, error) {
+	const value = typeof result === "function" ? result() : result;
+	if (!isResult(value)) throw new Error(MATCH_MESSAGE);
+	const hasObj = typeof first === "object" && first !== null;
+	const okHandler = hasObj ? first.ok : first;
+	const errorHandler = hasObj ? first.error : error;
+	if (isOk(value)) return okHandler(value.value);
+	return errorHandler(value.error, value.original);
 }
-function toCase(type, value, capitalizeAny, capitalizeFirst) {
-	caseMemoizers[type] ??= memoize(toCaseCallback.bind({
-		type,
-		capitalizeAny,
-		capitalizeFirst
-	}));
-	return caseMemoizers[type].run(value);
+const MATCH_MESSAGE = "`result.match` expected a Result or a function that returns a Result";
+Object.defineProperty(matchResult, "async", { value: asyncMatchResult });
+//#endregion
+//#region src/result/work/flow.ts
+function attemptAsyncFlow(...fns) {
+	let Flow;
+	return (...args) => asyncAttempt(() => {
+		Flow ??= asyncFlow(...fns);
+		return Flow(...args.map((value) => {
+			if (isError(value)) throw value.error;
+			return isOk(value) ? value.value : value;
+		}));
+	});
 }
-function toCaseCallback(value) {
-	if (typeof value !== "string") return "";
-	if (value.length < 1) return value;
-	const { capitalizeAny, capitalizeFirst, type } = this;
-	const parts = words(value);
-	const partsLength = parts.length;
-	const cased = [];
-	for (let partIndex = 0; partIndex < partsLength; partIndex += 1) {
-		const items = parts[partIndex].replace(EXPRESSION_ACRONYM, (full, one, two, three) => three === S ? full : `${one}-${two}${three}`).replace(EXPRESSION_CAMEL_CASE, REPLACEMENT_CAMEL_CASE).split("-");
-		const itemsLength = items.length;
-		const partResult = [];
-		let itemCount = 0;
-		for (let itemIndex = 0; itemIndex < itemsLength; itemIndex += 1) {
-			const item = items[itemIndex];
-			if (item.length === 0) continue;
-			if (!capitalizeAny || itemCount === 0 && partIndex === 0 && !capitalizeFirst) partResult.push(item.toLocaleLowerCase());
-			else partResult.push(capitalize(item));
-			itemCount += 1;
-		}
-		cased.push(join(partResult, delimiters[type]));
-	}
-	return join(cased, delimiters[type]);
+function attemptFlow(...fns) {
+	let Flow;
+	return (...args) => attempt(() => {
+		Flow ??= flow(...fns);
+		return Flow(...args.map((value) => {
+			if (isError(value)) throw value.error;
+			return isOk(value) ? value.value : value;
+		}));
+	});
 }
-/**
-* Convert a string to upper case
-*
-* @param value String to convert
-* @returns Upper-cased string
-*/
-function upperCase(value) {
-	if (typeof value !== "string" || value.length === 0) return "";
-	memoizedUpperCase ??= memoize((v) => v.toLocaleUpperCase());
-	return memoizedUpperCase.run(value);
+Object.defineProperty(attemptFlow, "async", { value: attemptAsyncFlow });
+//#endregion
+//#region src/result/work/pipe.ts
+async function attemptAsyncPipe(initial, first, ...seconds) {
+	return asyncAttempt(() => {
+		if (isError(initial)) throw initial.error;
+		const value = typeof initial === "function" ? initial() : isOk(initial) ? initial.value : initial;
+		if (first == null) return value;
+		return asyncPipe(value, ...[first, ...seconds]);
+	});
 }
-const CASE_CAMEL = "camel";
-const CASE_KEBAB = "kebab";
-const CASE_PASCAL = "pascal";
-const CASE_SNAKE = "snake";
-const DELIMTER_EMPTY = "";
-const DELIMITER_HYPHEN = "-";
-const DELIMITER_UNDERSCORE = "_";
-const EXPRESSION_CAMEL_CASE = /(\p{Ll})(\p{Lu})/gu;
-const EXPRESSION_ACRONYM = /(\p{Lu}*)(\p{Lu})(\p{Ll}+)/gu;
-const REPLACEMENT_CAMEL_CASE = "$1-$2";
-const S = "s";
-const caseMemoizers = {};
-const delimiters = {
-	[CASE_CAMEL]: DELIMTER_EMPTY,
-	[CASE_KEBAB]: DELIMITER_HYPHEN,
-	[CASE_PASCAL]: DELIMTER_EMPTY,
-	[CASE_SNAKE]: DELIMITER_UNDERSCORE
-};
-let memoizedCapitalize;
-let memoizedLowerCase;
-let memoizedTitleCase;
-let memoizedUpperCase;
+function attemptPipe(initial, first, ...seconds) {
+	return attempt(() => {
+		if (isError(initial)) throw initial.error;
+		const value = typeof initial === "function" ? initial() : isOk(initial) ? initial.value : initial;
+		if (first == null) return value;
+		return pipe(value, ...[first, ...seconds]);
+	});
+}
+Object.defineProperty(attemptPipe, "async", { value: attemptAsyncPipe });
 //#endregion
 //#region src/string/match.ts
 /**
@@ -2813,10 +2946,10 @@ function getHandler(input) {
 		case "string": return (item) => item[input];
 		default:
 			if (isPlainObject(input)) return getHandler(input.key ?? input.handler);
-			throw new TypeError(MESSAGE_HANDLER);
+			throw new TypeError(FUZZY_MESSAGE_HANDLER);
 	}
 }
-function getItems$1(items) {
+function getFuzzyItems(items) {
 	return items.sort((first, second) => first.haystack.localeCompare(second.haystack)).map(({ item }) => item);
 }
 function getFuzzyOptions(input, state) {
@@ -2840,22 +2973,22 @@ function getFuzzyState(items, input) {
 }
 function getTolerance(input, state) {
 	if (typeof input === "number" && !Number.isNaN(input)) return input < 0 ? 0 : Math.floor(input);
-	return state?.tolerance ?? PROXIMITY_THRESHOLD;
+	return state?.tolerance ?? FUZZY_PROXIMITY_THRESHOLD;
 }
 function fuzzy(items, configuration) {
-	if (!Array.isArray(items)) throw new TypeError(MESSAGE_ARRAY);
+	if (!Array.isArray(items)) throw new TypeError(FUZZY_MESSAGE_ARRAY);
 	const state = getFuzzyState(items, configuration);
 	const instance = { search: (value, options) => search(state.items, state.strings, value, options == null ? state : getFuzzyOptions(options, state)) };
 	Object.defineProperties(instance, {
 		items: {
+			enumerable: true,
 			get: () => state.items.slice(),
-			set: (items) => {
-				if (!Array.isArray(items)) throw new TypeError(MESSAGE_ARRAY);
-				state.items = items.slice();
-				state.strings = items.map(state.handler);
-			}
+			set: (value) => setItems(state, value)
 		},
-		strings: { get: () => state.strings.slice() }
+		strings: {
+			enumerable: true,
+			get: () => state.strings.slice()
+		}
 	});
 	return Object.freeze(instance);
 }
@@ -2899,14 +3032,14 @@ function getScore(haystack, needle) {
 			if (haystackIndex === 0) score += 1;
 			if (previousMatchIndex !== -1) {
 				const gap = haystackIndex - previousMatchIndex - 1;
-				score += Math.max(0, PROXIMITY_THRESHOLD - gap);
+				score += Math.max(0, FUZZY_PROXIMITY_THRESHOLD - gap);
 			}
 			previousMatchIndex = haystackIndex;
 			needleIndex += 1;
 		}
 		if (needleIndex === needleLength) break;
 	}
-	score -= Math.floor(lowerCaseHaystack.length / LENGTH_DIVISOR);
+	score -= Math.floor(lowerCaseHaystack.length / FUZZY_LENGTH_DIVISOR);
 	return Math.max(0, score);
 }
 function search(items, strings, input, options) {
@@ -2949,18 +3082,23 @@ function search(items, strings, input, options) {
 		for (let index = 0; index < length; index += 1) {
 			const key = keys[index];
 			if (maxScore - key > options.tolerance) break;
-			similar.push(...getItems$1(scored[key]));
+			similar.push(...getFuzzyItems(scored[key]));
 		}
 	}
-	result.exact = getItems$1(options.limit == null ? exact : exact.slice(0, options.limit));
+	result.exact = getFuzzyItems(options.limit == null ? exact : exact.slice(0, options.limit));
 	if (options.limit == null) result.similar = similar;
 	else result.similar = similar.slice(0, options.limit - result.exact.length);
 	return result;
 }
-const LENGTH_DIVISOR = 3;
-const MESSAGE_ARRAY = "Fuzzy requires an array of items";
-const MESSAGE_HANDLER = "Fuzzy requires a key or function to stringify items";
-const PROXIMITY_THRESHOLD = 5;
+function setItems(state, value) {
+	if (!Array.isArray(value)) throw new TypeError(FUZZY_MESSAGE_ARRAY);
+	state.items = value.slice();
+	state.strings = value.map(state.handler);
+}
+const FUZZY_LENGTH_DIVISOR = 3;
+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_PROXIMITY_THRESHOLD = 5;
 //#endregion
 //#region src/string/index.ts
 function dedent(value, ...values) {
@@ -2999,16 +3137,16 @@ function getUuid(html) {
 		crypto.getRandomValues(bytes);
 		bytes[6] = bytes[6] & 15 | 64;
 		bytes[8] = bytes[8] & 63 | 128;
-		const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, ZERO)).join("");
+		const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, STRING_ZERO)).join("");
 		const first = hex.substring(0, 8);
-		if (forHTML && NUMERICAL_PREFIX_PATTERN.test(first)) continue;
+		if (forHTML && STRING_NUMERICAL_PREFIX_PATTERN.test(first)) continue;
 		return [
 			first,
 			hex.substring(8, 12),
 			hex.substring(12, 16),
 			hex.substring(16, 20),
 			hex.substring(20, 32)
-		].join(forHTML ? DELIMITER_UUID_HTML : DELIMITER_UUID_DEFAULT);
+		].join(forHTML ? STRING_DELIMITER_UUID_HTML : STRING_DELIMITER_UUID_DEFAULT);
 	}
 }
 /**
@@ -3051,10 +3189,10 @@ function truncate(value, length, suffix) {
 	const truncatedLength = length - actualSuffixLength;
 	return `${value.slice(0, truncatedLength)}${actualSuffix}`;
 }
-const DELIMITER_UUID_DEFAULT = "-";
-const DELIMITER_UUID_HTML = "_";
-const NUMERICAL_PREFIX_PATTERN = /^\d/;
-const ZERO = "0";
+const STRING_DELIMITER_UUID_DEFAULT = "-";
+const STRING_DELIMITER_UUID_HTML = "_";
+const STRING_NUMERICAL_PREFIX_PATTERN = /^\d/;
+const STRING_ZERO = "0";
 //#endregion
 //#region src/string/normalize.ts
 /**
@@ -3066,8 +3204,8 @@ const ZERO = "0";
 function deburr(value) {
 	if (typeof value !== "string") return "";
 	deburrMemoizer ??= memoize((value) => {
-		let deburred = value.normalize(DEBURR_NORMALIZATION).replace(DEBURR_PATTERN_SIMPLE, "");
-		deburred = deburred.replace(DEBURR_PATTERN_CHARACTERS, (_, character) => DEBURR_CHARACTERS[character]);
+		let deburred = value.normalize(NORMALIZE_DEBURR_NORMALIZATION).replace(NORMALIZE_DEBURR_PATTERN_SIMPLE, "");
+		deburred = deburred.replace(NORMALIZE_DEBURR_PATTERN_CHARACTERS, (_, character) => NORMALIZE_DEBURR_CHARACTERS[character]);
 		return deburred;
 	});
 	return deburrMemoizer.run(value);
@@ -3111,13 +3249,13 @@ function normalizeString(value, options) {
 	if (typeof value !== "string") return "";
 	let result = value;
 	if (options.trim) result = result.trim();
-	if (options.whitespace) result = result.replace(WHITESPACE_PATTERN, WHITESPACE_REPLACEMENT);
+	if (options.whitespace) result = result.replace(NORMALIZE_WHITESPACE_PATTERN, NORMALIZE_WHITESPACE_REPLACEMENT);
 	if (options.deburr) result = deburr(result);
 	if (options.lowerCase) result = lowerCase(result);
-	if (options.special) result = result.replace(SPECIAL_PATTERN, SPECIAL_REPLACEMENT);
-	return result.normalize(NORMALIZATION_NORMALIZATION);
+	if (options.special) result = result.replace(NORMALIZE_SPECIAL_PATTERN, NORMALIZE_SPECIAL_REPLACEMENT);
+	return result.normalize(NORMALIZE_NORMALIZATION_NORMALIZATION);
 }
-const DEBURR_CHARACTERS = {
+const NORMALIZE_DEBURR_CHARACTERS = {
 	Æ: "AE",
 	æ: "ae",
 	Ð: "D",
@@ -3149,14 +3287,14 @@ const DEBURR_CHARACTERS = {
 	Ŧ: "T",
 	ŧ: "t"
 };
-const DEBURR_NORMALIZATION = "NFD";
-const DEBURR_PATTERN_CHARACTERS = new RegExp(`(${Object.keys(DEBURR_CHARACTERS).join("|")})`, "g");
-const DEBURR_PATTERN_SIMPLE = /[\u0300-\u036f]/g;
-const NORMALIZATION_NORMALIZATION = "NFC";
-const SPECIAL_PATTERN = /[\p{P}\p{S}]/gu;
-const SPECIAL_REPLACEMENT = "";
-const WHITESPACE_PATTERN = /\s+/g;
-const WHITESPACE_REPLACEMENT = " ";
+const NORMALIZE_DEBURR_NORMALIZATION = "NFD";
+const NORMALIZE_DEBURR_PATTERN_CHARACTERS = new RegExp(`(${Object.keys(NORMALIZE_DEBURR_CHARACTERS).join("|")})`, "g");
+const NORMALIZE_DEBURR_PATTERN_SIMPLE = /[\u0300-\u036f]/g;
+const NORMALIZE_NORMALIZATION_NORMALIZATION = "NFC";
+const NORMALIZE_SPECIAL_PATTERN = /[\p{P}\p{S}]/gu;
+const NORMALIZE_SPECIAL_REPLACEMENT = "";
+const NORMALIZE_WHITESPACE_PATTERN = /\s+/g;
+const NORMALIZE_WHITESPACE_REPLACEMENT = " ";
 let deburrMemoizer;
 //#endregion
 //#region src/string/template.ts
@@ -3169,7 +3307,7 @@ function getTemplateOptions(input) {
 	const options = isPlainObject(input) ? input : {};
 	return {
 		ignoreCase: options.ignoreCase === true,
-		pattern: options.pattern instanceof RegExp ? options.pattern : EXPRESSION_VARIABLE
+		pattern: options.pattern instanceof RegExp ? options.pattern : TEMPLATE_EXPRESSION_VARIABLE
 	};
 }
 function handleTemplate(value, pattern, ignoreCase, variables) {
@@ -3204,7 +3342,7 @@ function template(value, ...parameters) {
 	return handleTemplate(value, pattern, ignoreCase, parameters[0]);
 }
 template.initialize = initializeTemplater;
-const EXPRESSION_VARIABLE = /{{([\s\S]+?)}}/g;
+const TEMPLATE_EXPRESSION_VARIABLE = /{{([\s\S]+?)}}/g;
 //#endregion
 //#region src/value/clone.ts
 const CLONE_NAME = "clone";
@@ -3218,21 +3356,21 @@ clone.handlers = getSelfHandlers(clone, {
 clone.deregister = deregisterCloner;
 clone.register = registerCloner;
 function cloneArrayBuffer(value, depth, references) {
-	if (typeof depth === "number" && depth >= MAX_CLONE_DEPTH) return value;
+	if (typeof depth === "number" && depth >= CLONE_MAX_DEPTH) return value;
 	const cloned = new ArrayBuffer(value.byteLength);
 	new Uint8Array(cloned).set(new Uint8Array(value));
 	references?.set(value, cloned);
 	return cloned;
 }
 function cloneDataView(value, depth, references) {
-	if (depth >= MAX_CLONE_DEPTH) return value;
+	if (depth >= CLONE_MAX_DEPTH) return value;
 	const buffer = cloneArrayBuffer(value.buffer);
 	const cloned = new DataView(buffer, value.byteOffset, value.byteLength);
 	references.set(value, cloned);
 	return cloned;
 }
 function cloneMap(map, depth, references, flat) {
-	if (depth >= MAX_CLONE_DEPTH) return map;
+	if (depth >= CLONE_MAX_DEPTH) return map;
 	const cloned = /* @__PURE__ */ new Map();
 	const entries = map.entries();
 	for (const entry of entries) cloned.set(flat ? entry[0] : cloneValue(entry[0], depth + 1, references, false), flat ? entry[1] : cloneValue(entry[1], depth + 1, references, false));
@@ -3240,13 +3378,13 @@ function cloneMap(map, depth, references, flat) {
 	return cloned;
 }
 function cloneNode(node, depth, references) {
-	if (depth >= MAX_CLONE_DEPTH) return node;
+	if (depth >= CLONE_MAX_DEPTH) return node;
 	const cloned = node.cloneNode(true);
 	references.set(node, cloned);
 	return cloned;
 }
 function cloneObject(value, depth, references, flat) {
-	if (flat || depth >= MAX_CLONE_DEPTH) return Array.isArray(value) ? value.slice() : { ...value };
+	if (flat || depth >= CLONE_MAX_DEPTH) return Array.isArray(value) ? value.slice() : { ...value };
 	const cloned = Array.isArray(value) ? [] : {};
 	const keys = [...Object.keys(value), ...Object.getOwnPropertySymbols(value)];
 	const { length } = keys;
@@ -3258,14 +3396,14 @@ function cloneObject(value, depth, references, flat) {
 	return cloned;
 }
 function cloneRegularExpression(value, depth, references) {
-	if (depth >= MAX_CLONE_DEPTH) return value;
+	if (depth >= CLONE_MAX_DEPTH) return value;
 	const cloned = new RegExp(value.source, value.flags);
 	cloned.lastIndex = value.lastIndex;
 	references.set(value, cloned);
 	return cloned;
 }
 function cloneSet(set, depth, references, flat) {
-	if (depth >= MAX_CLONE_DEPTH) return set;
+	if (depth >= CLONE_MAX_DEPTH) return set;
 	const cloned = /* @__PURE__ */ new Set();
 	const values = [...set.values()];
 	const { length } = values;
@@ -3274,7 +3412,7 @@ function cloneSet(set, depth, references, flat) {
 	return cloned;
 }
 function cloneTypedArray(value, depth, references) {
-	if (depth >= MAX_CLONE_DEPTH) return value;
+	if (depth >= CLONE_MAX_DEPTH) return value;
 	const cloned = new value.constructor(value);
 	references.set(value, cloned);
 	return cloned;
@@ -3335,7 +3473,7 @@ function registerCloner(constructor, handler) {
 	clone.handlers.register(constructor, handler);
 }
 function tryStructuredClone(value, depth, references) {
-	if (depth >= MAX_CLONE_DEPTH) return value;
+	if (depth >= CLONE_MAX_DEPTH) return value;
 	try {
 		const cloned = structuredClone(value);
 		references.set(value, cloned);
@@ -3345,7 +3483,7 @@ function tryStructuredClone(value, depth, references) {
 		return value;
 	}
 }
-const MAX_CLONE_DEPTH = 100;
+const CLONE_MAX_DEPTH = 100;
 //#endregion
 //#region src/value/collection.ts
 function inMap(map, value, key) {
@@ -3609,7 +3747,7 @@ function shake(value) {
 //#endregion
 //#region src/value/smush.ts
 function flattenObject(value, depth, smushed, prefix) {
-	if (depth >= MAX_DEPTH) return {};
+	if (depth >= SMUSH_MAX_DEPTH) return {};
 	if (smushed.has(value)) return smushed.get(value);
 	const keys = Object.keys(value);
 	const { length } = keys;
@@ -3641,7 +3779,7 @@ function flattenObject(value, depth, smushed, prefix) {
 function smush(value) {
 	return typeof value === "object" && value !== null ? flattenObject(value, 0, /* @__PURE__ */ new WeakMap()) : {};
 }
-const MAX_DEPTH = 100;
+const SMUSH_MAX_DEPTH = 100;
 //#endregion
 //#region src/value/unsmush.ts
 function getKeys(value) {
@@ -3813,6 +3951,142 @@ function transformValue(value, transformer) {
 	return value;
 }
 //#endregion
+//#region src/internal/subscription.ts
+function addSubscription(subscriptions, subscription, state) {
+	const { key, value } = state.parameters;
+	const { items, values } = subscriptions.state;
+	if (!isKey(key)) {
+		items.any.add(subscription);
+		values.from.any.set(value, subscription);
+		values.to.any.set(subscription, value);
+		return;
+	}
+	/* istanbul ignore if */
+	if (items.keyed == null || values.from.keyed == null || values.to.keyed == null)
+ // istanbul ignore next
+	return;
+	let keyedItems = items.keyed.get(key);
+	if (keyedItems == null) {
+		keyedItems = /* @__PURE__ */ new Set();
+		items.keyed.set(key, keyedItems);
+	}
+	keyedItems.add(subscription);
+	let keyedFrom = values.from.keyed.get(key);
+	if (keyedFrom == null) {
+		keyedFrom = /* @__PURE__ */ new Map();
+		values.from.keyed.set(key, keyedFrom);
+	}
+	keyedFrom.set(value, subscription);
+	let keyedTo = values.to.keyed.get(key);
+	if (keyedTo == null) {
+		keyedTo = /* @__PURE__ */ new Map();
+		values.to.keyed.set(key, keyedTo);
+	}
+	keyedTo.set(subscription, value);
+}
+function clearSubscriptions(store) {
+	for (const susbcription of store.values.to.any.keys()) susbcription.unsubscribe();
+	if (store.values.to.keyed != null) for (const values of store.values.to.keyed.values()) for (const susbcription of values.keys()) susbcription.unsubscribe();
+}
+function createSubscription(subscriptions, property, parameters) {
+	if (parameters.signal?.aborted ?? false) throw new Error(parameters.signal?.reason);
+	const state = {
+		parameters,
+		active: true
+	};
+	const existing = getExistingSubscription(subscriptions, state);
+	if (existing != null) return [existing, true];
+	if (subscriptions.state.keys != null && isKey(parameters.key) && !subscriptions.state.keys.has(parameters.key)) throw new Error(SUBSCRIPTION_INVALID_KEY);
+	state.aborter = createAborter(parameters.signal, () => unsubscribe(subscriptions, instance, state));
+	const instance = { unsubscribe: () => unsubscribe(subscriptions, instance, state) };
+	Object.defineProperties(instance, {
+		[SUBSCRIPTION_PROPERTY]: { value: true },
+		[property.key]: { value: property.value ?? "subscription" },
+		active: {
+			enumerable: true,
+			get: () => (parameters.isActive?.() ?? true) && state.active
+		}
+	});
+	addSubscription(subscriptions, instance, state);
+	return [Object.freeze(instance), false];
+}
+function createSubscriptions(parameters) {
+	const { keys, property } = parameters;
+	const state = {
+		keys,
+		items: {
+			any: /* @__PURE__ */ new Set(),
+			keyed: keys == null ? void 0 : /* @__PURE__ */ new Map()
+		},
+		values: {
+			from: {
+				any: /* @__PURE__ */ new Map(),
+				keyed: keys == null ? void 0 : /* @__PURE__ */ new Map()
+			},
+			to: {
+				any: /* @__PURE__ */ new Map(),
+				keyed: keys == null ? void 0 : /* @__PURE__ */ new Map()
+			}
+		}
+	};
+	const instance = {
+		state,
+		clear: () => clearSubscriptions(state),
+		create: (parameters) => createSubscription(instance, property, parameters)
+	};
+	return instance;
+}
+function getExistingSubscription(subscriptions, state) {
+	const { parameters } = state;
+	const { values } = subscriptions.state;
+	return isKey(parameters.key) ? values.from.keyed?.get(parameters.key)?.get(parameters.value) : values.from.any.get(parameters.value);
+}
+/**
+* Is the value a subscription?
+*
+* @param value Value to check
+* @returns `true` if the value is a subscription, otherwise `false`
+*/
+function isSubscription(value) {
+	return isPlainObject(value) && SUBSCRIPTION_PROPERTY in value && value[SUBSCRIPTION_PROPERTY] === true;
+}
+function removeFromStore(items, values, subscription, value, key) {
+	items.delete(subscription);
+	if (key == null) {
+		values.from.any.delete(value);
+		values.to.any.delete(subscription);
+	} else {
+		values.from.keyed?.get(key)?.delete(value);
+		values.to.keyed?.get(key)?.delete(subscription);
+	}
+}
+function removeSubscription(subscriptions, subscription, state) {
+	if (!state.active) return;
+	state.aborter = void 0;
+	state.active = false;
+	state.parameters.isActive = void 0;
+	state.parameters.signal = void 0;
+	const { key, value } = state.parameters;
+	const { items, values } = subscriptions.state;
+	if (!isKey(key)) {
+		removeFromStore(items.any, values, subscription, value);
+		return;
+	}
+	const keyed = items.keyed?.get(key);
+	/* istanbul ignore if */
+	if (items.keyed == null || keyed == null)
+ // istanbul ignore next
+	return;
+	removeFromStore(keyed, values, subscription, value, key);
+	if (keyed.size === 0) items.keyed.delete(key);
+}
+function unsubscribe(subscriptions, subscription, state) {
+	state.aborter?.cancel();
+	removeSubscription(subscriptions, subscription, state);
+}
+const SUBSCRIPTION_INVALID_KEY = "Invalid key for subscription";
+const SUBSCRIPTION_PROPERTY = "$subscription";
+//#endregion
 //#region src/beacon.ts
 /**
 * Create a new beacon
@@ -3827,38 +4101,23 @@ function beacon(value, options) {
 		active: true,
 		observable: void 0,
 		options: getBeaconOptions(options),
-		subscriptions: getSubscriptions()
+		subscriptions: createSubscriptions({ property: beaconSubscription })
 	};
 	const instance = {
-		deactivate: () => {
-			finishBeacon(state, false);
-		},
-		emit: (value, finish) => {
-			update$1(TYPE_NEXT, state, value, finish);
-		},
-		error: (value, finish) => {
-			update$1(TYPE_ERROR, state, value, finish);
-		},
-		finish: () => {
-			finishBeacon(state, true);
-		}
+		deactivate: () => finishBeacon(state, false),
+		emit: (value, finish) => updateBeacon(BEACON_TYPE_NEXT, state, value, finish),
+		error: (value, finish) => updateBeacon(BEACON_TYPE_ERROR, state, value, finish),
+		finish: () => finishBeacon(state, true)
 	};
 	Object.defineProperties(instance, {
-		[KEY_BEACON]: {
-			enumerable: false,
-			value: NAME_BEACON
-		},
+		[BEACON_PROPERTY]: { value: BEACON_NAME },
 		active: {
 			enumerable: true,
 			get: () => state.active
 		},
 		observable: {
 			enumerable: true,
-			get: () => {
-				if (!state.active) throw new Error(MESSAGE_BEACON);
-				state.observable ??= observe(state);
-				return state.observable;
-			}
+			get: () => getObservable(state)
 		},
 		value: {
 			enumerable: true,
@@ -3870,8 +4129,8 @@ function beacon(value, options) {
 function finishBeacon(state, emit) {
 	if (!state.active) return;
 	state.active = false;
-	for (const [, observer] of state.subscriptions.values.to.any) if (emit) observer.complete?.();
-	clearSubscriptions(state.subscriptions);
+	for (const [, observer] of state.subscriptions.state.values.to.any) if (emit) observer.complete?.();
+	state.subscriptions.clear();
 	state.observable?.deactivate();
 	state.observable = void 0;
 }
@@ -3880,6 +4139,11 @@ function getBeaconOptions(input) {
 	options.equal = typeof options.equal === "function" ? options.equal : Object.is;
 	return options;
 }
+function getObservable(state) {
+	if (!state.active) throw new Error(BEACON_MESSAGE_RETRIEVE);
+	state.observable ??= observeBeacon(state);
+	return state.observable;
+}
 function getObservableCallback(value) {
 	return typeof value === "function" ? value : noop;
 }
@@ -3904,10 +4168,19 @@ function getObserver(first, second, third) {
 * @returns `true` if the value is a beacon, otherwise `false`
 */
 function isBeacon(value) {
-	return isBeaconInstance(NAME_BEACON, value);
+	return isBeaconInstance(BEACON_NAME, value);
 }
 function isBeaconInstance(name, value) {
-	return isPlainObject(value) && value[KEY_BEACON] === name;
+	return isPlainObject(value) && value[BEACON_PROPERTY] === 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_PROPERTY] === "subscription";
 }
 /**
 * Is the value an observable?
@@ -3916,9 +4189,9 @@ function isBeaconInstance(name, value) {
 * @returns `true` if the value is an observable, otherwise `false`
 */
 function isObservable(value) {
-	return isBeaconInstance(NAME_OBSERVABLE, value);
+	return isBeaconInstance(BEACON_OBSERVABLE, value);
 }
-function observe(beacon) {
+function observeBeacon(beacon) {
 	const state = {
 		beacon,
 		active: beacon.active
@@ -3927,24 +4200,10 @@ function observe(beacon) {
 		deactivate: () => {
 			state.active = false;
 		},
-		subscribe(first, second, third) {
-			if (!beacon.active || !state.active) throw new Error(MESSAGE_OBSERVABLE);
-			const observer = getObserver(first, second, third);
-			const subscription = getSubscription({
-				isActive: () => beacon.active && state.active,
-				property: beaconSubscription,
-				subscriptions: beacon.subscriptions,
-				value: observer
-			});
-			observer.next?.(beacon.value);
-			return subscription;
-		}
+		subscribe: (first, second, third) => subscribeToObservable(state, first, second, third)
 	};
 	Object.defineProperties(instance, {
-		[KEY_BEACON]: {
-			enumerable: false,
-			value: NAME_OBSERVABLE
-		},
+		[BEACON_PROPERTY]: { value: BEACON_OBSERVABLE },
 		active: {
 			enumerable: true,
 			get: () => beacon.active && state.active
@@ -3952,26 +4211,139 @@ function observe(beacon) {
 	});
 	return Object.freeze(instance);
 }
-function update$1(type, state, value, finish) {
-	if (!state.active) return;
-	if (type === TYPE_NEXT) {
-		if (state.options.equal(state.value, value)) return;
-		state.value = value;
-	}
-	for (const [, observer] of state.subscriptions.values.to.any) observer[type]?.(value);
-	if (finish === true) finishBeacon(state, true);
+function subscribeToObservable(state, first, second, third) {
+	if (!state.beacon.active || !state.active) throw new Error(BEACON_MESSAGE_SUBSCRIBE);
+	const observer = getObserver(first, second, third);
+	const [subscription] = state.beacon.subscriptions.create({
+		isActive: () => state.beacon.active && state.active,
+		value: observer
+	});
+	observer.next?.(state.beacon.value);
+	return subscription;
+}
+function updateBeacon(type, state, value, finish) {
+	if (!state.active) return;
+	if (type === BEACON_TYPE_NEXT) {
+		if (state.options.equal(state.value, value)) return;
+		state.value = value;
+	}
+	for (const [, observer] of state.subscriptions.state.values.to.any) observer[type]?.(value);
+	if (finish === true) finishBeacon(state, true);
+}
+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_TYPE_ERROR = "error";
+const BEACON_TYPE_NEXT = "next";
+const beaconSubscription = { key: BEACON_PROPERTY };
+//#endregion
+//#region src/internal/herald.ts
+function createEvents(herald, state) {
+	const events = {};
+	Object.defineProperty(events, HERALD_PROPERTY, { value: HERALD_NAME_EVENTS });
+	for (const key of state.keys) events[key] = (callback, signal) => herald.subscribe(key, callback, signal);
+	return Object.freeze(events);
+}
+function emitForHerald(state, event, ...parameters) {
+	const items = state.subscriptions.state.values.from.keyed?.get(event);
+	if (items == null || items.size === 0) return;
+	for (const [callback] of items) callback(...parameters);
+}
+function getHeraldSubscriptionProperty(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 getHeraldState(input) {
+	const options = isPlainObject(input) ? 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);
+	return {
+		keys,
+		subscriptions: createSubscriptions({
+			keys,
+			property: getHeraldSubscriptionProperty(options.property)
+		}),
+		onCreate: options.onCreate
+	};
+}
+/**
+* Create a _Herald_ for announcing named events
+*
+* @param names Event names
+* @param property Optional property for subscription identification _(defaults to `$herald`)_
+* @returns _Herald_ instance
+*/
+function herald(options) {
+	const state = getHeraldState(options);
+	const instance = {
+		clear: () => state.subscriptions.clear(),
+		emit: (event, ...parameters) => emitForHerald(state, event, ...parameters),
+		observed: (event) => (state.subscriptions.state.items.keyed?.get(event)?.size ?? 0) > 0,
+		subscribe: (key, callback, signal) => subscribeToHerald(state, key, callback, signal)
+	};
+	Object.defineProperties(instance, {
+		[HERALD_PROPERTY]: { value: HERALD_NAME_HERALD },
+		events: {
+			enumerable: true,
+			value: createEvents(instance, state)
+		}
+	});
+	return Object.freeze(instance);
+}
+/**
+* Is the value a herald?
+*
+* @param value Value to check
+* @returns `true` if the value is a herald, otherwise `false`
+*/
+function isHerald(value) {
+	return isHeraldInstance(HERALD_NAME_HERALD, value);
+}
+/**
+* Is the value events for a herald?
+*
+* @param value Value to check
+* @returns `true` if the value is events for a herald, otherwise `false`
+*/
+function isHeraldEvents(value) {
+	return isHeraldInstance(HERALD_NAME_EVENTS, value);
 }
-const KEY_BEACON = "$beacon";
-const MESSAGE_BEACON = "Cannot retrieve observable from a closed beacon";
-const MESSAGE_OBSERVABLE = "Cannot subscribe to a closed observable";
-const NAME_BEACON = "beacon";
-const NAME_OBSERVABLE = "observable";
-const TYPE_ERROR = "error";
-const TYPE_NEXT = "next";
-const beaconSubscription = {
-	key: KEY_BEACON,
-	value: "subscription"
-};
+function isHeraldInstance(name, value) {
+	return isPlainObject(value) && HERALD_PROPERTY in value && value[HERALD_PROPERTY] === 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) && value[HERALD_PROPERTY] === "subscription";
+}
+function subscribeToHerald(state, key, callback, signal) {
+	const [subscription, existing] = state.subscriptions.create({
+		key,
+		signal,
+		value: callback
+	});
+	if (!existing) state.onCreate?.(key, callback, subscription);
+	return subscription;
+}
+const HERALD_PROPERTY = "$herald";
+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 heraldSubscription = { key: HERALD_PROPERTY };
 //#endregion
 //#region src/color/constants.ts
 const COLOR_ALPHA = {
@@ -4042,10 +4414,7 @@ const COLOR_MAX = {
 	hex: 255,
 	percent: 100
 };
-const COLOR_PROPERTY = {
-	name: "$color",
-	subscription: "subscription"
-};
+const COLOR_PROPERTY = { name: "$color" };
 const COLOR_TYPE = {
 	all: void 0,
 	hex: "hex",
@@ -4055,7 +4424,8 @@ const COLOR_TYPE = {
 	hwb: "hwb",
 	hwba: "hwba",
 	rgb: "rgb",
-	rgba: "rgba"
+	rgba: "rgba",
+	wildcard: "*"
 };
 COLOR_TYPE.all = /* @__PURE__ */ new Set([
 	COLOR_ALPHA.name,
@@ -4967,7 +5337,7 @@ function getDefaultColorState() {
 		origin: COLOR_TYPE.hex
 	};
 }
-function setColorValue(color, state, subscriptions, type, value, alpha) {
+function setColorValue(color, state, changes, type, value, alpha) {
 	state.hex = void 0;
 	state.hsl = void 0;
 	state.hwb = void 0;
@@ -4975,36 +5345,33 @@ function setColorValue(color, state, subscriptions, type, value, alpha) {
 	state.origin = type;
 	state[type] = value;
 	if (alpha != null) state.alpha = getAlpha(alpha, type === COLOR_TYPE.hex);
-	for (const type of COLOR_TYPE.all) {
-		const callbacks = subscriptions.values.to.keyed?.get(type);
-		if (callbacks != null) for (const callback of callbacks.values()) callback(color[type]);
-	}
-	for (const callback of subscriptions.values.to.any.values()) callback(color);
+	for (const type of COLOR_TYPE.all) if (changes.observed(type)) changes.emit(type, color[type]);
+	changes.emit(COLOR_TYPE.wildcard, color);
 }
-function setHexColor(color, state, subscriptions, value, alpha) {
+function setHexColor(color, state, changes, value, alpha) {
 	if (!isHexColor(value) || !alpha && value === state.hex) return;
 	const normalized = getNormalizedHex(value, true);
-	setColorValue(color, state, subscriptions, COLOR_TYPE.hex, normalized.slice(0, COLOR_LENGTHS.hexLong), alpha ? normalized.slice(COLOR_LENGTHS.hexLong) : void 0);
+	setColorValue(color, state, changes, COLOR_TYPE.hex, normalized.slice(0, COLOR_LENGTHS.hexLong), alpha ? normalized.slice(COLOR_LENGTHS.hexLong) : void 0);
 }
-function setHSLColor(color, state, subscriptions, value, alpha) {
+function setHSLColor(color, state, changes, value, alpha) {
 	if (!isHslLike(value)) return;
-	setColorValue(color, state, subscriptions, COLOR_TYPE.hsl, {
+	setColorValue(color, state, changes, COLOR_TYPE.hsl, {
 		hue: getDegrees(value.hue),
 		saturation: getPercentage(value.saturation),
 		lightness: getPercentage(value.lightness)
 	}, alpha ? value.alpha : void 0);
 }
-function setHWBColor(color, state, subscriptions, value, alpha) {
+function setHWBColor(color, state, changes, value, alpha) {
 	if (!isHwbLike(value)) return;
-	setColorValue(color, state, subscriptions, COLOR_TYPE.hwb, {
+	setColorValue(color, state, changes, COLOR_TYPE.hwb, {
 		hue: getDegrees(value.hue),
 		whiteness: getPercentage(value.whiteness),
 		blackness: getPercentage(value.blackness)
 	}, alpha ? value.alpha : void 0);
 }
-function setRGBColor(color, state, subscriptions, value, alpha) {
+function setRGBColor(color, state, changes, value, alpha) {
 	if (!isRgbLike(value)) return;
-	setColorValue(color, state, subscriptions, COLOR_TYPE.rgb, {
+	setColorValue(color, state, changes, COLOR_TYPE.rgb, {
 		red: getHexValue(value.red),
 		green: getHexValue(value.green),
 		blue: getHexValue(value.blue)
@@ -5018,6 +5385,9 @@ const getters = {
 };
 //#endregion
 //#region src/color/misc/format.ts
+function formatHexColor(color, alpha) {
+	return `#${alpha === true ? color.hexa : color.hex}`;
+}
 function formatHslColor(state, alpha) {
 	const { hue, lightness, saturation } = getColorFromState(state, COLOR_TYPE.hsl);
 	return `hsl(${hue}deg ${saturation}% ${lightness}%${getSuffix(state, alpha)})`;
@@ -5036,51 +5406,56 @@ function getSuffix(state, alpha) {
 //#endregion
 //#region src/color/instance.ts
 function color(value) {
+	const changes = herald({
+		names: [COLOR_TYPE.wildcard, ...COLOR_TYPE.all],
+		property: colorSubscription,
+		onCreate: (event, callback) => onCreateSubscription(instance, event, callback)
+	});
 	const state = getColorState(value);
-	const subscriptions = getSubscriptions(COLOR_TYPE.all);
 	const instance = {
-		subscribe: (first, second) => subscribeToColor(subscriptions, first, second),
-		toHexString: (alpha) => `#${alpha === true ? instance.hexa : instance.hex}`,
+		subscribe: (callback, signal) => changes.subscribe(COLOR_TYPE.wildcard, callback, signal),
+		toHexString: (alpha) => formatHexColor(instance, alpha),
 		toHslString: (alpha) => formatHslColor(state, alpha),
 		toHwbString: (alpha) => formatHwbColor(state, alpha),
 		toRgbString: (alpha) => formatRgbColor(state, alpha),
 		toString: () => instance.toHexString(),
-		unsubscribe: () => clearSubscriptions(subscriptions)
+		unsubscribe: () => changes.clear()
 	};
 	Object.defineProperties(instance, {
-		[COLOR_PROPERTY.name]: {
-			enumerable: false,
-			value: true
-		},
+		[COLOR_PROPERTY.name]: { value: true },
 		alpha: {
 			enumerable: true,
 			get: () => state.alpha.value,
 			set: (value) => setAlphaValue(state, value)
 		},
-		hex: getProperty(COLOR_TYPE.hex, instance, state, subscriptions, false),
-		hexa: getProperty(COLOR_TYPE.hex, instance, state, subscriptions, true),
-		hsl: getProperty(COLOR_TYPE.hsl, instance, state, subscriptions, false),
-		hsla: getProperty(COLOR_TYPE.hsl, instance, state, subscriptions, true),
-		hwb: getProperty(COLOR_TYPE.hwb, instance, state, subscriptions, false),
-		hwba: getProperty(COLOR_TYPE.hwb, instance, state, subscriptions, true),
+		changes: {
+			enumerable: true,
+			value: changes.events
+		},
+		hex: getColorProperty(COLOR_TYPE.hex, instance, state, changes, false),
+		hexa: getColorProperty(COLOR_TYPE.hex, instance, state, changes, true),
+		hsl: getColorProperty(COLOR_TYPE.hsl, instance, state, changes, false),
+		hsla: getColorProperty(COLOR_TYPE.hsl, instance, state, changes, true),
+		hwb: getColorProperty(COLOR_TYPE.hwb, instance, state, changes, false),
+		hwba: getColorProperty(COLOR_TYPE.hwb, instance, state, changes, true),
 		origin: {
 			enumerable: true,
 			get: () => state.origin
 		},
-		rgb: getProperty(COLOR_TYPE.rgb, instance, state, subscriptions, false),
-		rgba: getProperty(COLOR_TYPE.rgb, instance, state, subscriptions, true)
+		rgb: getColorProperty(COLOR_TYPE.rgb, instance, state, changes, false),
+		rgba: getColorProperty(COLOR_TYPE.rgb, instance, state, changes, true)
 	});
 	return Object.freeze(instance);
 }
-function getProperty(space, color, state, subscriptions, alpha) {
+function getColorProperty(space, color, state, changes, alpha) {
 	const setValue = setters[space];
 	return {
 		enumerable: true,
-		get: () => getValue$1(space, state, alpha),
-		set: (value) => setValue(color, state, subscriptions, value, alpha)
+		get: () => getColorValue(space, state, alpha),
+		set: (value) => setValue(color, state, changes, value, alpha)
 	};
 }
-function getValue$1(space, state, alpha) {
+function getColorValue(space, state, alpha) {
 	const value = getColorFromState(state, space);
 	if (typeof value === "string") return alpha ? `${value}${state.alpha.hex}` : value;
 	return alpha ? {
@@ -5088,28 +5463,16 @@ function getValue$1(space, state, alpha) {
 		alpha: state.alpha.value
 	} : { ...value };
 }
+function onCreateSubscription(instance, event, callback) {
+	let value;
+	if (event === COLOR_TYPE.wildcard) value = instance;
+	else value = instance[event];
+	callback(value);
+}
 function setAlphaValue(state, value) {
 	if (typeof value === "number" && !Number.isNaN(value)) state.alpha = getAlpha(value, false);
 }
-function subscribeToColor(subscriptions, first, second) {
-	let key;
-	let value;
-	if (typeof first === "string") {
-		key = first;
-		value = second;
-	} else if (typeof first === "function") value = first;
-	if (typeof value !== "function") throw new Error();
-	return getSubscription({
-		key,
-		subscriptions,
-		value,
-		property: colorSubscription
-	});
-}
-const colorSubscription = {
-	key: COLOR_PROPERTY.name,
-	value: COLOR_PROPERTY.subscription
-};
+const colorSubscription = { key: COLOR_PROPERTY.name };
 const setters = {
 	hex: setHexColor,
 	hsl: setHSLColor,
@@ -5252,13 +5615,13 @@ const EXPRESSION_WHITESPACE = /^\s*$/;
 //#endregion
 //#region src/logger.ts
 function isLogger(value) {
-	return isLoggerInstance(NAME_LOGGER, value);
+	return isLoggerInstance(LOGGER_NAME, value);
 }
 function isLoggerInstance(name, value) {
-	return typeof value === "object" && value !== null && value[KEY_LOGGER] === name;
+	return typeof value === "object" && value !== null && value[LOGGER_PROPERTY] === name;
 }
 function isTimedLogger(value) {
-	return isLoggerInstance(NAME_TIMED, value);
+	return isLoggerInstance(LOGGER_NAME_TIMED, value);
 }
 function timedLogger(label) {
 	function stop() {
@@ -5277,35 +5640,20 @@ function timedLogger(label) {
 	};
 	const instance = {};
 	Object.defineProperties(instance, {
-		[KEY_LOGGER]: {
-			enumerable: false,
-			value: NAME_TIMED
-		},
+		[LOGGER_PROPERTY]: { value: LOGGER_NAME_TIMED },
 		active: {
 			enumerable: true,
-			get() {
-				return state.started && !state.stopped && enabled;
-			}
-		},
-		log: {
-			enumerable: true,
-			get() {
-				return this.active ? logger : noop;
-			}
+			get: () => state.started && !state.stopped && enabled
 		},
-		stop: {
-			enumerable: true,
-			get() {
-				return instance.active ? stop() : noop;
-			}
-		}
+		log: { get: () => instance.active ? logger : noop },
+		stop: { get: () => instance.active ? stop() : noop }
 	});
 	if (state.started) console.time(label);
 	return Object.freeze(instance);
 }
-const KEY_LOGGER = "$logger";
-const NAME_LOGGER = "Logger";
-const NAME_TIMED = "TimedLogger";
+const LOGGER_NAME = "Logger";
+const LOGGER_NAME_TIMED = "TimedLogger";
+const LOGGER_PROPERTY = "$logger";
 const methods = [
 	"debug",
 	"dir",
@@ -5324,349 +5672,84 @@ const methods = [
 const Logger = (() => {
 	const instance = {};
 	Object.defineProperties(instance, {
-		[KEY_LOGGER]: {
-			enumerable: false,
-			value: NAME_LOGGER
-		},
+		[LOGGER_PROPERTY]: { value: LOGGER_NAME },
 		enabled: {
 			enumerable: true,
-			get() {
-				return enabled;
-			},
-			set(value) {
+			get: () => enabled,
+			set: (value) => {
 				enabled = typeof value === "boolean" ? value : enabled;
 			}
 		},
-		time: {
-			enumerable: true,
-			value(label) {
-				return timedLogger(label);
-			}
-		}
-	});
-	for (const method of methods) Object.defineProperty(instance, method, {
-		enumerable: true,
-		get() {
-			return enabled ? console[method].bind(console) : noop;
-		}
+		time: { value: (label) => timedLogger(getString(label)) }
 	});
-	return Object.freeze(instance);
-})();
-let enabled = true;
-//#endregion
-//#region src/math.ts
-function average(array, key) {
-	const aggregated = aggregate(AGGREGATION_AVERAGE, array, key);
-	return aggregated.count > 0 ? aggregated.value / aggregated.count : NaN;
-}
-/**
-* Round a number up
-*
-* @param value Number to round up
-* @param decimals Number of decimal places to round to _(defaults to `0`)_
-* @returns Rounded number, or `Number.NaN` if the value if unable to be rounded
-*/
-function ceil(value, decimals) {
-	return roundNumber(Math.ceil, value, decimals);
-}
-function count(array, key, value) {
-	if (!Array.isArray(array)) return NaN;
-	const { length } = array;
-	const callback = getAggregateCallback(key);
-	if (callback == null) return length;
-	let counted = 0;
-	for (let index = 0; index < length; index += 1) {
-		const item = array[index];
-		if (Object.is(callback(item, index, array), value)) counted += 1;
-	}
-	return counted;
-}
-/**
-* Round a number down
-*
-* @param value Number to round down
-* @param decimals Number of decimal places to round to _(defaults to `0`)_
-* @returns Rounded number, or `Number.NaN` if the value if unable to be rounded
-*/
-function floor(value, decimals) {
-	return roundNumber(Math.floor, value, decimals);
-}
-function median(array, key) {
-	let length = Array.isArray(array) ? array.length : 0;
-	if (!Array.isArray(array) || length === 0) return NaN;
-	let values = array;
-	const callback = getAggregateCallback(key);
-	if (callback != null) values = array.map((item, index) => callback(item, index, array));
-	const numbers = values.filter(isNumber).sort((first, second) => first - second);
-	length = numbers.length;
-	if (length === 1) return numbers[0];
-	if (length % 2 === 0) {
-		const first = length / 2 - 1;
-		const second = length / 2;
-		return (numbers[first] + numbers[second]) / 2;
-	}
-	return numbers[Math.floor(length / 2)];
-}
-function min(array, key) {
-	return getAggregated("min", array, key);
-}
-function sum(array, key) {
-	return getAggregated("sum", array, key);
-}
-//#endregion
-//#region src/promise/models.ts
-/**
-* A _Promise_ that can be canceled
-*/
-var CancelablePromise = class extends Promise {
-	#rejector;
-	constructor(executor) {
-		let rejector;
-		super((resolve, reject) => {
-			rejector = reject;
-			executor(resolve, reject);
-		});
-		this.#rejector = rejector;
-	}
-	/**
-	* Cancel the _Promise_, rejecting it with an optional reason
-	*
-	* @param reason Optional reason for canceling the _Promise_
-	*/
-	cancel(reason) {
-		this.#rejector(reason);
-	}
-};
-/**
-* An error thrown when a promise times out
-*/
-var PromiseTimeoutError = class extends Error {
-	constructor() {
-		super(PROMISE_MESSAGE_TIMEOUT);
-		this.name = PROMISE_ERROR_NAME;
-	}
-};
-const PROMISE_ABORT_EVENT = "abort";
-const PROMISE_ABORT_OPTIONS = { once: true };
-const PROMISE_ERROR_NAME = "PromiseTimeoutError";
-const PROMISE_MESSAGE_EXPECTATION_ATTEMPT = "Attempt expected a function or a promise";
-const PROMISE_MESSAGE_EXPECTATION_RESULT = "toResult expected a Promise";
-const PROMISE_MESSAGE_EXPECTATION_TIMED = "Timed function expected a Promise";
-const PROMISE_MESSAGE_TIMEOUT = "Promise timed out";
-const PROMISE_STRATEGY_ALL = /* @__PURE__ */ new Set(["complete", "first"]);
-const PROMISE_STRATEGY_DEFAULT = "complete";
-const PROMISE_TYPE_FULFILLED = "fulfilled";
-const PROMISE_TYPE_REJECTED = "rejected";
-//#endregion
-//#region src/promise/helpers.ts
-function getPromiseOptions(input) {
-	if (typeof input === "number") return { time: getNumberOrDefault(input, 0) };
-	if (input instanceof AbortSignal) return {
-		signal: input,
-		time: 0
-	};
-	const options = typeof input === "object" && input !== null ? input : {};
-	return {
-		signal: options.signal instanceof AbortSignal ? options.signal : void 0,
-		time: getNumberOrDefault(options.time, 0)
-	};
-}
-function getPromisesOptions(input) {
-	if (typeof input === "string") return { strategy: getStrategyOrDefault(input) };
-	if (input instanceof AbortSignal) return {
-		signal: input,
-		strategy: PROMISE_STRATEGY_DEFAULT
-	};
-	const options = typeof input === "object" && input !== null ? input : {};
-	return {
-		signal: options.signal instanceof AbortSignal ? options.signal : void 0,
-		strategy: getStrategyOrDefault(options.strategy)
-	};
-}
-function getResultsFromPromises(promised) {
-	return promised.map((result) => isFulfilled(result) ? ok(result.value) : error(result.reason));
-}
-function getStrategyOrDefault(value) {
-	return PROMISE_STRATEGY_ALL.has(value) ? value : PROMISE_STRATEGY_DEFAULT;
-}
-/**
-* Is the value a fulfilled _Promise_ result?
-*
-* @param value Value to check
-* @returns `true` if the value is a fulfilled _Promise_ result, otherwise `false`
-*/
-function isFulfilled(value) {
-	return isType(value, PROMISE_TYPE_FULFILLED);
-}
-/**
-* Is the value a rejected _Promise_ result?
-*
-* @param value Value to check
-* @returns `true` if the value is a rejected _Promise_ result, otherwise `false`
-*/
-function isRejected(value) {
-	return isType(value, PROMISE_TYPE_REJECTED);
-}
-function isType(value, type) {
-	return typeof value === "object" && value !== null && value.status === type;
-}
-//#endregion
-//#region src/promise/misc.ts
-/**
-* Create a cancelable _Promise_
-*
-* @param executor Executor function for the _Promise_
-* @returns Cancelable _Promise_
-*/
-function cancelable(executor) {
-	return new CancelablePromise(executor);
-}
-function handleResult(status, parameters) {
-	const { abort, complete, data, handlers, index, signal, value } = parameters;
-	if (signal?.aborted ?? false) return;
-	if (!complete && status === "rejected") {
-		settlePromise(abort, handlers.reject, value, signal);
-		return;
-	}
-	data.result[index] = !complete ? value : status === "fulfilled" ? {
-		status,
-		value
-	} : {
-		status,
-		reason: value
-	};
-	if (index === data.last) settlePromise(abort, handlers.resolve, data.result, signal);
-}
-function settlePromise(aborter, settler, value, signal) {
-	signal?.removeEventListener(PROMISE_ABORT_EVENT, aborter);
-	settler(value);
-}
-async function toResult(value) {
-	const actual = typeof value === "function" ? value() : value;
-	if (!(actual instanceof Promise)) return Promise.reject(/* @__PURE__ */ new TypeError(PROMISE_MESSAGE_EXPECTATION_RESULT));
-	return actual.then((result) => ok(result)).catch((reason) => error(reason));
-}
-//#endregion
-//#region src/promise/delay.ts
-function delay(options) {
-	const { signal, time } = getPromiseOptions(options);
-	if (signal?.aborted ?? false) return Promise.reject(signal.reason);
-	function abort() {
-		timer.cancel();
-		rejector(signal.reason);
-	}
-	const timer = getTimer(TIMER_WAIT, () => {
-		settlePromise(abort, resolver, void 0, signal);
-	}, time);
-	signal?.addEventListener(PROMISE_ABORT_EVENT, abort, PROMISE_ABORT_OPTIONS);
-	let rejector;
-	let resolver;
-	return new Promise((resolve, reject) => {
-		rejector = reject;
-		resolver = resolve;
-		if (time === 0) settlePromise(abort, resolve, void 0, signal);
-		else timer();
+	for (const method of methods) Object.defineProperty(instance, method, {
+		enumerable: true,
+		get() {
+			return enabled ? console[method].bind(console) : noop;
+		}
 	});
-}
+	return Object.freeze(instance);
+})();
+let enabled = true;
 //#endregion
-//#region src/promise/timed.ts
-async function getTimedPromise(promise, time, signal) {
-	function abort() {
-		timer.cancel();
-		rejector(signal.reason);
-	}
-	signal?.addEventListener(PROMISE_ABORT_EVENT, abort, PROMISE_ABORT_OPTIONS);
-	const timer = getTimer(TIMER_WAIT, () => {
-		settlePromise(abort, rejector, new PromiseTimeoutError(), signal);
-	}, time);
-	let rejector;
-	return Promise.race([promise, new Promise((_, reject) => {
-		rejector = reject;
-		timer();
-	})]).then((value) => {
-		timer.cancel();
-		rejector(void 0);
-		signal?.removeEventListener(PROMISE_ABORT_EVENT, abort);
-		return value;
-	});
+//#region src/math.ts
+function average(array, key) {
+	const aggregated = aggregate(AGGREGATION_AVERAGE, array, key);
+	return aggregated.count > 0 ? aggregated.value / aggregated.count : NaN;
 }
-async function timed(promise, options) {
-	if (!(promise instanceof Promise)) return Promise.reject(/* @__PURE__ */ new TypeError(PROMISE_MESSAGE_EXPECTATION_TIMED));
-	const { signal, time } = getPromiseOptions(options);
-	if (signal?.aborted ?? false) return Promise.reject(signal.reason);
-	return time > 0 ? getTimedPromise(promise, time, signal) : promise;
+/**
+* Round a number up
+*
+* @param value Number to round up
+* @param decimals Number of decimal places to round to _(defaults to `0`)_
+* @returns Rounded number, or `Number.NaN` if the value if unable to be rounded
+*/
+function ceil(value, decimals) {
+	return roundNumber(Math.ceil, value, decimals);
 }
-//#endregion
-//#region src/promise/index.ts
-async function attemptPromise(value, options) {
-	const isFunction = typeof value === "function";
-	if (!isFunction && !(value instanceof Promise)) return Promise.reject(/* @__PURE__ */ new TypeError(PROMISE_MESSAGE_EXPECTATION_ATTEMPT));
-	const { signal, time } = getPromiseOptions(options);
-	if (signal?.aborted ?? false) return Promise.reject(signal.reason);
-	function abort() {
-		rejector(signal.reason);
-	}
-	async function handler(resolve, reject) {
-		try {
-			let result = isFunction ? value() : await value;
-			if (result instanceof Promise) result = await result;
-			settlePromise(abort, resolve, result, signal);
-		} catch (error) {
-			settlePromise(abort, reject, error, signal);
-		}
+function count(array, key, value) {
+	if (!Array.isArray(array)) return NaN;
+	const { length } = array;
+	const callback = getAggregateCallback(key);
+	if (callback == null) return length;
+	let counted = 0;
+	for (let index = 0; index < length; index += 1) {
+		const item = array[index];
+		if (Object.is(callback(item, index, array), value)) counted += 1;
 	}
-	let rejector;
-	signal?.addEventListener(PROMISE_ABORT_EVENT, abort, PROMISE_ABORT_OPTIONS);
-	const promise = new Promise((resolve, reject) => {
-		rejector = reject;
-		handler(resolve, reject);
-	});
-	return time > 0 ? getTimedPromise(promise, time, signal) : promise;
+	return counted;
 }
-async function promises(items, options) {
-	const { signal, strategy } = getPromisesOptions(options);
-	if (signal?.aborted ?? false) return Promise.reject(signal.reason);
-	if (!Array.isArray(items)) return Promise.resolve([]);
-	const actual = items.map((item) => typeof item === "function" ? item() : item).filter((item) => item instanceof Promise);
-	const { length } = actual;
-	if (length === 0) return Promise.resolve([]);
-	const complete = strategy === PROMISE_STRATEGY_DEFAULT;
-	function abort() {
-		handlers.reject(signal.reason);
+/**
+* Round a number down
+*
+* @param value Number to round down
+* @param decimals Number of decimal places to round to _(defaults to `0`)_
+* @returns Rounded number, or `Number.NaN` if the value if unable to be rounded
+*/
+function floor(value, decimals) {
+	return roundNumber(Math.floor, value, decimals);
+}
+function median(array, key) {
+	let length = Array.isArray(array) ? array.length : 0;
+	if (!Array.isArray(array) || length === 0) return NaN;
+	let values = array;
+	const callback = getAggregateCallback(key);
+	if (callback != null) values = array.map((item, index) => callback(item, index, array));
+	const numbers = values.filter(isNumber).sort((first, second) => first - second);
+	length = numbers.length;
+	if (length === 1) return numbers[0];
+	if (length % 2 === 0) {
+		const first = length / 2 - 1;
+		const second = length / 2;
+		return (numbers[first] + numbers[second]) / 2;
 	}
-	signal?.addEventListener(PROMISE_ABORT_EVENT, abort, PROMISE_ABORT_OPTIONS);
-	const data = {
-		last: length - 1,
-		result: []
-	};
-	let handlers;
-	return new Promise((resolve, reject) => {
-		handlers = {
-			reject,
-			resolve
-		};
-		for (let index = 0; index < length; index += 1) actual[index].then((value) => handleResult(PROMISE_TYPE_FULFILLED, {
-			abort,
-			complete,
-			data,
-			handlers,
-			index,
-			signal,
-			value
-		})).catch((reason) => handleResult(PROMISE_TYPE_REJECTED, {
-			abort,
-			complete,
-			data,
-			handlers,
-			index,
-			signal,
-			value: reason
-		}));
-	});
+	return numbers[Math.floor(length / 2)];
 }
-promises.result = resultPromises;
-async function resultPromises(items, signal) {
-	return promises(items, signal).then(getResultsFromPromises);
+function min(array, key) {
+	return getAggregated("min", array, key);
+}
+function sum(array, key) {
+	return getAggregated("sum", array, key);
 }
 //#endregion
 //#region src/query.ts
@@ -5678,15 +5761,15 @@ async function resultPromises(items, signal) {
 */
 function fromQuery(query) {
 	if (typeof query !== "string" || query.trim().length === 0) return {};
-	const parts = query.split(AMPERSAND).map((part) => part.split(EQUAL).map(tryDecode)).sort(([first], [second]) => first.localeCompare(second));
+	const parts = query.split(QUERY_AMPERSAND).map((part) => part.split(QUERY_EQUAL).map(tryDecode)).sort(([first], [second]) => first.localeCompare(second));
 	const { length } = parts;
 	const parameters = {};
 	let position = 0;
 	let array;
 	for (let index = 0; index < length; index += 1) {
 		const [key, value] = parts[index];
-		if (EXPRESSION_ARRAY_SUFFIX.test(key)) {
-			const named = key.replace(EXPRESSION_ARRAY_SUFFIX, "");
+		if (QUERY_EXPRESSION_ARRAY_SUFFIX.test(key)) {
+			const named = key.replace(QUERY_EXPRESSION_ARRAY_SUFFIX, "");
 			if (named !== array) {
 				array = named;
 				position = 0;
@@ -5708,9 +5791,9 @@ function getParts(value, fromArray, prefix) {
 	for (let index = 0; index < length; index += 1) {
 		const key = keys[index];
 		const val = value[key];
-		const fullKey = join([prefix, fromArray ? void 0 : key], DOT);
+		const fullKey = join([prefix, fromArray ? void 0 : key], QUERY_DOT);
 		const encodedKey = getString(tryEncode(fullKey));
-		const prefixedKey = fromArray ? join([encodedKey, index], DOT) : encodedKey;
+		const prefixedKey = fromArray ? join([encodedKey, index], QUERY_DOT) : encodedKey;
 		if (Array.isArray(val)) parts.push(...getParts(val, true, fullKey));
 		else if (isPlainObject(val)) parts.push(...getParts(val, false, fullKey));
 		else if (isDecodable(val)) parts.push(`${prefixedKey}=${getString(tryEncode(val))}`);
@@ -5719,7 +5802,7 @@ function getParts(value, fromArray, prefix) {
 	return parts;
 }
 function getQueryValue(value) {
-	if (EXPRESSION_BOOLEAN.test(value)) return value === TRUE;
+	if (QUERY_EXPRESSION_BOOLEAN.test(value)) return value === QUERY_TRUE;
 	const asNumber = getNumber(value);
 	if (!Number.isNaN(asNumber)) return asNumber;
 	const parsed = Date.parse(value);
@@ -5728,7 +5811,7 @@ function getQueryValue(value) {
 	return date.toJSON() === value ? date : value;
 }
 function isDecodable(value) {
-	return TYPES.has(typeof value);
+	return QUERY_TYPES.has(typeof value);
 }
 /**
 * Convert a plain _(nested)_ object to a query string
@@ -5737,15 +5820,15 @@ function isDecodable(value) {
 * @returns Query string representation of the object
 */
 function toQuery(parameters) {
-	return isPlainObject(parameters) ? join(getParts(parameters, false).filter((part) => part.length > 0), AMPERSAND) : "";
-}
-const AMPERSAND = "&";
-const DOT = ".";
-const EQUAL = "=";
-const EXPRESSION_ARRAY_SUFFIX = /\[\]$/;
-const EXPRESSION_BOOLEAN = /^(false|true)$/;
-const TRUE = "true";
-const TYPES = /* @__PURE__ */ new Set([
+	return isPlainObject(parameters) ? join(getParts(parameters, false).filter((part) => part.length > 0), QUERY_AMPERSAND) : "";
+}
+const QUERY_AMPERSAND = "&";
+const QUERY_DOT = ".";
+const QUERY_EQUAL = "=";
+const QUERY_EXPRESSION_ARRAY_SUFFIX = /\[\]$/;
+const QUERY_EXPRESSION_BOOLEAN = /^(false|true)$/;
+const QUERY_TRUE = "true";
+const QUERY_TYPES = /* @__PURE__ */ new Set([
 	"boolean",
 	"number",
 	"string"
@@ -5758,11 +5841,47 @@ const TYPES = /* @__PURE__ */ new Set([
 var QueueError = class extends Error {
 	constructor(message) {
 		super(message);
-		this.name = ERROR_NAME;
+		this.name = QUEUE_ERROR_NAME;
 	}
 };
+function addToQueue(instance, state, parameters, signal) {
+	if (instance.full) throw new QueueError(QUEUE_MESSAGE_MAXIMUM);
+	const abortSignal = signal instanceof AbortSignal ? signal : void 0;
+	if (abortSignal?.aborted ?? false) throw new Error(abortSignal?.reason);
+	const id = identify(state);
+	let rejector;
+	let resolver;
+	const promise = new Promise((resolve, reject) => {
+		rejector = reject;
+		resolver = resolve;
+	});
+	const aborter = createAborter(abortSignal, () => rejector(abortSignal?.reason));
+	state.items.push({
+		aborter,
+		id,
+		parameters,
+		promise,
+		key: state.key,
+		reject: rejector,
+		resolve: resolver
+	});
+	if (state.options.autostart) run(state);
+	return {
+		id,
+		promise
+	};
+}
+function clearQueue(state) {
+	const items = state.items.splice(0);
+	const { length } = items;
+	for (let index = 0; index < length; index += 1) {
+		const { aborter, reject } = items[index];
+		aborter?.cancel();
+		reject(new QueueError(QUEUE_MESSAGE_CLEAR));
+	}
+}
 function createQueue(callback, options, key) {
-	if (typeof callback !== "function") throw new TypeError(MESSAGE_CALLBACK);
+	if (typeof callback !== "function") throw new TypeError(QUEUE_MESSAGE_CALLBACK);
 	const state = {
 		callback,
 		key,
@@ -5774,71 +5893,16 @@ function createQueue(callback, options, key) {
 		runners: 0
 	};
 	const instance = {
-		add: (parameters, signal) => {
-			if (instance.full) throw new QueueError(MESSAGE_MAXIMUM);
-			const abortSignal = signal instanceof AbortSignal ? signal : void 0;
-			if (abortSignal?.aborted ?? false) throw new Error(abortSignal.reason);
-			const id = identify(state);
-			let rejector;
-			let resolver;
-			const promise = new Promise((resolve, reject) => {
-				rejector = reject;
-				resolver = resolve;
-			});
-			const aborter = abortSignal == null ? void 0 : () => rejector(abortSignal.reason);
-			signal?.addEventListener(EVENT_NAME, aborter, EVENT_OPTIONS);
-			state.items.push({
-				id,
-				parameters,
-				promise,
-				abort: aborter,
-				key: state.key,
-				reject: rejector,
-				resolve: resolver,
-				signal: abortSignal
-			});
-			if (state.options.autostart) run(state);
-			return {
-				id,
-				promise
-			};
-		},
-		clear: () => {
-			const items = state.items.splice(0);
-			const { length } = items;
-			for (let index = 0; index < length; index += 1) {
-				const { abort, reject, signal } = items[index];
-				reject(new QueueError(MESSAGE_CLEAR));
-				signal?.removeEventListener(EVENT_NAME, abort);
-			}
-		},
+		add: (parameters, signal) => addToQueue(instance, state, parameters, signal),
+		clear: () => clearQueue(state),
 		pause: () => {
 			state.paused = true;
 		},
-		remove: (id) => {
-			const index = state.items.findIndex((item) => item.id === id);
-			if (index > -1) {
-				const { abort, reject, signal } = state.items.splice(index, 1)[0];
-				reject(new QueueError(MESSAGE_REMOVE));
-				signal?.removeEventListener(EVENT_NAME, abort);
-			}
-		},
-		resume: () => {
-			if (state.paused) {
-				const handled = state.handled.splice(0);
-				const { length } = handled;
-				for (let index = 0; index < length; index += 1) handled[index]();
-			}
-			state.paused = false;
-			const length = Math.min(state.options.concurrency, state.items.length);
-			for (let index = 0; index < length; index += 1) run(state);
-		}
+		remove: (id) => removeQueued(state, id),
+		resume: () => resumeQueue(state)
 	};
 	Object.defineProperties(instance, {
-		[KEY_QUEUE]: {
-			enumerable: false,
-			value: NAME_QUEUE
-		},
+		[QUEUE_PROPERTY]: { value: QUEUE_NAME_QUEUE },
 		active: {
 			enumerable: true,
 			get: () => state.runners > 0
@@ -5874,15 +5938,6 @@ function createQueue(callback, options, key) {
 	});
 	return Object.freeze(instance);
 }
-function getBooleanOrDefault(value, defaultValue) {
-	return typeof value === "boolean" ? value : defaultValue;
-}
-function getItems(state) {
-	const size = {};
-	const queues = state.queues.entries();
-	for (const [key, queue] of queues) size[key] = queue.size;
-	return size;
-}
 function getOptions(input) {
 	const options = typeof input === "object" && input != null ? input : {};
 	return {
@@ -5892,7 +5947,7 @@ function getOptions(input) {
 	};
 }
 function getQueue(state, key, add) {
-	if (typeof key !== "string" || key.trim().length === 0) throw new TypeError(MESSAGE_KEY);
+	if (typeof key !== "string" || key.trim().length === 0) throw new TypeError(QUEUE_MESSAGE_KEY);
 	let queue = state.queues.get(key);
 	if (queue == null && add === true) {
 		queue = createQueue(state.callback, state.options, key);
@@ -5900,6 +5955,12 @@ function getQueue(state, key, add) {
 	}
 	return queue;
 }
+function getQueueItems(state) {
+	const size = {};
+	const queues = state.queues.entries();
+	for (const [key, queue] of queues) size[key] = queue.size;
+	return size;
+}
 function getStatus(state, status) {
 	const queues = state.queues.entries();
 	const result = [];
@@ -5907,8 +5968,8 @@ function getStatus(state, status) {
 	return result;
 }
 function handleQueuedResult(item, error, result) {
-	item.signal?.removeEventListener(EVENT_NAME, item.abort);
-	if (item.signal?.aborted ?? false) {
+	item.aborter?.cancel();
+	if (item.aborter?.signal?.aborted ?? false) {
 		item.reject();
 		return;
 	}
@@ -5937,7 +5998,7 @@ function identify(state) {
 * @returns `true` if the value is a keyed queue, otherwise `false`
 */
 function isKeyedQueue(value) {
-	return isQueueInstance(NAME_KEYED, value);
+	return isQueueInstance(QUEUE_NAME_KEYED, value);
 }
 /**
 * Is the value a queue?
@@ -5946,13 +6007,13 @@ function isKeyedQueue(value) {
 * @returns `true` if the value is a queue, otherwise `false`
 */
 function isQueue(value) {
-	return isQueueInstance(NAME_QUEUE, value);
+	return isQueueInstance(QUEUE_NAME_QUEUE, value);
 }
 function isQueueInstance(name, value) {
-	return typeof value === "object" && value != null && value[KEY_QUEUE] === name;
+	return typeof value === "object" && value != null && value[QUEUE_PROPERTY] === name;
 }
 function keyedQueue(callback, options) {
-	if (typeof callback !== "function") throw new TypeError(MESSAGE_CALLBACK);
+	if (typeof callback !== "function") throw new TypeError(QUEUE_MESSAGE_CALLBACK);
 	const state = {
 		callback,
 		options: getOptions(options),
@@ -5960,26 +6021,17 @@ function keyedQueue(callback, options) {
 	};
 	const instance = {
 		add: (key, parameters, signal) => getQueue(state, key, true).add(parameters, signal),
-		clear: (key) => {
-			handleQueues(state, HANDLE_CLEAR, key);
-		},
+		clear: (key) => handleQueues(state, QUEUE_HANDLE_CLEAR, key),
 		get: (key) => getQueue(state, key),
-		pause: (key) => {
-			handleQueues(state, HANDLE_PAUSE, key);
-		},
+		pause: (key) => handleQueues(state, QUEUE_HANDLE_PAUSE, key),
 		remove: (key, id) => removeQueue(state, key, id),
-		resume: (key) => {
-			handleQueues(state, HANDLE_RESUME, key);
-		}
+		resume: (key) => handleQueues(state, QUEUE_HANDLE_RESUME, key)
 	};
 	Object.defineProperties(instance, {
-		[KEY_QUEUE]: {
-			enumerable: false,
-			value: NAME_KEYED
-		},
+		[QUEUE_PROPERTY]: { value: QUEUE_NAME_KEYED },
 		active: {
 			enumerable: true,
-			get: () => getStatus(state, STATUS_ACTIVE)
+			get: () => getStatus(state, QUEUE_STATUS_ACTIVE)
 		},
 		autostart: {
 			enumerable: true,
@@ -5991,15 +6043,15 @@ function keyedQueue(callback, options) {
 		},
 		empty: {
 			enumerable: true,
-			get: () => getStatus(state, STATUS_EMPTY)
+			get: () => getStatus(state, QUEUE_STATUS_EMPTY)
 		},
 		full: {
 			enumerable: true,
-			get: () => getStatus(state, STATUS_FULL)
+			get: () => getStatus(state, QUEUE_STATUS_FULL)
 		},
 		items: {
 			enumerable: true,
-			get: () => getItems(state)
+			get: () => getQueueItems(state)
 		},
 		keys: {
 			enumerable: true,
@@ -6011,7 +6063,7 @@ function keyedQueue(callback, options) {
 		},
 		paused: {
 			enumerable: true,
-			get: () => getStatus(state, STATUS_PAUSED)
+			get: () => getStatus(state, QUEUE_STATUS_PAUSED)
 		},
 		queues: {
 			enumerable: true,
@@ -6026,7 +6078,7 @@ function queue(callback, options) {
 queue.keyed = keyedQueue;
 function removeQueue(state, key, id) {
 	if (key == null) {
-		handleQueues(state, HANDLE_CLEAR);
+		handleQueues(state, QUEUE_HANDLE_CLEAR);
 		state.queues.clear();
 		return;
 	}
@@ -6039,6 +6091,24 @@ function removeQueue(state, key, id) {
 	queue.clear();
 	state.queues.delete(key);
 }
+function removeQueued(state, id) {
+	const index = state.items.findIndex((item) => item.id === id);
+	if (index > -1) {
+		const { aborter, reject } = state.items.splice(index, 1)[0];
+		aborter?.cancel();
+		reject(new QueueError(QUEUE_MESSAGE_REMOVE));
+	}
+}
+function resumeQueue(state) {
+	if (state.paused) {
+		const handled = state.handled.splice(0);
+		const { length } = handled;
+		for (let index = 0; index < length; index += 1) handled[index]();
+	}
+	state.paused = false;
+	const length = Math.min(state.options.concurrency, state.items.length);
+	for (let index = 0; index < length; index += 1) run(state);
+}
 async function run(state) {
 	if (state.paused || state.runners >= state.options.concurrency) return;
 	state.runners += 1;
@@ -6047,7 +6117,7 @@ async function run(state) {
 		let error = false;
 		let result;
 		try {
-			if (!(item.signal?.aborted ?? false)) {
+			if (!(item.aborter?.signal?.aborted ?? false)) {
 				const parameters = item.key == null ? item.parameters : [item.key, ...item.parameters];
 				result = await state.callback(...parameters);
 			}
@@ -6057,9 +6127,7 @@ async function run(state) {
 		}
 		if (state.paused) {
 			const paused = item;
-			state.handled.push(() => {
-				handleQueuedResult(paused, error, result);
-			});
+			state.handled.push(() => handleQueuedResult(paused, error, result));
 			break;
 		}
 		handleQueuedResult(item, error, result);
@@ -6067,24 +6135,22 @@ async function run(state) {
 	}
 	state.runners -= 1;
 }
-const ERROR_NAME = "QueueError";
-const EVENT_NAME = "abort";
-const EVENT_OPTIONS = { once: true };
-const KEY_QUEUE = "$queue";
-const HANDLE_CLEAR = "clear";
-const HANDLE_PAUSE = "pause";
-const HANDLE_RESUME = "resume";
-const MESSAGE_CALLBACK = "A Queue requires a callback function";
-const MESSAGE_CLEAR = "Queue was cleared";
-const MESSAGE_KEY = "Key must be a non-empty string";
-const MESSAGE_MAXIMUM = "Queue has reached its maximum size";
-const MESSAGE_REMOVE = "Item removed from queue";
-const NAME_KEYED = "keyedQueue";
-const NAME_QUEUE = "queue";
-const STATUS_ACTIVE = "active";
-const STATUS_EMPTY = "empty";
-const STATUS_FULL = "full";
-const STATUS_PAUSED = "paused";
+const QUEUE_ERROR_NAME = "QueueError";
+const QUEUE_PROPERTY = "$queue";
+const QUEUE_HANDLE_CLEAR = "clear";
+const QUEUE_HANDLE_PAUSE = "pause";
+const QUEUE_HANDLE_RESUME = "resume";
+const QUEUE_MESSAGE_CALLBACK = "A Queue requires a callback function";
+const QUEUE_MESSAGE_CLEAR = "Queue was cleared";
+const QUEUE_MESSAGE_KEY = "Key must be a non-empty string";
+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_STATUS_ACTIVE = "active";
+const QUEUE_STATUS_EMPTY = "empty";
+const QUEUE_STATUS_FULL = "full";
+const QUEUE_STATUS_PAUSED = "paused";
 //#endregion
 //#region src/random.ts
 /**
@@ -6093,7 +6159,7 @@ const STATUS_PAUSED = "paused";
 * @returns Random boolean
 */
 function getRandomBoolean() {
-	return Math.random() > BOOLEAN_MODIFIER;
+	return Math.random() > RANDOM_BOOLEAN_MODIFIER;
 }
 /**
 * Get a random string of characters with a specified length
@@ -6104,7 +6170,7 @@ function getRandomBoolean() {
 */
 function getRandomCharacters(length, selection) {
 	if (typeof length !== "number" || length <= 0) return "";
-	const actual = typeof selection === "string" && selection.length > 0 ? selection : ALPHABET;
+	const actual = typeof selection === "string" && selection.length > 0 ? selection : RANDOM_ALPHABET;
 	let characters = "";
 	for (let index = 0; index < length; index += 1) characters += actual.charAt(getRandomInteger(0, actual.length - 1));
 	return characters;
@@ -6124,7 +6190,7 @@ function getRandomColor(prefix) {
 * @returns Random hexadecimal character from `0-9` and `A-F`
 */
 function getRandomHex() {
-	return HEX_CHARACTERS[getRandomInteger(0, HEX_MAXIMUM)];
+	return RANDOM_HEX_CHARACTERS[getRandomInteger(0, RANDOM_HEX_MAXIMUM)];
 }
 /**
 * Get a random item from an array
@@ -6142,96 +6208,10 @@ function getRandomItems(array, amount) {
 	if (amount === 1) return [array[getRandomInteger(0, array.length - 1)]];
 	return typeof amount !== "number" || amount <= 0 || amount >= array.length ? shuffle(array) : shuffle(array).slice(0, amount);
 }
-const ALPHABET = "abcdefghijklmnopqrstuvwxyz";
-const BOOLEAN_MODIFIER = .5;
-const HEX_CHARACTERS = "0123456789ABCDEF";
-const HEX_MAXIMUM = 15;
-//#endregion
-//#region src/result/index.ts
-async function asyncAttempt(value, err) {
-	try {
-		let result = typeof value === "function" ? value() : await value;
-		if (result instanceof Promise) result = await result;
-		return ok(result);
-	} catch (thrown) {
-		return getError(err ?? thrown, err == null ? void 0 : thrown);
-	}
-}
-function attempt(callback, err) {
-	try {
-		return ok(callback());
-	} catch (thrown) {
-		return getError(err ?? thrown, err == null ? void 0 : thrown);
-	}
-}
-attempt.async = asyncAttempt;
-//#endregion
-//#region src/result/match.ts
-async function asyncMatchResult(result, first, error) {
-	let value;
-	if (typeof result === "function") value = await result();
-	else if (result instanceof Promise) value = await result;
-	else value = result;
-	if (!isResult(value)) throw new Error(MESSAGE_RESULT);
-	const hasObj = typeof first === "object" && first !== null;
-	const okHandler = hasObj ? first.ok : first;
-	const errorHandler = hasObj ? first.error : error;
-	if (isOk(value)) return okHandler(value.value);
-	return errorHandler(value.error, value.original);
-}
-function matchResult(result, first, error) {
-	const value = typeof result === "function" ? result() : result;
-	if (!isResult(value)) throw new Error(MESSAGE_RESULT);
-	const hasObj = typeof first === "object" && first !== null;
-	const okHandler = hasObj ? first.ok : first;
-	const errorHandler = hasObj ? first.error : error;
-	if (isOk(value)) return okHandler(value.value);
-	return errorHandler(value.error, value.original);
-}
-matchResult.async = asyncMatchResult;
-const MESSAGE_RESULT = "`result.match` expected a Result or a function that returns a Result";
-//#endregion
-//#region src/result/work/flow.ts
-function attemptAsyncFlow(...fns) {
-	let Flow;
-	return (...args) => attempt.async(() => {
-		Flow ??= flow.async(...fns);
-		return Flow(...args.map((value) => {
-			if (isError(value)) throw value.error;
-			return isOk(value) ? value.value : value;
-		}));
-	});
-}
-function attemptFlow(...fns) {
-	let Flow;
-	return (...args) => attempt(() => {
-		Flow ??= flow(...fns);
-		return Flow(...args.map((value) => {
-			if (isError(value)) throw value.error;
-			return isOk(value) ? value.value : value;
-		}));
-	});
-}
-attemptFlow.async = attemptAsyncFlow;
-//#endregion
-//#region src/result/work/pipe.ts
-async function attemptAsyncPipe(initial, first, ...seconds) {
-	return attempt.async(() => {
-		if (isError(initial)) throw initial.error;
-		const value = typeof initial === "function" ? initial() : isOk(initial) ? initial.value : initial;
-		if (first == null) return value;
-		return asyncPipe(value, ...[first, ...seconds]);
-	});
-}
-function attemptPipe(initial, first, ...seconds) {
-	return attempt(() => {
-		if (isError(initial)) throw initial.error;
-		const value = typeof initial === "function" ? initial() : isOk(initial) ? initial.value : initial;
-		if (first == null) return value;
-		return pipe(value, ...[first, ...seconds]);
-	});
-}
-attemptPipe.async = attemptAsyncPipe;
+const RANDOM_ALPHABET = "abcdefghijklmnopqrstuvwxyz";
+const RANDOM_BOOLEAN_MODIFIER = .5;
+const RANDOM_HEX_CHARACTERS = "0123456789ABCDEF";
+const RANDOM_HEX_MAXIMUM = 15;
 //#endregion
 //#region src/sized/set.ts
 /**
@@ -6289,4 +6269,4 @@ var SizedSet = class extends Set {
 	}
 };
 //#endregion
-export { CancelablePromise, Logger, PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, PromiseTimeoutError, QueueError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, 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, filter, find, findLast, first, firstOrDefault, flatFreeze, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, getError, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getHwbColor, getHwbaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hasValueResult, herald, hexToHsl, hexToHsla, hexToHwb, hexToHwba, hexToRgb, hexToRgba, hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba, hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, interpolate, intersection, isArrayOrPlainObject, isBeacon, isColor, isConstructor, isEmpty, isError, isEvents, isFrozen, isFulfilled, isHerald, isHexColor, isHslColor, isHslaColor, isHwbColor, isHwbaColor, isInstanceOf, isKey, isKeyedQueue, isLogger, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isObservable, isOk, isPlainObject, isPrimitive, isQueue, isQueueInstance, isRejected, isResult, isRgbColor, isRgbaColor, isSorted, isSubscription, isTimedLogger, isTypedArray, join, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, lowerCase, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, select, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };
+export { CancelablePromise, Logger, PromiseTimeoutError, QueueError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, 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, filter, find, findLast, first, firstOrDefault, flatFreeze, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getHwbColor, getHwbaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hasValueResult, herald, hexToHsl, hexToHsla, hexToHwb, hexToHwba, hexToRgb, hexToRgba, hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba, hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, interpolate, intersection, isArrayOrPlainObject, isBeacon, isBeaconSubscription, isColor, isConstructor, isEmpty, isError, isFrozen, isFulfilled, 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, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isObservable, isOk, isPlainObject, isPrimitive, isQueue, isQueueInstance, isRejected, isResult, isRgbColor, isRgbaColor, isSorted, isSubscription, isTimedLogger, isTypedArray, join, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, lowerCase, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, select, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };