@oscarpalmer/atoms 0.194.0 → 0.195.1

package/dist/index.mjs

@@ -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;
@@ -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;
@@ -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 ? 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/array/push.ts
 /**
 * Push items into an array _(at the end)_
@@ -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
 *
@@ -1381,70 +1381,206 @@ 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 ? RESULT_PROPERTY_VALUE : RESULT_PROPERTY_ERROR) in value;
-}
-const RESULT_PROPERTY_ERROR = "error";
-const RESULT_PROPERTY_VALUE = "value";
+function noop() {}
 //#endregion
-//#region src/result/misc.ts
-function error(value, original) {
-	return getError(value, original);
-}
-function getError(value, original) {
-	const errorResult = {
-		error: value,
-		ok: false
+//#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;
 	};
-	if (original instanceof Error) errorResult.original = original;
-	return errorResult;
+	Object.defineProperty(timer, TIMER_CANCEL, { value: () => cancel() });
+	return timer;
 }
-/**
-* Creates an ok result
-*
-* @param value Value
-* @returns Ok result
-*/
-function ok(value) {
-	return {
-		ok: true,
-		value
-	};
+function getInterval(value) {
+	return typeof value === "number" && value > 0 ? value : 0;
 }
-/**
-* Converts a _Result_ to a _Promise_
+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);
+	};
+	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
+/**
+* Debounce a function, ensuring it is only called after `time` milliseconds have passed
 *
-* 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)_, the timer reset, and will wait another `time` milliseconds before the new call is made _(and so on...)_
 *
-* @param result _Result_ to convert
-* @returns Promised result
+* _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
 */
-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);
+function asyncDebounce(callback, time) {
+	return getAsyncTimer(TIMER_DEBOUNCE, callback, time);
+}
+/**
+* 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`_
+*
+* @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 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);
+}
+debounce.async = asyncDebounce;
+throttle.async = asyncThrottle;
+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 RESULT_MESSAGE_PROMISE = "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) {
@@ -1499,7 +1635,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
 *
@@ -1593,51 +1729,311 @@ function assertProperty(path, condition, message, error) {
 }
 const ASSERT_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() {}
-//#endregion
-//#region src/internal/number.ts
+//#region src/function/once.ts
 /**
-* Is the 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 check
-* @param minimum Minimum value
-* @param maximum Maximum value
-* @returns `true` if the value is between the minimum and maximum, otherwise `false`
+* _Available as `asyncOnce` and `once.async`_
+*
+* @param callback Callback to use once
+* @returns _Once_ callback
 */
-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);
+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);
+	}
 }
 /**
-* 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
+* Create a function that can only be called once, returning the same value on subsequent calls
 *
-* @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;
+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 ONCE_MESSAGE_CLEARED = "Once has been cleared";
+const ONCE_MESSAGE_EXPECTATION = "Once expected a function";
+once.async = asyncOnce;
+Object.defineProperty(once, "async", { value: asyncOnce });
+//#endregion
+//#region src/function/retry.ts
+/**
+* An error thrown when a retry fails
+*/
+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";
+retry.async = asyncRetry;
+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;
 }
