@oscarpalmer/atoms 0.191.0 → 0.192.0

package/dist/index.mjs

@@ -2289,6 +2289,131 @@ const MESSAGE = "Herald requires an array of event names.";
 const NAME_EVENTS = "events";
 const NAME_HERALD = "herald";
 //#endregion
+//#region src/internal/subscription.ts
+function addSubscription(subscription, state) {
+	const { key, subscriptions, value } = state.parameters;
+	const { items, values } = subscriptions;
+	if (key == null) {
+		items.any.add(subscription);
+		values.from.any.set(value, subscription);
+		values.to.any.set(subscription, value);
+		return;
+	}
+	if (items.keyed == null || values.from.keyed == null || values.to.keyed == null)
+ // istanbul ignore next
+	return;
+	let keyedItems = items.keyed.get(key);
+	if (keyedItems == null) {
+		keyedItems = /* @__PURE__ */ new Set();
+		items.keyed.set(key, keyedItems);
+	}
+	keyedItems.add(subscription);
+	let keyedFrom = values.from.keyed.get(key);
+	if (keyedFrom == null) {
+		keyedFrom = /* @__PURE__ */ new Map();
+		values.from.keyed.set(key, keyedFrom);
+	}
+	keyedFrom.set(value, subscription);
+	let keyedTo = values.to.keyed.get(key);
+	if (keyedTo == null) {
+		keyedTo = /* @__PURE__ */ new Map();
+		values.to.keyed.set(key, keyedTo);
+	}
+	keyedTo.set(subscription, 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 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) {
+	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);
+	} };
+	Object.defineProperties(instance, {
+		[PROPERTY]: {
+			enumerable: false,
+			value: true
+		},
+		[parameters.property.key]: {
+			enumerable: false,
+			value: parameters.property.value
+		},
+		active: {
+			enumerable: true,
+			get: () => (parameters.isActive?.() ?? true) && state.active
+		}
+	});
+	addSubscription(instance, state);
+	return Object.freeze(instance);
+}
+function getSubscriptions(keys) {
+	return {
+		keys,
+		items: {
+			any: /* @__PURE__ */ new Set(),
+			keyed: keys == null ? void 0 : /* @__PURE__ */ new Map()
+		},
+		values: {
+			from: {
+				any: /* @__PURE__ */ new Map(),
+				keyed: keys == null ? void 0 : /* @__PURE__ */ new Map()
+			},
+			to: {
+				any: /* @__PURE__ */ new Map(),
+				keyed: keys == null ? void 0 : /* @__PURE__ */ new Map()
+			}
+		}
+	};
+}
+/**
+* Is the value a subscription?
+*
+* @param value Value to check
+* @returns `true` if the value is a subscription, otherwise `false`
+*/
+function isSubscription(value) {
+	return isPlainObject(value) && PROPERTY in value && value[PROPERTY] === true;
+}
+function removeFromStore(items, values, subscription, value, key) {
+	items.delete(subscription);
+	if (key == null) {
+		values.from.any.delete(value);
+		values.to.any.delete(subscription);
+	} else {
+		values.from.keyed?.get(key)?.delete(value);
+		values.to.keyed?.get(key)?.delete(subscription);
+	}
+}
+function removeSubscription(subscription, state) {
+	if (!state.active) return;
+	state.active = false;
+	const { key, subscriptions, value } = state.parameters;
+	const { items, values } = subscriptions;
+	if (key == null) {
+		removeFromStore(items.any, values, subscription, value);
+		return;
+	}
+	const keyed = items.keyed?.get(key);
+	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";
+//#endregion
 //#region src/internal/value/equal.ts
 /**
 * Deregister a equality comparison handler for a specific class
@@ -2633,125 +2758,6 @@ let memoizedLowerCase;
 let memoizedTitleCase;
 let memoizedUpperCase;
 //#endregion
-//#region src/is.ts
-/**
-* Is the value empty, or only containing `null` or `undefined` values?
-*
-* @param value Value to check
-* @returns `true` if the value is considered empty, otherwise `false`
-*/
-function isEmpty(value) {
-	if (value == null) return true;
-	if (typeof value === "string") return value.length === 0;
-	const values = getArray(value);
-	const { length } = values;
-	for (let index = 0; index < length; index += 1) {
-		const item = values[index];
-		if (Array.isArray(item) ? item[1] != null : item != null) return false;
-	}
-	return true;
-}
-/**
-* Is the value not empty, or holding non-empty values?
-*
-* @param value Value to check
-* @returns `true` if the value is not considered empty, otherwise `false`
-*/
-function isNonEmpty(value) {
-	return !isEmpty(value);
-}
-/**
-* Is the value not `undefined` or `null`?
-*
-* @param value Value to check
-* @returns `true` if the value is not `undefined` or `null`, otherwise `false`
-*/
-function isNonNullable(value) {
-	return value != null;
-}
-/**
-* Is the value not `undefined`, `null`, or stringified as an empty _(no whitespace)_ string?
-*
-* @param value Value to check
-* @returns `true` if the value is not `undefined`, `null`, or matches an empty string, otherwise `false`
-*/
-function isNonNullableOrEmpty(value) {
-	return value != null && getString(value) !== "";
-}
-/**
-* Is the value not `undefined`, `null`, or stringified as a whitespace-only string?
-*
-* @param value Value to check
-* @returns `true` if the value is not `undefined`, `null`, or matches a whitespace-only string, otherwise `false`
-*/
-function isNonNullableOrWhitespace(value) {
-	return value != null && !EXPRESSION_WHITESPACE.test(getString(value));
-}
-/**
-* Is the value not a number or a number-like string?
-*
-* @param value Value to check
-* @returns `true` if the value is not a number or a number-like string, otherwise `false`
-*/
-function isNonNumerical(value) {
-	return !isNumerical(value);
-}
-/**
-* Is the value not an object _(or function)_?
-*
-* @param value Value to check
-* @returns `true` if the value is not an object, otherwise `false`
-*/
-function isNonObject(value) {
-	return !isObject(value);
-}
-/**
-* Is the value `undefined` or `null`?
-*
-* @param value Value to check
-* @returns `true` if the value is `undefined` or `null`, otherwise `false`
-*/
-function isNullable(value) {
-	return value == null;
-}
-/**
-* Is the value `undefined`, `null`, or stringified as an empty _(no whitespace)_ string?
-*
-* @param value Value to check
-* @returns `true` if the value is nullable or matches an empty string, otherwise `false`
-*/
-function isNullableOrEmpty(value) {
-	return value == null || getString(value) === "";
-}
-/**
-* Is the value `undefined`, `null`, or stringified as a whitespace-only string?
-*
-* @param value Value to check
-* @returns `true` if the value is nullable or matches a whitespace-only string, otherwise `false`
-*/
-function isNullableOrWhitespace(value) {
-	return value == null || EXPRESSION_WHITESPACE.test(getString(value));
-}
-/**
-* Is the value a number or a number-like string?
-*
-* @param value Value to check
-* @returns `true` if the value is a number or a number-like string, otherwise `false`
-*/
-function isNumerical(value) {
-	return isNumber(value) || typeof value === "string" && value.trim().length > 0 && !Number.isNaN(+value);
-}
-/**
-* Is the value an object _(or function)_?
-*
-* @param value Value to check
-* @returns `true` if the value matches, otherwise `false`
-*/
-function isObject(value) {
-	return typeof value === "object" && value !== null || typeof value === "function";
-}
-const EXPRESSION_WHITESPACE = /^\s*$/;
-//#endregion
 //#region src/string/match.ts
 /**
 * Check if a string ends with a specified substring
@@ -3820,11 +3826,11 @@ function beacon(value, options) {
 		value,
 		active: true,
 		observable: void 0,
-		observers: /* @__PURE__ */ new Map(),
-		options: getBeaconOptions(options)
+		options: getBeaconOptions(options),
+		subscriptions: getSubscriptions()
 	};
 	const instance = {
-		close: () => {
+		deactivate: () => {
 			finishBeacon(state, false);
 		},
 		emit: (value, finish) => {
@@ -3846,10 +3852,6 @@ function beacon(value, options) {
 			enumerable: true,
 			get: () => state.active
 		},
-		closed: {
-			enumerable: true,
-			get: () => !state.active
-		},
 		observable: {
 			enumerable: true,
 			get: () => {
@@ -3868,15 +3870,9 @@ function beacon(value, options) {
 function finishBeacon(state, emit) {
 	if (!state.active) return;
 	state.active = false;
-	const entries = [...state.observers.entries()];
-	const { length } = entries;
-	for (let index = 0; index < length; index += 1) {
-		const [subscription, observer] = entries[index];
-		if (emit) observer.complete?.();
-		subscription.close();
-	}
-	state.observable?.close();
-	state.observers.clear();
+	for (const [, observer] of state.subscriptions.values.to.any) if (emit) observer.complete?.();
+	clearSubscriptions(state.subscriptions);
+	state.observable?.deactivate();
 	state.observable = void 0;
 }
 function getBeaconOptions(input) {
@@ -3922,29 +3918,24 @@ function isBeaconInstance(name, value) {
 function isObservable(value) {
 	return isBeaconInstance(NAME_OBSERVABLE, value);
 }
-/**
-* Is the value a subscription?
-*
-* @param value Value to check
-* @returns `true` if the value is a subscription, otherwise `false`
-*/
-function isSubscription(value) {
-	return isBeaconInstance(NAME_SUBSCRIPTION, value);
-}
 function observe(beacon) {
 	const state = {
 		beacon,
 		active: beacon.active
 	};
 	const instance = {
-		close: () => {
+		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 = subscribe(state);
-			beacon.observers.set(subscription, observer);
+			const subscription = getSubscription({
+				isActive: () => beacon.active && state.active,
+				property: beaconSubscription,
+				subscriptions: beacon.subscriptions,
+				value: observer
+			});
 			observer.next?.(beacon.value);
 			return subscription;
 		}
@@ -3957,42 +3948,6 @@ function observe(beacon) {
 		active: {
 			enumerable: true,
 			get: () => beacon.active && state.active
-		},
-		closed: {
-			enumerable: true,
-			get: () => !beacon.active || !state.active
-		}
-	});
-	return Object.freeze(instance);
-}
-function subscribe(observable) {
-	function unsubscribe() {
-		if (active) {
-			active = false;
-			observable.beacon.observers.delete(instance);
-		}
-	}
-	let active = true;
-	const instance = {
-		close: () => {
-			unsubscribe();
-		},
-		unsubscribe: () => {
-			unsubscribe();
-		}
-	};
-	Object.defineProperties(instance, {
-		[KEY_BEACON]: {
-			enumerable: false,
-			value: NAME_SUBSCRIPTION
-		},
-		active: {
-			enumerable: true,
-			get: () => observable.beacon.active && observable.active && active
-		},
-		closed: {
-			enumerable: true,
-			get: () => !observable.beacon.active || !observable.active || !active
 		}
 	});
 	return Object.freeze(instance);
@@ -4003,7 +3958,7 @@ function update$1(type, state, value, finish) {
 		if (state.options.equal(state.value, value)) return;
 		state.value = value;
 	}
-	for (const [, observer] of state.observers) observer[type]?.(value);
+	for (const [, observer] of state.subscriptions.values.to.any) observer[type]?.(value);
 	if (finish === true) finishBeacon(state, true);
 }
 const KEY_BEACON = "$beacon";
@@ -4011,58 +3966,119 @@ 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 NAME_SUBSCRIPTION = "subscription";
 const TYPE_ERROR = "error";
 const TYPE_NEXT = "next";
-const ALPHA_FULL_HEX_LONG = `ff`;
-const DEFAULT_ALPHA = {
-	hex: ALPHA_FULL_HEX_LONG,
-	value: 100
+const beaconSubscription = {
+	key: KEY_BEACON,
+	value: "subscription"
 };
-const DEFAULT_HSL = {
-	hue: 0,
-	saturation: 0,
-	lightness: 0
+//#endregion
+//#region src/color/constants.ts
+const COLOR_ALPHA = {
+	fullHexShort: "f",
+	fullHexLong: "ff",
+	name: "alpha",
+	noneHex: "00",
+	noneValue: 0
 };
-const DEFAULT_HWB = {
-	hue: 0,
-	whiteness: 0,
-	blackness: 100
+const COLOR_DEFAULTS = {
+	alpha: {
+		hex: COLOR_ALPHA.fullHexLong,
+		value: 100
+	},
+	hexBlack: "000000",
+	hexWhite: "ffffff",
+	hsl: {
+		hue: 0,
+		saturation: 0,
+		lightness: 0
+	},
+	hwb: {
+		hue: 0,
+		whiteness: 0,
+		blackness: 100
+	},
+	rgb: {
+		blue: 0,
+		green: 0,
+		red: 0
+	}
 };
-const DEFAULT_RGB = {
-	blue: 0,
-	green: 0,
-	red: 0
+const COLOR_EXPRESSION = {
+	alphaHex: /^([a-f0-9]{1,2})$/i,
+	hexLong: /^#?([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})?$/i,
+	hexShort: /^#?([a-f0-9]{3,4})$/i,
+	prefix: /^#/
+};
+const COLOR_LENGTHS = {
+	hexLong: 6,
+	hexShort: 3
+};
+const COLOR_KEYS = {
+	hsl: [
+		"hue",
+		"saturation",
+		"lightness"
+	],
+	hsla: [],
+	hwb: [
+		"hue",
+		"whiteness",
+		"blackness"
+	],
+	hwba: [],
+	rgb: [
+		"red",
+		"green",
+		"blue"
+	],
+	rgba: []
+};
+COLOR_KEYS.hsla = [...COLOR_KEYS.hsl, COLOR_ALPHA.name];
+COLOR_KEYS.hwba = [...COLOR_KEYS.hwb, COLOR_ALPHA.name];
+COLOR_KEYS.rgba = [...COLOR_KEYS.rgb, COLOR_ALPHA.name];
+const COLOR_MAX = {
+	degree: 360,
+	hex: 255,
+	percent: 100
+};
+const COLOR_PROPERTY = {
+	name: "$color",
+	subscription: "subscription"
+};
+const COLOR_TYPE = {
+	all: void 0,
+	hex: "hex",
+	hexa: "hexa",
+	hsl: "hsl",
+	hsla: "hsla",
+	hwb: "hwb",
+	hwba: "hwba",
+	rgb: "rgb",
+	rgba: "rgba"
+};
+COLOR_TYPE.all = /* @__PURE__ */ new Set([
+	COLOR_ALPHA.name,
+	COLOR_TYPE.hex,
+	COLOR_TYPE.hexa,
+	COLOR_TYPE.hsl,
+	COLOR_TYPE.hsla,
+	COLOR_TYPE.hwb,
+	COLOR_TYPE.hwba,
+	COLOR_TYPE.rgb,
+	COLOR_TYPE.rgba
+]);
+const COLOR_SRGB = {
+	luminanceBlue: .0722,
+	luminanceExponent: 2.4,
+	luminanceGreen: .7152,
+	luminanceMinimum: .03928,
+	luminanceModifier: 1.055,
+	luminanceMultiplier: 12.92,
+	luminanceOffset: .055,
+	luminanceRed: .2126,
+	luminanceThreshold: .625
 };
-const EXPRESSION_ALPHA_HEX = /^([a-f0-9]{1,2})$/i;
-const EXPRESSION_HEX_LONG = /^#?([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})([a-f0-9]{2})?$/i;
-const EXPRESSION_HEX_SHORT = /^#?([a-f0-9]{3,4})$/i;
-const EXPRESSION_PREFIX = /^#/;
-const HEX_BLACK = "000000";
-const HEX_WHITE = "ffffff";
-const KEYS_HSL = [
-	"hue",
-	"saturation",
-	"lightness"
-];
-const KEYS_HSLA = [...KEYS_HSL, "alpha"];
-const KEYS_HWB = [
-	"hue",
-	"whiteness",
-	"blackness"
-];
-const KEYS_HWBA = [...KEYS_HWB, "alpha"];
-const KEYS_RGB = [
-	"red",
-	"green",
-	"blue"
-];
-const KEYS_RGBA = [...KEYS_RGB, "alpha"];
-const PROPERTY_COLOR = "$color";
-const SRGB_LUMINANCE_EXPONENT = 2.4;
-const SRGB_LUMINANCE_MODIFIER = 1.055;
-const SRGB_LUMINANCE_MULTIPLIER = 12.92;
-const SRGB_LUMINANCE_OFFSET = .055;
 //#endregion
 //#region src/internal/math/misc.ts
 /**
@@ -4085,17 +4101,17 @@ function roundNumber(callback, value, decimals) {
 //#region src/color/misc/alpha.ts
 function getAlpha(value, hex) {
 	if (typeof value === "number") return getAlphaFromValue(value);
-	if (typeof value !== "string" || value.toLowerCase() === ALPHA_FULL_HEX_LONG) return { ...DEFAULT_ALPHA };
-	if (hex && EXPRESSION_ALPHA_HEX.test(value)) return {
+	if (typeof value !== "string" || value.toLowerCase() === COLOR_ALPHA.fullHexLong) return { ...COLOR_DEFAULTS.alpha };
+	if (hex && COLOR_EXPRESSION.alphaHex.test(value)) return {
 		hex: value,
-		value: Number.parseInt(value, 16) / 255
+		value: Number.parseInt(value, 16) / COLOR_MAX.hex
 	};
 	return getAlphaFromValue(Number.parseFloat(value));
 }
 function getAlphaHexadecimal(value) {
-	if (value === 0) return "00";
-	if (value === 100) return ALPHA_FULL_HEX_LONG;
-	return round(value / 100 * 255).toString(16);
+	if (value === COLOR_ALPHA.noneValue) return COLOR_ALPHA.noneHex;
+	if (value === COLOR_MAX.percent) return COLOR_ALPHA.fullHexLong;
+	return round(value / COLOR_MAX.percent * COLOR_MAX.hex).toString(16);
 }
 function getAlphaFromValue(value) {
 	const alpha = getAlphaValue(value);
@@ -4105,8 +4121,8 @@ function getAlphaFromValue(value) {
 	};
 }
 function getAlphaValue(original) {
-	if (Number.isNaN(original)) return 100;
-	return clamp(original, 0, 100);
+	if (Number.isNaN(original)) return COLOR_MAX.percent;
+	return clamp(original, COLOR_ALPHA.noneValue, COLOR_MAX.percent);
 }
 //#endregion
 //#region src/color/misc/get.ts
@@ -4114,19 +4130,19 @@ function getClampedValue(value, minimum, maximum, rounding) {
 	return typeof value === "number" && !Number.isNaN(value) ? clamp(rounding ?? false ? round(value) : value, minimum, maximum) : minimum;
 }
 function getForegroundColor(value, hex) {
-	const { blue, green, red } = getColorFromState(getColorState(value), "rgb");
+	const { blue, green, red } = getColorFromState(getColorState(value), COLOR_TYPE.rgb);
 	const values = [
-		blue / 255,
-		green / 255,
-		red / 255
+		blue / COLOR_MAX.hex,
+		green / COLOR_MAX.hex,
+		red / COLOR_MAX.hex
 	];
 	const { length } = values;
 	for (let index = 0; index < length; index += 1) {
 		const color = values[index];
-		if (color <= .03928) values[index] /= SRGB_LUMINANCE_MULTIPLIER;
-		else values[index] = ((color + SRGB_LUMINANCE_OFFSET) / SRGB_LUMINANCE_MODIFIER) ** SRGB_LUMINANCE_EXPONENT;
+		if (color <= COLOR_SRGB.luminanceMinimum) values[index] /= COLOR_SRGB.luminanceMultiplier;
+		else values[index] = ((color + COLOR_SRGB.luminanceOffset) / COLOR_SRGB.luminanceModifier) ** COLOR_SRGB.luminanceExponent;
 	}
-	const foreground = .2126 * values[2] + .7152 * values[1] + .0722 * values[0] > .625 ? HEX_BLACK : HEX_WHITE;
+	const foreground = COLOR_SRGB.luminanceRed * values[2] + COLOR_SRGB.luminanceGreen * values[1] + COLOR_SRGB.luminanceBlue * values[0] > COLOR_SRGB.luminanceThreshold ? COLOR_DEFAULTS.hexBlack : COLOR_DEFAULTS.hexWhite;
 	return hex === true ? foreground : color(foreground);
 }
 /**
@@ -4152,13 +4168,13 @@ function getHexaColor(value) {
 * @returns Hex color string
 */
 function getHexColor(value) {
-	return getColorFromState(getColorState(value), "hex");
+	return getColorFromState(getColorState(value), COLOR_TYPE.hex);
 }
 function getHexValue(value) {
-	return getClampedValue(value, 0, 255, true);
+	return getClampedValue(value, 0, COLOR_MAX.hex, true);
 }
 function getDegrees(value) {
-	return getClampedValue(value, 0, 360);
+	return getClampedValue(value, 0, COLOR_MAX.degree);
 }
 /**
 * Get the _HSLA_ color from any kind of value
@@ -4172,7 +4188,7 @@ function getDegrees(value) {
 function getHslaColor(value) {
 	const state = getColorState(value);
 	return {
-		...getColorFromState(state, "hsl"),
+		...getColorFromState(state, COLOR_TYPE.hsl),
 		alpha: state.alpha.value
 	};
 }
@@ -4186,7 +4202,7 @@ function getHslaColor(value) {
 * @returns _HWB_ color
 */
 function getHwbColor(value) {
-	return getColorFromState(getColorState(value), "hwb");
+	return getColorFromState(getColorState(value), COLOR_TYPE.hwb);
 }
 /**
 * Get the _HWBA_ color from any kind of value
@@ -4200,7 +4216,7 @@ function getHwbColor(value) {
 function getHwbaColor(value) {
 	const state = getColorState(value);
 	return {
-		...getColorFromState(state, "hwb"),
+		...getColorFromState(state, COLOR_TYPE.hwb),
 		alpha: state.alpha.value
 	};
 }
@@ -4214,10 +4230,10 @@ function getHwbaColor(value) {
 * @returns _HSL_ color
 */
 function getHslColor(value) {
-	return getColorFromState(getColorState(value), "hsl");
+	return getColorFromState(getColorState(value), COLOR_TYPE.hsl);
 }
 function getPercentage(value) {
-	return getClampedValue(value, 0, 100);
+	return getClampedValue(value, 0, COLOR_MAX.percent);
 }
 /**
 * Get the _RGBA_ color from any kind of value
@@ -4231,7 +4247,7 @@ function getPercentage(value) {
 function getRgbaColor(value) {
 	const state = getColorState(value);
 	return {
-		...getColorFromState(state, "rgb"),
+		...getColorFromState(state, COLOR_TYPE.rgb),
 		alpha: state.alpha.value
 	};
 }
@@ -4245,7 +4261,7 @@ function getRgbaColor(value) {
 * @returns _RGB_ color
 */
 function getRgbColor(value) {
-	return getColorFromState(getColorState(value), "rgb");
+	return getColorFromState(getColorState(value), COLOR_TYPE.rgb);
 }
 //#endregion
 //#region src/color/misc/is.ts
@@ -4253,10 +4269,10 @@ function hasKeys(value, keys) {
 	return typeof value === "object" && value !== null && keys.every((key) => key in value);
 }
 function isAlpha(value) {
-	return typeof value === "number" && between(value, 0, 100);
+	return typeof value === "number" && between(value, COLOR_ALPHA.noneValue, COLOR_MAX.percent);
 }
 function isBytey(value) {
-	return typeof value === "number" && between(value, 0, 255);
+	return typeof value === "number" && between(value, 0, COLOR_MAX.hex);
 }
 /**
 * Is the value a _Color_?
@@ -4265,7 +4281,7 @@ function isBytey(value) {
 * @returns `true` if the value is a _Color_, otherwise `false`
 */
 function isColor(value) {
-	return typeof value === "object" && value !== null && "$color" in value && value["$color"] === true;
+	return isPlainObject(value) && COLOR_PROPERTY.name in value && value[COLOR_PROPERTY.name] === true;
 }
 function isColorValue(obj, properties) {
 	if (typeof obj !== "object" || obj === null) return false;
@@ -4279,7 +4295,7 @@ function isColorValue(obj, properties) {
 	return true;
 }
 function isDegree(value) {
-	return typeof value === "number" && between(value, 0, 360);
+	return typeof value === "number" && between(value, 0, COLOR_MAX.degree);
 }
 /**
 * Is the value a hex color?
@@ -4299,10 +4315,10 @@ function isDegree(value) {
 */
 function isHexColor(value, alpha) {
 	if (typeof value !== "string") return false;
-	if (!(EXPRESSION_HEX_SHORT.test(value) || EXPRESSION_HEX_LONG.test(value))) return false;
+	if (!(COLOR_EXPRESSION.hexShort.test(value) || COLOR_EXPRESSION.hexLong.test(value))) return false;
 	if (alpha === false) {
-		const unprefixed = value.replace(EXPRESSION_PREFIX, "");
-		return unprefixed.length === 3 || unprefixed.length === 6;
+		const unprefixed = value.replace(COLOR_EXPRESSION.prefix, "");
+		return unprefixed.length === COLOR_LENGTHS.hexShort || unprefixed.length === COLOR_LENGTHS.hexLong;
 	}
 	return true;
 }
@@ -4313,7 +4329,7 @@ function isHexColor(value, alpha) {
 * @returns `true` if the value is an _HSLA_ color, otherwise `false`
 */
 function isHslaColor(value) {
-	return isColorValue(value, KEYS_HSLA);
+	return isColorValue(value, COLOR_KEYS.hsla);
 }
 /**
 * Is the value an _HSL_ color?
@@ -4322,10 +4338,10 @@ function isHslaColor(value) {
 * @returns `true` if the value is an _HSL_ color, otherwise `false`
 */
 function isHslColor(value) {
-	return isColorValue(value, KEYS_HSLA) || isColorValue(value, KEYS_HSL);
+	return isColorValue(value, COLOR_KEYS.hsla) || isColorValue(value, COLOR_KEYS.hsl);
 }
 function isHslLike(value) {
-	return hasKeys(value, KEYS_HSL);
+	return hasKeys(value, COLOR_KEYS.hsl);
 }
 /**
 * Is the value an _HWBA_ color?
@@ -4334,7 +4350,7 @@ function isHslLike(value) {
 * @returns `true` if the value is an _HWBA_ color, otherwise `false`
 */
 function isHwbaColor(value) {
-	return isColorValue(value, KEYS_HWBA);
+	return isColorValue(value, COLOR_KEYS.hwba);
 }
 /**
 * Is the value an _HWB_ color?
@@ -4343,10 +4359,10 @@ function isHwbaColor(value) {
 * @returns `true` if the value is an _HWB_ color, otherwise `false`
 */
 function isHwbColor(value) {
-	return isColorValue(value, KEYS_HWB) || isColorValue(value, KEYS_HWBA);
+	return isColorValue(value, COLOR_KEYS.hwb) || isColorValue(value, COLOR_KEYS.hwba);
 }
 function isHwbLike(value) {
-	return hasKeys(value, KEYS_HWB);
+	return hasKeys(value, COLOR_KEYS.hwb);
 }
 /**
 * Is the value an _RGBA_ color?
@@ -4355,7 +4371,7 @@ function isHwbLike(value) {
 * @returns `true` if the value is an _RGBA_ color, otherwise `false`
 */
 function isRgbaColor(value) {
-	return isColorValue(value, KEYS_RGBA);
+	return isColorValue(value, COLOR_KEYS.rgba);
 }
 /**
 * Is the value an _RGB_ color?
@@ -4364,13 +4380,13 @@ function isRgbaColor(value) {
 * @returns `true` if the value is an _RGB_ color, otherwise `false`
 */
 function isRgbColor(value) {
-	return isColorValue(value, KEYS_RGBA) || isColorValue(value, KEYS_RGB);
+	return isColorValue(value, COLOR_KEYS.rgba) || isColorValue(value, COLOR_KEYS.rgb);
 }
 function isRgbLike(value) {
-	return hasKeys(value, KEYS_RGB);
+	return hasKeys(value, COLOR_KEYS.rgb);
 }
 function isPercentage(value) {
-	return typeof value === "number" && between(value, 0, 100);
+	return typeof value === "number" && between(value, 0, COLOR_MAX.percent);
 }
 const validators = {
 	alpha: isAlpha,
@@ -4399,7 +4415,7 @@ function convertRgbToHex(rgb, alpha) {
 	return `${hex}${a}`;
 }
 function convertRgbToHsla(value) {
-	const values = getRgbValues(isRgbLike(value) ? getRgbValue(value) : { ...DEFAULT_RGB });
+	const values = getRgbValues(isRgbLike(value) ? getRgbValue(value) : { ...COLOR_DEFAULTS.rgb });
 	const { delta, max, min } = values;
 	const lightness = (min + max) / 2;
 	let hue = 0;
@@ -4411,13 +4427,13 @@ function convertRgbToHsla(value) {
 	}
 	return {
 		hue,
-		saturation: saturation * 100,
-		lightness: lightness * 100,
-		alpha: getAlphaValue(value?.alpha ?? 100)
+		saturation: saturation * COLOR_MAX.percent,
+		lightness: lightness * COLOR_MAX.percent,
+		alpha: getAlphaValue(value?.alpha ?? COLOR_MAX.percent)
 	};
 }
 function convertRgbToHwba(value) {
-	const values = getRgbValues(isRgbLike(value) ? getRgbValue(value) : { ...DEFAULT_RGB });
+	const values = getRgbValues(isRgbLike(value) ? getRgbValue(value) : { ...COLOR_DEFAULTS.rgb });
 	const { delta, max, min } = values;
 	let hue = 0;
 	if (delta !== 0) {
@@ -4426,20 +4442,20 @@ function convertRgbToHwba(value) {
 	}
 	return {
 		hue,
-		whiteness: min * 100,
-		blackness: (1 - max) * 100,
-		alpha: getAlphaValue(value?.alpha ?? 100)
+		whiteness: min * COLOR_MAX.percent,
+		blackness: (1 - max) * COLOR_MAX.percent,
+		alpha: getAlphaValue(value?.alpha ?? COLOR_MAX.percent)
 	};
 }
 function getColorFromRgb(state, type) {
 	switch (type) {
-		case "hex":
+		case COLOR_TYPE.hex:
 			state.hex = rgbToHex(state.rgb);
 			break;
-		case "hsl":
+		case COLOR_TYPE.hsl:
 			state.hsl = rgbToHsl(state.rgb);
 			break;
-		case "hwb": state.hwb = rgbToHwb(state.rgb);
+		case COLOR_TYPE.hwb: state.hwb = rgbToHwb(state.rgb);
 	}
 	return state[type];
 }
@@ -4459,9 +4475,9 @@ function getRgbValue(value) {
 	};
 }
 function getRgbValues(rgb) {
-	const blue = rgb.blue / 255;
-	const green = rgb.green / 255;
-	const red = rgb.red / 255;
+	const blue = rgb.blue / COLOR_MAX.hex;
+	const green = rgb.green / COLOR_MAX.hex;
+	const red = rgb.red / COLOR_MAX.hex;
 	const max = Math.max(blue, green, red);
 	const min = Math.min(blue, green, red);
 	return {
@@ -4483,7 +4499,7 @@ function getRgbValues(rgb) {
 * @returns Hex color string
 */
 function rgbToHex(rgb, alpha) {
-	return convertRgbToHex(isRgbLike(rgb) ? getRgbValue(rgb) : { ...DEFAULT_RGB }, alpha ?? false);
+	return convertRgbToHex(isRgbLike(rgb) ? getRgbValue(rgb) : { ...COLOR_DEFAULTS.rgb }, alpha ?? false);
 }
 /**
 * Convert an _RGB(A)_ color to an _HSL_ color
@@ -4551,12 +4567,12 @@ function rgbToHwba(rgb) {
 //#region src/color/space/hex.ts
 function convertHexToRgba(value) {
 	const normalized = getNormalizedHex(value, true);
-	const pairs = EXPRESSION_HEX_LONG.exec(normalized);
+	const pairs = COLOR_EXPRESSION.hexLong.exec(normalized);
 	const values = [];
 	const { length } = pairs;
 	for (let index = 1; index < length; index += 1) values.push(Number.parseInt(pairs[index], 16));
 	return {
-		alpha: getPercentage(values[3] / 255 * 100),
+		alpha: getPercentage(values[3] / COLOR_MAX.hex * 100),
 		blue: getHexValue(values[2]),
 		green: getHexValue(values[1]),
 		red: getHexValue(values[0])
@@ -4564,13 +4580,13 @@ function convertHexToRgba(value) {
 }
 function getColorFromHex(state, type) {
 	switch (type) {
-		case "hsl":
+		case COLOR_TYPE.hsl:
 			state.hsl ??= hexToHsl(state.hex);
 			break;
-		case "hwb":
+		case COLOR_TYPE.hwb:
 			state.hwb ??= hexToHwb(state.hex);
 			break;
-		case "rgb": state.rgb ??= hexToRgb(state.hex);
+		case COLOR_TYPE.rgb: state.rgb ??= hexToRgb(state.hex);
 	}
 	return state[type];
 }
@@ -4585,10 +4601,10 @@ function getColorFromHex(state, type) {
 */
 function getNormalizedHex(value, alpha) {
 	const includeAlpha = alpha ?? false;
-	if (!isHexColor(value)) return `${HEX_BLACK}${includeAlpha ? ALPHA_FULL_HEX_LONG : ""}`;
-	const normalized = value.replace(EXPRESSION_PREFIX, "");
-	if (normalized.length < 6) return join(`${normalized.slice(0, 3)}${includeAlpha ? normalized[3] ?? "f" : ""}`.split("").map((character) => character.repeat(2)));
-	return `${normalized.slice(0, 6)}${includeAlpha ? normalized.slice(6) || ALPHA_FULL_HEX_LONG : ""}`;
+	if (!isHexColor(value)) return `${COLOR_DEFAULTS.hexBlack}${includeAlpha ? COLOR_ALPHA.fullHexLong : ""}`;
+	const normalized = value.replace(COLOR_EXPRESSION.prefix, "");
+	if (normalized.length < COLOR_LENGTHS.hexLong) return join(`${normalized.slice(0, COLOR_LENGTHS.hexShort)}${includeAlpha ? normalized[COLOR_LENGTHS.hexShort] ?? COLOR_ALPHA.fullHexShort : ""}`.split("").map((character) => character.repeat(2)));
+	return `${normalized.slice(0, COLOR_LENGTHS.hexLong)}${includeAlpha ? normalized.slice(COLOR_LENGTHS.hexLong) || COLOR_ALPHA.fullHexLong : ""}`;
 }
 /**
 * Convert a hex color string to a _HSL_ color
@@ -4674,27 +4690,27 @@ function hexToRgba(value) {
 //#endregion
 //#region src/color/space/hsl.ts
 function convertHslToHwba(input) {
-	let { hue, lightness, saturation } = isHslLike(input) ? getHslValue(input) : { ...DEFAULT_HSL };
-	lightness /= 100;
-	saturation /= 100;
+	let { hue, lightness, saturation } = isHslLike(input) ? getHslValue(input) : { ...COLOR_DEFAULTS.hsl };
+	lightness /= COLOR_MAX.percent;
+	saturation /= COLOR_MAX.percent;
 	const value = lightness + saturation * Math.min(lightness, 1 - lightness);
 	if (value === 0) saturation = 0;
 	else saturation = 2 * (1 - lightness / value);
 	const blackness = 1 - value;
 	return {
 		hue,
-		whiteness: (1 - saturation) * value * 100,
-		blackness: blackness * 100,
-		alpha: getAlphaValue(input?.alpha ?? 100)
+		whiteness: (1 - saturation) * value * COLOR_MAX.percent,
+		blackness: blackness * COLOR_MAX.percent,
+		alpha: getAlphaValue(input?.alpha ?? COLOR_MAX.percent)
 	};
 }
 function convertHslToRgba(input) {
-	const hsl = isHslLike(input) ? getHslValue(input) : { ...DEFAULT_HSL };
-	const hue = hsl.hue % 360;
-	const saturation = hsl.saturation / 100;
-	const lightness = hsl.lightness / 100;
+	const hsl = isHslLike(input) ? getHslValue(input) : { ...COLOR_DEFAULTS.hsl };
+	const hue = hsl.hue % COLOR_MAX.degree;
+	const saturation = hsl.saturation / COLOR_MAX.percent;
+	const lightness = hsl.lightness / COLOR_MAX.percent;
 	return {
-		alpha: getAlphaValue(input?.alpha ?? 100),
+		alpha: getAlphaValue(input?.alpha ?? COLOR_MAX.percent),
 		blue: getHexValue(getHexyValue(hue, lightness, saturation, 4)),
 		green: getHexValue(getHexyValue(hue, lightness, saturation, 8)),
 		red: getHexValue(getHexyValue(hue, lightness, saturation, 0))
@@ -4702,19 +4718,19 @@ function convertHslToRgba(input) {
 }
 function getColorFromHsl(state, type) {
 	switch (type) {
-		case "hex":
+		case COLOR_TYPE.hex:
 			state.hex = hslToHex(state.hsl);
 			break;
-		case "hwb":
+		case COLOR_TYPE.hwb:
 			state.hwb = hslToHwb(state.hsl);
 			break;
-		case "rgb": state.rgb = hslToRgb(state.hsl);
+		case COLOR_TYPE.rgb: state.rgb = hslToRgb(state.hsl);
 	}
 	return state[type];
 }
 function getHexyValue(hue, lightness, saturation, value) {
 	const part = (value + hue / 30) % 12;
-	return (lightness - saturation * Math.min(lightness, 1 - lightness) * Math.max(-1, Math.min(part - 3, 9 - part, 1))) * 255;
+	return (lightness - saturation * Math.min(lightness, 1 - lightness) * Math.max(-1, Math.min(part - 3, 9 - part, 1))) * COLOR_MAX.hex;
 }
 function getHslValue(value) {
 	return {
@@ -4796,9 +4812,9 @@ function hslToRgba(hsl) {
 //#endregion
 //#region src/color/space/hwb.ts
 function convertHwbToHsl(input) {
-	let { blackness, hue, whiteness } = isHwbLike(input) ? getHwbValue(input) : DEFAULT_HWB;
-	blackness /= 100;
-	whiteness /= 100;
+	let { blackness, hue, whiteness } = isHwbLike(input) ? getHwbValue(input) : COLOR_DEFAULTS.hwb;
+	blackness /= COLOR_MAX.percent;
+	whiteness /= COLOR_MAX.percent;
 	if (blackness + whiteness > 1) {
 		const total = blackness + whiteness;
 		blackness /= total;
@@ -4807,20 +4823,20 @@ function convertHwbToHsl(input) {
 	const lightness = (1 - blackness + whiteness) / 2;
 	return {
 		hue,
-		saturation: getHwbSaturation(blackness, whiteness, lightness) * 100,
-		lightness: lightness * 100,
-		alpha: getAlphaValue(input?.alpha ?? 100)
+		saturation: getHwbSaturation(blackness, whiteness, lightness) * COLOR_MAX.percent,
+		lightness: lightness * COLOR_MAX.percent,
+		alpha: getAlphaValue(input?.alpha ?? COLOR_MAX.percent)
 	};
 }
 function getColorFromHwb(state, type) {
 	switch (type) {
-		case "hex":
+		case COLOR_TYPE.hex:
 			state.hex = hwbToHex(state.hwb);
 			break;
-		case "hsl":
+		case COLOR_TYPE.hsl:
 			state.hsl = hwbToHsl(state.hwb);
 			break;
-		case "rgb": state.rgb = hwbToRgb(state.hwb);
+		case COLOR_TYPE.rgb: state.rgb = hwbToRgb(state.hwb);
 	}
 	return state[type];
 }
@@ -4919,15 +4935,15 @@ function getColorState(value) {
 			alpha: getAlpha(value.alpha, false),
 			origin: void 0
 		};
-		if (KEYS_HSL.every((key) => key in value)) {
+		if (COLOR_KEYS.hsl.every((key) => key in value)) {
 			state.hsl = getHslValue(value);
-			state.origin = "hsl";
-		} else if (KEYS_HWB.every((key) => key in value)) {
+			state.origin = COLOR_TYPE.hsl;
+		} else if (COLOR_KEYS.hwb.every((key) => key in value)) {
 			state.hwb = getHwbValue(value);
-			state.origin = "hwb";
-		} else if (KEYS_RGB.every((key) => key in value)) {
+			state.origin = COLOR_TYPE.hwb;
+		} else if (COLOR_KEYS.rgb.every((key) => key in value)) {
 			state.rgb = getRgbValue(value);
-			state.origin = "rgb";
+			state.origin = COLOR_TYPE.rgb;
 		}
 		if (state.origin != null) return state;
 	}
@@ -4936,54 +4952,59 @@ function getColorState(value) {
 function getColorStateForHex(value) {
 	const normalized = getNormalizedHex(value, true);
 	return {
-		hex: normalized.slice(0, 6),
-		alpha: getAlpha(normalized.slice(6), true),
-		origin: "hex"
+		hex: normalized.slice(0, COLOR_LENGTHS.hexLong),
+		alpha: getAlpha(normalized.slice(COLOR_LENGTHS.hexLong), true),
+		origin: COLOR_TYPE.hex
 	};
 }
 function getDefaultColorState() {
 	return {
-		alpha: getAlpha(100, false),
-		hex: HEX_BLACK,
-		hsl: { ...DEFAULT_HSL },
-		hwb: { ...DEFAULT_HWB },
-		rgb: { ...DEFAULT_RGB },
-		origin: "hex"
+		alpha: getAlpha(COLOR_MAX.percent, false),
+		hex: COLOR_DEFAULTS.hexBlack,
+		hsl: { ...COLOR_DEFAULTS.hsl },
+		hwb: { ...COLOR_DEFAULTS.hwb },
+		rgb: { ...COLOR_DEFAULTS.rgb },
+		origin: COLOR_TYPE.hex
 	};
 }
-function setColorValue(state, type, value, alpha) {
+function setColorValue(color, state, subscriptions, type, value, alpha) {
 	state.hex = void 0;
 	state.hsl = void 0;
 	state.hwb = void 0;
 	state.rgb = void 0;
 	state.origin = type;
 	state[type] = value;
-	if (alpha != null) state.alpha = getAlpha(alpha, type === "hex");
+	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);
 }
-function setHexColor(state, value, alpha) {
+function setHexColor(color, state, subscriptions, value, alpha) {
 	if (!isHexColor(value) || !alpha && value === state.hex) return;
 	const normalized = getNormalizedHex(value, true);
-	setColorValue(state, "hex", normalized.slice(0, 6), alpha ? normalized.slice(6) : void 0);
+	setColorValue(color, state, subscriptions, COLOR_TYPE.hex, normalized.slice(0, COLOR_LENGTHS.hexLong), alpha ? normalized.slice(COLOR_LENGTHS.hexLong) : void 0);
 }
-function setHSLColor(state, value, alpha) {
+function setHSLColor(color, state, subscriptions, value, alpha) {
 	if (!isHslLike(value)) return;
-	setColorValue(state, "hsl", {
+	setColorValue(color, state, subscriptions, COLOR_TYPE.hsl, {
 		hue: getDegrees(value.hue),
 		saturation: getPercentage(value.saturation),
 		lightness: getPercentage(value.lightness)
 	}, alpha ? value.alpha : void 0);
 }
-function setHWBColor(state, value, alpha) {
+function setHWBColor(color, state, subscriptions, value, alpha) {
 	if (!isHwbLike(value)) return;
-	setColorValue(state, "hwb", {
+	setColorValue(color, state, subscriptions, COLOR_TYPE.hwb, {
 		hue: getDegrees(value.hue),
 		whiteness: getPercentage(value.whiteness),
 		blackness: getPercentage(value.blackness)
 	}, alpha ? value.alpha : void 0);
 }
-function setRGBColor(state, value, alpha) {
+function setRGBColor(color, state, subscriptions, value, alpha) {
 	if (!isRgbLike(value)) return;
-	setColorValue(state, "rgb", {
+	setColorValue(color, state, subscriptions, COLOR_TYPE.rgb, {
 		red: getHexValue(value.red),
 		green: getHexValue(value.green),
 		blue: getHexValue(value.blue)
@@ -4998,15 +5019,15 @@ const getters = {
 //#endregion
 //#region src/color/misc/format.ts
 function formatHslColor(state, alpha) {
-	const { hue, lightness, saturation } = getColorFromState(state, "hsl");
+	const { hue, lightness, saturation } = getColorFromState(state, COLOR_TYPE.hsl);
 	return `hsl(${hue}deg ${saturation}% ${lightness}%${getSuffix(state, alpha)})`;
 }
 function formatHwbColor(state, alpha) {
-	const { blackness, hue, whiteness } = getColorFromState(state, "hwb");
+	const { blackness, hue, whiteness } = getColorFromState(state, COLOR_TYPE.hwb);
 	return `hwb(${hue}deg ${whiteness}% ${blackness}%${getSuffix(state, alpha)})`;
 }
 function formatRgbColor(state, alpha) {
-	const { blue, green, red } = getColorFromState(state, "rgb");
+	const { blue, green, red } = getColorFromState(state, COLOR_TYPE.rgb);
 	return `rgb(${red} ${green} ${blue}${getSuffix(state, alpha)})`;
 }
 function getSuffix(state, alpha) {
@@ -5016,15 +5037,18 @@ function getSuffix(state, alpha) {
 //#region src/color/instance.ts
 function color(value) {
 	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}`,
 		toHslString: (alpha) => formatHslColor(state, alpha),
 		toHwbString: (alpha) => formatHwbColor(state, alpha),
 		toRgbString: (alpha) => formatRgbColor(state, alpha),
-		toString: () => instance.toHexString()
+		toString: () => instance.toHexString(),
+		unsubscribe: () => clearSubscriptions(subscriptions)
 	};
 	Object.defineProperties(instance, {
-		[PROPERTY_COLOR]: {
+		[COLOR_PROPERTY.name]: {
 			enumerable: false,
 			value: true
 		},
@@ -5033,27 +5057,27 @@ function color(value) {
 			get: () => state.alpha.value,
 			set: (value) => setAlphaValue(state, value)
 		},
-		hex: getProperty("hex", state, false),
-		hexa: getProperty("hex", state, true),
-		hsl: getProperty("hsl", state, false),
-		hsla: getProperty("hsl", state, true),
-		hwb: getProperty("hwb", state, false),
-		hwba: getProperty("hwb", state, true),
+		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),
 		origin: {
 			enumerable: true,
 			get: () => state.origin
 		},
-		rgb: getProperty("rgb", state, false),
-		rgba: getProperty("rgb", state, true)
+		rgb: getProperty(COLOR_TYPE.rgb, instance, state, subscriptions, false),
+		rgba: getProperty(COLOR_TYPE.rgb, instance, state, subscriptions, true)
 	});
 	return Object.freeze(instance);
 }
-function getProperty(space, state, alpha) {
+function getProperty(space, color, state, subscriptions, alpha) {
 	const setValue = setters[space];
 	return {
 		enumerable: true,
 		get: () => getValue$1(space, state, alpha),
-		set: (value) => setValue(state, value, alpha)
+		set: (value) => setValue(color, state, subscriptions, value, alpha)
 	};
 }
 function getValue$1(space, state, alpha) {
@@ -5067,6 +5091,25 @@ function getValue$1(space, state, alpha) {
 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 setters = {
 	hex: setHexColor,
 	hsl: setHSLColor,
@@ -5088,6 +5131,125 @@ function getColor(value) {
 	return isColor(value) ? value : color(value);
 }
 //#endregion
+//#region src/is.ts
+/**
+* Is the value empty, or only containing `null` or `undefined` values?
+*
+* @param value Value to check
+* @returns `true` if the value is considered empty, otherwise `false`
+*/
+function isEmpty(value) {
+	if (value == null) return true;
+	if (typeof value === "string") return value.length === 0;
+	const values = getArray(value);
+	const { length } = values;
+	for (let index = 0; index < length; index += 1) {
+		const item = values[index];
+		if (Array.isArray(item) ? item[1] != null : item != null) return false;
+	}
+	return true;
+}
+/**
+* Is the value not empty, or holding non-empty values?
+*
+* @param value Value to check
+* @returns `true` if the value is not considered empty, otherwise `false`
+*/
+function isNonEmpty(value) {
+	return !isEmpty(value);
+}
+/**
+* Is the value not `undefined` or `null`?
+*
+* @param value Value to check
+* @returns `true` if the value is not `undefined` or `null`, otherwise `false`
+*/
+function isNonNullable(value) {
+	return value != null;
+}
+/**
+* Is the value not `undefined`, `null`, or stringified as an empty _(no whitespace)_ string?
+*
+* @param value Value to check
+* @returns `true` if the value is not `undefined`, `null`, or matches an empty string, otherwise `false`
+*/
+function isNonNullableOrEmpty(value) {
+	return value != null && getString(value) !== "";
+}
+/**
+* Is the value not `undefined`, `null`, or stringified as a whitespace-only string?
+*
+* @param value Value to check
+* @returns `true` if the value is not `undefined`, `null`, or matches a whitespace-only string, otherwise `false`
+*/
+function isNonNullableOrWhitespace(value) {
+	return value != null && !EXPRESSION_WHITESPACE.test(getString(value));
+}
+/**
+* Is the value not a number or a number-like string?
+*
+* @param value Value to check
+* @returns `true` if the value is not a number or a number-like string, otherwise `false`
+*/
+function isNonNumerical(value) {
+	return !isNumerical(value);
+}
+/**
+* Is the value not an object _(or function)_?
+*
+* @param value Value to check
+* @returns `true` if the value is not an object, otherwise `false`
+*/
+function isNonObject(value) {
+	return !isObject(value);
+}
+/**
+* Is the value `undefined` or `null`?
+*
+* @param value Value to check
+* @returns `true` if the value is `undefined` or `null`, otherwise `false`
+*/
+function isNullable(value) {
+	return value == null;
+}
+/**
+* Is the value `undefined`, `null`, or stringified as an empty _(no whitespace)_ string?
+*
+* @param value Value to check
+* @returns `true` if the value is nullable or matches an empty string, otherwise `false`
+*/
+function isNullableOrEmpty(value) {
+	return value == null || getString(value) === "";
+}
+/**
+* Is the value `undefined`, `null`, or stringified as a whitespace-only string?
+*
+* @param value Value to check
+* @returns `true` if the value is nullable or matches a whitespace-only string, otherwise `false`
+*/
+function isNullableOrWhitespace(value) {
+	return value == null || EXPRESSION_WHITESPACE.test(getString(value));
+}
+/**
+* Is the value a number or a number-like string?
+*
+* @param value Value to check
+* @returns `true` if the value is a number or a number-like string, otherwise `false`
+*/
+function isNumerical(value) {
+	return isNumber(value) || typeof value === "string" && value.trim().length > 0 && !Number.isNaN(+value);
+}
+/**
+* Is the value an object _(or function)_?
+*
+* @param value Value to check
+* @returns `true` if the value matches, otherwise `false`
+*/
+function isObject(value) {
+	return typeof value === "object" && value !== null || typeof value === "function";
+}
+const EXPRESSION_WHITESPACE = /^\s*$/;
+//#endregion
 //#region src/logger.ts
 function isLogger(value) {
 	return isLoggerInstance(NAME_LOGGER, value);