@oscarpalmer/atoms 0.202.0 → 0.204.0

package/dist/internal/subscription.mjs

@@ -1,13 +1,46 @@
 import { isKey, isPlainObject } from "./is.mjs";
-import { createAborter } from "./abort.mjs";
+import { createAborter } from "./aborter.mjs";
 //#region src/internal/subscription.ts
-function addSubscription(subscriptions, subscription, state) {
-	const { items, values } = subscriptions;
+const SUBSCRIPTION_NAME = "subscription";
+const SUBSCRIPTION_PROPERTY = "$subscription";
+const SUBSCRIPTION_STORE = "subscriptions";
+function Subscription(state, property, parameters) {
+	this[SUBSCRIPTION_SYMBOL] = state;
+	this[property.key] = property.value;
+	state.aborter = createAborter(parameters.signal, () => this.unsubscribe(subscriptions, this, state));
+	addSubscription(this);
+}
+Subscription.prototype[SUBSCRIPTION_PROPERTY] = SUBSCRIPTION_NAME;
+Subscription.prototype.unsubscribe = removeSubscription;
+Object.defineProperty(Subscription.prototype, "active", {
+	enumerable: true,
+	get: getSubscriptionActive
+});
+function Subscriptions(parameters) {
+	const { keys, property } = createSubscriptionsParameters(parameters);
+	this[SUBSCRIPTION_SYMBOL] = createSubscriptionsState(property, keys);
+}
+Subscriptions.prototype[SUBSCRIPTION_PROPERTY] = SUBSCRIPTION_STORE;
+Subscriptions.prototype.clear = clearSubscriptions;
+Subscriptions.prototype.create = createSubscription;
+Object.defineProperties(Subscriptions.prototype, {
+	items: {
+		enumerable: true,
+		get: getSubscriptionsItems
+	},
+	values: {
+		enumerable: true,
+		get: getSubscriptionsValues
+	}
+});
+function addSubscription(instance) {
+	const state = instance[SUBSCRIPTION_SYMBOL];
 	const { key, value } = state.parameters;
+	const { items, values } = state.subscriptions;
 	if (!isKey(key)) {
-		items.any.add(subscription);
-		values.from.any.set(value, subscription);
-		values.to.any.set(subscription, value);
+		items.any.add(instance);
+		values.from.any.set(value, instance);
+		values.to.any.set(instance, value);
 		return;
 	}
 	/* istanbul ignore if */
@@ -19,29 +52,32 @@ function addSubscription(subscriptions, subscription, state) {
 		keyedItems = /* @__PURE__ */ new Set();
 		items.keyed.set(key, keyedItems);
 	}
-	keyedItems.add(subscription);
+	keyedItems.add(instance);
 	let keyedFrom = values.from.keyed.get(key);
 	if (keyedFrom == null) {
 		keyedFrom = /* @__PURE__ */ new Map();
 		values.from.keyed.set(key, keyedFrom);
 	}
-	keyedFrom.set(value, subscription);
+	keyedFrom.set(value, instance);
 	let keyedTo = values.to.keyed.get(key);
 	if (keyedTo == null) {
 		keyedTo = /* @__PURE__ */ new Map();
 		values.to.keyed.set(key, keyedTo);
 	}
-	keyedTo.set(subscription, value);
+	keyedTo.set(instance, value);
 }
-function clearSubscriptions(store) {
-	for (const susbcription of store.values.to.any.keys()) susbcription.unsubscribe();
-	if (store.values.to.keyed != null) for (const values of store.values.to.keyed.values()) for (const susbcription of values.keys()) susbcription.unsubscribe();
+function clearSubscriptions() {
+	const state = this[SUBSCRIPTION_SYMBOL];
+	for (const susbcription of state.values.to.any.keys()) susbcription.unsubscribe();
+	if (state.values.to.keyed != null && state.values.to.keyed.size > 0) for (const values of state.values.to.keyed.values()) for (const susbcription of values.keys()) susbcription.unsubscribe();
 }
-function createSubscription(subscriptions, property, params) {
+function createSubscription(params) {
 	const parameters = createSubscriptionParameters(params);
 	if (parameters.signal?.aborted ?? false) throw new Error(parameters.signal?.reason);
+	const subscriptions = this[SUBSCRIPTION_SYMBOL];
 	const state = {
 		parameters,
+		subscriptions,
 		active: true
 	};
 	const existing = getExistingSubscription(subscriptions, state);
@@ -50,24 +86,23 @@ function createSubscription(subscriptions, property, params) {
 		if (subscriptions.keys === false) throw new Error(SUBSCRIPTION_DISALLOWED_KEY);
 		else if (subscriptions.keys !== true && !subscriptions.keys.has(parameters.key)) throw new Error(SUBSCRIPTION_INVALID_KEY);
 	}
-	state.aborter = createAborter(parameters.signal, () => unsubscribe(subscriptions, instance, state));
-	const instance = { unsubscribe: () => unsubscribe(subscriptions, instance, state) };
-	Object.defineProperties(instance, {
-		[SUBSCRIPTION_PROPERTY]: { value: SUBSCRIPTION_NAME },
-		[property.key]: { value: property.value },
-		active: {
-			enumerable: true,
-			get: () => (parameters.isActive?.() ?? true) && state.active
-		}
-	});
-	addSubscription(subscriptions, instance, state);
-	return [Object.freeze(instance), false];
+	return [new Subscription(state, subscriptions.property, parameters), false];
 }
 function getExistingSubscription(subscriptions, state) {
 	const { values } = subscriptions;
 	const { parameters } = state;
 	return isKey(parameters.key) ? values.from.keyed?.get(parameters.key)?.get(parameters.value) : values.from.any.get(parameters.value);
 }
+function getSubscriptionActive() {
+	const state = this[SUBSCRIPTION_SYMBOL];
+	return (state.parameters?.isActive?.() ?? true) && state.active;
+}
+function getSubscriptionsItems() {
+	return this[SUBSCRIPTION_SYMBOL].items;
+}
+function getSubscriptionsValues() {
+	return this[SUBSCRIPTION_SYMBOL].values;
+}
 function createSubscriptionParameters(input) {
 	const values = isPlainObject(input) ? input : {};
 	if (values.value == null) throw new Error(SUBSCRIPTION_INVALID_VALUE);
@@ -95,9 +130,10 @@ function createSubscriptionsProperty(input) {
 		value: values.value == null ? SUBSCRIPTION_NAME : values.value
 	};
 }
-function createSubscriptionsState(keys) {
+function createSubscriptionsState(property, keys) {
 	return {
 		keys,
+		property,
 		items: {
 			any: /* @__PURE__ */ new Set(),
 			keyed: keys === false ? void 0 : /* @__PURE__ */ new Map()
@@ -124,7 +160,7 @@ function isSubscription(value) {
 	return isSubscriptionInstance(value, SUBSCRIPTION_NAME);
 }
 function isSubscriptionInstance(value, name) {
-	return isPlainObject(value) && SUBSCRIPTION_PROPERTY in value && value[SUBSCRIPTION_PROPERTY] === name;
+	return typeof value === "object" && value !== null && SUBSCRIPTION_PROPERTY in value && value[SUBSCRIPTION_PROPERTY] === name;
 }
 /**
 * Is the value a subscriptions store?
@@ -145,16 +181,17 @@ function removeFromStore(items, values, subscription, value, key) {
 		values.to.keyed?.get(key)?.delete(subscription);
 	}
 }
-function removeSubscription(subscriptionsState, subscription, state) {
+function removeSubscription() {
+	const state = this[SUBSCRIPTION_SYMBOL];
 	if (!state.active) return;
 	state.aborter = void 0;
 	state.active = false;
-	state.parameters.isActive = void 0;
-	state.parameters.signal = void 0;
-	const { items, values } = subscriptionsState;
+	const { items, values } = state.subscriptions;
 	const { key, value } = state.parameters;
+	state.parameters = void 0;
+	state.subscriptions = void 0;
 	if (!isKey(key)) {
-		removeFromStore(items.any, values, subscription, value);
+		removeFromStore(items.any, values, this, value);
 		return;
 	}
 	const keyed = items.keyed?.get(key);
@@ -162,7 +199,7 @@ function removeSubscription(subscriptionsState, subscription, state) {
 	if (items.keyed == null || keyed == null)
  // istanbul ignore next
 	return;
-	removeFromStore(keyed, values, subscription, value, key);
+	removeFromStore(keyed, values, this, value, key);
 	if (keyed.size === 0) items.keyed.delete(key);
 }
 /**
@@ -172,34 +209,11 @@ function removeSubscription(subscriptionsState, subscription, state) {
 * @returns Subscription store
 */
 function subscriptions(parameters) {
-	const { keys, property } = createSubscriptionsParameters(parameters);
-	const state = createSubscriptionsState(keys);
-	const instance = {
-		clear: () => clearSubscriptions(state),
-		create: (parameters) => createSubscription(state, property, parameters)
-	};
-	Object.defineProperties(instance, {
-		[SUBSCRIPTION_PROPERTY]: { value: SUBSCRIPTION_STORE },
-		items: {
-			enumerable: true,
-			value: state.items
-		},
-		values: {
-			enumerable: true,
-			value: state.values
-		}
-	});
-	return Object.freeze(instance);
-}
-function unsubscribe(subscriptionsState, subscription, state) {
-	state.aborter?.cancel();
-	removeSubscription(subscriptionsState, subscription, state);
+	return new Subscriptions(parameters);
 }
 const SUBSCRIPTION_DISALLOWED_KEY = "Disallowed key for subscription";
 const SUBSCRIPTION_INVALID_KEY = "Invalid key for subscription";
 const SUBSCRIPTION_INVALID_VALUE = "A subscription requires a non-null value to identify it";
-const SUBSCRIPTION_NAME = "subscription";
-const SUBSCRIPTION_PROPERTY = "$subscriptions";
-const SUBSCRIPTION_STORE = "subscriptions";
+const SUBSCRIPTION_SYMBOL = Symbol(SUBSCRIPTION_PROPERTY);
 //#endregion
 export { SUBSCRIPTION_NAME, isSubscription, isSubscriptions, subscriptions };

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

@@ -8,13 +8,22 @@ type Comparator<Value = any> = (first: Value, second: Value) => number;
  * @param second Second value
  * @returns `0` if equal; `-1` first comes before second; `1` first comes after second
  */
-declare function compare(first: unknown, second: unknown): number;
-declare namespace compare {
+export declare function compare(first: unknown, second: unknown): number;
+export declare namespace compare {
   var deregister: typeof deregisterComparator;
-  var handlers: {
-    deregister(constructor: Constructor): void;
+  var handler: {
+    base: {
+      handlers: WeakMap<WeakKey, string | GenericCallback>;
+      options: {
+        callback: GenericCallback;
+        method?: string;
+      };
+      owner: GenericCallback;
+      deregister: (constructor: Constructor) => void;
+      get: (first: unknown, second: unknown) => string | GenericCallback | undefined;
+      register: (constructor: Constructor, handler?: string | GenericCallback) => void;
+    };
     handle(first: unknown, second: unknown, ...parameters: unknown[]): number;
-    register(constructor: Constructor, handler?: string | GenericCallback): void;
   };
   var register: typeof registerComparator;
 }
@@ -25,7 +34,7 @@ declare namespace compare {
  *
  * @param constructor Class constructor
  */
-declare function deregisterComparator<Instance>(constructor: Constructor<Instance>): void;
+export declare function deregisterComparator<Instance>(constructor: Constructor<Instance>): void;
 /**
  * Register a custom comparison handler for a class
  *
@@ -34,6 +43,5 @@ declare function deregisterComparator<Instance>(constructor: Constructor<Instanc
  * @param constructor Class constructor
  * @param handler Method name or comparison function _(defaults to `compare`)_
  */
-declare function registerComparator<Instance>(constructor: Constructor<Instance>, handler?: string | Comparator<Instance>): void;
-//#endregion
-export { compare, deregisterComparator, registerComparator };
+export declare function registerComparator<Instance>(constructor: Constructor<Instance>, handler?: string | Comparator<Instance>): void;
+//#endregion

package/dist/internal/value/compare.mjs

@@ -1,6 +1,6 @@
 import { max } from "../math/aggregate.mjs";
 import { getString, words } from "../string/misc.mjs";
-import { createCompareHandlers } from "./handlers.mjs";
+import { createCompareHandler } from "./handlers.mjs";
 //#region src/internal/value/compare.ts
 const COMPARE_NAME = "compare";
 /**
@@ -45,7 +45,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());
-	return compare.handlers.handle(first, second, compareStrings);
+	return compare.handler.handle(first, second, compareStrings);
 }
 /**
 * Deregister a custom comparison handler for a class
@@ -55,7 +55,7 @@ function compareValue(first, second, compareStrings) {
 * @param constructor Class constructor
 */
 function deregisterComparator(constructor) {
-	compare.handlers.deregister(constructor);
+	compare.handler.base.deregister(constructor);
 }
 function getComparisonParts(value) {
 	if (Array.isArray(value)) return value;
@@ -70,7 +70,7 @@ function getComparisonParts(value) {
 * @param handler Method name or comparison function _(defaults to `compare`)_
 */
 function registerComparator(constructor, handler) {
-	compare.handlers.register(constructor, handler);
+	compare.handler.base.register(constructor, handler);
 }
 const comparators = {
 	bigint: compareNumbers,
@@ -78,17 +78,12 @@ const comparators = {
 	number: compareNumbers,
 	symbol: compareSymbols
 };
-const compareHandlers = createCompareHandlers(compare, {
+const compareHandler = createCompareHandler(compare, {
 	callback: (first, second, compareStrings) => compareStrings ? getString(first).localeCompare(getString(second)) : void 0,
 	method: COMPARE_NAME
 });
 compare.deregister = deregisterComparator;
-compare.handlers = compareHandlers;
+compare.handler = compareHandler;
 compare.register = registerComparator;
-Object.defineProperties(compare, {
-	deregister: { value: deregisterComparator },
-	handlers: { value: compareHandlers },
-	register: { value: registerComparator }
-});
 //#endregion
 export { compare, deregisterComparator, registerComparator };

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

@@ -3,7 +3,7 @@ import { Constructor, GenericCallback } from "../../models.mjs";
 /**
  * Options for value equality comparison
  */
-type EqualOptions = {
+export type EqualOptions = {
   /**
    * When `true`, strings are compared case-insensitively
    */
@@ -31,7 +31,7 @@ type Equalizer = {
    * @param ignoreCase If `true`, comparison will be case-insensitive
    * @returns `true` if the strings are equal, otherwise `false`
    */
-  (first: string, second: string, ignoreCase?: boolean): boolean;
+  compare(first: string, second: string, ignoreCase?: boolean): boolean;
   /**
    * Are two values equal?
    *
@@ -39,7 +39,7 @@ type Equalizer = {
    * @param second Second value
    * @returns `true` if the values are equal, otherwise `false`
    */
-  (first: unknown, second: unknown): boolean;
+  compare(first: unknown, second: unknown): boolean;
   /**
    * Deregister a equality comparison handler for a specific class
    *
@@ -54,6 +54,17 @@ type Equalizer = {
    */
   register: <Instance>(constructor: Constructor<Instance>, handler: (first: Instance, second: Instance) => boolean) => void;
 };
+type Options = {
+  ignoreCase: boolean;
+  ignoreExpressions: OptionsKeys<RegExp[]>;
+  ignoreKeys: OptionsKeys<Set<string>>;
+  relaxedNullish: boolean;
+};
+type OptionsKeys<Values> = {
+  enabled: boolean;
+  values: Values;
+};
+declare function Equalizer(this: any, options: Options): void;
 /**
  * Deregister a equality comparison handler for a specific class
  *
@@ -61,7 +72,7 @@ type Equalizer = {
  *
  * @param constructor Class constructor
  */
-declare function deregisterEqualizer<Instance>(constructor: Constructor<Instance>): void;
+export declare function deregisterEqualizer<Instance>(constructor: Constructor<Instance>): void;
 /**
  * Are two strings equal?
  *
@@ -70,7 +81,7 @@ declare function deregisterEqualizer<Instance>(constructor: Constructor<Instance
  * @param ignoreCase If `true`, comparison will be case-insensitive
  * @returns `true` if the strings are equal, otherwise `false`
  */
-declare function equal(first: string, second: string, ignoreCase?: boolean): boolean;
+export declare function equal(first: string, second: string, ignoreCase?: boolean): boolean;
 /**
  * Are two values equal?
  *
@@ -79,14 +90,23 @@ declare function equal(first: string, second: string, ignoreCase?: boolean): boo
  * @param options Comparison options
  * @returns `true` if the values are equal, otherwise `false`
  */
-declare function equal(first: unknown, second: unknown, options?: EqualOptions): boolean;
-declare namespace equal {
-  var handlers: {
-    deregister(constructor: Constructor): void;
+export declare function equal(first: unknown, second: unknown, options?: EqualOptions): boolean;
+export declare namespace equal {
+  var deregister: typeof deregisterEqualizer;
+  var handler: {
+    base: {
+      handlers: WeakMap<WeakKey, string | GenericCallback>;
+      options: {
+        callback: GenericCallback;
+        method?: string;
+      };
+      owner: GenericCallback;
+      deregister: (constructor: Constructor) => void;
+      get: (first: unknown, second: unknown) => string | GenericCallback | undefined;
+      register: (constructor: Constructor, handler?: string | GenericCallback) => void;
+    };
     handle(first: unknown, second: unknown, ...parameters: unknown[]): boolean;
-    register(constructor: Constructor, handler?: string | GenericCallback): void;
   };
-  var deregister: typeof deregisterEqualizer;
   var initialize: typeof initializeEqualizer;
   var register: typeof registerEqualizer;
 }
@@ -98,7 +118,7 @@ declare namespace equal {
  * @param options Comparison options
  * @returns Equalizer function
  */
-declare function initializeEqualizer(options?: EqualOptions): Equalizer;
+export declare function initializeEqualizer(options?: EqualOptions): Equalizer;
 /**
  * Register a equality comparison function for a specific class
  *
@@ -107,6 +127,5 @@ declare function initializeEqualizer(options?: EqualOptions): Equalizer;
  * @param constructor Class constructor
  * @param handler Comparison function
  */
-declare function registerEqualizer<Instance>(constructor: Constructor<Instance>, handler: (first: Instance, second: Instance) => boolean): void;
-//#endregion
-export { EqualOptions, deregisterEqualizer, equal, initializeEqualizer, registerEqualizer };
+export declare function registerEqualizer<Instance>(constructor: Constructor<Instance>, handler: (first: Instance, second: Instance) => boolean): void;
+//#endregion

package/dist/internal/value/equal.mjs

@@ -1,6 +1,15 @@
 import { isNonPlainObject, isPlainObject, isPrimitive, isTypedArray } from "../is.mjs";
-import { createCompareHandlers } from "./handlers.mjs";
+import { createCompareHandler } from "./handlers.mjs";
 //#region src/internal/value/equal.ts
+function Equalizer(options) {
+	this[EQUAL_SYMBOL] = options;
+}
+Equalizer.prototype.compare = compare;
+Equalizer.prototype.deregister = deregisterEqualizer;
+Equalizer.prototype.register = registerEqualizer;
+function compare(first, second) {
+	return equalValue(first, second, this[EQUAL_SYMBOL]);
+}
 function createEqualOptions(input) {
 	const options = {
 		ignoreCase: false,
@@ -35,7 +44,7 @@ function createEqualOptions(input) {
 * @param constructor Class constructor
 */
 function deregisterEqualizer(constructor) {
-	equal.handlers.deregister(constructor);
+	equalHandler.base.deregister(constructor);
 }
 function filterKey(key, options) {
 	if (typeof key !== "string") return true;
@@ -46,10 +55,6 @@ function filterKey(key, options) {
 function equal(first, second, options) {
 	return equalValue(first, second, createEqualOptions(options));
 }
-equal.handlers = createCompareHandlers(equal, { callback: Object.is });
-equal.deregister = deregisterEqualizer;
-equal.initialize = initializeEqualizer;
-equal.register = registerEqualizer;
 function equalArray(first, second, options) {
 	const { length } = first;
 	if (length !== second.length) return false;
@@ -138,7 +143,7 @@ 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);
-		default: return equal.handlers.handle(first, second, options);
+		default: return equalHandler.handle(first, second, options);
 	}
 }
 /**
@@ -150,11 +155,7 @@ function equalValue(first, second, options) {
 * @returns Equalizer function
 */
 function initializeEqualizer(options) {
-	const actual = createEqualOptions(options);
-	const equalizer = (first, second) => equalValue(first, second, actual);
-	equalizer.deregister = deregisterEqualizer;
-	equalizer.register = registerEqualizer;
-	return equalizer;
+	return new Equalizer(createEqualOptions(options));
 }
 /**
 * Register a equality comparison function for a specific class
@@ -165,12 +166,18 @@ function initializeEqualizer(options) {
 * @param handler Comparison function
 */
 function registerEqualizer(constructor, handler) {
-	equal.handlers.register(constructor, handler);
+	equalHandler.base.register(constructor, handler);
 }
 const EQUAL_ARRAY_PEEK_PERCENTAGE = 10;
 const EQUAL_ARRAY_THRESHOLD = 100;
 const EQUAL_ERROR_PROPERTIES = ["name", "message"];
 const EQUAL_EXPRESSION_PROPERTIES = ["source", "flags"];
 const EQUAL_MINIMUM_LENGTH_FOR_SET = 16;
+const EQUAL_SYMBOL = Symbol("equal");
+const equalHandler = createCompareHandler(equal, { callback: Object.is });
+equal.deregister = deregisterEqualizer;
+equal.handler = equalHandler;
+equal.initialize = initializeEqualizer;
+equal.register = registerEqualizer;
 //#endregion
 export { deregisterEqualizer, equal, initializeEqualizer, registerEqualizer };

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

@@ -17,7 +17,7 @@ import { NestedKeys, NestedValue, PlainObject } from "../../models.mjs";
  * getValue(data, 'foo.nope');    // => undefined
  * ```
  */
-declare function getValue<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path): NestedValue<Data, Path>;
+export declare function getValue<Data extends PlainObject, Path extends NestedKeys<Data>>(data: Data, path: Path): NestedValue<Data, Path>;
 /**
  * Get the value from an object using an unknown path
  *
@@ -36,6 +36,5 @@ declare function getValue<Data extends PlainObject, Path extends NestedKeys<Data
  * getValue(data, 'foo.nope');          // => undefined
  * ```
  */
-declare function getValue<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): unknown;
-//#endregion
-export { getValue };
+export declare function getValue<Data extends PlainObject>(data: Data, path: string, ignoreCase?: boolean): unknown;
+//#endregion

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

@@ -1,18 +1,28 @@
 import { Constructor, GenericCallback } from "../../models.mjs";
 //#region src/internal/value/handlers.d.ts
-type Options = {
+type BaseHandler = {
+  handlers: WeakMap<WeakKey, string | GenericCallback>;
+  options: BaseHandlerOptions;
+  owner: GenericCallback;
+  deregister: (constructor: Constructor) => void;
+  get: (first: unknown, second: unknown) => string | GenericCallback | undefined;
+  register: (constructor: Constructor, handler?: string | GenericCallback) => void;
+};
+type BaseHandlerOptions = {
   callback: GenericCallback;
   method?: string;
 };
-declare function createCompareHandlers<Value>(owner: GenericCallback, options: Options): {
-  deregister(constructor: Constructor): void;
+type CompareHandler<Value> = {
+  base: BaseHandler;
   handle(first: unknown, second: unknown, ...parameters: unknown[]): Value;
-  register(constructor: Constructor, handler?: string | GenericCallback): void;
 };
-declare function createSelfHandlers(owner: GenericCallback, options: Options): {
-  deregister(constructor: Constructor): void;
+type ValueHandler = {
+  base: BaseHandler;
   handle(value: unknown, ...parameters: unknown[]): unknown;
-  register(constructor: Constructor, handler?: string | GenericCallback): void;
 };
-//#endregion
-export { createCompareHandlers, createSelfHandlers };
+declare function BaseHandler(this: any, owner: GenericCallback, options: BaseHandlerOptions): void;
+declare function CompareHandler(this: any, base: BaseHandler): void;
+declare function ValueHandler(this: any, value: BaseHandler): void;
+export declare function createCompareHandler<Value>(owner: GenericCallback, options: BaseHandlerOptions): CompareHandler<Value>;
+export declare function createValueHandler(owner: GenericCallback, options: BaseHandlerOptions): ValueHandler;
+//#endregion

package/dist/internal/value/handlers.mjs

@@ -1,57 +1,55 @@
 import { isNonConstructor } from "../is.mjs";
 //#region src/internal/value/handlers.ts
-function createCompareHandlers(owner, options) {
-	const handlers = createHandlers(owner, options);
-	return {
-		deregister(constructor) {
-			handlers.deregister(constructor);
-		},
-		handle(first, second, ...parameters) {
-			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 createHandlers(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);
-		},
-		register(constructor, handler) {
-			if (isNonConstructor(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);
-		}
-	};
-}
-function createSelfHandlers(owner, options) {
-	const handlers = createHandlers(owner, options);
-	return {
-		deregister(constructor) {
-			handlers.deregister(constructor);
-		},
-		handle(value, ...parameters) {
-			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);
-		}
-	};
+function BaseHandler(owner, options) {
+	this.handlers = /* @__PURE__ */ new WeakMap();
+	this.owner = owner;
+	this.options = options;
+}
+BaseHandler.prototype.deregister = deregisterHandler;
+BaseHandler.prototype.get = getHandler;
+BaseHandler.prototype.register = registerHandler;
+function CompareHandler(base) {
+	this.base = base;
+}
+CompareHandler.prototype.handle = handleComparison;
+function ValueHandler(value) {
+	this.base = value;
+}
+ValueHandler.prototype.handle = handleValue;
+function createBaseHandler(owner, options) {
+	return new BaseHandler(owner, options);
+}
+function createCompareHandler(owner, options) {
+	return new CompareHandler(createBaseHandler(owner, options));
+}
+function createValueHandler(owner, options) {
+	return new ValueHandler(createBaseHandler(owner, options));
+}
+function deregisterHandler(value) {
+	this.handlers.delete(value);
+}
+function getHandler(first, second) {
+	if (isConstructable(first) && isConstructable(second) && first.constructor === second.constructor) return this.handlers.get(first.constructor);
+}
+function handleComparison(first, second, ...parameters) {
+	const handler = this.base.get(first, second);
+	if (handler == null) return this.base.options.callback(first, second, ...parameters);
+	return typeof handler === "function" ? handler(first, second) : first[handler](second);
 }
 function isConstructable(value) {
 	return typeof value === "object" && value !== null;
 }
+function registerHandler(constructor, handler) {
+	if (isNonConstructor(constructor) || handler === this.owner) return;
+	let actual = handler ?? this.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) this.handlers.set(constructor, actual);
+}
+function handleValue(value, ...parameters) {
+	const handler = this.base.get(value, value);
+	if (handler == null) return this.base.options.callback(value, ...parameters);
+	return typeof handler === "function" ? handler(value) : value[handler]();
+}
 //#endregion
-export { createCompareHandlers, createSelfHandlers };
+export { createCompareHandler, createValueHandler };