@oscarpalmer/atoms 0.201.0 → 0.203.0

package/dist/internal/string/case.d.mts

@@ -5,55 +5,54 @@
  * @param value String to convert
  * @returns Camel-cased string
  */
-declare function camelCase(value: string): string;
+export declare function camelCase(value: string): string;
 /**
  * Capitalize the first letter of a string _(and lowercase the rest)_
  *
  * @param value String to capitalize
  * @returns Capitalized string
  */
-declare function capitalize(value: string): string;
+export declare function capitalize(value: string): string;
 /**
  * Convert a string to kebab case _(this-is-kebab-case)_
  *
  * @param value String to convert
  * @returns Kebab-cased string
  */
-declare function kebabCase(value: string): string;
+export declare function kebabCase(value: string): string;
 /**
  * Convert a string to lower case
  *
  * @param value String to convert
  * @returns Lower-cased string
  */
-declare function lowerCase(value: string): string;
+export declare function lowerCase(value: string): string;
 /**
  * Convert a string to pascal case _(ThisIsPascalCase)_
  *
  * @param value String to convert
  * @returns Pascal-cased string
  */
-declare function pascalCase(value: string): string;
+export declare function pascalCase(value: string): string;
 /**
  * Convert a string to snake case _(this_is_snake_case)_
  *
  * @param value String to convert
  * @returns Snake-cased string
  */
-declare function snakeCase(value: string): string;
+export declare function snakeCase(value: string): string;
 /**
  * Convert a string to title case _(Capitalizing Every Word)_
  *
  * @param value String to convert
  * @returns Title-cased string
  */
-declare function titleCase(value: string): string;
+export declare function titleCase(value: string): string;
 /**
  * Convert a string to upper case
  *
  * @param value String to convert
  * @returns Upper-cased string
  */
-declare function upperCase(value: string): string;
-//#endregion
-export { camelCase, capitalize, kebabCase, lowerCase, pascalCase, snakeCase, titleCase, upperCase };
+export declare function upperCase(value: string): string;
+//#endregion

package/dist/internal/string/misc.d.mts

