@oscarpalmer/atoms 0.203.0 → 0.204.1

package/dist/array/filter.mjs

@@ -7,6 +7,5 @@ function filter(array, ...parameters) {
 	return findValues("all", array, parameters).matched;
 }
 filter.remove = exclude;
-Object.defineProperty(filter, "remove", { value: exclude });
 //#endregion
 export { exclude, filter };

package/dist/array/find.mjs

@@ -7,6 +7,5 @@ function findLast(array, ...parameters) {
 	return findValue(FIND_VALUE_ITEM, array, parameters, true);
 }
 find.last = findLast;
-Object.defineProperty(find, "last", { value: findLast });
 //#endregion
 export { find, findLast };

package/dist/array/first.mjs

@@ -7,6 +7,5 @@ function firstOrDefault(array, defaultValue, ...parameters) {
 	return findAbsoluteValueOrDefault(array, parameters, defaultValue, true, false);
 }
 first.default = firstOrDefault;
-Object.defineProperty(first, "default", { value: firstOrDefault });
 //#endregion
 export { first, firstOrDefault };

package/dist/array/group-by.mjs

@@ -7,6 +7,5 @@ function groupArraysBy(array, first, second) {
 	return groupValues(array, first, second, true);
 }
 groupBy.arrays = groupArraysBy;
-Object.defineProperty(groupBy, "arrays", { value: groupArraysBy });
 //#endregion
 export { groupArraysBy, groupBy };

package/dist/array/last.mjs

@@ -7,6 +7,5 @@ function lastOrDefault(array, defaultValue, ...parameters) {
 	return findAbsoluteValueOrDefault(array, parameters, defaultValue, true, true);
 }
 last.default = lastOrDefault;
-Object.defineProperty(last, "default", { value: lastOrDefault });
 //#endregion
 export { last, lastOrDefault };

package/dist/array/move.mjs

@@ -72,9 +72,5 @@ function moveToIndex(array, value, index, key) {
 }
 move.indices = moveIndices;
 move.toIndex = moveToIndex;
-Object.defineProperties(move, {
-	indices: { value: moveIndices },
-	toIndex: { value: moveToIndex }
-});
 //#endregion
 export { move, moveIndices, moveToIndex };

package/dist/array/select.mjs

@@ -18,6 +18,5 @@ function selectValues(array, parameters) {
 	}).matched;
 }
 select.reverse = reverseSelect;
-Object.defineProperty(select, "reverse", { value: reverseSelect });
 //#endregion
 export { reverseSelect, select };

package/dist/array/sort.mjs

@@ -1,16 +1,12 @@
 import { isPlainObject } from "../internal/is.mjs";
 import { compare } from "../internal/value/compare.mjs";
 //#region src/array/sort.ts
-const SORTER_PROPERTY = "$sorter";
 function Sorter(sorters) {
-	Object.defineProperty(this, SORTER_SYMBOL, { value: sorters });
+	this[SORTER_SYMBOL] = sorters;
 }
-Object.defineProperties(Sorter.prototype, {
-	[SORTER_PROPERTY]: { value: true },
-	index: { value: getSortedArrayIndex },
-	is: { value: isSortedArray },
-	sort: { value: sortArray }
-});
+Sorter.prototype.index = getSortedArrayIndex;
+Sorter.prototype.is = isSortedArray;
+Sorter.prototype.sort = sortArray;
 function getComparisonSorter(callback, modifier) {
 	return {
 		modifier,
@@ -22,7 +18,7 @@ function getComparisonSorter(callback, modifier) {
 function getComparisonValue(first, second, sorters, length) {
 	for (let index = 0; index < length; index += 1) {
 		const sorter = sorters[index];
-		const values = [sorter.get ? sorter.value(first) : first, sorter.get ? sorter.value(second) : second];
+		const values = [sorter.get ? sorter.value?.(first) : first, sorter.get ? sorter.value?.(second) : second];
 		const comparison = (sorter.comparison?.complex?.(first, values[0], second, values[1]) ?? sorter.comparison?.simple?.(values[0], values[1]) ?? compare(values[0], values[1])) * sorter.modifier;
 		if (comparison !== 0) return comparison;
 	}
@@ -137,7 +133,7 @@ const SORT_PEEK_PERCENTAGE = 10;
 const SORT_THRESHOLD = 100;
 const SORT_DIRECTION_ASCENDING = "ascending";
 const SORT_DIRECTION_DESCENDING = "descending";
-const SORTER_SYMBOL = Symbol(SORTER_PROPERTY);
+const SORTER_SYMBOL = Symbol("sorter");
 const modifiers = {
 	[SORT_DIRECTION_ASCENDING]: 1,
 	[SORT_DIRECTION_DESCENDING]: -1
@@ -145,10 +141,5 @@ const modifiers = {
 sort.getIndex = getSortedIndex;
 sort.initialize = initializeSorter;
 sort.is = isSorted;
-Object.defineProperties(sort, {
-	getIndex: { value: getSortedIndex },
-	initialize: { value: initializeSorter },
-	is: { value: isSorted }
-});
 //#endregion
 export { SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, getSortedIndex, initializeSorter, isSorted, sort };

package/dist/array/swap.mjs

@@ -58,6 +58,5 @@ function swapValues(array, from, to, key) {
 	return swapIndices(array, first, second);
 }
 swap.indices = swapIndices;
-Object.defineProperty(swap, "indices", { value: swapIndices });
 //#endregion
 export { swap };

package/dist/array/to-map.mjs

@@ -24,6 +24,5 @@ function toMapArrays(array, first, second) {
 	return getMapValues(array, first, second, true);
 }
 toMap.arrays = toMapArrays;
-Object.defineProperty(toMap, "arrays", { value: toMapArrays });
 //#endregion
 export { toMap, toMapArrays };

package/dist/array/to-record.mjs

@@ -7,6 +7,5 @@ function toRecordArrays(array, first, second) {
 	return groupValues(array, first, second, true);
 }
 toRecord.arrays = toRecordArrays;
-Object.defineProperty(toRecord, "arrays", { value: toRecordArrays });
 //#endregion
 export { toRecord, toRecordArrays };

package/dist/beacon.mjs

@@ -6,54 +6,43 @@ const BEACON_PROPERTY = "$beacon";
 const BEACON_NAME = "beacon";
 const BEACON_OBSERVABLE = "observable";
 function Beacon(value, options) {
-	Object.defineProperty(this, BEACON_SYMBOL, { value: {
+	this[BEACON_SYMBOL] = {
 		value,
 		active: true,
 		options: createBeaconOptions(options)
-	} });
+	};
 }
+Beacon.prototype[BEACON_PROPERTY] = BEACON_NAME;
+Beacon.prototype.deactivate = deactivateBeacon;
+Beacon.prototype.emit = emitBeaconValue;
+Beacon.prototype.error = emitBeaconError;
+Beacon.prototype.finish = finishBeacon;
 Object.defineProperties(Beacon.prototype, {
-	[BEACON_PROPERTY]: { value: BEACON_NAME },
 	active: {
 		enumerable: true,
-		get() {
-			return this[BEACON_SYMBOL].active;
-		}
+		get: getBeaconActive
 	},
-	deactivate: { value: deactivateBeacon },
-	emit: { value: emitBeaconValue },
-	error: { value: emitBeaconError },
-	finish: { value: finishBeacon },
 	observable: {
 		enumerable: true,
-		get() {
-			return getObservable(this[BEACON_SYMBOL]);
-		}
+		get: getBeaconObservable
 	},
 	value: {
 		enumerable: true,
-		get() {
-			return this[BEACON_SYMBOL].value;
-		}
+		get: getBeaconValue
 	}
 });
 function Observable(beacon) {
-	Object.defineProperty(this, BEACON_SYMBOL, { value: {
+	this[BEACON_SYMBOL] = {
 		beacon,
 		active: beacon.active
-	} });
+	};
 }
-Object.defineProperties(Observable.prototype, {
-	[BEACON_PROPERTY]: { value: BEACON_OBSERVABLE },
-	active: {
-		enumerable: true,
-		get() {
-			const state = this[BEACON_SYMBOL];
-			return state.beacon.active && state.active;
-		}
-	},
-	deactivate: { value: deactiveateObservable },
-	subscribe: { value: subscribeToObservable }
+Observable.prototype[BEACON_PROPERTY] = BEACON_OBSERVABLE;
+Observable.prototype.deactivate = deactiveateObservable;
+Observable.prototype.subscribe = subscribeToObservable;
+Object.defineProperty(Observable.prototype, "active", {
+	enumerable: true,
+	get: getObservableActive
 });
 /**
 * Create a new beacon
@@ -78,8 +67,7 @@ function closeBeacon(state, emit) {
 }
 function createBeaconOptions(input) {
 	const options = isPlainObject(input) ? input : {};
-	options.equal = typeof options.equal === "function" ? options.equal : Object.is;
-	return options;
+	return { equal: typeof options.equal === "function" ? options.equal : Object.is };
 }
 function createObserver(first, second, third) {
 	let observer = { next: noop };
@@ -89,9 +77,10 @@ function createObserver(first, second, third) {
 		complete: getObservableCallback(third)
 	};
 	else if (typeof first === "object") {
-		observer.complete = getObservableCallback(first?.complete);
-		observer.error = getObservableCallback(first?.error);
-		observer.next = getObservableCallback(first?.next);
+		const object = first;
+		observer.complete = getObservableCallback(object?.complete);
+		observer.error = getObservableCallback(object?.error);
+		observer.next = getObservableCallback(object?.next);
 	}
 	return observer;
 }
@@ -110,11 +99,22 @@ function emitBeaconValue(value, finish) {
 function finishBeacon() {
 	closeBeacon(this[BEACON_SYMBOL], true);
 }
-function getObservable(state) {
+function getBeaconActive() {
+	return this[BEACON_SYMBOL].active;
+}
+function getBeaconObservable() {
+	const state = this[BEACON_SYMBOL];
 	if (!state.active) throw new Error(BEACON_MESSAGE_RETRIEVE);
 	state.observable ??= new Observable(state);
 	return state.observable;
 }
+function getBeaconValue() {
+	return this[BEACON_SYMBOL].value;
+}
+function getObservableActive() {
+	const state = this[BEACON_SYMBOL];
+	return state.beacon.active && state.active;
+}
 function getObservableCallback(value) {
 	return typeof value === "function" ? value : noop;
 }
@@ -128,7 +128,7 @@ function isBeacon(value) {
 	return isBeaconInstance(BEACON_NAME, value);
 }
 function isBeaconInstance(name, value) {
-	return typeof value === "object" && value !== null && value[BEACON_PROPERTY] === name;
+	return typeof value === "object" && value !== null && BEACON_PROPERTY in value && value[BEACON_PROPERTY] === name;
 }
 /**
 * Is the value a beacon subscription?

package/dist/color/instance.mjs

@@ -1,134 +1,95 @@
 import "../internal/subscription.mjs";
 import { herald } from "../internal/herald.mjs";
 import { COLOR_NAME, COLOR_PROPERTY, COLOR_SYMBOL, COLOR_TYPE, colorSubscription } from "./constants.mjs";
-import { getAlpha } from "./misc/alpha.mjs";
-import { getColorFromState, getColorState, setHSLColor, setHWBColor, setHexColor, setRGBColor } from "./misc/state.mjs";
+import { getColorAlpha, setColorAlpha } from "./misc/alpha.mjs";
+import { getRgbColor, getRgbaColor, setRgbValue, setRgbaValue } from "./space/rgb.mjs";
+import { getHexColor, getHexaColor, setHexValue, setHexaValue } from "./space/hex.mjs";
+import { getHslValue, getHslaValue, setHslValue, setHslaValue } from "./space/hsl.mjs";
+import { getHwbValue, getHwbaValue, setHwbValue, setHwbaValue } from "./space/hwb.mjs";
+import { getColorState } from "./misc/state.mjs";
 import { formatHexColor, formatHslColor, formatHwbColor, formatRgbColor } from "./misc/format.mjs";
 //#region src/color/instance.ts
 function Color(value) {
-	Object.defineProperty(this, COLOR_SYMBOL, { value: {
+	this[COLOR_SYMBOL] = {
 		changes: herald({
 			names: [COLOR_TYPE.wildcard, ...COLOR_TYPE.all],
 			property: colorSubscription,
 			onCreate: (event, callback) => onCreateSubscription(this, event, callback)
 		}),
 		values: getColorState(value)
-	} });
+	};
 }
+Color.prototype[COLOR_PROPERTY] = COLOR_NAME;
+Color.prototype.subscribe = subscribeToColor;
+Color.prototype.toHexString = formatHexColor;
+Color.prototype.toHslString = formatHslColor;
+Color.prototype.toHwbString = formatHwbColor;
+Color.prototype.toRgbString = formatRgbColor;
+Color.prototype.toString = formatHexColor;
+Color.prototype.unsubscribe = unsubscribeFromColor;
 Object.defineProperties(Color.prototype, {
-	[COLOR_PROPERTY]: { value: COLOR_NAME },
 	alpha: {
 		enumerable: true,
-		get() {
-			return this[COLOR_SYMBOL].values.alpha.value;
-		},
-		set(value) {
-			setAlphaValue(this[COLOR_SYMBOL].values, value);
-		}
+		get: getColorAlpha,
+		set: setColorAlpha
 	},
 	changes: {
 		enumerable: true,
-		get() {
-			return this[COLOR_SYMBOL].changes.events;
-		}
+		get: getColorChanges
 	},
 	hex: {
 		enumerable: true,
-		get() {
-			return getColorValue(this, COLOR_TYPE.hex, false);
-		},
-		set(value) {
-			setHexColor(this, value, false);
-		}
+		get: getHexColor,
+		set: setHexValue
 	},
 	hexa: {
 		enumerable: true,
-		get() {
-			return getColorValue(this, COLOR_TYPE.hex, true);
-		},
-		set(value) {
-			setHexColor(this, value, true);
-		}
+		get: getHexaColor,
+		set: setHexaValue
 	},
 	hsl: {
 		enumerable: true,
-		get() {
-			return getColorValue(this, COLOR_TYPE.hsl, false);
-		},
-		set(value) {
-			setHSLColor(this, value, false);
-		}
+		get: getHslValue,
+		set: setHslValue
 	},
 	hsla: {
 		enumerable: true,
-		get() {
-			return getColorValue(this, COLOR_TYPE.hsl, true);
-		},
-		set(value) {
-			setHSLColor(this, value, true);
-		}
+		get: getHslaValue,
+		set: setHslaValue
 	},
 	hwb: {
 		enumerable: true,
-		get() {
-			return getColorValue(this, COLOR_TYPE.hwb, false);
-		},
-		set(value) {
-			setHWBColor(this, value, false);
-		}
+		get: getHwbValue,
+		set: setHwbValue
 	},
 	hwba: {
 		enumerable: true,
-		get() {
-			return getColorValue(this, COLOR_TYPE.hwb, true);
-		},
-		set(value) {
-			setHWBColor(this, value, true);
-		}
+		get: getHwbaValue,
+		set: setHwbaValue
 	},
 	origin: {
 		enumerable: true,
-		get() {
-			return this[COLOR_SYMBOL].values.origin;
-		}
+		get: getOrigin
 	},
 	rgb: {
 		enumerable: true,
-		get() {
-			return getColorValue(this, COLOR_TYPE.rgb, false);
-		},
-		set(value) {
-			setRGBColor(this, value, false);
-		}
+		get: getRgbColor,
+		set: setRgbValue
 	},
 	rgba: {
 		enumerable: true,
-		get() {
-			return getColorValue(this, COLOR_TYPE.rgb, true);
-		},
-		set(value) {
-			setRGBColor(this, value, true);
-		}
-	},
-	subscribe: { value: subscribeToColor },
-	toHexString: { value: formatHexColor },
-	toHslString: { value: formatHslColor },
-	toHwbString: { value: formatHwbColor },
-	toRgbString: { value: formatRgbColor },
-	toString: { value: formatHexColor },
-	unsubscribe: { value: unsubscribeFromColor }
+		get: getRgbaColor,
+		set: setRgbaValue
+	}
 });
 function color(value) {
 	return new Color(value);
 }
-function getColorValue(instance, type, alpha) {
-	const { values } = instance[COLOR_SYMBOL];
-	const value = getColorFromState(values, type);
-	if (typeof value === "string") return alpha ? `${value}${values.alpha.hex}` : value;
-	return alpha ? {
-		...value,
-		alpha: values.alpha.value
-	} : { ...value };
+function getColorChanges() {
+	return this[COLOR_SYMBOL].changes.events;
+}
+function getOrigin() {
+	return this[COLOR_SYMBOL].values.origin;
 }
 function onCreateSubscription(instance, event, callback) {
 	let value;
@@ -136,9 +97,6 @@ function onCreateSubscription(instance, event, callback) {
 	else value = instance[event];
 	callback(value);
 }
-function setAlphaValue(state, value) {
-	if (typeof value === "number" && !Number.isNaN(value)) state.alpha = getAlpha(value, false);
-}
 function subscribeToColor(callback, signal) {
 	const { changes } = this[COLOR_SYMBOL];
 	return changes.subscribe(COLOR_TYPE.wildcard, callback, signal);

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

@@ -1,6 +1,8 @@
-import { Alpha } from "../models.mjs";
+import { Alpha, InternalColor } from "../models.mjs";
 //#region src/color/misc/alpha.d.ts
 export declare function getAlpha(value: unknown, hex: boolean): Alpha;
+export declare function getColorAlpha(this: InternalColor): number;
 export declare function getAlphaHexadecimal(value: number): string;
 export declare function getAlphaValue(original: number): number;
+export declare function setColorAlpha(this: InternalColor, value: unknown): void;
 //#endregion

package/dist/color/misc/alpha.mjs

@@ -1,5 +1,5 @@
 import { clamp } from "../../internal/number.mjs";
-import { COLOR_ALPHA, COLOR_DEFAULTS, COLOR_EXPRESSION, COLOR_MAX } from "../constants.mjs";
+import { COLOR_ALPHA, COLOR_DEFAULTS, COLOR_EXPRESSION, COLOR_MAX, COLOR_SYMBOL } from "../constants.mjs";
 import { round } from "../../internal/math/misc.mjs";
 //#region src/color/misc/alpha.ts
 function getAlpha(value, hex) {
@@ -11,6 +11,9 @@ function getAlpha(value, hex) {
 	};
 	return getAlphaFromValue(Number.parseFloat(value));
 }
+function getColorAlpha() {
+	return this[COLOR_SYMBOL].values.alpha.value;
+}
 function getAlphaHexadecimal(value) {
 	if (value === COLOR_ALPHA.noneValue) return COLOR_ALPHA.noneHex;
 	if (value === COLOR_MAX.percent) return COLOR_ALPHA.fullHexLong;
@@ -27,5 +30,8 @@ function getAlphaValue(original) {
 	if (Number.isNaN(original)) return COLOR_MAX.percent;
 	return clamp(original, COLOR_ALPHA.noneValue, COLOR_MAX.percent);
 }
+function setColorAlpha(value) {
+	if (typeof value === "number" && !Number.isNaN(value)) this[COLOR_SYMBOL].values.alpha = getAlpha(value, false);
+}
 //#endregion
-export { getAlpha, getAlphaHexadecimal, getAlphaValue };
+export { getAlpha, getAlphaHexadecimal, getAlphaValue, getColorAlpha, setColorAlpha };

package/dist/color/misc/is.mjs

@@ -27,13 +27,14 @@ function isColor(value) {
 * @returns `true` if the value is a color subscription, otherwise `false`
 */
 function isColorSubscription(value) {
-	return isSubscription(value) && value["$color"] === "subscription";
+	return isSubscription(value) && "$color" in value && value["$color"] === "subscription";
 }
-function isColorValue(obj, properties) {
-	if (typeof obj !== "object" || obj === null) return false;
-	const keys = Object.keys(obj);
+function isColorValue(value, properties) {
+	if (typeof value !== "object" || value === null) return false;
+	const keys = Object.keys(value);
 	const { length } = keys;
 	if (length !== properties.length) return false;
+	const obj = value;
 	for (let index = 0; index < length; index += 1) {
 		const key = keys[index];
 		if (!(properties.includes(key) && validators[key](obj[key]))) return false;

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

@@ -2,8 +2,33 @@ import { ColorState, ColorType, InternalColor } from "../models.mjs";
 //#region src/color/misc/state.d.ts
 export declare function getColorFromState<Type extends ColorType>(state: ColorState, type: Type): NonNullable<ColorState[Type]>;
 export declare function getColorState(value: unknown): ColorState;
-export declare function setHexColor(instance: InternalColor, value: string, alpha: boolean): void;
-export declare function setHSLColor(instance: InternalColor, value: unknown, alpha: boolean): void;
-export declare function setHWBColor(instance: InternalColor, value: unknown, alpha: boolean): void;
-export declare function setRGBColor(instance: InternalColor, value: unknown, alpha: boolean): void;
+export declare function getStateValue(instance: InternalColor, type: ColorType, alpha: boolean): string | {
+  alpha: number;
+  hue: number;
+  lightness: number;
+  saturation: number;
+} | {
+  alpha: number;
+  blackness: number;
+  hue: number;
+  whiteness: number;
+} | {
+  alpha: number;
+  blue: number;
+  green: number;
+  red: number;
+} | {
+  hue: number;
+  lightness: number;
+  saturation: number;
+} | {
+  blackness: number;
+  hue: number;
+  whiteness: number;
+} | {
+  blue: number;
+  green: number;
+  red: number;
+};
+export declare function setStateValue<Type extends ColorType>(instance: InternalColor, type: Type, value: ColorState[Type], alpha?: number | string): void;
 //#endregion

package/dist/color/misc/state.mjs

@@ -1,11 +1,10 @@
 import { COLOR_DEFAULTS, COLOR_KEYS, COLOR_LENGTHS, COLOR_MAX, COLOR_SYMBOL, COLOR_TYPE } from "../constants.mjs";
 import { getAlpha } from "./alpha.mjs";
-import { getDegrees, getHexValue, getPercentage } from "./get.mjs";
-import { isColor, isHexColor, isHslLike, isHwbLike, isRgbLike } from "./is.mjs";
-import { getColorFromRgb, getRgbValue } from "../space/rgb.mjs";
+import { isColor } from "./is.mjs";
+import { getColorFromRgb, getRgbValues } from "../space/rgb.mjs";
 import { getColorFromHex, getNormalizedHex } from "../space/hex.mjs";
-import { getColorFromHsl, getHslValue } from "../space/hsl.mjs";
-import { getColorFromHwb, getHwbValue } from "../space/hwb.mjs";
+import { getColorFromHsl, getHslValues } from "../space/hsl.mjs";
+import { getColorFromHwb, getHwbValues } from "../space/hwb.mjs";
 //#region src/color/misc/state.ts
 function getColorFromState(state, type) {
 	const { origin } = state;
@@ -28,13 +27,13 @@ function getColorState(value) {
 			origin: void 0
 		};
 		if (COLOR_KEYS.hsl.every((key) => key in value)) {
-			state.hsl = getHslValue(value);
+			state.hsl = getHslValues(value);
 			state.origin = COLOR_TYPE.hsl;
 		} else if (COLOR_KEYS.hwb.every((key) => key in value)) {
-			state.hwb = getHwbValue(value);
+			state.hwb = getHwbValues(value);
 			state.origin = COLOR_TYPE.hwb;
 		} else if (COLOR_KEYS.rgb.every((key) => key in value)) {
-			state.rgb = getRgbValue(value);
+			state.rgb = getRgbValues(value);
 			state.origin = COLOR_TYPE.rgb;
 		}
 		if (state.origin != null) return state;
@@ -59,7 +58,16 @@ function getDefaultColorState() {
 		origin: COLOR_TYPE.hex
 	};
 }
-function setColorValue(instance, type, value, alpha) {
+function getStateValue(instance, type, alpha) {
+	const { values } = instance[COLOR_SYMBOL];
+	const value = getColorFromState(values, type);
+	if (typeof value === "string") return alpha ? `${value}${values.alpha.hex}` : value;
+	return alpha ? {
+		...value,
+		alpha: values.alpha.value
+	} : { ...value };
+}
+function setStateValue(instance, type, value, alpha) {
 	const { changes, values } = instance[COLOR_SYMBOL];
 	values.hex = void 0;
 	values.hsl = void 0;
@@ -71,36 +79,6 @@ function setColorValue(instance, type, value, alpha) {
 	for (const type of COLOR_TYPE.all) if (changes.observed(type)) changes.emit(type, instance[type]);
 	changes.emit(COLOR_TYPE.wildcard, instance);
 }
-function setHexColor(instance, value, alpha) {
-	const { values } = instance[COLOR_SYMBOL];
-	if (!isHexColor(value) || !alpha && value === values.hex) return;
-	const normalized = getNormalizedHex(value, true);
-	setColorValue(instance, COLOR_TYPE.hex, normalized.slice(0, COLOR_LENGTHS.hexLong), alpha ? normalized.slice(COLOR_LENGTHS.hexLong) : void 0);
-}
-function setHSLColor(instance, value, alpha) {
-	if (!isHslLike(value)) return;
-	setColorValue(instance, COLOR_TYPE.hsl, {
-		hue: getDegrees(value.hue),
-		saturation: getPercentage(value.saturation),
-		lightness: getPercentage(value.lightness)
-	}, alpha ? value.alpha : void 0);
-}
-function setHWBColor(instance, value, alpha) {
-	if (!isHwbLike(value)) return;
-	setColorValue(instance, COLOR_TYPE.hwb, {
-		hue: getDegrees(value.hue),
-		whiteness: getPercentage(value.whiteness),
-		blackness: getPercentage(value.blackness)
-	}, alpha ? value.alpha : void 0);
-}
-function setRGBColor(instance, value, alpha) {
-	if (!isRgbLike(value)) return;
-	setColorValue(instance, COLOR_TYPE.rgb, {
-		red: getHexValue(value.red),
-		green: getHexValue(value.green),
-		blue: getHexValue(value.blue)
-	}, alpha ? value.alpha : void 0);
-}
 const getters = {
 	hex: getColorFromHex,
 	hsl: getColorFromHsl,
@@ -108,4 +86,4 @@ const getters = {
 	rgb: getColorFromRgb
 };
 //#endregion
-export { getColorFromState, getColorState, setHSLColor, setHWBColor, setHexColor, setRGBColor };
+export { getColorFromState, getColorState, getStateValue, setStateValue };

package/dist/color/space/hex.d.mts

@@ -1,6 +1,8 @@
-import { ColorState, ColorType, HSLAColor, HSLColor, HWBAColor, HWBColor, RGBAColor, RGBColor } from "../models.mjs";
+import { ColorState, ColorType, HSLAColor, HSLColor, HWBAColor, HWBColor, InternalColor, RGBAColor, RGBColor } from "../models.mjs";
 //#region src/color/space/hex.d.ts
 export declare function getColorFromHex<Type extends ColorType>(state: ColorState, type: Type): NonNullable<ColorState[Type]>;
+export declare function getHexColor(this: InternalColor): string;
+export declare function getHexaColor(this: InternalColor): string;
 /**
  * Get the normalized hex color from a value
  *
@@ -65,4 +67,6 @@ export declare function hexToRgb(value: string): RGBColor;
  * @returns _RGBA_ color
  */
 export declare function hexToRgba(value: string): RGBAColor;
+export declare function setHexValue(this: InternalColor, value: string): void;
+export declare function setHexaValue(this: InternalColor, value: string): void;
 //#endregion