@oscarpalmer/atoms 0.196.1 → 0.198.0

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 };

package/dist/internal/math/aggregate.d.mts

@@ -49,7 +49,7 @@ declare function max<Item>(items: Item[], callback: (item: Item, index: number,
  * @param first Return only the first item with the maximum value
  * @returns Item with the maximum value, or `undefined` if no maximum can be found
  */
-declare function max<Item extends PlainObject, ItemKey extends keyof NumericalValues<Item>>(items: Item[], key: ItemKey, first: true): Item | undefined;
+declare function max<Item extends PlainObject>(items: Item[], key: keyof NumericalValues<Item>, first: true): Item | undefined;
 /**
  * Get the maximum value from a list of items
  *
@@ -85,7 +85,7 @@ declare function max<Item>(items: Item[], callback: (item: Item, index: number,
  * @param key Key to use for value
  * @returns Items with the maximum value
  */
-declare function max<Item extends PlainObject, ItemKey extends keyof NumericalValues<Item>>(items: Item[], key: ItemKey): Item[];
+declare function max<Item extends PlainObject>(items: Item[], key: keyof NumericalValues<Item>): Item[];
 /**
  * Get the maximum value from a list of numbers
  *

package/dist/internal/sized/map.mjs

@@ -33,11 +33,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

package/dist/internal/value/compare.d.mts

@@ -10,12 +10,12 @@ type Comparator<Value = any> = (first: Value, second: Value) => number;
  */
 declare function compare(first: unknown, second: unknown): number;
 declare namespace compare {
+  var deregister: typeof deregisterComparator;
   var handlers: {
     deregister(constructor: Constructor): void;
     handle(first: unknown, second: unknown, ...parameters: unknown[]): number;
     register(constructor: Constructor, handler?: string | GenericCallback): void;
   };
-  var deregister: typeof deregisterComparator;
   var register: typeof registerComparator;
 }
 /**

package/dist/internal/value/compare.mjs

@@ -32,14 +32,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;
@@ -86,5 +78,17 @@ 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
 export { compare, deregisterComparator, registerComparator };

package/dist/internal/value/handlers.d.mts

@@ -11,7 +11,7 @@ declare function getCompareHandlers<Value>(owner: GenericCallback, options: Opti
 };
 declare function getSelfHandlers(owner: GenericCallback, options: Options): {
   deregister(constructor: Constructor): void;
-  handle(value: unknown, ...parameters: unknown[]): any;
+  handle(value: unknown, ...parameters: unknown[]): unknown;
   register(constructor: Constructor, handler?: string | GenericCallback): void;
 };
 //#endregion

package/dist/internal/value/has.mjs

@@ -3,9 +3,10 @@ import { getNestedValue } from "./misc.mjs";
 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
 export { hasValue, hasValueResult };

package/dist/promise/index.mjs

@@ -66,9 +66,10 @@ 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
 export { attemptPromise, promises, resultPromises };

package/dist/queue.mjs

@@ -241,7 +241,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);
@@ -317,5 +316,7 @@ 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
 export { QueueError, isKeyedQueue, isQueue, isQueueInstance, keyedQueue, queue };

package/dist/sized/set.mjs

@@ -45,13 +45,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/string/fuzzy.mjs

@@ -56,7 +56,6 @@ function fuzzy(items, configuration) {
 	});
 	return Object.freeze(instance);
 }
-fuzzy.match = fuzzyMatch;
 /**
 * Does the needle match the haystack in a fuzzy way?
 *
@@ -163,5 +162,7 @@ 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
 export { fuzzy, fuzzyMatch };

package/dist/string/normalize.mjs

@@ -51,7 +51,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;
@@ -103,5 +102,7 @@ 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
 export { deburr, initializeNormalizer, normalize };

package/dist/string/template.mjs

@@ -45,7 +45,8 @@ 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
 export { initializeTemplater, template };

package/dist/value/clone.d.mts

@@ -1,33 +1,66 @@
 import { Constructor, GenericCallback } from "../models.mjs";
 //#region src/value/clone.d.ts
+type CloneOptions = {
+  /**
+   * Copy functions instead of returning `undefined`? _(defaults to `false`)_
+   */
+  copyFunctions?: boolean;
+  /**
+   * Copy symbols instead of returning `Symbol(description)`? _(defaults to `false`)_
+   */
+  copySymbols?: boolean;
+};
 /**
- * Clone any kind of value _(shallowly)_
- *
- * @param value Value to clone
- * @param flat Clone only the value itself, without cloning nested values
- * @returns Cloned value
+ * A cloning function with predefined options
  */
-declare function clone<Value>(value: Value, flat: true): Value;
+type Cloner = {
+  /**
+   * Clone any kind of value
+   *
+   * @param value Value to clone
+   * @returns Cloned value
+   */
+  <Value>(value: Value): Value;
+  /**
+   * Deregister a clone handler for a specific class
+   *
+   * _Available as `deregisterCloner` and `template.deregister`_
+   *
+   * @param constructor Class constructor
+   */
+  deregister: typeof deregisterCloner;
+  /**
+   * Register a clone handler for a specific class
+   *
+   * _Available as `registerCloner` and `template.register`_
+   *
+   * @param constructor Class constructor
+   * @param handler Method name or clone function _(defaults to method name `clone`)_
+   */
+  register: typeof registerCloner;
+};
 /**
  * Clone any kind of value _(deeply, if needed)_
  *
  * @param value Value to clone
+ * @param options Clone options
  * @returns Cloned value
  */
-declare function clone<Value>(value: Value): Value;
+declare function clone<Value>(value: Value, options?: CloneOptions): Value;
 declare namespace clone {
+  var deregister: typeof deregisterCloner;
   var handlers: {
     deregister(constructor: Constructor): void;
-    handle(value: unknown, ...parameters: unknown[]): any;
+    handle(value: unknown, ...parameters: unknown[]): unknown;
     register(constructor: Constructor, handler?: string | GenericCallback): void;
   };
-  var deregister: typeof deregisterCloner;
+  var initialize: typeof initializeCloner;
   var register: typeof registerCloner;
 }
 /**
  * Copy any kind of value
  *
- * - Clones the value shallowly, without cloning nested values
+ * - Copies the value shallowly _(if possible)_, without copying or cloning nested values
  * - To copy a value deeply, use `clone` instead
  *
  * @param value Value to copy
@@ -42,6 +75,15 @@ declare function copy<Value>(value: Value): Value;
  * @param constructor Class constructor
  */
 declare function deregisterCloner<Instance>(constructor: Constructor<Instance>): void;
+/**
+ * Create a cloner with predefined options
+ *
+ * _Available as `initializeCloner` and `clone.initialize`_
+ *
+ * @param options Clone options
+ * @returns Cloner function
+ */
+declare function initializeCloner(options?: CloneOptions): Cloner;
 /**
  * Register a clone handler for a specific class
  *
@@ -52,4 +94,4 @@ declare function deregisterCloner<Instance>(constructor: Constructor<Instance>):
  */
 declare function registerCloner<Instance>(constructor: Constructor<Instance>, handler?: string | ((value: Instance) => Instance)): void;
 //#endregion
-export { clone, copy, deregisterCloner, registerCloner };
+export { CloneOptions, Cloner, clone, copy, deregisterCloner, initializeCloner, registerCloner };

package/dist/value/clone.mjs

@@ -2,110 +2,104 @@ import { isArrayOrPlainObject, isTypedArray } from "../internal/is.mjs";
 import { getSelfHandlers } from "../internal/value/handlers.mjs";
 //#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
@@ -117,6 +111,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
 *
@@ -128,17 +153,49 @@ 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
-export { clone, copy, deregisterCloner, registerCloner };
+export { clone, copy, deregisterCloner, initializeCloner, registerCloner };

package/dist/value/collection.mjs

@@ -4,7 +4,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_?

package/dist/value/freeze.mjs

@@ -10,8 +10,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);
@@ -76,5 +74,11 @@ 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
 export { flatFreeze, freeze, isFrozen };