@oscarpalmer/atoms 0.203.0 → 0.204.0

package/dist/index.mjs

@@ -114,7 +114,6 @@ function filter(array, ...parameters) {
 	return findValues("all", array, parameters).matched;
 }
 filter.remove = exclude;
-Object.defineProperty(filter, "remove", { value: exclude });
 //#endregion
 //#region src/array/first.ts
 function first(array, ...parameters) {
@@ -124,7 +123,6 @@ function firstOrDefault(array, defaultValue, ...parameters) {
 	return findAbsoluteValueOrDefault(array, parameters, defaultValue, true, false);
 }
 first.default = firstOrDefault;
-Object.defineProperty(first, "default", { value: firstOrDefault });
 //#endregion
 //#region src/internal/array/group.ts
 function groupValues(array, key, value, arrays) {
@@ -153,7 +151,6 @@ function groupArraysBy(array, first, second) {
 	return groupValues(array, first, second, true);
 }
 groupBy.arrays = groupArraysBy;
-Object.defineProperty(groupBy, "arrays", { value: groupArraysBy });
 //#endregion
 //#region src/internal/array/chunk.ts
 /**
@@ -379,13 +376,14 @@ function getArray(value, indiced) {
 	if (value instanceof Set) return [...value.values()];
 	if (isNonPlainObject(value)) return [value];
 	if (indiced !== true) return Object.entries(value);
-	const keys = Object.keys(value);
+	const obj = value;
+	const keys = Object.keys(obj);
 	const { length } = keys;
 	const array = [];
 	for (let index = 0; index < length; index += 1) {
 		const key = keys[index];
 		const asNumber = Number.parseInt(key, 10);
-		if (!Number.isNaN(asNumber)) array[asNumber] = value[key];
+		if (!Number.isNaN(asNumber)) array[asNumber] = obj[key];
 	}
 	return array;
 }
@@ -398,7 +396,6 @@ function lastIndexOf(array, ...parameters) {
 	return findValue(FIND_VALUE_INDEX, array, parameters, true);
 }
 indexOf.last = lastIndexOf;
-Object.defineProperty(indexOf, "last", { value: lastIndexOf });
 //#endregion
 //#region src/internal/array/match.ts
 function endsWithArray(haystack, needle, key) {
@@ -553,7 +550,6 @@ function findLast(array, ...parameters) {
 	return findValue(FIND_VALUE_ITEM, array, parameters, true);
 }
 find.last = findLast;
-Object.defineProperty(find, "last", { value: findLast });
 //#endregion
 //#region src/array/flatten.ts
 /**
@@ -689,7 +685,6 @@ function selectValues(array, parameters) {
 	}).matched;
 }
 select.reverse = reverseSelect;
-Object.defineProperty(select, "reverse", { value: reverseSelect });
 //#endregion
 //#region src/array/single.ts
 function single(array, ...parameters) {
@@ -818,7 +813,6 @@ function lastOrDefault(array, defaultValue, ...parameters) {
 	return findAbsoluteValueOrDefault(array, parameters, defaultValue, true, true);
 }
 last.default = lastOrDefault;
-Object.defineProperty(last, "default", { value: lastOrDefault });
 //#endregion
 //#region src/internal/array/overlap.ts
 function arraysOverlap(first, second) {
@@ -912,10 +906,6 @@ function moveToIndex(array, value, index, key) {
 }
 move.indices = moveIndices;
 move.toIndex = moveToIndex;
-Object.defineProperties(move, {
-	indices: { value: moveIndices },
-	toIndex: { value: moveToIndex }
-});
 //#endregion
 //#region src/internal/math/aggregate.ts
 function aggregate(type, array, key, first) {
@@ -1074,19 +1064,17 @@ function BaseHandler(owner, options) {
 	this.owner = owner;
 	this.options = options;
 }
-Object.defineProperties(BaseHandler.prototype, {
-	deregister: { value: deregisterHandler },
-	get: { value: getHandler$1 },
-	register: { value: registerHandler }
-});
+BaseHandler.prototype.deregister = deregisterHandler;
+BaseHandler.prototype.get = getHandler$1;
+BaseHandler.prototype.register = registerHandler;
 function CompareHandler(base) {
 	this.base = base;
 }
-Object.defineProperties(CompareHandler.prototype, { handle: { value: handleComparison } });
+CompareHandler.prototype.handle = handleComparison;
 function ValueHandler(value) {
 	this.base = value;
 }
-Object.defineProperties(ValueHandler.prototype, { handle: { value: handleValue$1 } });
+ValueHandler.prototype.handle = handleValue$1;
 function createBaseHandler(owner, options) {
 	return new BaseHandler(owner, options);
 }
@@ -1207,23 +1195,14 @@ const compareHandler = createCompareHandler(compare, {
 compare.deregister = deregisterComparator;
 compare.handler = compareHandler;
 compare.register = registerComparator;
-Object.defineProperties(compare, {
-	deregister: { value: deregisterComparator },
-	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 });
+	this[SORTER_SYMBOL] = sorters;
 }
-Object.defineProperties(Sorter.prototype, {
-	[SORTER_PROPERTY]: { value: true },
-	index: { value: getSortedArrayIndex },
-	is: { value: isSortedArray },
-	sort: { value: sortArray }
-});
+Sorter.prototype.index = getSortedArrayIndex;
+Sorter.prototype.is = isSortedArray;
+Sorter.prototype.sort = sortArray;
 function getComparisonSorter(callback, modifier) {
 	return {
 		modifier,
@@ -1235,7 +1214,7 @@ function getComparisonSorter(callback, modifier) {
 function getComparisonValue(first, second, sorters, length) {
 	for (let index = 0; index < length; index += 1) {
 		const sorter = sorters[index];
-		const values = [sorter.get ? sorter.value(first) : first, sorter.get ? sorter.value(second) : second];
+		const values = [sorter.get ? sorter.value?.(first) : first, sorter.get ? sorter.value?.(second) : second];
 		const comparison = (sorter.comparison?.complex?.(first, values[0], second, values[1]) ?? sorter.comparison?.simple?.(values[0], values[1]) ?? compare(values[0], values[1])) * sorter.modifier;
 		if (comparison !== 0) return comparison;
 	}
@@ -1350,7 +1329,7 @@ const SORT_PEEK_PERCENTAGE = 10;
 const SORT_THRESHOLD = 100;
 const SORT_DIRECTION_ASCENDING = "ascending";
 const SORT_DIRECTION_DESCENDING = "descending";
-const SORTER_SYMBOL = Symbol(SORTER_PROPERTY);
+const SORTER_SYMBOL = Symbol("sorter");
 const modifiers = {
 	[SORT_DIRECTION_ASCENDING]: 1,
 	[SORT_DIRECTION_DESCENDING]: -1
@@ -1358,11 +1337,6 @@ const modifiers = {
 sort.getIndex = getSortedIndex;
 sort.initialize = initializeSorter;
 sort.is = isSorted;
-Object.defineProperties(sort, {
-	getIndex: { value: getSortedIndex },
-	initialize: { value: initializeSorter },
-	is: { value: isSorted }
-});
 //#endregion
 //#region src/array/swap.ts
 function swap(array, first, second, third) {
@@ -1420,7 +1394,6 @@ function swapValues(array, from, to, key) {
 	return swapIndices(array, first, second);
 }
 swap.indices = swapIndices;
-Object.defineProperty(swap, "indices", { value: swapIndices });
 //#endregion
 //#region src/array/to-map.ts
 function getMapValues(array, first, second, arrays) {
@@ -1447,7 +1420,6 @@ function toMapArrays(array, first, second) {
 	return getMapValues(array, first, second, true);
 }
 toMap.arrays = toMapArrays;
-Object.defineProperty(toMap, "arrays", { value: toMapArrays });
 //#endregion
 //#region src/array/to-record.ts
 function toRecord(array, first, second) {
@@ -1457,7 +1429,6 @@ function toRecordArrays(array, first, second) {
 	return groupValues(array, first, second, true);
 }
 toRecord.arrays = toRecordArrays;
-Object.defineProperty(toRecord, "arrays", { value: toRecordArrays });
 //#endregion
 //#region src/internal/function/misc.ts
 /**
@@ -1478,33 +1449,29 @@ 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: {
+	this[LIMITER_SYMBOL] = {
 		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 }
-});
+AsyncLimiter.prototype[LIMITER_PROPERTY] = LIMITER_NAME_ASYNC;
+AsyncLimiter.prototype.cancel = cancelAsyncLimiter;
+AsyncLimiter.prototype.run = runAsyncLimiter;
 function Limiter(type, callback, time) {
-	Object.defineProperty(this, LIMITER_SYMBOL, { value: {
+	this[LIMITER_SYMBOL] = {
 		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 }
-});
+Limiter.prototype[LIMITER_PROPERTY] = LIMITER_NAME_SYNC;
+Limiter.prototype.cancel = cancelLimiter;
+Limiter.prototype.run = runLimiter;
 function cancelAsyncLimiter() {
 	const state = this[LIMITER_SYMBOL];
 	if (state.timer != null) clearTimer(state.timer);
@@ -1636,8 +1603,6 @@ function throttle(callback, time) {
 }
 debounce.async = asyncDebounce;
 throttle.async = asyncThrottle;
-Object.defineProperty(debounce, "async", { value: asyncDebounce });
-Object.defineProperty(throttle, "async", { value: asyncThrottle });
 //#endregion
 //#region src/internal/result/misc.ts
 function error(value, original) {
@@ -1667,8 +1632,7 @@ function isResult(value) {
 	return isResultValue(value, true) || isResultValue(value, false);
 }
 function isResultValue(value, okValue) {
-	if (isNonPlainObject(value)) return false;
-	return value.ok === okValue && (okValue ? RESULT_PROPERTY_VALUE : RESULT_PROPERTY_ERROR) in value;
+	return isPlainObject(value) && value.ok === okValue && (okValue ? RESULT_PROPERTY_VALUE : RESULT_PROPERTY_ERROR) in value;
 }
 /**
 * Creates an ok result
@@ -1689,8 +1653,6 @@ 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) {
@@ -1722,9 +1684,10 @@ function getPaths(path, lowercase) {
 function handleValue(data, path, value, get, ignoreCase) {
 	if (typeof data === "object" && data !== null) {
 		if (ignoreKey(path)) return error(MISC_NESTED_MESSAGE_UNSAFE);
-		const key = ignoreCase ? findKey(path, data) : path;
-		if (get) return key in data ? ok(data[key]) : error(MISC_NESTED_MESSAGE_MISSING);
-		data[key] = typeof value === "function" ? value(data[key]) : value;
+		const dataObject = data;
+		const key = ignoreCase ? findKey(path, dataObject) : path;
+		if (get) return key in dataObject ? ok(dataObject[key]) : error(MISC_NESTED_MESSAGE_MISSING);
+		dataObject[key] = typeof value === "function" ? value(dataObject[key]) : value;
 	}
 	if (get) return error(MISC_NESTED_MESSAGE_MISSING);
 }
@@ -1744,7 +1707,6 @@ function hasValueResult(data, path, ignoreCase) {
 	return getNestedValue(data, path, ignoreCase === true);
 }
 hasValue.get = hasValueResult;
-Object.defineProperty(hasValue, "get", { value: hasValueResult });
 //#endregion
 //#region src/internal/function/assert.ts
 /**
@@ -1839,20 +1801,13 @@ assert.defined = assertDefined;
 assert.instanceOf = assertInstanceOf;
 assert.is = assertIs;
 assert.property = assertProperty;
-Object.defineProperties(assert, {
-	condition: { value: assertCondition },
-	defined: { value: assertDefined },
-	instanceOf: { value: assertInstanceOf },
-	is: { value: assertIs },
-	property: { value: assertProperty }
-});
 //#endregion
 //#region src/function/once.ts
 const ONCE_NAME_ASYNC = "asyncOnce";
 const ONCE_NAME_SYNC = "once";
 const ONCE_PROPERTY = "$once";
 function AsyncOnce(callback) {
-	Object.defineProperty(this, ONCE_SYMBOL, { value: {
+	this[ONCE_SYMBOL] = {
 		callback,
 		called: false,
 		cleared: false,
@@ -1860,61 +1815,49 @@ function AsyncOnce(callback) {
 		finished: false,
 		items: [],
 		value: void 0
-	} });
+	};
 }
+AsyncOnce.prototype[ONCE_PROPERTY] = ONCE_NAME_ASYNC;
+AsyncOnce.prototype.clear = clearOnce;
+AsyncOnce.prototype.run = runOnceAsync;
 Object.defineProperties(AsyncOnce.prototype, {
-	[ONCE_PROPERTY]: { value: ONCE_NAME_ASYNC },
 	called: {
 		enumerable: true,
-		get() {
-			return this[ONCE_SYMBOL].called;
-		}
+		get: getOnceCalled
 	},
-	clear: { value: clearOnce },
 	cleared: {
 		enumerable: true,
-		get() {
-			return this[ONCE_SYMBOL].cleared;
-		}
+		get: getOnceCleared
 	},
 	error: {
 		enumerable: true,
-		get() {
-			return this[ONCE_SYMBOL].error;
-		}
+		get: getAsyncOnceError
 	},
 	finished: {
 		enumerable: true,
-		get() {
-			return this[ONCE_SYMBOL].finished;
-		}
-	},
-	run: { value: runOnceAsync }
+		get: getAsyncOnceFinished
+	}
 });
 function Once(callback) {
-	Object.defineProperty(this, ONCE_SYMBOL, { value: {
+	this[ONCE_SYMBOL] = {
 		callback,
 		called: false,
 		cleared: false,
 		value: void 0
-	} });
+	};
 }
+Once.prototype[ONCE_PROPERTY] = ONCE_NAME_SYNC;
+Once.prototype.clear = clearOnce;
+Once.prototype.run = runOnce;
 Object.defineProperties(Once.prototype, {
-	[ONCE_PROPERTY]: { value: ONCE_NAME_SYNC },
-	clear: { value: clearOnce },
 	called: {
 		enumerable: true,
-		get() {
-			return this[ONCE_SYMBOL].called;
-		}
+		get: getOnceCalled
 	},
 	cleared: {
 		enumerable: true,
-		get() {
-			return this[ONCE_SYMBOL].cleared;
-		}
-	},
-	run: { value: runOnce }
+		get: getOnceCleared
+	}
 });
 /**
 * Create an asynchronous function that can only be called once, rejecting or resolving the same result on subsequent calls
@@ -1935,6 +1878,18 @@ function clearOnce() {
 	state.cleared = true;
 	state.value = void 0;
 }
+function getAsyncOnceError() {
+	return this[ONCE_SYMBOL].error;
+}
+function getAsyncOnceFinished() {
+	return this[ONCE_SYMBOL].finished;
+}
+function getOnceCalled() {
+	return this[ONCE_SYMBOL].called;
+}
+function getOnceCleared() {
+	return this[ONCE_SYMBOL].cleared;
+}
 function handleOnceResult(state, value, error) {
 	state.error = error;
 	state.finished = true;
@@ -2016,12 +1971,6 @@ asyncOnce.is = isAsyncOnce;
 once.async = 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
 /**
@@ -2105,7 +2054,6 @@ const RETRY_ERROR_NAME = "RetryError";
 const RETRY_MESSAGE_EXPECTATION = "Retry expected a function";
 const RETRY_MESSAGE_FAILED = "Retry failed";
 retry.async = asyncRetry;
-Object.defineProperty(retry, "async", { value: asyncRetry });
 //#endregion
 //#region src/internal/function/work.ts
 function asyncFlow(...fns) {
@@ -2166,8 +2114,6 @@ const assertFlowFunctions = assert.condition((value) => Array.isArray(value) &&
 const assertPipeFunctions = assert.condition((value) => Array.isArray(value) && value.every((item) => typeof item === "function"), WORK_MESSAGE_PIPE_ARRAY, TypeError);
 flow.async = asyncFlow;
 pipe.async = asyncPipe;
-Object.defineProperty(flow, "async", { value: asyncFlow });
-Object.defineProperty(pipe, "async", { value: asyncPipe });
 //#endregion
 //#region src/internal/number.ts
 /**
@@ -2305,32 +2251,28 @@ 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: {
+	this[MEMOIZED_SYMBOL] = {
 		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
-		}
-	});
 }
+Memoized.prototype.clear = clearMemoized;
+Memoized.prototype.delete = deleteMemoizedValue;
+Memoized.prototype.get = getMemoizedValue;
+Memoized.prototype.has = hasMemoizedValue;
+Memoized.prototype.run = runMemoized;
 Object.defineProperties(Memoized.prototype, {
-	[MEMOIZED_PROPERTY]: { value: true },
-	clear: { value: clearMemoized },
-	delete: { value: deleteMemoizedValue },
-	get: { value: getMemoizedValue },
-	has: { value: hasMemoizedValue },
-	run: { value: runMemoized }
+	maximum: {
+		enumerable: true,
+		get: getMemoizedMaximum
+	},
+	size: {
+		enumerable: true,
+		get: getMemoizedSize
+	}
 });
 function clearMemoized() {
 	this[MEMOIZED_SYMBOL].cache.clear();
@@ -2354,6 +2296,12 @@ function createMemoizationOptions(input) {
 		cacheSize: getNumberOrDefault(cacheSize, MEMOIZED_CACHE_SIZE_DEFAULT)
 	};
 }
+function getMemoizedMaximum() {
+	return this[MEMOIZED_SYMBOL].cache.maximum;
+}
+function getMemoizedSize() {
+	return this[MEMOIZED_SYMBOL].cache.size;
+}
 function getMemoizedValue(key) {
 	return this[MEMOIZED_SYMBOL].cache.get(key);
 }
@@ -2377,7 +2325,7 @@ function runMemoized(...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);
+const MEMOIZED_SYMBOL = Symbol("memoized");
 //#endregion
 //#region src/internal/string/case.ts
 /**
@@ -2516,13 +2464,11 @@ let memoizedUpperCase;
 //#endregion
 //#region src/internal/value/equal.ts
 function Equalizer(options) {
-	Object.defineProperty(this, EQUAL_SYMBOL, { value: options });
+	this[EQUAL_SYMBOL] = options;
 }
-Object.defineProperties(Equalizer.prototype, {
-	compare: { value: compare$1 },
-	deregister: { value: deregisterEqualizer },
-	register: { value: registerEqualizer }
-});
+Equalizer.prototype.compare = compare$1;
+Equalizer.prototype.deregister = deregisterEqualizer;
+Equalizer.prototype.register = registerEqualizer;
 function compare$1(first, second) {
 	return equalValue(first, second, this[EQUAL_SYMBOL]);
 }
@@ -2695,12 +2641,6 @@ 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) {
@@ -2725,7 +2665,7 @@ function setValue(data, path, value, ignoreCase) {
 			handleValue(target, currentPath, value, false, shouldIgnoreCase);
 			break;
 		}
-		let next = handleValue(target, currentPath, null, true, shouldIgnoreCase).value;
+		let next = unwrap(handleValue(target, currentPath, null, true, shouldIgnoreCase), void 0);
 		if (typeof next !== "object" || next === null) {
 			const nextPath = paths[index + 1];
 			if (SET_EXPRESSION_INDEX.test(nextPath)) next = Array.from({ length: Number(nextPath) + 1 }, () => void 0);
@@ -2738,7 +2678,7 @@ function setValue(data, path, value, ignoreCase) {
 }
 const SET_EXPRESSION_INDEX = /^\d+$/;
 //#endregion
-//#region src/internal/abort.ts
+//#region src/internal/aborter.ts
 function createAborter(value, onAbort) {
 	if (!(value instanceof AbortSignal)) return;
 	value.addEventListener(ABORT_EVENT, onAbort, ABORT_OPTIONS);
@@ -2805,7 +2745,7 @@ function createPromiseOptions(input) {
 		signal: input,
 		time: 0
 	};
-	const options = typeof input === "object" && input !== null ? input : {};
+	const options = isPlainObject(input) ? input : {};
 	return {
 		signal: options.signal instanceof AbortSignal ? options.signal : void 0,
 		time: getNumberOrDefault(options.time, 0)
@@ -2817,7 +2757,7 @@ function createPromisesOptions(input) {
 		signal: input,
 		strategy: PROMISE_STRATEGY_DEFAULT
 	};
-	const options = typeof input === "object" && input !== null ? input : {};
+	const options = isPlainObject(input) ? input : {};
 	return {
 		signal: options.signal instanceof AbortSignal ? options.signal : void 0,
 		strategy: getStrategyOrDefault(options.strategy)
@@ -2856,7 +2796,7 @@ function isRejected(value) {
 	return isType(value, PROMISE_TYPE_REJECTED);
 }
 function isType(value, type) {
-	return typeof value === "object" && value !== null && value.status === type;
+	return isPlainObject(value) && "status" in value && value.status === type;
 }
 //#endregion
 //#region src/result/misc.ts
@@ -3026,7 +2966,6 @@ async function resultPromises(items, signal) {
 	return promises(items, signal).then(getResultsFromPromises);
 }
 promises.result = resultPromises;
-Object.defineProperty(promises, "result", { value: resultPromises });
 //#endregion
 //#region src/result/index.ts
 async function asyncAttempt(value, err) {
@@ -3046,7 +2985,6 @@ function attempt(callback, err) {
 	}
 }
 attempt.async = asyncAttempt;
-Object.defineProperty(attempt, "async", { value: asyncAttempt });
 //#endregion
 //#region src/result/match.ts
 async function asyncMatchResult(result, first, error) {
@@ -3072,7 +3010,6 @@ function matchResult(result, first, error) {
 }
 const MATCH_MESSAGE = "`result.match` expected a Result or a function that returns a Result";
 matchResult.async = asyncMatchResult;
-Object.defineProperty(matchResult, "async", { value: asyncMatchResult });
 //#endregion
 //#region src/result/work/flow.ts
 function attemptAsyncFlow(...fns) {
@@ -3096,7 +3033,6 @@ function attemptFlow(...fns) {
 	});
 }
 attemptFlow.async = attemptAsyncFlow;
-Object.defineProperty(attemptFlow, "async", { value: attemptAsyncFlow });
 //#endregion
 //#region src/result/work/pipe.ts
 async function attemptAsyncPipe(initial, first, ...seconds) {
@@ -3116,7 +3052,6 @@ function attemptPipe(initial, first, ...seconds) {
 	});
 }
 attemptPipe.async = attemptAsyncPipe;
-Object.defineProperty(attemptPipe, "async", { value: attemptAsyncPipe });
 //#endregion
 //#region src/string/match.ts
 /**
@@ -3169,27 +3104,24 @@ const matchMemoizers = {};
 const FUZZY_PROPERTY = "$fuzzy";
 const FUZZY_SYMBOL = Symbol(FUZZY_PROPERTY);
 function Fuzzy(state) {
-	Object.defineProperty(this, FUZZY_SYMBOL, { value: state });
+	this[FUZZY_SYMBOL] = state;
 }
+Fuzzy.prototype[FUZZY_PROPERTY] = true;
+Fuzzy.prototype.search = search;
 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);
-		}
+		get: getFuzzyItems,
+		set: setFuzzyItems
 	},
-	search: { value: search },
 	strings: {
 		enumerable: true,
-		get() {
-			return this[FUZZY_SYMBOL].strings.slice();
-		}
+		get: getFuzzyStrings
 	}
 });
+function createFuzzyItems(items) {
+	return items.sort((first, second) => first.haystack.localeCompare(second.haystack)).map(({ item }) => item);
+}
 function createFuzzyOptions(input, state) {
 	const options = isPlainObject(input) ? input : {};
 	const limit = typeof input === "number" ? input : options.limit;
@@ -3238,8 +3170,11 @@ function getHandler(input) {
 			throw new TypeError(FUZZY_MESSAGE_HANDLER);
 	}
 }
-function getFuzzyItems(items) {
-	return items.sort((first, second) => first.haystack.localeCompare(second.haystack)).map(({ item }) => item);
+function getFuzzyItems() {
+	return this[FUZZY_SYMBOL].items.slice();
+}
+function getFuzzyStrings() {
+	return this[FUZZY_SYMBOL].strings.slice();
 }
 function getScore(haystack, needle) {
 	if (!isSubsequence(haystack, needle)) return -1;
@@ -3334,16 +3269,17 @@ function search(input, option) {
 		for (let index = 0; index < length; index += 1) {
 			const key = keys[index];
 			if (maxScore - key > options.tolerance) break;
-			similar.push(...getFuzzyItems(scored[key]));
+			similar.push(...createFuzzyItems(scored[key]));
 		}
 	}
-	result.exact = getFuzzyItems(options.limit == null ? exact : exact.slice(0, options.limit));
+	result.exact = createFuzzyItems(options.limit == null ? exact : exact.slice(0, options.limit));
 	if (options.limit == null) result.similar = similar;
 	else result.similar = similar.slice(0, options.limit - result.exact.length);
 	return result;
 }
-function setItems(state, value) {
+function setFuzzyItems(value) {
 	if (!Array.isArray(value)) throw new TypeError(FUZZY_MESSAGE_ARRAY);
+	const state = this[FUZZY_SYMBOL];
 	state.items = value.slice();
 	state.strings = value.map(state.handler);
 }
@@ -3353,10 +3289,6 @@ const FUZZY_MESSAGE_HANDLER = "Fuzzy requires a key or function to stringify ite
 const FUZZY_PROXIMITY_THRESHOLD = 5;
 fuzzy.is = isFuzzy;
 fuzzy.match = fuzzyMatch;
-Object.defineProperties(fuzzy, {
-	is: { value: isFuzzy },
-	match: { value: fuzzyMatch }
-});
 //#endregion
 //#region src/string/index.ts
 function dedent(value, ...values) {
@@ -3454,9 +3386,9 @@ const STRING_ZERO = "0";
 //#endregion
 //#region src/string/normalize.ts
 function Normalizer(options) {
-	Object.defineProperty(this, NORMALIZE_SYMBOL, { value: options });
+	this[NORMALIZE_SYMBOL] = options;
 }
-Object.defineProperties(Normalizer.prototype, { normalize: { value: normalizeString } });
+Normalizer.prototype.normalize = normalizeString;
 function createNormalizeOptions(input) {
 	const options = isPlainObject(input) ? input : {};
 	return {
@@ -3559,13 +3491,12 @@ const NORMALIZE_WHITESPACE_PATTERN = /\s+/g;
 const NORMALIZE_WHITESPACE_REPLACEMENT = " ";
 let deburrMemoizer;
 normalize.initialize = initializeNormalizer;
-Object.defineProperty(normalize, "initialize", { value: initializeNormalizer });
 //#endregion
 //#region src/string/template.ts
 function Templater(options) {
-	Object.defineProperty(this, TEMPLATE_SYMBOL, { value: options });
+	this[TEMPLATE_SYMBOL] = options;
 }
-Object.defineProperties(Templater.prototype, { render: { value: render } });
+Templater.prototype.render = render;
 function createTemplateOptions(input) {
 	const options = isPlainObject(input) ? input : {};
 	return {
@@ -3614,18 +3545,15 @@ function template(value, ...parameters) {
 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 });
+	this[CLONE_SYMBOL] = options;
 }
-Object.defineProperties(Cloner.prototype, {
-	clone: { value: cloneFromCloner },
-	deregister: { value: deregisterCloner },
-	register: { value: registerCloner }
-});
+Cloner.prototype.clone = cloneFromCloner;
+Cloner.prototype.deregister = deregisterCloner;
+Cloner.prototype.register = registerCloner;
 function clone(value, options) {
 	return cloneAny(value, { copy: false }, 0, options);
 }
@@ -3809,12 +3737,6 @@ clone.deregister = deregisterCloner;
 clone.handlers = cloneHandler;
 clone.initialize = initializeCloner;
 clone.register = registerCloner;
-Object.defineProperties(clone, {
-	deregister: { value: deregisterCloner },
-	handler: { value: cloneHandler },
-	initialize: { value: initializeCloner },
-	register: { value: registerCloner }
-});
 //#endregion
 //#region src/value/collection.ts
 function inMap(map, value, key) {
@@ -4020,14 +3942,10 @@ function isFrozen(value) {
 const frozenValues = /* @__PURE__ */ new WeakSet();
 freeze.flat = flatFreeze;
 freeze.is = isFrozen;
-Object.defineProperties(freeze, {
-	flat: { value: flatFreeze },
-	is: { value: isFrozen }
-});
 //#endregion
 //#region src/internal/value/partial.ts
 function partial(value, providedKeys, omit) {
-	if (typeof value !== "object" || value === null) return {};
+	if (!isPlainObject(value)) return {};
 	const keys = omit ? Object.keys(value) : Array.isArray(providedKeys) ? providedKeys : [];
 	const { length } = keys;
 	if (length === 0) return omit ? value : {};
@@ -4157,16 +4075,16 @@ function unsmush(value) {
 //#endregion
 //#region src/value/merge.ts
 function Assigner(options) {
-	Object.defineProperty(this, MERGE_SYMBOL_ASSIGN, { value: {
+	this[MERGE_SYMBOL_ASSIGN] = {
 		...options,
 		assignValues: true
-	} });
+	};
 }
-Object.defineProperties(Assigner.prototype, { assign: { value: assignFromAssigner } });
+Assigner.prototype.assign = assignFromAssigner;
 function Merger(options) {
-	Object.defineProperty(this, MERGE_SYMBOL_MERGE, { value: options });
+	this[MERGE_SYMBOL_MERGE] = options;
 }
-Object.defineProperties(Merger.prototype, { merge: { value: mergeFromMerger } });
+Merger.prototype.merge = mergeFromMerger;
 /**
 * Assign values from one or more objects to the first one
 *
@@ -4270,12 +4188,10 @@ 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 Transformer(transformer) {
-	Object.defineProperty(this, TRANSFORM_SYMBOL, { value: transformer });
+	this[TRANSFORM_SYMBOL] = transformer;
 }
 Object.defineProperties(Transformer.prototype, { transform: { value: transformValue } });
 function getTransformHandler(input) {
@@ -4313,47 +4229,38 @@ function transformValue(value) {
 }
 const TRANSFORM_SYMBOL = Symbol("transform");
 transform.initialize = initializeTransformer;
-Object.defineProperty(transform, "initialize", { value: initializeTransformer });
 //#endregion
 //#region src/internal/subscription.ts
 const SUBSCRIPTION_NAME = "subscription";
 const SUBSCRIPTION_PROPERTY = "$subscription";
 const SUBSCRIPTION_STORE = "subscriptions";
 function Subscription(state, property, parameters) {
-	Object.defineProperty(this, SUBSCRIPTION_SYMBOL, { value: state });
+	this[SUBSCRIPTION_SYMBOL] = state;
+	this[property.key] = property.value;
 	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 }
+Subscription.prototype[SUBSCRIPTION_PROPERTY] = SUBSCRIPTION_NAME;
+Subscription.prototype.unsubscribe = removeSubscription;
+Object.defineProperty(Subscription.prototype, "active", {
+	enumerable: true,
+	get: getSubscriptionActive
 });
 function Subscriptions(parameters) {
 	const { keys, property } = createSubscriptionsParameters(parameters);
-	Object.defineProperty(this, SUBSCRIPTION_SYMBOL, { value: createSubscriptionsState(property, keys) });
+	this[SUBSCRIPTION_SYMBOL] = createSubscriptionsState(property, keys);
 }
+Subscriptions.prototype[SUBSCRIPTION_PROPERTY] = SUBSCRIPTION_STORE;
+Subscriptions.prototype.clear = clearSubscriptions;
+Subscriptions.prototype.create = createSubscription;
 Object.defineProperties(Subscriptions.prototype, {
-	[SUBSCRIPTION_PROPERTY]: { value: SUBSCRIPTION_STORE },
-	clear: { value: clearSubscriptions },
-	create: { value: createSubscription },
 	items: {
 		enumerable: true,
-		get() {
-			return this[SUBSCRIPTION_SYMBOL].items;
-		}
+		get: getSubscriptionsItems
 	},
 	values: {
 		enumerable: true,
-		get() {
-			return this[SUBSCRIPTION_SYMBOL].values;
-		}
+		get: getSubscriptionsValues
 	}
 });
 function addSubscription(instance) {
@@ -4416,6 +4323,16 @@ function getExistingSubscription(subscriptions, state) {
 	const { parameters } = state;
 	return isKey(parameters.key) ? values.from.keyed?.get(parameters.key)?.get(parameters.value) : values.from.any.get(parameters.value);
 }
+function getSubscriptionActive() {
+	const state = this[SUBSCRIPTION_SYMBOL];
+	return (state.parameters?.isActive?.() ?? true) && state.active;
+}
+function getSubscriptionsItems() {
+	return this[SUBSCRIPTION_SYMBOL].items;
+}
+function getSubscriptionsValues() {
+	return this[SUBSCRIPTION_SYMBOL].values;
+}
 function createSubscriptionParameters(input) {
 	const values = isPlainObject(input) ? input : {};
 	if (values.value == null) throw new Error(SUBSCRIPTION_INVALID_VALUE);
@@ -4534,54 +4451,43 @@ const BEACON_PROPERTY = "$beacon";
 const BEACON_NAME = "beacon";
 const BEACON_OBSERVABLE = "observable";
 function Beacon(value, options) {
-	Object.defineProperty(this, BEACON_SYMBOL, { value: {
+	this[BEACON_SYMBOL] = {
 		value,
 		active: true,
 		options: createBeaconOptions(options)
-	} });
+	};
 }
+Beacon.prototype[BEACON_PROPERTY] = BEACON_NAME;
+Beacon.prototype.deactivate = deactivateBeacon;
+Beacon.prototype.emit = emitBeaconValue;
+Beacon.prototype.error = emitBeaconError;
+Beacon.prototype.finish = finishBeacon;
 Object.defineProperties(Beacon.prototype, {
-	[BEACON_PROPERTY]: { value: BEACON_NAME },
 	active: {
 		enumerable: true,
-		get() {
-			return this[BEACON_SYMBOL].active;
-		}
+		get: getBeaconActive
 	},
-	deactivate: { value: deactivateBeacon },
-	emit: { value: emitBeaconValue },
-	error: { value: emitBeaconError },
-	finish: { value: finishBeacon },
 	observable: {
 		enumerable: true,
-		get() {
-			return getObservable(this[BEACON_SYMBOL]);
-		}
+		get: getBeaconObservable
 	},
 	value: {
 		enumerable: true,
-		get() {
-			return this[BEACON_SYMBOL].value;
-		}
+		get: getBeaconValue
 	}
 });
 function Observable(beacon) {
-	Object.defineProperty(this, BEACON_SYMBOL, { value: {
+	this[BEACON_SYMBOL] = {
 		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 }
+Observable.prototype[BEACON_PROPERTY] = BEACON_OBSERVABLE;
+Observable.prototype.deactivate = deactiveateObservable;
+Observable.prototype.subscribe = subscribeToObservable;
+Object.defineProperty(Observable.prototype, "active", {
+	enumerable: true,
+	get: getObservableActive
 });
 /**
 * Create a new beacon
@@ -4606,8 +4512,7 @@ function closeBeacon(state, emit) {
 }
 function createBeaconOptions(input) {
 	const options = isPlainObject(input) ? input : {};
-	options.equal = typeof options.equal === "function" ? options.equal : Object.is;
-	return options;
+	return { equal: typeof options.equal === "function" ? options.equal : Object.is };
 }
 function createObserver(first, second, third) {
 	let observer = { next: noop };
@@ -4617,9 +4522,10 @@ function createObserver(first, second, third) {
 		complete: getObservableCallback(third)
 	};
 	else if (typeof first === "object") {
-		observer.complete = getObservableCallback(first?.complete);
-		observer.error = getObservableCallback(first?.error);
-		observer.next = getObservableCallback(first?.next);
+		const object = first;
+		observer.complete = getObservableCallback(object?.complete);
+		observer.error = getObservableCallback(object?.error);
+		observer.next = getObservableCallback(object?.next);
 	}
 	return observer;
 }
@@ -4638,11 +4544,22 @@ function emitBeaconValue(value, finish) {
 function finishBeacon() {
 	closeBeacon(this[BEACON_SYMBOL], true);
 }
-function getObservable(state) {
+function getBeaconActive() {
+	return this[BEACON_SYMBOL].active;
+}
+function getBeaconObservable() {
+	const state = this[BEACON_SYMBOL];
 	if (!state.active) throw new Error(BEACON_MESSAGE_RETRIEVE);
 	state.observable ??= new Observable(state);
 	return state.observable;
 }
+function getBeaconValue() {
+	return this[BEACON_SYMBOL].value;
+}
+function getObservableActive() {
+	const state = this[BEACON_SYMBOL];
+	return state.beacon.active && state.active;
+}
 function getObservableCallback(value) {
 	return typeof value === "function" ? value : noop;
 }
@@ -4656,7 +4573,7 @@ function isBeacon(value) {
 	return isBeaconInstance(BEACON_NAME, value);
 }
 function isBeaconInstance(name, value) {
-	return typeof value === "object" && value !== null && value[BEACON_PROPERTY] === name;
+	return typeof value === "object" && value !== null && BEACON_PROPERTY in value && value[BEACON_PROPERTY] === name;
 }
 /**
 * Is the value a beacon subscription?
@@ -4718,23 +4635,19 @@ function Events(herald, state) {
 }
 Events.prototype[HERALD_PROPERTY] = HERALD_NAME_EVENTS;
 function Herald(state) {
-	Object.defineProperty(this, HERALD_SYMBOL, { value: {
+	this[HERALD_SYMBOL] = {
 		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 }
+Herald.prototype[HERALD_PROPERTY] = HERALD_NAME_HERALD;
+Herald.prototype.clear = clearHerald;
+Herald.prototype.emit = emitForHerald;
+Herald.prototype.observed = eventIsObserved;
+Herald.prototype.subscribe = subscribeToHerald;
+Object.defineProperty(Herald.prototype, "events", {
+	enumerable: true,
+	get: getHeraldEvents
 });
 function clearHerald() {
 	this[HERALD_SYMBOL].state.store.clear();
@@ -4771,6 +4684,9 @@ function emitForHerald(event, ...parameters) {
 function eventIsObserved(event) {
 	return (this[HERALD_SYMBOL].state.store.items.keyed?.get(event)?.size ?? 0) > 0;
 }
+function getHeraldEvents() {
+	return this[HERALD_SYMBOL].events;
+}
 /**
 * Create a _Herald_ for announcing named events
 *
@@ -4809,7 +4725,7 @@ function isHeraldInstance(name, value) {
 * @returns `true` if the value is a herald subscription, otherwise `false`
 */
 function isHeraldSubscription(value) {
-	return isSubscription(value) && value[HERALD_PROPERTY] === "subscription";
+	return isSubscription(value) && HERALD_PROPERTY in value && value[HERALD_PROPERTY] === "subscription";
 }
 function subscribeToHerald(key, callback, signal) {
 	const { state } = this[HERALD_SYMBOL];
@@ -4969,6 +4885,9 @@ function getAlpha(value, hex) {
 	};
 	return getAlphaFromValue(Number.parseFloat(value));
 }
+function getColorAlpha() {
+	return this[COLOR_SYMBOL].values.alpha.value;
+}
 function getAlphaHexadecimal(value) {
 	if (value === COLOR_ALPHA.noneValue) return COLOR_ALPHA.noneHex;
 	if (value === COLOR_MAX.percent) return COLOR_ALPHA.fullHexLong;
@@ -4985,6 +4904,9 @@ function getAlphaValue(original) {
 	if (Number.isNaN(original)) return COLOR_MAX.percent;
 	return clamp(original, COLOR_ALPHA.noneValue, COLOR_MAX.percent);
 }
+function setColorAlpha(value) {
+	if (typeof value === "number" && !Number.isNaN(value)) this[COLOR_SYMBOL].values.alpha = getAlpha(value, false);
+}
 //#endregion
 //#region src/color/misc/get.ts
 function getClampedValue(value, minimum, maximum, rounding) {
@@ -5144,11 +5066,12 @@ function isBytey(value) {
 function isColor(value) {
 	return typeof value === "object" && value !== null && "$color" in value && value["$color"] === "color";
 }
-function isColorValue(obj, properties) {
-	if (typeof obj !== "object" || obj === null) return false;
-	const keys = Object.keys(obj);
+function isColorValue(value, properties) {
+	if (typeof value !== "object" || value === null) return false;
+	const keys = Object.keys(value);
 	const { length } = keys;
 	if (length !== properties.length) return false;
+	const obj = value;
 	for (let index = 0; index < length; index += 1) {
 		const key = keys[index];
 		if (!(properties.includes(key) && validators[key](obj[key]))) return false;
@@ -5276,7 +5199,7 @@ function convertRgbToHex(rgb, alpha) {
 	return `${hex}${a}`;
 }
 function convertRgbToHsla(value) {
-	const values = getRgbValues(isRgbLike(value) ? getRgbValue(value) : { ...COLOR_DEFAULTS.rgb });
+	const values = getRgbCalculationValues(isRgbLike(value) ? getRgbValues(value) : { ...COLOR_DEFAULTS.rgb });
 	const { delta, max, min } = values;
 	const lightness = (min + max) / 2;
 	let hue = 0;
@@ -5294,7 +5217,7 @@ function convertRgbToHsla(value) {
 	};
 }
 function convertRgbToHwba(value) {
-	const values = getRgbValues(isRgbLike(value) ? getRgbValue(value) : { ...COLOR_DEFAULTS.rgb });
+	const values = getRgbCalculationValues(isRgbLike(value) ? getRgbValues(value) : { ...COLOR_DEFAULTS.rgb });
 	const { delta, max, min } = values;
 	let hue = 0;
 	if (delta !== 0) {
@@ -5320,22 +5243,7 @@ function getColorFromRgb(state, type) {
 	}
 	return state[type];
 }
-function getRgbHue(values) {
-	const { blue, delta, green, max, red } = values;
-	switch (max) {
-		case blue: return (red - green) / delta + 4;
-		case green: return (blue - red) / delta + 2;
-		default: return (green - blue) / delta + (green < blue ? 6 : 0);
-	}
-}
-function getRgbValue(value) {
-	return {
-		blue: getHexValue(value.blue),
-		green: getHexValue(value.green),
-		red: getHexValue(value.red)
-	};
-}
-function getRgbValues(rgb) {
+function getRgbCalculationValues(rgb) {
 	const blue = rgb.blue / COLOR_MAX.hex;
 	const green = rgb.green / COLOR_MAX.hex;
 	const red = rgb.red / COLOR_MAX.hex;
@@ -5350,6 +5258,27 @@ function getRgbValues(rgb) {
 		red
 	};
 }
+function getRgbColor$1() {
+	return getStateValue(this, COLOR_TYPE.rgb, false);
+}
+function getRgbaColor$1() {
+	return getStateValue(this, COLOR_TYPE.rgb, true);
+}
+function getRgbHue(values) {
+	const { blue, delta, green, max, red } = values;
+	switch (max) {
+		case blue: return (red - green) / delta + 4;
+		case green: return (blue - red) / delta + 2;
+		default: return (green - blue) / delta + (green < blue ? 6 : 0);
+	}
+}
+function getRgbValues(value) {
+	return {
+		blue: getHexValue(value.blue),
+		green: getHexValue(value.green),
+		red: getHexValue(value.red)
+	};
+}
 /**
 * Convert an _RGB(A)_ color to a hex color _(with optional alpha channel, i.e., opacity)_
 *
@@ -5360,7 +5289,7 @@ function getRgbValues(rgb) {
 * @returns Hex color string
 */
 function rgbToHex(rgb, alpha) {
-	return convertRgbToHex(isRgbLike(rgb) ? getRgbValue(rgb) : { ...COLOR_DEFAULTS.rgb }, alpha ?? false);
+	return convertRgbToHex(isRgbLike(rgb) ? getRgbValues(rgb) : { ...COLOR_DEFAULTS.rgb }, alpha ?? false);
 }
 /**
 * Convert an _RGB(A)_ color to an _HSL_ color
@@ -5424,6 +5353,20 @@ function rgbToHwb(rgb) {
 function rgbToHwba(rgb) {
 	return convertRgbToHwba(rgb);
 }
+function setRgbValue(value) {
+	setRgbColorValueInState(this, value, false);
+}
+function setRgbColorValueInState(instance, value, alpha) {
+	if (!isRgbLike(value)) return;
+	setStateValue(instance, COLOR_TYPE.rgb, {
+		red: getHexValue(value.red),
+		green: getHexValue(value.green),
+		blue: getHexValue(value.blue)
+	}, alpha ? value.alpha : void 0);
+}
+function setRgbaValue(value) {
+	setRgbColorValueInState(this, value, true);
+}
 //#endregion
 //#region src/color/space/hex.ts
 function convertHexToRgba(value) {
@@ -5451,6 +5394,12 @@ function getColorFromHex(state, type) {
 	}
 	return state[type];
 }
+function getHexColor$1() {
+	return getStateValue(this, COLOR_TYPE.hex, false);
+}
+function getHexaColor$1() {
+	return getStateValue(this, COLOR_TYPE.hex, true);
+}
 /**
 * Get the normalized hex color from a value
 *
@@ -5548,10 +5497,22 @@ function hexToRgb(value) {
 function hexToRgba(value) {
 	return convertHexToRgba(value);
 }
+function setHexValue(value) {
+	setHexValueInState(this, value, false);
+}
+function setHexValueInState(instance, value, alpha) {
+	const { values } = instance[COLOR_SYMBOL];
+	if (!isHexColor(value) || !alpha && value === values.hex) return;
+	const normalized = getNormalizedHex(value, true);
+	setStateValue(instance, COLOR_TYPE.hex, normalized.slice(0, COLOR_LENGTHS.hexLong), alpha ? normalized.slice(COLOR_LENGTHS.hexLong) : void 0);
+}
+function setHexaValue(value) {
+	setHexValueInState(this, value, true);
+}
 //#endregion
 //#region src/color/space/hsl.ts
 function convertHslToHwba(input) {
-	let { hue, lightness, saturation } = isHslLike(input) ? getHslValue(input) : { ...COLOR_DEFAULTS.hsl };
+	let { hue, lightness, saturation } = isHslLike(input) ? getHslValues(input) : { ...COLOR_DEFAULTS.hsl };
 	lightness /= COLOR_MAX.percent;
 	saturation /= COLOR_MAX.percent;
 	const value = lightness + saturation * Math.min(lightness, 1 - lightness);
@@ -5566,7 +5527,7 @@ function convertHslToHwba(input) {
 	};
 }
 function convertHslToRgba(input) {
-	const hsl = isHslLike(input) ? getHslValue(input) : { ...COLOR_DEFAULTS.hsl };
+	const hsl = isHslLike(input) ? getHslValues(input) : { ...COLOR_DEFAULTS.hsl };
 	const hue = hsl.hue % COLOR_MAX.degree;
 	const saturation = hsl.saturation / COLOR_MAX.percent;
 	const lightness = hsl.lightness / COLOR_MAX.percent;
@@ -5593,7 +5554,13 @@ function getHexyValue(hue, lightness, saturation, value) {
 	const part = (value + hue / 30) % 12;
 	return (lightness - saturation * Math.min(lightness, 1 - lightness) * Math.max(-1, Math.min(part - 3, 9 - part, 1))) * COLOR_MAX.hex;
 }
-function getHslValue(value) {
+function getHslValue() {
+	return getStateValue(this, COLOR_TYPE.hsl, false);
+}
+function getHslaValue() {
+	return getStateValue(this, COLOR_TYPE.hsl, true);
+}
+function getHslValues(value) {
 	return {
 		hue: getDegrees(value.hue),
 		saturation: getPercentage(value.saturation),
@@ -5670,10 +5637,24 @@ function hslToRgb(hsl) {
 function hslToRgba(hsl) {
 	return convertHslToRgba(hsl);
 }
+function setHslValue(value) {
+	setHSLValueInState(this, value, false);
+}
+function setHSLValueInState(instance, value, alpha) {
+	if (!isHslLike(value)) return;
+	setStateValue(instance, COLOR_TYPE.hsl, {
+		hue: getDegrees(value.hue),
+		saturation: getPercentage(value.saturation),
+		lightness: getPercentage(value.lightness)
+	}, alpha ? value.alpha : void 0);
+}
+function setHslaValue(value) {
+	setHSLValueInState(this, value, true);
+}
 //#endregion
 //#region src/color/space/hwb.ts
 function convertHwbToHsl(input) {
-	let { blackness, hue, whiteness } = isHwbLike(input) ? getHwbValue(input) : COLOR_DEFAULTS.hwb;
+	let { blackness, hue, whiteness } = isHwbLike(input) ? getHwbValues(input) : COLOR_DEFAULTS.hwb;
 	blackness /= COLOR_MAX.percent;
 	whiteness /= COLOR_MAX.percent;
 	if (blackness + whiteness > 1) {
@@ -5706,7 +5687,13 @@ function getHwbSaturation(blackness, whiteness, lightness) {
 	if (hue <= 0) return 0;
 	return hue / Math.min(2 * lightness, 2 - 2 * lightness);
 }
-function getHwbValue(value) {
+function getHwbValue() {
+	return getStateValue(this, COLOR_TYPE.hwb, false);
+}
+function getHwbaValue() {
+	return getStateValue(this, COLOR_TYPE.hwb, true);
+}
+function getHwbValues(value) {
 	return {
 		hue: getDegrees(value.hue),
 		whiteness: getPercentage(value.whiteness),
@@ -5774,6 +5761,20 @@ function hwbToRgb(hwb) {
 function hwbToRgba(hwb) {
 	return hslToRgba(hwbToHsla(hwb));
 }
+function setHwbValue(value) {
+	setHwbColorValueInState(this, value, false);
+}
+function setHwbColorValueInState(instance, value, alpha) {
+	if (!isHwbLike(value)) return;
+	setStateValue(instance, COLOR_TYPE.hwb, {
+		hue: getDegrees(value.hue),
+		whiteness: getPercentage(value.whiteness),
+		blackness: getPercentage(value.blackness)
+	}, alpha ? value.alpha : void 0);
+}
+function setHwbaValue(value) {
+	setHwbColorValueInState(this, value, true);
+}
 //#endregion
 //#region src/color/misc/state.ts
 function getColorFromState(state, type) {
@@ -5797,13 +5798,13 @@ function getColorState(value) {
 			origin: void 0
 		};
 		if (COLOR_KEYS.hsl.every((key) => key in value)) {
-			state.hsl = getHslValue(value);
+			state.hsl = getHslValues(value);
 			state.origin = COLOR_TYPE.hsl;
 		} else if (COLOR_KEYS.hwb.every((key) => key in value)) {
-			state.hwb = getHwbValue(value);
+			state.hwb = getHwbValues(value);
 			state.origin = COLOR_TYPE.hwb;
 		} else if (COLOR_KEYS.rgb.every((key) => key in value)) {
-			state.rgb = getRgbValue(value);
+			state.rgb = getRgbValues(value);
 			state.origin = COLOR_TYPE.rgb;
 		}
 		if (state.origin != null) return state;
@@ -5828,7 +5829,16 @@ function getDefaultColorState() {
 		origin: COLOR_TYPE.hex
 	};
 }
-function setColorValue(instance, type, value, alpha) {
+function getStateValue(instance, type, alpha) {
+	const { values } = instance[COLOR_SYMBOL];
+	const value = getColorFromState(values, type);
+	if (typeof value === "string") return alpha ? `${value}${values.alpha.hex}` : value;
+	return alpha ? {
+		...value,
+		alpha: values.alpha.value
+	} : { ...value };
+}
+function setStateValue(instance, type, value, alpha) {
 	const { changes, values } = instance[COLOR_SYMBOL];
 	values.hex = void 0;
 	values.hsl = void 0;
@@ -5840,36 +5850,6 @@ function setColorValue(instance, type, value, alpha) {
 	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(instance, COLOR_TYPE.hex, normalized.slice(0, COLOR_LENGTHS.hexLong), alpha ? normalized.slice(COLOR_LENGTHS.hexLong) : void 0);
-}
-function setHSLColor(instance, value, alpha) {
-	if (!isHslLike(value)) return;
-	setColorValue(instance, COLOR_TYPE.hsl, {
-		hue: getDegrees(value.hue),
-		saturation: getPercentage(value.saturation),
-		lightness: getPercentage(value.lightness)
-	}, alpha ? value.alpha : void 0);
-}
-function setHWBColor(instance, value, alpha) {
-	if (!isHwbLike(value)) return;
-	setColorValue(instance, COLOR_TYPE.hwb, {
-		hue: getDegrees(value.hue),
-		whiteness: getPercentage(value.whiteness),
-		blackness: getPercentage(value.blackness)
-	}, alpha ? value.alpha : void 0);
-}
-function setRGBColor(instance, value, alpha) {
-	if (!isRgbLike(value)) return;
-	setColorValue(instance, COLOR_TYPE.rgb, {
-		red: getHexValue(value.red),
-		green: getHexValue(value.green),
-		blue: getHexValue(value.blue)
-	}, alpha ? value.alpha : void 0);
-}
 const getters = {
 	hex: getColorFromHex,
 	hsl: getColorFromHsl,
@@ -5902,129 +5882,86 @@ function getSuffix(state, alpha) {
 //#endregion
 //#region src/color/instance.ts
 function Color(value) {
-	Object.defineProperty(this, COLOR_SYMBOL, { value: {
+	this[COLOR_SYMBOL] = {
 		changes: herald({
 			names: [COLOR_TYPE.wildcard, ...COLOR_TYPE.all],
 			property: colorSubscription,
 			onCreate: (event, callback) => onCreateSubscription(this, event, callback)
 		}),
 		values: getColorState(value)
-	} });
+	};
 }
+Color.prototype[COLOR_PROPERTY] = COLOR_NAME;
+Color.prototype.subscribe = subscribeToColor;
+Color.prototype.toHexString = formatHexColor;
+Color.prototype.toHslString = formatHslColor;
+Color.prototype.toHwbString = formatHwbColor;
+Color.prototype.toRgbString = formatRgbColor;
+Color.prototype.toString = formatHexColor;
+Color.prototype.unsubscribe = unsubscribeFromColor;
 Object.defineProperties(Color.prototype, {
-	[COLOR_PROPERTY]: { value: COLOR_NAME },
 	alpha: {
 		enumerable: true,
-		get() {
-			return this[COLOR_SYMBOL].values.alpha.value;
-		},
-		set(value) {
-			setAlphaValue(this[COLOR_SYMBOL].values, value);
-		}
+		get: getColorAlpha,
+		set: setColorAlpha
 	},
 	changes: {
 		enumerable: true,
-		get() {
-			return this[COLOR_SYMBOL].changes.events;
-		}
+		get: getColorChanges
 	},
 	hex: {
 		enumerable: true,
-		get() {
-			return getColorValue(this, COLOR_TYPE.hex, false);
-		},
-		set(value) {
-			setHexColor(this, value, false);
-		}
+		get: getHexColor$1,
+		set: setHexValue
 	},
 	hexa: {
 		enumerable: true,
-		get() {
-			return getColorValue(this, COLOR_TYPE.hex, true);
-		},
-		set(value) {
-			setHexColor(this, value, true);
-		}
+		get: getHexaColor$1,
+		set: setHexaValue
 	},
 	hsl: {
 		enumerable: true,
-		get() {
-			return getColorValue(this, COLOR_TYPE.hsl, false);
-		},
-		set(value) {
-			setHSLColor(this, value, false);
-		}
+		get: getHslValue,
+		set: setHslValue
 	},
 	hsla: {
 		enumerable: true,
-		get() {
-			return getColorValue(this, COLOR_TYPE.hsl, true);
-		},
-		set(value) {
-			setHSLColor(this, value, true);
-		}
+		get: getHslaValue,
+		set: setHslaValue
 	},
 	hwb: {
 		enumerable: true,
-		get() {
-			return getColorValue(this, COLOR_TYPE.hwb, false);
-		},
-		set(value) {
-			setHWBColor(this, value, false);
-		}
+		get: getHwbValue,
+		set: setHwbValue
 	},
 	hwba: {
 		enumerable: true,
-		get() {
-			return getColorValue(this, COLOR_TYPE.hwb, true);
-		},
-		set(value) {
-			setHWBColor(this, value, true);
-		}
+		get: getHwbaValue,
+		set: setHwbaValue
 	},
 	origin: {
 		enumerable: true,
-		get() {
-			return this[COLOR_SYMBOL].values.origin;
-		}
+		get: getOrigin
 	},
 	rgb: {
 		enumerable: true,
-		get() {
-			return getColorValue(this, COLOR_TYPE.rgb, false);
-		},
-		set(value) {
-			setRGBColor(this, value, false);
-		}
+		get: getRgbColor$1,
+		set: setRgbValue
 	},
 	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 }
+		get: getRgbaColor$1,
+		set: setRgbaValue
+	}
 });
 function color(value) {
 	return new Color(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: values.alpha.value
-	} : { ...value };
+function getColorChanges() {
+	return this[COLOR_SYMBOL].changes.events;
+}
+function getOrigin() {
+	return this[COLOR_SYMBOL].values.origin;
 }
 function onCreateSubscription(instance, event, callback) {
 	let value;
@@ -6032,9 +5969,6 @@ function onCreateSubscription(instance, event, callback) {
 	else value = instance[event];
 	callback(value);
 }
-function setAlphaValue(state, value) {
-	if (typeof value === "number" && !Number.isNaN(value)) state.alpha = getAlpha(value, false);
-}
 function subscribeToColor(callback, signal) {
 	const { changes } = this[COLOR_SYMBOL];
 	return changes.subscribe(COLOR_TYPE.wildcard, callback, signal);
@@ -6180,36 +6114,32 @@ const EXPRESSION_WHITESPACE = /^\s*$/;
 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;
-			}
-		});
-	}
-}
+function Lumberjack() {}
 Lumberjack.prototype[LOGGER_PROPERTY] = LOGGER_NAME;
+Lumberjack.prototype.time = getTimeLogger;
 Object.defineProperties(Lumberjack.prototype, {
+	debug: { get: getLoggerCallback.bind("debug") },
+	dir: { get: getLoggerCallback.bind("dir") },
+	error: { get: getLoggerCallback.bind("error") },
 	enabled: {
 		enumerable: true,
-		get: () => enabled,
-		set: (value) => {
-			enabled = typeof value === "boolean" ? value : enabled;
-		}
+		get: getLoggerEnabled,
+		set: setLoggerEnabled
 	},
-	time: { value: (label) => new TimeLogger(getString(label)) }
+	info: { get: getLoggerCallback.bind("info") },
+	log: { get: getLoggerCallback.bind("log") },
+	table: { get: getLoggerCallback.bind("table") },
+	trace: { get: getLoggerCallback.bind("trace") },
+	warn: { get: getLoggerCallback.bind("warn") }
 });
 function TimeLogger(label) {
-	Object.defineProperty(this, LOGGER_SYMBOL, { value: {
+	this[LOGGER_SYMBOL] = {
 		label,
 		started: enabled,
 		stopped: false
-	} });
+	};
 	this[LOGGER_SYMBOL].isActive = () => {
-		return this[LOGGER_SYMBOL].started && !this[LOGGER_SYMBOL].stopped && enabled;
+		return enabled && this[LOGGER_SYMBOL].started && !this[LOGGER_SYMBOL].stopped;
 	};
 	if (this[LOGGER_SYMBOL].started) console.time(label);
 }
@@ -6217,43 +6147,48 @@ TimeLogger.prototype[LOGGER_PROPERTY] = LOGGER_NAME_TIMED;
 Object.defineProperties(TimeLogger.prototype, {
 	active: {
 		enumerable: true,
-		get() {
-			return this[LOGGER_SYMBOL].isActive();
-		}
+		get: getTimeLoggerActive
 	},
-	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;
-	} }
+	log: { get: getTimerLoggerLog },
+	stop: { get: getTimeLoggerStop }
 });
+function getLoggerCallback() {
+	return enabled ? console[this].bind(console) : noop;
+}
+function getLoggerEnabled() {
+	return enabled;
+}
+function getTimeLogger(label) {
+	return new TimeLogger(getString(label));
+}
+function getTimeLoggerActive() {
+	return this[LOGGER_SYMBOL].isActive();
+}
+function getTimerLoggerLog() {
+	const state = this[LOGGER_SYMBOL];
+	return state.isActive() ? console.timeLog.bind(console, state.label) : noop;
+}
+function getTimeLoggerStop() {
+	const state = this[LOGGER_SYMBOL];
+	if (state.isActive()) {
+		state.stopped = true;
+		return console.timeEnd.bind(console, state.label);
+	}
+	return noop;
+}
 function isLogger(value) {
 	return isLoggerInstance(LOGGER_NAME, value);
 }
 function isLoggerInstance(name, value) {
-	return typeof value === "object" && value !== null && value[LOGGER_PROPERTY] === name;
+	return typeof value === "object" && value !== null && LOGGER_PROPERTY in value && value[LOGGER_PROPERTY] === name;
 }
 function isTimeLogger(value) {
 	return isLoggerInstance(LOGGER_NAME_TIMED, value);
 }
+function setLoggerEnabled(value) {
+	enabled = typeof value === "boolean" ? value : enabled;
+}
 const LOGGER_SYMBOL = Symbol(LOGGER_PROPERTY);
-const methods = [
-	"debug",
-	"dir",
-	"error",
-	"info",
-	"log",
-	"table",
-	"trace",
-	"warn"
-];
 /**
 * A logger that can be used to log messages to the console
 *
@@ -6418,83 +6353,63 @@ var QueueError = class extends Error {
 	}
 };
 function KeyedQueue(callback, options) {
-	Object.defineProperty(this, QUEUE_SYMBOL, { value: {
+	this[QUEUE_SYMBOL] = {
 		callback,
 		options: createQueueOptions(options),
 		queues: /* @__PURE__ */ new Map()
-	} });
+	};
 }
+KeyedQueue.prototype[QUEUE_PROPERTY] = QUEUE_NAME_KEYED;
+KeyedQueue.prototype.add = addKeyedQueue;
+KeyedQueue.prototype.clear = clearQueues;
+KeyedQueue.prototype.get = getQueue;
+KeyedQueue.prototype.pause = pauseQueues;
+KeyedQueue.prototype.remove = removeQueue;
+KeyedQueue.prototype.resume = resumeQueues;
 Object.defineProperties(KeyedQueue.prototype, {
-	[QUEUE_PROPERTY]: { value: QUEUE_NAME_KEYED },
 	active: {
 		enumerable: true,
-		get() {
-			return getStatus(this[QUEUE_SYMBOL], QUEUE_STATUS_ACTIVE);
-		}
+		get: getActiveQueues
 	},
-	add: { value: addKeyedQueue },
 	autostart: {
 		enumerable: true,
-		get() {
-			return this[QUEUE_SYMBOL].options.autostart;
-		}
+		get: getQueueAutostart
 	},
-	clear: { value: clearQueues },
 	concurrency: {
 		enumerable: true,
-		get() {
-			return this[QUEUE_SYMBOL].options.concurrency;
-		}
+		get: getQueueConcurrency
 	},
 	empty: {
 		enumerable: true,
-		get() {
-			return getStatus(this[QUEUE_SYMBOL], QUEUE_STATUS_EMPTY);
-		}
+		get: getEmptyQueues
 	},
 	full: {
 		enumerable: true,
-		get() {
-			return getStatus(this[QUEUE_SYMBOL], QUEUE_STATUS_FULL);
-		}
+		get: getFullQueues
 	},
-	get: { value: getQueue },
 	items: {
 		enumerable: true,
-		get() {
-			return getQueueItems(this[QUEUE_SYMBOL]);
-		}
+		get: getKeyedQueueItems
 	},
 	keys: {
 		enumerable: true,
-		get() {
-			return [...this[QUEUE_SYMBOL].queues.keys()];
-		}
+		get: getQueueKeys
 	},
 	maximum: {
 		enumerable: true,
-		get() {
-			return this[QUEUE_SYMBOL].options.maximum;
-		}
+		get: getQueueMaximum
 	},
-	pause: { value: pauseQueues },
 	paused: {
 		enumerable: true,
-		get() {
-			return getStatus(this[QUEUE_SYMBOL], QUEUE_STATUS_PAUSED);
-		}
+		get: getPausedQueues
 	},
 	queues: {
 		enumerable: true,
-		get() {
-			return this[QUEUE_SYMBOL].queues.size;
-		}
-	},
-	remove: { value: removeQueue },
-	resume: { value: resumeQueues }
+		get: getKeyedQueueSize
+	}
 });
 function Queue(callback, options, key) {
-	Object.defineProperty(this, QUEUE_SYMBOL, { value: {
+	this[QUEUE_SYMBOL] = {
 		callback,
 		key,
 		options,
@@ -6503,63 +6418,46 @@ function Queue(callback, options, key) {
 		items: [],
 		paused: !options.autostart,
 		runners: 0
-	} });
+	};
 }
+Queue.prototype[QUEUE_PROPERTY] = QUEUE_NAME_QUEUE;
+Queue.prototype.add = addToQueue;
+Queue.prototype.clear = clearQueue;
+Queue.prototype.pause = pauseQueue;
+Queue.prototype.remove = removeQueued;
+Queue.prototype.resume = resumeQueue;
 Object.defineProperties(Queue.prototype, {
-	[QUEUE_PROPERTY]: { value: QUEUE_NAME_QUEUE },
 	active: {
 		enumerable: true,
-		get() {
-			return this[QUEUE_SYMBOL].runners > 0;
-		}
+		get: getQueueActive
 	},
-	add: { value: addToQueue },
 	autostart: {
 		enumerable: true,
-		get() {
-			return this[QUEUE_SYMBOL].options.autostart;
-		}
+		get: getQueueAutostart
 	},
-	clear: { value: clearQueue },
 	concurrency: {
 		enumerable: true,
-		get() {
-			return this[QUEUE_SYMBOL].options.concurrency;
-		}
+		get: getQueueConcurrency
 	},
 	empty: {
 		enumerable: true,
-		get() {
-			return this[QUEUE_SYMBOL].items.length === 0;
-		}
+		get: getQueueEmpty
 	},
 	full: {
 		enumerable: true,
-		get() {
-			const state = this[QUEUE_SYMBOL];
-			return state.options.maximum > 0 && state.items.length >= state.options.maximum;
-		}
+		get: getQueueFull
 	},
 	maximum: {
 		enumerable: true,
-		get() {
-			return this[QUEUE_SYMBOL].options.maximum;
-		}
+		get: getQueueMaximum
 	},
-	pause: { value: pauseQueue },
 	paused: {
 		enumerable: true,
-		get() {
-			return this[QUEUE_SYMBOL].paused;
-		}
+		get: getQueuePaused
 	},
-	remove: { value: removeQueued },
-	resume: { value: resumeQueue },
 	size: {
 		enumerable: true,
-		get() {
-			return this[QUEUE_SYMBOL].items.length;
-		}
+		get: getQueueSize
 	}
 });
 function addKeyedQueue(key, parameters, signal) {
@@ -6617,6 +6515,28 @@ function createQueueOptions(input) {
 		maximum: getNumberOrDefault(options.maximum, 0)
 	};
 }
+function getActiveQueues() {
+	return getStatus(this[QUEUE_SYMBOL], QUEUE_STATUS_ACTIVE);
+}
+function getEmptyQueues() {
+	return getStatus(this[QUEUE_SYMBOL], QUEUE_STATUS_EMPTY);
+}
+function getFullQueues() {
+	return getStatus(this[QUEUE_SYMBOL], QUEUE_STATUS_FULL);
+}
+function getPausedQueues() {
+	return getStatus(this[QUEUE_SYMBOL], QUEUE_STATUS_PAUSED);
+}
+function getKeyedQueueItems() {
+	const state = this[QUEUE_SYMBOL];
+	const size = {};
+	const queues = state.queues.entries();
+	for (const [key, queue] of queues) size[key] = queue.size;
+	return size;
+}
+function getKeyedQueueSize() {
+	return this[QUEUE_SYMBOL].queues.size;
+}
 function getQueue(key, add) {
 	if (typeof key !== "string" || key.trim().length === 0) throw new TypeError(QUEUE_MESSAGE_KEY);
 	const state = this[QUEUE_SYMBOL];
@@ -6627,11 +6547,33 @@ function getQueue(key, add) {
 	}
 	return queue;
 }
-function getQueueItems(state) {
-	const size = {};
-	const queues = state.queues.entries();
-	for (const [key, queue] of queues) size[key] = queue.size;
-	return size;
+function getQueueActive() {
+	return this[QUEUE_SYMBOL].runners > 0;
+}
+function getQueueAutostart() {
+	return this[QUEUE_SYMBOL].options.autostart === true;
+}
+function getQueueConcurrency() {
+	return this[QUEUE_SYMBOL].options.concurrency;
+}
+function getQueueEmpty() {
+	return this[QUEUE_SYMBOL].items.length === 0;
+}
+function getQueueFull() {
+	const state = this[QUEUE_SYMBOL];
+	return state.options.maximum > 0 && state.items.length >= state.options.maximum;
+}
+function getQueueKeys() {
+	return [...this[QUEUE_SYMBOL].queues.keys()];
+}
+function getQueueMaximum() {
+	return this[QUEUE_SYMBOL].options.maximum;
+}
+function getQueuePaused() {
+	return this[QUEUE_SYMBOL].paused === true;
+}
+function getQueueSize() {
+	return this[QUEUE_SYMBOL].items.length;
 }
 function getStatus(state, status) {
 	const queues = state.queues.entries();
@@ -6777,7 +6719,6 @@ const QUEUE_STATUS_FULL = "full";
 const QUEUE_STATUS_PAUSED = "paused";
 const QUEUE_SYMBOL = Symbol(QUEUE_PROPERTY);
 queue.keyed = keyedQueue;
-Object.defineProperty(queue, "keyed", { value: keyedQueue });
 //#endregion
 //#region src/random.ts
 /**