@oscarpalmer/atoms 0.193.1 → 0.194.0

package/dist/array/difference.mjs

@@ -1,7 +1,7 @@
-import { COMPARE_SETS_DIFFERENCE, compareSets } from "../internal/array/sets.mjs";
+import { SETS_COMPARE_DIFFERENCE, compareSets } from "../internal/array/sets.mjs";
 //#region src/array/difference.ts
 function difference(first, second, key) {
-	return compareSets(COMPARE_SETS_DIFFERENCE, first, second, key);
+	return compareSets(SETS_COMPARE_DIFFERENCE, first, second, key);
 }
 //#endregion
 export { difference };

package/dist/array/intersection.mjs

@@ -1,7 +1,7 @@
-import { COMPARE_SETS_INTERSECTION, compareSets } from "../internal/array/sets.mjs";
+import { SETS_COMPARE_INTERSECTION, compareSets } from "../internal/array/sets.mjs";
 //#region src/array/intersection.ts
 function intersection(first, second, key) {
-	return compareSets(COMPARE_SETS_INTERSECTION, first, second, key);
+	return compareSets(SETS_COMPARE_INTERSECTION, first, second, key);
 }
 //#endregion
 export { intersection };

package/dist/array/match.mjs

@@ -7,8 +7,8 @@ function getArrayComparison(haystack, needle, key) {
 	return getPosition(haystack, needle, key)[1];
 }
 function getName(start, haystack, needle) {
-	if (start === 0) return haystack === needle ? COMPARISON_SAME : COMPARISON_START;
-	return start + needle === haystack ? COMPARISON_END : COMPARISON_INSIDE;
+	if (start === 0) return haystack === needle ? MATCH_COMPARISON_SAME : MATCH_COMPARISON_START;
+	return start + needle === haystack ? MATCH_COMPARISON_END : MATCH_COMPARISON_INSIDE;
 }
 function getPosition(haystack, needle, key) {
 	if (!Array.isArray(haystack) || !Array.isArray(needle)) return invalid;
@@ -43,16 +43,16 @@ function indexOfArray(haystack, needle, key) {
 function startsWithArray(haystack, needle, key) {
 	return starts.has(getPosition(haystack, needle, key)[1]);
 }
-const COMPARISON_END = "end";
-const COMPARISON_INSIDE = "inside";
-const COMPARISON_INVALID = "invalid";
-const COMPARISON_OUTSIDE = "outside";
-const COMPARISON_SAME = "same";
-const COMPARISON_START = "start";
-const endings = /* @__PURE__ */ new Set([COMPARISON_END, COMPARISON_SAME]);
-const invalid = [-1, COMPARISON_INVALID];
-const outside = [-1, COMPARISON_OUTSIDE];
-const outsides = /* @__PURE__ */ new Set([COMPARISON_INVALID, COMPARISON_OUTSIDE]);
-const starts = /* @__PURE__ */ new Set([COMPARISON_START, COMPARISON_SAME]);
+const MATCH_COMPARISON_END = "end";
+const MATCH_COMPARISON_INSIDE = "inside";
+const MATCH_COMPARISON_INVALID = "invalid";
+const MATCH_COMPARISON_OUTSIDE = "outside";
+const MATCH_COMPARISON_SAME = "same";
+const MATCH_COMPARISON_START = "start";
+const endings = /* @__PURE__ */ new Set([MATCH_COMPARISON_END, MATCH_COMPARISON_SAME]);
+const invalid = [-1, MATCH_COMPARISON_INVALID];
+const outside = [-1, MATCH_COMPARISON_OUTSIDE];
+const outsides = /* @__PURE__ */ new Set([MATCH_COMPARISON_INVALID, MATCH_COMPARISON_OUTSIDE]);
+const starts = /* @__PURE__ */ new Set([MATCH_COMPARISON_START, MATCH_COMPARISON_SAME]);
 //#endregion
 export { endsWithArray, getArrayComparison, includesArray, indexOfArray, startsWithArray };

package/dist/array/slice.mjs

@@ -1,13 +1,13 @@
 import { getArrayCallbacks } from "../internal/array/callbacks.mjs";
 //#region src/array/slice.ts
 function drop(array, first, second) {
-	return extract(EXTRACT_DROP, array, first, second);
+	return extract(SLICE_DROP, array, first, second);
 }
 function extract(type, array, first, second) {
 	if (!Array.isArray(array)) return [];
 	const { length } = array;
 	if (length === 0) return [];
-	const isTake = type === EXTRACT_TAKE;
+	const isTake = type === SLICE_TAKE;
 	if (typeof first === "number") {
 		if (Math.abs(first) >= length) return isTake ? array.slice() : [];
 		if (first === 0) return isTake ? [] : array.slice();
@@ -45,9 +45,9 @@ function slice(array, first, second) {
 	return first >= 0 ? array.slice(first, second) : array.slice(array.length + first, array.length + second);
 }
 function take(array, first, second) {
-	return extract(EXTRACT_TAKE, array, first, second);
+	return extract(SLICE_TAKE, array, first, second);
 }
-const EXTRACT_DROP = "drop";
-const EXTRACT_TAKE = "take";
+const SLICE_DROP = "drop";
+const SLICE_TAKE = "take";
 //#endregion
 export { drop, slice, take };

package/dist/array/sort.d.mts

@@ -38,6 +38,10 @@ type ArrayKeySorters<Item extends PlainObject> = { [ItemKey in keyof Item]: Arra
  * Sorter to use for sorting
  */
 type ArraySorter<Item> = Item extends PlainObject ? keyof Item | ArrayComparisonSorter<Item> | ArrayKeySorters<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item> : ArrayComparisonSorter<Item> | ArrayValueSorter<Item> | ComparisonSorter<Item>;
+/**
+ * Sorters to use for sorting
+ */
+type ArraySorters<Item> = Array<ArraySorter<Item>>;
 /**
  * Sorting information for arrays _(using a value callback and built-in comparison)_
  */
@@ -244,4 +248,4 @@ declare namespace sort {
 declare const SORT_DIRECTION_ASCENDING: SortDirection;
 declare const SORT_DIRECTION_DESCENDING: SortDirection;
 //#endregion
-export { ArrayComparisonSorter, ArrayKeySorter, ArrayValueSorter, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SortDirection, Sorter, getSortedIndex, initializeSorter, isSorted, sort };
+export { ArrayComparisonSorter, ArrayKeySorter, ArraySorter, ArraySorters, ArrayValueSorter, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SortDirection, Sorter, getSortedIndex, initializeSorter, isSorted, sort };

package/dist/array/sort.mjs

@@ -85,8 +85,10 @@ function getValueSorter(value, modifier) {
 function initializeSorter(first, second) {
 	const sorters = getSorters(first, getModifier(first, second));
 	const sorter = (array) => sortArray(array, sorters);
-	sorter.index = (array, item) => getIndex(array, item, sorters);
-	sorter.is = (array) => isSortedArray(array, sorters);
+	Object.defineProperties(sorter, {
+		index: { value: (array, item) => getIndex(array, item, sorters) },
+		is: { value: (array) => isSortedArray(array, sorters) }
+	});
 	return sorter;
 }
 function isSorted(array, first, second) {

package/dist/array/union.mjs

@@ -1,7 +1,7 @@
-import { COMPARE_SETS_UNION, compareSets } from "../internal/array/sets.mjs";
+import { SETS_COMPARE_UNION, compareSets } from "../internal/array/sets.mjs";
 //#region src/array/union.ts
 function union(first, second, key) {
-	return compareSets(COMPARE_SETS_UNION, first, second, key);
+	return compareSets(SETS_COMPARE_UNION, first, second, key);
 }
 //#endregion
 export { union };

package/dist/beacon.d.mts

@@ -105,6 +105,13 @@ declare function beacon<Value>(value: Value, options?: BeaconOptions<Value>): Be
  * @returns `true` if the value is a beacon, otherwise `false`
  */
 declare function isBeacon<Value = unknown>(value: unknown): value is Beacon<Value>;
+/**
+ * Is the value a beacon subscription?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is a beacon subscription, otherwise `false`
+ */
+declare function isBeaconSubscription(value: unknown): value is Subscription;
 /**
  * Is the value an observable?
  *
@@ -113,4 +120,4 @@ declare function isBeacon<Value = unknown>(value: unknown): value is Beacon<Valu
  */
 declare function isObservable<Value = unknown>(value: unknown): value is Observable<Value>;
 //#endregion
-export { Beacon, BeaconOptions, Observable, beacon, isBeacon, isObservable };
+export { Beacon, BeaconOptions, Observable, beacon, isBeacon, isBeaconSubscription, isObservable };

package/dist/beacon.mjs

@@ -1,6 +1,6 @@
 import { noop } from "./internal/function/misc.mjs";
 import { isPlainObject } from "./internal/is.mjs";
-import { clearSubscriptions, getSubscription, getSubscriptions } from "./internal/subscription.mjs";
+import { createSubscriptions, isSubscription } from "./internal/subscription.mjs";
 //#region src/beacon.ts
 /**
 * Create a new beacon
@@ -15,38 +15,23 @@ function beacon(value, options) {
 		active: true,
 		observable: void 0,
 		options: getBeaconOptions(options),
-		subscriptions: getSubscriptions()
+		subscriptions: createSubscriptions({ property: beaconSubscription })
 	};
 	const instance = {
-		deactivate: () => {
-			finishBeacon(state, false);
-		},
-		emit: (value, finish) => {
-			update(TYPE_NEXT, state, value, finish);
-		},
-		error: (value, finish) => {
-			update(TYPE_ERROR, state, value, finish);
-		},
-		finish: () => {
-			finishBeacon(state, true);
-		}
+		deactivate: () => finishBeacon(state, false),
+		emit: (value, finish) => updateBeacon(BEACON_TYPE_NEXT, state, value, finish),
+		error: (value, finish) => updateBeacon(BEACON_TYPE_ERROR, state, value, finish),
+		finish: () => finishBeacon(state, true)
 	};
 	Object.defineProperties(instance, {
-		[KEY_BEACON]: {
-			enumerable: false,
-			value: NAME_BEACON
-		},
+		[BEACON_PROPERTY]: { value: BEACON_NAME },
 		active: {
 			enumerable: true,
 			get: () => state.active
 		},
 		observable: {
 			enumerable: true,
-			get: () => {
-				if (!state.active) throw new Error(MESSAGE_BEACON);
-				state.observable ??= observe(state);
-				return state.observable;
-			}
+			get: () => getObservable(state)
 		},
 		value: {
 			enumerable: true,
@@ -58,8 +43,8 @@ function beacon(value, options) {
 function finishBeacon(state, emit) {
 	if (!state.active) return;
 	state.active = false;
-	for (const [, observer] of state.subscriptions.values.to.any) if (emit) observer.complete?.();
-	clearSubscriptions(state.subscriptions);
+	for (const [, observer] of state.subscriptions.state.values.to.any) if (emit) observer.complete?.();
+	state.subscriptions.clear();
 	state.observable?.deactivate();
 	state.observable = void 0;
 }
@@ -68,6 +53,11 @@ function getBeaconOptions(input) {
 	options.equal = typeof options.equal === "function" ? options.equal : Object.is;
 	return options;
 }
+function getObservable(state) {
+	if (!state.active) throw new Error(BEACON_MESSAGE_RETRIEVE);
+	state.observable ??= observeBeacon(state);
+	return state.observable;
+}
 function getObservableCallback(value) {
 	return typeof value === "function" ? value : noop;
 }
@@ -92,10 +82,19 @@ function getObserver(first, second, third) {
 * @returns `true` if the value is a beacon, otherwise `false`
 */
 function isBeacon(value) {
-	return isBeaconInstance(NAME_BEACON, value);
+	return isBeaconInstance(BEACON_NAME, value);
 }
 function isBeaconInstance(name, value) {
-	return isPlainObject(value) && value[KEY_BEACON] === name;
+	return isPlainObject(value) && value[BEACON_PROPERTY] === name;
+}
+/**
+* Is the value a beacon subscription?
+*
+* @param value Value to check
+* @returns `true` if the value is a beacon subscription, otherwise `false`
+*/
+function isBeaconSubscription(value) {
+	return isSubscription(value) && value[BEACON_PROPERTY] === "subscription";
 }
 /**
 * Is the value an observable?
@@ -104,9 +103,9 @@ function isBeaconInstance(name, value) {
 * @returns `true` if the value is an observable, otherwise `false`
 */
 function isObservable(value) {
-	return isBeaconInstance(NAME_OBSERVABLE, value);
+	return isBeaconInstance(BEACON_OBSERVABLE, value);
 }
-function observe(beacon) {
+function observeBeacon(beacon) {
 	const state = {
 		beacon,
 		active: beacon.active
@@ -115,24 +114,10 @@ function observe(beacon) {
 		deactivate: () => {
 			state.active = false;
 		},
-		subscribe(first, second, third) {
-			if (!beacon.active || !state.active) throw new Error(MESSAGE_OBSERVABLE);
-			const observer = getObserver(first, second, third);
-			const subscription = getSubscription({
-				isActive: () => beacon.active && state.active,
-				property: beaconSubscription,
-				subscriptions: beacon.subscriptions,
-				value: observer
-			});
-			observer.next?.(beacon.value);
-			return subscription;
-		}
+		subscribe: (first, second, third) => subscribeToObservable(state, first, second, third)
 	};
 	Object.defineProperties(instance, {
-		[KEY_BEACON]: {
-			enumerable: false,
-			value: NAME_OBSERVABLE
-		},
+		[BEACON_PROPERTY]: { value: BEACON_OBSERVABLE },
 		active: {
 			enumerable: true,
 			get: () => beacon.active && state.active
@@ -140,25 +125,32 @@ function observe(beacon) {
 	});
 	return Object.freeze(instance);
 }
-function update(type, state, value, finish) {
+function subscribeToObservable(state, first, second, third) {
+	if (!state.beacon.active || !state.active) throw new Error(BEACON_MESSAGE_SUBSCRIBE);
+	const observer = getObserver(first, second, third);
+	const [subscription] = state.beacon.subscriptions.create({
+		isActive: () => state.beacon.active && state.active,
+		value: observer
+	});
+	observer.next?.(state.beacon.value);
+	return subscription;
+}
+function updateBeacon(type, state, value, finish) {
 	if (!state.active) return;
-	if (type === TYPE_NEXT) {
+	if (type === BEACON_TYPE_NEXT) {
 		if (state.options.equal(state.value, value)) return;
 		state.value = value;
 	}
-	for (const [, observer] of state.subscriptions.values.to.any) observer[type]?.(value);
+	for (const [, observer] of state.subscriptions.state.values.to.any) observer[type]?.(value);
 	if (finish === true) finishBeacon(state, true);
 }
-const KEY_BEACON = "$beacon";
-const MESSAGE_BEACON = "Cannot retrieve observable from a closed beacon";
-const MESSAGE_OBSERVABLE = "Cannot subscribe to a closed observable";
-const NAME_BEACON = "beacon";
-const NAME_OBSERVABLE = "observable";
-const TYPE_ERROR = "error";
-const TYPE_NEXT = "next";
-const beaconSubscription = {
-	key: KEY_BEACON,
-	value: "subscription"
-};
+const BEACON_MESSAGE_RETRIEVE = "Cannot retrieve observable from a closed beacon";
+const BEACON_MESSAGE_SUBSCRIBE = "Cannot subscribe to a closed observable";
+const BEACON_PROPERTY = "$beacon";
+const BEACON_NAME = "beacon";
+const BEACON_OBSERVABLE = "observable";
+const BEACON_TYPE_ERROR = "error";
+const BEACON_TYPE_NEXT = "next";
+const beaconSubscription = { key: BEACON_PROPERTY };
 //#endregion
-export { beacon, isBeacon, isObservable };
+export { beacon, isBeacon, isBeaconSubscription, isObservable };

package/dist/color/constants.d.mts

@@ -10,6 +10,7 @@ type ColorTypes = {
   hwba: 'hwba';
   rgb: 'rgb';
   rgba: 'rgba';
+  wildcard: '*';
 };
 declare const COLOR_ALPHA: {
   fullHexShort: string;
@@ -66,7 +67,6 @@ declare const COLOR_MAX: {
 };
 declare const COLOR_PROPERTY: {
   name: string;
-  subscription: string;
 };
 declare const COLOR_TYPE: ColorTypes;
 declare const COLOR_SRGB: {

package/dist/color/constants.mjs

@@ -67,10 +67,7 @@ const COLOR_MAX = {
 	hex: 255,
 	percent: 100
 };
-const COLOR_PROPERTY = {
-	name: "$color",
-	subscription: "subscription"
-};
+const COLOR_PROPERTY = { name: "$color" };
 const COLOR_TYPE = {
 	all: void 0,
 	hex: "hex",
@@ -80,7 +77,8 @@ const COLOR_TYPE = {
 	hwb: "hwb",
 	hwba: "hwba",
 	rgb: "rgb",
-	rgba: "rgba"
+	rgba: "rgba",
+	wildcard: "*"
 };
 COLOR_TYPE.all = /* @__PURE__ */ new Set([
 	COLOR_ALPHA.name,

package/dist/color/instance.mjs

@@ -1,55 +1,60 @@
-import { clearSubscriptions, getSubscription, getSubscriptions } from "../internal/subscription.mjs";
+import { herald } from "../herald.mjs";
 import { COLOR_PROPERTY, COLOR_TYPE } from "./constants.mjs";
 import { getAlpha } from "./misc/alpha.mjs";
 import { getColorFromState, getColorState, setHSLColor, setHWBColor, setHexColor, setRGBColor } from "./misc/state.mjs";
-import { formatHslColor, formatHwbColor, formatRgbColor } from "./misc/format.mjs";
+import { formatHexColor, formatHslColor, formatHwbColor, formatRgbColor } from "./misc/format.mjs";
 //#region src/color/instance.ts
 function color(value) {
+	const changes = herald({
+		names: [COLOR_TYPE.wildcard, ...COLOR_TYPE.all],
+		property: colorSubscription,
+		onCreate: (event, callback) => onCreateSubscription(instance, event, callback)
+	});
 	const state = getColorState(value);
-	const subscriptions = getSubscriptions(COLOR_TYPE.all);
 	const instance = {
-		subscribe: (first, second) => subscribeToColor(subscriptions, first, second),
-		toHexString: (alpha) => `#${alpha === true ? instance.hexa : instance.hex}`,
+		subscribe: (callback, signal) => changes.subscribe(COLOR_TYPE.wildcard, callback, signal),
+		toHexString: (alpha) => formatHexColor(instance, alpha),
 		toHslString: (alpha) => formatHslColor(state, alpha),
 		toHwbString: (alpha) => formatHwbColor(state, alpha),
 		toRgbString: (alpha) => formatRgbColor(state, alpha),
 		toString: () => instance.toHexString(),
-		unsubscribe: () => clearSubscriptions(subscriptions)
+		unsubscribe: () => changes.clear()
 	};
 	Object.defineProperties(instance, {
-		[COLOR_PROPERTY.name]: {
-			enumerable: false,
-			value: true
-		},
+		[COLOR_PROPERTY.name]: { value: true },
 		alpha: {
 			enumerable: true,
 			get: () => state.alpha.value,
 			set: (value) => setAlphaValue(state, value)
 		},
-		hex: getProperty(COLOR_TYPE.hex, instance, state, subscriptions, false),
-		hexa: getProperty(COLOR_TYPE.hex, instance, state, subscriptions, true),
-		hsl: getProperty(COLOR_TYPE.hsl, instance, state, subscriptions, false),
-		hsla: getProperty(COLOR_TYPE.hsl, instance, state, subscriptions, true),
-		hwb: getProperty(COLOR_TYPE.hwb, instance, state, subscriptions, false),
-		hwba: getProperty(COLOR_TYPE.hwb, instance, state, subscriptions, true),
+		changes: {
+			enumerable: true,
+			value: changes.events
+		},
+		hex: getColorProperty(COLOR_TYPE.hex, instance, state, changes, false),
+		hexa: getColorProperty(COLOR_TYPE.hex, instance, state, changes, true),
+		hsl: getColorProperty(COLOR_TYPE.hsl, instance, state, changes, false),
+		hsla: getColorProperty(COLOR_TYPE.hsl, instance, state, changes, true),
+		hwb: getColorProperty(COLOR_TYPE.hwb, instance, state, changes, false),
+		hwba: getColorProperty(COLOR_TYPE.hwb, instance, state, changes, true),
 		origin: {
 			enumerable: true,
 			get: () => state.origin
 		},
-		rgb: getProperty(COLOR_TYPE.rgb, instance, state, subscriptions, false),
-		rgba: getProperty(COLOR_TYPE.rgb, instance, state, subscriptions, true)
+		rgb: getColorProperty(COLOR_TYPE.rgb, instance, state, changes, false),
+		rgba: getColorProperty(COLOR_TYPE.rgb, instance, state, changes, true)
 	});
 	return Object.freeze(instance);
 }
-function getProperty(space, color, state, subscriptions, alpha) {
+function getColorProperty(space, color, state, changes, alpha) {
 	const setValue = setters[space];
 	return {
 		enumerable: true,
-		get: () => getValue(space, state, alpha),
-		set: (value) => setValue(color, state, subscriptions, value, alpha)
+		get: () => getColorValue(space, state, alpha),
+		set: (value) => setValue(color, state, changes, value, alpha)
 	};
 }
-function getValue(space, state, alpha) {
+function getColorValue(space, state, alpha) {
 	const value = getColorFromState(state, space);
 	if (typeof value === "string") return alpha ? `${value}${state.alpha.hex}` : value;
 	return alpha ? {
@@ -57,28 +62,16 @@ function getValue(space, state, alpha) {
 		alpha: state.alpha.value
 	} : { ...value };
 }
+function onCreateSubscription(instance, event, callback) {
+	let value;
+	if (event === COLOR_TYPE.wildcard) value = instance;
+	else value = instance[event];
+	callback(value);
+}
 function setAlphaValue(state, value) {
 	if (typeof value === "number" && !Number.isNaN(value)) state.alpha = getAlpha(value, false);
 }
-function subscribeToColor(subscriptions, first, second) {
-	let key;
-	let value;
-	if (typeof first === "string") {
-		key = first;
-		value = second;
-	} else if (typeof first === "function") value = first;
-	if (typeof value !== "function") throw new Error();
-	return getSubscription({
-		key,
-		subscriptions,
-		value,
-		property: colorSubscription
-	});
-}
-const colorSubscription = {
-	key: COLOR_PROPERTY.name,
-	value: COLOR_PROPERTY.subscription
-};
+const colorSubscription = { key: COLOR_PROPERTY.name };
 const setters = {
 	hex: setHexColor,
 	hsl: setHSLColor,

package/dist/color/misc/format.d.mts

@@ -1,7 +1,8 @@
-import { ColorState } from "../models.mjs";
+import { Color, ColorState } from "../models.mjs";
 //#region src/color/misc/format.d.ts
+declare function formatHexColor(color: Color, alpha?: boolean): string;
 declare function formatHslColor(state: ColorState, alpha?: boolean): string;
 declare function formatHwbColor(state: ColorState, alpha?: boolean): string;
 declare function formatRgbColor(state: ColorState, alpha?: boolean): string;
 //#endregion
-export { formatHslColor, formatHwbColor, formatRgbColor };
+export { formatHexColor, formatHslColor, formatHwbColor, formatRgbColor };

package/dist/color/misc/format.mjs

@@ -1,6 +1,9 @@
 import { COLOR_TYPE } from "../constants.mjs";
 import { getColorFromState } from "./state.mjs";
 //#region src/color/misc/format.ts
+function formatHexColor(color, alpha) {
+	return `#${alpha === true ? color.hexa : color.hex}`;
+}
 function formatHslColor(state, alpha) {
 	const { hue, lightness, saturation } = getColorFromState(state, COLOR_TYPE.hsl);
 	return `hsl(${hue}deg ${saturation}% ${lightness}%${getSuffix(state, alpha)})`;
@@ -17,4 +20,4 @@ function getSuffix(state, alpha) {
 	return alpha === true ? ` / ${state.alpha.value}%` : "";
 }
 //#endregion
-export { formatHslColor, formatHwbColor, formatRgbColor };
+export { formatHexColor, formatHslColor, formatHwbColor, formatRgbColor };

package/dist/color/misc/is.d.mts

@@ -1,3 +1,4 @@
+import { Subscription } from "../../internal/subscription.mjs";
 import { Color, HSLAColor, HSLColor, HWBAColor, HWBColor, RGBAColor, RGBColor } from "../models.mjs";
 //#region src/color/misc/is.d.ts
 /**
@@ -7,6 +8,13 @@ import { Color, HSLAColor, HSLColor, HWBAColor, HWBColor, RGBAColor, RGBColor }
  * @returns `true` if the value is a _Color_, otherwise `false`
  */
 declare function isColor(value: unknown): value is Color;
+/**
+ * Is the value a color subscription?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is a color subscription, otherwise `false`
+ */
+declare function isColorSubscription(value: unknown): value is Subscription;
 /**
  * Is the value a hex color?
  *
@@ -73,4 +81,4 @@ declare function isRgbaLike(value: unknown): value is Record<keyof RGBAColor, un
 declare function isRgbColor(value: unknown): value is RGBColor;
 declare function isRgbLike(value: unknown): value is Record<keyof RGBColor, unknown>;
 //#endregion
-export { isColor, isHexColor, isHslColor, isHslLike, isHslaColor, isHslaLike, isHwbColor, isHwbLike, isHwbaColor, isHwbaLike, isRgbColor, isRgbLike, isRgbaColor, isRgbaLike };
+export { isColor, isColorSubscription, isHexColor, isHslColor, isHslLike, isHslaColor, isHslaLike, isHwbColor, isHwbLike, isHwbaColor, isHwbaLike, isRgbColor, isRgbLike, isRgbaColor, isRgbaLike };

package/dist/color/misc/is.mjs

@@ -1,4 +1,5 @@
 import { isPlainObject } from "../../internal/is.mjs";
+import { isSubscription } from "../../internal/subscription.mjs";
 import { between } from "../../internal/number.mjs";
 import { COLOR_ALPHA, COLOR_EXPRESSION, COLOR_KEYS, COLOR_LENGTHS, COLOR_MAX, COLOR_PROPERTY } from "../constants.mjs";
 //#region src/color/misc/is.ts
@@ -20,6 +21,15 @@ function isBytey(value) {
 function isColor(value) {
 	return isPlainObject(value) && COLOR_PROPERTY.name in value && value[COLOR_PROPERTY.name] === true;
 }
+/**
+* Is the value a color subscription?
+*
+* @param value Value to check
+* @returns `true` if the value is a color subscription, otherwise `false`
+*/
+function isColorSubscription(value) {
+	return isSubscription(value) && value[COLOR_PROPERTY.name] === "subscription";
+}
 function isColorValue(obj, properties) {
 	if (typeof obj !== "object" || obj === null) return false;
 	const keys = Object.keys(obj);
@@ -146,4 +156,4 @@ const validators = {
 	whiteness: isPercentage
 };
 //#endregion
-export { isColor, isHexColor, isHslColor, isHslLike, isHslaColor, isHslaLike, isHwbColor, isHwbLike, isHwbaColor, isHwbaLike, isRgbColor, isRgbLike, isRgbaColor, isRgbaLike };
+export { isColor, isColorSubscription, isHexColor, isHslColor, isHslLike, isHslaColor, isHslaLike, isHwbColor, isHwbLike, isHwbaColor, isHwbaLike, isRgbColor, isRgbLike, isRgbaColor, isRgbaLike };

package/dist/color/misc/state.d.mts

@@ -1,11 +1,11 @@
-import { Subscriptions } from "../../internal/subscription.mjs";
-import { Color, ColorState, ColorType } from "../models.mjs";
+import { Herald } from "../../herald.mjs";
+import { Color, ColorChanges, ColorState, ColorType } from "../models.mjs";
 //#region src/color/misc/state.d.ts
 declare function getColorFromState<Type extends ColorType>(state: ColorState, type: Type): NonNullable<ColorState[Type]>;
 declare function getColorState(value: unknown): ColorState;
-declare function setHexColor(color: Color, state: ColorState, subscriptions: Subscriptions<Function>, value: string, alpha: boolean): void;
-declare function setHSLColor(color: Color, state: ColorState, subscriptions: Subscriptions<Function>, value: unknown, alpha: boolean): void;
-declare function setHWBColor(color: Color, state: ColorState, subscriptions: Subscriptions<Function>, value: unknown, alpha: boolean): void;
-declare function setRGBColor(color: Color, state: ColorState, subscriptions: Subscriptions<Function>, value: unknown, alpha: boolean): void;
+declare function setHexColor(color: Color, state: ColorState, changes: Herald<ColorChanges>, value: string, alpha: boolean): void;
+declare function setHSLColor(color: Color, state: ColorState, changes: Herald<ColorChanges>, value: unknown, alpha: boolean): void;
+declare function setHWBColor(color: Color, state: ColorState, changes: Herald<ColorChanges>, value: unknown, alpha: boolean): void;
+declare function setRGBColor(color: Color, state: ColorState, changes: Herald<ColorChanges>, value: unknown, alpha: boolean): void;
 //#endregion
 export { getColorFromState, getColorState, setHSLColor, setHWBColor, setHexColor, setRGBColor };

package/dist/color/misc/state.mjs

@@ -59,7 +59,7 @@ function getDefaultColorState() {
 		origin: COLOR_TYPE.hex
 	};
 }
-function setColorValue(color, state, subscriptions, type, value, alpha) {
+function setColorValue(color, state, changes, type, value, alpha) {
 	state.hex = void 0;
 	state.hsl = void 0;
 	state.hwb = void 0;
@@ -67,36 +67,33 @@ function setColorValue(color, state, subscriptions, type, value, alpha) {
 	state.origin = type;
 	state[type] = value;
 	if (alpha != null) state.alpha = getAlpha(alpha, type === COLOR_TYPE.hex);
-	for (const type of COLOR_TYPE.all) {
-		const callbacks = subscriptions.values.to.keyed?.get(type);
-		if (callbacks != null) for (const callback of callbacks.values()) callback(color[type]);
-	}
-	for (const callback of subscriptions.values.to.any.values()) callback(color);
+	for (const type of COLOR_TYPE.all) if (changes.observed(type)) changes.emit(type, color[type]);
+	changes.emit(COLOR_TYPE.wildcard, color);
 }
-function setHexColor(color, state, subscriptions, value, alpha) {
+function setHexColor(color, state, changes, value, alpha) {
 	if (!isHexColor(value) || !alpha && value === state.hex) return;
 	const normalized = getNormalizedHex(value, true);
-	setColorValue(color, state, subscriptions, COLOR_TYPE.hex, normalized.slice(0, COLOR_LENGTHS.hexLong), alpha ? normalized.slice(COLOR_LENGTHS.hexLong) : void 0);
+	setColorValue(color, state, changes, COLOR_TYPE.hex, normalized.slice(0, COLOR_LENGTHS.hexLong), alpha ? normalized.slice(COLOR_LENGTHS.hexLong) : void 0);
 }
-function setHSLColor(color, state, subscriptions, value, alpha) {
+function setHSLColor(color, state, changes, value, alpha) {
 	if (!isHslLike(value)) return;
-	setColorValue(color, state, subscriptions, COLOR_TYPE.hsl, {
+	setColorValue(color, state, changes, COLOR_TYPE.hsl, {
 		hue: getDegrees(value.hue),
 		saturation: getPercentage(value.saturation),
 		lightness: getPercentage(value.lightness)
 	}, alpha ? value.alpha : void 0);
 }
-function setHWBColor(color, state, subscriptions, value, alpha) {
+function setHWBColor(color, state, changes, value, alpha) {
 	if (!isHwbLike(value)) return;
-	setColorValue(color, state, subscriptions, COLOR_TYPE.hwb, {
+	setColorValue(color, state, changes, COLOR_TYPE.hwb, {
 		hue: getDegrees(value.hue),
 		whiteness: getPercentage(value.whiteness),
 		blackness: getPercentage(value.blackness)
 	}, alpha ? value.alpha : void 0);
 }
-function setRGBColor(color, state, subscriptions, value, alpha) {
+function setRGBColor(color, state, changes, value, alpha) {
 	if (!isRgbLike(value)) return;
-	setColorValue(color, state, subscriptions, COLOR_TYPE.rgb, {
+	setColorValue(color, state, changes, COLOR_TYPE.rgb, {
 		red: getHexValue(value.red),
 		green: getHexValue(value.green),
 		blue: getHexValue(value.blue)