@oscarpalmer/atoms 0.197.0 → 0.199.0

package/dist/internal/array/find.d.mts

@@ -10,14 +10,14 @@ type Parameters = {
   key?: unknown;
   value?: unknown;
 };
+declare function createFindParameters(original: unknown[]): Parameters;
 declare function findValue(type: Exclude<FindValueType, 'item'>, array: unknown[], parameters: unknown[], reversed: boolean): number;
 declare function findValue(type: Exclude<FindValueType, 'index'>, array: unknown[], parameters: unknown[], reversed: boolean): unknown;
 declare function findAbsoluteValueOrDefault(array: unknown[], parameters: unknown[], defaultValue: unknown, useDefaultValue: boolean, reversed: boolean): unknown;
 declare function findValues(type: FindValuesType, array: unknown[], parameters: unknown[], mapper?: unknown): FindValuesResult;
-declare function getFindParameters(original: unknown[]): Parameters;
 declare const FIND_VALUE_INDEX = "index";
 declare const FIND_VALUE_ITEM = "item";
 declare const FIND_VALUES_ALL: FindValuesType;
 declare const FIND_VALUES_UNIQUE: FindValuesType;
 //#endregion
-export { FIND_VALUES_ALL, FIND_VALUES_UNIQUE, FIND_VALUE_INDEX, FIND_VALUE_ITEM, findAbsoluteValueOrDefault, findValue, findValues, getFindParameters };
+export { FIND_VALUES_ALL, FIND_VALUES_UNIQUE, FIND_VALUE_INDEX, FIND_VALUE_ITEM, createFindParameters, findAbsoluteValueOrDefault, findValue, findValues };

package/dist/internal/array/find.mjs

@@ -1,9 +1,17 @@
 import { getArrayCallback, getArrayCallbacks } from "./callbacks.mjs";
 //#region src/internal/array/find.ts
+function createFindParameters(original) {
+	const { length } = original;
+	return {
+		bool: length === 1 && typeof original[0] === "function" ? original[0] : void 0,
+		key: length === 2 ? original[0] : void 0,
+		value: length === 1 && typeof original[0] !== "function" ? original[0] : original[1]
+	};
+}
 function findValue(type, array, parameters, reversed) {
 	const findIndex = type === FIND_VALUE_INDEX;
 	if (!Array.isArray(array) || array.length === 0) return findIndex ? -1 : void 0;
-	const { bool, key, value } = getFindParameters(parameters);
+	const { bool, key, value } = createFindParameters(parameters);
 	const callbacks = getArrayCallbacks(bool, key);
 	if (callbacks?.bool == null && callbacks?.keyed == null) {
 		if (findIndex) return reversed ? array.lastIndexOf(value) : array.indexOf(value);
@@ -38,7 +46,7 @@ function findValues(type, array, parameters, mapper) {
 	};
 	if (!Array.isArray(array) || array.length === 0) return result;
 	const { length } = array;
-	const { bool, key, value } = getFindParameters(parameters);
+	const { bool, key, value } = createFindParameters(parameters);
 	const callbacks = getArrayCallbacks(bool, key);
 	if (type === "unique" && callbacks?.keyed == null && length >= FIND_UNIQUE_THRESHOLD) {
 		result.matched = [...new Set(array)];
@@ -65,18 +73,10 @@ function findValues(type, array, parameters, mapper) {
 	}
 	return result;
 }
-function getFindParameters(original) {
-	const { length } = original;
-	return {
-		bool: length === 1 && typeof original[0] === "function" ? original[0] : void 0,
-		key: length === 2 ? original[0] : void 0,
-		value: length === 1 && typeof original[0] !== "function" ? original[0] : original[1]
-	};
-}
 const FIND_VALUE_INDEX = "index";
 const FIND_VALUE_ITEM = "item";
 const FIND_VALUES_ALL = "all";
 const FIND_VALUES_UNIQUE = "unique";
 const FIND_UNIQUE_THRESHOLD = 100;
 //#endregion
-export { FIND_VALUES_ALL, FIND_VALUES_UNIQUE, FIND_VALUE_INDEX, FIND_VALUE_ITEM, findAbsoluteValueOrDefault, findValue, findValues, getFindParameters };
+export { FIND_VALUES_ALL, FIND_VALUES_UNIQUE, FIND_VALUE_INDEX, FIND_VALUE_ITEM, createFindParameters, findAbsoluteValueOrDefault, findValue, findValues };

package/dist/internal/function/memoize.mjs

@@ -1,12 +1,13 @@
 import { isPlainObject } from "../is.mjs";
 import { getString, join } from "../string/misc.mjs";
+import { getNumberOrDefault } from "../defaults.mjs";
 import { SizedMap } from "../sized/map.mjs";
 //#region src/internal/function/memoize.ts
-function getMemoizationOptions(input) {
+function createMemoizationOptions(input) {
 	const { cacheKey, cacheSize } = isPlainObject(input) ? input : {};
 	return {
 		cacheKey: typeof cacheKey === "function" ? cacheKey : void 0,
-		cacheSize: typeof cacheSize === "number" && cacheSize > 0 ? cacheSize : MEMOIZED_CACHE_SIZE_DEFAULT
+		cacheSize: getNumberOrDefault(cacheSize, MEMOIZED_CACHE_SIZE_DEFAULT)
 	};
 }
 /**
@@ -21,7 +22,7 @@ function memoize(callback, options) {
 	const state = {
 		cache: void 0,
 		getter: void 0,
-		options: getMemoizationOptions(options)
+		options: createMemoizationOptions(options)
 	};
 	state.cache = new SizedMap(state.options.cacheSize);
 	state.getter = (...parameters) => {

package/dist/internal/function/timer.mjs

@@ -1,3 +1,4 @@
+import { getNumberOrDefault } from "../defaults.mjs";
 //#region src/internal/function/timer.ts
 function getAsyncTimer(type, callback, time) {
 	function cancel() {
@@ -24,7 +25,7 @@ function getAsyncTimer(type, callback, time) {
 			}
 		} else id = startTimer(() => run(item));
 	}
-	const interval = getInterval(time);
+	const interval = getNumberOrDefault(time, 0);
 	const throttle = type === TIMER_THROTTLE;
 	let id;
 	let last;
@@ -47,9 +48,6 @@ function getAsyncTimer(type, callback, time) {
 	Object.defineProperty(timer, TIMER_CANCEL, { value: () => cancel() });
 	return timer;
 }
-function getInterval(value) {
-	return typeof value === "number" && value > 0 ? value : 0;
-}
 function getTimer(type, callback, time) {
 	function cancel() {
 		clearTimer(id);
@@ -62,7 +60,7 @@ function getTimer(type, callback, time) {
 			callback(...args);
 		} else id = startTimer(run);
 	}
-	const interval = getInterval(time);
+	const interval = getNumberOrDefault(time, 0);
 	const throttle = type === TIMER_THROTTLE;
 	let args;
 	let id;

package/dist/internal/herald.mjs

@@ -1,5 +1,5 @@
 import { isPlainObject } from "./is.mjs";
-import { createSubscriptions, isSubscription } from "./subscription.mjs";
+import { SUBSCRIPTION_NAME, isSubscription, subscriptions } from "./subscription.mjs";
 //#region src/internal/herald.ts
 function createEvents(herald, state) {
 	const events = {};
@@ -7,35 +7,35 @@ function createEvents(herald, state) {
 	for (const key of state.keys) events[key] = (callback, signal) => herald.subscribe(key, callback, signal);
 	return Object.freeze(events);
 }
-function emitForHerald(state, event, ...parameters) {
-	const items = state.subscriptions.state.values.from.keyed?.get(event);
-	if (items == null || items.size === 0) return;
-	for (const [callback] of items) callback(...parameters);
-}
-function getHeraldSubscriptionProperty(input) {
-	if (input == null) return heraldSubscription;
-	const property = isPlainObject(input) ? input : {};
-	if (typeof property.key !== "string" || property.value != null && typeof property.value !== "string") throw new Error(HERALD_MESSAGE_PROPERTY);
-	return {
-		key: property.key,
-		value: property.value
-	};
-}
-function getHeraldState(input) {
+function createHeraldState(input) {
 	const options = isPlainObject(input) ? input : {};
 	if (!Array.isArray(options.names) || options.names.length === 0 || !options.names.every((name) => typeof name === "string")) throw new Error(HERALD_MESSAGE_ARRAY);
 	if (options.onCreate != null && typeof options.onCreate !== "function") throw new Error(HERALD_MESSAGE_ONCREATE);
 	const keys = new Set(options.names);
-	const property = getHeraldSubscriptionProperty(options.property);
+	const property = createHeraldSubscriptionProperty(options.property);
 	return {
 		keys,
-		subscriptions: createSubscriptions({
+		store: subscriptions({
 			keys,
 			property
 		}),
 		onCreate: options.onCreate
 	};
 }
+function createHeraldSubscriptionProperty(input) {
+	if (input == null) return heraldSubscription;
+	const property = isPlainObject(input) ? input : {};
+	if (typeof property.key !== "string" || property.value != null && typeof property.value !== "string") throw new Error(HERALD_MESSAGE_PROPERTY);
+	return {
+		key: property.key,
+		value: property.value
+	};
+}
+function emitForHerald(state, event, ...parameters) {
+	const items = state.store.values.from.keyed?.get(event);
+	if (items == null || items.size === 0) return;
+	for (const [callback] of items) callback(...parameters);
+}
 /**
 * Create a _Herald_ for announcing named events
 *
@@ -44,11 +44,11 @@ function getHeraldState(input) {
 * @returns _Herald_ instance
 */
 function herald(options) {
-	const state = getHeraldState(options);
+	const state = createHeraldState(options);
 	const instance = {
-		clear: () => state.subscriptions.clear(),
+		clear: () => state.store.clear(),
 		emit: (event, ...parameters) => emitForHerald(state, event, ...parameters),
-		observed: (event) => (state.subscriptions.state.items.keyed?.get(event)?.size ?? 0) > 0,
+		observed: (event) => (state.store.items.keyed?.get(event)?.size ?? 0) > 0,
 		subscribe: (key, callback, signal) => subscribeToHerald(state, key, callback, signal)
 	};
 	Object.defineProperties(instance, {
@@ -91,7 +91,7 @@ function isHeraldSubscription(value) {
 	return isSubscription(value) && value[HERALD_PROPERTY] === "subscription";
 }
 function subscribeToHerald(state, key, callback, signal) {
-	const [subscription, existing] = state.subscriptions.create({
+	const [subscription, existing] = state.store.create({
 		key,
 		signal,
 		value: callback
@@ -105,6 +105,9 @@ const HERALD_MESSAGE_ONCREATE = `Herald requires a valid onCreate callback for s
 const HERALD_MESSAGE_PROPERTY = `Herald requires valid property information for subscription identification`;
 const HERALD_NAME_EVENTS = "events";
 const HERALD_NAME_HERALD = "herald";
-const heraldSubscription = { key: HERALD_PROPERTY };
+const heraldSubscription = {
+	key: HERALD_PROPERTY,
+	value: SUBSCRIPTION_NAME
+};
 //#endregion
 export { herald, isHerald, isHeraldEvents, isHeraldSubscription };

package/dist/internal/subscription.d.mts

@@ -10,10 +10,25 @@ type Subscription = {
    */
   unsubscribe(): void;
 };
+/**
+ * Parameters for creating a subscription
+ */
 type SubscriptionParameters = {
+  /**
+   * Is the owner of the subscription alive? _(defaults to `true`)_
+   */
   isActive?: () => boolean;
+  /**
+   * Key used to identify a subscription _(defaults to `undefined`)_
+   */
   key?: unknown;
+  /**
+   * Signal used to abort the subscription _(defaults to `undefined`)_
+   */
   signal?: AbortSignal;
+  /**
+   * Value used to identify a subscription
+   */
   value: unknown;
 };
 /**
@@ -25,37 +40,64 @@ type SubscriptionProperty = {
    */
   key: string;
   /**
-   * Value of the property used to identify a subscription _(defaults to `subscription`)_
+   * Value of the property used to identify a subscription
    */
-  value?: unknown;
+  value: unknown;
 };
-type Subscriptions<Value = unknown> = {
-  state: SubscriptionsState<Value>;
+type Subscriptions = {
+  /**
+   * Items of the subscriptions store
+   *
+   * - `any` - Set of subscriptions _(for unkeyed subscriptions)_
+   * - `keyed` - Map of keys to sets of subscriptions _(for keyed subscriptions)_
+   */
+  readonly items: Readonly<SubscriptionsItems>;
+  /**
+   * Values of the subscriptions store
+   *
+   * - `from.any` - Map of values to subscriptions _(for unkeyed subscriptions)_
+   * - `from.keyed` - Map of keys to maps of values to subscriptions _(for keyed 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>;
+  /**
+   * Clear all subscriptions
+   */
   clear: () => void;
+  /**
+   * Create _(or retrieve)_ a subscription
+   *
+   * @param parameters Subscription parameters
+   * @returns Tuple holding subsccription and existing boolean
+   */
   create: (parameters: SubscriptionParameters) => [Subscription, boolean];
 };
+/**
+ * Parameters for creating a subscription store
+ */
 type SubscriptionsParameters = {
-  keys?: Set<Key>;
-  property: SubscriptionProperty;
-};
-type SubscriptionsState<Value = unknown> = {
-  items: SubscriptionsItems;
-  keys?: Set<Key>;
-  values: SubscriptionsValues<Value>;
+  /**
+   * Allow any or specific keys for subscriptions? _(defaults to `false`, which prevents keyed subscriptions)_
+   */
+  keys?: boolean | Set<Key>;
+  /**
+   * Property information for subscription identification
+   */
+  property?: SubscriptionProperty;
 };
 type SubscriptionsItems = {
   any: Set<Subscription>;
   keyed?: Map<Key, Set<Subscription>>;
 };
-type SubscriptionsValues<Value = unknown> = {
-  from: SubscriptionsValuesItem<Value, Subscription>;
-  to: SubscriptionsValuesItem<Subscription, Value>;
+type SubscriptionsValues = {
+  from: SubscriptionsValuesItem<unknown, Subscription>;
+  to: SubscriptionsValuesItem<Subscription, unknown>;
 };
 type SubscriptionsValuesItem<MapKey, MapValue> = {
   any: Map<MapKey, MapValue>;
   keyed?: Map<Key, Map<MapKey, MapValue>>;
 };
-declare function createSubscriptions<Value = unknown>(parameters: SubscriptionsParameters): Subscriptions<Value>;
 /**
  * Is the value a subscription?
  *
@@ -63,6 +105,20 @@ declare function createSubscriptions<Value = unknown>(parameters: SubscriptionsP
  * @returns `true` if the value is a subscription, otherwise `false`
  */
 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;
+/**
+ * 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, createSubscriptions, isSubscription };
+export { SUBSCRIPTION_NAME, Subscription, SubscriptionParameters, SubscriptionProperty, Subscriptions, SubscriptionsParameters, isSubscription, isSubscriptions, subscriptions };

package/dist/internal/subscription.mjs

@@ -2,8 +2,8 @@ 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 { key, value } = state.parameters;
-	const { items, values } = subscriptions.state;
 	if (!isKey(key)) {
 		items.any.add(subscription);
 		values.from.any.set(value, subscription);
@@ -37,7 +37,8 @@ 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 createSubscription(subscriptions, property, parameters) {
+function createSubscription(subscriptions, property, params) {
+	const parameters = createSubscriptionParameters(params);
 	if (parameters.signal?.aborted ?? false) throw new Error(parameters.signal?.reason);
 	const state = {
 		parameters,
@@ -45,12 +46,15 @@ function createSubscription(subscriptions, property, parameters) {
 	};
 	const existing = getExistingSubscription(subscriptions, state);
 	if (existing != null) return [existing, true];
-	if (subscriptions.state.keys != null && isKey(parameters.key) && !subscriptions.state.keys.has(parameters.key)) throw new Error(SUBSCRIPTION_INVALID_KEY);
+	if (subscriptions.keys != null && isKey(parameters.key)) {
+		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: true },
-		[property.key]: { value: property.value ?? "subscription" },
+		[SUBSCRIPTION_PROPERTY]: { value: SUBSCRIPTION_NAME },
+		[property.key]: { value: property.value },
 		active: {
 			enumerable: true,
 			get: () => (parameters.isActive?.() ?? true) && state.active
@@ -59,36 +63,56 @@ function createSubscription(subscriptions, property, parameters) {
 	addSubscription(subscriptions, instance, state);
 	return [Object.freeze(instance), false];
 }
-function createSubscriptions(parameters) {
-	const { keys, property } = parameters;
-	const state = {
+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 createSubscriptionParameters(input) {
+	const values = isPlainObject(input) ? input : {};
+	if (values.value == null) throw new Error(SUBSCRIPTION_INVALID_VALUE);
+	return {
+		isActive: typeof values.isActive === "function" ? values.isActive : void 0,
+		key: isKey(values.key) ? values.key : void 0,
+		signal: values.signal instanceof AbortSignal ? values.signal : void 0,
+		value: values.value
+	};
+}
+function createSubscriptionsParameters(input) {
+	const values = isPlainObject(input) ? input : {};
+	let keys;
+	if (values.keys instanceof Set) keys = values.keys;
+	else keys = typeof values.keys === "boolean" ? values.keys : false;
+	return {
+		keys,
+		property: createSubscriptionsProperty(values.property)
+	};
+}
+function createSubscriptionsProperty(input) {
+	const values = isPlainObject(input) ? input : {};
+	return {
+		key: typeof values.key === "string" ? values.key : SUBSCRIPTION_PROPERTY,
+		value: values.value == null ? SUBSCRIPTION_NAME : values.value
+	};
+}
+function createSubscriptionsState(keys) {
+	return {
 		keys,
 		items: {
 			any: /* @__PURE__ */ new Set(),
-			keyed: keys == null ? void 0 : /* @__PURE__ */ new Map()
+			keyed: keys === false ? void 0 : /* @__PURE__ */ new Map()
 		},
 		values: {
 			from: {
 				any: /* @__PURE__ */ new Map(),
-				keyed: keys == null ? void 0 : /* @__PURE__ */ new Map()
+				keyed: keys === false ? void 0 : /* @__PURE__ */ new Map()
 			},
 			to: {
 				any: /* @__PURE__ */ new Map(),
-				keyed: keys == null ? void 0 : /* @__PURE__ */ new Map()
+				keyed: keys === false ? void 0 : /* @__PURE__ */ new Map()
 			}
 		}
 	};
-	const instance = {
-		state,
-		clear: () => clearSubscriptions(state),
-		create: (parameters) => createSubscription(instance, property, parameters)
-	};
-	return instance;
-}
-function getExistingSubscription(subscriptions, state) {
-	const { parameters } = state;
-	const { values } = subscriptions.state;
-	return isKey(parameters.key) ? values.from.keyed?.get(parameters.key)?.get(parameters.value) : values.from.any.get(parameters.value);
 }
 /**
 * Is the value a subscription?
@@ -97,7 +121,19 @@ function getExistingSubscription(subscriptions, state) {
 * @returns `true` if the value is a subscription, otherwise `false`
 */
 function isSubscription(value) {
-	return isPlainObject(value) && SUBSCRIPTION_PROPERTY in value && value[SUBSCRIPTION_PROPERTY] === true;
+	return isSubscriptionInstance(value, SUBSCRIPTION_NAME);
+}
+function isSubscriptionInstance(value, name) {
+	return isPlainObject(value) && SUBSCRIPTION_PROPERTY in value && value[SUBSCRIPTION_PROPERTY] === name;
+}
+/**
+* Is the value a subscriptions store?
+*
+* @param value Value to check
+* @returns `true` if the value is a subscriptions store, otherwise `false`
+*/
+function isSubscriptions(value) {
+	return isSubscriptionInstance(value, SUBSCRIPTION_STORE);
 }
 function removeFromStore(items, values, subscription, value, key) {
 	items.delete(subscription);
@@ -109,14 +145,14 @@ function removeFromStore(items, values, subscription, value, key) {
 		values.to.keyed?.get(key)?.delete(subscription);
 	}
 }
-function removeSubscription(subscriptions, subscription, state) {
+function removeSubscription(subscriptionsState, subscription, state) {
 	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 { key, value } = state.parameters;
-	const { items, values } = subscriptions.state;
 	if (!isKey(key)) {
 		removeFromStore(items.any, values, subscription, value);
 		return;
@@ -129,12 +165,41 @@ function removeSubscription(subscriptions, subscription, state) {
 	removeFromStore(keyed, values, subscription, value, key);
 	if (keyed.size === 0) items.keyed.delete(key);
 }
-function unsubscribe(subscriptions, subscription, state) {
+/**
+* Create a subscription store
+*
+* @param parameters Store parameters
+* @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(subscriptions, subscription, state);
+	removeSubscription(subscriptionsState, subscription, state);
 }
+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 = "$subscription";
+const SUBSCRIPTION_PROPERTY = "$subscriptions";
+const SUBSCRIPTION_STORE = "subscriptions";
 //#endregion
-export { SUBSCRIPTION_NAME, createSubscriptions, isSubscription };
+export { SUBSCRIPTION_NAME, isSubscription, isSubscriptions, subscriptions };

package/dist/internal/value/compare.mjs

@@ -1,6 +1,6 @@
 import { max } from "../math/aggregate.mjs";
 import { getString, words } from "../string/misc.mjs";
-import { getCompareHandlers } from "./handlers.mjs";
+import { createCompareHandlers } from "./handlers.mjs";
 //#region src/internal/value/compare.ts
 const COMPARE_NAME = "compare";
 /**
@@ -78,7 +78,7 @@ const comparators = {
 	number: compareNumbers,
 	symbol: compareSymbols
 };
-const compareHandlers = getCompareHandlers(compare, {
+const compareHandlers = createCompareHandlers(compare, {
 	callback: (first, second, compareStrings) => compareStrings ? getString(first).localeCompare(getString(second)) : void 0,
 	method: COMPARE_NAME
 });

package/dist/internal/value/equal.mjs

@@ -1,6 +1,32 @@
 import { isNonPlainObject, isPlainObject, isPrimitive, isTypedArray } from "../is.mjs";
-import { getCompareHandlers } from "./handlers.mjs";
+import { createCompareHandlers } from "./handlers.mjs";
 //#region src/internal/value/equal.ts
+function createEqualOptions(input) {
+	const options = {
+		ignoreCase: false,
+		ignoreExpressions: {
+			enabled: false,
+			values: []
+		},
+		ignoreKeys: {
+			enabled: false,
+			values: /* @__PURE__ */ new Set()
+		},
+		relaxedNullish: false
+	};
+	if (typeof input === "boolean") {
+		options.ignoreCase = input;
+		return options;
+	}
+	if (isNonPlainObject(input)) return options;
+	options.ignoreCase = typeof input.ignoreCase === "boolean" ? input.ignoreCase : false;
+	options.ignoreExpressions.values = (Array.isArray(input.ignoreKeys) ? input.ignoreKeys : [input.ignoreKeys]).filter((key) => key instanceof RegExp);
+	options.ignoreKeys.values = new Set((Array.isArray(input.ignoreKeys) ? input.ignoreKeys : [input.ignoreKeys]).filter((key) => typeof key === "string"));
+	options.ignoreExpressions.enabled = options.ignoreExpressions.values.length > 0;
+	options.ignoreKeys.enabled = options.ignoreKeys.values.size > 0;
+	options.relaxedNullish = input.relaxedNullish === true;
+	return options;
+}
 /**
 * Deregister a equality comparison handler for a specific class
 *
@@ -18,9 +44,9 @@ function filterKey(key, options) {
 	return true;
 }
 function equal(first, second, options) {
-	return equalValue(first, second, getEqualOptions(options));
+	return equalValue(first, second, createEqualOptions(options));
 }
-equal.handlers = getCompareHandlers(equal, { callback: Object.is });
+equal.handlers = createCompareHandlers(equal, { callback: Object.is });
 equal.deregister = deregisterEqualizer;
 equal.initialize = initializeEqualizer;
 equal.register = registerEqualizer;
@@ -115,32 +141,6 @@ function equalValue(first, second, options) {
 		default: return equal.handlers.handle(first, second, options);
 	}
 }
-function getEqualOptions(input) {
-	const options = {
-		ignoreCase: false,
-		ignoreExpressions: {
-			enabled: false,
-			values: []
-		},
-		ignoreKeys: {
-			enabled: false,
-			values: /* @__PURE__ */ new Set()
-		},
-		relaxedNullish: false
-	};
-	if (typeof input === "boolean") {
-		options.ignoreCase = input;
-		return options;
-	}
-	if (isNonPlainObject(input)) return options;
-	options.ignoreCase = typeof input.ignoreCase === "boolean" ? input.ignoreCase : false;
-	options.ignoreExpressions.values = (Array.isArray(input.ignoreKeys) ? input.ignoreKeys : [input.ignoreKeys]).filter((key) => key instanceof RegExp);
-	options.ignoreKeys.values = new Set((Array.isArray(input.ignoreKeys) ? input.ignoreKeys : [input.ignoreKeys]).filter((key) => typeof key === "string"));
-	options.ignoreExpressions.enabled = options.ignoreExpressions.values.length > 0;
-	options.ignoreKeys.enabled = options.ignoreKeys.values.size > 0;
-	options.relaxedNullish = input.relaxedNullish === true;
-	return options;
-}
 /**
 * Create an equalizer with predefined options
 *
@@ -150,7 +150,7 @@ function getEqualOptions(input) {
 * @returns Equalizer function
 */
 function initializeEqualizer(options) {
-	const actual = getEqualOptions(options);
+	const actual = createEqualOptions(options);
 	const equalizer = (first, second) => equalValue(first, second, actual);
 	equalizer.deregister = deregisterEqualizer;
 	equalizer.register = registerEqualizer;

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

@@ -4,15 +4,15 @@ type Options = {
   callback: GenericCallback;
   method?: string;
 };
-declare function getCompareHandlers<Value>(owner: GenericCallback, options: Options): {
+declare function createCompareHandlers<Value>(owner: GenericCallback, options: Options): {
   deregister(constructor: Constructor): void;
   handle(first: unknown, second: unknown, ...parameters: unknown[]): Value;
   register(constructor: Constructor, handler?: string | GenericCallback): void;
 };
-declare function getSelfHandlers(owner: GenericCallback, options: Options): {
+declare function createSelfHandlers(owner: GenericCallback, options: Options): {
   deregister(constructor: Constructor): void;
   handle(value: unknown, ...parameters: unknown[]): unknown;
   register(constructor: Constructor, handler?: string | GenericCallback): void;
 };
 //#endregion
-export { getCompareHandlers, getSelfHandlers };
+export { createCompareHandlers, createSelfHandlers };