@oscarpalmer/atoms 0.196.1 → 0.197.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,13 +3405,23 @@ 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) {
+	switch (true) {
+		case value === null:
+		case value === void 0:
+		case typeof value === "bigint":
+		case typeof value === "boolean":
+		case typeof value === "number":
+		case typeof value === "string": return value;
+		case value instanceof Date: return new Date(value.getTime());
+		default: return cloneAny(value, getCloneParameters(options), 0);
+	}
 }
 clone.handlers = getSelfHandlers(clone, {
 	callback: tryStructuredClone,
@@ -3384,90 +3429,92 @@ clone.handlers = getSelfHandlers(clone, {
 });
 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) {
+	switch (true) {
+		case value == null:
+		case typeof value === "bigint":
+		case typeof value === "boolean":
+		case typeof value === "number":
+		case typeof value === "string": return value;
+		case value instanceof Date: return new Date(value.getTime());
+		case typeof value === "function": return parameters.options?.copyFunctions ? value : void 0;
+		case typeof value === "symbol": return parameters.options?.copySymbols ? value : Symbol(value.description);
+		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 clone.handlers.handle(value, parameters, depth);
+	}
+}
+function cloneArrayBuffer(value, parameters, depth) {
+	if (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) {
+function cloneDataView(value, parameters, depth) {
 	if (depth >= CLONE_MAX_DEPTH) return value;
-	const buffer = cloneArrayBuffer(value.buffer);
+	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;
+	const flat = parameters.options?.flat;
 	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 entry of entries) cloned.set(flat ? entry[0] : cloneAny(entry[0], parameters, depth + 1), flat ? entry[1] : cloneAny(entry[1], parameters, depth + 1));
+	parameters.references.set(map, cloned);
 	return cloned;
 }
-function cloneNode(node, depth, references) {
+function cloneNode(node, parameters, depth) {
 	if (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) {
+	const isArray = Array.isArray(value);
+	if (parameters.options?.flat || depth >= CLONE_MAX_DEPTH) 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) {
+function cloneRegularExpression(value, parameters, depth) {
 	if (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;
 	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 (let index = 0; index < length; index += 1) cloned.add(parameters.options?.flat ? values[index] : cloneAny(values[index], parameters, depth + 1));
+	parameters.references.set(set, cloned);
 	return cloned;
 }
-function cloneTypedArray(value, depth, references) {
+function cloneTypedArray(value, parameters, depth) {
 	if (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
 *
@@ -3478,7 +3525,7 @@ function cloneValue(value, depth, references, flat) {
 * @returns Copied value
 */
 function copy(value) {
-	return cloneValue(value, 0, /* @__PURE__ */ new WeakMap(), true);
+	return clone(value, CLONE_COPY_OPTIONS);
 }
 /**
 * Deregister a clone handler for a specific class
@@ -3490,6 +3537,25 @@ function copy(value) {
 function deregisterCloner(constructor) {
 	clone.handlers.deregister(constructor);
 }
+function getCloneOptions(input) {
+	if (typeof input === "boolean") return {
+		copyFunctions: false,
+		copySymbols: false,
+		flat: input === true
+	};
+	if (typeof input !== "object" || input === null) return CLONE_DEFAULT_OPTIONS;
+	return {
+		copyFunctions: input.copyFunctions === true,
+		copySymbols: input.copySymbols === true,
+		flat: input.flat === true
+	};
+}
+function getCloneParameters(input) {
+	return {
+		options: getCloneOptions(input),
+		references: /* @__PURE__ */ new WeakMap()
+	};
+}
 /**
 * Register a clone handler for a specific class
 *
@@ -3501,17 +3567,27 @@ 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,
+	flat: true
+};
+const CLONE_DEFAULT_OPTIONS = {
+	copyFunctions: false,
+	copySymbols: false,
+	flat: false
+};
 const CLONE_MAX_DEPTH = 100;
 //#endregion
 //#region src/value/collection.ts
@@ -3519,7 +3595,9 @@ 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 +3726,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 +3790,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 +3941,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 +3994,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 +4023,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 +4049,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 +4062,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 +6189,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 +6264,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,13 +6374,12 @@ 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

package/dist/internal/array/callbacks.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) {

package/dist/internal/array/index-of.mjs

@@ -3,9 +3,10 @@ import { FIND_VALUE_INDEX, findValue } from "./find.mjs";
 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
 export { indexOf, lastIndexOf };

package/dist/internal/function/assert.mjs

@@ -10,11 +10,6 @@ import { hasValueResult } from "../value/has.mjs";
 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
 *
@@ -92,5 +87,17 @@ 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
 export { assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty };