@oscarpalmer/atoms 0.193.1 → 0.194.0

package/dist/index.mjs

@@ -55,7 +55,7 @@ function findValues(type, array, parameters, mapper) {
 	const { length } = array;
 	const { bool, key, value } = getFindParameters(parameters);
 	const callbacks = getArrayCallbacks(bool, key);
-	if (type === "unique" && callbacks?.keyed == null && length >= UNIQUE_THRESHOLD) {
+	if (type === "unique" && callbacks?.keyed == null && length >= FIND_UNIQUE_THRESHOLD) {
 		result.matched = [...new Set(array)];
 		return result;
 	}
@@ -91,7 +91,7 @@ function getFindParameters(original) {
 const FIND_VALUE_INDEX = "index";
 const FIND_VALUE_ITEM = "item";
 const FIND_VALUES_UNIQUE = "unique";
-const UNIQUE_THRESHOLD = 100;
+const FIND_UNIQUE_THRESHOLD = 100;
 //#endregion
 //#region src/array/filter.ts
 function exclude(array, ...parameters) {
@@ -156,7 +156,7 @@ function chunk(array, size) {
 	if (!Array.isArray(array)) return [];
 	if (array.length === 0) return [];
 	const { length } = array;
-	const actualSize = typeof size === "number" && size > 0 && size <= MAX_SIZE ? size : MAX_SIZE;
+	const actualSize = typeof size === "number" && size > 0 && size <= CHUNK_MAX_SIZE ? size : CHUNK_MAX_SIZE;
 	if (length <= actualSize) return [array];
 	const chunks = [];
 	let index = 0;
@@ -166,7 +166,7 @@ function chunk(array, size) {
 	}
 	return chunks;
 }
-const MAX_SIZE = 5e3;
+const CHUNK_MAX_SIZE = 5e3;
 //#endregion
 //#region src/internal/array/compact.ts
 function compact(array, strict) {
@@ -416,9 +416,9 @@ function shuffle(array) {
 //#region src/internal/array/sets.ts
 function compareSets(type, first, second, key) {
 	if (!Array.isArray(first)) return [];
-	const isDifference = type === COMPARE_SETS_DIFFERENCE;
-	const isIntersection = type === COMPARE_SETS_INTERSECTION;
-	const isUnion = type === COMPARE_SETS_UNION;
+	const isDifference = type === SETS_COMPARE_DIFFERENCE;
+	const isIntersection = type === SETS_COMPARE_INTERSECTION;
+	const isUnion = type === SETS_COMPARE_UNION;
 	if (first.length === 0) return isDifference ? first.slice() : isIntersection ? [] : second.slice();
 	if (!Array.isArray(second) || second.length === 0) return isIntersection ? [] : first.slice();
 	const callback = getArrayCallback(key);
@@ -439,13 +439,13 @@ function compareSets(type, first, second, key) {
 	}
 	return result;
 }
-const COMPARE_SETS_DIFFERENCE = "difference";
-const COMPARE_SETS_INTERSECTION = "intersection";
-const COMPARE_SETS_UNION = "union";
+const SETS_COMPARE_DIFFERENCE = "difference";
+const SETS_COMPARE_INTERSECTION = "intersection";
+const SETS_COMPARE_UNION = "union";
 //#endregion
 //#region src/array/difference.ts
 function difference(first, second, key) {
-	return compareSets(COMPARE_SETS_DIFFERENCE, first, second, key);
+	return compareSets(SETS_COMPARE_DIFFERENCE, first, second, key);
 }
 //#endregion
 //#region src/array/exists.ts
@@ -549,7 +549,7 @@ function insert(array, indexOrItems, items) {
 //#endregion
 //#region src/array/intersection.ts
 function intersection(first, second, key) {
-	return compareSets(COMPARE_SETS_INTERSECTION, first, second, key);
+	return compareSets(SETS_COMPARE_INTERSECTION, first, second, key);
 }
 //#endregion
 //#region src/array/partition.ts
@@ -566,8 +566,8 @@ function getArrayComparison(haystack, needle, key) {
 	return getPosition(haystack, needle, key)[1];
 }
 function getName(start, haystack, needle) {
-	if (start === 0) return haystack === needle ? COMPARISON_SAME : COMPARISON_START;
-	return start + needle === haystack ? COMPARISON_END : COMPARISON_INSIDE;
+	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;
@@ -602,17 +602,17 @@ function indexOfArray(haystack, needle, key) {
 function startsWithArray(haystack, needle, key) {
 	return starts.has(getPosition(haystack, needle, key)[1]);
 }
-const COMPARISON_END = "end";
-const COMPARISON_INSIDE = "inside";
-const COMPARISON_INVALID = "invalid";
-const COMPARISON_OUTSIDE = "outside";
-const COMPARISON_SAME = "same";
-const COMPARISON_START = "start";
-const endings = /* @__PURE__ */ new Set([COMPARISON_END, COMPARISON_SAME]);
-const invalid = [-1, COMPARISON_INVALID];
-const outside = [-1, COMPARISON_OUTSIDE];
-const outsides = /* @__PURE__ */ new Set([COMPARISON_INVALID, COMPARISON_OUTSIDE]);
-const starts = /* @__PURE__ */ new Set([COMPARISON_START, COMPARISON_SAME]);
+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
 /**
@@ -669,13 +669,13 @@ const SINGLE_MESSAGE = "Multiple items were found";
 //#endregion
 //#region src/array/slice.ts
 function drop(array, first, second) {
-	return extract(EXTRACT_DROP, array, first, second);
+	return extract(SLICE_DROP, array, first, second);
 }
 function extract(type, array, first, second) {
 	if (!Array.isArray(array)) return [];
 	const { length } = array;
 	if (length === 0) return [];
-	const isTake = type === EXTRACT_TAKE;
+	const isTake = type === SLICE_TAKE;
 	if (typeof first === "number") {
 		if (Math.abs(first) >= length) return isTake ? array.slice() : [];
 		if (first === 0) return isTake ? [] : array.slice();
@@ -713,10 +713,10 @@ function slice(array, first, second) {
 	return first >= 0 ? array.slice(first, second) : array.slice(array.length + first, array.length + second);
 }
 function take(array, first, second) {
-	return extract(EXTRACT_TAKE, array, first, second);
+	return extract(SLICE_TAKE, array, first, second);
 }
-const EXTRACT_DROP = "drop";
-const EXTRACT_TAKE = "take";
+const SLICE_DROP = "drop";
+const SLICE_TAKE = "take";
 //#endregion
 //#region src/array/splice.ts
 function splice(array, start, deleteCountOrItems, items) {
@@ -764,7 +764,7 @@ function toggle(array, values, key) {
 //#endregion
 //#region src/array/union.ts
 function union(first, second, key) {
-	return compareSets(COMPARE_SETS_UNION, first, second, key);
+	return compareSets(SETS_COMPARE_UNION, first, second, key);
 }
 //#endregion
 //#region src/array/unique.ts
@@ -954,7 +954,7 @@ function getString(value) {
 	return asString.startsWith("[object ") ? JSON.stringify(value) : asString;
 }
 function ignoreKey(key) {
-	return EXPRESSION_IGNORED.test(key);
+	return STRING_EXPRESSION_IGNORED.test(key);
 }
 function interpolate(strings, values) {
 	const { length } = strings;
@@ -1005,10 +1005,10 @@ function tryEncode(value) {
 * @returns Array of words found in the string
 */
 function words(value) {
-	return typeof value === "string" ? value.match(EXPRESSION_WORDS) ?? [] : [];
+	return typeof value === "string" ? value.match(STRING_EXPRESSION_WORDS) ?? [] : [];
 }
-const EXPRESSION_IGNORED = /(^|\.)(__proto__|constructor|prototype)(\.|$)/i;
-const EXPRESSION_WORDS = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
+const STRING_EXPRESSION_IGNORED = /(^|\.)(__proto__|constructor|prototype)(\.|$)/i;
+const STRING_EXPRESSION_WORDS = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
 //#endregion
 //#region src/internal/value/handlers.ts
 function getCompareHandlers(owner, options) {
@@ -1236,8 +1236,10 @@ function getValueSorter(value, modifier) {
 function initializeSorter(first, second) {
 	const sorters = getSorters(first, getModifier(first, second));
 	const sorter = (array) => sortArray(array, sorters);
-	sorter.index = (array, item) => getIndex(array, item, sorters);
-	sorter.is = (array) => isSortedArray(array, sorters);
+	Object.defineProperties(sorter, {
+		index: { value: (array, item) => getIndex(array, item, sorters) },
+		is: { value: (array) => isSortedArray(array, sorters) }
+	});
 	return sorter;
 }
 function isSorted(array, first, second) {
@@ -1397,10 +1399,10 @@ function isResult(value) {
 }
 function isResultValue(value, okValue) {
 	if (isNonPlainObject(value)) return false;
-	return value.ok === okValue && (okValue ? PROPERTY_VALUE : PROPERTY_ERROR) in value;
+	return value.ok === okValue && (okValue ? RESULT_PROPERTY_VALUE : RESULT_PROPERTY_ERROR) in value;
 }
-const PROPERTY_ERROR = "error";
-const PROPERTY_VALUE = "value";
+const RESULT_PROPERTY_ERROR = "error";
+const RESULT_PROPERTY_VALUE = "value";
 //#endregion
 //#region src/result/misc.ts
 function error(value, original) {
@@ -1436,13 +1438,13 @@ function ok(value) {
 */
 async function toPromise(result) {
 	const actual = typeof result === "function" ? result() : result;
-	if (!isResult(actual)) return Promise.reject(new Error(MESSAGE_PROMISE_RESULT));
+	if (!isResult(actual)) return Promise.reject(new Error(RESULT_MESSAGE_PROMISE));
 	return isOk(actual) ? Promise.resolve(actual.value) : Promise.reject(actual.error);
 }
 function unwrap(value, defaultValue) {
 	return isOk(value) ? value.value : defaultValue;
 }
-const MESSAGE_PROMISE_RESULT = "toPromise expected to receive a Result";
+const RESULT_MESSAGE_PROMISE = "toPromise expected to receive a Result";
 //#endregion
 //#region src/internal/value/misc.ts
 function findKey(needle, haystack) {
@@ -1451,8 +1453,8 @@ function findKey(needle, haystack) {
 	return index > -1 ? keys[index] : needle;
 }
 function getNestedValue(data, path, ignoreCase) {
-	if (typeof data !== "object" || data === null) return error(NESTED_MESSAGE_INPUT);
-	if (typeof path !== "string" || path.trim().length === 0) return error(NESTED_MESSAGE_PATH);
+	if (typeof data !== "object" || data === null) return error(MISC_NESTED_MESSAGE_INPUT);
+	if (typeof path !== "string" || path.trim().length === 0) return error(MISC_NESTED_MESSAGE_PATH);
 	const shouldIgnoreCase = ignoreCase === true;
 	const paths = getPaths(path, shouldIgnoreCase);
 	if (typeof paths === "string") return handleValue(data, paths, null, true, shouldIgnoreCase);
@@ -1468,25 +1470,25 @@ function getNestedValue(data, path, ignoreCase) {
 }
 function getPaths(path, lowercase) {
 	const normalized = lowercase ? path.toLowerCase() : path;
-	if (!EXPRESSION_NESTED.test(normalized)) return normalized;
-	return normalized.replace(EXPRESSION_BRACKET, ".$1").replace(EXPRESSION_DOTS, "").split(".");
+	if (!MISC_EXPRESSION_NESTED.test(normalized)) return normalized;
+	return normalized.replace(MISC_EXPRESSION_BRACKET, ".$1").replace(MISC_EXPRESSION_DOTS, "").split(".");
 }
 function handleValue(data, path, value, get, ignoreCase) {
 	if (typeof data === "object" && data !== null) {
-		if (ignoreKey(path)) return error(NESTED_MESSAGE_UNSAFE);
+		if (ignoreKey(path)) return error(MISC_NESTED_MESSAGE_UNSAFE);
 		const key = ignoreCase ? findKey(path, data) : path;
-		if (get) return key in data ? ok(data[key]) : error(NESTED_MESSAGE_MISSING);
+		if (get) return key in data ? ok(data[key]) : error(MISC_NESTED_MESSAGE_MISSING);
 		data[key] = typeof value === "function" ? value(data[key]) : value;
 	}
-	if (get) return error(NESTED_MESSAGE_MISSING);
+	if (get) return error(MISC_NESTED_MESSAGE_MISSING);
 }
-const EXPRESSION_BRACKET = /\[(\w+)\]/g;
-const EXPRESSION_DOTS = /^\.|\.$/g;
-const EXPRESSION_NESTED = /\.|\[\w+\]/;
-const NESTED_MESSAGE_INPUT = "Expected data to be an object";
-const NESTED_MESSAGE_MISSING = "Expected property to exist in object";
-const NESTED_MESSAGE_PATH = "Expected path to be a string";
-const NESTED_MESSAGE_UNSAFE = "Access to this property is not allowed";
+const MISC_EXPRESSION_BRACKET = /\[(\w+)\]/g;
+const MISC_EXPRESSION_DOTS = /^\.|\.$/g;
+const MISC_EXPRESSION_NESTED = /\.|\[\w+\]/;
+const MISC_NESTED_MESSAGE_INPUT = "Expected data to be an object";
+const MISC_NESTED_MESSAGE_MISSING = "Expected property to exist in object";
+const MISC_NESTED_MESSAGE_PATH = "Expected path to be a string";
+const MISC_NESTED_MESSAGE_UNSAFE = "Access to this property is not allowed";
 //#endregion
 //#region src/internal/value/has.ts
 function hasValue(data, path, ignoreCase) {
@@ -1538,7 +1540,7 @@ function assertCondition(condition, message, error) {
 * @param error Error constructor _(defaults to `Error`)_
 */
 function assertDefined(value, message, error) {
-	assert(() => value != null, message ?? MESSAGE_VALUE_DEFINED, error);
+	assert(() => value != null, message ?? ASSERT_MESSAGE_VALUE_DEFINED, error);
 }
 /**
 * Creates an _Asserter_ that asserts a value is an instance of a constructor, throwing an error if it is not
@@ -1589,7 +1591,7 @@ function assertProperty(path, condition, message, error) {
 		}, message, error);
 	};
 }
-const MESSAGE_VALUE_DEFINED = "Expected value to be defined";
+const ASSERT_MESSAGE_VALUE_DEFINED = "Expected value to be defined";
 //#endregion
 //#region src/internal/function/misc.ts
 /**
@@ -1657,28 +1659,28 @@ function getNumber(value) {
 	if (typeof parsed !== "string") return getNumber(parsed);
 	const trimmed = parsed.trim();
 	if (trimmed.length === 0) return NaN;
-	if (EXPRESSION_ZEROISH.test(parsed)) return 0;
-	const isBinary = EXPRESSION_BINARY.test(trimmed);
-	if (isBinary || EXPRESSION_OCTAL.test(trimmed)) return Number.parseInt(trimmed.slice(2), isBinary ? 2 : OCTAL_VALUE);
+	if (NUMBER_EXPRESSION_ZEROISH.test(parsed)) return 0;
+	const isBinary = NUMBER_EXPRESSION_BINARY.test(trimmed);
+	if (isBinary || NUMBER_EXPRESSION_OCTAL.test(trimmed)) return Number.parseInt(trimmed.slice(2), isBinary ? 2 : NUMBER_OCTAL_VALUE);
 	return Number(trimmed);
 }
 function getNumberOrDefault(value, defaultValue, minimum) {
 	return typeof value === "number" && !Number.isNaN(value) && value >= (minimum ?? 0) ? Math.floor(value) : defaultValue;
 }
-const EXPRESSION_BINARY = /^0b[01]+$/i;
-const EXPRESSION_OCTAL = /^0o[0-7]+$/i;
-const EXPRESSION_ZEROISH = /^\s*0+\s*$/;
-const OCTAL_VALUE = 8;
+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
 function getSizedMaximum(first, second) {
 	let actual;
 	if (typeof first === "number") actual = first;
-	else actual = typeof second === "number" ? second : MAXIMUM_DEFAULT;
-	return clamp(actual, 1, MAXIMUM_ABSOLUTE);
+	else actual = typeof second === "number" ? second : SIZED_MAXIMUM_DEFAULT;
+	return clamp(actual, 1, SIZED_MAXIMUM_ABSOLUTE);
 }
-const MAXIMUM_ABSOLUTE = 16777216;
-const MAXIMUM_DEFAULT = 1048576;
+const SIZED_MAXIMUM_ABSOLUTE = 16777216;
+const SIZED_MAXIMUM_DEFAULT = 1048576;
 //#endregion
 //#region src/sized/map.ts
 /**
@@ -1739,7 +1741,7 @@ function getMemoizationOptions(input) {
 	const { cacheKey, cacheSize } = isPlainObject(input) ? input : {};
 	return {
 		cacheKey: typeof cacheKey === "function" ? cacheKey : void 0,
-		cacheSize: typeof cacheSize === "number" && cacheSize > 0 ? cacheSize : DEFAULT_CACHE_SIZE
+		cacheSize: typeof cacheSize === "number" && cacheSize > 0 ? cacheSize : MEMOIZED_CACHE_SIZE_DEFAULT
 	};
 }
 /**
@@ -1750,62 +1752,56 @@ function getMemoizationOptions(input) {
 * @returns _Memoized_ instance
 */
 function memoize(callback, options) {
-	if (typeof callback !== "function") throw new TypeError(MEMOIZED_ERROR_CALLBACK);
-	const state = { options: getMemoizationOptions(options) };
+	if (typeof callback !== "function") throw new TypeError(MEMOIZED_CALLBACK);
+	const state = {
+		cache: void 0,
+		getter: void 0,
+		options: getMemoizationOptions(options)
+	};
 	state.cache = new SizedMap(state.options.cacheSize);
 	state.getter = (...parameters) => {
-		const key = state.options.cacheKey?.(...parameters) ?? (parameters.length === 1 ? parameters[0] : join(parameters.map(getString), SEPARATOR));
+		const key = state.options.cacheKey?.(...parameters) ?? (parameters.length === 1 ? parameters[0] : join(parameters.map(getString), MEMOIZED_KEY_SEPARATOR));
 		if (state.cache.has(key)) return state.cache.get(key);
 		const value = callback(...parameters);
-		state.cache?.set(key, value);
+		state.cache.set(key, value);
 		return value;
 	};
 	const instance = {
-		clear: () => {
-			state.cache?.clear();
-		},
-		delete: (key) => {
-			return state.cache?.delete(key) ?? false;
-		},
-		destroy: () => {
-			state.cache?.clear();
-			state.cache = void 0;
-			state.getter = void 0;
-		},
-		get: (key) => {
-			return state.cache?.get(key);
-		},
-		has: (key) => {
-			return state.cache?.has(key) ?? false;
-		},
-		run: (...parameters) => {
-			if (state.cache == null || state.getter == null) throw new Error(MEMOIZED_ERROR_DESTROYED);
-			return state.getter(...parameters);
-		}
+		clear: () => state.cache.clear(),
+		delete: (key) => state.cache.delete(key),
+		get: (key) => state.cache.get(key),
+		has: (key) => state.cache.has(key),
+		run: (...parameters) => state.getter(...parameters)
 	};
 	Object.defineProperties(instance, {
 		maximum: {
 			enumerable: true,
-			get: () => state.cache?.maximum ?? NaN
+			get: () => state.cache.maximum
 		},
 		size: {
 			enumerable: true,
-			get: () => state.cache?.size ?? NaN
+			get: () => state.cache.size
 		}
 	});
 	return Object.freeze(instance);
 }
-const DEFAULT_CACHE_SIZE = 1024;
-const MEMOIZED_ERROR_CALLBACK = "Memoized requires a callback function";
-const MEMOIZED_ERROR_DESTROYED = "The Memoized instance has been destroyed";
-const SEPARATOR = "_";
+const MEMOIZED_CACHE_SIZE_DEFAULT = 1024;
+const MEMOIZED_CALLBACK = "Memoized requires a callback function";
+const MEMOIZED_KEY_SEPARATOR = "_";
 //#endregion
 //#region src/internal/function/timer.ts
 function getAsyncTimer(type, callback, time) {
+	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 - OFFSET) {
+		if (interval === 0 || now - start >= interval - TIMER_OFFSET) {
 			start = throttle ? now : void 0;
 			item.running = true;
 			try {
@@ -1825,7 +1821,7 @@ function getAsyncTimer(type, callback, time) {
 	let last;
 	let start;
 	const timer = (...parameters) => {
-		timer.cancel();
+		cancel();
 		const next = {
 			parameters,
 			running: false
@@ -1836,25 +1832,23 @@ function getAsyncTimer(type, callback, time) {
 		});
 		last = next;
 		if (throttle) run(next);
-		else id = startTimer(() => {
-			run(next);
-		});
+		else id = startTimer(() => run(next));
 		return next.promise;
 	};
-	timer.cancel = () => {
-		clearTimer(id);
-		if (last != null && !last.running) last.reject();
-	};
+	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 - OFFSET) {
+		if (interval === 0 || now - start >= interval - TIMER_OFFSET) {
 			start = throttle ? now : void 0;
 			callback(...args);
 		} else id = startTimer(run);
@@ -1865,18 +1859,17 @@ function getTimer(type, callback, time) {
 	let id;
 	let start;
 	const timer = (...parameters) => {
-		timer.cancel();
+		cancel();
 		args = parameters;
 		if (throttle) run();
 		else id = startTimer(run);
 	};
-	timer.cancel = () => {
-		clearTimer(id);
-	};
+	Object.defineProperty(timer, TIMER_CANCEL, { value: () => cancel() });
 	return timer;
 }
-const OFFSET = 5;
+const TIMER_CANCEL = "cancel";
 const TIMER_DEBOUNCE = "debounce";
+const TIMER_OFFSET = 5;
 const TIMER_THROTTLE = "throttle";
 const TIMER_WAIT = "wait";
 // istanbul ignore next
@@ -1927,7 +1920,6 @@ function asyncThrottle(callback, time) {
 function debounce(callback, time) {
 	return getTimer(TIMER_DEBOUNCE, callback, time);
 }
-debounce.async = asyncDebounce;
 /**
 * Throttle a function, ensuring it is only called once every `time` milliseconds
 *
@@ -1938,7 +1930,8 @@ debounce.async = asyncDebounce;
 function throttle(callback, time) {
 	return getTimer(TIMER_THROTTLE, callback, time);
 }
-throttle.async = asyncThrottle;
+Object.defineProperty(debounce, "async", { value: asyncDebounce });
+Object.defineProperty(throttle, "async", { value: asyncThrottle });
 //#endregion
 //#region src/function/once.ts
 /**
@@ -1986,6 +1979,7 @@ function asyncOnce(callback) {
 			enumerable: true,
 			get: () => state.called
 		},
+		clear: { value: () => clearState(state) },
 		cleared: {
 			enumerable: true,
 			get: () => state.cleared
@@ -1999,13 +1993,13 @@ function asyncOnce(callback) {
 			get: () => state.finished
 		}
 	});
-	fn.clear = () => {
-		if (!state.called || !state.finished || state.cleared) return;
-		state.cleared = true;
-		state.value = void 0;
-	};
 	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;
@@ -2039,19 +2033,21 @@ function once(callback) {
 		return state.value;
 	};
 	Object.defineProperties(fn, {
-		called: { get: () => state.called },
-		cleared: { get: () => state.cleared }
+		called: {
+			enumerable: true,
+			get: () => state.called
+		},
+		clear: { value: () => clearState(state) },
+		cleared: {
+			enumerable: true,
+			get: () => state.cleared
+		}
 	});
-	fn.clear = () => {
-		if (!state.called || state.cleared) return;
-		state.cleared = true;
-		state.value = void 0;
-	};
 	return fn;
 }
-once.async = asyncOnce;
 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
 /**
@@ -2131,13 +2127,13 @@ function retry(callback, options) {
 	}
 	throw new RetryError(RETRY_MESSAGE_FAILED, last);
 }
-retry.async = asyncRetry;
 function shouldRetry() {
 	return true;
 }
 const RETRY_ERROR_NAME = "RetryError";
 const RETRY_MESSAGE_EXPECTATION = "Retry expected a function";
 const RETRY_MESSAGE_FAILED = "Retry failed";
+Object.defineProperty(retry, "async", { value: asyncRetry });
 //#endregion
 //#region src/function/work.ts
 function asyncFlow(...fns) {
@@ -2154,7 +2150,6 @@ function flow(...fns) {
 		return isOk(value) ? value.value : value;
 	}), fns, true);
 }
-flow.async = asyncFlow;
 async function asyncPipe(value, ...pipes) {
 	assertPipeFunctions(pipes);
 	return asyncWork(value, pipes, false);
@@ -2163,7 +2158,6 @@ function pipe(value, ...pipes) {
 	assertPipeFunctions(pipes);
 	return work(value, pipes, false);
 }
-pipe.async = asyncPipe;
 async function asyncWork(initial, functions, flow) {
 	const { length } = functions;
 	let transformed = unwrapValue(initial);
@@ -2175,10 +2169,10 @@ async function asyncWork(initial, functions, flow) {
 }
 function unwrapValue(value, flow, nested) {
 	if (typeof value === "function") {
-		if (nested != null) throw new TypeError(MESSAGE_NESTING);
+		if (nested != null) throw new TypeError(WORK_MESSAGE_NESTING);
 		return unwrapValue(value(), flow, true);
 	}
-	if (flow != null && value instanceof Promise) throw new TypeError(flow ? MESSAGE_FLOW_PROMISE : MESSAGE_PIPE_PROMISE);
+	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;
 }
@@ -2191,114 +2185,42 @@ function work(initial, functions, flow) {
 	}
 	return transformed;
 }
-const MESSAGE_FLOW_ARRAY = "Flow expected to receive an array of functions";
-const MESSAGE_FLOW_PROMISE = "Synchronous Flow received a promise. Use `flow.async` instead.";
-const MESSAGE_NESTING = "Return values are too deeply nested.";
-const MESSAGE_PIPE_ARRAY = "Pipe expected to receive an array of functions";
-const MESSAGE_PIPE_PROMISE = "Synchronous Pipe received a promise. Use `pipe.async` instead.";
-const assertFlowFunctions = assert.condition((value) => Array.isArray(value) && value.every((item) => typeof item === "function"), MESSAGE_FLOW_ARRAY, TypeError);
-const assertPipeFunctions = assert.condition((value) => Array.isArray(value) && value.every((item) => typeof item === "function"), MESSAGE_PIPE_ARRAY, TypeError);
+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/herald.ts
-function getEvents(herald) {
-	const events = {
-		subscribe: (event, callback) => herald.subscribe(event, callback),
-		unsubscribe: (event, callback) => herald.unsubscribe(event, callback)
-	};
-	Object.defineProperty(events, KEY_HERALD, {
-		enumerable: false,
-		value: NAME_EVENTS
-	});
-	return Object.freeze(events);
-}
-/**
-* Create a _Herald_ for announcing named events
-*
-* @param names Event names
-* @returns _Herald_ instance
-*/
-function herald(names) {
-	if (!Array.isArray(names) || names.length === 0 || !names.every((name) => typeof name === "string")) throw new Error(MESSAGE);
-	const set = new Set(names);
-	const subscribers = /* @__PURE__ */ new Map();
-	const instance = {
-		clear() {
-			subscribers.clear();
-		},
-		emit(event, ...parameters) {
-			const callbacks = subscribers.get(event);
-			if (callbacks == null) return;
-			for (const callback of callbacks) callback(...parameters);
-		},
-		subscribe(event, callback) {
-			if (!set.has(event) || typeof callback !== "function") return noop;
-			let eventSubscribers = subscribers.get(event);
-			if (eventSubscribers == null) {
-				eventSubscribers = /* @__PURE__ */ new Set();
-				subscribers.set(event, eventSubscribers);
-			}
-			eventSubscribers.add(callback);
-			return () => {
-				eventSubscribers?.delete(callback);
-			};
-		},
-		unsubscribe(event, callback) {
-			if (!set.has(event) || (callback != null ? typeof callback !== "function" : false)) return;
-			const eventSubscribers = subscribers.get(event);
-			if (eventSubscribers == null) return;
-			if (callback == null) eventSubscribers.clear();
-			else eventSubscribers.delete(callback);
-			if (callback == null || eventSubscribers.size === 0) subscribers.delete(event);
-		}
+//#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)
 	};
-	Object.defineProperties(instance, {
-		[KEY_HERALD]: {
-			enumerable: false,
-			value: NAME_HERALD
-		},
-		events: {
-			enumerable: true,
-			value: getEvents(instance)
-		}
-	});
-	return Object.freeze(instance);
-}
-/**
-* 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 isEvents(value) {
-	return isHeraldInstance(NAME_EVENTS, value);
 }
-/**
-* 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(NAME_HERALD, value);
-}
-function isHeraldInstance(name, value) {
-	return typeof value === "object" && value != null && KEY_HERALD in value && value[KEY_HERALD] === name;
-}
-const KEY_HERALD = "$herald";
-const MESSAGE = "Herald requires an array of event names.";
-const NAME_EVENTS = "events";
-const NAME_HERALD = "herald";
+const ABORT_EVENT = "abort";
+const ABORT_OPTIONS = { once: true };
 //#endregion
 //#region src/internal/subscription.ts
-function addSubscription(subscription, state) {
-	const { key, subscriptions, value } = state.parameters;
-	const { items, values } = subscriptions;
-	if (key == null) {
+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;
@@ -2325,41 +2247,31 @@ function clearSubscriptions(store) {
 	for (const susbcription of store.values.to.any.keys()) susbcription.unsubscribe();
 	if (store.values.to.keyed != null) for (const values of store.values.to.keyed.values()) for (const susbcription of values.keys()) susbcription.unsubscribe();
 }
-function getExistingSubscription(state) {
-	const { parameters } = state;
-	const { values } = parameters.subscriptions;
-	return parameters.key == null ? values.from.any.get(parameters.value) : values.from.keyed?.get(parameters.key)?.get(parameters.value);
-}
-function getSubscription(parameters) {
+function createSubscription(subscriptions, property, parameters) {
+	if (parameters.signal?.aborted ?? false) throw new Error(parameters.signal?.reason);
 	const state = {
 		parameters,
 		active: true
 	};
-	const existing = getExistingSubscription(state);
-	if (existing != null) return existing;
-	if (parameters.subscriptions.keys != null && parameters.key != null && !parameters.subscriptions.keys.has(parameters.key)) throw new Error();
-	const instance = { unsubscribe: () => {
-		removeSubscription(instance, state);
-	} };
+	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, {
-		[PROPERTY]: {
-			enumerable: false,
-			value: true
-		},
-		[parameters.property.key]: {
-			enumerable: false,
-			value: parameters.property.value
-		},
+		[SUBSCRIPTION_PROPERTY]: { value: true },
+		[property.key]: { value: property.value ?? "subscription" },
 		active: {
 			enumerable: true,
 			get: () => (parameters.isActive?.() ?? true) && state.active
 		}
 	});
-	addSubscription(instance, state);
-	return Object.freeze(instance);
+	addSubscription(subscriptions, instance, state);
+	return [Object.freeze(instance), false];
 }
-function getSubscriptions(keys) {
-	return {
+function createSubscriptions(parameters) {
+	const { keys, property } = parameters;
+	const state = {
 		keys,
 		items: {
 			any: /* @__PURE__ */ new Set(),
@@ -2376,6 +2288,17 @@ function getSubscriptions(keys) {
 			}
 		}
 	};
+	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?
@@ -2384,7 +2307,7 @@ function getSubscriptions(keys) {
 * @returns `true` if the value is a subscription, otherwise `false`
 */
 function isSubscription(value) {
-	return isPlainObject(value) && PROPERTY in value && value[PROPERTY] === true;
+	return isPlainObject(value) && SUBSCRIPTION_PROPERTY in value && value[SUBSCRIPTION_PROPERTY] === true;
 }
 function removeFromStore(items, values, subscription, value, key) {
 	items.delete(subscription);
@@ -2396,23 +2319,138 @@ function removeFromStore(items, values, subscription, value, key) {
 		values.to.keyed?.get(key)?.delete(subscription);
 	}
 }
-function removeSubscription(subscription, state) {
+function removeSubscription(subscriptions, subscription, state) {
 	if (!state.active) return;
+	state.aborter = void 0;
 	state.active = false;
-	const { key, subscriptions, value } = state.parameters;
-	const { items, values } = subscriptions;
-	if (key == null) {
+	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);
 }
-const PROPERTY = "$subscription";
+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/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 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);
+}
+/**
+* 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);
+}
+function isHeraldInstance(name, value) {
+	return isPlainObject(value) && HERALD_PROPERTY in value && value[HERALD_PROPERTY] === name;
+}
+/**
+* Is the value a herald subscription?
+*
+* @param value Value to check
+* @returns `true` if the value is a herald subscription, otherwise `false`
+*/
+function isHeraldSubscription(value) {
+	return isSubscription(value) && value[HERALD_PROPERTY] === "subscription";
+}
+function subscribeToHerald(state, key, callback, signal) {
+	const [subscription, existing] = state.subscriptions.create({
+		key,
+		signal,
+		value: callback
+	});
+	if (!existing) state.onCreate?.(key, callback, subscription);
+	return subscription;
+}
+const HERALD_PROPERTY = "$herald";
+const HERALD_MESSAGE_ARRAY = "Herald requires an array of event names.";
+const HERALD_MESSAGE_ONCREATE = `Herald requires a valid onCreate callback for subscription creation`;
+const HERALD_MESSAGE_PROPERTY = `Herald requires valid property information for subscription identification`;
+const HERALD_NAME_EVENTS = "events";
+const HERALD_NAME_HERALD = "herald";
+const heraldSubscription = { key: HERALD_PROPERTY };
 //#endregion
 //#region src/internal/value/equal.ts
 /**
@@ -2474,7 +2512,7 @@ function equalPlainObject(first, second, options) {
 		firstKeys = firstKeys.filter((key) => filterKey(key, options));
 		secondKeys = secondKeys.filter((key) => filterKey(key, options));
 	}
-	const secondSet = secondKeys.length >= MINIMUM_LENGTH_FOR_SET ? new Set(secondKeys) : void 0;
+	const 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) {
@@ -2519,9 +2557,9 @@ function equalValue(first, second, options) {
 		case first instanceof ArrayBuffer && second instanceof ArrayBuffer: return equalArrayBuffer(first, second, options);
 		case first instanceof Date && second instanceof Date: return Object.is(first.getTime(), second.getTime());
 		case first instanceof DataView && second instanceof DataView: return equalDataView(first, second, options);
-		case first instanceof Error && second instanceof Error: return equalProperties(first, second, ERROR_PROPERTIES, options);
+		case first instanceof 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, EXPRESSION_PROPERTIES, 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);
@@ -2583,9 +2621,9 @@ function registerEqualizer(constructor, handler) {
 }
 const EQUAL_ARRAY_PEEK_PERCENTAGE = 10;
 const EQUAL_ARRAY_THRESHOLD = 100;
-const ERROR_PROPERTIES = ["name", "message"];
-const EXPRESSION_PROPERTIES = ["source", "flags"];
-const MINIMUM_LENGTH_FOR_SET = 16;
+const EQUAL_ERROR_PROPERTIES = ["name", "message"];
+const EQUAL_EXPRESSION_PROPERTIES = ["source", "flags"];
+const EQUAL_MINIMUM_LENGTH_FOR_SET = 16;
 //#endregion
 //#region src/internal/value/get.ts
 function getValue(data, path, ignoreCase) {
@@ -2613,7 +2651,7 @@ function setValue(data, path, value, ignoreCase) {
 		let next = handleValue(target, currentPath, null, true, shouldIgnoreCase).value;
 		if (typeof next !== "object" || next === null) {
 			const nextPath = paths[index + 1];
-			if (EXPRESSION_INDEX.test(nextPath)) next = Array.from({ length: Number(nextPath) + 1 }, () => void 0);
+			if (SET_EXPRESSION_INDEX.test(nextPath)) next = Array.from({ length: Number(nextPath) + 1 }, () => void 0);
 			else next = {};
 			target[currentPath] = next;
 		}
@@ -2621,7 +2659,7 @@ function setValue(data, path, value, ignoreCase) {
 	}
 	return data;
 }
-const EXPRESSION_INDEX = /^\d+$/;
+const SET_EXPRESSION_INDEX = /^\d+$/;
 //#endregion
 //#region src/string/case.ts
 /**
@@ -2631,7 +2669,7 @@ const EXPRESSION_INDEX = /^\d+$/;
 * @returns Camel-cased string
 */
 function camelCase(value) {
-	return toCase(CASE_CAMEL, value, true, false);
+	return toCase(STRING_CASE_CAMEL, value, true, false);
 }
 /**
 * Capitalize the first letter of a string _(and lowercase the rest)_
@@ -2651,7 +2689,7 @@ function capitalize(value) {
 * @returns Kebab-cased string
 */
 function kebabCase(value) {
-	return toCase(CASE_KEBAB, value, false, false);
+	return toCase(STRING_CASE_KEBAB, value, false, false);
 }
 /**
 * Convert a string to lower case
@@ -2671,7 +2709,7 @@ function lowerCase(value) {
 * @returns Pascal-cased string
 */
 function pascalCase(value) {
-	return toCase(CASE_PASCAL, value, true, true);
+	return toCase(STRING_CASE_PASCAL, value, true, true);
 }
 /**
 * Convert a string to snake case _(this_is_snake_case)_
@@ -2680,7 +2718,7 @@ function pascalCase(value) {
 * @returns Snake-cased string
 */
 function snakeCase(value) {
-	return toCase(CASE_SNAKE, value, false, false);
+	return toCase(STRING_CASE_SNAKE, value, false, false);
 }
 /**
 * Convert a string to title case _(Capitalizing Every Word)_
@@ -2709,7 +2747,7 @@ function toCaseCallback(value) {
 	const partsLength = parts.length;
 	const cased = [];
 	for (let partIndex = 0; partIndex < partsLength; partIndex += 1) {
-		const items = parts[partIndex].replace(EXPRESSION_ACRONYM, (full, one, two, three) => three === S ? full : `${one}-${two}${three}`).replace(EXPRESSION_CAMEL_CASE, REPLACEMENT_CAMEL_CASE).split("-");
+		const 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;
@@ -2735,23 +2773,23 @@ function upperCase(value) {
 	memoizedUpperCase ??= memoize((v) => v.toLocaleUpperCase());
 	return memoizedUpperCase.run(value);
 }
-const CASE_CAMEL = "camel";
-const CASE_KEBAB = "kebab";
-const CASE_PASCAL = "pascal";
-const CASE_SNAKE = "snake";
-const DELIMTER_EMPTY = "";
-const DELIMITER_HYPHEN = "-";
-const DELIMITER_UNDERSCORE = "_";
-const EXPRESSION_CAMEL_CASE = /(\p{Ll})(\p{Lu})/gu;
-const EXPRESSION_ACRONYM = /(\p{Lu}*)(\p{Lu})(\p{Ll}+)/gu;
-const REPLACEMENT_CAMEL_CASE = "$1-$2";
-const S = "s";
+const 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 = {
-	[CASE_CAMEL]: DELIMTER_EMPTY,
-	[CASE_KEBAB]: DELIMITER_HYPHEN,
-	[CASE_PASCAL]: DELIMTER_EMPTY,
-	[CASE_SNAKE]: DELIMITER_UNDERSCORE
+	[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;
@@ -2813,10 +2851,10 @@ function getHandler(input) {
 		case "string": return (item) => item[input];
 		default:
 			if (isPlainObject(input)) return getHandler(input.key ?? input.handler);
-			throw new TypeError(MESSAGE_HANDLER);
+			throw new TypeError(FUZZY_MESSAGE_HANDLER);
 	}
 }
-function getItems$1(items) {
+function getFuzzyItems(items) {
 	return items.sort((first, second) => first.haystack.localeCompare(second.haystack)).map(({ item }) => item);
 }
 function getFuzzyOptions(input, state) {
@@ -2840,22 +2878,22 @@ function getFuzzyState(items, input) {
 }
 function getTolerance(input, state) {
 	if (typeof input === "number" && !Number.isNaN(input)) return input < 0 ? 0 : Math.floor(input);
-	return state?.tolerance ?? PROXIMITY_THRESHOLD;
+	return state?.tolerance ?? FUZZY_PROXIMITY_THRESHOLD;
 }
 function fuzzy(items, configuration) {
-	if (!Array.isArray(items)) throw new TypeError(MESSAGE_ARRAY);
+	if (!Array.isArray(items)) throw new TypeError(FUZZY_MESSAGE_ARRAY);
 	const state = getFuzzyState(items, configuration);
 	const instance = { search: (value, options) => search(state.items, state.strings, value, options == null ? state : getFuzzyOptions(options, state)) };
 	Object.defineProperties(instance, {
 		items: {
+			enumerable: true,
 			get: () => state.items.slice(),
-			set: (items) => {
-				if (!Array.isArray(items)) throw new TypeError(MESSAGE_ARRAY);
-				state.items = items.slice();
-				state.strings = items.map(state.handler);
-			}
+			set: (value) => setItems(state, value)
 		},
-		strings: { get: () => state.strings.slice() }
+		strings: {
+			enumerable: true,
+			get: () => state.strings.slice()
+		}
 	});
 	return Object.freeze(instance);
 }
@@ -2899,14 +2937,14 @@ function getScore(haystack, needle) {
 			if (haystackIndex === 0) score += 1;
 			if (previousMatchIndex !== -1) {
 				const gap = haystackIndex - previousMatchIndex - 1;
-				score += Math.max(0, PROXIMITY_THRESHOLD - gap);
+				score += Math.max(0, FUZZY_PROXIMITY_THRESHOLD - gap);
 			}
 			previousMatchIndex = haystackIndex;
 			needleIndex += 1;
 		}
 		if (needleIndex === needleLength) break;
 	}
-	score -= Math.floor(lowerCaseHaystack.length / LENGTH_DIVISOR);
+	score -= Math.floor(lowerCaseHaystack.length / FUZZY_LENGTH_DIVISOR);
 	return Math.max(0, score);
 }
 function search(items, strings, input, options) {
@@ -2949,18 +2987,23 @@ function search(items, strings, input, options) {
 		for (let index = 0; index < length; index += 1) {
 			const key = keys[index];
 			if (maxScore - key > options.tolerance) break;
-			similar.push(...getItems$1(scored[key]));
+			similar.push(...getFuzzyItems(scored[key]));
 		}
 	}
-	result.exact = getItems$1(options.limit == null ? exact : exact.slice(0, options.limit));
+	result.exact = getFuzzyItems(options.limit == null ? exact : exact.slice(0, options.limit));
 	if (options.limit == null) result.similar = similar;
 	else result.similar = similar.slice(0, options.limit - result.exact.length);
 	return result;
 }
-const LENGTH_DIVISOR = 3;
-const MESSAGE_ARRAY = "Fuzzy requires an array of items";
-const MESSAGE_HANDLER = "Fuzzy requires a key or function to stringify items";
-const PROXIMITY_THRESHOLD = 5;
+function setItems(state, value) {
+	if (!Array.isArray(value)) throw new TypeError(FUZZY_MESSAGE_ARRAY);
+	state.items = value.slice();
+	state.strings = value.map(state.handler);
+}
+const FUZZY_LENGTH_DIVISOR = 3;
+const FUZZY_MESSAGE_ARRAY = "Fuzzy requires an array of items";
+const FUZZY_MESSAGE_HANDLER = "Fuzzy requires a key or function to stringify items";
+const FUZZY_PROXIMITY_THRESHOLD = 5;
 //#endregion
 //#region src/string/index.ts
 function dedent(value, ...values) {
@@ -2999,16 +3042,16 @@ function getUuid(html) {
 		crypto.getRandomValues(bytes);
 		bytes[6] = bytes[6] & 15 | 64;
 		bytes[8] = bytes[8] & 63 | 128;
-		const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, ZERO)).join("");
+		const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, STRING_ZERO)).join("");
 		const first = hex.substring(0, 8);
-		if (forHTML && NUMERICAL_PREFIX_PATTERN.test(first)) continue;
+		if (forHTML && STRING_NUMERICAL_PREFIX_PATTERN.test(first)) continue;
 		return [
 			first,
 			hex.substring(8, 12),
 			hex.substring(12, 16),
 			hex.substring(16, 20),
 			hex.substring(20, 32)
-		].join(forHTML ? DELIMITER_UUID_HTML : DELIMITER_UUID_DEFAULT);
+		].join(forHTML ? STRING_DELIMITER_UUID_HTML : STRING_DELIMITER_UUID_DEFAULT);
 	}
 }
 /**
@@ -3051,10 +3094,10 @@ function truncate(value, length, suffix) {
 	const truncatedLength = length - actualSuffixLength;
 	return `${value.slice(0, truncatedLength)}${actualSuffix}`;
 }
-const DELIMITER_UUID_DEFAULT = "-";
-const DELIMITER_UUID_HTML = "_";
-const NUMERICAL_PREFIX_PATTERN = /^\d/;
-const ZERO = "0";
+const STRING_DELIMITER_UUID_DEFAULT = "-";
+const STRING_DELIMITER_UUID_HTML = "_";
+const STRING_NUMERICAL_PREFIX_PATTERN = /^\d/;
+const STRING_ZERO = "0";
 //#endregion
 //#region src/string/normalize.ts
 /**
@@ -3066,8 +3109,8 @@ const ZERO = "0";
 function deburr(value) {
 	if (typeof value !== "string") return "";
 	deburrMemoizer ??= memoize((value) => {
-		let deburred = value.normalize(DEBURR_NORMALIZATION).replace(DEBURR_PATTERN_SIMPLE, "");
-		deburred = deburred.replace(DEBURR_PATTERN_CHARACTERS, (_, character) => DEBURR_CHARACTERS[character]);
+		let deburred = value.normalize(NORMALIZE_DEBURR_NORMALIZATION).replace(NORMALIZE_DEBURR_PATTERN_SIMPLE, "");
+		deburred = deburred.replace(NORMALIZE_DEBURR_PATTERN_CHARACTERS, (_, character) => NORMALIZE_DEBURR_CHARACTERS[character]);
 		return deburred;
 	});
 	return deburrMemoizer.run(value);
@@ -3111,13 +3154,13 @@ function normalizeString(value, options) {
 	if (typeof value !== "string") return "";
 	let result = value;
 	if (options.trim) result = result.trim();
-	if (options.whitespace) result = result.replace(WHITESPACE_PATTERN, WHITESPACE_REPLACEMENT);
+	if (options.whitespace) result = result.replace(NORMALIZE_WHITESPACE_PATTERN, NORMALIZE_WHITESPACE_REPLACEMENT);
 	if (options.deburr) result = deburr(result);
 	if (options.lowerCase) result = lowerCase(result);
-	if (options.special) result = result.replace(SPECIAL_PATTERN, SPECIAL_REPLACEMENT);
-	return result.normalize(NORMALIZATION_NORMALIZATION);
+	if (options.special) result = result.replace(NORMALIZE_SPECIAL_PATTERN, NORMALIZE_SPECIAL_REPLACEMENT);
+	return result.normalize(NORMALIZE_NORMALIZATION_NORMALIZATION);
 }
-const DEBURR_CHARACTERS = {
+const NORMALIZE_DEBURR_CHARACTERS = {
 	Æ: "AE",
 	æ: "ae",
 	Ð: "D",
@@ -3149,14 +3192,14 @@ const DEBURR_CHARACTERS = {
 	Ŧ: "T",
 	ŧ: "t"
 };
-const DEBURR_NORMALIZATION = "NFD";
-const DEBURR_PATTERN_CHARACTERS = new RegExp(`(${Object.keys(DEBURR_CHARACTERS).join("|")})`, "g");
-const DEBURR_PATTERN_SIMPLE = /[\u0300-\u036f]/g;
-const NORMALIZATION_NORMALIZATION = "NFC";
-const SPECIAL_PATTERN = /[\p{P}\p{S}]/gu;
-const SPECIAL_REPLACEMENT = "";
-const WHITESPACE_PATTERN = /\s+/g;
-const WHITESPACE_REPLACEMENT = " ";
+const NORMALIZE_DEBURR_NORMALIZATION = "NFD";
+const NORMALIZE_DEBURR_PATTERN_CHARACTERS = new RegExp(`(${Object.keys(NORMALIZE_DEBURR_CHARACTERS).join("|")})`, "g");
+const NORMALIZE_DEBURR_PATTERN_SIMPLE = /[\u0300-\u036f]/g;
+const NORMALIZE_NORMALIZATION_NORMALIZATION = "NFC";
+const NORMALIZE_SPECIAL_PATTERN = /[\p{P}\p{S}]/gu;
+const NORMALIZE_SPECIAL_REPLACEMENT = "";
+const NORMALIZE_WHITESPACE_PATTERN = /\s+/g;
+const NORMALIZE_WHITESPACE_REPLACEMENT = " ";
 let deburrMemoizer;
 //#endregion
 //#region src/string/template.ts
@@ -3169,7 +3212,7 @@ function getTemplateOptions(input) {
 	const options = isPlainObject(input) ? input : {};
 	return {
 		ignoreCase: options.ignoreCase === true,
-		pattern: options.pattern instanceof RegExp ? options.pattern : EXPRESSION_VARIABLE
+		pattern: options.pattern instanceof RegExp ? options.pattern : TEMPLATE_EXPRESSION_VARIABLE
 	};
 }
 function handleTemplate(value, pattern, ignoreCase, variables) {
@@ -3204,7 +3247,7 @@ function template(value, ...parameters) {
 	return handleTemplate(value, pattern, ignoreCase, parameters[0]);
 }
 template.initialize = initializeTemplater;
-const EXPRESSION_VARIABLE = /{{([\s\S]+?)}}/g;
+const TEMPLATE_EXPRESSION_VARIABLE = /{{([\s\S]+?)}}/g;
 //#endregion
 //#region src/value/clone.ts
 const CLONE_NAME = "clone";
@@ -3218,21 +3261,21 @@ clone.handlers = getSelfHandlers(clone, {
 clone.deregister = deregisterCloner;
 clone.register = registerCloner;
 function cloneArrayBuffer(value, depth, references) {
-	if (typeof depth === "number" && depth >= MAX_CLONE_DEPTH) return value;
+	if (typeof depth === "number" && depth >= CLONE_MAX_DEPTH) return value;
 	const cloned = new ArrayBuffer(value.byteLength);
 	new Uint8Array(cloned).set(new Uint8Array(value));
 	references?.set(value, cloned);
 	return cloned;
 }
 function cloneDataView(value, depth, references) {
-	if (depth >= MAX_CLONE_DEPTH) return value;
+	if (depth >= CLONE_MAX_DEPTH) return value;
 	const buffer = cloneArrayBuffer(value.buffer);
 	const cloned = new DataView(buffer, value.byteOffset, value.byteLength);
 	references.set(value, cloned);
 	return cloned;
 }
 function cloneMap(map, depth, references, flat) {
-	if (depth >= MAX_CLONE_DEPTH) return map;
+	if (depth >= CLONE_MAX_DEPTH) return map;
 	const cloned = /* @__PURE__ */ new Map();
 	const entries = map.entries();
 	for (const entry of entries) cloned.set(flat ? entry[0] : cloneValue(entry[0], depth + 1, references, false), flat ? entry[1] : cloneValue(entry[1], depth + 1, references, false));
@@ -3240,13 +3283,13 @@ function cloneMap(map, depth, references, flat) {
 	return cloned;
 }
 function cloneNode(node, depth, references) {
-	if (depth >= MAX_CLONE_DEPTH) return node;
+	if (depth >= CLONE_MAX_DEPTH) return node;
 	const cloned = node.cloneNode(true);
 	references.set(node, cloned);
 	return cloned;
 }
 function cloneObject(value, depth, references, flat) {
-	if (flat || depth >= MAX_CLONE_DEPTH) return Array.isArray(value) ? value.slice() : { ...value };
+	if (flat || depth >= CLONE_MAX_DEPTH) return Array.isArray(value) ? value.slice() : { ...value };
 	const cloned = Array.isArray(value) ? [] : {};
 	const keys = [...Object.keys(value), ...Object.getOwnPropertySymbols(value)];
 	const { length } = keys;
@@ -3258,14 +3301,14 @@ function cloneObject(value, depth, references, flat) {
 	return cloned;
 }
 function cloneRegularExpression(value, depth, references) {
-	if (depth >= MAX_CLONE_DEPTH) return value;
+	if (depth >= CLONE_MAX_DEPTH) return value;
 	const cloned = new RegExp(value.source, value.flags);
 	cloned.lastIndex = value.lastIndex;
 	references.set(value, cloned);
 	return cloned;
 }
 function cloneSet(set, depth, references, flat) {
-	if (depth >= MAX_CLONE_DEPTH) return set;
+	if (depth >= CLONE_MAX_DEPTH) return set;
 	const cloned = /* @__PURE__ */ new Set();
 	const values = [...set.values()];
 	const { length } = values;
@@ -3274,7 +3317,7 @@ function cloneSet(set, depth, references, flat) {
 	return cloned;
 }
 function cloneTypedArray(value, depth, references) {
-	if (depth >= MAX_CLONE_DEPTH) return value;
+	if (depth >= CLONE_MAX_DEPTH) return value;
 	const cloned = new value.constructor(value);
 	references.set(value, cloned);
 	return cloned;
@@ -3335,7 +3378,7 @@ function registerCloner(constructor, handler) {
 	clone.handlers.register(constructor, handler);
 }
 function tryStructuredClone(value, depth, references) {
-	if (depth >= MAX_CLONE_DEPTH) return value;
+	if (depth >= CLONE_MAX_DEPTH) return value;
 	try {
 		const cloned = structuredClone(value);
 		references.set(value, cloned);
@@ -3345,7 +3388,7 @@ function tryStructuredClone(value, depth, references) {
 		return value;
 	}
 }
-const MAX_CLONE_DEPTH = 100;
+const CLONE_MAX_DEPTH = 100;
 //#endregion
 //#region src/value/collection.ts
 function inMap(map, value, key) {
@@ -3609,7 +3652,7 @@ function shake(value) {
 //#endregion
 //#region src/value/smush.ts
 function flattenObject(value, depth, smushed, prefix) {
-	if (depth >= MAX_DEPTH) return {};
+	if (depth >= SMUSH_MAX_DEPTH) return {};
 	if (smushed.has(value)) return smushed.get(value);
 	const keys = Object.keys(value);
 	const { length } = keys;
@@ -3641,7 +3684,7 @@ function flattenObject(value, depth, smushed, prefix) {
 function smush(value) {
 	return typeof value === "object" && value !== null ? flattenObject(value, 0, /* @__PURE__ */ new WeakMap()) : {};
 }
-const MAX_DEPTH = 100;
+const SMUSH_MAX_DEPTH = 100;
 //#endregion
 //#region src/value/unsmush.ts
 function getKeys(value) {
@@ -3827,38 +3870,23 @@ function beacon(value, options) {
 		active: true,
 		observable: void 0,
 		options: getBeaconOptions(options),
-		subscriptions: getSubscriptions()
+		subscriptions: createSubscriptions({ property: beaconSubscription })
 	};
 	const instance = {
-		deactivate: () => {
-			finishBeacon(state, false);
-		},
-		emit: (value, finish) => {
-			update$1(TYPE_NEXT, state, value, finish);
-		},
-		error: (value, finish) => {
-			update$1(TYPE_ERROR, state, value, finish);
-		},
-		finish: () => {
-			finishBeacon(state, true);
-		}
+		deactivate: () => finishBeacon(state, false),
+		emit: (value, finish) => updateBeacon(BEACON_TYPE_NEXT, state, value, finish),
+		error: (value, finish) => updateBeacon(BEACON_TYPE_ERROR, state, value, finish),
+		finish: () => finishBeacon(state, true)
 	};
 	Object.defineProperties(instance, {
-		[KEY_BEACON]: {
-			enumerable: false,
-			value: NAME_BEACON
-		},
+		[BEACON_PROPERTY]: { value: BEACON_NAME },
 		active: {
 			enumerable: true,
 			get: () => state.active
 		},
 		observable: {
 			enumerable: true,
-			get: () => {
-				if (!state.active) throw new Error(MESSAGE_BEACON);
-				state.observable ??= observe(state);
-				return state.observable;
-			}
+			get: () => getObservable(state)
 		},
 		value: {
 			enumerable: true,
@@ -3870,8 +3898,8 @@ function beacon(value, options) {
 function finishBeacon(state, emit) {
 	if (!state.active) return;
 	state.active = false;
-	for (const [, observer] of state.subscriptions.values.to.any) if (emit) observer.complete?.();
-	clearSubscriptions(state.subscriptions);
+	for (const [, observer] of state.subscriptions.state.values.to.any) if (emit) observer.complete?.();
+	state.subscriptions.clear();
 	state.observable?.deactivate();
 	state.observable = void 0;
 }
@@ -3880,6 +3908,11 @@ function getBeaconOptions(input) {
 	options.equal = typeof options.equal === "function" ? options.equal : Object.is;
 	return options;
 }
+function getObservable(state) {
+	if (!state.active) throw new Error(BEACON_MESSAGE_RETRIEVE);
+	state.observable ??= observeBeacon(state);
+	return state.observable;
+}
 function getObservableCallback(value) {
 	return typeof value === "function" ? value : noop;
 }
@@ -3904,10 +3937,19 @@ function getObserver(first, second, third) {
 * @returns `true` if the value is a beacon, otherwise `false`
 */
 function isBeacon(value) {
-	return isBeaconInstance(NAME_BEACON, value);
+	return isBeaconInstance(BEACON_NAME, value);
 }
 function isBeaconInstance(name, value) {
-	return isPlainObject(value) && value[KEY_BEACON] === name;
+	return isPlainObject(value) && value[BEACON_PROPERTY] === name;
+}
+/**
+* Is the value a beacon subscription?
+*
+* @param value Value to check
+* @returns `true` if the value is a beacon subscription, otherwise `false`
+*/
+function isBeaconSubscription(value) {
+	return isSubscription(value) && value[BEACON_PROPERTY] === "subscription";
 }
 /**
 * Is the value an observable?
@@ -3916,9 +3958,9 @@ function isBeaconInstance(name, value) {
 * @returns `true` if the value is an observable, otherwise `false`
 */
 function isObservable(value) {
-	return isBeaconInstance(NAME_OBSERVABLE, value);
+	return isBeaconInstance(BEACON_OBSERVABLE, value);
 }
-function observe(beacon) {
+function observeBeacon(beacon) {
 	const state = {
 		beacon,
 		active: beacon.active
@@ -3927,24 +3969,10 @@ function observe(beacon) {
 		deactivate: () => {
 			state.active = false;
 		},
-		subscribe(first, second, third) {
-			if (!beacon.active || !state.active) throw new Error(MESSAGE_OBSERVABLE);
-			const observer = getObserver(first, second, third);
-			const subscription = getSubscription({
-				isActive: () => beacon.active && state.active,
-				property: beaconSubscription,
-				subscriptions: beacon.subscriptions,
-				value: observer
-			});
-			observer.next?.(beacon.value);
-			return subscription;
-		}
+		subscribe: (first, second, third) => subscribeToObservable(state, first, second, third)
 	};
 	Object.defineProperties(instance, {
-		[KEY_BEACON]: {
-			enumerable: false,
-			value: NAME_OBSERVABLE
-		},
+		[BEACON_PROPERTY]: { value: BEACON_OBSERVABLE },
 		active: {
 			enumerable: true,
 			get: () => beacon.active && state.active
@@ -3952,26 +3980,33 @@ function observe(beacon) {
 	});
 	return Object.freeze(instance);
 }
-function update$1(type, state, value, finish) {
+function subscribeToObservable(state, first, second, third) {
+	if (!state.beacon.active || !state.active) throw new Error(BEACON_MESSAGE_SUBSCRIBE);
+	const observer = getObserver(first, second, third);
+	const [subscription] = state.beacon.subscriptions.create({
+		isActive: () => state.beacon.active && state.active,
+		value: observer
+	});
+	observer.next?.(state.beacon.value);
+	return subscription;
+}
+function updateBeacon(type, state, value, finish) {
 	if (!state.active) return;
-	if (type === TYPE_NEXT) {
+	if (type === BEACON_TYPE_NEXT) {
 		if (state.options.equal(state.value, value)) return;
 		state.value = value;
 	}
-	for (const [, observer] of state.subscriptions.values.to.any) observer[type]?.(value);
+	for (const [, observer] of state.subscriptions.state.values.to.any) observer[type]?.(value);
 	if (finish === true) finishBeacon(state, true);
 }
-const KEY_BEACON = "$beacon";
-const MESSAGE_BEACON = "Cannot retrieve observable from a closed beacon";
-const MESSAGE_OBSERVABLE = "Cannot subscribe to a closed observable";
-const NAME_BEACON = "beacon";
-const NAME_OBSERVABLE = "observable";
-const TYPE_ERROR = "error";
-const TYPE_NEXT = "next";
-const beaconSubscription = {
-	key: KEY_BEACON,
-	value: "subscription"
-};
+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/color/constants.ts
 const COLOR_ALPHA = {
@@ -4042,10 +4077,7 @@ const COLOR_MAX = {
 	hex: 255,
 	percent: 100
 };
-const COLOR_PROPERTY = {
-	name: "$color",
-	subscription: "subscription"
-};
+const COLOR_PROPERTY = { name: "$color" };
 const COLOR_TYPE = {
 	all: void 0,
 	hex: "hex",
@@ -4055,7 +4087,8 @@ const COLOR_TYPE = {
 	hwb: "hwb",
 	hwba: "hwba",
 	rgb: "rgb",
-	rgba: "rgba"
+	rgba: "rgba",
+	wildcard: "*"
 };
 COLOR_TYPE.all = /* @__PURE__ */ new Set([
 	COLOR_ALPHA.name,
@@ -4967,7 +5000,7 @@ function getDefaultColorState() {
 		origin: COLOR_TYPE.hex
 	};
 }
-function setColorValue(color, state, subscriptions, type, value, alpha) {
+function setColorValue(color, state, changes, type, value, alpha) {
 	state.hex = void 0;
 	state.hsl = void 0;
 	state.hwb = void 0;
@@ -4975,36 +5008,33 @@ function setColorValue(color, state, subscriptions, type, value, alpha) {
 	state.origin = type;
 	state[type] = value;
 	if (alpha != null) state.alpha = getAlpha(alpha, type === COLOR_TYPE.hex);
-	for (const type of COLOR_TYPE.all) {
-		const callbacks = subscriptions.values.to.keyed?.get(type);
-		if (callbacks != null) for (const callback of callbacks.values()) callback(color[type]);
-	}
-	for (const callback of subscriptions.values.to.any.values()) callback(color);
+	for (const type of COLOR_TYPE.all) if (changes.observed(type)) changes.emit(type, color[type]);
+	changes.emit(COLOR_TYPE.wildcard, color);
 }
-function setHexColor(color, state, subscriptions, value, alpha) {
+function setHexColor(color, state, changes, value, alpha) {
 	if (!isHexColor(value) || !alpha && value === state.hex) return;
 	const normalized = getNormalizedHex(value, true);
-	setColorValue(color, state, subscriptions, COLOR_TYPE.hex, normalized.slice(0, COLOR_LENGTHS.hexLong), alpha ? normalized.slice(COLOR_LENGTHS.hexLong) : void 0);
+	setColorValue(color, state, changes, COLOR_TYPE.hex, normalized.slice(0, COLOR_LENGTHS.hexLong), alpha ? normalized.slice(COLOR_LENGTHS.hexLong) : void 0);
 }
-function setHSLColor(color, state, subscriptions, value, alpha) {
+function setHSLColor(color, state, changes, value, alpha) {
 	if (!isHslLike(value)) return;
-	setColorValue(color, state, subscriptions, COLOR_TYPE.hsl, {
+	setColorValue(color, state, changes, COLOR_TYPE.hsl, {
 		hue: getDegrees(value.hue),
 		saturation: getPercentage(value.saturation),
 		lightness: getPercentage(value.lightness)
 	}, alpha ? value.alpha : void 0);
 }
-function setHWBColor(color, state, subscriptions, value, alpha) {
+function setHWBColor(color, state, changes, value, alpha) {
 	if (!isHwbLike(value)) return;
-	setColorValue(color, state, subscriptions, COLOR_TYPE.hwb, {
+	setColorValue(color, state, changes, COLOR_TYPE.hwb, {
 		hue: getDegrees(value.hue),
 		whiteness: getPercentage(value.whiteness),
 		blackness: getPercentage(value.blackness)
 	}, alpha ? value.alpha : void 0);
 }
-function setRGBColor(color, state, subscriptions, value, alpha) {
+function setRGBColor(color, state, changes, value, alpha) {
 	if (!isRgbLike(value)) return;
-	setColorValue(color, state, subscriptions, COLOR_TYPE.rgb, {
+	setColorValue(color, state, changes, COLOR_TYPE.rgb, {
 		red: getHexValue(value.red),
 		green: getHexValue(value.green),
 		blue: getHexValue(value.blue)
@@ -5018,6 +5048,9 @@ const getters = {
 };
 //#endregion
 //#region src/color/misc/format.ts
+function formatHexColor(color, alpha) {
+	return `#${alpha === true ? color.hexa : color.hex}`;
+}
 function formatHslColor(state, alpha) {
 	const { hue, lightness, saturation } = getColorFromState(state, COLOR_TYPE.hsl);
 	return `hsl(${hue}deg ${saturation}% ${lightness}%${getSuffix(state, alpha)})`;
@@ -5036,51 +5069,56 @@ function getSuffix(state, alpha) {
 //#endregion
 //#region src/color/instance.ts
 function color(value) {
+	const changes = herald({
+		names: [COLOR_TYPE.wildcard, ...COLOR_TYPE.all],
+		property: colorSubscription,
+		onCreate: (event, callback) => onCreateSubscription(instance, event, callback)
+	});
 	const state = getColorState(value);
-	const subscriptions = getSubscriptions(COLOR_TYPE.all);
 	const instance = {
-		subscribe: (first, second) => subscribeToColor(subscriptions, first, second),
-		toHexString: (alpha) => `#${alpha === true ? instance.hexa : instance.hex}`,
+		subscribe: (callback, signal) => changes.subscribe(COLOR_TYPE.wildcard, callback, signal),
+		toHexString: (alpha) => formatHexColor(instance, alpha),
 		toHslString: (alpha) => formatHslColor(state, alpha),
 		toHwbString: (alpha) => formatHwbColor(state, alpha),
 		toRgbString: (alpha) => formatRgbColor(state, alpha),
 		toString: () => instance.toHexString(),
-		unsubscribe: () => clearSubscriptions(subscriptions)
+		unsubscribe: () => changes.clear()
 	};
 	Object.defineProperties(instance, {
-		[COLOR_PROPERTY.name]: {
-			enumerable: false,
-			value: true
-		},
+		[COLOR_PROPERTY.name]: { value: true },
 		alpha: {
 			enumerable: true,
 			get: () => state.alpha.value,
 			set: (value) => setAlphaValue(state, value)
 		},
-		hex: getProperty(COLOR_TYPE.hex, instance, state, subscriptions, false),
-		hexa: getProperty(COLOR_TYPE.hex, instance, state, subscriptions, true),
-		hsl: getProperty(COLOR_TYPE.hsl, instance, state, subscriptions, false),
-		hsla: getProperty(COLOR_TYPE.hsl, instance, state, subscriptions, true),
-		hwb: getProperty(COLOR_TYPE.hwb, instance, state, subscriptions, false),
-		hwba: getProperty(COLOR_TYPE.hwb, instance, state, subscriptions, true),
+		changes: {
+			enumerable: true,
+			value: changes.events
+		},
+		hex: getColorProperty(COLOR_TYPE.hex, instance, state, changes, false),
+		hexa: getColorProperty(COLOR_TYPE.hex, instance, state, changes, true),
+		hsl: getColorProperty(COLOR_TYPE.hsl, instance, state, changes, false),
+		hsla: getColorProperty(COLOR_TYPE.hsl, instance, state, changes, true),
+		hwb: getColorProperty(COLOR_TYPE.hwb, instance, state, changes, false),
+		hwba: getColorProperty(COLOR_TYPE.hwb, instance, state, changes, true),
 		origin: {
 			enumerable: true,
 			get: () => state.origin
 		},
-		rgb: getProperty(COLOR_TYPE.rgb, instance, state, subscriptions, false),
-		rgba: getProperty(COLOR_TYPE.rgb, instance, state, subscriptions, true)
+		rgb: getColorProperty(COLOR_TYPE.rgb, instance, state, changes, false),
+		rgba: getColorProperty(COLOR_TYPE.rgb, instance, state, changes, true)
 	});
 	return Object.freeze(instance);
 }
-function getProperty(space, color, state, subscriptions, alpha) {
+function getColorProperty(space, color, state, changes, alpha) {
 	const setValue = setters[space];
 	return {
 		enumerable: true,
-		get: () => getValue$1(space, state, alpha),
-		set: (value) => setValue(color, state, subscriptions, value, alpha)
+		get: () => getColorValue(space, state, alpha),
+		set: (value) => setValue(color, state, changes, value, alpha)
 	};
 }
-function getValue$1(space, state, alpha) {
+function getColorValue(space, state, alpha) {
 	const value = getColorFromState(state, space);
 	if (typeof value === "string") return alpha ? `${value}${state.alpha.hex}` : value;
 	return alpha ? {
@@ -5088,28 +5126,16 @@ function getValue$1(space, state, alpha) {
 		alpha: state.alpha.value
 	} : { ...value };
 }
+function onCreateSubscription(instance, event, callback) {
+	let value;
+	if (event === COLOR_TYPE.wildcard) value = instance;
+	else value = instance[event];
+	callback(value);
+}
 function setAlphaValue(state, value) {
 	if (typeof value === "number" && !Number.isNaN(value)) state.alpha = getAlpha(value, false);
 }
-function subscribeToColor(subscriptions, first, second) {
-	let key;
-	let value;
-	if (typeof first === "string") {
-		key = first;
-		value = second;
-	} else if (typeof first === "function") value = first;
-	if (typeof value !== "function") throw new Error();
-	return getSubscription({
-		key,
-		subscriptions,
-		value,
-		property: colorSubscription
-	});
-}
-const colorSubscription = {
-	key: COLOR_PROPERTY.name,
-	value: COLOR_PROPERTY.subscription
-};
+const colorSubscription = { key: COLOR_PROPERTY.name };
 const setters = {
 	hex: setHexColor,
 	hsl: setHSLColor,
@@ -5252,13 +5278,13 @@ const EXPRESSION_WHITESPACE = /^\s*$/;
 //#endregion
 //#region src/logger.ts
 function isLogger(value) {
-	return isLoggerInstance(NAME_LOGGER, value);
+	return isLoggerInstance(LOGGER_NAME, value);
 }
 function isLoggerInstance(name, value) {
-	return typeof value === "object" && value !== null && value[KEY_LOGGER] === name;
+	return typeof value === "object" && value !== null && value[LOGGER_PROPERTY] === name;
 }
 function isTimedLogger(value) {
-	return isLoggerInstance(NAME_TIMED, value);
+	return isLoggerInstance(LOGGER_NAME_TIMED, value);
 }
 function timedLogger(label) {
 	function stop() {
@@ -5277,35 +5303,20 @@ function timedLogger(label) {
 	};
 	const instance = {};
 	Object.defineProperties(instance, {
-		[KEY_LOGGER]: {
-			enumerable: false,
-			value: NAME_TIMED
-		},
+		[LOGGER_PROPERTY]: { value: LOGGER_NAME_TIMED },
 		active: {
 			enumerable: true,
-			get() {
-				return state.started && !state.stopped && enabled;
-			}
+			get: () => state.started && !state.stopped && enabled
 		},
-		log: {
-			enumerable: true,
-			get() {
-				return this.active ? logger : noop;
-			}
-		},
-		stop: {
-			enumerable: true,
-			get() {
-				return instance.active ? stop() : noop;
-			}
-		}
+		log: { get: () => instance.active ? logger : noop },
+		stop: { get: () => instance.active ? stop() : noop }
 	});
 	if (state.started) console.time(label);
 	return Object.freeze(instance);
 }
-const KEY_LOGGER = "$logger";
-const NAME_LOGGER = "Logger";
-const NAME_TIMED = "TimedLogger";
+const LOGGER_NAME = "Logger";
+const LOGGER_NAME_TIMED = "TimedLogger";
+const LOGGER_PROPERTY = "$logger";
 const methods = [
 	"debug",
 	"dir",
@@ -5324,25 +5335,15 @@ const methods = [
 const Logger = (() => {
 	const instance = {};
 	Object.defineProperties(instance, {
-		[KEY_LOGGER]: {
-			enumerable: false,
-			value: NAME_LOGGER
-		},
+		[LOGGER_PROPERTY]: { value: LOGGER_NAME },
 		enabled: {
 			enumerable: true,
-			get() {
-				return enabled;
-			},
-			set(value) {
+			get: () => enabled,
+			set: (value) => {
 				enabled = typeof value === "boolean" ? value : enabled;
 			}
 		},
-		time: {
-			enumerable: true,
-			value(label) {
-				return timedLogger(label);
-			}
-		}
+		time: { value: (label) => timedLogger(getString(label)) }
 	});
 	for (const method of methods) Object.defineProperty(instance, method, {
 		enumerable: true,
@@ -5414,6 +5415,17 @@ 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
@@ -5434,7 +5446,8 @@ var CancelablePromise = class extends Promise {
 	* @param reason Optional reason for canceling the _Promise_
 	*/
 	cancel(reason) {
-		this.#rejector(reason);
+		this.#rejector?.(reason);
+		this.#rejector = void 0;
 	}
 };
 /**
@@ -5446,17 +5459,6 @@ var PromiseTimeoutError = class extends Error {
 		this.name = PROMISE_ERROR_NAME;
 	}
 };
-const PROMISE_ABORT_EVENT = "abort";
-const PROMISE_ABORT_OPTIONS = { once: true };
-const PROMISE_ERROR_NAME = "PromiseTimeoutError";
-const PROMISE_MESSAGE_EXPECTATION_ATTEMPT = "Attempt expected a function or a promise";
-const PROMISE_MESSAGE_EXPECTATION_RESULT = "toResult expected a Promise";
-const PROMISE_MESSAGE_EXPECTATION_TIMED = "Timed function expected a Promise";
-const PROMISE_MESSAGE_TIMEOUT = "Promise timed out";
-const PROMISE_STRATEGY_ALL = /* @__PURE__ */ new Set(["complete", "first"]);
-const PROMISE_STRATEGY_DEFAULT = "complete";
-const PROMISE_TYPE_FULFILLED = "fulfilled";
-const PROMISE_TYPE_REJECTED = "rejected";
 //#endregion
 //#region src/promise/helpers.ts
 function getPromiseOptions(input) {
@@ -5522,10 +5524,10 @@ function cancelable(executor) {
 	return new CancelablePromise(executor);
 }
 function handleResult(status, parameters) {
-	const { abort, complete, data, handlers, index, signal, value } = parameters;
-	if (signal?.aborted ?? false) return;
+	const { aborter, complete, data, handlers, index, value } = parameters;
+	if (aborter?.signal.aborted ?? false) return;
 	if (!complete && status === "rejected") {
-		settlePromise(abort, handlers.reject, value, signal);
+		settlePromise(handlers.reject, value, aborter);
 		return;
 	}
 	data.result[index] = !complete ? value : status === "fulfilled" ? {
@@ -5535,10 +5537,10 @@ function handleResult(status, parameters) {
 		status,
 		reason: value
 	};
-	if (index === data.last) settlePromise(abort, handlers.resolve, data.result, signal);
+	if (index === data.last) settlePromise(handlers.resolve, data.result, aborter);
 }
-function settlePromise(aborter, settler, value, signal) {
-	signal?.removeEventListener(PROMISE_ABORT_EVENT, aborter);
+function settlePromise(settler, value, aborter) {
+	aborter?.cancel();
 	settler(value);
 }
 async function toResult(value) {
@@ -5550,50 +5552,44 @@ async function toResult(value) {
 //#region src/promise/delay.ts
 function delay(options) {
 	const { signal, time } = getPromiseOptions(options);
-	if (signal?.aborted ?? false) return Promise.reject(signal.reason);
-	function abort() {
+	if (signal?.aborted ?? false) return Promise.reject(signal?.reason);
+	const aborter = createAborter(signal, () => {
 		timer.cancel();
-		rejector(signal.reason);
-	}
-	const timer = getTimer(TIMER_WAIT, () => {
-		settlePromise(abort, resolver, void 0, signal);
-	}, time);
-	signal?.addEventListener(PROMISE_ABORT_EVENT, abort, PROMISE_ABORT_OPTIONS);
+		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(abort, resolve, void 0, signal);
+		if (time === 0) settlePromise(resolver, void 0, aborter);
 		else timer();
 	});
 }
 //#endregion
 //#region src/promise/timed.ts
 async function getTimedPromise(promise, time, signal) {
-	function abort() {
+	const aborter = createAborter(signal, () => {
 		timer.cancel();
-		rejector(signal.reason);
-	}
-	signal?.addEventListener(PROMISE_ABORT_EVENT, abort, PROMISE_ABORT_OPTIONS);
-	const timer = getTimer(TIMER_WAIT, () => {
-		settlePromise(abort, rejector, new PromiseTimeoutError(), signal);
-	}, time);
+		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);
-		signal?.removeEventListener(PROMISE_ABORT_EVENT, abort);
 		return value;
 	});
 }
 async function timed(promise, options) {
 	if (!(promise instanceof Promise)) return Promise.reject(/* @__PURE__ */ new TypeError(PROMISE_MESSAGE_EXPECTATION_TIMED));
 	const { signal, time } = getPromiseOptions(options);
-	if (signal?.aborted ?? false) return Promise.reject(signal.reason);
+	if (signal?.aborted ?? false) return Promise.reject(signal?.reason);
 	return time > 0 ? getTimedPromise(promise, time, signal) : promise;
 }
 //#endregion
@@ -5602,21 +5598,20 @@ async function attemptPromise(value, options) {
 	const isFunction = typeof value === "function";
 	if (!isFunction && !(value instanceof Promise)) return Promise.reject(/* @__PURE__ */ new TypeError(PROMISE_MESSAGE_EXPECTATION_ATTEMPT));
 	const { signal, time } = getPromiseOptions(options);
-	if (signal?.aborted ?? false) return Promise.reject(signal.reason);
-	function abort() {
-		rejector(signal.reason);
-	}
+	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(abort, resolve, result, signal);
+			settlePromise(resolve, result, aborter);
 		} catch (error) {
-			settlePromise(abort, reject, error, signal);
+			settlePromise(reject, error, aborter);
 		}
 	}
 	let rejector;
-	signal?.addEventListener(PROMISE_ABORT_EVENT, abort, PROMISE_ABORT_OPTIONS);
 	const promise = new Promise((resolve, reject) => {
 		rejector = reject;
 		handler(resolve, reject);
@@ -5625,16 +5620,15 @@ async function attemptPromise(value, options) {
 }
 async function promises(items, options) {
 	const { signal, strategy } = getPromisesOptions(options);
-	if (signal?.aborted ?? false) return Promise.reject(signal.reason);
+	if (signal?.aborted ?? false) return Promise.reject(signal?.reason);
 	if (!Array.isArray(items)) return Promise.resolve([]);
 	const actual = items.map((item) => typeof item === "function" ? item() : item).filter((item) => item instanceof Promise);
 	const { length } = actual;
 	if (length === 0) return Promise.resolve([]);
 	const complete = strategy === PROMISE_STRATEGY_DEFAULT;
-	function abort() {
-		handlers.reject(signal.reason);
-	}
-	signal?.addEventListener(PROMISE_ABORT_EVENT, abort, PROMISE_ABORT_OPTIONS);
+	const aborter = createAborter(signal, () => {
+		handlers.reject(signal?.reason);
+	});
 	const data = {
 		last: length - 1,
 		result: []
@@ -5646,20 +5640,18 @@ async function promises(items, options) {
 			resolve
 		};
 		for (let index = 0; index < length; index += 1) actual[index].then((value) => handleResult(PROMISE_TYPE_FULFILLED, {
-			abort,
+			aborter,
 			complete,
 			data,
 			handlers,
 			index,
-			signal,
 			value
 		})).catch((reason) => handleResult(PROMISE_TYPE_REJECTED, {
-			abort,
+			aborter,
 			complete,
 			data,
 			handlers,
 			index,
-			signal,
 			value: reason
 		}));
 	});
@@ -5678,15 +5670,15 @@ async function resultPromises(items, signal) {
 */
 function fromQuery(query) {
 	if (typeof query !== "string" || query.trim().length === 0) return {};
-	const parts = query.split(AMPERSAND).map((part) => part.split(EQUAL).map(tryDecode)).sort(([first], [second]) => first.localeCompare(second));
+	const parts = query.split(QUERY_AMPERSAND).map((part) => part.split(QUERY_EQUAL).map(tryDecode)).sort(([first], [second]) => first.localeCompare(second));
 	const { length } = parts;
 	const parameters = {};
 	let position = 0;
 	let array;
 	for (let index = 0; index < length; index += 1) {
 		const [key, value] = parts[index];
-		if (EXPRESSION_ARRAY_SUFFIX.test(key)) {
-			const named = key.replace(EXPRESSION_ARRAY_SUFFIX, "");
+		if (QUERY_EXPRESSION_ARRAY_SUFFIX.test(key)) {
+			const named = key.replace(QUERY_EXPRESSION_ARRAY_SUFFIX, "");
 			if (named !== array) {
 				array = named;
 				position = 0;
@@ -5708,9 +5700,9 @@ function getParts(value, fromArray, prefix) {
 	for (let index = 0; index < length; index += 1) {
 		const key = keys[index];
 		const val = value[key];
-		const fullKey = join([prefix, fromArray ? void 0 : key], DOT);
+		const fullKey = join([prefix, fromArray ? void 0 : key], QUERY_DOT);
 		const encodedKey = getString(tryEncode(fullKey));
-		const prefixedKey = fromArray ? join([encodedKey, index], DOT) : encodedKey;
+		const prefixedKey = fromArray ? join([encodedKey, index], QUERY_DOT) : encodedKey;
 		if (Array.isArray(val)) parts.push(...getParts(val, true, fullKey));
 		else if (isPlainObject(val)) parts.push(...getParts(val, false, fullKey));
 		else if (isDecodable(val)) parts.push(`${prefixedKey}=${getString(tryEncode(val))}`);
@@ -5719,7 +5711,7 @@ function getParts(value, fromArray, prefix) {
 	return parts;
 }
 function getQueryValue(value) {
-	if (EXPRESSION_BOOLEAN.test(value)) return value === TRUE;
+	if (QUERY_EXPRESSION_BOOLEAN.test(value)) return value === QUERY_TRUE;
 	const asNumber = getNumber(value);
 	if (!Number.isNaN(asNumber)) return asNumber;
 	const parsed = Date.parse(value);
@@ -5728,7 +5720,7 @@ function getQueryValue(value) {
 	return date.toJSON() === value ? date : value;
 }
 function isDecodable(value) {
-	return TYPES.has(typeof value);
+	return QUERY_TYPES.has(typeof value);
 }
 /**
 * Convert a plain _(nested)_ object to a query string
@@ -5737,15 +5729,15 @@ function isDecodable(value) {
 * @returns Query string representation of the object
 */
 function toQuery(parameters) {
-	return isPlainObject(parameters) ? join(getParts(parameters, false).filter((part) => part.length > 0), AMPERSAND) : "";
-}
-const AMPERSAND = "&";
-const DOT = ".";
-const EQUAL = "=";
-const EXPRESSION_ARRAY_SUFFIX = /\[\]$/;
-const EXPRESSION_BOOLEAN = /^(false|true)$/;
-const TRUE = "true";
-const TYPES = /* @__PURE__ */ new Set([
+	return isPlainObject(parameters) ? join(getParts(parameters, false).filter((part) => part.length > 0), QUERY_AMPERSAND) : "";
+}
+const QUERY_AMPERSAND = "&";
+const QUERY_DOT = ".";
+const QUERY_EQUAL = "=";
+const QUERY_EXPRESSION_ARRAY_SUFFIX = /\[\]$/;
+const QUERY_EXPRESSION_BOOLEAN = /^(false|true)$/;
+const QUERY_TRUE = "true";
+const QUERY_TYPES = /* @__PURE__ */ new Set([
 	"boolean",
 	"number",
 	"string"
@@ -5758,11 +5750,47 @@ const TYPES = /* @__PURE__ */ new Set([
 var QueueError = class extends Error {
 	constructor(message) {
 		super(message);
-		this.name = ERROR_NAME;
+		this.name = QUEUE_ERROR_NAME;
 	}
 };
+function addToQueue(instance, state, parameters, signal) {
+	if (instance.full) throw new QueueError(QUEUE_MESSAGE_MAXIMUM);
+	const abortSignal = signal instanceof AbortSignal ? signal : void 0;
+	if (abortSignal?.aborted ?? false) throw new Error(abortSignal?.reason);
+	const id = identify(state);
+	let rejector;
+	let resolver;
+	const promise = new Promise((resolve, reject) => {
+		rejector = reject;
+		resolver = resolve;
+	});
+	const aborter = createAborter(abortSignal, () => rejector(abortSignal?.reason));
+	state.items.push({
+		aborter,
+		id,
+		parameters,
+		promise,
+		key: state.key,
+		reject: rejector,
+		resolve: resolver
+	});
+	if (state.options.autostart) run(state);
+	return {
+		id,
+		promise
+	};
+}
+function clearQueue(state) {
+	const items = state.items.splice(0);
+	const { length } = items;
+	for (let index = 0; index < length; index += 1) {
+		const { aborter, reject } = items[index];
+		aborter?.cancel();
+		reject(new QueueError(QUEUE_MESSAGE_CLEAR));
+	}
+}
 function createQueue(callback, options, key) {
-	if (typeof callback !== "function") throw new TypeError(MESSAGE_CALLBACK);
+	if (typeof callback !== "function") throw new TypeError(QUEUE_MESSAGE_CALLBACK);
 	const state = {
 		callback,
 		key,
@@ -5774,71 +5802,16 @@ function createQueue(callback, options, key) {
 		runners: 0
 	};
 	const instance = {
-		add: (parameters, signal) => {
-			if (instance.full) throw new QueueError(MESSAGE_MAXIMUM);
-			const abortSignal = signal instanceof AbortSignal ? signal : void 0;
-			if (abortSignal?.aborted ?? false) throw new Error(abortSignal.reason);
-			const id = identify(state);
-			let rejector;
-			let resolver;
-			const promise = new Promise((resolve, reject) => {
-				rejector = reject;
-				resolver = resolve;
-			});
-			const aborter = abortSignal == null ? void 0 : () => rejector(abortSignal.reason);
-			signal?.addEventListener(EVENT_NAME, aborter, EVENT_OPTIONS);
-			state.items.push({
-				id,
-				parameters,
-				promise,
-				abort: aborter,
-				key: state.key,
-				reject: rejector,
-				resolve: resolver,
-				signal: abortSignal
-			});
-			if (state.options.autostart) run(state);
-			return {
-				id,
-				promise
-			};
-		},
-		clear: () => {
-			const items = state.items.splice(0);
-			const { length } = items;
-			for (let index = 0; index < length; index += 1) {
-				const { abort, reject, signal } = items[index];
-				reject(new QueueError(MESSAGE_CLEAR));
-				signal?.removeEventListener(EVENT_NAME, abort);
-			}
-		},
+		add: (parameters, signal) => addToQueue(instance, state, parameters, signal),
+		clear: () => clearQueue(state),
 		pause: () => {
 			state.paused = true;
 		},
-		remove: (id) => {
-			const index = state.items.findIndex((item) => item.id === id);
-			if (index > -1) {
-				const { abort, reject, signal } = state.items.splice(index, 1)[0];
-				reject(new QueueError(MESSAGE_REMOVE));
-				signal?.removeEventListener(EVENT_NAME, abort);
-			}
-		},
-		resume: () => {
-			if (state.paused) {
-				const handled = state.handled.splice(0);
-				const { length } = handled;
-				for (let index = 0; index < length; index += 1) handled[index]();
-			}
-			state.paused = false;
-			const length = Math.min(state.options.concurrency, state.items.length);
-			for (let index = 0; index < length; index += 1) run(state);
-		}
+		remove: (id) => removeQueued(state, id),
+		resume: () => resumeQueue(state)
 	};
 	Object.defineProperties(instance, {
-		[KEY_QUEUE]: {
-			enumerable: false,
-			value: NAME_QUEUE
-		},
+		[QUEUE_PROPERTY]: { value: QUEUE_NAME_QUEUE },
 		active: {
 			enumerable: true,
 			get: () => state.runners > 0
@@ -5877,12 +5850,6 @@ function createQueue(callback, options, key) {
 function getBooleanOrDefault(value, defaultValue) {
 	return typeof value === "boolean" ? value : defaultValue;
 }
-function getItems(state) {
-	const size = {};
-	const queues = state.queues.entries();
-	for (const [key, queue] of queues) size[key] = queue.size;
-	return size;
-}
 function getOptions(input) {
 	const options = typeof input === "object" && input != null ? input : {};
 	return {
@@ -5892,7 +5859,7 @@ function getOptions(input) {
 	};
 }
 function getQueue(state, key, add) {
-	if (typeof key !== "string" || key.trim().length === 0) throw new TypeError(MESSAGE_KEY);
+	if (typeof key !== "string" || key.trim().length === 0) throw new TypeError(QUEUE_MESSAGE_KEY);
 	let queue = state.queues.get(key);
 	if (queue == null && add === true) {
 		queue = createQueue(state.callback, state.options, key);
@@ -5900,6 +5867,12 @@ function getQueue(state, key, add) {
 	}
 	return queue;
 }
+function getQueueItems(state) {
+	const size = {};
+	const queues = state.queues.entries();
+	for (const [key, queue] of queues) size[key] = queue.size;
+	return size;
+}
 function getStatus(state, status) {
 	const queues = state.queues.entries();
 	const result = [];
@@ -5907,8 +5880,8 @@ function getStatus(state, status) {
 	return result;
 }
 function handleQueuedResult(item, error, result) {
-	item.signal?.removeEventListener(EVENT_NAME, item.abort);
-	if (item.signal?.aborted ?? false) {
+	item.aborter?.cancel();
+	if (item.aborter?.signal?.aborted ?? false) {
 		item.reject();
 		return;
 	}
@@ -5937,7 +5910,7 @@ function identify(state) {
 * @returns `true` if the value is a keyed queue, otherwise `false`
 */
 function isKeyedQueue(value) {
-	return isQueueInstance(NAME_KEYED, value);
+	return isQueueInstance(QUEUE_NAME_KEYED, value);
 }
 /**
 * Is the value a queue?
@@ -5946,13 +5919,13 @@ function isKeyedQueue(value) {
 * @returns `true` if the value is a queue, otherwise `false`
 */
 function isQueue(value) {
-	return isQueueInstance(NAME_QUEUE, value);
+	return isQueueInstance(QUEUE_NAME_QUEUE, value);
 }
 function isQueueInstance(name, value) {
-	return typeof value === "object" && value != null && value[KEY_QUEUE] === name;
+	return typeof value === "object" && value != null && value[QUEUE_PROPERTY] === name;
 }
 function keyedQueue(callback, options) {
-	if (typeof callback !== "function") throw new TypeError(MESSAGE_CALLBACK);
+	if (typeof callback !== "function") throw new TypeError(QUEUE_MESSAGE_CALLBACK);
 	const state = {
 		callback,
 		options: getOptions(options),
@@ -5960,26 +5933,17 @@ function keyedQueue(callback, options) {
 	};
 	const instance = {
 		add: (key, parameters, signal) => getQueue(state, key, true).add(parameters, signal),
-		clear: (key) => {
-			handleQueues(state, HANDLE_CLEAR, key);
-		},
+		clear: (key) => handleQueues(state, QUEUE_HANDLE_CLEAR, key),
 		get: (key) => getQueue(state, key),
-		pause: (key) => {
-			handleQueues(state, HANDLE_PAUSE, key);
-		},
+		pause: (key) => handleQueues(state, QUEUE_HANDLE_PAUSE, key),
 		remove: (key, id) => removeQueue(state, key, id),
-		resume: (key) => {
-			handleQueues(state, HANDLE_RESUME, key);
-		}
+		resume: (key) => handleQueues(state, QUEUE_HANDLE_RESUME, key)
 	};
 	Object.defineProperties(instance, {
-		[KEY_QUEUE]: {
-			enumerable: false,
-			value: NAME_KEYED
-		},
+		[QUEUE_PROPERTY]: { value: QUEUE_NAME_KEYED },
 		active: {
 			enumerable: true,
-			get: () => getStatus(state, STATUS_ACTIVE)
+			get: () => getStatus(state, QUEUE_STATUS_ACTIVE)
 		},
 		autostart: {
 			enumerable: true,
@@ -5991,15 +5955,15 @@ function keyedQueue(callback, options) {
 		},
 		empty: {
 			enumerable: true,
-			get: () => getStatus(state, STATUS_EMPTY)
+			get: () => getStatus(state, QUEUE_STATUS_EMPTY)
 		},
 		full: {
 			enumerable: true,
-			get: () => getStatus(state, STATUS_FULL)
+			get: () => getStatus(state, QUEUE_STATUS_FULL)
 		},
 		items: {
 			enumerable: true,
-			get: () => getItems(state)
+			get: () => getQueueItems(state)
 		},
 		keys: {
 			enumerable: true,
@@ -6011,7 +5975,7 @@ function keyedQueue(callback, options) {
 		},
 		paused: {
 			enumerable: true,
-			get: () => getStatus(state, STATUS_PAUSED)
+			get: () => getStatus(state, QUEUE_STATUS_PAUSED)
 		},
 		queues: {
 			enumerable: true,
@@ -6026,7 +5990,7 @@ function queue(callback, options) {
 queue.keyed = keyedQueue;
 function removeQueue(state, key, id) {
 	if (key == null) {
-		handleQueues(state, HANDLE_CLEAR);
+		handleQueues(state, QUEUE_HANDLE_CLEAR);
 		state.queues.clear();
 		return;
 	}
@@ -6039,6 +6003,24 @@ function removeQueue(state, key, id) {
 	queue.clear();
 	state.queues.delete(key);
 }
+function removeQueued(state, id) {
+	const index = state.items.findIndex((item) => item.id === id);
+	if (index > -1) {
+		const { aborter, reject } = state.items.splice(index, 1)[0];
+		aborter?.cancel();
+		reject(new QueueError(QUEUE_MESSAGE_REMOVE));
+	}
+}
+function resumeQueue(state) {
+	if (state.paused) {
+		const handled = state.handled.splice(0);
+		const { length } = handled;
+		for (let index = 0; index < length; index += 1) handled[index]();
+	}
+	state.paused = false;
+	const length = Math.min(state.options.concurrency, state.items.length);
+	for (let index = 0; index < length; index += 1) run(state);
+}
 async function run(state) {
 	if (state.paused || state.runners >= state.options.concurrency) return;
 	state.runners += 1;
@@ -6047,7 +6029,7 @@ async function run(state) {
 		let error = false;
 		let result;
 		try {
-			if (!(item.signal?.aborted ?? false)) {
+			if (!(item.aborter?.signal?.aborted ?? false)) {
 				const parameters = item.key == null ? item.parameters : [item.key, ...item.parameters];
 				result = await state.callback(...parameters);
 			}
@@ -6057,9 +6039,7 @@ async function run(state) {
 		}
 		if (state.paused) {
 			const paused = item;
-			state.handled.push(() => {
-				handleQueuedResult(paused, error, result);
-			});
+			state.handled.push(() => handleQueuedResult(paused, error, result));
 			break;
 		}
 		handleQueuedResult(item, error, result);
@@ -6067,24 +6047,22 @@ async function run(state) {
 	}
 	state.runners -= 1;
 }
-const ERROR_NAME = "QueueError";
-const EVENT_NAME = "abort";
-const EVENT_OPTIONS = { once: true };
-const KEY_QUEUE = "$queue";
-const HANDLE_CLEAR = "clear";
-const HANDLE_PAUSE = "pause";
-const HANDLE_RESUME = "resume";
-const MESSAGE_CALLBACK = "A Queue requires a callback function";
-const MESSAGE_CLEAR = "Queue was cleared";
-const MESSAGE_KEY = "Key must be a non-empty string";
-const MESSAGE_MAXIMUM = "Queue has reached its maximum size";
-const MESSAGE_REMOVE = "Item removed from queue";
-const NAME_KEYED = "keyedQueue";
-const NAME_QUEUE = "queue";
-const STATUS_ACTIVE = "active";
-const STATUS_EMPTY = "empty";
-const STATUS_FULL = "full";
-const STATUS_PAUSED = "paused";
+const QUEUE_ERROR_NAME = "QueueError";
+const QUEUE_PROPERTY = "$queue";
+const QUEUE_HANDLE_CLEAR = "clear";
+const QUEUE_HANDLE_PAUSE = "pause";
+const QUEUE_HANDLE_RESUME = "resume";
+const QUEUE_MESSAGE_CALLBACK = "A Queue requires a callback function";
+const QUEUE_MESSAGE_CLEAR = "Queue was cleared";
+const QUEUE_MESSAGE_KEY = "Key must be a non-empty string";
+const QUEUE_MESSAGE_MAXIMUM = "Queue has reached its maximum size";
+const QUEUE_MESSAGE_REMOVE = "Item removed from queue";
+const QUEUE_NAME_KEYED = "keyedQueue";
+const QUEUE_NAME_QUEUE = "queue";
+const QUEUE_STATUS_ACTIVE = "active";
+const QUEUE_STATUS_EMPTY = "empty";
+const QUEUE_STATUS_FULL = "full";
+const QUEUE_STATUS_PAUSED = "paused";
 //#endregion
 //#region src/random.ts
 /**
@@ -6093,7 +6071,7 @@ const STATUS_PAUSED = "paused";
 * @returns Random boolean
 */
 function getRandomBoolean() {
-	return Math.random() > BOOLEAN_MODIFIER;
+	return Math.random() > RANDOM_BOOLEAN_MODIFIER;
 }
 /**
 * Get a random string of characters with a specified length
@@ -6104,7 +6082,7 @@ function getRandomBoolean() {
 */
 function getRandomCharacters(length, selection) {
 	if (typeof length !== "number" || length <= 0) return "";
-	const actual = typeof selection === "string" && selection.length > 0 ? selection : ALPHABET;
+	const actual = typeof selection === "string" && selection.length > 0 ? selection : RANDOM_ALPHABET;
 	let characters = "";
 	for (let index = 0; index < length; index += 1) characters += actual.charAt(getRandomInteger(0, actual.length - 1));
 	return characters;
@@ -6124,7 +6102,7 @@ function getRandomColor(prefix) {
 * @returns Random hexadecimal character from `0-9` and `A-F`
 */
 function getRandomHex() {
-	return HEX_CHARACTERS[getRandomInteger(0, HEX_MAXIMUM)];
+	return RANDOM_HEX_CHARACTERS[getRandomInteger(0, RANDOM_HEX_MAXIMUM)];
 }
 /**
 * Get a random item from an array
@@ -6142,10 +6120,10 @@ function getRandomItems(array, amount) {
 	if (amount === 1) return [array[getRandomInteger(0, array.length - 1)]];
 	return typeof amount !== "number" || amount <= 0 || amount >= array.length ? shuffle(array) : shuffle(array).slice(0, amount);
 }
-const ALPHABET = "abcdefghijklmnopqrstuvwxyz";
-const BOOLEAN_MODIFIER = .5;
-const HEX_CHARACTERS = "0123456789ABCDEF";
-const HEX_MAXIMUM = 15;
+const RANDOM_ALPHABET = "abcdefghijklmnopqrstuvwxyz";
+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) {
@@ -6164,7 +6142,7 @@ function attempt(callback, err) {
 		return getError(err ?? thrown, err == null ? void 0 : thrown);
 	}
 }
-attempt.async = asyncAttempt;
+Object.defineProperty(attempt, "async", { value: asyncAttempt });
 //#endregion
 //#region src/result/match.ts
 async function asyncMatchResult(result, first, error) {
@@ -6172,7 +6150,7 @@ async function asyncMatchResult(result, first, error) {
 	if (typeof result === "function") value = await result();
 	else if (result instanceof Promise) value = await result;
 	else value = result;
-	if (!isResult(value)) throw new Error(MESSAGE_RESULT);
+	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;
@@ -6181,21 +6159,21 @@ async function asyncMatchResult(result, first, error) {
 }
 function matchResult(result, first, error) {
 	const value = typeof result === "function" ? result() : result;
-	if (!isResult(value)) throw new Error(MESSAGE_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);
 }
-matchResult.async = asyncMatchResult;
-const MESSAGE_RESULT = "`result.match` expected a Result or a function that returns a Result";
+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) => attempt.async(() => {
-		Flow ??= flow.async(...fns);
+	return (...args) => asyncAttempt(() => {
+		Flow ??= asyncFlow(...fns);
 		return Flow(...args.map((value) => {
 			if (isError(value)) throw value.error;
 			return isOk(value) ? value.value : value;
@@ -6212,11 +6190,11 @@ function attemptFlow(...fns) {
 		}));
 	});
 }
-attemptFlow.async = attemptAsyncFlow;
+Object.defineProperty(attemptFlow, "async", { value: attemptAsyncFlow });
 //#endregion
 //#region src/result/work/pipe.ts
 async function attemptAsyncPipe(initial, first, ...seconds) {
-	return attempt.async(() => {
+	return asyncAttempt(() => {
 		if (isError(initial)) throw initial.error;
 		const value = typeof initial === "function" ? initial() : isOk(initial) ? initial.value : initial;
 		if (first == null) return value;
@@ -6231,7 +6209,7 @@ function attemptPipe(initial, first, ...seconds) {
 		return pipe(value, ...[first, ...seconds]);
 	});
 }
-attemptPipe.async = attemptAsyncPipe;
+Object.defineProperty(attemptPipe, "async", { value: attemptAsyncPipe });
 //#endregion
 //#region src/sized/set.ts
 /**
@@ -6289,4 +6267,4 @@ var SizedSet = class extends Set {
 	}
 };
 //#endregion
-export { CancelablePromise, Logger, PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, PromiseTimeoutError, QueueError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, copy, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, filter, find, findLast, first, firstOrDefault, flatFreeze, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, getError, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getHwbColor, getHwbaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hasValueResult, herald, hexToHsl, hexToHsla, hexToHwb, hexToHwba, hexToRgb, hexToRgba, hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba, hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, interpolate, intersection, isArrayOrPlainObject, isBeacon, isColor, isConstructor, isEmpty, isError, isEvents, isFrozen, isFulfilled, isHerald, isHexColor, isHslColor, isHslaColor, isHwbColor, isHwbaColor, isInstanceOf, isKey, isKeyedQueue, isLogger, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isObservable, isOk, isPlainObject, isPrimitive, isQueue, isQueueInstance, isRejected, isResult, isRgbColor, isRgbaColor, isSorted, isSubscription, isTimedLogger, isTypedArray, join, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, lowerCase, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, select, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };
+export { CancelablePromise, Logger, PromiseTimeoutError, QueueError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, copy, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, filter, find, findLast, first, firstOrDefault, flatFreeze, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, 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 };