@oscarpalmer/atoms 0.196.1 → 0.198.0

package/dist/index.mjs

@@ -4,6 +4,7 @@ function getArrayCallback(value) {
 		case "function": return value;
 		case "number":
 		case "string": return typeof value === "string" && value.includes(".") ? void 0 : (obj) => obj[value];
+		default: return;
 	}
 }
 function getArrayCallbacks(bool, key, value) {
@@ -101,15 +102,17 @@ 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) {
 	return findAbsoluteValueOrDefault(array, parameters, void 0, false, false);
 }
-first.default = firstOrDefault;
 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) {
@@ -134,10 +137,11 @@ function groupValues(array, key, value, arrays) {
 function groupBy(array, first, second) {
 	return groupValues(array, first, second, false);
 }
-groupBy.arrays = groupArraysBy;
 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
 /**
@@ -378,10 +382,11 @@ function getArray(value, indiced) {
 function indexOf(array, ...parameters) {
 	return findValue(FIND_VALUE_INDEX, array, parameters, false);
 }
-indexOf.last = lastIndexOf;
 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) {
@@ -532,10 +537,11 @@ function exists(array, ...parameters) {
 function find(array, ...parameters) {
 	return findValue(FIND_VALUE_ITEM, array, parameters, false);
 }
-find.last = findLast;
 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
 /**
@@ -782,10 +788,11 @@ function update(array, values, key) {
 function last(array, ...parameters) {
 	return findAbsoluteValueOrDefault(array, parameters, void 0, false, true);
 }
-last.default = lastOrDefault;
 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) {
@@ -830,8 +837,6 @@ function move(array, from, to, key) {
 	else array.splice(next, 0, ...firstArray);
 	return array;
 }
-move.indices = moveIndices;
-move.toIndex = moveToIndex;
 /**
 * Move an item from one index to another within an array
 *
@@ -879,6 +884,12 @@ function moveToIndex(array, value, index, key) {
 	else array.splice(next, 0, ...values);
 	return array;
 }
+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) {
@@ -1117,14 +1128,6 @@ function compare(first, second) {
 	}
 	return 0;
 }
-compare.handlers = getCompareHandlers(compare, {
-	callback: (first, second, compareStrings) => {
-		if (compareStrings) return getString(first).localeCompare(getString(second));
-	},
-	method: COMPARE_NAME
-});
-compare.deregister = deregisterComparator;
-compare.register = registerComparator;
 function compareNumbers(first, second) {
 	if (Object.is(first, second)) return 0;
 	if (Number.isNaN(first)) return -1;
@@ -1171,6 +1174,18 @@ const comparators = {
 	number: compareNumbers,
 	symbol: compareSymbols
 };
+const compareHandlers = getCompareHandlers(compare, {
+	callback: (first, second, compareStrings) => compareStrings ? getString(first).localeCompare(getString(second)) : void 0,
+	method: COMPARE_NAME
+});
+compare.deregister = deregisterComparator;
+compare.handlers = compareHandlers;
+compare.register = registerComparator;
+Object.defineProperties(compare, {
+	deregister: { value: deregisterComparator },
+	handlers: { value: compareHandlers },
+	register: { value: registerComparator }
+});
 //#endregion
 //#region src/array/sort.ts
 function getComparisonSorter(callback, modifier) {
@@ -1298,9 +1313,6 @@ function sortArray(array, sorters) {
 	const { length } = sorters;
 	return array.length > 1 ? array.sort((first, second) => getComparisonValue(first, second, sorters, length)) : array;
 }
-sort.getIndex = getSortedIndex;
-sort.initialize = initializeSorter;
-sort.is = isSorted;
 const SORT_PEEK_PERCENTAGE = 10;
 const SORT_THRESHOLD = 100;
 const SORT_DIRECTION_ASCENDING = "ascending";
@@ -1309,6 +1321,14 @@ const modifiers = {
 	[SORT_DIRECTION_ASCENDING]: 1,
 	[SORT_DIRECTION_DESCENDING]: -1
 };
+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) {
@@ -1317,7 +1337,6 @@ function swap(array, first, second, third) {
 	if (Array.isArray(first) && Array.isArray(second)) return swapArrays(array, first, second, third);
 	return swapValues(array, first, second, third);
 }
-swap.indices = swapIndices;
 function swapArrays(array, from, to, key) {
 	if (from.length === 0 || to.length === 0) return array;
 	if (from.length === 1 && to.length === 1) return swapValues(array, from[0], to[0], key);
@@ -1366,6 +1385,8 @@ function swapValues(array, from, to, key) {
 	if (first === second || first === -1 || second === -1) return array;
 	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) {
@@ -1388,19 +1409,21 @@ function getMapValues(array, first, second, arrays) {
 function toMap(array, first, second) {
 	return getMapValues(array, first, second, false);
 }
-toMap.arrays = toMapArrays;
 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) {
 	return groupValues(array, first, second, false);
 }
-toRecord.arrays = toRecordArrays;
 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
 /**
@@ -1651,10 +1674,11 @@ const MISC_NESTED_MESSAGE_UNSAFE = "Access to this property is not allowed";
 function hasValue(data, path, ignoreCase) {
 	return getNestedValue(data, path, ignoreCase === true).ok;
 }
-hasValue.get = hasValueResult;
 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
 /**
@@ -1667,11 +1691,6 @@ function hasValueResult(data, path, ignoreCase) {
 function assert(condition, message, error) {
 	if (!condition()) throw new (error ?? Error)(message);
 }
-assert.condition = assertCondition;
-assert.defined = assertDefined;
-assert.instanceOf = assertInstanceOf;
-assert.is = assertIs;
-assert.property = assertProperty;
 /**
 * Creates an _Asserter_ that asserts a condition is true, throwing an error if it is not
 *
@@ -1749,6 +1768,18 @@ function assertProperty(path, condition, message, error) {
 	};
 }
 const ASSERT_MESSAGE_VALUE_DEFINED = "Expected value to be defined";
+assert.condition = assertCondition;
+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
 /**
@@ -2130,11 +2161,12 @@ var SizedMap = class extends Map {
 	* @inheritdoc
 	*/
 	get(key) {
+		let value;
 		if (super.has(key)) {
-			const value = super.get(key);
+			value = super.get(key);
 			this.#setValue(key, value, true);
-			return value;
 		}
+		return value;
 	}
 	/**
 	* @inheritdoc
@@ -2825,10 +2857,11 @@ async function promises(items, options) {
 		}));
 	});
 }
-promises.result = resultPromises;
 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) {
@@ -3021,7 +3054,6 @@ function fuzzy(items, configuration) {
 	});
 	return Object.freeze(instance);
 }
-fuzzy.match = fuzzyMatch;
 /**
 * Does the needle match the haystack in a fuzzy way?
 *
@@ -3128,6 +3160,8 @@ const FUZZY_LENGTH_DIVISOR = 3;
 const FUZZY_MESSAGE_ARRAY = "Fuzzy requires an array of items";
 const FUZZY_MESSAGE_HANDLER = "Fuzzy requires a key or function to stringify items";
 const FUZZY_PROXIMITY_THRESHOLD = 5;
+fuzzy.match = fuzzyMatch;
+Object.defineProperty(fuzzy, "match", { value: fuzzyMatch });
 //#endregion
 //#region src/string/index.ts
 function dedent(value, ...values) {
@@ -3273,7 +3307,6 @@ function initializeNormalizer(options) {
 function normalize(value, options) {
 	return normalizeString(value, getNormalizeOptions(options));
 }
-normalize.initialize = initializeNormalizer;
 function normalizeString(value, options) {
 	if (typeof value !== "string") return "";
 	let result = value;
@@ -3325,6 +3358,8 @@ const NORMALIZE_SPECIAL_REPLACEMENT = "";
 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 getRenderer(strings, values) {
@@ -3370,115 +3405,110 @@ function template(value, ...parameters) {
 	const { ignoreCase, pattern } = getTemplateOptions(parameters[1]);
 	return handleTemplate(value, pattern, ignoreCase, parameters[0]);
 }
-template.initialize = initializeTemplater;
 const TEMPLATE_EXPRESSION_VARIABLE = /{{([\s\S]+?)}}/g;
+template.initialize = initializeTemplater;
+Object.defineProperty(template, "initialize", { value: initializeTemplater });
 //#endregion
 //#region src/value/clone.ts
 const CLONE_NAME = "clone";
-function clone(value, flat) {
-	return flat === true ? copy(value) : cloneValue(value, 0, /* @__PURE__ */ new WeakMap(), false);
+function clone(value, options) {
+	return cloneAny(value, { copy: false }, 0, options);
 }
-clone.handlers = getSelfHandlers(clone, {
-	callback: tryStructuredClone,
-	method: CLONE_NAME
-});
-clone.deregister = deregisterCloner;
-clone.register = registerCloner;
-function cloneArrayBuffer(value, depth, references) {
-	if (typeof depth === "number" && depth >= CLONE_MAX_DEPTH) return value;
+function cloneAny(value, parameters, depth, options) {
+	switch (true) {
+		case value === null || CLONE_PRIMITIVES[typeof value]: return value;
+		case value instanceof Date: return new Date(value.getTime());
+		case typeof value === "function":
+			parameters.options ??= getCloneOptions(options);
+			return parameters.options.copyFunctions ? value : void 0;
+		case typeof value === "symbol":
+			parameters.options ??= getCloneOptions(options);
+			return parameters.options.copySymbols ? value : Symbol(value.description);
+	}
+	parameters.options ??= getCloneOptions(options);
+	parameters.references ??= /* @__PURE__ */ new WeakMap();
+	switch (true) {
+		case parameters.references.has(value): return parameters.references.get(value);
+		case value instanceof ArrayBuffer: return cloneArrayBuffer(value, parameters, depth);
+		case value instanceof DataView: return cloneDataView(value, parameters, depth);
+		case value instanceof RegExp: return cloneRegularExpression(value, parameters, depth);
+		case value instanceof Map: return cloneMap(value, parameters, depth);
+		case typeof Node !== "undefined" && value instanceof Node: return cloneNode(value, parameters, depth);
+		case value instanceof Set: return cloneSet(value, parameters, depth);
+		case isArrayOrPlainObject(value): return cloneObject(value, parameters, depth);
+		case isTypedArray(value): return cloneTypedArray(value, parameters, depth);
+		default: return parameters.copy ? value : clone.handlers.handle(value, parameters, depth);
+	}
+}
+function cloneArrayBuffer(value, parameters, depth) {
+	if (parameters.copy || depth >= CLONE_MAX_DEPTH) return value;
 	const cloned = new ArrayBuffer(value.byteLength);
 	new Uint8Array(cloned).set(new Uint8Array(value));
-	references?.set(value, cloned);
+	parameters.references.set(value, cloned);
 	return cloned;
 }
-function cloneDataView(value, depth, references) {
-	if (depth >= CLONE_MAX_DEPTH) return value;
-	const buffer = cloneArrayBuffer(value.buffer);
+function cloneDataView(value, parameters, depth) {
+	if (parameters.copy || depth >= CLONE_MAX_DEPTH) return value;
+	const buffer = cloneArrayBuffer(value.buffer, parameters, depth);
 	const cloned = new DataView(buffer, value.byteOffset, value.byteLength);
-	references.set(value, cloned);
+	parameters.references.set(value, cloned);
 	return cloned;
 }
-function cloneMap(map, depth, references, flat) {
+function cloneMap(map, parameters, depth) {
 	if (depth >= CLONE_MAX_DEPTH) return map;
+	if (parameters.copy) return new Map(map);
 	const cloned = /* @__PURE__ */ new Map();
-	const entries = map.entries();
-	for (const entry of entries) cloned.set(flat ? entry[0] : cloneValue(entry[0], depth + 1, references, false), flat ? entry[1] : cloneValue(entry[1], depth + 1, references, false));
-	references.set(map, cloned);
+	for (const [key, value] of map.entries()) cloned.set(cloneAny(key, parameters, depth + 1), cloneAny(value, parameters, depth + 1));
+	parameters.references.set(map, cloned);
 	return cloned;
 }
-function cloneNode(node, depth, references) {
-	if (depth >= CLONE_MAX_DEPTH) return node;
+function cloneNode(node, parameters, depth) {
+	if (parameters.copy || depth >= CLONE_MAX_DEPTH) return node;
 	const cloned = node.cloneNode(true);
-	references.set(node, cloned);
+	parameters.references.set(node, cloned);
 	return cloned;
 }
-function cloneObject(value, depth, references, flat) {
-	if (flat || depth >= CLONE_MAX_DEPTH) return Array.isArray(value) ? value.slice() : { ...value };
-	const cloned = Array.isArray(value) ? [] : {};
-	const keys = [...Object.keys(value), ...Object.getOwnPropertySymbols(value)];
-	const { length } = keys;
+function cloneObject(value, parameters, depth) {
+	if (depth >= CLONE_MAX_DEPTH) return value;
+	const isArray = Array.isArray(value);
+	if (parameters.copy) return isArray ? value.slice() : { ...value };
+	const cloned = isArray ? [] : {};
+	const keys = isArray ? void 0 : Object.keys(value);
+	const { length } = keys ?? value;
 	for (let index = 0; index < length; index += 1) {
-		const key = keys[index];
-		cloned[key] = cloneValue(value[key], depth + 1, references, false);
+		const key = keys?.[index] ?? index;
+		cloned[key] = cloneAny(value[key], parameters, depth + 1);
 	}
-	references.set(value, cloned);
+	parameters.references.set(value, cloned);
 	return cloned;
 }
-function cloneRegularExpression(value, depth, references) {
-	if (depth >= CLONE_MAX_DEPTH) return value;
+function cloneRegularExpression(value, parameters, depth) {
+	if (parameters.copy || depth >= CLONE_MAX_DEPTH) return value;
 	const cloned = new RegExp(value.source, value.flags);
 	cloned.lastIndex = value.lastIndex;
-	references.set(value, cloned);
+	parameters.references.set(value, cloned);
 	return cloned;
 }
-function cloneSet(set, depth, references, flat) {
+function cloneSet(set, parameters, depth) {
 	if (depth >= CLONE_MAX_DEPTH) return set;
+	if (parameters.copy) return new Set(set);
 	const cloned = /* @__PURE__ */ new Set();
-	const values = [...set.values()];
-	const { length } = values;
-	for (let index = 0; index < length; index += 1) cloned.add(flat ? values[index] : cloneValue(values[index], depth + 1, references, false));
-	references.set(set, cloned);
+	for (const value of set.values()) cloned.add(cloneAny(value, parameters, depth + 1));
+	parameters.references.set(set, cloned);
 	return cloned;
 }
-function cloneTypedArray(value, depth, references) {
-	if (depth >= CLONE_MAX_DEPTH) return value;
+function cloneTypedArray(value, parameters, depth) {
+	if (parameters.copy || depth >= CLONE_MAX_DEPTH) return value;
 	const cloned = new value.constructor(value);
-	references.set(value, cloned);
+	parameters.references.set(value, cloned);
 	return cloned;
 }
-function cloneValue(value, depth, references, flat) {
-	switch (true) {
-		case value == null:
-		case typeof value === "bigint":
-		case typeof value === "boolean":
-		case typeof value === "number":
-		case typeof value === "string": return value;
-		case typeof value === "function": return;
-		case typeof value === "symbol": return Symbol(value.description);
-		case references.has(value): return references.get(value);
-		case value instanceof ArrayBuffer: return cloneArrayBuffer(value, depth, references);
-		case value instanceof DataView: return cloneDataView(value, depth, references);
-		case value instanceof Date: return new Date(value.getTime());
-		case value instanceof RegExp: return cloneRegularExpression(value, depth, references);
-		case value instanceof Map: return cloneMap(value, depth, references, flat);
-		case typeof Node !== "undefined" && value instanceof Node: return cloneNode(value, depth, references);
-		case value instanceof Set: return cloneSet(value, depth, references, flat);
-		case isArrayOrPlainObject(value): return cloneObject(value, depth, references, flat);
-		case isTypedArray(value): return cloneTypedArray(value, depth, references);
-		default: return clone.handlers.handle(value, depth, references);
-	}
-}
-/**
-* Copy any kind of value
-*
-* - Clones the value shallowly, without cloning nested values
-* - To copy a value deeply, use `clone` instead
-*
-* @param value Value to copy
-* @returns Copied value
-*/
 function copy(value) {
-	return cloneValue(value, 0, /* @__PURE__ */ new WeakMap(), true);
+	return cloneAny(value, {
+		copy: true,
+		options: CLONE_COPY_OPTIONS,
+		references: void 0
+	}, 0);
 }
 /**
 * Deregister a clone handler for a specific class
@@ -3490,6 +3520,37 @@ function copy(value) {
 function deregisterCloner(constructor) {
 	clone.handlers.deregister(constructor);
 }
+function getCloneOptions(input) {
+	if (typeof input !== "object" || input === null) return CLONE_DEFAULT_OPTIONS;
+	return {
+		copyFunctions: input.copyFunctions === true,
+		copySymbols: input.copySymbols === true
+	};
+}
+/**
+* Create a cloner with predefined options
+*
+* _Available as `initializeCloner` and `clone.initialize`_
+*
+* @param options Clone options
+* @returns Cloner function
+*/
+function initializeCloner(options) {
+	const opts = getCloneOptions(options);
+	function cloner(value) {
+		return cloneAny(value, {
+			copy: false,
+			options: opts
+		}, 0);
+	}
+	cloner.deregister = deregisterCloner;
+	cloner.register = registerCloner;
+	Object.defineProperties(cloner, {
+		deregister: { value: deregisterCloner },
+		register: { value: registerCloner }
+	});
+	return cloner;
+}
 /**
 * Register a clone handler for a specific class
 *
@@ -3501,25 +3562,59 @@ function deregisterCloner(constructor) {
 function registerCloner(constructor, handler) {
 	clone.handlers.register(constructor, handler);
 }
-function tryStructuredClone(value, depth, references) {
+function tryStructuredClone(value, parameters, depth) {
 	if (depth >= CLONE_MAX_DEPTH) return value;
 	try {
 		const cloned = structuredClone(value);
-		references.set(value, cloned);
+		parameters.references.set(value, cloned);
 		return cloned;
 	} catch {
-		references.set(value, value);
+		parameters.references.set(value, value);
 		return value;
 	}
 }
+const CLONE_COPY_OPTIONS = {
+	copyFunctions: true,
+	copySymbols: true
+};
+const CLONE_DEFAULT_OPTIONS = {
+	copyFunctions: false,
+	copySymbols: false
+};
 const CLONE_MAX_DEPTH = 100;
+const cloneHandlers = getSelfHandlers(clone, {
+	callback: tryStructuredClone,
+	method: CLONE_NAME
+});
+const CLONE_PRIMITIVES = {
+	bigint: true,
+	boolean: true,
+	function: false,
+	number: true,
+	object: false,
+	string: true,
+	symbol: false,
+	undefined: true
+};
+clone.deregister = deregisterCloner;
+clone.handlers = cloneHandlers;
+clone.initialize = initializeCloner;
+clone.register = registerCloner;
+Object.defineProperties(clone, {
+	deregister: { value: deregisterCloner },
+	handlers: { value: cloneHandlers },
+	initialize: { value: initializeCloner },
+	register: { value: registerCloner }
+});
 //#endregion
 //#region src/value/collection.ts
 function inMap(map, value, key) {
 	const getKey = key === true;
 	if (!(map instanceof Map)) return getKey ? void 0 : false;
 	if (!getKey) return inSet(new Set(map.values()), value);
-	for (const [key, item] of map) if (equal(item, value)) return key;
+	let found;
+	for (const [key, item] of map) if (equal(item, value)) found = key;
+	return found;
 }
 /**
 * Does the value exist in a _Set_?
@@ -3648,8 +3743,6 @@ function flatFreeze(value) {
 function freeze(value, flat) {
 	return freezeValue(value, /* @__PURE__ */ new WeakSet(), flat === true);
 }
-freeze.flat = flatFreeze;
-freeze.is = isFrozen;
 function freezeArray(array, references, flat) {
 	if (flat) return Object.freeze(array);
 	references.add(array);
@@ -3714,6 +3807,12 @@ function isFrozen(value) {
 	return typeof value === "object" && value !== null && Object.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) {
@@ -3859,7 +3958,6 @@ function assign(to, from, options) {
 	actual.assignValues = true;
 	return mergeValues([to, ...from], actual);
 }
-assign.initialize = initializeAssigner;
 function getMergeOptions(options) {
 	const actual = {
 		assignValues: false,
@@ -3913,7 +4011,6 @@ function initializeMerger(options) {
 function merge(values, options) {
 	return mergeValues(values, getMergeOptions(options));
 }
-merge.initialize = initializeMerger;
 function mergeObjects(values, options, destination, prefix) {
 	const { length } = values;
 	const isArray = Array.isArray(destination ?? values[0]);
@@ -3943,6 +4040,10 @@ function mergeValues(values, options, prefix) {
 	if (actual.length > 1) return mergeObjects(actual, options, options.assignValues ? actual[0] : void 0, prefix);
 	return options.assignValues ? actual[0] : Array.isArray(actual[0]) ? actual[0].slice() : { ...actual[0] };
 }
+assign.initialize = initializeAssigner;
+merge.initialize = initializeMerger;
+Object.defineProperty(assign, "initialize", { value: initializeAssigner });
+Object.defineProperty(merge, "initialize", { value: initializeMerger });
 //#endregion
 //#region src/value/transform.ts
 function getTransformer(input) {
@@ -3965,7 +4066,6 @@ function initializeTransformer(transform) {
 function transform(value, transform) {
 	return transformValue(value, getTransformer(transform));
 }
-transform.initialize = initializeTransformer;
 function transformValue(value, transformer) {
 	if (isNonPlainObject(value)) return {};
 	if (transformer == null) return value;
@@ -3979,6 +4079,8 @@ function transformValue(value, transformer) {
 	}
 	return value;
 }
+transform.initialize = initializeTransformer;
+Object.defineProperty(transform, "initialize", { value: initializeTransformer });
 //#endregion
 //#region src/internal/subscription.ts
 function addSubscription(subscriptions, subscription, state) {
@@ -6104,7 +6206,6 @@ function keyedQueue(callback, options) {
 function queue(callback, options) {
 	return createQueue(callback, options);
 }
-queue.keyed = keyedQueue;
 function removeQueue(state, key, id) {
 	if (key == null) {
 		handleQueues(state, QUEUE_HANDLE_CLEAR);
@@ -6180,6 +6281,8 @@ const QUEUE_STATUS_ACTIVE = "active";
 const QUEUE_STATUS_EMPTY = "empty";
 const QUEUE_STATUS_FULL = "full";
 const QUEUE_STATUS_PAUSED = "paused";
+queue.keyed = keyedQueue;
+Object.defineProperty(queue, "keyed", { value: keyedQueue });
 //#endregion
 //#region src/random.ts
 /**
@@ -6288,14 +6391,13 @@ var SizedSet = class extends Set {
 	* @returns Found value if it exists, otherwise `undefined`
 	*/
 	get(value, update) {
-		if (super.has(value)) {
-			if (update ?? false) {
-				super.delete(value);
-				this.add(value);
-			}
-			return value;
+		if (!super.has(value)) return;
+		if (update ?? false) {
+			super.delete(value);
+			this.add(value);
 		}
+		return value;
 	}
 };
 //#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, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, interpolate, intersection, isArrayOrPlainObject, isBeacon, isBeaconSubscription, isColor, isConstructor, isEmpty, isError, isFrozen, isFulfilled, isHerald, isHeraldEvents, isHeraldSubscription, isHexColor, isHslColor, isHslaColor, isHwbColor, isHwbaColor, isInstanceOf, isKey, isKeyedQueue, isLogger, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isObservable, isOk, isPlainObject, isPrimitive, isQueue, isQueueInstance, isRejected, isResult, isRgbColor, isRgbaColor, isSorted, isSubscription, isTimedLogger, isTypedArray, join, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, lowerCase, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, select, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };
+export { CancelablePromise, Logger, PromiseTimeoutError, QueueError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, copy, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, filter, find, findLast, first, firstOrDefault, flatFreeze, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getHwbColor, getHwbaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hasValueResult, herald, hexToHsl, hexToHsla, hexToHwb, hexToHwba, hexToRgb, hexToRgba, hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba, hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeCloner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, interpolate, intersection, isArrayOrPlainObject, isBeacon, isBeaconSubscription, isColor, isConstructor, isEmpty, isError, isFrozen, isFulfilled, isHerald, isHeraldEvents, isHeraldSubscription, isHexColor, isHslColor, isHslaColor, isHwbColor, isHwbaColor, isInstanceOf, isKey, isKeyedQueue, isLogger, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isObservable, isOk, isPlainObject, isPrimitive, isQueue, isQueueInstance, isRejected, isResult, isRgbColor, isRgbaColor, isSorted, isSubscription, isTimedLogger, isTypedArray, join, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, lowerCase, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, select, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };