@oscarpalmer/atoms 0.193.1 → 0.195.0

package/dist/internal/herald.mjs

@@ -0,0 +1,110 @@
+import { isPlainObject } from "./is.mjs";
+import { createSubscriptions, isSubscription } from "./subscription.mjs";
+//#region src/internal/herald.ts
+function createEvents(herald, state) {
+	const events = {};
+	Object.defineProperty(events, HERALD_PROPERTY, { value: HERALD_NAME_EVENTS });
+	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) {
+	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);
+	return {
+		keys,
+		subscriptions: createSubscriptions({
+			keys,
+			property
+		}),
+		onCreate: options.onCreate
+	};
+}
+/**
+* Create a _Herald_ for announcing named events
+*
+* @param names Event names
+* @param property Optional property for subscription identification _(defaults to `$herald`)_
+* @returns _Herald_ instance
+*/
+function herald(options) {
+	const state = getHeraldState(options);
+	const instance = {
+		clear: () => state.subscriptions.clear(),
+		emit: (event, ...parameters) => emitForHerald(state, event, ...parameters),
+		observed: (event) => (state.subscriptions.state.items.keyed?.get(event)?.size ?? 0) > 0,
+		subscribe: (key, callback, signal) => subscribeToHerald(state, key, callback, signal)
+	};
+	Object.defineProperties(instance, {
+		[HERALD_PROPERTY]: { value: HERALD_NAME_HERALD },
+		events: {
+			enumerable: true,
+			value: createEvents(instance, state)
+		}
+	});
+	return Object.freeze(instance);
+}
+/**
+* Is the value a herald?
+*
+* @param value Value to check
+* @returns `true` if the value is a herald, otherwise `false`
+*/
+function isHerald(value) {
+	return isHeraldInstance(HERALD_NAME_HERALD, value);
+}
+/**
+* Is the value events for a herald?
+*
+* @param value Value to check
+* @returns `true` if the value is events for a herald, otherwise `false`
+*/
+function isHeraldEvents(value) {
+	return isHeraldInstance(HERALD_NAME_EVENTS, value);
+}
+function isHeraldInstance(name, value) {
+	return isPlainObject(value) && HERALD_PROPERTY in value && value[HERALD_PROPERTY] === name;
+}
+/**
+* Is the value a herald subscription?
+*
+* @param value Value to check
+* @returns `true` if the value is a herald subscription, otherwise `false`
+*/
+function isHeraldSubscription(value) {
+	return isSubscription(value) && value[HERALD_PROPERTY] === "subscription";
+}
+function subscribeToHerald(state, key, callback, signal) {
+	const [subscription, existing] = state.subscriptions.create({
+		key,
+		signal,
+		value: callback
+	});
+	if (!existing) state.onCreate?.(key, callback, subscription);
+	return subscription;
+}
+const HERALD_PROPERTY = "$herald";
+const HERALD_MESSAGE_ARRAY = "Herald requires an array of event names.";
+const HERALD_MESSAGE_ONCREATE = `Herald requires a valid onCreate callback for subscription creation`;
+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 };
+//#endregion
+export { herald, isHerald, isHeraldEvents, isHeraldSubscription };

package/dist/internal/number.d.mts