@@ -1664,15 +2060,12 @@ function getNumber(value) {
 	if (isBinary || NUMBER_EXPRESSION_OCTAL.test(trimmed)) return Number.parseInt(trimmed.slice(2), isBinary ? 2 : NUMBER_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 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.ts
+//#region src/internal/sized/misc.ts
 function getSizedMaximum(first, second) {
 	let actual;
 	if (typeof first === "number") actual = first;
@@ -1682,7 +2075,7 @@ function getSizedMaximum(first, second) {
 const SIZED_MAXIMUM_ABSOLUTE = 16777216;
 const SIZED_MAXIMUM_DEFAULT = 1048576;
 //#endregion
-//#region src/sized/map.ts
+//#region src/internal/sized/map.ts
 /**
 * A _Map_ with a maximum size
 *
@@ -1736,7 +2129,7 @@ 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 {
@@ -1789,1012 +2182,722 @@ 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) {
-	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 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);
-	};
-	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
+//#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
+* Convert a string to kebab case _(this-is-kebab-case)_
 *
-* On subsequent calls, the timer is reset and will wait another `time` milliseconds _(and so on...)_
+* @param value String to convert
+* @returns Kebab-cased string
+*/
+function kebabCase(value) {
+	return toCase(STRING_CASE_KEBAB, value, false, false);
+}
+/**
+* Convert a string to lower 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 Lower-cased string
 */
-function debounce(callback, time) {
-	return getTimer(TIMER_DEBOUNCE, callback, time);
+function lowerCase(value) {
+	if (typeof value !== "string") return "";
+	memoizedLowerCase ??= memoize((v) => v.toLocaleLowerCase());
+	return memoizedLowerCase.run(value);
 }
 /**
-* Throttle a function, ensuring it is only called once every `time` milliseconds
+* Convert a string to pascal case _(ThisIsPascalCase)_
 *
-* @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 Pascal-cased string
 */
-function throttle(callback, time) {
-	return getTimer(TIMER_THROTTLE, callback, time);
+function pascalCase(value) {
+	return toCase(STRING_CASE_PASCAL, value, true, true);
 }
-Object.defineProperty(debounce, "async", { value: asyncDebounce });
-Object.defineProperty(throttle, "async", { value: 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
+* Convert a string to snake case _(this_is_snake_case)_
 *
-* _Available as `asyncOnce` and `once.async`_
+* @param value String to convert
+* @returns Snake-cased string
+*/
+function snakeCase(value) {
+	return toCase(STRING_CASE_SNAKE, value, false, false);
+}
+/**
+* Convert a string to title case _(Capitalizing Every Word)_
 *
-* @param callback Callback to use once
-* @returns _Once_ callback
+* @param value String to convert
+* @returns Title-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
-		},
-		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 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 clearState(state) {
-	if (!state.called || state.cleared) return;
-	state.cleared = true;
-	state.value = void 0;
+function toCase(type, value, capitalizeAny, capitalizeFirst) {
+	caseMemoizers[type] ??= memoize(toCaseCallback.bind({
+		type,
+		capitalizeAny,
+		capitalizeFirst
+	}));
+	return caseMemoizers[type].run(value);
 }
-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 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]);
 }
 /**
-* Create a function that can only be called once, returning the same value on subsequent calls
+* Convert a string to upper case
 *
-* @param callback Callback to use once
-* @returns _Once_ callback
+* @param value String to convert
+* @returns Upper-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: {
-			enumerable: true,
-			get: () => state.called
-		},
-		clear: { value: () => clearState(state) },
-		cleared: {
-			enumerable: true,
-			get: () => state.cleared
-		}
-	});
-	return fn;
+function upperCase(value) {
+	if (typeof value !== "string" || value.length === 0) return "";
+	memoizedUpperCase ??= memoize((v) => v.toLocaleUpperCase());
+	return memoizedUpperCase.run(value);
 }
-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/function/retry.ts
-/**
-* An error thrown when a retry fails
-*/
-var RetryError = class extends Error {
-	original;
-	constructor(message, original) {
-		super(message);
-		this.original = original;
-		this.name = RETRY_ERROR_NAME;
-	}
+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, with a delay between attempts
+* Deregister a equality comparison handler for a specific class
 *
-* _Available as `asyncRetry` and `retry.async`_
+* _Available as `deregisterEqualizer` and `equal.deregister`_
 *
-* @param callback Callback to retry
-* @param options Retry options
-* @returns Callback result
+* @param constructor Class constructor
 */
-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 deregisterEqualizer(constructor) {
+	equal.handlers.deregister(constructor);
 }
-function getRetryNumber(value) {
-	return typeof value === "number" && value > 0 ? value : 0;
+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 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 equal(first, second, options) {
+	return equalValue(first, second, getEqualOptions(options));
 }
-/**
-* 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;
-		}
+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;
 	}
-	throw new RetryError(RETRY_MESSAGE_FAILED, last);
-}
-function shouldRetry() {
+	const end = length - offset;
+	for (let index = offset; index < end; index += 1) if (!equalValue(first[index], second[index], options)) return false;
 	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/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);
+function equalArrayBuffer(first, second, options) {
+	return first.byteLength === second.byteLength ? equalArray(new Uint8Array(first), new Uint8Array(second), options) : false;
 }
-async function asyncPipe(value, ...pipes) {
-	assertPipeFunctions(pipes);
-	return asyncWork(value, pipes, false);
+function equalDataView(first, second, options) {
+	return first.byteOffset === second.byteOffset ? equalArrayBuffer(first.buffer, second.buffer, options) : false;
 }
-function pipe(value, ...pipes) {
-	assertPipeFunctions(pipes);
-	return work(value, pipes, 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;
 }
-async function asyncWork(initial, functions, flow) {
-	const { length } = functions;
-	let transformed = unwrapValue(initial);
+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 >= 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 fn = functions[index];
-		transformed = unwrapValue(flow && index === 0 && Array.isArray(initial) ? await fn(...initial) : await fn(transformed));
+		const key = firstKeys[index];
+		if (!(secondSet?.has(key) ?? secondKeys.includes(key)) || !equalValue(first[key], second[key], options)) return false;
 	}
-	return transformed;
+	return true;
 }
-function unwrapValue(value, flow, nested) {
-	if (typeof value === "function") {
-		if (nested != null) throw new TypeError(WORK_MESSAGE_NESTING);
-		return unwrapValue(value(), flow, 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;
 	}
-	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;
+	return true;
 }
-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);
+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 transformed;
+	return true;
 }
-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/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)
-	};
+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;
 }
-const ABORT_EVENT = "abort";
-const ABORT_OPTIONS = { once: true };
-//#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);
+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);
 	}
-	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()
+function getEqualOptions(input) {
+	const options = {
+		ignoreCase: false,
+		ignoreExpressions: {
+			enabled: false,
+			values: []
 		},
-		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)
+		ignoreKeys: {
+			enabled: false,
+			values: /* @__PURE__ */ new Set()
+		},
+		relaxedNullish: false
 	};
-	return 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;
 }
-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);
+/**
+* Create an equalizer with predefined options
+*
+* _Available as `initializeEqualizer` and `equal.initialize`_
+*
+* @param options Comparison options
+* @returns Equalizer function
+*/
+function initializeEqualizer(options) {
+	const actual = getEqualOptions(options);
+	const equalizer = (first, second) => equalValue(first, second, actual);
+	equalizer.deregister = deregisterEqualizer;
+	equalizer.register = registerEqualizer;
+	return equalizer;
 }
 /**
-* Is the value a subscription?
+* Register a equality comparison function for a specific class
 *
-* @param value Value to check
-* @returns `true` if the value is a subscription, otherwise `false`
+* _Available as `registerEqualizer` and `equal.register`_
+*
+* @param constructor Class constructor
+* @param handler Comparison function
 */
-function isSubscription(value) {
-	return isPlainObject(value) && SUBSCRIPTION_PROPERTY in value && value[SUBSCRIPTION_PROPERTY] === true;
+function registerEqualizer(constructor, handler) {
+	equal.handlers.register(constructor, handler);
 }
-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);
-	}
+const EQUAL_ARRAY_PEEK_PERCENTAGE = 10;
+const EQUAL_ARRAY_THRESHOLD = 100;
+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) {
+	return getNestedValue(data, path, ignoreCase === true).value;
 }
-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;
+//#endregion
+//#region src/internal/value/set.ts
+function setValue(data, path, value, ignoreCase) {
+	if (typeof data !== "object" || data === null || typeof path !== "string" || path.trim().length === 0) return data;
+	const shouldIgnoreCase = ignoreCase === true;
+	const paths = getPaths(path, shouldIgnoreCase);
+	if (typeof paths === "string") {
+		handleValue(data, paths, value, false, shouldIgnoreCase);
+		return data;
 	}
-	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 { length } = paths;
+	const lastIndex = length - 1;
+	let target = data;
+	for (let index = 0; index < length; index += 1) {
+		const currentPath = paths[index];
+		if (index === lastIndex) {
+			handleValue(target, currentPath, value, false, shouldIgnoreCase);
+			break;
+		}
+		let next = handleValue(target, currentPath, null, true, shouldIgnoreCase).value;
+		if (typeof next !== "object" || next === null) {
+			const nextPath = paths[index + 1];
+			if (SET_EXPRESSION_INDEX.test(nextPath)) next = Array.from({ length: Number(nextPath) + 1 }, () => void 0);
+			else next = {};
+			target[currentPath] = next;
+		}
+		target = next;
+	}
+	return data;
 }
-const SUBSCRIPTION_INVALID_KEY = "Invalid key for subscription";
-const SUBSCRIPTION_PROPERTY = "$subscription";
+const SET_EXPRESSION_INDEX = /^\d+$/;
 //#endregion
-//#region src/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);
+//#region src/internal/abort.ts
+function createAborter(value, onAbort) {
+	if (!(value instanceof AbortSignal)) return;
+	value.addEventListener(ABORT_EVENT, onAbort, ABORT_OPTIONS);
 	return {
-		key: property.key,
-		value: property.value
+		callback: onAbort,
+		signal: value,
+		cancel: () => value.removeEventListener(ABORT_EVENT, onAbort)
 	};
 }
-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
-	};
+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
 /**
-* Create a _Herald_ for announcing named events
-*
-* @param names Event names
-* @param property Optional property for subscription identification _(defaults to `$herald`)_
-* @returns _Herald_ instance
+* A _Promise_ that can be canceled
 */
-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)
+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
 	};
-	Object.defineProperties(instance, {
-		[HERALD_PROPERTY]: { value: HERALD_NAME_HERALD },
-		events: {
-			enumerable: true,
-			value: createEvents(instance, state)
-		}
-	});
-	return Object.freeze(instance);
+	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 events for a herald?
+* Is the value a fulfilled _Promise_ result?
 *
 * @param value Value to check
-* @returns `true` if the value is events for a herald, otherwise `false`
+* @returns `true` if the value is a fulfilled _Promise_ result, otherwise `false`
 */
-function isHeraldEvents(value) {
-	return isHeraldInstance(HERALD_NAME_EVENTS, value);
+function isFulfilled(value) {
+	return isType(value, PROMISE_TYPE_FULFILLED);
 }
 /**
-* Is the value a herald?
+* Is the value a rejected _Promise_ result?
 *
 * @param value Value to check
-* @returns `true` if the value is a herald, otherwise `false`
+* @returns `true` if the value is a rejected _Promise_ result, otherwise `false`
 */
-function isHerald(value) {
-	return isHeraldInstance(HERALD_NAME_HERALD, value);
+function isRejected(value) {
+	return isType(value, PROMISE_TYPE_REJECTED);
 }
-function isHeraldInstance(name, value) {
-	return isPlainObject(value) && HERALD_PROPERTY in value && value[HERALD_PROPERTY] === name;
+function isType(value, type) {
+	return typeof value === "object" && value !== null && value.status === type;
 }
+//#endregion
+//#region src/result/misc.ts
 /**
-* Is the value a herald subscription?
+* Converts a _Result_ to a _Promise_
 *
-* @param value Value to check
-* @returns `true` if the value is a herald subscription, otherwise `false`
+* Resolves if ok, rejects for error
+*
+* @param result _Result_ to convert
+* @returns Promised result
 */
-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;
+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 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 };
+const RESULT_MESSAGE_PROMISE = "toPromise expected to receive a Result";
 //#endregion
-//#region src/internal/value/equal.ts
+//#region src/promise/misc.ts
 /**
-* Deregister a equality comparison handler for a specific class
-*
-* _Available as `deregisterEqualizer` and `equal.deregister`_
+* Create a cancelable _Promise_
 *
-* @param constructor Class constructor
+* @param executor Executor function for the _Promise_
+* @returns Cancelable _Promise_
 */
-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));
+function cancelable(executor) {
+	return new CancelablePromise(executor);
 }
-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;
+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;
 	}
