@oscarpalmer/atoms 0.179.0 → 0.180.0

package/dist/index.mjs

@@ -92,13 +92,13 @@ const FIND_VALUES_UNIQUE = "unique";
 const UNIQUE_THRESHOLD = 100;
 //#endregion
 //#region src/array/filter.ts
+function exclude(array, ...parameters) {
+	return findValues("all", array, parameters).notMatched;
+}
 function filter(array, ...parameters) {
 	return findValues("all", array, parameters).matched;
 }
-filter.remove = removeFiltered;
-function removeFiltered(array, ...parameters) {
-	return findValues("all", array, parameters).notMatched;
-}
+filter.remove = exclude;
 //#endregion
 //#region src/array/first.ts
 function first(array, ...parameters) {
@@ -175,7 +175,7 @@ function compact(array, strict) {
 //#endregion
 //#region src/internal/array/index-of.ts
 function indexOf(array, ...parameters) {
-	return findValue(FIND_VALUE_INDEX, array, parameters);
+	return findValue(FIND_VALUE_INDEX, array, parameters, false);
 }
 //#endregion
 //#region src/internal/is.ts
@@ -582,6 +582,11 @@ function push(array, pushed) {
 }
 //#endregion
 //#region src/array/reverse.ts
+/**
+* Reverse the order of items in an array
+* @param array Array to reverse
+* @returns Reversed array
+*/
 function reverse(array) {
 	if (!Array.isArray(array)) return [];
 	const { length } = array;
@@ -777,6 +782,8 @@ move.toIndex = moveToIndex;
 * Move an item from one index to another within an array
 *
 * If the from index is out of bounds, the array will be returned unchanged
+*
+* Available as `moveIndices` and `move.indices`
 * @param array Array to move within
 * @param from Index to move from
 * @param to Index to move to
@@ -908,20 +915,27 @@ const EXPRESSION_WORDS = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
 //#endregion
 //#region src/internal/value/handlers.ts
 function getCompareHandlers(owner, options) {
-	const { get, register, unregister } = getHandlers(owner, options);
+	const handlers = getHandlers(owner, options);
 	return {
-		register,
-		unregister,
+		deregister(constructor) {
+			handlers.deregister(constructor);
+		},
 		handle(first, second, ...parameters) {
-			const handler = get(first, second);
+			const handler = handlers.get(first, second);
 			if (handler == null) return options.callback(first, second, ...parameters);
 			return typeof handler === "function" ? handler(first, second) : first[handler](second);
+		},
+		register(constructor, handler) {
+			handlers.register(constructor, handler);
 		}
 	};
 }
 function getHandlers(owner, options) {
 	const handlers = /* @__PURE__ */ new WeakMap();
 	return {
+		deregister(constructor) {
+			handlers.delete(constructor);
+		},
 		get(first, second) {
 			if (isConstructable(first) && isConstructable(second) && first.constructor === second.constructor) return handlers.get(first.constructor);
 		},
@@ -931,21 +945,22 @@ function getHandlers(owner, options) {
 			if (typeof actual !== "function" && typeof actual !== "string") return;
 			if (typeof actual === "string") actual = typeof constructor.prototype[actual] === "function" ? actual : void 0;
 			if (actual != null) handlers.set(constructor, actual);
-		},
-		unregister(constructor) {
-			handlers.delete(constructor);
 		}
 	};
 }
 function getSelfHandlers(owner, options) {
-	const { get, register, unregister } = getHandlers(owner, options);
+	const handlers = getHandlers(owner, options);
 	return {
-		register,
-		unregister,
+		deregister(constructor) {
+			handlers.deregister(constructor);
+		},
 		handle(value, ...parameters) {
-			const handler = get(value, value);
+			const handler = handlers.get(value, value);
 			if (handler == null) return options.callback(value, ...parameters);
 			return typeof handler === "function" ? handler(value) : value[handler]();
+		},
+		register(constructor, handler) {
+			handlers.register(constructor, handler);
 		}
 	};
 }
@@ -989,8 +1004,8 @@ compare.handlers = getCompareHandlers(compare, {
 	},
 	method: COMPARE_NAME
 });
+compare.deregister = deregisterComparator;
 compare.register = registerComparator;
-compare.unregister = unregisterComparator;
 function compareNumbers(first, second) {
 	if (Object.is(first, second)) return 0;
 	if (Number.isNaN(first)) return -1;
@@ -1006,25 +1021,29 @@ function compareValue(first, second, compareStrings) {
 	if (first instanceof Date && second instanceof Date) return compareNumbers(first.getTime(), second.getTime());
 	return compare.handlers.handle(first, second, compareStrings);
 }
+/**
+* Deregister a custom comparison handler for a class
+*
+* Available as `deregisterComparator` and `compare.deregister`
+* @param constructor Class constructor
+*/
+function deregisterComparator(constructor) {
+	compare.handlers.deregister(constructor);
+}
 function getComparisonParts(value) {
 	if (Array.isArray(value)) return value;
 	return typeof value === "object" ? [value] : words(getString(value));
 }
 /**
 * Register a custom comparison handler for a class
+*
+* Available as `registerComparator` and `compare.register`
 * @param constructor Class constructor
 * @param handler Method name or comparison function _(defaults to `compare`)_
 */
 function registerComparator(constructor, handler) {
 	compare.handlers.register(constructor, handler);
 }
-/**
-* Unregister a custom comparison handler for a class
-* @param constructor Class constructor
-*/
-function unregisterComparator(constructor) {
-	compare.handlers.unregister(constructor);
-}
 const comparators = {
 	bigint: compareNumbers,
 	boolean: (first, second) => compareNumbers(first ? 1 : 0, second ? 1 : 0),
@@ -1050,23 +1069,7 @@ function getComparisonValue(first, second, sorters, length) {
 	}
 	return 0;
 }
-function getIndex(array, item, first, second) {
-	return getSortedIndex(array, item, getSorters(first, getModifier(first, second)));
-}
-function getModifier(first, second) {
-	return modifiers[first === true || second === true ? SORT_DIRECTION_DESCENDING : SORT_DIRECTION_ASCENDING];
-}
-function getObjectSorter(obj, modifier) {
-	let sorter;
-	if (typeof obj.comparison === "function") sorter = getComparisonSorter(obj.comparison, modifier);
-	else if (typeof obj.key === "string") {
-		sorter = getValueSorter(obj.key, modifier);
-		if (typeof obj.compare === "function") sorter.compare = { complex: obj.compare };
-	} else if (typeof obj.value === "function") sorter = getValueSorter(obj.value, modifier);
-	if (sorter != null && typeof obj.direction === "string") sorter.modifier = modifiers[obj.direction] ?? modifier;
-	return sorter;
-}
-function getSortedIndex(array, item, sorters) {
+function getIndex(array, item, sorters) {
 	if (!Array.isArray(array)) return -1;
 	const { length } = array;
 	if (length === 0) return 0;
@@ -1082,6 +1085,22 @@ function getSortedIndex(array, item, sorters) {
 	}
 	return low;
 }
+function getModifier(first, second) {
+	return modifiers[first === true || second === true ? SORT_DIRECTION_DESCENDING : SORT_DIRECTION_ASCENDING];
+}
+function getObjectSorter(obj, modifier) {
+	let sorter;
+	if (typeof obj.comparison === "function") sorter = getComparisonSorter(obj.comparison, modifier);
+	else if (typeof obj.key === "string") {
+		sorter = getValueSorter(obj.key, modifier);
+		if (typeof obj.compare === "function") sorter.compare = { complex: obj.compare };
+	} else if (typeof obj.value === "function") sorter = getValueSorter(obj.value, modifier);
+	if (sorter != null && typeof obj.direction === "string") sorter.modifier = modifiers[obj.direction] ?? modifier;
+	return sorter;
+}
+function getSortedIndex(array, item, first, second) {
+	return getIndex(array, item, getSorters(first, getModifier(first, second)));
+}
 function getSorter(value, modifier) {
 	switch (true) {
 		case typeof value === "function": return getComparisonSorter(value, modifier);
@@ -1114,10 +1133,10 @@ function getValueSorter(value, modifier) {
 		value: typeof value === "function" ? value : (item) => item[value]
 	};
 }
-function initializeSort(first, second) {
+function initializeSorter(first, second) {
 	const sorters = getSorters(first, getModifier(first, second));
 	const sorter = (array) => sortArray(array, sorters);
-	sorter.index = (array, item) => getSortedIndex(array, item, sorters);
+	sorter.index = (array, item) => getIndex(array, item, sorters);
 	sorter.is = (array) => isSortedArray(array, sorters);
 	return sorter;
 }
@@ -1156,8 +1175,8 @@ function sortArray(array, sorters) {
 	const { length } = sorters;
 	return array.length > 1 ? array.sort((first, second) => getComparisonValue(first, second, sorters, length)) : array;
 }
-sort.index = getIndex;
-sort.initialize = initializeSort;
+sort.index = getSortedIndex;
+sort.initialize = initializeSorter;
 sort.is = isSorted;
 const ARRAY_PEEK_PERCENTAGE$1 = 10;
 const ARRAY_THRESHOLD$1 = 100;
@@ -1198,6 +1217,8 @@ function swapArrays(array, from, to, key) {
 * Swap two indiced items in an array
 *
 * If either index is out of bounds, the array will be returned unchanged
+*
+* Available as `swapIndices` and `swap.indices`
 * @param array Array of items to swap
 * @param first First index _(can be negative to count from the end)_
 * @param second Second index _(can be negative to count from the end)_
@@ -1273,6 +1294,8 @@ assert.instanceOf = assertInstanceOf;
 assert.is = assertIs;
 /**
 * Creates an asserter that asserts a condition is true, throwing an error if it is not
+*
+* Available as `assertCondition` and `assert.condition`
 * @param condition Condition to assert
 * @param message Error message
 * @param error Error constructor
@@ -1285,6 +1308,8 @@ function assertCondition(condition, message, error) {
 }
 /**
 * Asserts that a value is defined throwing an error if it is not
+*
+* Available as `assertDefined` and `assert.defined`
 * @param value Value to assert
 * @param message Error message
 */
@@ -1293,6 +1318,8 @@ function assertDefined(value, message) {
 }
 /**
 * Creates an asserter that asserts a value is an instance of a constructor, throwing an error if it is not
+*
+* Available as `assertInstanceOf` and `assert.instanceOf`
 * @param constructor Constructor to check against
 * @param message Error message
 * @param error Error constructor
@@ -1305,6 +1332,8 @@ function assertInstanceOf(constructor, message, error) {
 }
 /**
 * Creates an asserter that asserts a value is of a specific type, throwing an error if it is not
+*
+* Available as `assertIs` and `assert.is`
 * @param condition Type guard function to check the value
 * @param message Error message
 * @param error Error constructor
@@ -1578,7 +1607,9 @@ function getAsyncTimer(type, callback, time) {
 		});
 		last = next;
 		if (throttle) run(next);
-		else id = startTimer(() => run(next));
+		else id = startTimer(() => {
+			run(next);
+		});
 		return next.promise;
 	};
 	timer.cancel = () => {
@@ -1631,6 +1662,8 @@ const startTimer = typeof requestAnimationFrame === "function" ? requestAnimatio
 * When called, successful _(finished)_ results will resolve and errors will reject.
 *
 * On subsequent calls, existing calls will be canceled _(rejected)_, the timer reset, and will wait another `time` milliseconds before the new call is made _(and so on...)_
+*
+* Available as `asyncDebounce` and `debounce.async`
 * @param callback Callback to debounce
 * @param time Time in milliseconds to wait before calling the callback _(defaults to `0`; e.g., as soon as possible)_
 * @returns Debounced callback handler with a `cancel` method
@@ -1644,6 +1677,8 @@ function asyncDebounce(callback, time) {
 * When called, successful _(finished)_ results will resolve and errors will reject.
 *
 * On subsequent calls, existing calls will be canceled _(rejected)_ and will wait until the next valid time to call the callback again _(and so on...)_
+*
+* Available as `asyncThrottle` and `throttle.async`
 * @param callback Callback to throttle
 * @param time Time in milliseconds to wait before calling the callback again _(defaults to `0`; e.g., as soon as possible)_
 * @returns Throttled callback handler with a `cancel` method
@@ -1677,6 +1712,8 @@ throttle.async = asyncThrottle;
 //#region src/function/once.ts
 /**
 * Create an asynchronous function that can only be called once, rejecting or resolving the same result on subsequent calls
+*
+* Available as `asyncOnce` and `once.async`
 * @param callback Callback to use once
 * @returns Once callback
 */
@@ -1781,6 +1818,8 @@ var RetryError = class extends Error {
 };
 /**
 * Retry a callback a specified number of times, with a delay between attempts
+*
+* Available as `asyncRetry` and `retry.async`
 * @param callback Callback to retry
 * @param options Retry options
 * @returns Callback result
@@ -1937,13 +1976,28 @@ const assertFlowFunctions = assert.condition((value) => Array.isArray(value) &&
 const assertPipeFunctions = assert.condition((value) => Array.isArray(value) && value.every((item) => typeof item === "function"), MESSAGE_PIPE_ARRAY, TypeError);
 //#endregion
 //#region src/internal/value/equal.ts
+/**
+* Deregister a equality comparison handler for a specific class
+*
+* Available as `deregisterEqualizer` and `equal.deregister`
+* @param constructor Class constructor
+*/
+function deregisterEqualizer(constructor) {
+	equal.handlers.deregister(constructor);
+}
+function filterKey(key, options) {
+	if (typeof key !== "string") return true;
+	if (options.ignoreExpressions.enabled && options.ignoreExpressions.values.some((expression) => expression.test(key))) return false;
+	if (options.ignoreKeys.enabled && options.ignoreKeys.values.has(key)) return false;
+	return true;
+}
 function equal(first, second, options) {
 	return equalValue(first, second, getEqualOptions(options));
 }
 equal.handlers = getCompareHandlers(equal, { callback: Object.is });
+equal.deregister = deregisterEqualizer;
 equal.initialize = initializeEqualizer;
 equal.register = registerEqualizer;
-equal.unregister = unregisterEqualizer;
 function equalArray(first, second, options) {
 	const { length } = first;
 	if (length !== second.length) return false;
@@ -2035,39 +2089,6 @@ function equalValue(first, second, options) {
 		default: return equal.handlers.handle(first, second, options);
 	}
 }
-/**
-* Create an equalizer with predefined options
-* @param options Comparison options
-* @returns Equalizer function
-*/
-function initializeEqualizer(options) {
-	const actual = getEqualOptions(options);
-	const equalizer = (first, second) => equalValue(first, second, actual);
-	equalizer.register = registerEqualizer;
-	equalizer.unregister = unregisterEqualizer;
-	return equalizer;
-}
-/**
-* Register a equality comparison function for a specific class
-* @param constructor Class constructor
-* @param fn Comparison function
-*/
-function registerEqualizer(constructor, handler) {
-	equal.handlers.register(constructor, handler);
-}
-/**
-* Unregister a equality comparison handler for a specific class
-* @param constructor Class constructor
-*/
-function unregisterEqualizer(constructor) {
-	equal.handlers.unregister(constructor);
-}
-function filterKey(key, options) {
-	if (typeof key !== "string") return true;
-	if (options.ignoreExpressions.enabled && options.ignoreExpressions.values.some((expression) => expression.test(key))) return false;
-	if (options.ignoreKeys.enabled && options.ignoreKeys.values.has(key)) return false;
-	return true;
-}
 function getEqualOptions(input) {
 	const options = {
 		ignoreCase: false,
@@ -2094,12 +2115,76 @@ function getEqualOptions(input) {
 	options.relaxedNullish = input.relaxedNullish === true;
 	return options;
 }
+/**
+* Create an equalizer with predefined options
+*
+* Available as `initializeEqualizer` and `equal.initialize`
+* @param options Comparison options
+* @returns Equalizer function
+*/
+function initializeEqualizer(options) {
+	const actual = getEqualOptions(options);
+	const equalizer = (first, second) => equalValue(first, second, actual);
+	equalizer.deregister = deregisterEqualizer;
+	equalizer.register = registerEqualizer;
+	return equalizer;
+}
+/**
+* Register a equality comparison function for a specific class
+*
+* Available as `registerEqualizer` and `equal.register`
+* @param constructor Class constructor
+* @param handler Comparison function
+*/
+function registerEqualizer(constructor, handler) {
+	equal.handlers.register(constructor, handler);
+}
 const ARRAY_PEEK_PERCENTAGE = 10;
 const ARRAY_THRESHOLD = 100;
 const ERROR_PROPERTIES = ["name", "message"];
 const EXPRESSION_PROPERTIES = ["source", "flags"];
 const MINIMUM_LENGTH_FOR_SET = 16;
 //#endregion
+//#region src/result/misc.ts
+function error(value, original) {
+	return getError(value, original);
+}
+function getError(value, original) {
+	const errorResult = {
+		error: value,
+		ok: false
+	};
+	if (original instanceof Error) errorResult.original = original;
+	return errorResult;
+}
+/**
+* Creates an ok result
+* @param value Value
+* @returns Ok result
+*/
+function ok(value) {
+	return {
+		ok: true,
+		value
+	};
+}
+/**
+* Converts a result to a promise
+*
+* Resolves if ok, rejects for error
+* @param result Result to convert
+* @returns Promised result
+*/
+async function toPromise(result) {
+	const actual = typeof result === "function" ? result() : result;
+	if (!isResult(actual)) return Promise.reject(new Error(MESSAGE_PROMISE_RESULT));
+	return isOk(actual) ? Promise.resolve(actual.value) : Promise.reject(actual.error);
+}
+function unwrap(value, defaultValue) {
+	return isOk(value) ? value.value : defaultValue;
+}
+const MESSAGE_PROMISE_RESULT = "toPromise expected to receive a Result";
+//#endregion
 //#region src/internal/value/misc.ts
 function findKey(needle, haystack) {
 	const keys = Object.keys(haystack);
@@ -2107,10 +2192,7 @@ function findKey(needle, haystack) {
 	return index > -1 ? keys[index] : needle;
 }
 function getNestedValue(data, path, ignoreCase) {
-	if (typeof data !== "object" || data === null || typeof path !== "string" || path.trim().length === 0) return {
-		exists: false,
-		value: void 0
-	};
+	if (typeof data !== "object" || data === null || typeof path !== "string" || path.trim().length === 0) return error(void 0);
 	const shouldIgnoreCase = ignoreCase === true;
 	const paths = getPaths(path, shouldIgnoreCase);
 	if (typeof paths === "string") return handleValue(data, paths, null, true, shouldIgnoreCase);
@@ -2119,13 +2201,10 @@ function getNestedValue(data, path, ignoreCase) {
 	for (let index = 0; index < length; index += 1) {
 		const part = paths[index];
 		const handled = handleValue(current, part, null, true, shouldIgnoreCase);
-		if (!handled.exists) return handled;
+		if (!handled.ok) return handled;
 		current = handled.value;
 	}
-	return {
-		exists: true,
-		value: current
-	};
+	return ok(current);
 }
 function getPaths(path, lowercase) {
 	const normalized = lowercase ? path.toLowerCase() : path;
@@ -2135,16 +2214,10 @@ function getPaths(path, lowercase) {
 function handleValue(data, path, value, get, ignoreCase) {
 	if (typeof data === "object" && data !== null && !ignoreKey(path)) {
 		const key = ignoreCase ? findKey(path, data) : path;
-		if (get) return {
-			exists: key in data,
-			value: data[key]
-		};
+		if (get) return key in data ? ok(data[key]) : error(void 0);
 		data[key] = typeof value === "function" ? value(data[key]) : value;
 	}
-	if (get) return {
-		exists: false,
-		value: void 0
-	};
+	if (get) return error(void 0);
 }
 const EXPRESSION_BRACKET = /\[(\w+)\]/g;
 const EXPRESSION_DOTS = /^\.|\.$/g;
@@ -2157,10 +2230,10 @@ function getValue(data, path, ignoreCase) {
 //#endregion
 //#region src/internal/value/has.ts
 function hasValue(data, path, ignoreCase) {
-	return getNestedValue(data, path, ignoreCase === true).exists;
+	return getNestedValue(data, path, ignoreCase === true).ok;
 }
-hasValue.get = getWithHasValue;
-function getWithHasValue(data, path, ignoreCase) {
+hasValue.get = hasValueResult;
+function hasValueResult(data, path, ignoreCase) {
 	return getNestedValue(data, path, ignoreCase === true);
 }
 //#endregion
@@ -2495,7 +2568,7 @@ var Fuzzy = class {
 		this.#state = state;
 	}
 	search(value, options) {
-		return search(this.#state.items, this.#state.strings, value, options == null ? this.#state : getOptions$1(options, this.#state));
+		return search(this.#state.items, this.#state.strings, value, options == null ? this.#state : getFuzzyOptions(options, this.#state));
 	}
 };
 function getHandler(input) {
@@ -2511,18 +2584,17 @@ function getHandler(input) {
 function getItems(items) {
 	return items.sort((first, second) => first.haystack.localeCompare(second.haystack)).map(({ item }) => item);
 }
-function getOptions$1(input, state) {
+function getFuzzyOptions(input, state) {
 	const options = isPlainObject(input) ? input : {};
 	const limit = typeof input === "number" ? input : options.limit;
 	if (typeof limit === "number" && !Number.isNaN(limit) && limit >= 1) options.limit = Math.floor(limit);
 	else options.limit = state?.limit;
-	if (typeof options.tolerance === "number" && !Number.isNaN(options.tolerance)) options.tolerance = options.tolerance < 0 ? 0 : Math.floor(options.tolerance);
-	else options.tolerance = state?.tolerance ?? PROXIMITY_THRESHOLD;
+	options.tolerance = getTolerance(options.tolerance, state);
 	return options;
 }
 function getState$1(items, input) {
 	const handler = getHandler(input);
-	const options = getOptions$1(input);
+	const options = getFuzzyOptions(input);
 	return {
 		handler,
 		items: items.slice(),
@@ -2531,10 +2603,27 @@ function getState$1(items, input) {
 		tolerance: options.tolerance
 	};
 }
+function getTolerance(input, state) {
+	if (typeof input === "number" && !Number.isNaN(input)) return input < 0 ? 0 : Math.floor(input);
+	return state?.tolerance ?? PROXIMITY_THRESHOLD;
+}
 function fuzzy(items, configuration) {
 	if (!Array.isArray(items)) throw new TypeError(MESSAGE_ARRAY);
 	return new Fuzzy(getState$1(items, configuration));
 }
+fuzzy.match = fuzzyMatch;
+/**
+* Does the needle match the haystack in a fuzzy way?
+* @param haystack Haystack to search through
+* @param needle Needle to search for
+* @returns `true` if the needle matches the haystack in a fuzzy way, `false` otherwise
+*/
+function fuzzyMatch(haystack, needle) {
+	if (typeof haystack !== "string" || typeof needle !== "string") return false;
+	const trimmed = needle.trim();
+	if (includes(haystack, trimmed, true)) return true;
+	return getScore(haystack, trimmed) > -1;
+}
 function isSubsequence(haystack, needle) {
 	const lowerCaseHaystack = lowerCase(haystack);
 	const lowerCaseNeedle = lowerCase(needle);
@@ -2734,6 +2823,8 @@ function handleTemplate(value, pattern, ignoreCase, variables) {
 }
 /**
 * Create a templater with predefined options
+*
+* Available as `initializeTemplater` and `template.initialize`
 * @param options Templating options
 * @returns Templater function
 */
@@ -2766,23 +2857,8 @@ clone.handlers = getSelfHandlers(clone, {
 	callback: tryStructuredClone,
 	method: CLONE_NAME
 });
+clone.deregister = deregisterCloner;
 clone.register = registerCloner;
-clone.unregister = unregisterCloner;
-/**
-* Register a clone handler for a specific class
-* @param constructor Class constructor
-* @param handler Method name or clone function _(defaults to `clone`)_
-*/
-function registerCloner(constructor, handler) {
-	clone.handlers.register(constructor, handler);
-}
-/**
-* Unregister a clone handler for a specific class
-* @param constructor Class constructor
-*/
-function unregisterCloner(constructor) {
-	clone.handlers.unregister(constructor);
-}
 function cloneArrayBuffer(value, depth, references) {
 	if (typeof depth === "number" && depth >= MAX_CLONE_DEPTH) return value;
 	const cloned = new ArrayBuffer(value.byteLength);
@@ -2867,6 +2943,25 @@ function cloneValue(value, depth, references) {
 		default: return clone.handlers.handle(value, depth, references);
 	}
 }
+/**
+* Deregister a clone handler for a specific class
+*
+* Available as `deregisterCloner` and `template.deregister`
+* @param constructor Class constructor
+*/
+function deregisterCloner(constructor) {
+	clone.handlers.deregister(constructor);
+}
+/**
+* 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 `clone`)_
+*/
+function registerCloner(constructor, handler) {
+	clone.handlers.register(constructor, handler);
+}
 function tryStructuredClone(value, depth, references) {
 	if (depth >= MAX_CLONE_DEPTH) return value;
 	try {
@@ -3128,12 +3223,10 @@ function getReplaceableObjects(value) {
 function handleMerge(values, options) {
 	return !Array.isArray(values) || values.length === 0 ? {} : mergeValues(values, options, true);
 }
-function merge(values, options) {
-	return handleMerge(values, getMergeOptions(options));
-}
-merge.initialize = initializeMerger;
 /**
 * Create a merger with predefined options
+*
+* Available as `initializeMerger` and `merge.initialize`
 * @param options Merging options
 * @returns Merger function
 */
@@ -3141,6 +3234,10 @@ function initializeMerger(options) {
 	const actual = getMergeOptions(options);
 	return (values) => handleMerge(values, actual);
 }
+function merge(values, options) {
+	return handleMerge(values, getMergeOptions(options));
+}
+merge.initialize = initializeMerger;
 function mergeObjects(values, options, prefix) {
 	const { length } = values;
 	const isArray = values.every(Array.isArray);
@@ -4187,46 +4284,6 @@ function sum(array, key) {
 	return getAggregated("sum", array, key);
 }
 //#endregion
-//#region src/result/misc.ts
-function error(value, original) {
-	return getError(value, original);
-}
-function getError(value, original) {
-	const errorResult = {
-		error: value,
-		ok: false
-	};
-	if (original instanceof Error) errorResult.original = original;
-	return errorResult;
-}
-/**
-* Creates an ok result
-* @param value Value
-* @returns Ok result
-*/
-function ok(value) {
-	return {
-		ok: true,
-		value
-	};
-}
-/**
-* Converts a result to a promise
-*
-* Resolves if ok, rejects for error
-* @param result Result to convert
-* @returns Promised result
-*/
-async function toPromise(result) {
-	const actual = typeof result === "function" ? result() : result;
-	if (!isResult(actual)) return Promise.reject(new Error(MESSAGE_PROMISE_RESULT));
-	return isOk(actual) ? Promise.resolve(actual.value) : Promise.reject(actual.error);
-}
-function unwrap(value, defaultValue) {
-	return isOk(value) ? value.value : defaultValue;
-}
-const MESSAGE_PROMISE_RESULT = "toPromise expected to receive a Result";
-//#endregion
 //#region src/promise/models.ts
 var CancelablePromise = class extends Promise {
 	#rejector;
@@ -4870,7 +4927,7 @@ async function attemptAsyncPipe(initial, first, ...seconds) {
 		if (isError(initial)) throw initial.error;
 		const value = typeof initial === "function" ? initial() : isOk(initial) ? initial.value : initial;
 		if (first == null) return value;
-		return pipe.async(value, ...[first, ...seconds]);
+		return asyncPipe(value, ...[first, ...seconds]);
 	});
 }
 function attemptPipe(initial, first, ...seconds) {
@@ -4960,4 +5017,4 @@ var SizedSet = class extends Set {
 	}
 };
 //#endregion
-export { CancelablePromise, PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, PromiseTimeoutError, QueueError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, assert, attempt, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, count, debounce, dedent, delay, diff, difference, drop, endsWith, endsWithArray, equal, error, exists, filter, find, first, flatten, floor, flow, fromQuery, toPromise as fromResult, toPromise, fuzzy, getArray, getArrayPosition, getColor, getError, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getString, getTimedPromise, getUuid, getValue, groupBy, handleResult, hasValue, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, insert, intersection, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isTypedArray, join, kebabCase, last, logger, lowerCase, matchResult, max, median, memoize, merge, min, move, noop, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, settlePromise, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toQuery, toRecord, toResult, toSet, toggle, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };
+export { CancelablePromise, PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, PromiseTimeoutError, QueueError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, 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, count, debounce, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, filter, find, first, firstOrDefault, flatten, floor, flow, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayPosition, getColor, getError, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeEqualizer, initializeMerger, initializeSorter, initializeTemplater, insert, intersection, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isSorted, isTypedArray, join, kebabCase, last, lastOrDefault, logger, lowerCase, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, settlePromise, 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, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };