@oscarpalmer/atoms 0.202.0 → 0.204.0

package/dist/index.mjs

@@ -114,7 +114,6 @@ function filter(array, ...parameters) {
 	return findValues("all", array, parameters).matched;
 }
 filter.remove = exclude;
-Object.defineProperty(filter, "remove", { value: exclude });
 //#endregion
 //#region src/array/first.ts
 function first(array, ...parameters) {
@@ -124,7 +123,6 @@ function firstOrDefault(array, defaultValue, ...parameters) {
 	return findAbsoluteValueOrDefault(array, parameters, defaultValue, true, false);
 }
 first.default = firstOrDefault;
-Object.defineProperty(first, "default", { value: firstOrDefault });
 //#endregion
 //#region src/internal/array/group.ts
 function groupValues(array, key, value, arrays) {
@@ -153,7 +151,6 @@ function groupArraysBy(array, first, second) {
 	return groupValues(array, first, second, true);
 }
 groupBy.arrays = groupArraysBy;
-Object.defineProperty(groupBy, "arrays", { value: groupArraysBy });
 //#endregion
 //#region src/internal/array/chunk.ts
 /**
@@ -379,13 +376,14 @@ function getArray(value, indiced) {
 	if (value instanceof Set) return [...value.values()];
 	if (isNonPlainObject(value)) return [value];
 	if (indiced !== true) return Object.entries(value);
-	const keys = Object.keys(value);
+	const obj = value;
+	const keys = Object.keys(obj);
 	const { length } = keys;
 	const array = [];
 	for (let index = 0; index < length; index += 1) {
 		const key = keys[index];
 		const asNumber = Number.parseInt(key, 10);
-		if (!Number.isNaN(asNumber)) array[asNumber] = value[key];
+		if (!Number.isNaN(asNumber)) array[asNumber] = obj[key];
 	}
 	return array;
 }
@@ -398,7 +396,6 @@ function lastIndexOf(array, ...parameters) {
 	return findValue(FIND_VALUE_INDEX, array, parameters, true);
 }
 indexOf.last = lastIndexOf;
-Object.defineProperty(indexOf, "last", { value: lastIndexOf });
 //#endregion
 //#region src/internal/array/match.ts
 function endsWithArray(haystack, needle, key) {
@@ -553,7 +550,6 @@ function findLast(array, ...parameters) {
 	return findValue(FIND_VALUE_ITEM, array, parameters, true);
 }
 find.last = findLast;
-Object.defineProperty(find, "last", { value: findLast });
 //#endregion
 //#region src/array/flatten.ts
 /**
@@ -689,7 +685,6 @@ function selectValues(array, parameters) {
 	}).matched;
 }
 select.reverse = reverseSelect;
-Object.defineProperty(select, "reverse", { value: reverseSelect });
 //#endregion
 //#region src/array/single.ts
 function single(array, ...parameters) {
@@ -818,7 +813,6 @@ function lastOrDefault(array, defaultValue, ...parameters) {
 	return findAbsoluteValueOrDefault(array, parameters, defaultValue, true, true);
 }
 last.default = lastOrDefault;
-Object.defineProperty(last, "default", { value: lastOrDefault });
 //#endregion
 //#region src/internal/array/overlap.ts
 function arraysOverlap(first, second) {
@@ -912,10 +906,6 @@ function moveToIndex(array, value, index, key) {
 }
 move.indices = moveIndices;
 move.toIndex = moveToIndex;
-Object.defineProperties(move, {
-	indices: { value: moveIndices },
-	toIndex: { value: moveToIndex }
-});
 //#endregion
 //#region src/internal/math/aggregate.ts
 function aggregate(type, array, key, first) {
@@ -1069,59 +1059,57 @@ const STRING_EXPRESSION_IGNORED = /(^|\.)(__proto__|constructor|prototype)(\.|$)
 const STRING_EXPRESSION_WORDS = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
 //#endregion
 //#region src/internal/value/handlers.ts
-function createCompareHandlers(owner, options) {
-	const handlers = createHandlers(owner, options);
-	return {
-		deregister(constructor) {
-			handlers.deregister(constructor);
-		},
-		handle(first, second, ...parameters) {
-			const handler = handlers.get(first, second);
-			if (handler == null) return options.callback(first, second, ...parameters);
-			return typeof handler === "function" ? handler(first, second) : first[handler](second);
-		},
-		register(constructor, handler) {
-			handlers.register(constructor, handler);
-		}
-	};
+function BaseHandler(owner, options) {
+	this.handlers = /* @__PURE__ */ new WeakMap();
+	this.owner = owner;
+	this.options = options;
 }
-function createHandlers(owner, options) {
-	const handlers = /* @__PURE__ */ new WeakMap();
-	return {
-		deregister(constructor) {
-			handlers.delete(constructor);
-		},
-		get(first, second) {
-			if (isConstructable(first) && isConstructable(second) && first.constructor === second.constructor) return handlers.get(first.constructor);
-		},
-		register(constructor, handler) {
-			if (isNonConstructor(constructor) || handler === owner) return;
-			let actual = handler ?? options.method;
-			if (typeof actual !== "function" && typeof actual !== "string") return;
-			if (typeof actual === "string") actual = typeof constructor.prototype[actual] === "function" ? actual : void 0;
-			if (actual != null) handlers.set(constructor, actual);
-		}
-	};
+BaseHandler.prototype.deregister = deregisterHandler;
+BaseHandler.prototype.get = getHandler$1;
+BaseHandler.prototype.register = registerHandler;
+function CompareHandler(base) {
+	this.base = base;
 }
-function createSelfHandlers(owner, options) {
-	const handlers = createHandlers(owner, options);
-	return {
-		deregister(constructor) {
-			handlers.deregister(constructor);
-		},
-		handle(value, ...parameters) {
-			const handler = handlers.get(value, value);
-			if (handler == null) return options.callback(value, ...parameters);
-			return typeof handler === "function" ? handler(value) : value[handler]();
-		},
-		register(constructor, handler) {
-			handlers.register(constructor, handler);
-		}
-	};
+CompareHandler.prototype.handle = handleComparison;
+function ValueHandler(value) {
+	this.base = value;
+}
+ValueHandler.prototype.handle = handleValue$1;
+function createBaseHandler(owner, options) {
+	return new BaseHandler(owner, options);
+}
+function createCompareHandler(owner, options) {
+	return new CompareHandler(createBaseHandler(owner, options));
+}
+function createValueHandler(owner, options) {
+	return new ValueHandler(createBaseHandler(owner, options));
+}
+function deregisterHandler(value) {
+	this.handlers.delete(value);
+}
+function getHandler$1(first, second) {
+	if (isConstructable(first) && isConstructable(second) && first.constructor === second.constructor) return this.handlers.get(first.constructor);
+}
+function handleComparison(first, second, ...parameters) {
+	const handler = this.base.get(first, second);
+	if (handler == null) return this.base.options.callback(first, second, ...parameters);
+	return typeof handler === "function" ? handler(first, second) : first[handler](second);
 }
 function isConstructable(value) {
 	return typeof value === "object" && value !== null;
 }
+function registerHandler(constructor, handler) {
+	if (isNonConstructor(constructor) || handler === this.owner) return;
+	let actual = handler ?? this.options.method;
+	if (typeof actual !== "function" && typeof actual !== "string") return;
+	if (typeof actual === "string") actual = typeof constructor.prototype[actual] === "function" ? actual : void 0;
+	if (actual != null) this.handlers.set(constructor, actual);
+}
+function handleValue$1(value, ...parameters) {
+	const handler = this.base.get(value, value);
+	if (handler == null) return this.base.options.callback(value, ...parameters);
+	return typeof handler === "function" ? handler(value) : value[handler]();
+}
 //#endregion
 //#region src/internal/value/compare.ts
 const COMPARE_NAME = "compare";
@@ -1167,7 +1155,7 @@ function compareValue(first, second, compareStrings) {
 	const firstType = typeof first;
 	if (firstType === typeof second && firstType in comparators) return comparators[firstType](first, second);
 	if (first instanceof Date && second instanceof Date) return compareNumbers(first.getTime(), second.getTime());
-	return compare.handlers.handle(first, second, compareStrings);
+	return compare.handler.handle(first, second, compareStrings);
 }
 /**
 * Deregister a custom comparison handler for a class
@@ -1177,7 +1165,7 @@ function compareValue(first, second, compareStrings) {
 * @param constructor Class constructor
 */
 function deregisterComparator(constructor) {
-	compare.handlers.deregister(constructor);
+	compare.handler.base.deregister(constructor);
 }
 function getComparisonParts(value) {
 	if (Array.isArray(value)) return value;
@@ -1192,7 +1180,7 @@ function getComparisonParts(value) {
 * @param handler Method name or comparison function _(defaults to `compare`)_
 */
 function registerComparator(constructor, handler) {
-	compare.handlers.register(constructor, handler);
+	compare.handler.base.register(constructor, handler);
 }
 const comparators = {
 	bigint: compareNumbers,
@@ -1200,24 +1188,25 @@ const comparators = {
 	number: compareNumbers,
 	symbol: compareSymbols
 };
-const compareHandlers = createCompareHandlers(compare, {
+const compareHandler = createCompareHandler(compare, {
 	callback: (first, second, compareStrings) => compareStrings ? getString(first).localeCompare(getString(second)) : void 0,
 	method: COMPARE_NAME
 });
 compare.deregister = deregisterComparator;
-compare.handlers = compareHandlers;
+compare.handler = compareHandler;
 compare.register = registerComparator;
-Object.defineProperties(compare, {
-	deregister: { value: deregisterComparator },
-	handlers: { value: compareHandlers },
-	register: { value: registerComparator }
-});
 //#endregion
 //#region src/array/sort.ts
+function Sorter(sorters) {
+	this[SORTER_SYMBOL] = sorters;
+}
+Sorter.prototype.index = getSortedArrayIndex;
+Sorter.prototype.is = isSortedArray;
+Sorter.prototype.sort = sortArray;
 function getComparisonSorter(callback, modifier) {
 	return {
 		modifier,
-		compare: { simple: callback },
+		comparison: { simple: callback },
 		get: false,
 		identifier: callback.toString()
 	};
@@ -1225,16 +1214,30 @@ function getComparisonSorter(callback, modifier) {
 function getComparisonValue(first, second, sorters, length) {
 	for (let index = 0; index < length; index += 1) {
 		const sorter = sorters[index];
-		const values = [sorter.get ? sorter.value(first) : first, sorter.get ? sorter.value(second) : second];
-		const comparison = (sorter.compare?.complex?.(first, values[0], second, values[1]) ?? sorter.compare?.simple?.(values[0], values[1]) ?? compare(values[0], values[1])) * sorter.modifier;
+		const values = [sorter.get ? sorter.value?.(first) : first, sorter.get ? sorter.value?.(second) : second];
+		const comparison = (sorter.comparison?.complex?.(first, values[0], second, values[1]) ?? sorter.comparison?.simple?.(values[0], values[1]) ?? compare(values[0], values[1])) * sorter.modifier;
 		if (comparison !== 0) return comparison;
 	}
 	return 0;
 }
-function getIndex(array, item, sorters) {
+function getModifier(first, second) {
+	return modifiers[first === true || second === true ? SORT_DIRECTION_DESCENDING : SORT_DIRECTION_ASCENDING];
+}
+function getObjectSorter(obj, modifier) {
+	let sorter;
+	if (typeof obj.comparison === "function") sorter = getComparisonSorter(obj.comparison, modifier);
+	else if (typeof obj.key === "string") {
+		sorter = getValueSortHandlers(obj.key, modifier);
+		if (typeof obj.compare === "function") sorter.comparison = { complex: obj.compare };
+	} else if (typeof obj.value === "function") sorter = getValueSortHandlers(obj.value, modifier);
+	if (sorter != null && typeof obj.direction === "string") sorter.modifier = modifiers[obj.direction] ?? modifier;
+	return sorter;
+}
+function getSortedArrayIndex(array, item) {
 	if (!Array.isArray(array)) return -1;
 	const { length } = array;
 	if (length === 0) return 0;
+	const sorters = Array.isArray(this) ? this : this[SORTER_SYMBOL];
 	const sortersLength = sorters.length;
 	if (getComparisonValue(item, array[0], sorters, sortersLength) < 0) return 0;
 	if (getComparisonValue(item, array[length - 1], sorters, sortersLength) >= 0) return length;
@@ -1247,36 +1250,23 @@ function getIndex(array, item, sorters) {
 	}
 	return low;
 }
-function getModifier(first, second) {
-	return modifiers[first === true || second === true ? SORT_DIRECTION_DESCENDING : SORT_DIRECTION_ASCENDING];
-}
-function getObjectSorter(obj, modifier) {
-	let sorter;
-	if (typeof obj.comparison === "function") sorter = getComparisonSorter(obj.comparison, modifier);
-	else if (typeof obj.key === "string") {
-		sorter = getValueSorter(obj.key, modifier);
-		if (typeof obj.compare === "function") sorter.compare = { complex: obj.compare };
-	} else if (typeof obj.value === "function") sorter = getValueSorter(obj.value, modifier);
-	if (sorter != null && typeof obj.direction === "string") sorter.modifier = modifiers[obj.direction] ?? modifier;
-	return sorter;
-}
 function getSortedIndex(array, item, first, second) {
-	return getIndex(array, item, getSorters(first, getModifier(first, second)));
+	return getSortedArrayIndex.call(getSortHandlers(first, getModifier(first, second)), array, item);
 }
-function getSorter(value, modifier) {
+function getSortHandler(value, modifier) {
 	switch (true) {
 		case typeof value === "function": return getComparisonSorter(value, modifier);
-		case typeof value === "string": return getValueSorter(value, modifier);
+		case typeof value === "string": return getValueSortHandlers(value, modifier);
 		case isPlainObject(value): return getObjectSorter(value, modifier);
 	}
 }
-function getSorters(value, modifier) {
+function getSortHandlers(value, modifier) {
 	const array = Array.isArray(value) ? value : [value];
 	const { length } = array;
 	const sorters = [];
 	for (let index = 0; index < length; index += 1) {
 		const item = array[index];
-		const sorter = getSorter(item, modifier);
+		const sorter = getSortHandler(item, modifier);
 		if (sorter != null) sorters.push(sorter);
 	}
 	if (sorters.length === 0) return [{
@@ -1286,7 +1276,7 @@ function getSorters(value, modifier) {
 	}];
 	return sorters.filter((value, index, array) => array.findIndex((next) => next.identifier === value.identifier) === index);
 }
-function getValueSorter(value, modifier) {
+function getValueSortHandlers(value, modifier) {
 	const isFunction = typeof value === "function";
 	return {
 		modifier,
@@ -1296,21 +1286,16 @@ function getValueSorter(value, modifier) {
 	};
 }
 function initializeSorter(first, second) {
-	const sorters = getSorters(first, getModifier(first, second));
-	const sorter = (array) => sortArray(array, sorters);
-	Object.defineProperties(sorter, {
-		index: { value: (array, item) => getIndex(array, item, sorters) },
-		is: { value: (array) => isSortedArray(array, sorters) }
-	});
-	return sorter;
+	return new Sorter(getSortHandlers(first, getModifier(first, second)));
 }
 function isSorted(array, first, second) {
-	return isSortedArray(array, getSorters(first, getModifier(first, second)));
+	return isSortedArray.call(getSortHandlers(first, getModifier(first, second)), array);
 }
-function isSortedArray(array, sorters) {
+function isSortedArray(array) {
 	if (!Array.isArray(array)) return false;
 	const { length } = array;
 	if (length < 2) return true;
+	const sorters = Array.isArray(this) ? this : this[SORTER_SYMBOL];
 	const sortersLength = sorters.length;
 	let offset = 0;
 	if (length >= SORT_THRESHOLD) {
@@ -1332,10 +1317,11 @@ function isSortedArray(array, sorters) {
 	return true;
 }
 function sort(array, first, second) {
-	return sortArray(array, getSorters(first, getModifier(first, second)));
+	return sortArray.call(getSortHandlers(first, getModifier(first, second)), array);
 }
-function sortArray(array, sorters) {
+function sortArray(array) {
 	if (!Array.isArray(array)) return [];
+	const sorters = Array.isArray(this) ? this : this[SORTER_SYMBOL];
 	const { length } = sorters;
 	return array.length > 1 ? array.sort((first, second) => getComparisonValue(first, second, sorters, length)) : array;
 }
@@ -1343,6 +1329,7 @@ const SORT_PEEK_PERCENTAGE = 10;
 const SORT_THRESHOLD = 100;
 const SORT_DIRECTION_ASCENDING = "ascending";
 const SORT_DIRECTION_DESCENDING = "descending";
+const SORTER_SYMBOL = Symbol("sorter");
 const modifiers = {
 	[SORT_DIRECTION_ASCENDING]: 1,
 	[SORT_DIRECTION_DESCENDING]: -1
@@ -1350,11 +1337,6 @@ const modifiers = {
 sort.getIndex = getSortedIndex;
 sort.initialize = initializeSorter;
 sort.is = isSorted;
-Object.defineProperties(sort, {
-	getIndex: { value: getSortedIndex },
-	initialize: { value: initializeSorter },
-	is: { value: isSorted }
-});
 //#endregion
 //#region src/array/swap.ts
 function swap(array, first, second, third) {
@@ -1412,7 +1394,6 @@ function swapValues(array, from, to, key) {
 	return swapIndices(array, first, second);
 }
 swap.indices = swapIndices;
-Object.defineProperty(swap, "indices", { value: swapIndices });
 //#endregion
 //#region src/array/to-map.ts
 function getMapValues(array, first, second, arrays) {
@@ -1439,7 +1420,6 @@ function toMapArrays(array, first, second) {
 	return getMapValues(array, first, second, true);
 }
 toMap.arrays = toMapArrays;
-Object.defineProperty(toMap, "arrays", { value: toMapArrays });
 //#endregion
 //#region src/array/to-record.ts
 function toRecord(array, first, second) {
@@ -1449,7 +1429,6 @@ function toRecordArrays(array, first, second) {
 	return groupValues(array, first, second, true);
 }
 toRecord.arrays = toRecordArrays;
-Object.defineProperty(toRecord, "arrays", { value: toRecordArrays });
 //#endregion
 //#region src/internal/function/misc.ts
 /**
@@ -1465,86 +1444,105 @@ function getNumberOrDefault(value, defaultValue, minimum) {
 	return typeof value === "number" && !Number.isNaN(value) && value >= (minimum ?? 0) ? value : defaultValue;
 }
 //#endregion
-//#region src/internal/function/timer.ts
-function getAsyncTimer(type, callback, time) {
-	function cancel() {
-		clearTimer(id);
-		if (last != null && !last.running) {
-			last.reject();
-			last = void 0;
-		}
-	}
-	async function run(item) {
-		const now = performance.now();
-		start ??= now;
-		if (interval === 0 || now - start >= interval - TIMER_OFFSET) {
-			start = throttle ? now : void 0;
-			item.running = true;
-			try {
-				let result = callback(...item.parameters);
-				if (result instanceof Promise) result = await result;
-				item.resolve(result);
-			} catch (error) {
-				item.reject(error);
-			} finally {
-				item.running = false;
-			}
-		} else id = startTimer(() => run(item));
-	}
-	const interval = getNumberOrDefault(time, 0);
-	const throttle = type === TIMER_THROTTLE;
-	let id;
-	let last;
-	let start;
-	const timer = (...parameters) => {
-		cancel();
-		const next = {
-			parameters,
-			running: false
-		};
-		next.promise = new Promise((resolve, reject) => {
-			next.reject = reject;
-			next.resolve = resolve;
-		});
-		last = next;
-		if (throttle) run(next);
-		else id = startTimer(() => run(next));
-		return next.promise;
+//#region src/internal/function/limit.ts
+const LIMITER_NAME_ASYNC = "asyncLimiter";
+const LIMITER_NAME_SYNC = "limiter";
+const LIMITER_PROPERTY = "$limiter";
+function AsyncLimiter(type, callback, time) {
+	this[LIMITER_SYMBOL] = {
+		callback,
+		type,
+		interval: getNumberOrDefault(time, 0),
+		parameters: [],
+		throttle: type === LIMITER_THROTTLE
+	};
+}
+AsyncLimiter.prototype[LIMITER_PROPERTY] = LIMITER_NAME_ASYNC;
+AsyncLimiter.prototype.cancel = cancelAsyncLimiter;
+AsyncLimiter.prototype.run = runAsyncLimiter;
+function Limiter(type, callback, time) {
+	this[LIMITER_SYMBOL] = {
+		callback,
+		type,
+		interval: getNumberOrDefault(time, 0),
+		parameters: [],
+		throttle: type === LIMITER_THROTTLE
 	};
-	Object.defineProperty(timer, TIMER_CANCEL, { value: () => cancel() });
-	return timer;
-}
-function getTimer(type, callback, time) {
-	function cancel() {
-		clearTimer(id);
-	}
-	function run() {
-		const now = performance.now();
-		start ??= now;
-		if (interval === 0 || now - start >= interval - TIMER_OFFSET) {
-			start = throttle ? now : void 0;
-			callback(...args);
-		} else id = startTimer(run);
-	}
-	const interval = getNumberOrDefault(time, 0);
-	const throttle = type === TIMER_THROTTLE;
-	let args;
-	let id;
-	let start;
-	const timer = (...parameters) => {
-		cancel();
-		args = parameters;
-		if (throttle) run();
-		else id = startTimer(run);
+}
+Limiter.prototype[LIMITER_PROPERTY] = LIMITER_NAME_SYNC;
+Limiter.prototype.cancel = cancelLimiter;
+Limiter.prototype.run = runLimiter;
+function cancelAsyncLimiter() {
+	const state = this[LIMITER_SYMBOL];
+	if (state.timer != null) clearTimer(state.timer);
+	if (state.last != null && !state.last.running) {
+		state.last.reject();
+		state.last = void 0;
+	}
+}
+function cancelLimiter() {
+	const { timer } = this[LIMITER_SYMBOL];
+	if (timer != null) clearTimer(timer);
+}
+function getAsyncLimiter(type, callback, time) {
+	return new AsyncLimiter(type, callback, time);
+}
+function getLimiter(type, callback, time) {
+	return new Limiter(type, callback, time);
+}
+async function handleAsyncLimiter(state, item) {
+	const now = performance.now();
+	state.start ??= now;
+	if (state.interval === 0 || now - state.start >= state.interval - LIMITER_OFFSET) {
+		state.start = state.throttle ? now : void 0;
+		item.running = true;
+		try {
+			let result = state.callback(...item.parameters);
+			if (result instanceof Promise) result = await result;
+			item.resolve(result);
+		} catch (error) {
+			item.reject(error);
+		} finally {
+			item.running = false;
+		}
+	} else state.timer = startTimer(() => handleAsyncLimiter(state, item));
+}
+function handleLimiter(state) {
+	const now = performance.now();
+	state.start ??= now;
+	if (state.interval === 0 || now - state.start >= state.interval - LIMITER_OFFSET) {
+		state.start = state.throttle ? now : void 0;
+		state.callback(...state.parameters);
+	} else state.timer = startTimer(() => handleLimiter(state));
+}
+function runAsyncLimiter() {
+	const state = this[LIMITER_SYMBOL];
+	cancelAsyncLimiter.call(this);
+	const next = {
+		parameters: state.parameters,
+		running: false
 	};
-	Object.defineProperty(timer, TIMER_CANCEL, { value: () => cancel() });
-	return timer;
-}
-const TIMER_CANCEL = "cancel";
-const TIMER_DEBOUNCE = "debounce";
-const TIMER_OFFSET = 5;
-const TIMER_THROTTLE = "throttle";
-const TIMER_WAIT = "wait";
+	next.promise = new Promise((resolve, reject) => {
+		next.reject = reject;
+		next.resolve = resolve;
+	});
+	state.last = next;
+	if (state.throttle) handleAsyncLimiter(state, next);
+	else state.timer = startTimer(() => handleAsyncLimiter(state, next));
+	return next.promise;
+}
+function runLimiter(...parameters) {
+	const state = this[LIMITER_SYMBOL];
+	cancelLimiter.call(this);
+	state.parameters = parameters;
+	if (state.throttle) handleLimiter(state);
+	else state.timer = startTimer(() => handleLimiter(state));
+}
+const LIMITER_DEBOUNCE = "debounce";
+const LIMITER_OFFSET = 5;
+const LIMITER_SYMBOL = Symbol("limiter");
+const LIMITER_THROTTLE = "throttle";
+const LIMITER_WAIT = "wait";
 // istanbul ignore next
 const clearTimer = typeof cancelAnimationFrame === "function" ? cancelAnimationFrame : clearTimeout;
 // istanbul ignore next
@@ -1564,7 +1562,7 @@ const startTimer = typeof requestAnimationFrame === "function" ? requestAnimatio
 * @returns Debounced callback handler with a `cancel` method
 */
 function asyncDebounce(callback, time) {
-	return getAsyncTimer(TIMER_DEBOUNCE, callback, time);
+	return getAsyncLimiter(LIMITER_DEBOUNCE, callback, time);
 }
 /**
 * Throttle a function, ensuring it is only called once every `time` milliseconds
@@ -1579,7 +1577,7 @@ function asyncDebounce(callback, time) {
 * @returns Throttled callback handler with a `cancel` method
 */
 function asyncThrottle(callback, time) {
-	return getAsyncTimer(TIMER_THROTTLE, callback, time);
+	return getAsyncLimiter(LIMITER_THROTTLE, callback, time);
 }
 /**
 * Debounce a function, ensuring it is only called after `time` milliseconds have passed
@@ -1591,7 +1589,7 @@ function asyncThrottle(callback, time) {
 * @returns Debounced callback handler with a `cancel` method
 */
 function debounce(callback, time) {
-	return getTimer(TIMER_DEBOUNCE, callback, time);
+	return getLimiter(LIMITER_DEBOUNCE, callback, time);
 }
 /**
 * Throttle a function, ensuring it is only called once every `time` milliseconds
@@ -1601,12 +1599,10 @@ function debounce(callback, time) {
 * @returns Throttled callback handler with a `cancel` method
 */
 function throttle(callback, time) {
-	return getTimer(TIMER_THROTTLE, callback, time);
+	return getLimiter(LIMITER_THROTTLE, callback, time);
 }
 debounce.async = asyncDebounce;
 throttle.async = asyncThrottle;
-Object.defineProperty(debounce, "async", { value: asyncDebounce });
-Object.defineProperty(throttle, "async", { value: asyncThrottle });
 //#endregion
 //#region src/internal/result/misc.ts
 function error(value, original) {
@@ -1636,8 +1632,7 @@ function isResult(value) {
 	return isResultValue(value, true) || isResultValue(value, false);
 }
 function isResultValue(value, okValue) {
-	if (isNonPlainObject(value)) return false;
-	return value.ok === okValue && (okValue ? RESULT_PROPERTY_VALUE : RESULT_PROPERTY_ERROR) in value;
+	return isPlainObject(value) && value.ok === okValue && (okValue ? RESULT_PROPERTY_VALUE : RESULT_PROPERTY_ERROR) in value;
 }
 /**
 * Creates an ok result
@@ -1656,6 +1651,8 @@ function unwrap(value, defaultValue) {
 }
 const RESULT_PROPERTY_ERROR = "error";
 const RESULT_PROPERTY_VALUE = "value";
+error.is = isError;
+ok.is = isOk;
 //#endregion
 //#region src/internal/value/misc.ts
 function findKey(needle, haystack) {
@@ -1687,9 +1684,10 @@ function getPaths(path, lowercase) {
 function handleValue(data, path, value, get, ignoreCase) {
 	if (typeof data === "object" && data !== null) {
 		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(MISC_NESTED_MESSAGE_MISSING);
-		data[key] = typeof value === "function" ? value(data[key]) : value;
+		const dataObject = data;
+		const key = ignoreCase ? findKey(path, dataObject) : path;
+		if (get) return key in dataObject ? ok(dataObject[key]) : error(MISC_NESTED_MESSAGE_MISSING);
+		dataObject[key] = typeof value === "function" ? value(dataObject[key]) : value;
 	}
 	if (get) return error(MISC_NESTED_MESSAGE_MISSING);
 }
@@ -1709,7 +1707,6 @@ function hasValueResult(data, path, ignoreCase) {
 	return getNestedValue(data, path, ignoreCase === true);
 }
 hasValue.get = hasValueResult;
-Object.defineProperty(hasValue, "get", { value: hasValueResult });
 //#endregion
 //#region src/internal/function/assert.ts
 /**
@@ -1804,15 +1801,64 @@ assert.defined = assertDefined;
 assert.instanceOf = assertInstanceOf;
 assert.is = assertIs;
 assert.property = assertProperty;
-Object.defineProperties(assert, {
-	condition: { value: assertCondition },
-	defined: { value: assertDefined },
-	instanceOf: { value: assertInstanceOf },
-	is: { value: assertIs },
-	property: { value: assertProperty }
-});
 //#endregion
 //#region src/function/once.ts
+const ONCE_NAME_ASYNC = "asyncOnce";
+const ONCE_NAME_SYNC = "once";
+const ONCE_PROPERTY = "$once";
+function AsyncOnce(callback) {
+	this[ONCE_SYMBOL] = {
+		callback,
+		called: false,
+		cleared: false,
+		error: false,
+		finished: false,
+		items: [],
+		value: void 0
+	};
+}
+AsyncOnce.prototype[ONCE_PROPERTY] = ONCE_NAME_ASYNC;
+AsyncOnce.prototype.clear = clearOnce;
+AsyncOnce.prototype.run = runOnceAsync;
+Object.defineProperties(AsyncOnce.prototype, {
+	called: {
+		enumerable: true,
+		get: getOnceCalled
+	},
+	cleared: {
+		enumerable: true,
+		get: getOnceCleared
+	},
+	error: {
+		enumerable: true,
+		get: getAsyncOnceError
+	},
+	finished: {
+		enumerable: true,
+		get: getAsyncOnceFinished
+	}
+});
+function Once(callback) {
+	this[ONCE_SYMBOL] = {
+		callback,
+		called: false,
+		cleared: false,
+		value: void 0
+	};
+}
+Once.prototype[ONCE_PROPERTY] = ONCE_NAME_SYNC;
+Once.prototype.clear = clearOnce;
+Once.prototype.run = runOnce;
+Object.defineProperties(Once.prototype, {
+	called: {
+		enumerable: true,
+		get: getOnceCalled
+	},
+	cleared: {
+		enumerable: true,
+		get: getOnceCleared
+	}
+});
 /**
 * Create an asynchronous function that can only be called once, rejecting or resolving the same result on subsequent calls
 *
@@ -1823,62 +1869,27 @@ Object.defineProperties(assert, {
 */
 function asyncOnce(callback) {
 	assert(() => typeof callback === "function", ONCE_MESSAGE_EXPECTATION);
-	const state = {
-		called: false,
-		cleared: false,
-		error: false,
-		finished: false,
-		items: [],
-		value: void 0
-	};
-	const fn = (...parameters) => {
-		if (state.cleared) return Promise.reject(new Error(ONCE_MESSAGE_CLEARED));
-		if (state.finished) return state.error ? Promise.reject(state.value) : Promise.resolve(state.value);
-		if (state.called) return new Promise((resolve, reject) => {
-			state.items.push({
-				reject,
-				resolve
-			});
-		});
-		state.called = true;
-		return new Promise((resolve, reject) => {
-			state.items.push({
-				reject,
-				resolve
-			});
-			callback(...parameters).then((value) => {
-				handleOnceResult(state, value, false);
-			}).catch((error) => {
-				handleOnceResult(state, error, true);
-			});
-		});
-	};
-	Object.defineProperties(fn, {
-		called: {
-			enumerable: true,
-			get: () => state.called
-		},
-		clear: { value: () => clearState(state) },
-		cleared: {
-			enumerable: true,
-			get: () => state.cleared
-		},
-		error: {
-			enumerable: true,
-			get: () => state.error
-		},
-		finished: {
-			enumerable: true,
-			get: () => state.finished
-		}
-	});
-	return fn;
+	return new AsyncOnce(callback);
 }
-function clearState(state) {
+function clearOnce() {
+	const state = this[ONCE_SYMBOL];
 	if (!state.called || state.cleared) return;
+	state.callback = void 0;
 	state.cleared = true;
 	state.value = void 0;
 }
+function getAsyncOnceError() {
+	return this[ONCE_SYMBOL].error;
+}
+function getAsyncOnceFinished() {
+	return this[ONCE_SYMBOL].finished;
+}
+function getOnceCalled() {
+	return this[ONCE_SYMBOL].called;
+}
+function getOnceCleared() {
+	return this[ONCE_SYMBOL].cleared;
+}
 function handleOnceResult(state, value, error) {
 	state.error = error;
 	state.finished = true;
@@ -1892,6 +1903,27 @@ function handleOnceResult(state, value, error) {
 	}
 }
 /**
+* Is the value an asynchronous once callback?
+*
+* @param value Value to check
+* @returns `true` if the value is an asynchronous once callback, otherwise `false`
+*/
+function isAsyncOnce(value) {
+	return isOnceInstance(value, ONCE_NAME_ASYNC);
+}
+/**
+* Is the value a once callback?
+*
+* @param value Value to check
+* @returns `true` if the value is a once callback, otherwise `false`
+*/
+function isOnce(value) {
+	return isOnceInstance(value, ONCE_NAME_SYNC);
+}
+function isOnceInstance(value, name) {
+	return typeof value === "object" && value !== null && ONCE_PROPERTY in value && value[ONCE_PROPERTY] === name;
+}
+/**
 * Create a function that can only be called once, returning the same value on subsequent calls
 *
 * @param callback Callback to use once
@@ -1899,35 +1931,46 @@ function handleOnceResult(state, value, error) {
 */
 function once(callback) {
 	assert(() => typeof callback === "function", ONCE_MESSAGE_EXPECTATION);
-	const state = {
-		called: false,
-		cleared: false,
-		value: void 0
-	};
-	const fn = (...parameters) => {
-		if (state.cleared) throw new Error(ONCE_MESSAGE_CLEARED);
-		if (state.called) return state.value;
-		state.called = true;
-		state.value = callback(...parameters);
-		return state.value;
-	};
-	Object.defineProperties(fn, {
-		called: {
-			enumerable: true,
-			get: () => state.called
-		},
-		clear: { value: () => clearState(state) },
-		cleared: {
-			enumerable: true,
-			get: () => state.cleared
-		}
+	return new Once(callback);
+}
+function runOnce(...parameters) {
+	const state = this[ONCE_SYMBOL];
+	if (state.cleared) throw new Error(ONCE_MESSAGE_CLEARED);
+	if (state.called) return state.value;
+	state.called = true;
+	state.value = state.callback(...parameters);
+	return state.value;
+}
+function runOnceAsync(...parameters) {
+	const state = this[ONCE_SYMBOL];
+	if (state.cleared) return Promise.reject(new Error(ONCE_MESSAGE_CLEARED));
+	if (state.finished) return state.error ? Promise.reject(state.value) : Promise.resolve(state.value);
+	if (state.called) return new Promise((resolve, reject) => {
+		state.items.push({
+			reject,
+			resolve
+		});
+	});
+	state.called = true;
+	return new Promise((resolve, reject) => {
+		state.items.push({
+			reject,
+			resolve
+		});
+		state.callback(...parameters).then((value) => {
+			handleOnceResult(state, value, false);
+		}).catch((error) => {
+			handleOnceResult(state, error, true);
+		});
 	});
-	return fn;
 }
 const ONCE_MESSAGE_CLEARED = "Once has been cleared";
 const ONCE_MESSAGE_EXPECTATION = "Once expected a function";
+const ONCE_SYMBOL = Symbol(ONCE_PROPERTY);
+asyncOnce.is = isAsyncOnce;
 once.async = asyncOnce;
-Object.defineProperty(once, "async", { value: asyncOnce });
+once.is = isOnce;
+once.isAsync = isAsyncOnce;
 //#endregion
 //#region src/function/retry.ts
 /**
@@ -1960,12 +2003,12 @@ async function asyncRetry(callback, options) {
 			if (attempts >= times || !when(error)) rejector(new RetryError(RETRY_MESSAGE_FAILED, error));
 			else {
 				attempts += 1;
-				timer();
+				limiter.run();
 			}
 		}
 	}
 	const { delay, times, when } = createRetryOptions(options);
-	const timer = getTimer(TIMER_WAIT, handle, delay);
+	const limiter = getLimiter(LIMITER_WAIT, handle, delay);
 	let attempts = 0;
 	let rejector;
 	let resolver;
@@ -2011,7 +2054,6 @@ const RETRY_ERROR_NAME = "RetryError";
 const RETRY_MESSAGE_EXPECTATION = "Retry expected a function";
 const RETRY_MESSAGE_FAILED = "Retry failed";
 retry.async = asyncRetry;
-Object.defineProperty(retry, "async", { value: asyncRetry });
 //#endregion
 //#region src/internal/function/work.ts
 function asyncFlow(...fns) {
@@ -2072,8 +2114,6 @@ const assertFlowFunctions = assert.condition((value) => Array.isArray(value) &&
 const assertPipeFunctions = assert.condition((value) => Array.isArray(value) && value.every((item) => typeof item === "function"), WORK_MESSAGE_PIPE_ARRAY, TypeError);
 flow.async = asyncFlow;
 pipe.async = asyncPipe;
-Object.defineProperty(flow, "async", { value: asyncFlow });
-Object.defineProperty(pipe, "async", { value: asyncPipe });
 //#endregion
 //#region src/internal/number.ts
 /**
@@ -2211,6 +2251,44 @@ var SizedMap = class extends Map {
 };
 //#endregion
 //#region src/internal/function/memoize.ts
+function Memoized(callback, options) {
+	this[MEMOIZED_SYMBOL] = {
+		options,
+		cache: new SizedMap(options.cacheSize),
+		getter: void 0
+	};
+	this[MEMOIZED_SYMBOL].getter = createGetter(this[MEMOIZED_SYMBOL], callback);
+}
+Memoized.prototype.clear = clearMemoized;
+Memoized.prototype.delete = deleteMemoizedValue;
+Memoized.prototype.get = getMemoizedValue;
+Memoized.prototype.has = hasMemoizedValue;
+Memoized.prototype.run = runMemoized;
+Object.defineProperties(Memoized.prototype, {
+	maximum: {
+		enumerable: true,
+		get: getMemoizedMaximum
+	},
+	size: {
+		enumerable: true,
+		get: getMemoizedSize
+	}
+});
+function clearMemoized() {
+	this[MEMOIZED_SYMBOL].cache.clear();
+}
+function deleteMemoizedValue(key) {
+	return this[MEMOIZED_SYMBOL].cache.delete(key);
+}
+function createGetter(state, callback) {
+	return (...parameters) => {
+		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);
+		return value;
+	};
+}
 function createMemoizationOptions(input) {
 	const { cacheKey, cacheSize } = isPlainObject(input) ? input : {};
 	return {
@@ -2218,6 +2296,18 @@ function createMemoizationOptions(input) {
 		cacheSize: getNumberOrDefault(cacheSize, MEMOIZED_CACHE_SIZE_DEFAULT)
 	};
 }
+function getMemoizedMaximum() {
+	return this[MEMOIZED_SYMBOL].cache.maximum;
+}
+function getMemoizedSize() {
+	return this[MEMOIZED_SYMBOL].cache.size;
+}
+function getMemoizedValue(key) {
+	return this[MEMOIZED_SYMBOL].cache.get(key);
+}
+function hasMemoizedValue(key) {
+	return this[MEMOIZED_SYMBOL].cache.has(key);
+}
 /**
 * Memoize a function, caching and retrieving results based on the first parameter
 *
@@ -2227,41 +2317,15 @@ function createMemoizationOptions(input) {
 */
 function memoize(callback, options) {
 	if (typeof callback !== "function") throw new TypeError(MEMOIZED_CALLBACK);
-	const state = {
-		cache: void 0,
-		getter: void 0,
-		options: createMemoizationOptions(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), MEMOIZED_KEY_SEPARATOR));
-		if (state.cache.has(key)) return state.cache.get(key);
-		const value = callback(...parameters);
-		state.cache.set(key, value);
-		return value;
-	};
-	const instance = {
-		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
-		},
-		size: {
-			enumerable: true,
-			get: () => state.cache.size
-		}
-	});
-	return Object.freeze(instance);
+	return new Memoized(callback, createMemoizationOptions(options));
+}
+function runMemoized(...parameters) {
+	return this[MEMOIZED_SYMBOL].getter(...parameters);
 }
 const MEMOIZED_CACHE_SIZE_DEFAULT = 1024;
 const MEMOIZED_CALLBACK = "Memoized requires a callback function";
 const MEMOIZED_KEY_SEPARATOR = "_";
+const MEMOIZED_SYMBOL = Symbol("memoized");
 //#endregion
 //#region src/internal/string/case.ts
 /**
@@ -2399,6 +2463,15 @@ let memoizedTitleCase;
 let memoizedUpperCase;
 //#endregion
 //#region src/internal/value/equal.ts
+function Equalizer(options) {
+	this[EQUAL_SYMBOL] = options;
+}
+Equalizer.prototype.compare = compare$1;
+Equalizer.prototype.deregister = deregisterEqualizer;
+Equalizer.prototype.register = registerEqualizer;
+function compare$1(first, second) {
+	return equalValue(first, second, this[EQUAL_SYMBOL]);
+}
 function createEqualOptions(input) {
 	const options = {
 		ignoreCase: false,
@@ -2433,7 +2506,7 @@ function createEqualOptions(input) {
 * @param constructor Class constructor
 */
 function deregisterEqualizer(constructor) {
-	equal.handlers.deregister(constructor);
+	equalHandler.base.deregister(constructor);
 }
 function filterKey(key, options) {
 	if (typeof key !== "string") return true;
@@ -2444,10 +2517,6 @@ function filterKey(key, options) {
 function equal(first, second, options) {
 	return equalValue(first, second, createEqualOptions(options));
 }
-equal.handlers = createCompareHandlers(equal, { callback: Object.is });
-equal.deregister = deregisterEqualizer;
-equal.initialize = initializeEqualizer;
-equal.register = registerEqualizer;
 function equalArray(first, second, options) {
 	const { length } = first;
 	if (length !== second.length) return false;
@@ -2536,7 +2605,7 @@ function equalValue(first, second, options) {
 		case Array.isArray(first) && Array.isArray(second): return equalArray(first, second, options);
 		case isPlainObject(first) && isPlainObject(second): return equalPlainObject(first, second, options);
 		case isTypedArray(first) && isTypedArray(second): return equalTypedArray(first, second);
-		default: return equal.handlers.handle(first, second, options);
+		default: return equalHandler.handle(first, second, options);
 	}
 }
 /**
@@ -2548,11 +2617,7 @@ function equalValue(first, second, options) {
 * @returns Equalizer function
 */
 function initializeEqualizer(options) {
-	const actual = createEqualOptions(options);
-	const equalizer = (first, second) => equalValue(first, second, actual);
-	equalizer.deregister = deregisterEqualizer;
-	equalizer.register = registerEqualizer;
-	return equalizer;
+	return new Equalizer(createEqualOptions(options));
 }
 /**
 * Register a equality comparison function for a specific class
@@ -2563,13 +2628,19 @@ function initializeEqualizer(options) {
 * @param handler Comparison function
 */
 function registerEqualizer(constructor, handler) {
-	equal.handlers.register(constructor, handler);
+	equalHandler.base.register(constructor, handler);
 }
 const EQUAL_ARRAY_PEEK_PERCENTAGE = 10;
 const EQUAL_ARRAY_THRESHOLD = 100;
 const EQUAL_ERROR_PROPERTIES = ["name", "message"];
 const EQUAL_EXPRESSION_PROPERTIES = ["source", "flags"];
 const EQUAL_MINIMUM_LENGTH_FOR_SET = 16;
+const EQUAL_SYMBOL = Symbol("equal");
+const equalHandler = createCompareHandler(equal, { callback: Object.is });
+equal.deregister = deregisterEqualizer;
+equal.handler = equalHandler;
+equal.initialize = initializeEqualizer;
+equal.register = registerEqualizer;
 //#endregion
 //#region src/internal/value/get.ts
 function getValue(data, path, ignoreCase) {
@@ -2594,7 +2665,7 @@ function setValue(data, path, value, ignoreCase) {
 			handleValue(target, currentPath, value, false, shouldIgnoreCase);
 			break;
 		}
-		let next = handleValue(target, currentPath, null, true, shouldIgnoreCase).value;
+		let next = unwrap(handleValue(target, currentPath, null, true, shouldIgnoreCase), void 0);
 		if (typeof next !== "object" || next === null) {
 			const nextPath = paths[index + 1];
 			if (SET_EXPRESSION_INDEX.test(nextPath)) next = Array.from({ length: Number(nextPath) + 1 }, () => void 0);
@@ -2607,7 +2678,7 @@ function setValue(data, path, value, ignoreCase) {
 }
 const SET_EXPRESSION_INDEX = /^\d+$/;
 //#endregion
-//#region src/internal/abort.ts
+//#region src/internal/aborter.ts
 function createAborter(value, onAbort) {
 	if (!(value instanceof AbortSignal)) return;
 	value.addEventListener(ABORT_EVENT, onAbort, ABORT_OPTIONS);
@@ -2674,7 +2745,7 @@ function createPromiseOptions(input) {
 		signal: input,
 		time: 0
 	};
-	const options = typeof input === "object" && input !== null ? input : {};
+	const options = isPlainObject(input) ? input : {};
 	return {
 		signal: options.signal instanceof AbortSignal ? options.signal : void 0,
 		time: getNumberOrDefault(options.time, 0)
@@ -2686,7 +2757,7 @@ function createPromisesOptions(input) {
 		signal: input,
 		strategy: PROMISE_STRATEGY_DEFAULT
 	};
-	const options = typeof input === "object" && input !== null ? input : {};
+	const options = isPlainObject(input) ? input : {};
 	return {
 		signal: options.signal instanceof AbortSignal ? options.signal : void 0,
 		strategy: getStrategyOrDefault(options.strategy)
@@ -2725,7 +2796,7 @@ function isRejected(value) {
 	return isType(value, PROMISE_TYPE_REJECTED);
 }
 function isType(value, type) {
-	return typeof value === "object" && value !== null && value.status === type;
+	return isPlainObject(value) && "status" in value && value.status === type;
 }
 //#endregion
 //#region src/result/misc.ts
@@ -2785,34 +2856,34 @@ function delay(options) {
 	const { signal, time } = createPromiseOptions(options);
 	if (signal?.aborted ?? false) return Promise.reject(signal?.reason);
 	const aborter = createAborter(signal, () => {
-		timer.cancel();
+		limiter.cancel();
 		rejector(signal?.reason);
 	});
-	const timer = getTimer(TIMER_WAIT, () => settlePromise(resolver, void 0, aborter), time);
+	const limiter = getLimiter(LIMITER_WAIT, () => settlePromise(resolver, void 0, aborter), time);
 	let rejector;
 	let resolver;
 	return new Promise((resolve, reject) => {
 		rejector = reject;
 		resolver = resolve;
 		if (time === 0) settlePromise(resolver, void 0, aborter);
-		else timer();
+		else limiter.run();
 	});
 }
 //#endregion
 //#region src/promise/timed.ts
 async function getTimedPromise(promise, time, signal) {
 	const aborter = createAborter(signal, () => {
-		timer.cancel();
+		limiter.cancel();
 		rejector(signal?.reason);
 	});
-	const timer = getTimer(TIMER_WAIT, () => settlePromise(rejector, new PromiseTimeoutError(), aborter), time);
+	const limiter = getLimiter(LIMITER_WAIT, () => settlePromise(rejector, new PromiseTimeoutError(), aborter), time);
 	let rejector;
 	return Promise.race([promise, new Promise((_, reject) => {
 		rejector = reject;
-		timer();
+		limiter.run();
 	})]).then((value) => {
 		aborter?.cancel();
-		timer.cancel();
+		limiter.cancel();
 		rejector(void 0);
 		return value;
 	});
@@ -2895,7 +2966,6 @@ async function resultPromises(items, signal) {
 	return promises(items, signal).then(getResultsFromPromises);
 }
 promises.result = resultPromises;
-Object.defineProperty(promises, "result", { value: resultPromises });
 //#endregion
 //#region src/result/index.ts
 async function asyncAttempt(value, err) {
@@ -2915,7 +2985,6 @@ function attempt(callback, err) {
 	}
 }
 attempt.async = asyncAttempt;
-Object.defineProperty(attempt, "async", { value: asyncAttempt });
 //#endregion
 //#region src/result/match.ts
 async function asyncMatchResult(result, first, error) {
@@ -2941,7 +3010,6 @@ function matchResult(result, first, error) {
 }
 const MATCH_MESSAGE = "`result.match` expected a Result or a function that returns a Result";
 matchResult.async = asyncMatchResult;
-Object.defineProperty(matchResult, "async", { value: asyncMatchResult });
 //#endregion
 //#region src/result/work/flow.ts
 function attemptAsyncFlow(...fns) {
@@ -2965,7 +3033,6 @@ 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) {
@@ -2985,7 +3052,6 @@ function attemptPipe(initial, first, ...seconds) {
 	});
 }
 attemptPipe.async = attemptAsyncPipe;
-Object.defineProperty(attemptPipe, "async", { value: attemptAsyncPipe });
 //#endregion
 //#region src/string/match.ts
 /**
@@ -3035,6 +3101,27 @@ const MATCH_STARTS_WITH = "startsWith";
 const matchMemoizers = {};
 //#endregion
 //#region src/string/fuzzy.ts
+const FUZZY_PROPERTY = "$fuzzy";
+const FUZZY_SYMBOL = Symbol(FUZZY_PROPERTY);
+function Fuzzy(state) {
+	this[FUZZY_SYMBOL] = state;
+}
+Fuzzy.prototype[FUZZY_PROPERTY] = true;
+Fuzzy.prototype.search = search;
+Object.defineProperties(Fuzzy.prototype, {
+	items: {
+		enumerable: true,
+		get: getFuzzyItems,
+		set: setFuzzyItems
+	},
+	strings: {
+		enumerable: true,
+		get: getFuzzyStrings
+	}
+});
+function createFuzzyItems(items) {
+	return items.sort((first, second) => first.haystack.localeCompare(second.haystack)).map(({ item }) => item);
+}
 function createFuzzyOptions(input, state) {
 	const options = isPlainObject(input) ? input : {};
 	const limit = typeof input === "number" ? input : options.limit;
@@ -3054,43 +3141,13 @@ function createFuzzyState(items, input) {
 		tolerance: options.tolerance
 	};
 }
-function getHandler(input) {
-	if (input == null || input === getString) return getString;
-	switch (typeof input) {
-		case "function": return input;
-		case "string": return (item) => item[input];
-		default:
-			if (isPlainObject(input)) return getHandler(input.key ?? input.handler);
-			throw new TypeError(FUZZY_MESSAGE_HANDLER);
-	}
-}
-function getFuzzyItems(items) {
-	return items.sort((first, second) => first.haystack.localeCompare(second.haystack)).map(({ item }) => item);
-}
-function getTolerance(input, state) {
-	if (typeof input === "number" && !Number.isNaN(input)) return input < 0 ? 0 : Math.floor(input);
-	return state?.tolerance ?? FUZZY_PROXIMITY_THRESHOLD;
-}
 function fuzzy(items, configuration) {
 	if (!Array.isArray(items)) throw new TypeError(FUZZY_MESSAGE_ARRAY);
-	const state = createFuzzyState(items, configuration);
-	const instance = { search: (value, options) => search(state.items, state.strings, value, options == null ? state : createFuzzyOptions(options, state)) };
-	Object.defineProperties(instance, {
-		items: {
-			enumerable: true,
-			get: () => state.items.slice(),
-			set: (value) => setItems(state, value)
-		},
-		strings: {
-			enumerable: true,
-			get: () => state.strings.slice()
-		}
-	});
-	return Object.freeze(instance);
+	return new Fuzzy(createFuzzyState(items, configuration));
 }
 /**
 * Does the needle match the haystack in a fuzzy way?
-* 
+*
 * _Available as `fuzzyMatch` and `fuzzy.match`_
 *
 * @param haystack Haystack to search through
@@ -3103,17 +3160,21 @@ function fuzzyMatch(haystack, needle) {
 	if (includes(haystack, trimmed, true)) return true;
 	return getScore(haystack, trimmed) > -1;
 }
-function isSubsequence(haystack, needle) {
-	const lowerCaseHaystack = lowerCase(haystack);
-	const lowerCaseNeedle = lowerCase(needle);
-	const haystackLength = lowerCaseHaystack.length;
-	const needleLength = lowerCaseNeedle.length;
-	let needleIndex = 0;
-	for (let haystackIndex = 0; haystackIndex < haystackLength; haystackIndex += 1) {
-		if (lowerCaseHaystack[haystackIndex] === lowerCaseNeedle[needleIndex]) needleIndex += 1;
-		if (needleIndex === needleLength) return true;
+function getHandler(input) {
+	if (input == null || input === getString) return getString;
+	switch (typeof input) {
+		case "function": return input;
+		case "string": return (item) => item[input];
+		default:
+			if (isPlainObject(input)) return getHandler(input.key ?? input.handler);
+			throw new TypeError(FUZZY_MESSAGE_HANDLER);
 	}
-	return false;
+}
+function getFuzzyItems() {
+	return this[FUZZY_SYMBOL].items.slice();
+}
+function getFuzzyStrings() {
+	return this[FUZZY_SYMBOL].strings.slice();
 }
 function getScore(haystack, needle) {
 	if (!isSubsequence(haystack, needle)) return -1;
@@ -3139,26 +3200,55 @@ function getScore(haystack, needle) {
 	score -= Math.floor(lowerCaseHaystack.length / FUZZY_LENGTH_DIVISOR);
 	return Math.max(0, score);
 }
-function search(items, strings, input, options) {
-	const result = {
-		exact: [],
-		similar: []
-	};
-	const value = typeof input === "string" ? input.trim() : "";
-	if (value.length === 0) {
-		result.exact = items.slice(0, options.limit);
-		return result;
-	}
-	let { length } = items;
-	const exact = [];
-	const similar = [];
-	const scored = {};
-	for (let index = 0; index < length; index += 1) {
-		const item = items[index];
-		const haystack = strings[index];
-		if (includes(haystack, value, true)) {
-			exact.push({
-				item,
+function getTolerance(input, state) {
+	if (typeof input === "number" && !Number.isNaN(input)) return input < 0 ? 0 : Math.floor(input);
+	return state?.tolerance ?? FUZZY_PROXIMITY_THRESHOLD;
+}
+/**
+* Is the value a fuzzy searcher?
+*
+* _Available as `isFuzzy` and `fuzzy.is`_
+*
+* @param value Value to check
+* @returns `true` if the value is a fuzzy searcher, otherwise `false`
+*/
+function isFuzzy(value) {
+	return typeof value === "object" && value !== null && FUZZY_PROPERTY in value && value[FUZZY_PROPERTY] === true;
+}
+function isSubsequence(haystack, needle) {
+	const lowerCaseHaystack = lowerCase(haystack);
+	const lowerCaseNeedle = lowerCase(needle);
+	const haystackLength = lowerCaseHaystack.length;
+	const needleLength = lowerCaseNeedle.length;
+	let needleIndex = 0;
+	for (let haystackIndex = 0; haystackIndex < haystackLength; haystackIndex += 1) {
+		if (lowerCaseHaystack[haystackIndex] === lowerCaseNeedle[needleIndex]) needleIndex += 1;
+		if (needleIndex === needleLength) return true;
+	}
+	return false;
+}
+function search(input, option) {
+	const state = this[FUZZY_SYMBOL];
+	const options = option == null ? state : createFuzzyOptions(option, state);
+	const result = {
+		exact: [],
+		similar: []
+	};
+	const value = typeof input === "string" ? input.trim() : "";
+	if (value.length === 0) {
+		result.exact = state.items.slice(0, options.limit);
+		return result;
+	}
+	let { length } = state.items;
+	const exact = [];
+	const similar = [];
+	const scored = {};
+	for (let index = 0; index < length; index += 1) {
+		const item = state.items[index];
+		const haystack = state.strings[index];
+		if (includes(haystack, value, true)) {
+			exact.push({
+				item,
 				haystack
 			});
 			continue;
@@ -3179,16 +3269,17 @@ 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(...getFuzzyItems(scored[key]));
+			similar.push(...createFuzzyItems(scored[key]));
 		}
 	}
-	result.exact = getFuzzyItems(options.limit == null ? exact : exact.slice(0, options.limit));
+	result.exact = createFuzzyItems(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;
 }
-function setItems(state, value) {
+function setFuzzyItems(value) {
 	if (!Array.isArray(value)) throw new TypeError(FUZZY_MESSAGE_ARRAY);
+	const state = this[FUZZY_SYMBOL];
 	state.items = value.slice();
 	state.strings = value.map(state.handler);
 }
@@ -3196,8 +3287,8 @@ 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;
+fuzzy.is = isFuzzy;
 fuzzy.match = fuzzyMatch;
-Object.defineProperty(fuzzy, "match", { value: fuzzyMatch });
 //#endregion
 //#region src/string/index.ts
 function dedent(value, ...values) {
@@ -3294,6 +3385,10 @@ const STRING_NUMERICAL_PREFIX_PATTERN = /^\d/;
 const STRING_ZERO = "0";
 //#endregion
 //#region src/string/normalize.ts
+function Normalizer(options) {
+	this[NORMALIZE_SYMBOL] = options;
+}
+Normalizer.prototype.normalize = normalizeString;
 function createNormalizeOptions(input) {
 	const options = isPlainObject(input) ? input : {};
 	return {
@@ -3328,8 +3423,7 @@ function deburr(value) {
 * @returns Normalizer function
 */
 function initializeNormalizer(options) {
-	const normalization = createNormalizeOptions(options);
-	return (value) => normalizeString(value, normalization);
+	return new Normalizer(createNormalizeOptions(options));
 }
 /**
 * Normalize a string
@@ -3341,10 +3435,11 @@ function initializeNormalizer(options) {
 * @returns Normalized string
 */
 function normalize(value, options) {
-	return normalizeString(value, createNormalizeOptions(options));
+	return normalizeString.call(createNormalizeOptions(options), value);
 }
-function normalizeString(value, options) {
+function normalizeString(value) {
 	if (typeof value !== "string") return "";
+	const options = NORMALIZE_SYMBOL in this ? this[NORMALIZE_SYMBOL] : this;
 	let result = value;
 	if (options.trim) result = result.trim();
 	if (options.whitespace) result = result.replace(NORMALIZE_WHITESPACE_PATTERN, NORMALIZE_WHITESPACE_REPLACEMENT);
@@ -3391,13 +3486,17 @@ 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_SYMBOL = Symbol("normalize");
 const NORMALIZE_WHITESPACE_PATTERN = /\s+/g;
 const NORMALIZE_WHITESPACE_REPLACEMENT = " ";
 let deburrMemoizer;
 normalize.initialize = initializeNormalizer;
-Object.defineProperty(normalize, "initialize", { value: initializeNormalizer });
 //#endregion
 //#region src/string/template.ts
+function Templater(options) {
+	this[TEMPLATE_SYMBOL] = options;
+}
+Templater.prototype.render = render;
 function createTemplateOptions(input) {
 	const options = isPlainObject(input) ? input : {};
 	return {
@@ -3431,10 +3530,12 @@ function handleTemplate(value, pattern, ignoreCase, variables) {
 * @returns _Templater_ function
 */
 function initializeTemplater(options) {
-	const { ignoreCase, pattern } = createTemplateOptions(options);
-	return ((value, ...parameters) => {
-		return isTemplateStringsArray(value) ? (variables) => handleTemplate(interpolate(value, parameters), pattern, ignoreCase, variables) : handleTemplate(value, pattern, ignoreCase, parameters[0]);
-	});
+	return new Templater(createTemplateOptions(options));
+}
+function render(value, ...parameters) {
+	const { ignoreCase, pattern } = this[TEMPLATE_SYMBOL];
+	if (isTemplateStringsArray(value)) return (variables) => handleTemplate(interpolate(value, parameters), pattern, ignoreCase, variables);
+	return handleTemplate(value, pattern, ignoreCase, parameters[0]);
 }
 function template(value, ...parameters) {
 	if (isTemplateStringsArray(value)) return getRenderer(value, parameters);
@@ -3442,11 +3543,17 @@ function template(value, ...parameters) {
 	return handleTemplate(value, pattern, ignoreCase, parameters[0]);
 }
 const TEMPLATE_EXPRESSION_VARIABLE = /{{([\s\S]+?)}}/g;
+const TEMPLATE_SYMBOL = Symbol("template");
 template.initialize = initializeTemplater;
-Object.defineProperty(template, "initialize", { value: initializeTemplater });
 //#endregion
 //#region src/value/clone.ts
 const CLONE_NAME = "clone";
+function Cloner(options) {
+	this[CLONE_SYMBOL] = options;
+}
+Cloner.prototype.clone = cloneFromCloner;
+Cloner.prototype.deregister = deregisterCloner;
+Cloner.prototype.register = registerCloner;
 function clone(value, options) {
 	return cloneAny(value, { copy: false }, 0, options);
 }
@@ -3490,6 +3597,12 @@ function cloneDataView(value, parameters, depth) {
 	parameters.references.set(value, cloned);
 	return cloned;
 }
+function cloneFromCloner(value) {
+	return cloneAny(value, {
+		copy: false,
+		options: this[CLONE_SYMBOL]
+	}, 0);
+}
 function cloneMap(map, parameters, depth) {
 	if (depth >= CLONE_MAX_DEPTH) return map;
 	if (parameters.copy) return new Map(map);
@@ -3561,7 +3674,7 @@ function createCloneOptions(input) {
 * @param constructor Class constructor
 */
 function deregisterCloner(constructor) {
-	clone.handlers.deregister(constructor);
+	cloneHandler.base.deregister(constructor);
 }
 /**
 * Create a cloner with predefined options
@@ -3572,20 +3685,7 @@ function deregisterCloner(constructor) {
 * @returns Cloner function
 */
 function initializeCloner(options) {
-	const opts = createCloneOptions(options);
-	function cloner(value) {
-		return cloneAny(value, {
-			copy: false,
-			options: opts
-		}, 0);
-	}
-	cloner.deregister = deregisterCloner;
-	cloner.register = registerCloner;
-	Object.defineProperties(cloner, {
-		deregister: { value: deregisterCloner },
-		register: { value: registerCloner }
-	});
-	return cloner;
+	return new Cloner(createCloneOptions(options));
 }
 /**
 * Register a clone handler for a specific class
@@ -3596,7 +3696,7 @@ function initializeCloner(options) {
 * @param handler Method name or clone function _(defaults to method name `clone`)_
 */
 function registerCloner(constructor, handler) {
-	clone.handlers.register(constructor, handler);
+	cloneHandler.base.register(constructor, handler);
 }
 function tryStructuredClone(value, parameters, depth) {
 	if (depth >= CLONE_MAX_DEPTH) return value;
@@ -3618,7 +3718,7 @@ const CLONE_DEFAULT_OPTIONS = {
 	copySymbols: false
 };
 const CLONE_MAX_DEPTH = 100;
-const cloneHandlers = createSelfHandlers(clone, {
+const cloneHandler = createValueHandler(clone, {
 	callback: tryStructuredClone,
 	method: CLONE_NAME
 });
@@ -3632,16 +3732,11 @@ const CLONE_PRIMITIVES = {
 	symbol: false,
 	undefined: true
 };
+const CLONE_SYMBOL = Symbol(CLONE_NAME);
 clone.deregister = deregisterCloner;
-clone.handlers = cloneHandlers;
+clone.handlers = cloneHandler;
 clone.initialize = initializeCloner;
 clone.register = registerCloner;
-Object.defineProperties(clone, {
-	deregister: { value: deregisterCloner },
-	handlers: { value: cloneHandlers },
-	initialize: { value: initializeCloner },
-	register: { value: registerCloner }
-});
 //#endregion
 //#region src/value/collection.ts
 function inMap(map, value, key) {
@@ -3834,7 +3929,7 @@ function freezeValue(value, references, flat) {
 }
 /**
 * Is the value frozen?
-* 
+*
 * _Available as `isFrozen` and `freeze.is`_
 *
 * @param value Value to check
@@ -3847,14 +3942,10 @@ function isFrozen(value) {
 const frozenValues = /* @__PURE__ */ new WeakSet();
 freeze.flat = flatFreeze;
 freeze.is = isFrozen;
-Object.defineProperties(freeze, {
-	flat: { value: flatFreeze },
-	is: { value: isFrozen }
-});
 //#endregion
 //#region src/internal/value/partial.ts
 function partial(value, providedKeys, omit) {
-	if (typeof value !== "object" || value === null) return {};
+	if (!isPlainObject(value)) return {};
 	const keys = omit ? Object.keys(value) : Array.isArray(providedKeys) ? providedKeys : [];
 	const { length } = keys;
 	if (length === 0) return omit ? value : {};
@@ -3983,6 +4074,17 @@ function unsmush(value) {
 }
 //#endregion
 //#region src/value/merge.ts
+function Assigner(options) {
+	this[MERGE_SYMBOL_ASSIGN] = {
+		...options,
+		assignValues: true
+	};
+}
+Assigner.prototype.assign = assignFromAssigner;
+function Merger(options) {
+	this[MERGE_SYMBOL_MERGE] = options;
+}
+Merger.prototype.merge = mergeFromMerger;
 /**
 * Assign values from one or more objects to the first one
 *
@@ -3996,6 +4098,9 @@ function assign(to, from, options) {
 	actual.assignValues = true;
 	return mergeValues([to, ...from], actual);
 }
+function assignFromAssigner(to, from) {
+	return mergeValues([to, ...from], this[MERGE_SYMBOL_ASSIGN]);
+}
 function createMergeOptions(options) {
 	const actual = {
 		assignValues: false,
@@ -4024,9 +4129,7 @@ function getReplaceableObjects(value) {
 * @returns Assigner function
 */
 function initializeAssigner(options) {
-	const actual = createMergeOptions(options);
-	actual.assignValues = true;
-	return ((to, from) => mergeValues([to, ...from], actual));
+	return new Assigner(createMergeOptions(options));
 }
 /**
 * Create a merger with predefined options
@@ -4037,8 +4140,7 @@ function initializeAssigner(options) {
 * @returns Merger function
 */
 function initializeMerger(options) {
-	const actual = createMergeOptions(options);
-	return ((values) => mergeValues(values, actual));
+	return new Merger(createMergeOptions(options));
 }
 /**
 * Merge multiple arrays or objects into a single one
@@ -4050,6 +4152,9 @@ function initializeMerger(options) {
 function merge(values, options) {
 	return mergeValues(values, createMergeOptions(options));
 }
+function mergeFromMerger(values) {
+	return mergeValues(values, this[MERGE_SYMBOL_MERGE]);
+}
 function mergeObjects(values, options, destination, prefix) {
 	const { length } = values;
 	const isArray = Array.isArray(destination ?? values[0]);
@@ -4079,13 +4184,17 @@ function mergeValues(values, options, prefix) {
 	if (actual.length > 1) return mergeObjects(actual, options, options.assignValues ? actual[0] : void 0, prefix);
 	return options.assignValues ? actual[0] : Array.isArray(actual[0]) ? actual[0].slice() : { ...actual[0] };
 }
+const MERGE_SYMBOL_ASSIGN = Symbol("assign");
+const MERGE_SYMBOL_MERGE = Symbol("merge");
 assign.initialize = initializeAssigner;
 merge.initialize = initializeMerger;
-Object.defineProperty(assign, "initialize", { value: initializeAssigner });
-Object.defineProperty(merge, "initialize", { value: initializeMerger });
 //#endregion
 //#region src/value/transform.ts
-function getTransformer(input) {
+function Transformer(transformer) {
+	this[TRANSFORM_SYMBOL] = transformer;
+}
+Object.defineProperties(Transformer.prototype, { transform: { value: transformValue } });
+function getTransformHandler(input) {
 	if (typeof input === "function") return input;
 	if (isNonPlainObject(input)) return;
 	const keys = Object.keys(input);
@@ -4096,18 +4205,18 @@ function getTransformer(input) {
 		const value = input[key];
 		if (typeof value === "function") transformer[key] = value;
 	}
-	if (Object.keys(transformer).length > 0) return transformer;
+	return Object.keys(transformer).length > 0 ? transformer : void 0;
 }
 function initializeTransformer(transform) {
-	const transformer = getTransformer(transform);
-	return (value) => transformValue(value, transformer);
+	return new Transformer(getTransformHandler(transform));
 }
 function transform(value, transform) {
-	return transformValue(value, getTransformer(transform));
+	return transformValue.call(getTransformHandler(transform), value);
 }
-function transformValue(value, transformer) {
+function transformValue(value) {
 	if (isNonPlainObject(value)) return {};
-	if (transformer == null) return value;
+	if (this == null) return value;
+	const transformer = TRANSFORM_SYMBOL in this ? this[TRANSFORM_SYMBOL] : this;
 	const keys = Object.keys(value);
 	const { length } = keys;
 	for (let index = 0; index < length; index += 1) {
@@ -4118,17 +4227,50 @@ function transformValue(value, transformer) {
 	}
 	return value;
 }
+const TRANSFORM_SYMBOL = Symbol("transform");
 transform.initialize = initializeTransformer;
-Object.defineProperty(transform, "initialize", { value: initializeTransformer });
 //#endregion
 //#region src/internal/subscription.ts
-function addSubscription(subscriptions, subscription, state) {
-	const { items, values } = subscriptions;
+const SUBSCRIPTION_NAME = "subscription";
+const SUBSCRIPTION_PROPERTY = "$subscription";
+const SUBSCRIPTION_STORE = "subscriptions";
+function Subscription(state, property, parameters) {
+	this[SUBSCRIPTION_SYMBOL] = state;
+	this[property.key] = property.value;
+	state.aborter = createAborter(parameters.signal, () => this.unsubscribe(subscriptions, this, state));
+	addSubscription(this);
+}
+Subscription.prototype[SUBSCRIPTION_PROPERTY] = SUBSCRIPTION_NAME;
+Subscription.prototype.unsubscribe = removeSubscription;
+Object.defineProperty(Subscription.prototype, "active", {
+	enumerable: true,
+	get: getSubscriptionActive
+});
+function Subscriptions(parameters) {
+	const { keys, property } = createSubscriptionsParameters(parameters);
+	this[SUBSCRIPTION_SYMBOL] = createSubscriptionsState(property, keys);
+}
+Subscriptions.prototype[SUBSCRIPTION_PROPERTY] = SUBSCRIPTION_STORE;
+Subscriptions.prototype.clear = clearSubscriptions;
+Subscriptions.prototype.create = createSubscription;
+Object.defineProperties(Subscriptions.prototype, {
+	items: {
+		enumerable: true,
+		get: getSubscriptionsItems
+	},
+	values: {
+		enumerable: true,
+		get: getSubscriptionsValues
+	}
+});
+function addSubscription(instance) {
+	const state = instance[SUBSCRIPTION_SYMBOL];
 	const { key, value } = state.parameters;
+	const { items, values } = state.subscriptions;
 	if (!isKey(key)) {
-		items.any.add(subscription);
-		values.from.any.set(value, subscription);
-		values.to.any.set(subscription, value);
+		items.any.add(instance);
+		values.from.any.set(value, instance);
+		values.to.any.set(instance, value);
 		return;
 	}
 	/* istanbul ignore if */
@@ -4140,29 +4282,32 @@ function addSubscription(subscriptions, subscription, state) {
 		keyedItems = /* @__PURE__ */ new Set();
 		items.keyed.set(key, keyedItems);
 	}
-	keyedItems.add(subscription);
+	keyedItems.add(instance);
 	let keyedFrom = values.from.keyed.get(key);
 	if (keyedFrom == null) {
 		keyedFrom = /* @__PURE__ */ new Map();
 		values.from.keyed.set(key, keyedFrom);
 	}
-	keyedFrom.set(value, subscription);
+	keyedFrom.set(value, instance);
 	let keyedTo = values.to.keyed.get(key);
 	if (keyedTo == null) {
 		keyedTo = /* @__PURE__ */ new Map();
 		values.to.keyed.set(key, keyedTo);
 	}
-	keyedTo.set(subscription, value);
+	keyedTo.set(instance, value);
 }
-function clearSubscriptions(store) {
-	for (const susbcription of store.values.to.any.keys()) susbcription.unsubscribe();
-	if (store.values.to.keyed != null) for (const values of store.values.to.keyed.values()) for (const susbcription of values.keys()) susbcription.unsubscribe();
+function clearSubscriptions() {
+	const state = this[SUBSCRIPTION_SYMBOL];
+	for (const susbcription of state.values.to.any.keys()) susbcription.unsubscribe();
+	if (state.values.to.keyed != null && state.values.to.keyed.size > 0) for (const values of state.values.to.keyed.values()) for (const susbcription of values.keys()) susbcription.unsubscribe();
 }
-function createSubscription(subscriptions, property, params) {
+function createSubscription(params) {
 	const parameters = createSubscriptionParameters(params);
 	if (parameters.signal?.aborted ?? false) throw new Error(parameters.signal?.reason);
+	const subscriptions = this[SUBSCRIPTION_SYMBOL];
 	const state = {
 		parameters,
+		subscriptions,
 		active: true
 	};
 	const existing = getExistingSubscription(subscriptions, state);
@@ -4171,24 +4316,23 @@ function createSubscription(subscriptions, property, params) {
 		if (subscriptions.keys === false) throw new Error(SUBSCRIPTION_DISALLOWED_KEY);
 		else if (subscriptions.keys !== true && !subscriptions.keys.has(parameters.key)) throw new Error(SUBSCRIPTION_INVALID_KEY);
 	}
-	state.aborter = createAborter(parameters.signal, () => unsubscribe(subscriptions, instance, state));
-	const instance = { unsubscribe: () => unsubscribe(subscriptions, instance, state) };
-	Object.defineProperties(instance, {
-		[SUBSCRIPTION_PROPERTY]: { value: SUBSCRIPTION_NAME },
-		[property.key]: { value: property.value },
-		active: {
-			enumerable: true,
-			get: () => (parameters.isActive?.() ?? true) && state.active
-		}
-	});
-	addSubscription(subscriptions, instance, state);
-	return [Object.freeze(instance), false];
+	return [new Subscription(state, subscriptions.property, parameters), false];
 }
 function getExistingSubscription(subscriptions, state) {
 	const { values } = subscriptions;
 	const { parameters } = state;
 	return isKey(parameters.key) ? values.from.keyed?.get(parameters.key)?.get(parameters.value) : values.from.any.get(parameters.value);
 }
+function getSubscriptionActive() {
+	const state = this[SUBSCRIPTION_SYMBOL];
+	return (state.parameters?.isActive?.() ?? true) && state.active;
+}
+function getSubscriptionsItems() {
+	return this[SUBSCRIPTION_SYMBOL].items;
+}
+function getSubscriptionsValues() {
+	return this[SUBSCRIPTION_SYMBOL].values;
+}
 function createSubscriptionParameters(input) {
 	const values = isPlainObject(input) ? input : {};
 	if (values.value == null) throw new Error(SUBSCRIPTION_INVALID_VALUE);
@@ -4216,9 +4360,10 @@ function createSubscriptionsProperty(input) {
 		value: values.value == null ? SUBSCRIPTION_NAME : values.value
 	};
 }
-function createSubscriptionsState(keys) {
+function createSubscriptionsState(property, keys) {
 	return {
 		keys,
+		property,
 		items: {
 			any: /* @__PURE__ */ new Set(),
 			keyed: keys === false ? void 0 : /* @__PURE__ */ new Map()
@@ -4245,7 +4390,7 @@ function isSubscription(value) {
 	return isSubscriptionInstance(value, SUBSCRIPTION_NAME);
 }
 function isSubscriptionInstance(value, name) {
-	return isPlainObject(value) && SUBSCRIPTION_PROPERTY in value && value[SUBSCRIPTION_PROPERTY] === name;
+	return typeof value === "object" && value !== null && SUBSCRIPTION_PROPERTY in value && value[SUBSCRIPTION_PROPERTY] === name;
 }
 /**
 * Is the value a subscriptions store?
@@ -4266,16 +4411,17 @@ function removeFromStore(items, values, subscription, value, key) {
 		values.to.keyed?.get(key)?.delete(subscription);
 	}
 }
-function removeSubscription(subscriptionsState, subscription, state) {
+function removeSubscription() {
+	const state = this[SUBSCRIPTION_SYMBOL];
 	if (!state.active) return;
 	state.aborter = void 0;
 	state.active = false;
-	state.parameters.isActive = void 0;
-	state.parameters.signal = void 0;
-	const { items, values } = subscriptionsState;
+	const { items, values } = state.subscriptions;
 	const { key, value } = state.parameters;
+	state.parameters = void 0;
+	state.subscriptions = void 0;
 	if (!isKey(key)) {
-		removeFromStore(items.any, values, subscription, value);
+		removeFromStore(items.any, values, this, value);
 		return;
 	}
 	const keyed = items.keyed?.get(key);
@@ -4283,7 +4429,7 @@ function removeSubscription(subscriptionsState, subscription, state) {
 	if (items.keyed == null || keyed == null)
  // istanbul ignore next
 	return;
-	removeFromStore(keyed, values, subscription, value, key);
+	removeFromStore(keyed, values, this, value, key);
 	if (keyed.size === 0) items.keyed.delete(key);
 }
 /**
@@ -4293,37 +4439,56 @@ function removeSubscription(subscriptionsState, subscription, state) {
 * @returns Subscription store
 */
 function subscriptions(parameters) {
-	const { keys, property } = createSubscriptionsParameters(parameters);
-	const state = createSubscriptionsState(keys);
-	const instance = {
-		clear: () => clearSubscriptions(state),
-		create: (parameters) => createSubscription(state, property, parameters)
-	};
-	Object.defineProperties(instance, {
-		[SUBSCRIPTION_PROPERTY]: { value: SUBSCRIPTION_STORE },
-		items: {
-			enumerable: true,
-			value: state.items
-		},
-		values: {
-			enumerable: true,
-			value: state.values
-		}
-	});
-	return Object.freeze(instance);
-}
-function unsubscribe(subscriptionsState, subscription, state) {
-	state.aborter?.cancel();
-	removeSubscription(subscriptionsState, subscription, state);
+	return new Subscriptions(parameters);
 }
 const SUBSCRIPTION_DISALLOWED_KEY = "Disallowed key for subscription";
 const SUBSCRIPTION_INVALID_KEY = "Invalid key for subscription";
 const SUBSCRIPTION_INVALID_VALUE = "A subscription requires a non-null value to identify it";
-const SUBSCRIPTION_NAME = "subscription";
-const SUBSCRIPTION_PROPERTY = "$subscriptions";
-const SUBSCRIPTION_STORE = "subscriptions";
+const SUBSCRIPTION_SYMBOL = Symbol(SUBSCRIPTION_PROPERTY);
 //#endregion
 //#region src/beacon.ts
+const BEACON_PROPERTY = "$beacon";
+const BEACON_NAME = "beacon";
+const BEACON_OBSERVABLE = "observable";
+function Beacon(value, options) {
+	this[BEACON_SYMBOL] = {
+		value,
+		active: true,
+		options: createBeaconOptions(options)
+	};
+}
+Beacon.prototype[BEACON_PROPERTY] = BEACON_NAME;
+Beacon.prototype.deactivate = deactivateBeacon;
+Beacon.prototype.emit = emitBeaconValue;
+Beacon.prototype.error = emitBeaconError;
+Beacon.prototype.finish = finishBeacon;
+Object.defineProperties(Beacon.prototype, {
+	active: {
+		enumerable: true,
+		get: getBeaconActive
+	},
+	observable: {
+		enumerable: true,
+		get: getBeaconObservable
+	},
+	value: {
+		enumerable: true,
+		get: getBeaconValue
+	}
+});
+function Observable(beacon) {
+	this[BEACON_SYMBOL] = {
+		beacon,
+		active: beacon.active
+	};
+}
+Observable.prototype[BEACON_PROPERTY] = BEACON_OBSERVABLE;
+Observable.prototype.deactivate = deactiveateObservable;
+Observable.prototype.subscribe = subscribeToObservable;
+Object.defineProperty(Observable.prototype, "active", {
+	enumerable: true,
+	get: getObservableActive
+});
 /**
 * Create a new beacon
 *
@@ -4332,60 +4497,22 @@ const SUBSCRIPTION_STORE = "subscriptions";
 * @returns Beacon instance
 */
 function beacon(value, options) {
-	const state = {
-		value,
-		active: true,
-		observable: void 0,
-		options: createBeaconOptions(options),
-		subscriptions: subscriptions({ property: beaconSubscription })
-	};
-	const instance = {
-		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, {
-		[BEACON_PROPERTY]: { value: BEACON_NAME },
-		active: {
-			enumerable: true,
-			get: () => state.active
-		},
-		observable: {
-			enumerable: true,
-			get: () => getObservable(state)
-		},
-		value: {
-			enumerable: true,
-			get: () => state.value
-		}
-	});
-	return Object.freeze(instance);
+	return new Beacon(value, options);
+}
+function closeBeacon(state, emit) {
+	if (!state.active) return;
+	state.active = false;
+	const subscriptions = state.subscriptions?.values.to.any;
+	if (subscriptions != null && subscriptions.size > 0) {
+		for (const [, observer] of subscriptions) if (emit) observer.complete?.();
+	}
+	state.subscriptions?.clear();
+	state.observable?.deactivate();
+	state.observable = void 0;
 }
 function createBeaconOptions(input) {
 	const options = isPlainObject(input) ? input : {};
-	options.equal = typeof options.equal === "function" ? options.equal : Object.is;
-	return options;
-}
-function createObservable(beacon) {
-	const state = {
-		beacon,
-		active: beacon.active
-	};
-	const instance = {
-		deactivate: () => {
-			state.active = false;
-		},
-		subscribe: (first, second, third) => subscribeToObservable(state, first, second, third)
-	};
-	Object.defineProperties(instance, {
-		[BEACON_PROPERTY]: { value: BEACON_OBSERVABLE },
-		active: {
-			enumerable: true,
-			get: () => beacon.active && state.active
-		}
-	});
-	return Object.freeze(instance);
+	return { equal: typeof options.equal === "function" ? options.equal : Object.is };
 }
 function createObserver(first, second, third) {
 	let observer = { next: noop };
@@ -4395,25 +4522,44 @@ function createObserver(first, second, third) {
 		complete: getObservableCallback(third)
 	};
 	else if (typeof first === "object") {
-		observer.complete = getObservableCallback(first?.complete);
-		observer.error = getObservableCallback(first?.error);
-		observer.next = getObservableCallback(first?.next);
+		const object = first;
+		observer.complete = getObservableCallback(object?.complete);
+		observer.error = getObservableCallback(object?.error);
+		observer.next = getObservableCallback(object?.next);
 	}
 	return observer;
 }
-function finishBeacon(state, emit) {
-	if (!state.active) return;
-	state.active = false;
-	for (const [, observer] of state.subscriptions.values.to.any) if (emit) observer.complete?.();
-	state.subscriptions.clear();
-	state.observable?.deactivate();
-	state.observable = void 0;
+function deactivateBeacon() {
+	closeBeacon(this[BEACON_SYMBOL], false);
+}
+function deactiveateObservable() {
+	this[BEACON_SYMBOL].active = false;
+}
+function emitBeaconError(error, finish) {
+	updateBeacon(this, BEACON_TYPE_ERROR, error, finish ?? false);
+}
+function emitBeaconValue(value, finish) {
+	updateBeacon(this, BEACON_TYPE_NEXT, value, finish ?? false);
+}
+function finishBeacon() {
+	closeBeacon(this[BEACON_SYMBOL], true);
 }
-function getObservable(state) {
+function getBeaconActive() {
+	return this[BEACON_SYMBOL].active;
+}
+function getBeaconObservable() {
+	const state = this[BEACON_SYMBOL];
 	if (!state.active) throw new Error(BEACON_MESSAGE_RETRIEVE);
-	state.observable ??= createObservable(state);
+	state.observable ??= new Observable(state);
 	return state.observable;
 }
+function getBeaconValue() {
+	return this[BEACON_SYMBOL].value;
+}
+function getObservableActive() {
+	const state = this[BEACON_SYMBOL];
+	return state.beacon.active && state.active;
+}
 function getObservableCallback(value) {
 	return typeof value === "function" ? value : noop;
 }
@@ -4427,7 +4573,7 @@ function isBeacon(value) {
 	return isBeaconInstance(BEACON_NAME, value);
 }
 function isBeaconInstance(name, value) {
-	return isPlainObject(value) && value[BEACON_PROPERTY] === name;
+	return typeof value === "object" && value !== null && BEACON_PROPERTY in value && value[BEACON_PROPERTY] === name;
 }
 /**
 * Is the value a beacon subscription?
@@ -4447,8 +4593,10 @@ function isBeaconSubscription(value) {
 function isObservable(value) {
 	return isBeaconInstance(BEACON_OBSERVABLE, value);
 }
-function subscribeToObservable(state, first, second, third) {
+function subscribeToObservable(first, second, third) {
+	const state = this[BEACON_SYMBOL];
 	if (!state.beacon.active || !state.active) throw new Error(BEACON_MESSAGE_SUBSCRIBE);
+	state.beacon.subscriptions ??= subscriptions({ property: beaconSubscription });
 	const observer = createObserver(first, second, third);
 	const [subscription] = state.beacon.subscriptions.create({
 		isActive: () => state.beacon.active && state.active,
@@ -4457,20 +4605,20 @@ function subscribeToObservable(state, first, second, third) {
 	observer.next?.(state.beacon.value);
 	return subscription;
 }
-function updateBeacon(type, state, value, finish) {
+function updateBeacon(instance, type, value, finish) {
+	const state = instance[BEACON_SYMBOL];
 	if (!state.active) return;
 	if (type === BEACON_TYPE_NEXT) {
 		if (state.options.equal(state.value, value)) return;
 		state.value = value;
 	}
-	for (const [, observer] of state.subscriptions.values.to.any) observer[type]?.(value);
-	if (finish === true) finishBeacon(state, true);
+	const subscriptions = state.subscriptions?.values.to.any;
+	if (subscriptions != null && subscriptions.size > 0) for (const [, observer] of subscriptions) observer[type]?.(value);
+	if (finish === true) closeBeacon(state, true);
 }
 const BEACON_MESSAGE_RETRIEVE = "Cannot retrieve observable from a closed beacon";
 const BEACON_MESSAGE_SUBSCRIBE = "Cannot subscribe to a closed observable";
-const BEACON_PROPERTY = "$beacon";
-const BEACON_NAME = "beacon";
-const BEACON_OBSERVABLE = "observable";
+const BEACON_SYMBOL = Symbol(BEACON_PROPERTY);
 const BEACON_TYPE_ERROR = "error";
 const BEACON_TYPE_NEXT = "next";
 const beaconSubscription = {
@@ -4479,11 +4627,30 @@ const beaconSubscription = {
 };
 //#endregion
 //#region src/internal/herald.ts
-function createEvents(herald, state) {
-	const events = {};
-	Object.defineProperty(events, HERALD_PROPERTY, { value: HERALD_NAME_EVENTS });
-	for (const key of state.keys) events[key] = (callback, signal) => herald.subscribe(key, callback, signal);
-	return Object.freeze(events);
+const HERALD_NAME_EVENTS = "events";
+const HERALD_NAME_HERALD = "herald";
+const HERALD_PROPERTY = "$herald";
+function Events(herald, state) {
+	for (const key of state.keys) Object.defineProperty(this, key, { value: (callback, signal) => herald.subscribe(key, callback, signal) });
+}
+Events.prototype[HERALD_PROPERTY] = HERALD_NAME_EVENTS;
+function Herald(state) {
+	this[HERALD_SYMBOL] = {
+		state,
+		events: new Events(this, state)
+	};
+}
+Herald.prototype[HERALD_PROPERTY] = HERALD_NAME_HERALD;
+Herald.prototype.clear = clearHerald;
+Herald.prototype.emit = emitForHerald;
+Herald.prototype.observed = eventIsObserved;
+Herald.prototype.subscribe = subscribeToHerald;
+Object.defineProperty(Herald.prototype, "events", {
+	enumerable: true,
+	get: getHeraldEvents
+});
+function clearHerald() {
+	this[HERALD_SYMBOL].state.store.clear();
 }
 function createHeraldState(input) {
 	const options = isPlainObject(input) ? input : {};
@@ -4508,11 +4675,18 @@ function createHeraldSubscriptionProperty(input) {
 		value: property.value
 	};
 }
-function emitForHerald(state, event, ...parameters) {
+function emitForHerald(event, ...parameters) {
+	const { state } = this[HERALD_SYMBOL];
 	const items = state.store.values.from.keyed?.get(event);
 	if (items == null || items.size === 0) return;
 	for (const [callback] of items) callback(...parameters);
 }
+function eventIsObserved(event) {
+	return (this[HERALD_SYMBOL].state.store.items.keyed?.get(event)?.size ?? 0) > 0;
+}
+function getHeraldEvents() {
+	return this[HERALD_SYMBOL].events;
+}
 /**
 * Create a _Herald_ for announcing named events
 *
@@ -4521,21 +4695,7 @@ function emitForHerald(state, event, ...parameters) {
 * @returns _Herald_ instance
 */
 function herald(options) {
-	const state = createHeraldState(options);
-	const instance = {
-		clear: () => state.store.clear(),
-		emit: (event, ...parameters) => emitForHerald(state, event, ...parameters),
-		observed: (event) => (state.store.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);
+	return new Herald(createHeraldState(options));
 }
 /**
 * Is the value a herald?
@@ -4556,7 +4716,7 @@ function isHeraldEvents(value) {
 	return isHeraldInstance(HERALD_NAME_EVENTS, value);
 }
 function isHeraldInstance(name, value) {
-	return isPlainObject(value) && HERALD_PROPERTY in value && value[HERALD_PROPERTY] === name;
+	return typeof value === "object" && value !== null && HERALD_PROPERTY in value && value[HERALD_PROPERTY] === name;
 }
 /**
 * Is the value a herald subscription?
@@ -4565,9 +4725,10 @@ function isHeraldInstance(name, value) {
 * @returns `true` if the value is a herald subscription, otherwise `false`
 */
 function isHeraldSubscription(value) {
-	return isSubscription(value) && value[HERALD_PROPERTY] === "subscription";
+	return isSubscription(value) && HERALD_PROPERTY in value && value[HERALD_PROPERTY] === "subscription";
 }
-function subscribeToHerald(state, key, callback, signal) {
+function subscribeToHerald(key, callback, signal) {
+	const { state } = this[HERALD_SYMBOL];
 	const [subscription, existing] = state.store.create({
 		key,
 		signal,
@@ -4576,12 +4737,10 @@ function subscribeToHerald(state, key, callback, signal) {
 	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 HERALD_SYMBOL = Symbol(HERALD_PROPERTY);
 const heraldSubscription = {
 	key: HERALD_PROPERTY,
 	value: SUBSCRIPTION_NAME
@@ -4656,7 +4815,9 @@ const COLOR_MAX = {
 	hex: 255,
 	percent: 100
 };
-const COLOR_PROPERTY = { name: "$color" };
+const COLOR_NAME = "color";
+const COLOR_PROPERTY = "$color";
+const COLOR_SYMBOL = Symbol(COLOR_PROPERTY);
 const COLOR_TYPE = {
 	all: void 0,
 	hex: "hex",
@@ -4691,6 +4852,10 @@ const COLOR_SRGB = {
 	luminanceRed: .2126,
 	luminanceThreshold: .625
 };
+const colorSubscription = {
+	key: COLOR_PROPERTY,
+	value: SUBSCRIPTION_NAME
+};
 //#endregion
 //#region src/internal/math/misc.ts
 /**
@@ -4720,6 +4885,9 @@ function getAlpha(value, hex) {
 	};
 	return getAlphaFromValue(Number.parseFloat(value));
 }
+function getColorAlpha() {
+	return this[COLOR_SYMBOL].values.alpha.value;
+}
 function getAlphaHexadecimal(value) {
 	if (value === COLOR_ALPHA.noneValue) return COLOR_ALPHA.noneHex;
 	if (value === COLOR_MAX.percent) return COLOR_ALPHA.fullHexLong;
@@ -4736,6 +4904,9 @@ function getAlphaValue(original) {
 	if (Number.isNaN(original)) return COLOR_MAX.percent;
 	return clamp(original, COLOR_ALPHA.noneValue, COLOR_MAX.percent);
 }
+function setColorAlpha(value) {
+	if (typeof value === "number" && !Number.isNaN(value)) this[COLOR_SYMBOL].values.alpha = getAlpha(value, false);
+}
 //#endregion
 //#region src/color/misc/get.ts
 function getClampedValue(value, minimum, maximum, rounding) {
@@ -4893,13 +5064,14 @@ function isBytey(value) {
 * @returns `true` if the value is a _Color_, otherwise `false`
 */
 function isColor(value) {
-	return isPlainObject(value) && COLOR_PROPERTY.name in value && value[COLOR_PROPERTY.name] === true;
+	return typeof value === "object" && value !== null && "$color" in value && value["$color"] === "color";
 }
-function isColorValue(obj, properties) {
-	if (typeof obj !== "object" || obj === null) return false;
-	const keys = Object.keys(obj);
+function isColorValue(value, properties) {
+	if (typeof value !== "object" || value === null) return false;
+	const keys = Object.keys(value);
 	const { length } = keys;
 	if (length !== properties.length) return false;
+	const obj = value;
 	for (let index = 0; index < length; index += 1) {
 		const key = keys[index];
 		if (!(properties.includes(key) && validators[key](obj[key]))) return false;
@@ -5027,7 +5199,7 @@ function convertRgbToHex(rgb, alpha) {
 	return `${hex}${a}`;
 }
 function convertRgbToHsla(value) {
-	const values = getRgbValues(isRgbLike(value) ? getRgbValue(value) : { ...COLOR_DEFAULTS.rgb });
+	const values = getRgbCalculationValues(isRgbLike(value) ? getRgbValues(value) : { ...COLOR_DEFAULTS.rgb });
 	const { delta, max, min } = values;
 	const lightness = (min + max) / 2;
 	let hue = 0;
@@ -5045,7 +5217,7 @@ function convertRgbToHsla(value) {
 	};
 }
 function convertRgbToHwba(value) {
-	const values = getRgbValues(isRgbLike(value) ? getRgbValue(value) : { ...COLOR_DEFAULTS.rgb });
+	const values = getRgbCalculationValues(isRgbLike(value) ? getRgbValues(value) : { ...COLOR_DEFAULTS.rgb });
 	const { delta, max, min } = values;
 	let hue = 0;
 	if (delta !== 0) {
@@ -5071,22 +5243,7 @@ function getColorFromRgb(state, type) {
 	}
 	return state[type];
 }
-function getRgbHue(values) {
-	const { blue, delta, green, max, red } = values;
-	switch (max) {
-		case blue: return (red - green) / delta + 4;
-		case green: return (blue - red) / delta + 2;
-		default: return (green - blue) / delta + (green < blue ? 6 : 0);
-	}
-}
-function getRgbValue(value) {
-	return {
-		blue: getHexValue(value.blue),
-		green: getHexValue(value.green),
-		red: getHexValue(value.red)
-	};
-}
-function getRgbValues(rgb) {
+function getRgbCalculationValues(rgb) {
 	const blue = rgb.blue / COLOR_MAX.hex;
 	const green = rgb.green / COLOR_MAX.hex;
 	const red = rgb.red / COLOR_MAX.hex;
@@ -5101,6 +5258,27 @@ function getRgbValues(rgb) {
 		red
 	};
 }
+function getRgbColor$1() {
+	return getStateValue(this, COLOR_TYPE.rgb, false);
+}
+function getRgbaColor$1() {
+	return getStateValue(this, COLOR_TYPE.rgb, true);
+}
+function getRgbHue(values) {
+	const { blue, delta, green, max, red } = values;
+	switch (max) {
+		case blue: return (red - green) / delta + 4;
+		case green: return (blue - red) / delta + 2;
+		default: return (green - blue) / delta + (green < blue ? 6 : 0);
+	}
+}
+function getRgbValues(value) {
+	return {
+		blue: getHexValue(value.blue),
+		green: getHexValue(value.green),
+		red: getHexValue(value.red)
+	};
+}
 /**
 * Convert an _RGB(A)_ color to a hex color _(with optional alpha channel, i.e., opacity)_
 *
@@ -5111,7 +5289,7 @@ function getRgbValues(rgb) {
 * @returns Hex color string
 */
 function rgbToHex(rgb, alpha) {
-	return convertRgbToHex(isRgbLike(rgb) ? getRgbValue(rgb) : { ...COLOR_DEFAULTS.rgb }, alpha ?? false);
+	return convertRgbToHex(isRgbLike(rgb) ? getRgbValues(rgb) : { ...COLOR_DEFAULTS.rgb }, alpha ?? false);
 }
 /**
 * Convert an _RGB(A)_ color to an _HSL_ color
@@ -5175,6 +5353,20 @@ function rgbToHwb(rgb) {
 function rgbToHwba(rgb) {
 	return convertRgbToHwba(rgb);
 }
+function setRgbValue(value) {
+	setRgbColorValueInState(this, value, false);
+}
+function setRgbColorValueInState(instance, value, alpha) {
+	if (!isRgbLike(value)) return;
+	setStateValue(instance, COLOR_TYPE.rgb, {
+		red: getHexValue(value.red),
+		green: getHexValue(value.green),
+		blue: getHexValue(value.blue)
+	}, alpha ? value.alpha : void 0);
+}
+function setRgbaValue(value) {
+	setRgbColorValueInState(this, value, true);
+}
 //#endregion
 //#region src/color/space/hex.ts
 function convertHexToRgba(value) {
@@ -5202,6 +5394,12 @@ function getColorFromHex(state, type) {
 	}
 	return state[type];
 }
+function getHexColor$1() {
+	return getStateValue(this, COLOR_TYPE.hex, false);
+}
+function getHexaColor$1() {
+	return getStateValue(this, COLOR_TYPE.hex, true);
+}
 /**
 * Get the normalized hex color from a value
 *
@@ -5299,10 +5497,22 @@ function hexToRgb(value) {
 function hexToRgba(value) {
 	return convertHexToRgba(value);
 }
+function setHexValue(value) {
+	setHexValueInState(this, value, false);
+}
+function setHexValueInState(instance, value, alpha) {
+	const { values } = instance[COLOR_SYMBOL];
+	if (!isHexColor(value) || !alpha && value === values.hex) return;
+	const normalized = getNormalizedHex(value, true);
+	setStateValue(instance, COLOR_TYPE.hex, normalized.slice(0, COLOR_LENGTHS.hexLong), alpha ? normalized.slice(COLOR_LENGTHS.hexLong) : void 0);
+}
+function setHexaValue(value) {
+	setHexValueInState(this, value, true);
+}
 //#endregion
 //#region src/color/space/hsl.ts
 function convertHslToHwba(input) {
-	let { hue, lightness, saturation } = isHslLike(input) ? getHslValue(input) : { ...COLOR_DEFAULTS.hsl };
+	let { hue, lightness, saturation } = isHslLike(input) ? getHslValues(input) : { ...COLOR_DEFAULTS.hsl };
 	lightness /= COLOR_MAX.percent;
 	saturation /= COLOR_MAX.percent;
 	const value = lightness + saturation * Math.min(lightness, 1 - lightness);
@@ -5317,7 +5527,7 @@ function convertHslToHwba(input) {
 	};
 }
 function convertHslToRgba(input) {
-	const hsl = isHslLike(input) ? getHslValue(input) : { ...COLOR_DEFAULTS.hsl };
+	const hsl = isHslLike(input) ? getHslValues(input) : { ...COLOR_DEFAULTS.hsl };
 	const hue = hsl.hue % COLOR_MAX.degree;
 	const saturation = hsl.saturation / COLOR_MAX.percent;
 	const lightness = hsl.lightness / COLOR_MAX.percent;
@@ -5344,7 +5554,13 @@ function getHexyValue(hue, lightness, saturation, value) {
 	const part = (value + hue / 30) % 12;
 	return (lightness - saturation * Math.min(lightness, 1 - lightness) * Math.max(-1, Math.min(part - 3, 9 - part, 1))) * COLOR_MAX.hex;
 }
-function getHslValue(value) {
+function getHslValue() {
+	return getStateValue(this, COLOR_TYPE.hsl, false);
+}
+function getHslaValue() {
+	return getStateValue(this, COLOR_TYPE.hsl, true);
+}
+function getHslValues(value) {
 	return {
 		hue: getDegrees(value.hue),
 		saturation: getPercentage(value.saturation),
@@ -5421,10 +5637,24 @@ function hslToRgb(hsl) {
 function hslToRgba(hsl) {
 	return convertHslToRgba(hsl);
 }
+function setHslValue(value) {
+	setHSLValueInState(this, value, false);
+}
+function setHSLValueInState(instance, value, alpha) {
+	if (!isHslLike(value)) return;
+	setStateValue(instance, COLOR_TYPE.hsl, {
+		hue: getDegrees(value.hue),
+		saturation: getPercentage(value.saturation),
+		lightness: getPercentage(value.lightness)
+	}, alpha ? value.alpha : void 0);
+}
+function setHslaValue(value) {
+	setHSLValueInState(this, value, true);
+}
 //#endregion
 //#region src/color/space/hwb.ts
 function convertHwbToHsl(input) {
-	let { blackness, hue, whiteness } = isHwbLike(input) ? getHwbValue(input) : COLOR_DEFAULTS.hwb;
+	let { blackness, hue, whiteness } = isHwbLike(input) ? getHwbValues(input) : COLOR_DEFAULTS.hwb;
 	blackness /= COLOR_MAX.percent;
 	whiteness /= COLOR_MAX.percent;
 	if (blackness + whiteness > 1) {
@@ -5457,7 +5687,13 @@ function getHwbSaturation(blackness, whiteness, lightness) {
 	if (hue <= 0) return 0;
 	return hue / Math.min(2 * lightness, 2 - 2 * lightness);
 }
-function getHwbValue(value) {
+function getHwbValue() {
+	return getStateValue(this, COLOR_TYPE.hwb, false);
+}
+function getHwbaValue() {
+	return getStateValue(this, COLOR_TYPE.hwb, true);
+}
+function getHwbValues(value) {
 	return {
 		hue: getDegrees(value.hue),
 		whiteness: getPercentage(value.whiteness),
@@ -5525,6 +5761,20 @@ function hwbToRgb(hwb) {
 function hwbToRgba(hwb) {
 	return hslToRgba(hwbToHsla(hwb));
 }
+function setHwbValue(value) {
+	setHwbColorValueInState(this, value, false);
+}
+function setHwbColorValueInState(instance, value, alpha) {
+	if (!isHwbLike(value)) return;
+	setStateValue(instance, COLOR_TYPE.hwb, {
+		hue: getDegrees(value.hue),
+		whiteness: getPercentage(value.whiteness),
+		blackness: getPercentage(value.blackness)
+	}, alpha ? value.alpha : void 0);
+}
+function setHwbaValue(value) {
+	setHwbColorValueInState(this, value, true);
+}
 //#endregion
 //#region src/color/misc/state.ts
 function getColorFromState(state, type) {
@@ -5548,13 +5798,13 @@ function getColorState(value) {
 			origin: void 0
 		};
 		if (COLOR_KEYS.hsl.every((key) => key in value)) {
-			state.hsl = getHslValue(value);
+			state.hsl = getHslValues(value);
 			state.origin = COLOR_TYPE.hsl;
 		} else if (COLOR_KEYS.hwb.every((key) => key in value)) {
-			state.hwb = getHwbValue(value);
+			state.hwb = getHwbValues(value);
 			state.origin = COLOR_TYPE.hwb;
 		} else if (COLOR_KEYS.rgb.every((key) => key in value)) {
-			state.rgb = getRgbValue(value);
+			state.rgb = getRgbValues(value);
 			state.origin = COLOR_TYPE.rgb;
 		}
 		if (state.origin != null) return state;
@@ -5579,45 +5829,26 @@ function getDefaultColorState() {
 		origin: COLOR_TYPE.hex
 	};
 }
-function setColorValue(color, state, changes, type, value, alpha) {
-	state.hex = void 0;
-	state.hsl = void 0;
-	state.hwb = void 0;
-	state.rgb = void 0;
-	state.origin = type;
-	state[type] = value;
-	if (alpha != null) state.alpha = getAlpha(alpha, type === COLOR_TYPE.hex);
-	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, changes, value, alpha) {
-	if (!isHexColor(value) || !alpha && value === state.hex) return;
-	const normalized = getNormalizedHex(value, true);
-	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, changes, value, alpha) {
-	if (!isHslLike(value)) return;
-	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 getStateValue(instance, type, alpha) {
+	const { values } = instance[COLOR_SYMBOL];
+	const value = getColorFromState(values, type);
+	if (typeof value === "string") return alpha ? `${value}${values.alpha.hex}` : value;
+	return alpha ? {
+		...value,
+		alpha: values.alpha.value
+	} : { ...value };
 }
-function setHWBColor(color, state, changes, value, alpha) {
-	if (!isHwbLike(value)) return;
-	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, changes, value, alpha) {
-	if (!isRgbLike(value)) return;
-	setColorValue(color, state, changes, COLOR_TYPE.rgb, {
-		red: getHexValue(value.red),
-		green: getHexValue(value.green),
-		blue: getHexValue(value.blue)
-	}, alpha ? value.alpha : void 0);
+function setStateValue(instance, type, value, alpha) {
+	const { changes, values } = instance[COLOR_SYMBOL];
+	values.hex = void 0;
+	values.hsl = void 0;
+	values.hwb = void 0;
+	values.rgb = void 0;
+	values.origin = type;
+	values[type] = value;
+	if (alpha != null) values.alpha = getAlpha(alpha, type === COLOR_TYPE.hex);
+	for (const type of COLOR_TYPE.all) if (changes.observed(type)) changes.emit(type, instance[type]);
+	changes.emit(COLOR_TYPE.wildcard, instance);
 }
 const getters = {
 	hex: getColorFromHex,
@@ -5627,83 +5858,110 @@ const getters = {
 };
 //#endregion
 //#region src/color/misc/format.ts
-function formatHexColor(color, alpha) {
-	return `#${alpha === true ? color.hexa : color.hex}`;
+function formatHexColor(alpha) {
+	return `#${alpha === true ? this.hexa : this.hex}`;
 }
-function formatHslColor(state, alpha) {
-	const { hue, lightness, saturation } = getColorFromState(state, COLOR_TYPE.hsl);
-	return `hsl(${hue}deg ${saturation}% ${lightness}%${getSuffix(state, alpha)})`;
+function formatHslColor(alpha) {
+	const { values } = this[COLOR_SYMBOL];
+	const { hue, lightness, saturation } = getColorFromState(values, COLOR_TYPE.hsl);
+	return `hsl(${hue}deg ${saturation}% ${lightness}%${getSuffix(values, alpha)})`;
 }
-function formatHwbColor(state, alpha) {
-	const { blackness, hue, whiteness } = getColorFromState(state, COLOR_TYPE.hwb);
-	return `hwb(${hue}deg ${whiteness}% ${blackness}%${getSuffix(state, alpha)})`;
+function formatHwbColor(alpha) {
+	const { values } = this[COLOR_SYMBOL];
+	const { blackness, hue, whiteness } = getColorFromState(values, COLOR_TYPE.hwb);
+	return `hwb(${hue}deg ${whiteness}% ${blackness}%${getSuffix(values, alpha)})`;
 }
-function formatRgbColor(state, alpha) {
-	const { blue, green, red } = getColorFromState(state, COLOR_TYPE.rgb);
-	return `rgb(${red} ${green} ${blue}${getSuffix(state, alpha)})`;
+function formatRgbColor(alpha) {
+	const { values } = this[COLOR_SYMBOL];
+	const { blue, green, red } = getColorFromState(values, COLOR_TYPE.rgb);
+	return `rgb(${red} ${green} ${blue}${getSuffix(values, alpha)})`;
 }
 function getSuffix(state, alpha) {
 	return alpha === true ? ` / ${state.alpha.value}%` : "";
 }
 //#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 instance = {
-		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: () => changes.clear()
+function Color(value) {
+	this[COLOR_SYMBOL] = {
+		changes: herald({
+			names: [COLOR_TYPE.wildcard, ...COLOR_TYPE.all],
+			property: colorSubscription,
+			onCreate: (event, callback) => onCreateSubscription(this, event, callback)
+		}),
+		values: getColorState(value)
 	};
-	Object.defineProperties(instance, {
-		[COLOR_PROPERTY.name]: { value: true },
-		alpha: {
-			enumerable: true,
-			get: () => state.alpha.value,
-			set: (value) => setAlphaValue(state, value)
-		},
-		changes: {
-			enumerable: true,
-			value: changes.events
-		},
-		hex: createColorProperty(COLOR_TYPE.hex, instance, state, changes, false),
-		hexa: createColorProperty(COLOR_TYPE.hex, instance, state, changes, true),
-		hsl: createColorProperty(COLOR_TYPE.hsl, instance, state, changes, false),
-		hsla: createColorProperty(COLOR_TYPE.hsl, instance, state, changes, true),
-		hwb: createColorProperty(COLOR_TYPE.hwb, instance, state, changes, false),
-		hwba: createColorProperty(COLOR_TYPE.hwb, instance, state, changes, true),
-		origin: {
-			enumerable: true,
-			get: () => state.origin
-		},
-		rgb: createColorProperty(COLOR_TYPE.rgb, instance, state, changes, false),
-		rgba: createColorProperty(COLOR_TYPE.rgb, instance, state, changes, true)
-	});
-	return Object.freeze(instance);
 }
-function createColorProperty(space, color, state, changes, alpha) {
-	const setValue = setters[space];
-	return {
+Color.prototype[COLOR_PROPERTY] = COLOR_NAME;
+Color.prototype.subscribe = subscribeToColor;
+Color.prototype.toHexString = formatHexColor;
+Color.prototype.toHslString = formatHslColor;
+Color.prototype.toHwbString = formatHwbColor;
+Color.prototype.toRgbString = formatRgbColor;
+Color.prototype.toString = formatHexColor;
+Color.prototype.unsubscribe = unsubscribeFromColor;
+Object.defineProperties(Color.prototype, {
+	alpha: {
 		enumerable: true,
-		get: () => getColorValue(space, state, alpha),
-		set: (value) => setValue(color, state, changes, value, alpha)
-	};
+		get: getColorAlpha,
+		set: setColorAlpha
+	},
+	changes: {
+		enumerable: true,
+		get: getColorChanges
+	},
+	hex: {
+		enumerable: true,
+		get: getHexColor$1,
+		set: setHexValue
+	},
+	hexa: {
+		enumerable: true,
+		get: getHexaColor$1,
+		set: setHexaValue
+	},
+	hsl: {
+		enumerable: true,
+		get: getHslValue,
+		set: setHslValue
+	},
+	hsla: {
+		enumerable: true,
+		get: getHslaValue,
+		set: setHslaValue
+	},
+	hwb: {
+		enumerable: true,
+		get: getHwbValue,
+		set: setHwbValue
+	},
+	hwba: {
+		enumerable: true,
+		get: getHwbaValue,
+		set: setHwbaValue
+	},
+	origin: {
+		enumerable: true,
+		get: getOrigin
+	},
+	rgb: {
+		enumerable: true,
+		get: getRgbColor$1,
+		set: setRgbValue
+	},
+	rgba: {
+		enumerable: true,
+		get: getRgbaColor$1,
+		set: setRgbaValue
+	}
+});
+function color(value) {
+	return new Color(value);
 }
-function getColorValue(space, state, alpha) {
-	const value = getColorFromState(state, space);
-	if (typeof value === "string") return alpha ? `${value}${state.alpha.hex}` : value;
-	return alpha ? {
-		...value,
-		alpha: state.alpha.value
-	} : { ...value };
+function getColorChanges() {
+	return this[COLOR_SYMBOL].changes.events;
+}
+function getOrigin() {
+	return this[COLOR_SYMBOL].values.origin;
 }
 function onCreateSubscription(instance, event, callback) {
 	let value;
@@ -5711,19 +5969,13 @@ function onCreateSubscription(instance, event, callback) {
 	else value = instance[event];
 	callback(value);
 }
-function setAlphaValue(state, value) {
-	if (typeof value === "number" && !Number.isNaN(value)) state.alpha = getAlpha(value, false);
+function subscribeToColor(callback, signal) {
+	const { changes } = this[COLOR_SYMBOL];
+	return changes.subscribe(COLOR_TYPE.wildcard, callback, signal);
+}
+function unsubscribeFromColor() {
+	this[COLOR_SYMBOL].changes.clear();
 }
-const colorSubscription = {
-	key: COLOR_PROPERTY.name,
-	value: SUBSCRIPTION_NAME
-};
-const setters = {
-	hex: setHexColor,
-	hsl: setHSLColor,
-	hwb: setHWBColor,
-	rgb: setRGBColor
-};
 //#endregion
 //#region src/color/index.ts
 /**
@@ -5859,82 +6111,90 @@ function isObject(value) {
 const EXPRESSION_WHITESPACE = /^\s*$/;
 //#endregion
 //#region src/logger.ts
+const LOGGER_NAME = "Logger";
+const LOGGER_NAME_TIMED = "TimedLogger";
+const LOGGER_PROPERTY = "$logger";
+function Lumberjack() {}
+Lumberjack.prototype[LOGGER_PROPERTY] = LOGGER_NAME;
+Lumberjack.prototype.time = getTimeLogger;
+Object.defineProperties(Lumberjack.prototype, {
+	debug: { get: getLoggerCallback.bind("debug") },
+	dir: { get: getLoggerCallback.bind("dir") },
+	error: { get: getLoggerCallback.bind("error") },
+	enabled: {
+		enumerable: true,
+		get: getLoggerEnabled,
+		set: setLoggerEnabled
+	},
+	info: { get: getLoggerCallback.bind("info") },
+	log: { get: getLoggerCallback.bind("log") },
+	table: { get: getLoggerCallback.bind("table") },
+	trace: { get: getLoggerCallback.bind("trace") },
+	warn: { get: getLoggerCallback.bind("warn") }
+});
+function TimeLogger(label) {
+	this[LOGGER_SYMBOL] = {
+		label,
+		started: enabled,
+		stopped: false
+	};
+	this[LOGGER_SYMBOL].isActive = () => {
+		return enabled && this[LOGGER_SYMBOL].started && !this[LOGGER_SYMBOL].stopped;
+	};
+	if (this[LOGGER_SYMBOL].started) console.time(label);
+}
+TimeLogger.prototype[LOGGER_PROPERTY] = LOGGER_NAME_TIMED;
+Object.defineProperties(TimeLogger.prototype, {
+	active: {
+		enumerable: true,
+		get: getTimeLoggerActive
+	},
+	log: { get: getTimerLoggerLog },
+	stop: { get: getTimeLoggerStop }
+});
+function getLoggerCallback() {
+	return enabled ? console[this].bind(console) : noop;
+}
+function getLoggerEnabled() {
+	return enabled;
+}
+function getTimeLogger(label) {
+	return new TimeLogger(getString(label));
+}
+function getTimeLoggerActive() {
+	return this[LOGGER_SYMBOL].isActive();
+}
+function getTimerLoggerLog() {
+	const state = this[LOGGER_SYMBOL];
+	return state.isActive() ? console.timeLog.bind(console, state.label) : noop;
+}
+function getTimeLoggerStop() {
+	const state = this[LOGGER_SYMBOL];
+	if (state.isActive()) {
+		state.stopped = true;
+		return console.timeEnd.bind(console, state.label);
+	}
+	return noop;
+}
 function isLogger(value) {
 	return isLoggerInstance(LOGGER_NAME, value);
 }
 function isLoggerInstance(name, value) {
-	return typeof value === "object" && value !== null && value[LOGGER_PROPERTY] === name;
+	return typeof value === "object" && value !== null && LOGGER_PROPERTY in value && value[LOGGER_PROPERTY] === name;
 }
-function isTimedLogger(value) {
+function isTimeLogger(value) {
 	return isLoggerInstance(LOGGER_NAME_TIMED, value);
 }
-function timedLogger(label) {
-	function stop() {
-		const fn = stopper;
-		state.stopped = true;
-		logger = void 0;
-		stopper = void 0;
-		return fn;
-	}
-	let logger = console.timeLog.bind(console, label);
-	let stopper = console.timeEnd.bind(console, label);
-	const state = {
-		label,
-		started: enabled,
-		stopped: false
-	};
-	const instance = {};
-	Object.defineProperties(instance, {
-		[LOGGER_PROPERTY]: { value: LOGGER_NAME_TIMED },
-		active: {
-			enumerable: true,
-			get: () => state.started && !state.stopped && enabled
-		},
-		log: { get: () => instance.active ? logger : noop },
-		stop: { get: () => instance.active ? stop() : noop }
-	});
-	if (state.started) console.time(label);
-	return Object.freeze(instance);
+function setLoggerEnabled(value) {
+	enabled = typeof value === "boolean" ? value : enabled;
 }
-const LOGGER_NAME = "Logger";
-const LOGGER_NAME_TIMED = "TimedLogger";
-const LOGGER_PROPERTY = "$logger";
-const methods = [
-	"debug",
-	"dir",
-	"error",
-	"info",
-	"log",
-	"table",
-	"trace",
-	"warn"
-];
+const LOGGER_SYMBOL = Symbol(LOGGER_PROPERTY);
 /**
 * A logger that can be used to log messages to the console
 *
 * _(Logging can be enabled or disabled by setting the `enabled` property)_
 */
-const Logger = (() => {
-	const instance = {};
-	Object.defineProperties(instance, {
-		[LOGGER_PROPERTY]: { value: LOGGER_NAME },
-		enabled: {
-			enumerable: true,
-			get: () => enabled,
-			set: (value) => {
-				enabled = typeof value === "boolean" ? value : enabled;
-			}
-		},
-		time: { value: (label) => timedLogger(getString(label)) }
-	});
-	for (const method of methods) Object.defineProperty(instance, method, {
-		enumerable: true,
-		get() {
-			return enabled ? console[method].bind(console) : noop;
-		}
-	});
-	return Object.freeze(instance);
-})();
+const Logger = new Lumberjack();
 let enabled = true;
 //#endregion
 //#region src/math.ts
@@ -6080,6 +6340,9 @@ const QUERY_TYPES = /* @__PURE__ */ new Set([
 ]);
 //#endregion
 //#region src/queue.ts
+const QUEUE_NAME_KEYED = "keyedQueue";
+const QUEUE_NAME_QUEUE = "queue";
+const QUEUE_PROPERTY = "$queue";
 /**
 * An error thrown by the Queue when an operation fails
 */
@@ -6089,10 +6352,122 @@ var QueueError = class extends Error {
 		this.name = QUEUE_ERROR_NAME;
 	}
 };
-function addToQueue(instance, state, parameters, signal) {
-	if (instance.full) throw new QueueError(QUEUE_MESSAGE_MAXIMUM);
+function KeyedQueue(callback, options) {
+	this[QUEUE_SYMBOL] = {
+		callback,
+		options: createQueueOptions(options),
+		queues: /* @__PURE__ */ new Map()
+	};
+}
+KeyedQueue.prototype[QUEUE_PROPERTY] = QUEUE_NAME_KEYED;
+KeyedQueue.prototype.add = addKeyedQueue;
+KeyedQueue.prototype.clear = clearQueues;
+KeyedQueue.prototype.get = getQueue;
+KeyedQueue.prototype.pause = pauseQueues;
+KeyedQueue.prototype.remove = removeQueue;
+KeyedQueue.prototype.resume = resumeQueues;
+Object.defineProperties(KeyedQueue.prototype, {
+	active: {
+		enumerable: true,
+		get: getActiveQueues
+	},
+	autostart: {
+		enumerable: true,
+		get: getQueueAutostart
+	},
+	concurrency: {
+		enumerable: true,
+		get: getQueueConcurrency
+	},
+	empty: {
+		enumerable: true,
+		get: getEmptyQueues
+	},
+	full: {
+		enumerable: true,
+		get: getFullQueues
+	},
+	items: {
+		enumerable: true,
+		get: getKeyedQueueItems
+	},
+	keys: {
+		enumerable: true,
+		get: getQueueKeys
+	},
+	maximum: {
+		enumerable: true,
+		get: getQueueMaximum
+	},
+	paused: {
+		enumerable: true,
+		get: getPausedQueues
+	},
+	queues: {
+		enumerable: true,
+		get: getKeyedQueueSize
+	}
+});
+function Queue(callback, options, key) {
+	this[QUEUE_SYMBOL] = {
+		callback,
+		key,
+		options,
+		handled: [],
+		id: 0,
+		items: [],
+		paused: !options.autostart,
+		runners: 0
+	};
+}
+Queue.prototype[QUEUE_PROPERTY] = QUEUE_NAME_QUEUE;
+Queue.prototype.add = addToQueue;
+Queue.prototype.clear = clearQueue;
+Queue.prototype.pause = pauseQueue;
+Queue.prototype.remove = removeQueued;
+Queue.prototype.resume = resumeQueue;
+Object.defineProperties(Queue.prototype, {
+	active: {
+		enumerable: true,
+		get: getQueueActive
+	},
+	autostart: {
+		enumerable: true,
+		get: getQueueAutostart
+	},
+	concurrency: {
+		enumerable: true,
+		get: getQueueConcurrency
+	},
+	empty: {
+		enumerable: true,
+		get: getQueueEmpty
+	},
+	full: {
+		enumerable: true,
+		get: getQueueFull
+	},
+	maximum: {
+		enumerable: true,
+		get: getQueueMaximum
+	},
+	paused: {
+		enumerable: true,
+		get: getQueuePaused
+	},
+	size: {
+		enumerable: true,
+		get: getQueueSize
+	}
+});
+function addKeyedQueue(key, parameters, signal) {
+	return getQueue.call(this, key, true).add(parameters, signal);
+}
+function addToQueue(parameters, signal) {
+	if (this.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 state = this[QUEUE_SYMBOL];
 	const id = identify(state);
 	let rejector;
 	let resolver;
@@ -6116,8 +6491,8 @@ function addToQueue(instance, state, parameters, signal) {
 		promise
 	};
 }
-function clearQueue(state) {
-	const items = state.items.splice(0);
+function clearQueue() {
+	const items = this[QUEUE_SYMBOL].items.splice(0);
 	const { length } = items;
 	for (let index = 0; index < length; index += 1) {
 		const { aborter, reject } = items[index];
@@ -6125,63 +6500,12 @@ function clearQueue(state) {
 		reject(new QueueError(QUEUE_MESSAGE_CLEAR));
 	}
 }
+function clearQueues(key) {
+	handleQueues(this, QUEUE_HANDLE_CLEAR, key);
+}
 function createQueue(callback, options, key) {
 	if (typeof callback !== "function") throw new TypeError(QUEUE_MESSAGE_CALLBACK);
-	const state = {
-		callback,
-		key,
-		handled: [],
-		id: 0,
-		items: [],
-		options: createQueueOptions(options),
-		paused: !getBooleanOrDefault(options?.autostart, true),
-		runners: 0
-	};
-	const instance = {
-		add: (parameters, signal) => addToQueue(instance, state, parameters, signal),
-		clear: () => clearQueue(state),
-		pause: () => {
-			state.paused = true;
-		},
-		remove: (id) => removeQueued(state, id),
-		resume: () => resumeQueue(state)
-	};
-	Object.defineProperties(instance, {
-		[QUEUE_PROPERTY]: { value: QUEUE_NAME_QUEUE },
-		active: {
-			enumerable: true,
-			get: () => state.runners > 0
-		},
-		autostart: {
-			enumerable: true,
-			get: () => state.options.autostart
-		},
-		concurrency: {
-			enumerable: true,
-			get: () => state.options.concurrency
-		},
-		empty: {
-			enumerable: true,
-			get: () => state.items.length === 0
-		},
-		full: {
-			enumerable: true,
-			get: () => state.options.maximum > 0 && state.items.length >= state.options.maximum
-		},
-		maximum: {
-			enumerable: true,
-			get: () => state.options.maximum
-		},
-		paused: {
-			enumerable: true,
-			get: () => state.paused
-		},
-		size: {
-			enumerable: true,
-			get: () => state.items.length
-		}
-	});
-	return Object.freeze(instance);
+	return new Queue(callback, createQueueOptions(options), key);
 }
 function createQueueOptions(input) {
 	const options = typeof input === "object" && input != null ? input : {};
@@ -6191,8 +6515,31 @@ function createQueueOptions(input) {
 		maximum: getNumberOrDefault(options.maximum, 0)
 	};
 }
-function getQueue(state, key, add) {
+function getActiveQueues() {
+	return getStatus(this[QUEUE_SYMBOL], QUEUE_STATUS_ACTIVE);
+}
+function getEmptyQueues() {
+	return getStatus(this[QUEUE_SYMBOL], QUEUE_STATUS_EMPTY);
+}
+function getFullQueues() {
+	return getStatus(this[QUEUE_SYMBOL], QUEUE_STATUS_FULL);
+}
+function getPausedQueues() {
+	return getStatus(this[QUEUE_SYMBOL], QUEUE_STATUS_PAUSED);
+}
+function getKeyedQueueItems() {
+	const state = this[QUEUE_SYMBOL];
+	const size = {};
+	const queues = state.queues.entries();
+	for (const [key, queue] of queues) size[key] = queue.size;
+	return size;
+}
+function getKeyedQueueSize() {
+	return this[QUEUE_SYMBOL].queues.size;
+}
+function getQueue(key, add) {
 	if (typeof key !== "string" || key.trim().length === 0) throw new TypeError(QUEUE_MESSAGE_KEY);
+	const state = this[QUEUE_SYMBOL];
 	let queue = state.queues.get(key);
 	if (queue == null && add === true) {
 		queue = createQueue(state.callback, state.options, key);
@@ -6200,11 +6547,33 @@ 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 getQueueActive() {
+	return this[QUEUE_SYMBOL].runners > 0;
+}
+function getQueueAutostart() {
+	return this[QUEUE_SYMBOL].options.autostart === true;
+}
+function getQueueConcurrency() {
+	return this[QUEUE_SYMBOL].options.concurrency;
+}
+function getQueueEmpty() {
+	return this[QUEUE_SYMBOL].items.length === 0;
+}
+function getQueueFull() {
+	const state = this[QUEUE_SYMBOL];
+	return state.options.maximum > 0 && state.items.length >= state.options.maximum;
+}
+function getQueueKeys() {
+	return [...this[QUEUE_SYMBOL].queues.keys()];
+}
+function getQueueMaximum() {
+	return this[QUEUE_SYMBOL].options.maximum;
+}
+function getQueuePaused() {
+	return this[QUEUE_SYMBOL].paused === true;
+}
+function getQueueSize() {
+	return this[QUEUE_SYMBOL].items.length;
 }
 function getStatus(state, status) {
 	const queues = state.queues.entries();
@@ -6224,12 +6593,12 @@ function handleQueuedResult(item, error, result) {
 	}
 	item.resolve(result);
 }
-function handleQueues(state, type, key) {
+function handleQueues(instance, type, key) {
 	if (typeof key === "string") {
-		getQueue(state, key)?.[type]();
+		getQueue.call(instance, key)?.[type]();
 		return;
 	}
-	const queues = state.queues.values();
+	const queues = instance[QUEUE_SYMBOL].queues.values();
 	for (const queue of queues) queue[type]();
 }
 function identify(state) {
@@ -6255,78 +6624,29 @@ function isQueue(value) {
 	return isQueueInstance(QUEUE_NAME_QUEUE, value);
 }
 function isQueueInstance(name, value) {
-	return typeof value === "object" && value != null && value[QUEUE_PROPERTY] === name;
+	return typeof value === "object" && value != null && QUEUE_PROPERTY in value && value[QUEUE_PROPERTY] === name;
 }
 function keyedQueue(callback, options) {
 	if (typeof callback !== "function") throw new TypeError(QUEUE_MESSAGE_CALLBACK);
-	const state = {
-		callback,
-		options: createQueueOptions(options),
-		queues: /* @__PURE__ */ new Map()
-	};
-	const instance = {
-		add: (key, parameters, signal) => getQueue(state, key, true).add(parameters, signal),
-		clear: (key) => handleQueues(state, QUEUE_HANDLE_CLEAR, key),
-		get: (key) => getQueue(state, key),
-		pause: (key) => handleQueues(state, QUEUE_HANDLE_PAUSE, key),
-		remove: (key, id) => removeQueue(state, key, id),
-		resume: (key) => handleQueues(state, QUEUE_HANDLE_RESUME, key)
-	};
-	Object.defineProperties(instance, {
-		[QUEUE_PROPERTY]: { value: QUEUE_NAME_KEYED },
-		active: {
-			enumerable: true,
-			get: () => getStatus(state, QUEUE_STATUS_ACTIVE)
-		},
-		autostart: {
-			enumerable: true,
-			get: () => state.options.autostart
-		},
-		concurrency: {
-			enumerable: true,
-			get: () => state.options.concurrency
-		},
-		empty: {
-			enumerable: true,
-			get: () => getStatus(state, QUEUE_STATUS_EMPTY)
-		},
-		full: {
-			enumerable: true,
-			get: () => getStatus(state, QUEUE_STATUS_FULL)
-		},
-		items: {
-			enumerable: true,
-			get: () => getQueueItems(state)
-		},
-		keys: {
-			enumerable: true,
-			get: () => [...state.queues.keys()]
-		},
-		maximum: {
-			enumerable: true,
-			get: () => state.options.maximum
-		},
-		paused: {
-			enumerable: true,
-			get: () => getStatus(state, QUEUE_STATUS_PAUSED)
-		},
-		queues: {
-			enumerable: true,
-			get: () => state.queues.size
-		}
-	});
-	return Object.freeze(instance);
+	return new KeyedQueue(callback, createQueueOptions(options));
+}
+function pauseQueue() {
+	this[QUEUE_SYMBOL].paused = true;
+}
+function pauseQueues(key) {
+	handleQueues(this, QUEUE_HANDLE_PAUSE, key);
 }
 function queue(callback, options) {
 	return createQueue(callback, options);
 }
-function removeQueue(state, key, id) {
+function removeQueue(key, id) {
+	const state = this[QUEUE_SYMBOL];
 	if (key == null) {
-		handleQueues(state, QUEUE_HANDLE_CLEAR);
+		handleQueues(this, QUEUE_HANDLE_CLEAR);
 		state.queues.clear();
 		return;
 	}
-	const queue = getQueue(state, key);
+	const queue = getQueue.call(this, key);
 	if (queue == null) return;
 	if (typeof id === "number") {
 		queue.remove(id);
@@ -6335,7 +6655,8 @@ function removeQueue(state, key, id) {
 	queue.clear();
 	state.queues.delete(key);
 }
-function removeQueued(state, id) {
+function removeQueued(id) {
+	const state = this[QUEUE_SYMBOL];
 	const index = state.items.findIndex((item) => item.id === id);
 	if (index > -1) {
 		const { aborter, reject } = state.items.splice(index, 1)[0];
@@ -6343,7 +6664,8 @@ function removeQueued(state, id) {
 		reject(new QueueError(QUEUE_MESSAGE_REMOVE));
 	}
 }
-function resumeQueue(state) {
+function resumeQueue() {
+	const state = this[QUEUE_SYMBOL];
 	if (state.paused) {
 		const handled = state.handled.splice(0);
 		const { length } = handled;
@@ -6353,6 +6675,9 @@ function resumeQueue(state) {
 	const length = Math.min(state.options.concurrency, state.items.length);
 	for (let index = 0; index < length; index += 1) run(state);
 }
+function resumeQueues(key) {
+	handleQueues(this, QUEUE_HANDLE_RESUME, key);
+}
 async function run(state) {
 	if (state.paused || state.runners >= state.options.concurrency) return;
 	state.runners += 1;
@@ -6380,7 +6705,6 @@ async function run(state) {
 	state.runners -= 1;
 }
 const QUEUE_ERROR_NAME = "QueueError";
-const QUEUE_PROPERTY = "$queue";
 const QUEUE_HANDLE_CLEAR = "clear";
 const QUEUE_HANDLE_PAUSE = "pause";
 const QUEUE_HANDLE_RESUME = "resume";
@@ -6389,14 +6713,12 @@ 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";
+const QUEUE_SYMBOL = Symbol(QUEUE_PROPERTY);
 queue.keyed = keyedQueue;
-Object.defineProperty(queue, "keyed", { value: keyedQueue });
 //#endregion
 //#region src/random.ts
 /**
@@ -6514,4 +6836,4 @@ var SizedSet = class extends Set {
 	}
 };
 //#endregion
-export { CancelablePromise, Logger, PromiseTimeoutError, QueueError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, copy, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, filter, find, findLast, first, firstOrDefault, flatFreeze, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, 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, initializeCloner, 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, isSubscriptions, 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, reverseSelect, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, select, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, subscriptions, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };
+export { CancelablePromise, Logger, PromiseTimeoutError, QueueError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, copy, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, filter, find, findLast, first, firstOrDefault, flatFreeze, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getHwbColor, getHwbaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hasValueResult, herald, hexToHsl, hexToHsla, hexToHwb, hexToHwba, hexToRgb, hexToRgba, hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba, hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeCloner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, interpolate, intersection, isArrayOrPlainObject, isAsyncOnce, isBeacon, isBeaconSubscription, isColor, isConstructor, isEmpty, isError, isFrozen, isFulfilled, isFuzzy, 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, isOnce, isPlainObject, isPrimitive, isQueue, isQueueInstance, isRejected, isResult, isRgbColor, isRgbaColor, isSorted, isSubscription, isSubscriptions, isTimeLogger, 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, reverseSelect, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, select, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, subscriptions, 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 };