-	const end = length - offset;
-	for (let index = offset; index < end; index += 1) if (!equalValue(first[index], second[index], options)) return false;
-	return true;
+	data.result[index] = !complete ? value : status === "fulfilled" ? {
+		status,
+		value
+	} : {
+		status,
+		reason: value
+	};
+	if (index === data.last) settlePromise(handlers.resolve, data.result, aborter);
 }
-function equalArrayBuffer(first, second, options) {
-	return first.byteLength === second.byteLength ? equalArray(new Uint8Array(first), new Uint8Array(second), options) : false;
+function settlePromise(settler, value, aborter) {
+	aborter?.cancel();
+	settler(value);
 }
-function equalDataView(first, second, options) {
-	return first.byteOffset === second.byteOffset ? equalArrayBuffer(first.buffer, second.buffer, options) : false;
+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));
 }
-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;
+//#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();
+	});
 }
-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 >= 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 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;
+//#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;
+	});
 }
-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;
+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;
 }
-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);
+//#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;
 }
-function getEqualOptions(input) {
-	const options = {
-		ignoreCase: false,
-		ignoreExpressions: {
-			enabled: false,
-			values: []
-		},
-		ignoreKeys: {
-			enabled: false,
-			values: /* @__PURE__ */ new Set()
-		},
-		relaxedNullish: false
+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: []
 	};
-	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
-*/
-function initializeEqualizer(options) {
-	const actual = getEqualOptions(options);
-	const equalizer = (first, second) => equalValue(first, second, actual);
-	equalizer.deregister = deregisterEqualizer;
-	equalizer.register = registerEqualizer;
-	return equalizer;
-}
-/**
-* Register a equality comparison function for a specific class
-*
-* _Available as `registerEqualizer` and `equal.register`_
-*
-* @param constructor Class constructor
-* @param handler Comparison function
-*/
-function registerEqualizer(constructor, handler) {
-	equal.handlers.register(constructor, handler);
+	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
+		}));
+	});
 }
