@oscarpalmer/atoms 0.203.0 → 0.204.1

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
 /**
@@ -300,6 +297,15 @@ function isNonPrimitive(value) {
 	return !isPrimitive(value);
 }
 /**
+* Is the value not a template strings array?
+*
+* @param value Value to check
+* @returns `true` if the value is not a `TemplateStringsArray`, otherwise `false`
+*/
+function isNonTemplateStringsArray(value) {
+	return !isTemplateStringsArray(value);
+}
+/**
 * Is the value not a typed array?
 *
 * @param value Value to check
@@ -379,13 +385,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 +405,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 +559,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 +694,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 +822,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 +915,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 +1073,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 +1204,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 +1223,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 +1338,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 +1346,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 +1403,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 +1429,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 +1438,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 +1458,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 +1612,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 +1641,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 +1662,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 +1693,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 +1716,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 +1810,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 +1824,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 +1887,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 +1980,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 +2063,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 +2123,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 +2260,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 +2305,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 +2334,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 +2473,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 +2650,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 +2674,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 +2687,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 +2754,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 +2766,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 +2805,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 +2975,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 +2994,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 +3019,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 +3042,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 +3061,6 @@ function attemptPipe(initial, first, ...seconds) {
 	});
 }
 attemptPipe.async = attemptAsyncPipe;
-Object.defineProperty(attemptPipe, "async", { value: attemptAsyncPipe });
 //#endregion
 //#region src/string/match.ts
 /**
@@ -3169,27 +3113,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 +3179,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 +3278,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 +3298,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 +3395,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 +3500,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 +3554,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 +3746,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 +3951,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 +4084,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 +4197,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 +4238,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 +4332,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 +4460,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 +4521,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 +4531,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 +4553,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 +4582,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 +4644,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 +4693,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 +4734,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 +4894,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 +4913,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 +5075,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 +5208,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 +5226,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 +5252,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 +5267,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 +5298,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 +5362,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 +5403,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 +5506,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 +5536,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 +5563,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 +5646,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 +5696,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 +5770,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 +5807,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 +5838,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 +5859,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 +5891,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 +5978,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 +6123,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 +6156,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 +6362,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 +6427,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 +6524,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 +6556,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 +6728,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
 /**
@@ -6895,4 +6845,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, 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 };
+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, isNonTemplateStringsArray, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isObservable, isOk, isOnce, isPlainObject, isPrimitive, isQueue, isQueueInstance, isRejected, isResult, isRgbColor, isRgbaColor, isSorted, isSubscription, isSubscriptions, isTemplateStringsArray, 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 };