@oscarpalmer/atoms 0.129.0 → 0.130.0

package/dist/atoms.full.js

@@ -325,6 +325,51 @@ function words(value) {
 }
 const EXPRESSION_IGNORED = /(^|\.)(__proto__|constructor|prototype)(\.|$)/i;
 const EXPRESSION_WORDS = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
+function getCompareHandlers(owner, options) {
+	const { get, register, unregister } = getHandlers(owner, options);
+	return {
+		register,
+		unregister,
+		handle(first, second, ...parameters) {
+			const handler = get(first, second);
+			if (handler == null) return options.callback(first, second, ...parameters);
+			return typeof handler === "function" ? handler(first, second) : first[handler](second);
+		}
+	};
+}
+function getHandlers(owner, options) {
+	const handlers = /* @__PURE__ */ new WeakMap();
+	return {
+		get(first, second) {
+			if (isConstructable(first) && isConstructable(second) && first.constructor === second.constructor) return handlers.get(first.constructor);
+		},
+		register(constructor, handler) {
+			if (!isConstructor(constructor) || handler === owner) return;
+			let actual = handler ?? options.method;
+			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);
+	return {
+		register,
+		unregister,
+		handle(value, ...parameters) {
+			const handler = get(value, value);
+			if (handler == null) return options.callback(value, ...parameters);
+			return typeof handler === "function" ? handler(value) : value[handler]();
+		}
+	};
+}
+function isConstructable(value) {
+	return typeof value === "object" && value !== null;
+}
 function compare(first, second) {
 	if (Object.is(first, second)) return 0;
 	if (first == null) return -1;
@@ -347,6 +392,16 @@ function compare(first, second) {
 	}
 	return 0;
 }
+compare.handlers = getCompareHandlers(compare, {
+	callback: (first, second, compareStrings) => {
+		if (compareStrings) return getString(first).localeCompare(getString(second));
+	},
+	method: "compare"
+});
+compare.register = function(constructor, handler) {
+	compare.handlers.register(constructor, handler);
+};
+compare.unregister = compare.handlers.unregister;
 function compareNumbers(first, second) {
 	const firstNumber = Number(first);
 	const secondNumber = Number(second);
@@ -360,7 +415,7 @@ function compareValue(first, second, compareStrings) {
 	const firstType = typeof first;
 	if (firstType === typeof second && firstType in comparators) return comparators[firstType](first, second);
 	if (first instanceof Date && second instanceof Date) return compareNumbers(first.getTime(), second.getTime());
-	if (compareStrings) return getString(first).localeCompare(getString(second));
+	return compare.handlers.handle(first, second, compareStrings);
 }
 function getComparisonParts(value) {
 	if (Array.isArray(value)) return value;
@@ -1626,12 +1681,12 @@ function titleCase(value) {
 	return memoizedTitleCase.run(value);
 }
 function toCase(type, value, capitalizeAny, capitalizeFirst) {
-	memoizers$1[type] ??= memoize(toCaseCallback.bind({
+	caseMemoizers[type] ??= memoize(toCaseCallback.bind({
 		type,
 		capitalizeAny,
 		capitalizeFirst
 	}));
-	return memoizers$1[type].run(value);
+	return caseMemoizers[type].run(value);
 }
 function toCaseCallback(value) {
 	if (typeof value !== "string") return "";
@@ -1667,7 +1722,7 @@ const delimiters = {
 };
 const EXPRESSION_CAMEL_CASE = /(\p{Ll})(\p{Lu})/gu;
 const EXPRESSION_ACRONYM = /(\p{Lu}*)(\p{Lu})(\p{Ll}+)/gu;
-const memoizers$1 = {};
+const caseMemoizers = {};
 const REPLACEMENT_CAMEL_CASE = "$1-$2";
 let memoizedCapitalize;
 let memoizedTitleCase;
@@ -1696,8 +1751,8 @@ function includes(haystack, needle, ignoreCase) {
 }
 function match(type, haystack, needle, ignoreCase) {
 	if (typeof haystack !== "string" || typeof needle !== "string") return false;
-	memoizers[type] ??= memoize(matchCallback.bind(type));
-	return memoizers[type].run(haystack, needle, ignoreCase);
+	matchMemoizers[type] ??= memoize(matchCallback.bind(type));
+	return matchMemoizers[type].run(haystack, needle, ignoreCase);
 }
 function matchCallback(haystack, needle, ignoreCase) {
 	return (ignoreCase ? haystack.toLocaleLowerCase() : haystack)[this](ignoreCase ? needle.toLocaleLowerCase() : needle);
@@ -1724,7 +1779,7 @@ function truncate(value, length, suffix) {
 	const truncatedLength = length - actualSuffixLength;
 	return `${value.slice(0, truncatedLength)}${actualSuffix}`;
 }
-const memoizers = {};
+const matchMemoizers = {};
 function getValue(data, path, ignoreCase) {
 	if (typeof data !== "object" || data === null || typeof path !== "string" || path.trim().length === 0) return;
 	const shouldIgnoreCase = ignoreCase === true;
@@ -1807,11 +1862,6 @@ function equalMap(first, second, options) {
 	}
 	return true;
 }
-function equalObject(first, second) {
-	const comparison = comparisons.get(first.constructor);
-	if (comparison == null) return Object.is(first, second);
-	return second instanceof first.constructor && comparison(first, second);
-}
 function equalPlainObject(first, second, options) {
 	let firstKeys = [...Object.keys(first), ...Object.getOwnPropertySymbols(first)];
 	let secondKeys = [...Object.keys(second), ...Object.getOwnPropertySymbols(second)];
@@ -1870,10 +1920,10 @@ function equalValue(first, second, options) {
 		case Array.isArray(first) && Array.isArray(second): return equalArray(first, second, options);
 		case isPlainObject(first) && isPlainObject(second): return equalPlainObject(first, second, options);
 		case isTypedArray(first) && isTypedArray(second): return equalTypedArray(first, second);
-		case typeof first === "object": return equalObject(first, second);
-		default: return Object.is(first, second);
+		default: return equal.handlers.handle(first, second, options);
 	}
 }
+equal.handlers = getCompareHandlers(equal, { callback: Object.is });
 equal.initialize = function(options) {
 	const actual = getEqualOptions(options);
 	const equalizer = (first, second) => equalValue(first, second, actual);
@@ -1881,12 +1931,10 @@ equal.initialize = function(options) {
 	equalizer.unregister = equal.unregister;
 	return equalizer;
 };
-equal.register = function(constructor, comparison) {
-	if (isConstructor(constructor) && typeof comparison === "function") comparisons.set(constructor, comparison);
-};
-equal.unregister = function(constructor) {
-	if (isConstructor(constructor)) comparisons.delete(constructor);
+equal.register = function(constructor, fn) {
+	equal.handlers.register(constructor, fn);
 };
+equal.unregister = equal.handlers.unregister;
 function filterKey(key, options) {
 	if (typeof key !== "string") return true;
 	if (options.ignoreExpressions.enabled && options.ignoreExpressions.values.some((expression) => expression.test(key))) return false;
@@ -1921,18 +1969,17 @@ function getEqualOptions(input) {
 }
 const ARRAY_PEEK_PERCENTAGE = 10;
 const ARRAY_THRESHOLD = 100;
-const comparisons = /* @__PURE__ */ new WeakMap();
 function clone(value) {
 	return cloneValue(value, 0, /* @__PURE__ */ new WeakMap());
 }
-clone.register = function(constructor, cloner) {
-	if (!isConstructor(constructor) || cloner === clone) return;
-	const actual = cloner ?? "clone";
-	if (typeof actual === "function" || typeof constructor.prototype[actual] === "function") cloners.set(constructor, actual);
-};
-clone.unregister = function(constructor) {
-	if (isConstructor(constructor)) cloners.delete(constructor);
+clone.handlers = getSelfHandlers(clone, {
+	callback: tryStructuredClone,
+	method: "clone"
+});
+clone.register = function(constructor, handler) {
+	clone.handlers.register(constructor, handler);
 };
+clone.unregister = clone.handlers.unregister;
 function cloneArrayBuffer(value, depth, references) {
 	if (typeof depth === "number" && depth >= MAX_CLONE_DEPTH) return value;
 	const cloned = new ArrayBuffer(value.byteLength);
@@ -1967,12 +2014,6 @@ function cloneNode(node, depth, references) {
 	references.set(node, cloned);
 	return cloned;
 }
-function cloneObject(value, depth, references) {
-	const cloner = cloners.get(value.constructor);
-	if (typeof cloner === "function") return cloner(value);
-	if (cloner == null) return tryStructuredClone(value, depth, references);
-	return value[cloner]();
-}
 function clonePlainObject(value, depth, references) {
 	if (depth >= MAX_CLONE_DEPTH) return Array.isArray(value) ? [...value] : { ...value };
 	const cloned = Array.isArray(value) ? [] : {};
@@ -2010,13 +2051,14 @@ function cloneValue(value, depth, references) {
 		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:
 		case value instanceof Set: return cloneMapOrSet(value, depth, references);
 		case value instanceof Node: return cloneNode(value, depth, references);
 		case isArrayOrPlainObject(value): return clonePlainObject(value, depth, references);
 		case isTypedArray(value): return cloneTypedArray(value, depth, references);
-		default: return cloneObject(value, depth, references);
+		default: return clone.handlers.handle(value, depth, references);
 	}
 }
 function tryStructuredClone(value, depth, references) {
@@ -2030,7 +2072,6 @@ function tryStructuredClone(value, depth, references) {
 		return value;
 	}
 }
-const cloners = /* @__PURE__ */ new WeakMap();
 const MAX_CLONE_DEPTH = 100;
 function diff(first, second, options) {
 	const relaxedNullish = typeof options === "object" && options?.relaxedNullish === true;

package/dist/internal/value/compare.js

@@ -1,5 +1,6 @@
 import { max } from "../math/aggregate.js";
 import { getString, words } from "../string.js";
+import { getCompareHandlers } from "./handlers.js";
 function compare(first, second) {
 	if (Object.is(first, second)) return 0;
 	if (first == null) return -1;
@@ -22,6 +23,16 @@ function compare(first, second) {
 	}
 	return 0;
 }
+compare.handlers = getCompareHandlers(compare, {
+	callback: (first, second, compareStrings) => {
+		if (compareStrings) return getString(first).localeCompare(getString(second));
+	},
+	method: "compare"
+});
+compare.register = function(constructor, handler) {
+	compare.handlers.register(constructor, handler);
+};
+compare.unregister = compare.handlers.unregister;
 function compareNumbers(first, second) {
 	const firstNumber = Number(first);
 	const secondNumber = Number(second);
@@ -35,7 +46,7 @@ function compareValue(first, second, compareStrings) {
 	const firstType = typeof first;
 	if (firstType === typeof second && firstType in comparators) return comparators[firstType](first, second);
 	if (first instanceof Date && second instanceof Date) return compareNumbers(first.getTime(), second.getTime());
-	if (compareStrings) return getString(first).localeCompare(getString(second));
+	return compare.handlers.handle(first, second, compareStrings);
 }
 function getComparisonParts(value) {
 	if (Array.isArray(value)) return value;

package/dist/internal/value/equal.js

@@ -1,5 +1,6 @@
-import { isConstructor, isPlainObject, isTypedArray } from "../is.js";
+import { isPlainObject, isTypedArray } from "../is.js";
 import { chunk } from "../array/chunk.js";
+import { getCompareHandlers } from "./handlers.js";
 function equal(first, second, options) {
 	return equalValue(first, second, getEqualOptions(options));
 }
@@ -41,11 +42,6 @@ function equalMap(first, second, options) {
 	}
 	return true;
 }
-function equalObject(first, second) {
-	const comparison = comparisons.get(first.constructor);
-	if (comparison == null) return Object.is(first, second);
-	return second instanceof first.constructor && comparison(first, second);
-}
 function equalPlainObject(first, second, options) {
 	let firstKeys = [...Object.keys(first), ...Object.getOwnPropertySymbols(first)];
 	let secondKeys = [...Object.keys(second), ...Object.getOwnPropertySymbols(second)];
@@ -104,10 +100,10 @@ function equalValue(first, second, options) {
 		case Array.isArray(first) && Array.isArray(second): return equalArray(first, second, options);
 		case isPlainObject(first) && isPlainObject(second): return equalPlainObject(first, second, options);
 		case isTypedArray(first) && isTypedArray(second): return equalTypedArray(first, second);
-		case typeof first === "object": return equalObject(first, second);
-		default: return Object.is(first, second);
+		default: return equal.handlers.handle(first, second, options);
 	}
 }
+equal.handlers = getCompareHandlers(equal, { callback: Object.is });
 equal.initialize = function(options) {
 	const actual = getEqualOptions(options);
 	const equalizer = (first, second) => equalValue(first, second, actual);
@@ -115,12 +111,10 @@ equal.initialize = function(options) {
 	equalizer.unregister = equal.unregister;
 	return equalizer;
 };
-equal.register = function(constructor, comparison) {
-	if (isConstructor(constructor) && typeof comparison === "function") comparisons.set(constructor, comparison);
-};
-equal.unregister = function(constructor) {
-	if (isConstructor(constructor)) comparisons.delete(constructor);
+equal.register = function(constructor, fn) {
+	equal.handlers.register(constructor, fn);
 };
+equal.unregister = equal.handlers.unregister;
 function filterKey(key, options) {
 	if (typeof key !== "string") return true;
 	if (options.ignoreExpressions.enabled && options.ignoreExpressions.values.some((expression) => expression.test(key))) return false;
@@ -155,5 +149,4 @@ function getEqualOptions(input) {
 }
 var ARRAY_PEEK_PERCENTAGE = 10;
 var ARRAY_THRESHOLD = 100;
-var comparisons = /* @__PURE__ */ new WeakMap();
 export { equal };

package/dist/internal/value/handlers.js

@@ -0,0 +1,47 @@
+import { isConstructor } from "../is.js";
+function getCompareHandlers(owner, options) {
+	const { get, register, unregister } = getHandlers(owner, options);
+	return {
+		register,
+		unregister,
+		handle(first, second, ...parameters) {
+			const handler = get(first, second);
+			if (handler == null) return options.callback(first, second, ...parameters);
+			return typeof handler === "function" ? handler(first, second) : first[handler](second);
+		}
+	};
+}
+function getHandlers(owner, options) {
+	const handlers = /* @__PURE__ */ new WeakMap();
+	return {
+		get(first, second) {
+			if (isConstructable(first) && isConstructable(second) && first.constructor === second.constructor) return handlers.get(first.constructor);
+		},
+		register(constructor, handler) {
+			if (!isConstructor(constructor) || handler === owner) return;
+			let actual = handler ?? options.method;
+			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);
+	return {
+		register,
+		unregister,
+		handle(value, ...parameters) {
+			const handler = get(value, value);
+			if (handler == null) return options.callback(value, ...parameters);
+			return typeof handler === "function" ? handler(value) : value[handler]();
+		}
+	};
+}
+function isConstructable(value) {
+	return typeof value === "object" && value !== null;
+}
+export { getCompareHandlers, getSelfHandlers };

package/dist/string/case.js

@@ -26,12 +26,12 @@ function titleCase(value) {
 	return memoizedTitleCase.run(value);
 }
 function toCase(type, value, capitalizeAny, capitalizeFirst) {
-	memoizers[type] ??= memoize(toCaseCallback.bind({
+	caseMemoizers[type] ??= memoize(toCaseCallback.bind({
 		type,
 		capitalizeAny,
 		capitalizeFirst
 	}));
-	return memoizers[type].run(value);
+	return caseMemoizers[type].run(value);
 }
 function toCaseCallback(value) {
 	if (typeof value !== "string") return "";
@@ -67,7 +67,7 @@ var delimiters = {
 };
 var EXPRESSION_CAMEL_CASE = /(\p{Ll})(\p{Lu})/gu;
 var EXPRESSION_ACRONYM = /(\p{Lu}*)(\p{Lu})(\p{Ll}+)/gu;
-var memoizers = {};
+var caseMemoizers = {};
 var REPLACEMENT_CAMEL_CASE = "$1-$2";
 var memoizedCapitalize;
 var memoizedTitleCase;

package/dist/string/misc.js

@@ -24,8 +24,8 @@ function includes(haystack, needle, ignoreCase) {
 }
 function match(type, haystack, needle, ignoreCase) {
 	if (typeof haystack !== "string" || typeof needle !== "string") return false;
-	memoizers[type] ??= memoize(matchCallback.bind(type));
-	return memoizers[type].run(haystack, needle, ignoreCase);
+	matchMemoizers[type] ??= memoize(matchCallback.bind(type));
+	return matchMemoizers[type].run(haystack, needle, ignoreCase);
 }
 function matchCallback(haystack, needle, ignoreCase) {
 	return (ignoreCase ? haystack.toLocaleLowerCase() : haystack)[this](ignoreCase ? needle.toLocaleLowerCase() : needle);
@@ -52,5 +52,5 @@ function truncate(value, length, suffix) {
 	const truncatedLength = length - actualSuffixLength;
 	return `${value.slice(0, truncatedLength)}${actualSuffix}`;
 }
-var memoizers = {};
+var matchMemoizers = {};
 export { createUuid, endsWith, getUuid, includes, parse, startsWith, trim, truncate };

package/dist/value/clone.js

@@ -1,15 +1,16 @@
-import { isArrayOrPlainObject, isConstructor, isTypedArray } from "../internal/is.js";
+import { isArrayOrPlainObject, isTypedArray } from "../internal/is.js";
+import { getSelfHandlers } from "../internal/value/handlers.js";
 function clone(value) {
 	return cloneValue(value, 0, /* @__PURE__ */ new WeakMap());
 }
-clone.register = function(constructor, cloner) {
-	if (!isConstructor(constructor) || cloner === clone) return;
-	const actual = cloner ?? "clone";
-	if (typeof actual === "function" || typeof constructor.prototype[actual] === "function") cloners.set(constructor, actual);
-};
-clone.unregister = function(constructor) {
-	if (isConstructor(constructor)) cloners.delete(constructor);
+clone.handlers = getSelfHandlers(clone, {
+	callback: tryStructuredClone,
+	method: "clone"
+});
+clone.register = function(constructor, handler) {
+	clone.handlers.register(constructor, handler);
 };
+clone.unregister = clone.handlers.unregister;
 function cloneArrayBuffer(value, depth, references) {
 	if (typeof depth === "number" && depth >= MAX_CLONE_DEPTH) return value;
 	const cloned = new ArrayBuffer(value.byteLength);
@@ -44,12 +45,6 @@ function cloneNode(node, depth, references) {
 	references.set(node, cloned);
 	return cloned;
 }
-function cloneObject(value, depth, references) {
-	const cloner = cloners.get(value.constructor);
-	if (typeof cloner === "function") return cloner(value);
-	if (cloner == null) return tryStructuredClone(value, depth, references);
-	return value[cloner]();
-}
 function clonePlainObject(value, depth, references) {
 	if (depth >= MAX_CLONE_DEPTH) return Array.isArray(value) ? [...value] : { ...value };
 	const cloned = Array.isArray(value) ? [] : {};
@@ -87,13 +82,14 @@ function cloneValue(value, depth, references) {
 		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:
 		case value instanceof Set: return cloneMapOrSet(value, depth, references);
 		case value instanceof Node: return cloneNode(value, depth, references);
 		case isArrayOrPlainObject(value): return clonePlainObject(value, depth, references);
 		case isTypedArray(value): return cloneTypedArray(value, depth, references);
-		default: return cloneObject(value, depth, references);
+		default: return clone.handlers.handle(value, depth, references);
 	}
 }
 function tryStructuredClone(value, depth, references) {
@@ -107,6 +103,5 @@ function tryStructuredClone(value, depth, references) {
 		return value;
 	}
 }
-var cloners = /* @__PURE__ */ new WeakMap();
 var MAX_CLONE_DEPTH = 100;
 export { clone };

package/package.json

@@ -13,7 +13,7 @@
 		"rolldown": "1.0.0-rc.1",
 		"tslib": "^2.8",
 		"typescript": "^5.9",
-		"vite": "8.0.0-beta.9",
+		"vite": "8.0.0-beta.10",
 		"vitest": "^4"
 	},
 	"exports": {
@@ -105,5 +105,5 @@
 	},
 	"type": "module",
 	"types": "./types/index.d.ts",
-	"version": "0.129.0"
+	"version": "0.130.0"
 }

package/src/internal/value/compare.ts

@@ -1,5 +1,13 @@
+import type {Constructor} from '../../models';
 import {max} from '../math/aggregate';
 import {getString, words} from '../string';
+import {getCompareHandlers} from './handlers';
+
+// #region Types
+
+type Comparator<Value = any> = (first: Value, second: Value) => number;
+
+// #endregion
 
 // #region Functions
 
@@ -53,6 +61,33 @@ export function compare(first: unknown, second: unknown): number {
 	return 0;
 }
 
+compare.handlers = getCompareHandlers<number>(compare, {
+	callback: (first, second, compareStrings) => {
+		if (compareStrings) {
+			return getString(first).localeCompare(getString(second));
+		}
+	},
+	method: 'compare',
+});
+
+/**
+ * Register a custom comparison handler for a class
+ * @param constructor Class constructor
+ * @param handler Method name or comparison function _(defaults to `compare`)_
+ */
+compare.register = function <Instance>(
+	constructor: Constructor<Instance>,
+	handler?: string | ((first: Instance, second: Instance) => number),
+): void {
+	compare.handlers.register(constructor, handler);
+};
+
+/**
+ * Unregister a custom comparison handler for a class
+ * @param constructor Class constructor
+ */
+compare.unregister = compare.handlers.unregister;
+
 function compareNumbers(
 	first: bigint | boolean | number,
 	second: bigint | boolean | number,
@@ -89,9 +124,7 @@ function compareValue(
 		return compareNumbers(first.getTime(), second.getTime());
 	}
 
-	if (compareStrings) {
-		return getString(first).localeCompare(getString(second));
-	}
+	return compare.handlers.handle(first, second, compareStrings);
 }
 
 function getComparisonParts(value: unknown): unknown[] {
@@ -106,7 +139,7 @@ function getComparisonParts(value: unknown): unknown[] {
 
 // #region Constants
 
-const comparators: Record<string, (first: never, second: never) => number | undefined> = {
+const comparators: Record<string, Comparator> = {
 	bigint: compareNumbers,
 	boolean: compareNumbers,
 	number: compareNumbers,

package/src/internal/value/equal.ts

@@ -1,11 +1,10 @@
 import type {ArrayOrPlainObject, Constructor, PlainObject, TypedArray} from '../../models';
 import {chunk} from '../array/chunk';
-import {isConstructor, isPlainObject, isTypedArray} from '../is';
+import {isPlainObject, isTypedArray} from '../is';
+import {getCompareHandlers} from './handlers';
 
 // #region Types
 
-type Comparison<Instance> = (first: Instance, second: Instance) => boolean;
-
 /**
  * Options for value equality comparison
  */
@@ -34,14 +33,20 @@ type Equalizer = {
 	(first: unknown, second: unknown): boolean;
 
 	/**
-	 * @inheritdoc equal.register
+	 * Register a equality comparison handler for a specific class
+	 * @param constructor Class constructor
+	 * @param handler Equality comparison handler
 	 */
-	register: typeof equal.register;
+	register: <Instance>(
+		constructor: Constructor<Instance>,
+		handler?: string | ((first: Instance, second: Instance) => boolean),
+	) => void;
 
 	/**
-	 * @inheritdoc equal.unregister
+	 * Unregister a equality comparison handler for a specific class
+	 * @param constructor Class constructor
 	 */
-	unregister: typeof equal.unregister;
+	unregister: (constructor: Constructor) => void;
 };
 
 type Options = {
@@ -169,16 +174,6 @@ function equalMap(
 	return true;
 }
 
-function equalObject(first: object, second: object): boolean {
-	const comparison = comparisons.get(first.constructor as Constructor);
-
-	if (comparison == null) {
-		return Object.is(first, second);
-	}
-
-	return second instanceof first.constructor && comparison(first, second);
-}
-
 function equalPlainObject(
 	first: ArrayOrPlainObject,
 	second: ArrayOrPlainObject,
@@ -317,14 +312,15 @@ function equalValue(first: unknown, second: unknown, options: Options): boolean
 		case isTypedArray(first) && isTypedArray(second):
 			return equalTypedArray(first as TypedArray, second as TypedArray);
 
-		case typeof first === 'object':
-			return equalObject(first, second);
-
 		default:
-			return Object.is(first, second);
+			return equal.handlers.handle(first, second, options);
 	}
 }
 
+equal.handlers = getCompareHandlers<boolean>(equal, {
+	callback: Object.is,
+});
+
 /**
  * Create an equalizer with predefined options
  * @param options Comparison options
@@ -338,32 +334,26 @@ equal.initialize = function (options?: EqualOptions): Equalizer {
 	equalizer.register = equal.register;
 	equalizer.unregister = equal.unregister;
 
-	return equalizer;
+	return equalizer as Equalizer;
 };
 
 /**
- * Register a custom comparison for a specific class
+ * Register a equality comparison function for a specific class
  * @param constructor Class constructor
- * @param comparison Comparison function
+ * @param fn Comparison function
  */
 equal.register = function <Instance>(
 	constructor: Constructor<Instance>,
-	comparison: Comparison<Instance>,
+	fn: (first: Instance, second: Instance) => boolean,
 ): void {
-	if (isConstructor(constructor) && typeof comparison === 'function') {
-		comparisons.set(constructor, comparison as Comparison<unknown>);
-	}
+	equal.handlers.register(constructor, fn);
 };
 
 /**
- * Unregister a custom comparison for a specific class
+ * Unregister a equality comparison handler for a specific class
  * @param constructor Class constructor
  */
-equal.unregister = function <Instance>(constructor: Constructor<Instance>): void {
-	if (isConstructor(constructor)) {
-		comparisons.delete(constructor);
-	}
-};
+equal.unregister = equal.handlers.unregister;
 
 function filterKey(key: string | symbol, options: Options): boolean {
 	if (typeof key !== 'string') {
@@ -437,6 +427,4 @@ const ARRAY_PEEK_PERCENTAGE = 10;
 
 const ARRAY_THRESHOLD = 100;
 
-const comparisons = new WeakMap<Constructor, Comparison<unknown>>();
-
 // #endregion

package/src/internal/value/handlers.ts

@@ -0,0 +1,87 @@
+import type {Constructor, GenericCallback} from '../../models';
+import {isConstructor} from '../is';
+
+type Options = {
+	callback: GenericCallback;
+	method?: string;
+};
+
+export function getCompareHandlers<Value>(owner: GenericCallback, options: Options) {
+	const {get, register, unregister} = getHandlers(owner, options);
+
+	return {
+		register,
+		unregister,
+		handle(first: unknown, second: unknown, ...parameters: unknown[]): Value {
+			const handler = get(first, second);
+
+			if (handler == null) {
+				return options.callback(first, second, ...parameters);
+			}
+
+			return typeof handler === 'function'
+				? handler(first, second)
+				: (first as any)[handler](second);
+		},
+	};
+}
+
+function getHandlers(owner: GenericCallback, options: Options) {
+	const handlers = new WeakMap<Constructor, string | GenericCallback>();
+
+	return {
+		get(first: unknown, second: unknown): string | GenericCallback | undefined {
+			if (
+				isConstructable(first) &&
+				isConstructable(second) &&
+				(first as object).constructor === (second as object).constructor
+			) {
+				return handlers.get((first as object).constructor as Constructor);
+			}
+		},
+		register(constructor: Constructor, handler?: string | GenericCallback) {
+			if (!isConstructor(constructor) || handler === owner) {
+				return;
+			}
+
+			let actual: string | GenericCallback | undefined = handler ?? options.method;
+
+			if (typeof actual !== 'function' && typeof actual !== 'string') {
+				return;
+			}
+
+			if (typeof actual === 'string') {
+				actual = typeof constructor.prototype[actual] === 'function' ? actual : undefined;
+			}
+
+			if (actual != null) {
+				handlers.set(constructor, actual);
+			}
+		},
+		unregister(constructor: Constructor) {
+			handlers.delete(constructor);
+		},
+	};
+}
+
+export function getSelfHandlers(owner: GenericCallback, options: Options) {
+	const {get, register, unregister} = getHandlers(owner, options);
+
+	return {
+		register,
+		unregister,
+		handle(value: unknown, ...parameters: unknown[]) {
+			const handler = get(value, value);
+
+			if (handler == null) {
+				return options.callback(value, ...parameters);
+			}
+
+			return typeof handler === 'function' ? handler(value) : (value as any)[handler]();
+		},
+	};
+}
+
+function isConstructable(value: unknown): boolean {
+	return typeof value === 'object' && value !== null;
+}

package/src/string/case.ts

@@ -102,9 +102,9 @@ function toCase(
 	capitalizeAny: boolean,
 	capitalizeFirst: boolean,
 ): string {
-	memoizers[type] ??= memoize(toCaseCallback.bind({type, capitalizeAny, capitalizeFirst}));
+	caseMemoizers[type] ??= memoize(toCaseCallback.bind({type, capitalizeAny, capitalizeFirst}));
 
-	return memoizers[type].run(value);
+	return caseMemoizers[type].run(value);
 }
 
 function toCaseCallback(this: Options, value: string): string {
@@ -185,7 +185,7 @@ const EXPRESSION_CAMEL_CASE = /(\p{Ll})(\p{Lu})/gu;
 
 const EXPRESSION_ACRONYM = /(\p{Lu}*)(\p{Lu})(\p{Ll}+)/gu;
 
-const memoizers: Partial<Record<string, Memoized<typeof toCaseCallback>>> = {};
+const caseMemoizers: Partial<Record<string, Memoized<typeof toCaseCallback>>> = {};
 
 const REPLACEMENT_CAMEL_CASE = '$1-$2';
 

package/src/string/misc.ts

@@ -68,9 +68,9 @@ function match(type: Match, haystack: string, needle: string, ignoreCase: boolea
 		return false;
 	}
 
-	memoizers[type] ??= memoize(matchCallback.bind(type));
+	matchMemoizers[type] ??= memoize(matchCallback.bind(type));
 
-	return memoizers[type].run(haystack, needle, ignoreCase);
+	return matchMemoizers[type].run(haystack, needle, ignoreCase);
 }
 
 function matchCallback(
@@ -153,6 +153,6 @@ export function truncate(value: string, length: number, suffix?: string): string
 
 // #region Constants
 
-const memoizers: Partial<Record<Match, Memoized<typeof matchCallback>>> = {};
+const matchMemoizers: Partial<Record<Match, Memoized<typeof matchCallback>>> = {};
 
 // #endregion

package/src/value/clone.ts

@@ -1,12 +1,7 @@
-import {isArrayOrPlainObject, isConstructor, isTypedArray} from '../internal/is';
+import {isArrayOrPlainObject, isTypedArray} from '../internal/is';
+import {getSelfHandlers} from '../internal/value/handlers';
 import type {ArrayOrPlainObject, Constructor, PlainObject, TypedArray} from '../models';
 
-// #region Types
-
-type Cloner<Instance> = (original: Instance) => Instance;
-
-// #endregion
-
 // #region Functions
 
 /**
@@ -20,35 +15,28 @@ export function clone(value: unknown): unknown {
 	return cloneValue(value, 0, new WeakMap());
 }
 
+clone.handlers = getSelfHandlers(clone, {
+	callback: tryStructuredClone,
+	method: 'clone',
+});
+
 /**
- * Register a custom cloner for a specific class
+ * Register a clone handler for a specific class
  * @param constructor Class constructor
- * @param cloner Method name or cloning function _(defaults to `clone`)_
+ * @param handler Method name or clone function _(defaults to `clone`)_
  */
 clone.register = function <Instance>(
 	constructor: Constructor<Instance>,
-	cloner?: string | Cloner<Instance>,
+	handler?: string | ((value: Instance) => Instance),
 ): void {
-	if (!isConstructor(constructor) || cloner === clone) {
-		return;
-	}
-
-	const actual = cloner ?? 'clone';
-
-	if (typeof actual === 'function' || typeof constructor.prototype[actual] === 'function') {
-		cloners.set(constructor, actual as string | Cloner<unknown>);
-	}
+	clone.handlers.register(constructor, handler);
 };
 
 /**
- * Unregister a custom cloner for a specific class
+ * Unregister a clone handler for a specific class
  * @param constructor Class constructor
  */
-clone.unregister = function (constructor: Constructor): void {
-	if (isConstructor(constructor)) {
-		cloners.delete(constructor);
-	}
-};
+clone.unregister = clone.handlers.unregister;
 
 function cloneArrayBuffer(
 	value: ArrayBuffer,
@@ -130,20 +118,6 @@ function cloneNode(node: Node, depth: number, references: WeakMap<WeakKey, unkno
 	return cloned;
 }
 
-function cloneObject(value: object, depth: number, references: WeakMap<WeakKey, unknown>): unknown {
-	const cloner = cloners.get(value.constructor as Constructor);
-
-	if (typeof cloner === 'function') {
-		return cloner(value);
-	}
-
-	if (cloner == null) {
-		return tryStructuredClone(value, depth, references);
-	}
-
-	return ((value as unknown as PlainObject)[cloner] as Function)();
-}
-
 function clonePlainObject(
 	value: ArrayOrPlainObject,
 	depth: number,
@@ -234,6 +208,9 @@ function cloneValue(value: unknown, depth: number, references: WeakMap<WeakKey,
 		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);
 
@@ -251,7 +228,7 @@ function cloneValue(value: unknown, depth: number, references: WeakMap<WeakKey,
 			return cloneTypedArray(value, depth, references);
 
 		default:
-			return cloneObject(value, depth, references);
+			return clone.handlers.handle(value, depth, references);
 	}
 }
 
@@ -281,8 +258,6 @@ function tryStructuredClone(
 
 // #region Constants
 
-const cloners = new WeakMap<Constructor, string | Cloner<unknown>>();
-
 const MAX_CLONE_DEPTH = 100;
 
 // #endregion

package/types/internal/value/compare.d.ts

@@ -1,3 +1,4 @@
+import type { Constructor } from '../../models';
 /**
  * Compare two values _(for sorting purposes)_
  * @param first First value
@@ -5,3 +6,12 @@
  * @returns `0` if equal; `-1` first comes before second; `1` first comes after second
  */
 export declare function compare(first: unknown, second: unknown): number;
+export declare namespace compare {
+    var handlers: {
+        register: (constructor: Constructor, handler?: string | import("../..").GenericCallback) => void;
+        unregister: (constructor: Constructor) => void;
+        handle(first: unknown, second: unknown, ...parameters: unknown[]): number;
+    };
+    var register: <Instance>(constructor: Constructor<Instance>, handler?: string | ((first: Instance, second: Instance) => number)) => void;
+    var unregister: (constructor: Constructor) => void;
+}

package/types/internal/value/equal.d.ts

@@ -1,5 +1,4 @@
 import type { Constructor } from '../../models';
-type Comparison<Instance> = (first: Instance, second: Instance) => boolean;
 /**
  * Options for value equality comparison
  */
@@ -26,13 +25,16 @@ type Equalizer = {
      */
     (first: unknown, second: unknown): boolean;
     /**
-     * @inheritdoc equal.register
+     * Register a equality comparison handler for a specific class
+     * @param constructor Class constructor
+     * @param handler Equality comparison handler
      */
-    register: typeof equal.register;
+    register: <Instance>(constructor: Constructor<Instance>, handler?: string | ((first: Instance, second: Instance) => boolean)) => void;
     /**
-     * @inheritdoc equal.unregister
+     * Unregister a equality comparison handler for a specific class
+     * @param constructor Class constructor
      */
-    unregister: typeof equal.unregister;
+    unregister: (constructor: Constructor) => void;
 };
 /**
  * Are two strings equal?
@@ -51,8 +53,13 @@ export declare function equal(first: string, second: string, ignoreCase?: boolea
  */
 export declare function equal(first: unknown, second: unknown, options?: EqualOptions): boolean;
 export declare namespace equal {
+    var handlers: {
+        register: (constructor: Constructor, handler?: string | import("../..").GenericCallback) => void;
+        unregister: (constructor: Constructor) => void;
+        handle(first: unknown, second: unknown, ...parameters: unknown[]): boolean;
+    };
     var initialize: (options?: EqualOptions) => Equalizer;
-    var register: <Instance>(constructor: Constructor<Instance>, comparison: Comparison<Instance>) => void;
-    var unregister: <Instance>(constructor: Constructor<Instance>) => void;
+    var register: <Instance>(constructor: Constructor<Instance>, fn: (first: Instance, second: Instance) => boolean) => void;
+    var unregister: (constructor: Constructor) => void;
 }
 export {};

package/types/internal/value/handlers.d.ts

@@ -0,0 +1,16 @@
+import type { Constructor, GenericCallback } from '../../models';
+type Options = {
+    callback: GenericCallback;
+    method?: string;
+};
+export declare function getCompareHandlers<Value>(owner: GenericCallback, options: Options): {
+    register: (constructor: Constructor, handler?: string | GenericCallback) => void;
+    unregister: (constructor: Constructor) => void;
+    handle(first: unknown, second: unknown, ...parameters: unknown[]): Value;
+};
+export declare function getSelfHandlers(owner: GenericCallback, options: Options): {
+    register: (constructor: Constructor, handler?: string | GenericCallback) => void;
+    unregister: (constructor: Constructor) => void;
+    handle(value: unknown, ...parameters: unknown[]): any;
+};
+export {};

package/types/value/clone.d.ts

@@ -1,5 +1,4 @@
 import type { Constructor } from '../models';
-type Cloner<Instance> = (original: Instance) => Instance;
 /**
  * Clone any kind of value _(deeply, if needed)_
  * @param value Value to clone
@@ -7,7 +6,11 @@ type Cloner<Instance> = (original: Instance) => Instance;
  */
 export declare function clone<Value>(value: Value): Value;
 export declare namespace clone {
-    var register: <Instance>(constructor: Constructor<Instance>, cloner?: string | Cloner<Instance>) => void;
+    var handlers: {
+        register: (constructor: Constructor, handler?: string | import("..").GenericCallback) => void;
+        unregister: (constructor: Constructor) => void;
+        handle(value: unknown, ...parameters: unknown[]): any;
+    };
+    var register: <Instance>(constructor: Constructor<Instance>, handler?: string | ((value: Instance) => Instance)) => void;
     var unregister: (constructor: Constructor) => void;
 }
-export {};