@@ -33,6 +33,5 @@ declare function clamp(value: number, minimum: number, maximum: number, loop?: b
  * @returns Original value as a number, or `Number.NaN` if the value is unable to be parsed
  */
 declare function getNumber(value: unknown): number;
-declare function getNumberOrDefault(value: unknown, defaultValue: number, minimum?: number): number;
 //#endregion
-export { between, clamp, getNumber, getNumberOrDefault };
+export { between, clamp, getNumber };

package/dist/internal/number.mjs

@@ -59,17 +59,14 @@ function getNumber(value) {
 	if (typeof parsed !== "string") return getNumber(parsed);
 	const trimmed = parsed.trim();
 	if (trimmed.length === 0) return NaN;
-	if (EXPRESSION_ZEROISH.test(parsed)) return 0;
-	const isBinary = EXPRESSION_BINARY.test(trimmed);
-	if (isBinary || EXPRESSION_OCTAL.test(trimmed)) return Number.parseInt(trimmed.slice(2), isBinary ? 2 : OCTAL_VALUE);
+	if (NUMBER_EXPRESSION_ZEROISH.test(parsed)) return 0;
+	const isBinary = NUMBER_EXPRESSION_BINARY.test(trimmed);
+	if (isBinary || NUMBER_EXPRESSION_OCTAL.test(trimmed)) return Number.parseInt(trimmed.slice(2), isBinary ? 2 : NUMBER_OCTAL_VALUE);
 	return Number(trimmed);
 }
-function getNumberOrDefault(value, defaultValue, minimum) {
-	return typeof value === "number" && !Number.isNaN(value) && value >= (minimum ?? 0) ? Math.floor(value) : defaultValue;
-}
-const EXPRESSION_BINARY = /^0b[01]+$/i;
-const EXPRESSION_OCTAL = /^0o[0-7]+$/i;
-const EXPRESSION_ZEROISH = /^\s*0+\s*$/;
-const OCTAL_VALUE = 8;
+const NUMBER_EXPRESSION_BINARY = /^0b[01]+$/i;
+const NUMBER_EXPRESSION_OCTAL = /^0o[0-7]+$/i;
+const NUMBER_EXPRESSION_ZEROISH = /^\s*0+\s*$/;
+const NUMBER_OCTAL_VALUE = 8;
 //#endregion
-export { between, clamp, getNumber, getNumberOrDefault };
+export { between, clamp, getNumber };

package/dist/internal/{result.d.mts → result/misc.d.mts}

@@ -1,5 +1,21 @@
-import { Err, ExtendedErr, Ok, Result } from "../result/models.mjs";
-//#region src/internal/result.d.ts
+import { Err, ExtendedErr, Ok, Result } from "./models.mjs";
+//#region src/internal/result/misc.d.ts
+/**
+ * Creates an extended error result
+ *
+ * @param value Error value
+ * @param original Original error
+ * @returns Error result
+ */
+declare function error<E>(value: E, original: Error): ExtendedErr<E>;
+/**
+ * Creates an error result
+ *
+ * @param value Error value
+ * @returns Error result
+ */
+declare function error<E>(value: E): Err<E>;
+declare function getError<E>(value: E, original?: Error): Err<E> | ExtendedErr<E>;
 /**
  * Is the _Result_ an extended error?
  *
@@ -42,5 +58,28 @@ declare function isOk(value: unknown): value is Ok<unknown>;
  * @returns `true` if the value is a _Result_, otherwise `false`
  */
 declare function isResult(value: unknown): value is ExtendedErr<unknown> | Result<unknown, unknown>;
+/**
+ * Creates an ok result
+ *
+ * @param value Value
+ * @returns Ok result
+ */
+declare function ok<Value>(value: Value): Ok<Value>;
+/**
+ * Gets the value of an ok result _(or a default value)_
+ *
+ * @param value _Result_ to unwrap
+ * @param defaultValue Default value
+ * @returns Value of the _Result_ _(or the default value)_
+ */
+declare function unwrap<Value, E = Error>(value: Result<Value, E>, defaultValue: Value): Value;
+/**
+ * Gets the value of an ok result _(or a default value)_
+ *
+ * @param value _Result_ to unwrap
+ * @param defaultValue Default value
+ * @returns Value of the _Result_ _(or the default value)_
+ */
+declare function unwrap(value: unknown, defaultValue: unknown): unknown;
 //#endregion
-export { isError, isOk, isResult };
+export { error, getError, isError, isOk, isResult, ok, unwrap };

package/dist/internal/result/misc.mjs

@@ -0,0 +1,51 @@
+import { isNonPlainObject } from "../is.mjs";
+//#region src/internal/result/misc.ts
+function error(value, original) {
+	return getError(value, original);
+}
+function getError(value, original) {
+	const errorResult = {
+		error: value,
+		ok: false
+	};
+	if (original instanceof Error) errorResult.original = original;
+	return errorResult;
+}
+function isError(value, extended) {
+	return isResultValue(value, false) && (extended === true ? value.original instanceof Error : true);
+}
+function isOk(value) {
+	return isResultValue(value, true);
+}
+/**
+* Is the value a _Result_?
+*
+* @param value Value to check
+* @returns `true` if the value is a _Result_, otherwise `false`
+*/
+function isResult(value) {
+	return isResultValue(value, true) || isResultValue(value, false);
+}
+function isResultValue(value, okValue) {
+	if (isNonPlainObject(value)) return false;
+	return value.ok === okValue && (okValue ? RESULT_PROPERTY_VALUE : RESULT_PROPERTY_ERROR) in value;
+}
+/**
+* Creates an ok result
+*
+* @param value Value
+* @returns Ok result
+*/
+function ok(value) {
+	return {
+		ok: true,
+		value
+	};
+}
+function unwrap(value, defaultValue) {
+	return isOk(value) ? value.value : defaultValue;
+}
+const RESULT_PROPERTY_ERROR = "error";
+const RESULT_PROPERTY_VALUE = "value";
+//#endregion
+export { error, getError, isError, isOk, isResult, ok, unwrap };

package/dist/{result → internal/result}/models.d.mts

@@ -1,5 +1,5 @@
-import { GenericCallback } from "../models.mjs";
-//#region src/result/models.d.ts
+import { GenericCallback } from "../../models.mjs";
+//#region src/internal/result/models.d.ts
 /**
  * An unknown result
  */

package/dist/{sized → internal/sized}/map.d.mts

@@ -1,4 +1,4 @@
-//#region src/sized/map.d.ts
+//#region src/internal/sized/map.d.ts
 /**
  * A _Map_ with a maximum size
  *

package/dist/{sized → internal/sized}/map.mjs

@@ -1,5 +1,5 @@
-import { getSizedMaximum } from "../internal/sized.mjs";
-//#region src/sized/map.ts
+import { getSizedMaximum } from "./misc.mjs";
+//#region src/internal/sized/map.ts
 /**
 * A _Map_ with a maximum size
 *

package/dist/internal/{sized.d.mts → sized/misc.d.mts}

@@ -1,4 +1,4 @@
-//#region src/internal/sized.d.ts
+//#region src/internal/sized/misc.d.ts
 declare function getSizedMaximum(first?: unknown, second?: unknown): number;
 //#endregion
 export { getSizedMaximum };

package/dist/internal/sized/misc.mjs

@@ -0,0 +1,12 @@
+import { clamp } from "../number.mjs";
+//#region src/internal/sized/misc.ts
+function getSizedMaximum(first, second) {
+	let actual;
+	if (typeof first === "number") actual = first;
+	else actual = typeof second === "number" ? second : SIZED_MAXIMUM_DEFAULT;
+	return clamp(actual, 1, SIZED_MAXIMUM_ABSOLUTE);
+}
+const SIZED_MAXIMUM_ABSOLUTE = 16777216;
+const SIZED_MAXIMUM_DEFAULT = 1048576;
+//#endregion
+export { getSizedMaximum };

package/dist/{string → internal/string}/case.d.mts

@@ -1,4 +1,4 @@
-//#region src/string/case.d.ts
+//#region src/internal/string/case.d.ts
 /**
  * Convert a string to camel case _(thisIsCamelCase)_
  *

package/dist/{string → internal/string}/case.mjs

@@ -1,6 +1,6 @@
-import { join, words } from "../internal/string.mjs";
+import { join, words } from "./misc.mjs";
 import { memoize } from "../function/memoize.mjs";
-//#region src/string/case.ts
+//#region src/internal/string/case.ts
 /**
 * Convert a string to camel case _(thisIsCamelCase)_
 *
@@ -8,7 +8,7 @@ import { memoize } from "../function/memoize.mjs";
 * @returns Camel-cased string
 */
 function camelCase(value) {
-	return toCase(CASE_CAMEL, value, true, false);
+	return toCase(STRING_CASE_CAMEL, value, true, false);
 }
 /**
 * Capitalize the first letter of a string _(and lowercase the rest)_
@@ -28,7 +28,7 @@ function capitalize(value) {
 * @returns Kebab-cased string
 */
 function kebabCase(value) {
-	return toCase(CASE_KEBAB, value, false, false);
+	return toCase(STRING_CASE_KEBAB, value, false, false);
 }
 /**
 * Convert a string to lower case
@@ -48,7 +48,7 @@ function lowerCase(value) {
 * @returns Pascal-cased string
 */
 function pascalCase(value) {
-	return toCase(CASE_PASCAL, value, true, true);
+	return toCase(STRING_CASE_PASCAL, value, true, true);
 }
 /**
 * Convert a string to snake case _(this_is_snake_case)_
@@ -57,7 +57,7 @@ function pascalCase(value) {
 * @returns Snake-cased string
 */
 function snakeCase(value) {
-	return toCase(CASE_SNAKE, value, false, false);
+	return toCase(STRING_CASE_SNAKE, value, false, false);
 }
 /**
 * Convert a string to title case _(Capitalizing Every Word)_
@@ -86,7 +86,7 @@ function toCaseCallback(value) {
 	const partsLength = parts.length;
 	const cased = [];
 	for (let partIndex = 0; partIndex < partsLength; partIndex += 1) {
-		const items = parts[partIndex].replace(EXPRESSION_ACRONYM, (full, one, two, three) => three === S ? full : `${one}-${two}${three}`).replace(EXPRESSION_CAMEL_CASE, REPLACEMENT_CAMEL_CASE).split("-");
+		const items = parts[partIndex].replace(STRING_EXPRESSION_ACRONYM, (full, one, two, three) => three === STRING_S ? full : `${one}-${two}${three}`).replace(STRING_EXPRESSION_CAMEL_CASE, STRING_REPLACEMENT_CAMEL_CASE).split("-");
 		const itemsLength = items.length;
 		const partResult = [];
 		let itemCount = 0;
@@ -112,23 +112,23 @@ function upperCase(value) {
 	memoizedUpperCase ??= memoize((v) => v.toLocaleUpperCase());
 	return memoizedUpperCase.run(value);
 }
-const CASE_CAMEL = "camel";
-const CASE_KEBAB = "kebab";
-const CASE_PASCAL = "pascal";
-const CASE_SNAKE = "snake";
-const DELIMTER_EMPTY = "";
-const DELIMITER_HYPHEN = "-";
-const DELIMITER_UNDERSCORE = "_";
-const EXPRESSION_CAMEL_CASE = /(\p{Ll})(\p{Lu})/gu;
-const EXPRESSION_ACRONYM = /(\p{Lu}*)(\p{Lu})(\p{Ll}+)/gu;
-const REPLACEMENT_CAMEL_CASE = "$1-$2";
-const S = "s";
+const STRING_CASE_CAMEL = "camel";
+const STRING_CASE_KEBAB = "kebab";
+const STRING_CASE_PASCAL = "pascal";
+const STRING_CASE_SNAKE = "snake";
+const STRING_DELIMTER_EMPTY = "";
+const STRING_DELIMITER_HYPHEN = "-";
+const STRING_DELIMITER_UNDERSCORE = "_";
+const STRING_EXPRESSION_CAMEL_CASE = /(\p{Ll})(\p{Lu})/gu;
+const STRING_EXPRESSION_ACRONYM = /(\p{Lu}*)(\p{Lu})(\p{Ll}+)/gu;
+const STRING_REPLACEMENT_CAMEL_CASE = "$1-$2";
+const STRING_S = "s";
 const caseMemoizers = {};
 const delimiters = {
-	[CASE_CAMEL]: DELIMTER_EMPTY,
-	[CASE_KEBAB]: DELIMITER_HYPHEN,
-	[CASE_PASCAL]: DELIMTER_EMPTY,
-	[CASE_SNAKE]: DELIMITER_UNDERSCORE
+	[STRING_CASE_CAMEL]: STRING_DELIMTER_EMPTY,
+	[STRING_CASE_KEBAB]: STRING_DELIMITER_HYPHEN,
+	[STRING_CASE_PASCAL]: STRING_DELIMTER_EMPTY,
+	[STRING_CASE_SNAKE]: STRING_DELIMITER_UNDERSCORE
 };
 let memoizedCapitalize;
 let memoizedLowerCase;

package/dist/internal/{string.d.mts → string/misc.d.mts}

@@ -1,4 +1,4 @@
-//#region src/internal/string.d.ts
+//#region src/internal/string/misc.d.ts
 /**
  * Get the string value from any value
  *

package/dist/internal/{string.mjs → string/misc.mjs}

@@ -1,4 +1,4 @@
-//#region src/internal/string.ts
+//#region src/internal/string/misc.ts
 /**
 * Get the string value from any value
 *
@@ -25,7 +25,7 @@ function getString(value) {
 	return asString.startsWith("[object ") ? JSON.stringify(value) : asString;
 }
 function ignoreKey(key) {
-	return EXPRESSION_IGNORED.test(key);
+	return STRING_EXPRESSION_IGNORED.test(key);
 }
 function interpolate(strings, values) {
 	const { length } = strings;
@@ -76,9 +76,9 @@ function tryEncode(value) {
 * @returns Array of words found in the string
 */
 function words(value) {
-	return typeof value === "string" ? value.match(EXPRESSION_WORDS) ?? [] : [];
+	return typeof value === "string" ? value.match(STRING_EXPRESSION_WORDS) ?? [] : [];
 }
-const EXPRESSION_IGNORED = /(^|\.)(__proto__|constructor|prototype)(\.|$)/i;
-const EXPRESSION_WORDS = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
+const STRING_EXPRESSION_IGNORED = /(^|\.)(__proto__|constructor|prototype)(\.|$)/i;
+const STRING_EXPRESSION_WORDS = /[^\x00-\x2f\x3a-\x40\x5b-\x60\x7b-\x7f]+/g;
 //#endregion
 export { getString, ignoreKey, interpolate, join, tryDecode, tryEncode, words };

package/dist/internal/subscription.d.mts

@@ -12,16 +12,33 @@ type Subscription = {
 };
 type SubscriptionParameters = {
   isActive?: () => boolean;
-  key?: Key;
-  property: SubscriptionProperty;
-  subscriptions: Subscriptions;
+  key?: unknown;
+  signal?: AbortSignal;
   value: unknown;
 };
+/**
+ * Property information for subscription identification
+ */
 type SubscriptionProperty = {
+  /**
+   * Name of the property used to identify a subscription
+   */
   key: string;
-  value: unknown;
+  /**
+   * Value of the property used to identify a subscription _(defaults to `subscription`)_
+   */
+  value?: unknown;
 };
 type Subscriptions<Value = unknown> = {
+  state: SubscriptionsState<Value>;
+  clear: () => void;
+  create: (parameters: SubscriptionParameters) => [Subscription, boolean];
+};
+type SubscriptionsParameters = {
+  keys?: Set<Key>;
+  property: SubscriptionProperty;
+};
+type SubscriptionsState<Value = unknown> = {
   items: SubscriptionsItems;
   keys?: Set<Key>;
   values: SubscriptionsValues<Value>;
@@ -38,9 +55,7 @@ type SubscriptionsValuesItem<MapKey, MapValue> = {
   any: Map<MapKey, MapValue>;
   keyed?: Map<Key, Map<MapKey, MapValue>>;
 };
-declare function clearSubscriptions(store: Subscriptions): void;
-declare function getSubscription(parameters: SubscriptionParameters): Subscription;
-declare function getSubscriptions<Value = unknown>(keys?: Set<Key>): Subscriptions<Value>;
+declare function createSubscriptions<Value = unknown>(parameters: SubscriptionsParameters): Subscriptions<Value>;
 /**
  * Is the value a subscription?
  *
@@ -48,5 +63,6 @@ declare function getSubscriptions<Value = unknown>(keys?: Set<Key>): Subscriptio
  * @returns `true` if the value is a subscription, otherwise `false`
  */
 declare function isSubscription(value: unknown): value is Subscription;
+declare const SUBSCRIPTION_NAME = "subscription";
 //#endregion
-export { Subscription, SubscriptionParameters, SubscriptionProperty, Subscriptions, clearSubscriptions, getSubscription, getSubscriptions, isSubscription };
+export { SUBSCRIPTION_NAME, Subscription, SubscriptionParameters, SubscriptionProperty, Subscriptions, createSubscriptions, isSubscription };

package/dist/internal/subscription.mjs

@@ -1,14 +1,16 @@
-import { isPlainObject } from "./is.mjs";
+import { isKey, isPlainObject } from "./is.mjs";
+import { createAborter } from "./abort.mjs";
 //#region src/internal/subscription.ts
-function addSubscription(subscription, state) {
-	const { key, subscriptions, value } = state.parameters;
-	const { items, values } = subscriptions;
-	if (key == null) {
+function addSubscription(subscriptions, subscription, state) {
+	const { key, value } = state.parameters;
+	const { items, values } = subscriptions.state;
+	if (!isKey(key)) {
 		items.any.add(subscription);
 		values.from.any.set(value, subscription);
 		values.to.any.set(subscription, value);
 		return;
 	}
+	/* istanbul ignore if */
 	if (items.keyed == null || values.from.keyed == null || values.to.keyed == null)
  // istanbul ignore next
 	return;
@@ -35,41 +37,31 @@ 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 getExistingSubscription(state) {
-	const { parameters } = state;
-	const { values } = parameters.subscriptions;
-	return parameters.key == null ? values.from.any.get(parameters.value) : values.from.keyed?.get(parameters.key)?.get(parameters.value);
-}
-function getSubscription(parameters) {
+function createSubscription(subscriptions, property, parameters) {
+	if (parameters.signal?.aborted ?? false) throw new Error(parameters.signal?.reason);
 	const state = {
 		parameters,
 		active: true
 	};
-	const existing = getExistingSubscription(state);
-	if (existing != null) return existing;
-	if (parameters.subscriptions.keys != null && parameters.key != null && !parameters.subscriptions.keys.has(parameters.key)) throw new Error();
-	const instance = { unsubscribe: () => {
-		removeSubscription(instance, state);
-	} };
+	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);
+	state.aborter = createAborter(parameters.signal, () => unsubscribe(subscriptions, instance, state));
+	const instance = { unsubscribe: () => unsubscribe(subscriptions, instance, state) };
 	Object.defineProperties(instance, {
-		[PROPERTY]: {
-			enumerable: false,
-			value: true
-		},
-		[parameters.property.key]: {
-			enumerable: false,
-			value: parameters.property.value
-		},
+		[SUBSCRIPTION_PROPERTY]: { value: true },
+		[property.key]: { value: property.value ?? "subscription" },
 		active: {
 			enumerable: true,
 			get: () => (parameters.isActive?.() ?? true) && state.active
 		}
 	});
-	addSubscription(instance, state);
-	return Object.freeze(instance);
+	addSubscription(subscriptions, instance, state);
+	return [Object.freeze(instance), false];
 }
-function getSubscriptions(keys) {
-	return {
+function createSubscriptions(parameters) {
+	const { keys, property } = parameters;
+	const state = {
 		keys,
 		items: {
 			any: /* @__PURE__ */ new Set(),
@@ -86,6 +78,17 @@ function getSubscriptions(keys) {
 			}
 		}
 	};
+	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?
@@ -94,7 +97,7 @@ function getSubscriptions(keys) {
 * @returns `true` if the value is a subscription, otherwise `false`
 */
 function isSubscription(value) {
-	return isPlainObject(value) && PROPERTY in value && value[PROPERTY] === true;
+	return isPlainObject(value) && SUBSCRIPTION_PROPERTY in value && value[SUBSCRIPTION_PROPERTY] === true;
 }
 function removeFromStore(items, values, subscription, value, key) {
 	items.delete(subscription);
@@ -106,22 +109,32 @@ function removeFromStore(items, values, subscription, value, key) {
 		values.to.keyed?.get(key)?.delete(subscription);
 	}
 }
-function removeSubscription(subscription, state) {
+function removeSubscription(subscriptions, subscription, state) {
 	if (!state.active) return;
+	state.aborter = void 0;
 	state.active = false;
-	const { key, subscriptions, value } = state.parameters;
-	const { items, values } = subscriptions;
-	if (key == null) {
+	state.parameters.isActive = void 0;
+	state.parameters.signal = void 0;
+	const { key, value } = state.parameters;
+	const { items, values } = subscriptions.state;
+	if (!isKey(key)) {
 		removeFromStore(items.any, values, subscription, value);
 		return;
 	}
 	const keyed = items.keyed?.get(key);
+	/* istanbul ignore if */
 	if (items.keyed == null || keyed == null)
  // istanbul ignore next
 	return;
 	removeFromStore(keyed, values, subscription, value, key);
 	if (keyed.size === 0) items.keyed.delete(key);
 }
-const PROPERTY = "$subscription";
+function unsubscribe(subscriptions, subscription, state) {
+	state.aborter?.cancel();
+	removeSubscription(subscriptions, subscription, state);
+}
+const SUBSCRIPTION_INVALID_KEY = "Invalid key for subscription";
+const SUBSCRIPTION_NAME = "subscription";
+const SUBSCRIPTION_PROPERTY = "$subscription";
 //#endregion
-export { clearSubscriptions, getSubscription, getSubscriptions, isSubscription };
+export { SUBSCRIPTION_NAME, createSubscriptions, isSubscription };

package/dist/internal/value/compare.mjs

@@ -1,5 +1,5 @@
 import { max } from "../math/aggregate.mjs";
-import { getString, words } from "../string.mjs";
+import { getString, words } from "../string/misc.mjs";
 import { getCompareHandlers } from "./handlers.mjs";
 //#region src/internal/value/compare.ts
 const COMPARE_NAME = "compare";