-const EQUAL_ARRAY_PEEK_PERCENTAGE = 10;
-const EQUAL_ARRAY_THRESHOLD = 100;
-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) {
-	return getNestedValue(data, path, ignoreCase === true).value;
+promises.result = resultPromises;
+async function resultPromises(items, signal) {
+	return promises(items, signal).then(getResultsFromPromises);
 }
 //#endregion
-//#region src/internal/value/set.ts
-function setValue(data, path, value, ignoreCase) {
-	if (typeof data !== "object" || data === null || typeof path !== "string" || path.trim().length === 0) return data;
-	const shouldIgnoreCase = ignoreCase === true;
-	const paths = getPaths(path, shouldIgnoreCase);
-	if (typeof paths === "string") {
-		handleValue(data, paths, value, false, shouldIgnoreCase);
-		return data;
+//#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);
 	}
-	const { length } = paths;
-	const lastIndex = length - 1;
-	let target = data;
-	for (let index = 0; index < length; index += 1) {
-		const currentPath = paths[index];
-		if (index === lastIndex) {
-			handleValue(target, currentPath, value, false, shouldIgnoreCase);
-			break;
-		}
-		let next = handleValue(target, currentPath, null, true, shouldIgnoreCase).value;
-		if (typeof next !== "object" || next === null) {
-			const nextPath = paths[index + 1];
-			if (SET_EXPRESSION_INDEX.test(nextPath)) next = Array.from({ length: Number(nextPath) + 1 }, () => void 0);
-			else next = {};
-			target[currentPath] = next;
-		}
-		target = next;
+}
+function attempt(callback, err) {
+	try {
+		return ok(callback());
+	} catch (thrown) {
+		return getError(err ?? thrown, err == null ? void 0 : thrown);
 	}
-	return data;
 }
-const SET_EXPRESSION_INDEX = /^\d+$/;
+attempt.async = asyncAttempt;
+Object.defineProperty(attempt, "async", { value: asyncAttempt });
 //#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(STRING_CASE_CAMEL, value, true, false);
-}
-/**
-* Capitalize the first letter of a string _(and lowercase the rest)_
-*
-* @param value String to capitalize
-* @returns Capitalized string
-*/
-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);
-}
-/**
-* Convert a string to kebab case _(this-is-kebab-case)_
-*
-* @param value String to convert
-* @returns Kebab-cased string
-*/
-function kebabCase(value) {
-	return toCase(STRING_CASE_KEBAB, value, false, false);
-}
-/**
-* Convert a string to lower case
-*
-* @param value String to convert
-* @returns Lower-cased string
-*/
-function lowerCase(value) {
-	if (typeof value !== "string") return "";
-	memoizedLowerCase ??= memoize((v) => v.toLocaleLowerCase());
-	return memoizedLowerCase.run(value);
-}
-/**
-* Convert a string to pascal case _(ThisIsPascalCase)_
-*
-* @param value String to convert
-* @returns Pascal-cased string
-*/
-function pascalCase(value) {
-	return toCase(STRING_CASE_PASCAL, value, true, true);
-}
-/**
-* Convert a string to snake case _(this_is_snake_case)_
-*
-* @param value String to convert
-* @returns Snake-cased string
-*/
-function snakeCase(value) {
-	return toCase(STRING_CASE_SNAKE, value, false, false);
-}
-/**
-* 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);
+//#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);
 }
-function toCase(type, value, capitalizeAny, capitalizeFirst) {
-	caseMemoizers[type] ??= memoize(toCaseCallback.bind({
-		type,
-		capitalizeAny,
-		capitalizeFirst
-	}));
-	return caseMemoizers[type].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 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]);
+const MATCH_MESSAGE = "`result.match` expected a Result or a function that returns a Result";
+matchResult.async = asyncMatchResult;
+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;
+		}));
+	});
 }
-/**
-* 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);
+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;
+		}));
+	});
 }
-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;
+attemptFlow.async = attemptAsyncFlow;
+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]);
+	});
+}
+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;
+Object.defineProperty(attemptPipe, "async", { value: attemptAsyncPipe });
 //#endregion
 //#region src/string/match.ts
 /**
@@ -3856,6 +3959,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
@@ -3987,26 +4226,132 @@ function subscribeToObservable(state, first, second, third) {
 		isActive: () => state.beacon.active && state.active,
 		value: observer
 	});
-	observer.next?.(state.beacon.value);
+	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);
+}
+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;
 }
-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 };
+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 = {
@@ -5333,332 +5678,86 @@ const methods = [
 * _(Logging can be enabled or disabled by setting the `enabled` property)_
 */
 const Logger = (() => {
-	const instance = {};
-	Object.defineProperties(instance, {
-		[LOGGER_PROPERTY]: { value: LOGGER_NAME },
-		enabled: {
-			enumerable: true,
-			get: () => enabled,
-			set: (value) => {
-				enabled = typeof value === "boolean" ? value : enabled;
-			}
-		},
-		time: { value: (label) => timedLogger(getString(label)) }
-	});
-	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/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/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
-/**
-* 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);
-		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;
-}
-/**
-* 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 { 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 instance = {};
+	Object.defineProperties(instance, {
+		[LOGGER_PROPERTY]: { value: LOGGER_NAME },
+		enabled: {
+			enumerable: true,
+			get: () => enabled,
+			set: (value) => {
+				enabled = typeof value === "boolean" ? value : enabled;
+			}
+		},
+		time: { value: (label) => timedLogger(getString(label)) }
 	});
-	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();
+	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) {
-	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;
-	});
+//#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);
-	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);
-		}
+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;
-	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;
-	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
-		}));
-	});
+/**
+* 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);
 }
-promises.result = resultPromises;
-async function resultPromises(items, signal) {
-	return promises(items, signal).then(getResultsFromPromises);
+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/query.ts
@@ -5847,9 +5946,6 @@ function createQueue(callback, options, key) {
 	});
 	return Object.freeze(instance);
 }
-function getBooleanOrDefault(value, defaultValue) {
-	return typeof value === "boolean" ? value : defaultValue;
-}
 function getOptions(input) {
 	const options = typeof input === "object" && input != null ? input : {};
 	return {
@@ -6125,92 +6221,6 @@ const RANDOM_BOOLEAN_MODIFIER = .5;
 const RANDOM_HEX_CHARACTERS = "0123456789ABCDEF";
 const RANDOM_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);
-	}
-}
-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);
-}
-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);
-}
-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 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;
-		}));
-	});
-}
-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]);
-	});
-}
-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/sized/set.ts
 /**
 * A _Set_ with a maximum size
@@ -6267,4 +6277,4 @@ var SizedSet = class extends Set {
 	}
 };
 //#endregion
-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, 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, 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 };
+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 };