@@ -16,9 +16,9 @@
  * getString(() => 123)  // => '123'
  * ```
  */
-declare function getString(value: unknown): string;
-declare function ignoreKey(key: string): boolean;
-declare function interpolate(strings: TemplateStringsArray, values: unknown[]): string;
+export declare function getString(value: unknown): string;
+export declare function ignoreKey(key: string): boolean;
+export declare function interpolate(strings: TemplateStringsArray, values: unknown[]): string;
 /**
  * Join an array of values into a string _(while ignoring empty values)_
  *
@@ -28,15 +28,14 @@ declare function interpolate(strings: TemplateStringsArray, values: unknown[]):
  * @param delimiter Delimiter to use between values
  * @returns Joined string
  */
-declare function join(array: unknown[], delimiter?: string): string;
-declare function tryDecode(value: string): string;
-declare function tryEncode(value: boolean | number | string): unknown;
+export declare function join(array: unknown[], delimiter?: string): string;
+export declare function tryDecode(value: string): string;
+export declare function tryEncode(value: boolean | number | string): unknown;
 /**
  * Split a string into words _(and other readable parts)_
  *
  * @param value Original string
  * @returns Array of words found in the string
  */
-declare function words(value: string): string[];
-//#endregion
-export { getString, ignoreKey, interpolate, join, tryDecode, tryEncode, words };
+export declare function words(value: string): string[];
+//#endregion

package/dist/internal/subscription.d.mts

@@ -1,6 +1,7 @@
 import { Key } from "../models.mjs";
 //#region src/internal/subscription.d.ts
-type Subscription = {
+export declare const SUBSCRIPTION_NAME = "subscription";
+export type Subscription = {
   /**
    * Is the subscription active?
    */
@@ -13,7 +14,7 @@ type Subscription = {
 /**
  * Parameters for creating a subscription
  */
-type SubscriptionParameters = {
+export type SubscriptionParameters = {
   /**
    * Is the owner of the subscription alive? _(defaults to `true`)_
    */
@@ -34,7 +35,7 @@ type SubscriptionParameters = {
 /**
  * Property information for subscription identification
  */
-type SubscriptionProperty = {
+export type SubscriptionProperty = {
   /**
    * Name of the property used to identify a subscription
    */
@@ -44,7 +45,7 @@ type SubscriptionProperty = {
    */
   value: unknown;
 };
-type Subscriptions = {
+export type Subscriptions<Value = unknown> = {
   /**
    * Items of the subscriptions store
    *
@@ -60,7 +61,7 @@ type Subscriptions = {
    * - `to.any` - Map of subscriptions to values _(for unkeyed subscriptions)_
    * - `to.keyed` - Map of keys to maps of subscriptions to values _(for keyed subscriptions)_
    */
-  readonly values: Readonly<SubscriptionsValues>;
+  readonly values: Readonly<SubscriptionsValues<Value>>;
   /**
    * Clear all subscriptions
    */
@@ -76,7 +77,7 @@ type Subscriptions = {
 /**
  * Parameters for creating a subscription store
  */
-type SubscriptionsParameters = {
+export type SubscriptionsParameters = {
   /**
    * Allow any or specific keys for subscriptions? _(defaults to `false`, which prevents keyed subscriptions)_
    */
@@ -90,9 +91,9 @@ type SubscriptionsItems = {
   any: Set<Subscription>;
   keyed?: Map<Key, Set<Subscription>>;
 };
-type SubscriptionsValues = {
-  from: SubscriptionsValuesItem<unknown, Subscription>;
-  to: SubscriptionsValuesItem<Subscription, unknown>;
+type SubscriptionsValues<Value = unknown> = {
+  from: SubscriptionsValuesItem<Value, Subscription>;
+  to: SubscriptionsValuesItem<Subscription, Value>;
 };
 type SubscriptionsValuesItem<MapKey, MapValue> = {
   any: Map<MapKey, MapValue>;
@@ -104,21 +105,19 @@ type SubscriptionsValuesItem<MapKey, MapValue> = {
  * @param value Value to check
  * @returns `true` if the value is a subscription, otherwise `false`
  */
-declare function isSubscription(value: unknown): value is Subscription;
+export declare function isSubscription(value: unknown): value is Subscription;
 /**
  * Is the value a subscriptions store?
  *
  * @param value Value to check
  * @returns `true` if the value is a subscriptions store, otherwise `false`
  */
-declare function isSubscriptions(value: unknown): value is Subscriptions;
+export declare function isSubscriptions(value: unknown): value is Subscriptions;
 /**
  * Create a subscription store
  *
  * @param parameters Store parameters
  * @returns Subscription store
  */
-declare function subscriptions(parameters?: SubscriptionsParameters): Subscriptions;
-declare const SUBSCRIPTION_NAME = "subscription";
-//#endregion
-export { SUBSCRIPTION_NAME, Subscription, SubscriptionParameters, SubscriptionProperty, Subscriptions, SubscriptionsParameters, isSubscription, isSubscriptions, subscriptions };
+export declare function subscriptions<Value = unknown>(parameters?: SubscriptionsParameters): Subscriptions<Value>;
+//#endregion

package/dist/internal/subscription.mjs

@@ -1,13 +1,54 @@
 import { isKey, isPlainObject } from "./is.mjs";
 import { createAborter } from "./abort.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) {
+	Object.defineProperty(this, SUBSCRIPTION_SYMBOL, { value: state });
+	state.aborter = createAborter(parameters.signal, () => this.unsubscribe(subscriptions, this, state));
+	Object.defineProperties(this, {
+		[property.key]: { value: property.value },
+		active: {
+			enumerable: true,
+			get: () => (state.parameters?.isActive?.() ?? true) && state.active
+		}
+	});
+	addSubscription(this);
+}
+Object.defineProperties(Subscription.prototype, {
+	[SUBSCRIPTION_PROPERTY]: { value: SUBSCRIPTION_NAME },
+	unsubscribe: { value: removeSubscription }
+});
+function Subscriptions(parameters) {
+	const { keys, property } = createSubscriptionsParameters(parameters);
+	Object.defineProperty(this, SUBSCRIPTION_SYMBOL, { value: createSubscriptionsState(property, keys) });
+}
+Object.defineProperties(Subscriptions.prototype, {
+	[SUBSCRIPTION_PROPERTY]: { value: SUBSCRIPTION_STORE },
+	clear: { value: clearSubscriptions },
+	create: { value: createSubscription },
+	items: {
+		enumerable: true,
+		get() {
+			return this[SUBSCRIPTION_SYMBOL].items;
+		}
+	},
+	values: {
+		enumerable: true,
+		get() {
+			return this[SUBSCRIPTION_SYMBOL].values;
+		}
+	}
+});
+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 +60,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,18 +94,7 @@ 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;
@@ -95,9 +128,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 +158,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 +179,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 +197,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 +207,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<Constructor, 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,16 +78,16 @@ 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 },
+	handler: { value: compareHandler },
 	register: { value: registerComparator }
 });
 //#endregion

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<Constructor, 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