@oscarpalmer/atoms 0.201.0 → 0.203.0

package/dist/index.mjs

@@ -1069,59 +1069,59 @@ 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;
+}
+Object.defineProperties(BaseHandler.prototype, {
+	deregister: { value: deregisterHandler },
+	get: { value: getHandler$1 },
+	register: { value: registerHandler }
+});
+function CompareHandler(base) {
+	this.base = base;
 }
-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);
-		}
-	};
+Object.defineProperties(CompareHandler.prototype, { handle: { value: handleComparison } });
+function ValueHandler(value) {
+	this.base = value;
 }
-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);
-		}
-	};
+Object.defineProperties(ValueHandler.prototype, { handle: { value: 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 +1167,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 +1177,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 +1192,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 +1200,34 @@ 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 },
+	handler: { value: compareHandler },
 	register: { value: registerComparator }
 });
 //#endregion
 //#region src/array/sort.ts
+const SORTER_PROPERTY = "$sorter";
+function Sorter(sorters) {
+	Object.defineProperty(this, SORTER_SYMBOL, { value: sorters });
+}
+Object.defineProperties(Sorter.prototype, {
+	[SORTER_PROPERTY]: { value: true },
+	index: { value: getSortedArrayIndex },
+	is: { value: isSortedArray },
+	sort: { value: sortArray }
+});
 function getComparisonSorter(callback, modifier) {
 	return {
 		modifier,
-		compare: { simple: callback },
+		comparison: { simple: callback },
 		get: false,
 		identifier: callback.toString()
 	};
@@ -1226,15 +1236,29 @@ 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 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 +1271,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 +1297,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 +1307,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 +1338,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 +1350,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_PROPERTY);
 const modifiers = {
 	[SORT_DIRECTION_ASCENDING]: 1,
 	[SORT_DIRECTION_DESCENDING]: -1
@@ -1465,86 +1473,109 @@ 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;
+//#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) {
+	Object.defineProperty(this, LIMITER_SYMBOL, { value: {
+		callback,
+		type,
+		interval: getNumberOrDefault(time, 0),
+		parameters: [],
+		throttle: type === LIMITER_THROTTLE
+	} });
+}
+Object.defineProperties(AsyncLimiter.prototype, {
+	[LIMITER_PROPERTY]: { value: LIMITER_NAME_ASYNC },
+	cancel: { value: cancelAsyncLimiter },
+	run: { value: runAsyncLimiter }
+});
+function Limiter(type, callback, time) {
+	Object.defineProperty(this, LIMITER_SYMBOL, { value: {
+		callback,
+		type,
+		interval: getNumberOrDefault(time, 0),
+		parameters: [],
+		throttle: type === LIMITER_THROTTLE
+	} });
+}
+Object.defineProperties(Limiter.prototype, {
+	[LIMITER_PROPERTY]: { value: LIMITER_NAME_SYNC },
+	cancel: { value: cancelLimiter },
+	run: { value: 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;
 		}
-	}
-	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;
-	};
-	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);
+	} 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 +1595,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 +1610,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 +1622,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,7 +1632,7 @@ 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;
@@ -1656,6 +1687,10 @@ function unwrap(value, defaultValue) {
 }
 const RESULT_PROPERTY_ERROR = "error";
 const RESULT_PROPERTY_VALUE = "value";
+error.is = isError;
+ok.is = isOk;
+Object.defineProperty(error, "is", { value: isError });
+Object.defineProperty(ok, "is", { value: isOk });
 //#endregion
 //#region src/internal/value/misc.ts
 function findKey(needle, haystack) {
@@ -1813,6 +1848,74 @@ Object.defineProperties(assert, {
 });
 //#endregion
 //#region src/function/once.ts
+const ONCE_NAME_ASYNC = "asyncOnce";
+const ONCE_NAME_SYNC = "once";
+const ONCE_PROPERTY = "$once";
+function AsyncOnce(callback) {
+	Object.defineProperty(this, ONCE_SYMBOL, { value: {
+		callback,
+		called: false,
+		cleared: false,
+		error: false,
+		finished: false,
+		items: [],
+		value: void 0
+	} });
+}
+Object.defineProperties(AsyncOnce.prototype, {
+	[ONCE_PROPERTY]: { value: ONCE_NAME_ASYNC },
+	called: {
+		enumerable: true,
+		get() {
+			return this[ONCE_SYMBOL].called;
+		}
+	},
+	clear: { value: clearOnce },
+	cleared: {
+		enumerable: true,
+		get() {
+			return this[ONCE_SYMBOL].cleared;
+		}
+	},
+	error: {
+		enumerable: true,
+		get() {
+			return this[ONCE_SYMBOL].error;
+		}
+	},
+	finished: {
+		enumerable: true,
+		get() {
+			return this[ONCE_SYMBOL].finished;
+		}
+	},
+	run: { value: runOnceAsync }
+});
+function Once(callback) {
+	Object.defineProperty(this, ONCE_SYMBOL, { value: {
+		callback,
+		called: false,
+		cleared: false,
+		value: void 0
+	} });
+}
+Object.defineProperties(Once.prototype, {
+	[ONCE_PROPERTY]: { value: ONCE_NAME_SYNC },
+	clear: { value: clearOnce },
+	called: {
+		enumerable: true,
+		get() {
+			return this[ONCE_SYMBOL].called;
+		}
+	},
+	cleared: {
+		enumerable: true,
+		get() {
+			return this[ONCE_SYMBOL].cleared;
+		}
+	},
+	run: { value: runOnce }
+});
 /**
 * Create an asynchronous function that can only be called once, rejecting or resolving the same result on subsequent calls
 *
@@ -1823,59 +1926,12 @@ 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;
 }
@@ -1892,6 +1948,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 +1976,52 @@ 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;
+Object.defineProperty(asyncOnce, "is", { value: isAsyncOnce });
+Object.defineProperties(once, {
+	async: { value: asyncOnce },
+	is: { value: isOnce },
+	isAsync: { value: isAsyncOnce }
+});
 //#endregion
 //#region src/function/retry.ts
 /**
@@ -1960,12 +2054,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;
@@ -2211,6 +2305,48 @@ var SizedMap = class extends Map {
 };
 //#endregion
 //#region src/internal/function/memoize.ts
+const MEMOIZED_PROPERTY = "$memoized";
+function Memoized(callback, options) {
+	Object.defineProperty(this, MEMOIZED_SYMBOL, { value: {
+		options,
+		cache: new SizedMap(options.cacheSize),
+		getter: void 0
+	} });
+	this[MEMOIZED_SYMBOL].getter = createGetter(this[MEMOIZED_SYMBOL], callback);
+	Object.defineProperties(this, {
+		maximum: {
+			enumerable: true,
+			get: () => this[MEMOIZED_SYMBOL].cache.maximum
+		},
+		size: {
+			enumerable: true,
+			get: () => this[MEMOIZED_SYMBOL].cache.size
+		}
+	});
+}
+Object.defineProperties(Memoized.prototype, {
+	[MEMOIZED_PROPERTY]: { value: true },
+	clear: { value: clearMemoized },
+	delete: { value: deleteMemoizedValue },
+	get: { value: getMemoizedValue },
+	has: { value: hasMemoizedValue },
+	run: { value: runMemoized }
+});
+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 +2354,12 @@ function createMemoizationOptions(input) {
 		cacheSize: getNumberOrDefault(cacheSize, MEMOIZED_CACHE_SIZE_DEFAULT)
 	};
 }
+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 +2369,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_PROPERTY);
 //#endregion
 //#region src/internal/string/case.ts
 /**
@@ -2399,6 +2515,17 @@ let memoizedTitleCase;
 let memoizedUpperCase;
 //#endregion
 //#region src/internal/value/equal.ts
+function Equalizer(options) {
+	Object.defineProperty(this, EQUAL_SYMBOL, { value: options });
+}
+Object.defineProperties(Equalizer.prototype, {
+	compare: { value: compare$1 },
+	deregister: { value: deregisterEqualizer },
+	register: { value: registerEqualizer }
+});
+function compare$1(first, second) {
+	return equalValue(first, second, this[EQUAL_SYMBOL]);
+}
 function createEqualOptions(input) {
 	const options = {
 		ignoreCase: false,
@@ -2433,7 +2560,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 +2571,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 +2659,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 +2671,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 +2682,25 @@ 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;
+Object.defineProperties(equal, {
+	deregister: { value: deregisterEqualizer },
+	handler: { value: equalHandler },
+	initialize: { value: initializeEqualizer },
+	register: { value: registerEqualizer }
+});
 //#endregion
 //#region src/internal/value/get.ts
 function getValue(data, path, ignoreCase) {
@@ -2785,34 +2916,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;
 	});
@@ -3035,6 +3166,30 @@ 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) {
+	Object.defineProperty(this, FUZZY_SYMBOL, { value: state });
+}
+Object.defineProperties(Fuzzy.prototype, {
+	[FUZZY_PROPERTY]: { value: true },
+	items: {
+		enumerable: true,
+		get() {
+			return this[FUZZY_SYMBOL].items.slice();
+		},
+		set(value) {
+			setItems(this[FUZZY_SYMBOL], value);
+		}
+	},
+	search: { value: search },
+	strings: {
+		enumerable: true,
+		get() {
+			return this[FUZZY_SYMBOL].strings.slice();
+		}
+	}
+});
 function createFuzzyOptions(input, state) {
 	const options = isPlainObject(input) ? input : {};
 	const limit = typeof input === "number" ? input : options.limit;
@@ -3054,43 +3209,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,20 +3228,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;
-	}
-	return false;
-}
-function getScore(haystack, needle) {
-	if (!isSubsequence(haystack, needle)) return -1;
+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 getScore(haystack, needle) {
+	if (!isSubsequence(haystack, needle)) return -1;
 	const lowerCaseHaystack = lowerCase(haystack);
 	const lowerCaseNeedle = lowerCase(needle);
 	const needleLength = lowerCaseNeedle.length;
@@ -3139,23 +3265,52 @@ function getScore(haystack, needle) {
 	score -= Math.floor(lowerCaseHaystack.length / FUZZY_LENGTH_DIVISOR);
 	return Math.max(0, score);
 }
-function search(items, strings, input, options) {
+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 = items.slice(0, options.limit);
+		result.exact = state.items.slice(0, options.limit);
 		return result;
 	}
-	let { length } = items;
+	let { length } = state.items;
 	const exact = [];
 	const similar = [];
 	const scored = {};
 	for (let index = 0; index < length; index += 1) {
-		const item = items[index];
-		const haystack = strings[index];
+		const item = state.items[index];
+		const haystack = state.strings[index];
 		if (includes(haystack, value, true)) {
 			exact.push({
 				item,
@@ -3196,8 +3351,12 @@ 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 });
+Object.defineProperties(fuzzy, {
+	is: { value: isFuzzy },
+	match: { value: fuzzyMatch }
+});
 //#endregion
 //#region src/string/index.ts
 function dedent(value, ...values) {
@@ -3294,6 +3453,10 @@ const STRING_NUMERICAL_PREFIX_PATTERN = /^\d/;
 const STRING_ZERO = "0";
 //#endregion
 //#region src/string/normalize.ts
+function Normalizer(options) {
+	Object.defineProperty(this, NORMALIZE_SYMBOL, { value: options });
+}
+Object.defineProperties(Normalizer.prototype, { normalize: { value: normalizeString } });
 function createNormalizeOptions(input) {
 	const options = isPlainObject(input) ? input : {};
 	return {
@@ -3328,8 +3491,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 +3503,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,6 +3554,7 @@ 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;
@@ -3398,6 +3562,10 @@ normalize.initialize = initializeNormalizer;
 Object.defineProperty(normalize, "initialize", { value: initializeNormalizer });
 //#endregion
 //#region src/string/template.ts
+function Templater(options) {
+	Object.defineProperty(this, TEMPLATE_SYMBOL, { value: options });
+}
+Object.defineProperties(Templater.prototype, { render: { value: render } });
 function createTemplateOptions(input) {
 	const options = isPlainObject(input) ? input : {};
 	return {
@@ -3431,10 +3599,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 +3612,20 @@ 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) {
+	Object.defineProperty(this, CLONE_SYMBOL, { value: options });
+}
+Object.defineProperties(Cloner.prototype, {
+	clone: { value: cloneFromCloner },
+	deregister: { value: deregisterCloner },
+	register: { value: registerCloner }
+});
 function clone(value, options) {
 	return cloneAny(value, { copy: false }, 0, options);
 }
@@ -3490,6 +3669,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 +3746,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 +3757,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 +3768,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 +3790,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,13 +3804,14 @@ 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 },
+	handler: { value: cloneHandler },
 	initialize: { value: initializeCloner },
 	register: { value: registerCloner }
 });
@@ -3834,7 +4007,7 @@ function freezeValue(value, references, flat) {
 }
 /**
 * Is the value frozen?
-* 
+*
 * _Available as `isFrozen` and `freeze.is`_
 *
 * @param value Value to check
@@ -3983,6 +4156,17 @@ function unsmush(value) {
 }
 //#endregion
 //#region src/value/merge.ts
+function Assigner(options) {
+	Object.defineProperty(this, MERGE_SYMBOL_ASSIGN, { value: {
+		...options,
+		assignValues: true
+	} });
+}
+Object.defineProperties(Assigner.prototype, { assign: { value: assignFromAssigner } });
+function Merger(options) {
+	Object.defineProperty(this, MERGE_SYMBOL_MERGE, { value: options });
+}
+Object.defineProperties(Merger.prototype, { merge: { value: mergeFromMerger } });
 /**
 * Assign values from one or more objects to the first one
 *
@@ -3996,6 +4180,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 +4211,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 +4222,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 +4234,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 +4266,19 @@ 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) {
+	Object.defineProperty(this, TRANSFORM_SYMBOL, { value: 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 +4289,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 +4311,59 @@ 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) {
+	Object.defineProperty(this, SUBSCRIPTION_SYMBOL, { value: state });
+	state.aborter = createAborter(parameters.signal, () => this.unsubscribe(subscriptions, this, state));
+	Object.defineProperties(this, {
+		[property.key]: { value: property.value },
+		active: {
+			enumerable: true,
+			get: () => (state.parameters?.isActive?.() ?? true) && state.active
+		}
+	});
+	addSubscription(this);
+}
+Object.defineProperties(Subscription.prototype, {
+	[SUBSCRIPTION_PROPERTY]: { value: SUBSCRIPTION_NAME },
+	unsubscribe: { value: removeSubscription }
+});
+function Subscriptions(parameters) {
+	const { keys, property } = createSubscriptionsParameters(parameters);
+	Object.defineProperty(this, SUBSCRIPTION_SYMBOL, { value: createSubscriptionsState(property, keys) });
+}
+Object.defineProperties(Subscriptions.prototype, {
+	[SUBSCRIPTION_PROPERTY]: { value: SUBSCRIPTION_STORE },
+	clear: { value: clearSubscriptions },
+	create: { value: createSubscription },
+	items: {
+		enumerable: true,
+		get() {
+			return this[SUBSCRIPTION_SYMBOL].items;
+		}
+	},
+	values: {
+		enumerable: true,
+		get() {
+			return this[SUBSCRIPTION_SYMBOL].values;
+		}
+	}
+});
+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 +4375,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,18 +4409,7 @@ 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;
@@ -4216,9 +4443,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 +4473,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 +4494,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 +4512,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 +4522,67 @@ 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) {
+	Object.defineProperty(this, BEACON_SYMBOL, { value: {
+		value,
+		active: true,
+		options: createBeaconOptions(options)
+	} });
+}
+Object.defineProperties(Beacon.prototype, {
+	[BEACON_PROPERTY]: { value: BEACON_NAME },
+	active: {
+		enumerable: true,
+		get() {
+			return this[BEACON_SYMBOL].active;
+		}
+	},
+	deactivate: { value: deactivateBeacon },
+	emit: { value: emitBeaconValue },
+	error: { value: emitBeaconError },
+	finish: { value: finishBeacon },
+	observable: {
+		enumerable: true,
+		get() {
+			return getObservable(this[BEACON_SYMBOL]);
+		}
+	},
+	value: {
+		enumerable: true,
+		get() {
+			return this[BEACON_SYMBOL].value;
+		}
+	}
+});
+function Observable(beacon) {
+	Object.defineProperty(this, BEACON_SYMBOL, { value: {
+		beacon,
+		active: beacon.active
+	} });
+}
+Object.defineProperties(Observable.prototype, {
+	[BEACON_PROPERTY]: { value: BEACON_OBSERVABLE },
+	active: {
+		enumerable: true,
+		get() {
+			const state = this[BEACON_SYMBOL];
+			return state.beacon.active && state.active;
+		}
+	},
+	deactivate: { value: deactiveateObservable },
+	subscribe: { value: subscribeToObservable }
+});
 /**
 * Create a new beacon
 *
@@ -4332,61 +4591,24 @@ 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);
-}
 function createObserver(first, second, third) {
 	let observer = { next: noop };
 	if (typeof first === "function") observer = {
@@ -4401,17 +4623,24 @@ function createObserver(first, second, third) {
 	}
 	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) {
 	if (!state.active) throw new Error(BEACON_MESSAGE_RETRIEVE);
-	state.observable ??= createObservable(state);
+	state.observable ??= new Observable(state);
 	return state.observable;
 }
 function getObservableCallback(value) {
@@ -4427,7 +4656,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 && value[BEACON_PROPERTY] === name;
 }
 /**
 * Is the value a beacon subscription?
@@ -4447,8 +4676,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 +4688,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 +4710,34 @@ 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) {
+	Object.defineProperty(this, HERALD_SYMBOL, { value: {
+		state,
+		events: new Events(this, state)
+	} });
+}
+Object.defineProperties(Herald.prototype, {
+	[HERALD_PROPERTY]: { value: HERALD_NAME_HERALD },
+	clear: { value: clearHerald },
+	emit: { value: emitForHerald },
+	events: {
+		enumerable: true,
+		get() {
+			return this[HERALD_SYMBOL].events;
+		}
+	},
+	observed: { value: eventIsObserved },
+	subscribe: { value: subscribeToHerald }
+});
+function clearHerald() {
+	this[HERALD_SYMBOL].state.store.clear();
 }
 function createHeraldState(input) {
 	const options = isPlainObject(input) ? input : {};
@@ -4508,11 +4762,15 @@ 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;
+}
 /**
 * Create a _Herald_ for announcing named events
 *
@@ -4521,21 +4779,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 +4800,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?
@@ -4567,7 +4811,8 @@ function isHeraldInstance(name, value) {
 function isHeraldSubscription(value) {
 	return isSubscription(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 +4821,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 +4899,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 +4936,10 @@ const COLOR_SRGB = {
 	luminanceRed: .2126,
 	luminanceThreshold: .625
 };
+const colorSubscription = {
+	key: COLOR_PROPERTY,
+	value: SUBSCRIPTION_NAME
+};
 //#endregion
 //#region src/internal/math/misc.ts
 /**
@@ -4893,7 +5142,7 @@ 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;
@@ -5579,41 +5828,43 @@ 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;
+function setColorValue(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);
+}
+function setHexColor(instance, value, alpha) {
+	const { values } = instance[COLOR_SYMBOL];
+	if (!isHexColor(value) || !alpha && value === values.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);
+	setColorValue(instance, COLOR_TYPE.hex, normalized.slice(0, COLOR_LENGTHS.hexLong), alpha ? normalized.slice(COLOR_LENGTHS.hexLong) : void 0);
 }
-function setHSLColor(color, state, changes, value, alpha) {
+function setHSLColor(instance, value, alpha) {
 	if (!isHslLike(value)) return;
-	setColorValue(color, state, changes, COLOR_TYPE.hsl, {
+	setColorValue(instance, COLOR_TYPE.hsl, {
 		hue: getDegrees(value.hue),
 		saturation: getPercentage(value.saturation),
 		lightness: getPercentage(value.lightness)
 	}, alpha ? value.alpha : void 0);
 }
-function setHWBColor(color, state, changes, value, alpha) {
+function setHWBColor(instance, value, alpha) {
 	if (!isHwbLike(value)) return;
-	setColorValue(color, state, changes, COLOR_TYPE.hwb, {
+	setColorValue(instance, 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) {
+function setRGBColor(instance, value, alpha) {
 	if (!isRgbLike(value)) return;
-	setColorValue(color, state, changes, COLOR_TYPE.rgb, {
+	setColorValue(instance, COLOR_TYPE.rgb, {
 		red: getHexValue(value.red),
 		green: getHexValue(value.green),
 		blue: getHexValue(value.blue)
@@ -5627,82 +5878,152 @@ 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()
-	};
-	Object.defineProperties(instance, {
-		[COLOR_PROPERTY.name]: { value: true },
-		alpha: {
-			enumerable: true,
-			get: () => state.alpha.value,
-			set: (value) => setAlphaValue(state, value)
+function Color(value) {
+	Object.defineProperty(this, COLOR_SYMBOL, { value: {
+		changes: herald({
+			names: [COLOR_TYPE.wildcard, ...COLOR_TYPE.all],
+			property: colorSubscription,
+			onCreate: (event, callback) => onCreateSubscription(this, event, callback)
+		}),
+		values: getColorState(value)
+	} });
+}
+Object.defineProperties(Color.prototype, {
+	[COLOR_PROPERTY]: { value: COLOR_NAME },
+	alpha: {
+		enumerable: true,
+		get() {
+			return this[COLOR_SYMBOL].values.alpha.value;
 		},
-		changes: {
-			enumerable: true,
-			value: changes.events
+		set(value) {
+			setAlphaValue(this[COLOR_SYMBOL].values, value);
+		}
+	},
+	changes: {
+		enumerable: true,
+		get() {
+			return this[COLOR_SYMBOL].changes.events;
+		}
+	},
+	hex: {
+		enumerable: true,
+		get() {
+			return getColorValue(this, COLOR_TYPE.hex, false);
 		},
-		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
+		set(value) {
+			setHexColor(this, value, false);
+		}
+	},
+	hexa: {
+		enumerable: true,
+		get() {
+			return getColorValue(this, COLOR_TYPE.hex, true);
 		},
-		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 {
+		set(value) {
+			setHexColor(this, value, true);
+		}
+	},
+	hsl: {
 		enumerable: true,
-		get: () => getColorValue(space, state, alpha),
-		set: (value) => setValue(color, state, changes, value, alpha)
-	};
+		get() {
+			return getColorValue(this, COLOR_TYPE.hsl, false);
+		},
+		set(value) {
+			setHSLColor(this, value, false);
+		}
+	},
+	hsla: {
+		enumerable: true,
+		get() {
+			return getColorValue(this, COLOR_TYPE.hsl, true);
+		},
+		set(value) {
+			setHSLColor(this, value, true);
+		}
+	},
+	hwb: {
+		enumerable: true,
+		get() {
+			return getColorValue(this, COLOR_TYPE.hwb, false);
+		},
+		set(value) {
+			setHWBColor(this, value, false);
+		}
+	},
+	hwba: {
+		enumerable: true,
+		get() {
+			return getColorValue(this, COLOR_TYPE.hwb, true);
+		},
+		set(value) {
+			setHWBColor(this, value, true);
+		}
+	},
+	origin: {
+		enumerable: true,
+		get() {
+			return this[COLOR_SYMBOL].values.origin;
+		}
+	},
+	rgb: {
+		enumerable: true,
+		get() {
+			return getColorValue(this, COLOR_TYPE.rgb, false);
+		},
+		set(value) {
+			setRGBColor(this, value, false);
+		}
+	},
+	rgba: {
+		enumerable: true,
+		get() {
+			return getColorValue(this, COLOR_TYPE.rgb, true);
+		},
+		set(value) {
+			setRGBColor(this, value, true);
+		}
+	},
+	subscribe: { value: subscribeToColor },
+	toHexString: { value: formatHexColor },
+	toHslString: { value: formatHslColor },
+	toHwbString: { value: formatHwbColor },
+	toRgbString: { value: formatRgbColor },
+	toString: { value: formatHexColor },
+	unsubscribe: { value: unsubscribeFromColor }
+});
+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;
+function getColorValue(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: state.alpha.value
+		alpha: values.alpha.value
 	} : { ...value };
 }
 function onCreateSubscription(instance, event, callback) {
@@ -5714,16 +6035,13 @@ function onCreateSubscription(instance, event, callback) {
 function setAlphaValue(state, value) {
 	if (typeof value === "number" && !Number.isNaN(value)) state.alpha = getAlpha(value, false);
 }
-const colorSubscription = {
-	key: COLOR_PROPERTY.name,
-	value: SUBSCRIPTION_NAME
-};
-const setters = {
-	hex: setHexColor,
-	hsl: setHSLColor,
-	hwb: setHWBColor,
-	rgb: setRGBColor
-};
+function subscribeToColor(callback, signal) {
+	const { changes } = this[COLOR_SYMBOL];
+	return changes.subscribe(COLOR_TYPE.wildcard, callback, signal);
+}
+function unsubscribeFromColor() {
+	this[COLOR_SYMBOL].changes.clear();
+}
 //#endregion
 //#region src/color/index.ts
 /**
@@ -5859,46 +6177,73 @@ 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() {
+	for (const method of methods) {
+		const bound = console[method].bind(console);
+		Object.defineProperty(this, method, {
+			enumerable: true,
+			get() {
+				return enabled ? bound : noop;
+			}
+		});
+	}
+}
+Lumberjack.prototype[LOGGER_PROPERTY] = LOGGER_NAME;
+Object.defineProperties(Lumberjack.prototype, {
+	enabled: {
+		enumerable: true,
+		get: () => enabled,
+		set: (value) => {
+			enabled = typeof value === "boolean" ? value : enabled;
+		}
+	},
+	time: { value: (label) => new TimeLogger(getString(label)) }
+});
+function TimeLogger(label) {
+	Object.defineProperty(this, LOGGER_SYMBOL, { value: {
+		label,
+		started: enabled,
+		stopped: false
+	} });
+	this[LOGGER_SYMBOL].isActive = () => {
+		return this[LOGGER_SYMBOL].started && !this[LOGGER_SYMBOL].stopped && enabled;
+	};
+	if (this[LOGGER_SYMBOL].started) console.time(label);
+}
+TimeLogger.prototype[LOGGER_PROPERTY] = LOGGER_NAME_TIMED;
+Object.defineProperties(TimeLogger.prototype, {
+	active: {
+		enumerable: true,
+		get() {
+			return this[LOGGER_SYMBOL].isActive();
+		}
+	},
+	log: { get() {
+		const state = this[LOGGER_SYMBOL];
+		return state.isActive() ? console.timeLog.bind(console, state.label) : noop;
+	} },
+	stop: { get() {
+		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;
 }
-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);
-}
-const LOGGER_NAME = "Logger";
-const LOGGER_NAME_TIMED = "TimedLogger";
-const LOGGER_PROPERTY = "$logger";
+const LOGGER_SYMBOL = Symbol(LOGGER_PROPERTY);
 const methods = [
 	"debug",
 	"dir",
@@ -5914,27 +6259,7 @@ const methods = [
 *
 * _(Logging can be enabled or disabled by setting the `enabled` property)_
 */
-const Logger = (() => {
-	const instance = {};
-	Object.defineProperties(instance, {
-		[LOGGER_PROPERTY]: { value: LOGGER_NAME },
-		enabled: {
-			enumerable: true,
-			get: () => enabled,
-			set: (value) => {
-				enabled = typeof value === "boolean" ? value : enabled;
-			}
-		},
-		time: { value: (label) => timedLogger(getString(label)) }
-	});
-	for (const method of methods) Object.defineProperty(instance, method, {
-		enumerable: true,
-		get() {
-			return enabled ? console[method].bind(console) : noop;
-		}
-	});
-	return Object.freeze(instance);
-})();
+const Logger = new Lumberjack();
 let enabled = true;
 //#endregion
 //#region src/math.ts
@@ -6080,6 +6405,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 +6417,159 @@ 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) {
+	Object.defineProperty(this, QUEUE_SYMBOL, { value: {
+		callback,
+		options: createQueueOptions(options),
+		queues: /* @__PURE__ */ new Map()
+	} });
+}
+Object.defineProperties(KeyedQueue.prototype, {
+	[QUEUE_PROPERTY]: { value: QUEUE_NAME_KEYED },
+	active: {
+		enumerable: true,
+		get() {
+			return getStatus(this[QUEUE_SYMBOL], QUEUE_STATUS_ACTIVE);
+		}
+	},
+	add: { value: addKeyedQueue },
+	autostart: {
+		enumerable: true,
+		get() {
+			return this[QUEUE_SYMBOL].options.autostart;
+		}
+	},
+	clear: { value: clearQueues },
+	concurrency: {
+		enumerable: true,
+		get() {
+			return this[QUEUE_SYMBOL].options.concurrency;
+		}
+	},
+	empty: {
+		enumerable: true,
+		get() {
+			return getStatus(this[QUEUE_SYMBOL], QUEUE_STATUS_EMPTY);
+		}
+	},
+	full: {
+		enumerable: true,
+		get() {
+			return getStatus(this[QUEUE_SYMBOL], QUEUE_STATUS_FULL);
+		}
+	},
+	get: { value: getQueue },
+	items: {
+		enumerable: true,
+		get() {
+			return getQueueItems(this[QUEUE_SYMBOL]);
+		}
+	},
+	keys: {
+		enumerable: true,
+		get() {
+			return [...this[QUEUE_SYMBOL].queues.keys()];
+		}
+	},
+	maximum: {
+		enumerable: true,
+		get() {
+			return this[QUEUE_SYMBOL].options.maximum;
+		}
+	},
+	pause: { value: pauseQueues },
+	paused: {
+		enumerable: true,
+		get() {
+			return getStatus(this[QUEUE_SYMBOL], QUEUE_STATUS_PAUSED);
+		}
+	},
+	queues: {
+		enumerable: true,
+		get() {
+			return this[QUEUE_SYMBOL].queues.size;
+		}
+	},
+	remove: { value: removeQueue },
+	resume: { value: resumeQueues }
+});
+function Queue(callback, options, key) {
+	Object.defineProperty(this, QUEUE_SYMBOL, { value: {
+		callback,
+		key,
+		options,
+		handled: [],
+		id: 0,
+		items: [],
+		paused: !options.autostart,
+		runners: 0
+	} });
+}
+Object.defineProperties(Queue.prototype, {
+	[QUEUE_PROPERTY]: { value: QUEUE_NAME_QUEUE },
+	active: {
+		enumerable: true,
+		get() {
+			return this[QUEUE_SYMBOL].runners > 0;
+		}
+	},
+	add: { value: addToQueue },
+	autostart: {
+		enumerable: true,
+		get() {
+			return this[QUEUE_SYMBOL].options.autostart;
+		}
+	},
+	clear: { value: clearQueue },
+	concurrency: {
+		enumerable: true,
+		get() {
+			return this[QUEUE_SYMBOL].options.concurrency;
+		}
+	},
+	empty: {
+		enumerable: true,
+		get() {
+			return this[QUEUE_SYMBOL].items.length === 0;
+		}
+	},
+	full: {
+		enumerable: true,
+		get() {
+			const state = this[QUEUE_SYMBOL];
+			return state.options.maximum > 0 && state.items.length >= state.options.maximum;
+		}
+	},
+	maximum: {
+		enumerable: true,
+		get() {
+			return this[QUEUE_SYMBOL].options.maximum;
+		}
+	},
+	pause: { value: pauseQueue },
+	paused: {
+		enumerable: true,
+		get() {
+			return this[QUEUE_SYMBOL].paused;
+		}
+	},
+	remove: { value: removeQueued },
+	resume: { value: resumeQueue },
+	size: {
+		enumerable: true,
+		get() {
+			return this[QUEUE_SYMBOL].items.length;
+		}
+	}
+});
+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 +6593,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 +6602,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 +6617,9 @@ function createQueueOptions(input) {
 		maximum: getNumberOrDefault(options.maximum, 0)
 	};
 }
-function getQueue(state, key, add) {
+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);
@@ -6224,12 +6651,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 +6682,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 +6713,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 +6722,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 +6733,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 +6763,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,12 +6771,11 @@ 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
@@ -6514,4 +6895,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 };