@oscarpalmer/atoms 0.188.0 → 0.189.0

package/dist/index.mjs

@@ -4,7 +4,6 @@ function getArrayCallback(value) {
 		case "function": return value;
 		case "number":
 		case "string": return typeof value === "string" && value.includes(".") ? void 0 : (obj) => obj[value];
-		default: break;
 	}
 }
 function getArrayCallbacks(bool, key, value) {
@@ -350,7 +349,7 @@ function isTemplateStringsArray(value) {
 * @returns `true` if the value is a typed array, otherwise `false`
 */
 function isTypedArray(value) {
-	isTypedArray.types ??= new Set([
+	isTypedArray.types ??= /* @__PURE__ */ new Set([
 		Int8Array,
 		Uint8Array,
 		Uint8ClampedArray,
@@ -609,11 +608,11 @@ const COMPARISON_INVALID = "invalid";
 const COMPARISON_OUTSIDE = "outside";
 const COMPARISON_SAME = "same";
 const COMPARISON_START = "start";
-const endings = new Set([COMPARISON_END, COMPARISON_SAME]);
+const endings = /* @__PURE__ */ new Set([COMPARISON_END, COMPARISON_SAME]);
 const invalid = [-1, COMPARISON_INVALID];
 const outside = [-1, COMPARISON_OUTSIDE];
-const outsides = new Set([COMPARISON_INVALID, COMPARISON_OUTSIDE]);
-const starts = new Set([COMPARISON_START, COMPARISON_SAME]);
+const outsides = /* @__PURE__ */ new Set([COMPARISON_INVALID, COMPARISON_OUTSIDE]);
+const starts = /* @__PURE__ */ new Set([COMPARISON_START, COMPARISON_SAME]);
 //#endregion
 //#region src/array/push.ts
 /**
@@ -1207,7 +1206,6 @@ function getSorter(value, modifier) {
 		case typeof value === "function": return getComparisonSorter(value, modifier);
 		case typeof value === "string": return getValueSorter(value, modifier);
 		case isPlainObject(value): return getObjectSorter(value, modifier);
-		default: break;
 	}
 }
 function getSorters(value, modifier) {
@@ -3061,23 +3059,22 @@ function dedent(value, ...values) {
 */
 function getUuid(html) {
 	const forHTML = html === true;
-	let uuid;
 	while (true) {
-		const bytes = new Uint8Array(16);
+		const bytes = /* @__PURE__ */ new Uint8Array(16);
 		crypto.getRandomValues(bytes);
 		bytes[6] = bytes[6] & 15 | 64;
 		bytes[8] = bytes[8] & 63 | 128;
 		const hex = Array.from(bytes, (byte) => byte.toString(16).padStart(2, ZERO)).join("");
-		uuid = [
-			hex.substring(0, 8),
+		const first = hex.substring(0, 8);
+		if (forHTML && NUMERICAL_PREFIX_PATTERN.test(first)) continue;
+		return [
+			first,
 			hex.substring(8, 12),
 			hex.substring(12, 16),
 			hex.substring(16, 20),
 			hex.substring(20, 32)
-		].join("-");
-		if (!forHTML || !NUMERICAL_PREFIX_PATTERN.test(uuid)) break;
+		].join(forHTML ? DELIMITER_UUID_HTML : DELIMITER_UUID_DEFAULT);
 	}
-	return uuid;
 }
 /**
 * Parse a JSON string into its proper value _(or `undefined` if it fails)_
@@ -3119,6 +3116,8 @@ function truncate(value, length, suffix) {
 	const truncatedLength = length - actualSuffixLength;
 	return `${value.slice(0, truncatedLength)}${actualSuffix}`;
 }
+const DELIMITER_UUID_DEFAULT = "-";
+const DELIMITER_UUID_HTML = "_";
 const NUMERICAL_PREFIX_PATTERN = /^\d/;
 const ZERO = "0";
 //#endregion
@@ -4064,15 +4063,52 @@ const MESSAGE_BEACON = "Cannot retrieve observable from a destroyed beacon";
 const MESSAGE_OBSERVABLE = "Cannot subscribe to a destroyed observable";
 const TYPE_ERROR = "error";
 const TYPE_NEXT = "next";
+//#endregion
+//#region src/internal/math/misc.ts
+/**
+* Round a number
+*
+* @param value Number to round
+* @param decimals Number of decimal places to round to _(defaults to `0`)_
+* @returns Rounded number, or `Number.NaN` if the value if unable to be rounded
+*/
+function round(value, decimals) {
+	return roundNumber(Math.round, value, decimals);
+}
+function roundNumber(callback, value, decimals) {
+	if (typeof value !== "number") return NaN;
+	if (typeof decimals !== "number" || decimals < 1) return callback(value);
+	const mod = 10 ** decimals;
+	return callback((value + Number.EPSILON) * mod) / mod;
+}
+//#endregion
+//#region src/color/misc/index.ts
+function formatHslColor(color, alpha) {
+	const { hue, lightness, saturation } = color.hsl;
+	return `hsl(${hue}deg ${saturation}% ${lightness}%${alpha ? ` / ${color.alpha}%` : ""})`;
+}
+function formatHwbColor(color, alpha) {
+	const { blackness, hue, whiteness } = color.hwb;
+	return `hwb(${hue}deg ${whiteness}% ${blackness}%${alpha ? ` / ${color.alpha}%` : ""})`;
+}
+function formatRgbColor(color, alpha) {
+	const { blue, green, red } = color.rgb;
+	return `rgb(${red} ${green} ${blue}${alpha ? ` / ${color.alpha}%` : ""})`;
+}
 const ALPHA_FULL_HEX_LONG = `ff`;
 const DEFAULT_ALPHA = {
 	hex: ALPHA_FULL_HEX_LONG,
-	value: 1
+	value: 100
 };
 const DEFAULT_HSL = {
 	hue: 0,
-	lightness: 0,
-	saturation: 0
+	saturation: 0,
+	lightness: 0
+};
+const DEFAULT_HWB = {
+	hue: 0,
+	whiteness: 0,
+	blackness: 100
 };
 const DEFAULT_RGB = {
 	blue: 0,
@@ -4090,6 +4126,12 @@ const KEYS_HSL = [
 	"lightness"
 ];
 const KEYS_HSLA = [...KEYS_HSL, "alpha"];
+const KEYS_HWB = [
+	"hue",
+	"whiteness",
+	"blackness"
+];
+const KEYS_HWBA = [...KEYS_HWB, "alpha"];
 const KEYS_RGB = [
 	"red",
 	"green",
@@ -4101,18 +4143,6 @@ const SRGB_LUMINANCE_MODIFIER = 1.055;
 const SRGB_LUMINANCE_MULTIPLIER = 12.92;
 const SRGB_LUMINANCE_OFFSET = .055;
 //#endregion
-//#region src/color/misc/index.ts
-function formatColor(space, color, alpha) {
-	const suffix = alpha ? ` / ${color.alpha}` : "";
-	const value = color[space];
-	return `${space}(${join(keys[space].map((key) => value[key]), SPACE)}${suffix})`;
-}
-const SPACE = " ";
-const keys = {
-	hsl: KEYS_HSL,
-	rgb: KEYS_RGB
-};
-//#endregion
 //#region src/color/misc/alpha.ts
 function getAlpha(value) {
 	if (typeof value === "number") return getAlphaFromValue(value);
@@ -4124,8 +4154,8 @@ function getAlpha(value) {
 }
 function getAlphaHexadecimal(value) {
 	if (value === 0) return "00";
-	if (value === 1) return ALPHA_FULL_HEX_LONG;
-	return Math.round(value * 255).toString(16);
+	if (value === 100) return ALPHA_FULL_HEX_LONG;
+	return round(value * 255).toString(16);
 }
 function getAlphaFromValue(value) {
 	const alpha = getAlphaValue(value);
@@ -4135,9 +4165,147 @@ function getAlphaFromValue(value) {
 	};
 }
 function getAlphaValue(original) {
-	if (Number.isNaN(original) || original >= 100 || original === 1) return 1;
-	if (original < 0) return 0;
-	return original <= 1 ? original : original / 100;
+	if (Number.isNaN(original) || original >= 100) return 100;
+	return original <= 0 ? 0 : original;
+}
+//#endregion
+//#region src/color/misc/get.ts
+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 } = getColorState(value).rgb;
+	const values = [
+		blue / 255,
+		green / 255,
+		red / 255
+	];
+	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;
+	}
+	const color = .2126 * values[2] + .7152 * values[1] + .0722 * values[0] > .625 ? HEX_BLACK : HEX_WHITE;
+	return hex === true ? color : new Color(color);
+}
+/**
+* Get the hex color _(with alpha channel, i.e., opacity)_ from any kind of value
+*
+* - Values that can be parsed are: hex(a) color strings, as well as _HSL(A)_, _HWB(A)_, and _RGB(A)_ color objects
+* - If the value cannot be parsed, a black hex color will be returned
+*
+* @param value Original value
+* @returns Hex color string
+*/
+function getHexaColor(value) {
+	const { alpha, hex } = getColorState(value);
+	return `${hex}${alpha.hex}`;
+}
+/**
+* Get the hex color from any kind of value
+*
+* - Values that can be parsed are: hex(a) color strings, as well as _HSL(A)_, _HWB(A)_, and _RGB(A)_ color objects
+* - If the value cannot be parsed, a black hex color will be returned
+*
+* @param value Original value
+* @returns Hex color string
+*/
+function getHexColor(value) {
+	return getColorState(value).hex;
+}
+function getHexValue(value) {
+	return getClampedValue(value, 0, 255, true);
+}
+function getDegrees(value) {
+	return getClampedValue(value, 0, 360);
+}
+/**
+* Get the _HSLA_ color from any kind of value
+*
+* - Values that can be parsed are: hex(a) color strings, as well as _HSL(A)_, _HWB(A)_, and _RGB(A)_ color objects
+* - If the value cannot be parsed, a black _HSLA_ color will be returned
+*
+* @param value Original value
+* @returns _HSLA_ color
+*/
+function getHslaColor(value) {
+	const { alpha, hsl } = getColorState(value);
+	return {
+		...hsl,
+		alpha: alpha.value
+	};
+}
+/**
+* Get the _HWB_ color from any kind of value
+*
+* - Values that can be parsed are: hex(a) color strings, as well as _HSL(A)_, _HWB(A)_, and _RGB(A)_ color objects
+* - If the value cannot be parsed, a black _HWB_ color will be returned
+*
+* @param value Original value
+* @returns _HWB_ color
+*/
+function getHwbColor(value) {
+	return getColorState(value).hwb;
+}
+/**
+* Get the _HWBA_ color from any kind of value
+*
+* - Values that can be parsed are: hex(a) color strings, as well as _HSL(A)_, _HWB(A)_, and _RGB(A)_ color objects
+* - If the value cannot be parsed, a black _HWBA_ color will be returned
+*
+* @param value Original value
+* @returns _HWBA_ color
+*/
+function getHwbaColor(value) {
+	const { alpha, hwb } = getColorState(value);
+	return {
+		...hwb,
+		alpha: alpha.value
+	};
+}
+/**
+* Get the _HSL_ color from any kind of value
+*
+* - Values that can be parsed are: hex(a) color strings, as well as _HSL(A)_, _HWB(A)_, and _RGB(A)_ color objects
+* - If the value cannot be parsed, a black _HSL_ color will be returned
+*
+* @param value Original value
+* @returns _HSL_ color
+*/
+function getHslColor(value) {
+	return getColorState(value).hsl;
+}
+function getPercentage(value) {
+	return getClampedValue(value, 0, 100);
+}
+/**
+* Get the _RGBA_ color from any kind of value
+*
+* - Values that can be parsed are: hex(a) color strings, as well as _HSL(A)_, _HWB(A)_, and _RGB(A)_ color objects
+* - If the value cannot be parsed, a black _RGBA_ color will be returned
+*
+* @param value Original value
+* @returns _RGBA_ color
+*/
+function getRgbaColor(value) {
+	const { alpha, rgb } = getColorState(value);
+	return {
+		...rgb,
+		alpha: alpha.value
+	};
+}
+/**
+* Get the _RGB_ color from any kind of value
+*
+* - Values that can be parsed are: hex(a) color strings, as well as _HSL(A)_, _HWB(A)_, and _RGB(A)_ color objects
+* - If the value cannot be parsed, a black _RGB_ color will be returned
+*
+* @param value Original value
+* @returns _RGB_ color
+*/
+function getRgbColor(value) {
+	return getColorState(value).rgb;
 }
 //#endregion
 //#region src/color/misc/is.ts
@@ -4145,7 +4313,7 @@ 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, 1);
+	return typeof value === "number" && between(value, 0, 100);
 }
 function isBytey(value) {
 	return typeof value === "number" && between(value, 0, 255);
@@ -4213,161 +4381,92 @@ function isHslaColor(value) {
 function isHslColor(value) {
 	return isColorValue(value, KEYS_HSLA) || isColorValue(value, KEYS_HSL);
 }
-function isHslLike(value) {
-	return hasKeys(value, KEYS_HSL);
-}
 /**
-* Is the value an _RGBA_ color?
+* Is the value like an _HSL_ color?
 *
 * @param value Value to check
-* @returns `true` if the value is an _RGBA_ color, otherwise `false`
+* @returns `true` if the value is like an _HSL_ color, otherwise `false`
 */
-function isRgbaColor(value) {
-	return isColorValue(value, KEYS_RGBA);
+function isHslLike(value) {
+	return hasKeys(value, KEYS_HSL);
 }
 /**
-* Is the value an _RGB_ color?
+* Is the value an _HWBA_ color?
 *
 * @param value Value to check
-* @returns `true` if the value is an _RGB_ color, otherwise `false`
+* @returns `true` if the value is an _HWBA_ color, otherwise `false`
 */
-function isRgbColor(value) {
-	return isColorValue(value, KEYS_RGBA) || isColorValue(value, KEYS_RGB);
-}
-function isRgbLike(value) {
-	return hasKeys(value, KEYS_RGB);
-}
-function isPercentage(value) {
-	return typeof value === "number" && between(value, 0, 100);
-}
-const validators = {
-	alpha: isAlpha,
-	blue: isBytey,
-	green: isBytey,
-	hue: isDegree,
-	lightness: isPercentage,
-	saturation: isPercentage,
-	red: isBytey
-};
-//#endregion
-//#region src/color/misc/get.ts
-function getClampedValue(value, minimum, maximum) {
-	return typeof value === "number" ? clamp(value, minimum, maximum) : minimum;
+function isHwbaColor(value) {
+	return isColorValue(value, KEYS_HWBA);
 }
 /**
-* Get a foreground color _(usually text)_ based on a background color's luminance
-*
-* - Values that can be parsed are: hex(a) color strings, _HSL(A)_ color objects, and _RGB(A)_ color objects
-* - If the value cannot be parsed, a white foreground color will be returned
+* Is the value like an _HWBA_ color?
 *
-* @param value Original value
-* @returns Foreground color
+* @param value Value to check
+* @returns `true` if the value is like an _HWBA_ color, otherwise `false`
 */
-function getForegroundColor(value) {
-	const { blue, green, red } = getColorState(value).rgb;
-	const values = [
-		blue / 255,
-		green / 255,
-		red / 255
-	];
-	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;
-	}
-	return new Color(.2126 * values[2] + .7152 * values[1] + .0722 * values[0] > .625 ? HEX_BLACK : HEX_WHITE);
+function isHwbaLike(value) {
+	return hasKeys(value, KEYS_HWBA);
 }
 /**
-* Get the hex color _(with alpha channel, i.e., opacity)_ from any kind of value
+* Is the value an _HWB_ color?
 *
-* - Values that can be parsed are: hex(a) color strings, _HSL(A)_ color objects, and _RGB(A)_ color objects
-* - If the value cannot be parsed, a black hex color with an alpha channel of `0` will be returned
-*
-* @param value Original value
-* @returns Hex color string
+* @param value Value to check
+* @returns `true` if the value is an _HWB_ color, otherwise `false`
 */
-function getHexaColor(value) {
-	const { alpha, hex } = getColorState(value);
-	return `${hex}${alpha.hex}`;
+function isHwbColor(value) {
+	return isColorValue(value, KEYS_HWB) || isColorValue(value, KEYS_HWBA);
 }
 /**
-* Get the hex color from any kind of value
-*
-* - Values that can be parsed are: hex(a) color strings, _HSL(A)_ color objects, and _RGB(A)_ color objects
-* - If the value cannot be parsed, a black hex color will be returned
+* Is the value like an _HWB_ color?
 *
-* @param value Original value
-* @returns Hex color string
+* @param value Value to check
+* @returns `true` if the value is like an _HWB_ color, otherwise `false`
 */
-function getHexColor(value) {
-	return getColorState(value).hex;
-}
-function getHexValue(value) {
-	return getClampedValue(value, 0, 255);
-}
-function getDegrees(value) {
-	return getClampedValue(value, 0, 360);
+function isHwbLike(value) {
+	return hasKeys(value, KEYS_HWB);
 }
 /**
-* Get the _HSLA_ color from any kind of value
-*
-* - Values that can be parsed are: hex(a) color strings, _HSL(A)_ color objects, and _RGB(A)_ color objects
-* - If the value cannot be parsed, a black _HSLA_ color with an alpha channel _(opacity)_ of `0` will be returned
+* Is the value an _RGBA_ color?
 *
-* @param value Original value
-* @returns _HSLA_ color
+* @param value Value to check
+* @returns `true` if the value is an _RGBA_ color, otherwise `false`
 */
-function getHslaColor(value) {
-	const { alpha, hsl } = getColorState(value);
-	return {
-		...hsl,
-		alpha: alpha.value
-	};
+function isRgbaColor(value) {
+	return isColorValue(value, KEYS_RGBA);
 }
 /**
-* Get the _HSL_ color from any kind of value
-*
-* - Values that can be parsed are: hex(a) color strings, _HSL(A)_ color objects, and _RGB(A)_ color objects
-* - If the value cannot be parsed, a black _HSL_ color will be returned
+* Is the value an _RGB_ color?
 *
-* @param value Original value
-* @returns _HSL_ color
+* @param value Value to check
+* @returns `true` if the value is an _RGB_ color, otherwise `false`
 */
-function getHslColor(value) {
-	return getColorState(value).hsl;
-}
-function getPercentage(value) {
-	return getClampedValue(value, 0, 100);
+function isRgbColor(value) {
+	return isColorValue(value, KEYS_RGBA) || isColorValue(value, KEYS_RGB);
 }
 /**
-* Get the _RGBA_ color from any kind of value
-*
-* - Values that can be parsed are: hex(a) color strings, _HSL(A)_ color objects, and _RGB(A)_ color objects
-* - If the value cannot be parsed, a black _RGBA_ color with an alpha channel _(opacity)_ of `0` will be returned
+* Is the value like an _RGB_ color?
 *
-* @param value Original value
-* @returns _RGBA_ color
+* @param value Value to check
+* @returns `true` if the value is like an _RGB_ color, otherwise `false`
 */
-function getRgbaColor(value) {
-	const { alpha, rgb } = getColorState(value);
-	return {
-		...rgb,
-		alpha: alpha.value
-	};
+function isRgbLike(value) {
+	return hasKeys(value, KEYS_RGB);
 }
-/**
-* Get the _RGB_ color from any kind of value
-*
-* - Values that can be parsed are: hex(a) color strings, _HSL(A)_ color objects, and _RGB(A)_ color objects
-* - If the value cannot be parsed, a black _RGB_ color will be returned
-*
-* @param value Original value
-* @returns _RGB_ color
-*/
-function getRgbColor(value) {
-	return getColorState(value).rgb;
+function isPercentage(value) {
+	return typeof value === "number" && between(value, 0, 100);
 }
+const validators = {
+	alpha: isAlpha,
+	blackness: isPercentage,
+	blue: isBytey,
+	green: isBytey,
+	hue: isDegree,
+	lightness: isPercentage,
+	saturation: isPercentage,
+	red: isBytey,
+	whiteness: isPercentage
+};
 //#endregion
 //#region src/color/space/rgb.ts
 function convertRgbToHex(rgb, alpha) {
@@ -4384,38 +4483,46 @@ function convertRgbToHex(rgb, alpha) {
 	return `${hex}${a}`;
 }
 function convertRgbToHsla(value) {
-	const rgb = isRgbLike(value) ? getRgbValue(value) : { ...DEFAULT_RGB };
-	const blue = rgb.blue / 255;
-	const green = rgb.green / 255;
-	const red = rgb.red / 255;
-	const maxHex = Math.max(blue, green, red);
-	const minHex = Math.min(blue, green, red);
-	const delta = maxHex - minHex;
-	const lightness = (minHex + maxHex) / 2;
+	const values = getRgbValues(isRgbLike(value) ? getRgbValue(value) : { ...DEFAULT_RGB });
+	const { delta, max, min } = values;
+	const lightness = (min + max) / 2;
 	let hue = 0;
 	let saturation = 0;
 	if (delta !== 0) {
-		saturation = (maxHex - lightness) / Math.min(lightness, 1 - lightness);
-		switch (maxHex) {
-			case blue:
-				hue = (red - green) / delta + 4;
-				break;
-			case green:
-				hue = (blue - red) / delta + 2;
-				break;
-			case red:
-				hue = (green - blue) / delta + (green < blue ? 6 : 0);
-				break;
-		}
+		saturation = (max - lightness) / Math.min(lightness, 1 - lightness);
+		hue = getRgbHue(values);
+		hue *= 60;
+	}
+	return {
+		hue,
+		saturation: saturation * 100,
+		lightness: lightness * 100,
+		alpha: getAlphaValue(value?.alpha ?? 100)
+	};
+}
+function convertRgbToHwba(value) {
+	const values = getRgbValues(isRgbLike(value) ? getRgbValue(value) : { ...DEFAULT_RGB });
+	const { delta, max, min } = values;
+	let hue = 0;
+	if (delta !== 0) {
+		hue = getRgbHue(values);
 		hue *= 60;
 	}
 	return {
-		alpha: getAlphaValue(value.alpha ?? 1),
-		hue: +hue.toFixed(2),
-		lightness: +(lightness * 100).toFixed(2),
-		saturation: +(saturation * 100).toFixed(2)
+		hue,
+		whiteness: min * 100,
+		blackness: (1 - max) * 100,
+		alpha: getAlphaValue(value?.alpha ?? 100)
 	};
 }
+function getRgbHue(values) {
+	const { blue, delta, green, max, red } = values;
+	switch (max) {
+		case blue: return (red - green) / delta + 4;
+		case green: return (blue - red) / delta + 2;
+		default: return (green - blue) / delta + (green < blue ? 6 : 0);
+	}
+}
 function getRgbValue(value) {
 	return {
 		blue: getHexValue(value.blue),
@@ -4423,6 +4530,21 @@ function getRgbValue(value) {
 		red: getHexValue(value.red)
 	};
 }
+function getRgbValues(rgb) {
+	const blue = rgb.blue / 255;
+	const green = rgb.green / 255;
+	const red = rgb.red / 255;
+	const max = Math.max(blue, green, red);
+	const min = Math.min(blue, green, red);
+	return {
+		blue,
+		delta: max - min,
+		green,
+		max,
+		min,
+		red
+	};
+}
 /**
 * Convert an _RGB(A)_ color to a hex color _(with optional alpha channel, i.e., opacity)_
 *
@@ -4438,7 +4560,7 @@ function rgbToHex(rgb, alpha) {
 /**
 * Convert an _RGB(A)_ color to an _HSL_ color
 *
-* _If the value is unable to be converted, a black HSL color will be returned_
+* _If the value is unable to be converted, a black _HSL_ color will be returned_
 *
 * _Thanks, https://github.com/color-js/color.js/blob/main/src/spaces/hsl.js#L26_
 *
@@ -4456,7 +4578,7 @@ function rgbToHsl(rgb) {
 /**
 * Convert an _RGB(A)_ color to an _HSLA_ color
 *
-* _If the value is unable to be converted, a black _HSLA_ color with an alpha channel (opacity) of `0` will be returned_
+* _If the value is unable to be converted, a black _HSLA_ color will be returned_
 *
 * _Thanks, https://github.com/color-js/color.js/blob/main/src/spaces/hsl.js#L26_
 *
@@ -4466,6 +4588,37 @@ function rgbToHsl(rgb) {
 function rgbToHsla(rgb) {
 	return convertRgbToHsla(rgb);
 }
+/**
+* Convert an _RGB(A)_ color to an _HWB_ color
+*
+* _If the value is unable to be converted, a black _HWB_ color will be returned_
+*
+* _Thanks, https://github.com/color-js/color.js/blob/main/src/spaces/hsl.js#L26_
+*
+* @param rgb _RGB(A)_ color
+* @returns _HWB_ color
+*/
+function rgbToHwb(rgb) {
+	const { blackness, hue, whiteness } = convertRgbToHwba(rgb);
+	return {
+		hue,
+		whiteness,
+		blackness
+	};
+}
+/**
+* Convert an _RGB(A)_ color to an _HWBA_ color
+
+* _If the value is unable to be converted, a black _HWBA_ color will be returned_
+*
+* _Thanks, https://github.com/color-js/color.js/blob/main/src/spaces/hsl.js#L26_
+*
+* @param rgb _RGB(A)_ color
+* @returns _HWBA_ color
+*/
+function rgbToHwba(rgb) {
+	return convertRgbToHwba(rgb);
+}
 //#endregion
 //#region src/color/space/hex.ts
 function convertHexToRgba(value) {
@@ -4475,10 +4628,10 @@ function convertHexToRgba(value) {
 	const { length } = pairs;
 	for (let index = 1; index < length; index += 1) values.push(Number.parseInt(pairs[index], 16));
 	return {
-		alpha: values[3] / 255,
-		blue: values[2],
-		green: values[1],
-		red: values[0]
+		alpha: getPercentage(values[3] / 255 * 100),
+		blue: getHexValue(values[2]),
+		green: getHexValue(values[1]),
+		red: getHexValue(values[0])
 	};
 }
 /**
@@ -4497,6 +4650,14 @@ function getNormalizedHex(value, alpha) {
 	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 : ""}`;
 }
+/**
+* Convert a hex color string to a _HSL_ color
+*
+* _If the value is unable to be converted, a black _HSL_ color will be returned_
+*
+* @param value Hex color string
+* @returns _HSL_ color
+*/
 function hexToHsl(value) {
 	const { hue, lightness, saturation } = hexToHsla(value);
 	return {
@@ -4505,13 +4666,48 @@ function hexToHsl(value) {
 		saturation
 	};
 }
+/**
+* Convert a hex color string to a _HSLA_ color
+*
+* _If the value is unable to be converted, a black _HSLA_ color will be returned_
+*
+* @param value Hex color string
+* @returns _HSLA_ color
+*/
 function hexToHsla(value) {
 	return convertRgbToHsla(convertHexToRgba(value));
 }
 /**
+* Convert a hex color string to a _HWB_ color
+*
+* _If the value is unable to be converted, a black _HWB_ color will be returned_
+*
+* @param value Hex color string
+* @returns _HWB_ color
+*/
+function hexToHwb(value) {
+	const { blackness, hue, whiteness } = hexToHwba(value);
+	return {
+		hue,
+		whiteness,
+		blackness
+	};
+}
+/**
+* Convert a hex color string to a _HWBA_ color
+*
+* _If the value is unable to be converted, a black _HWBA_ color will be returned_
+*
+* @param value Hex color string
+* @returns _HWBA_ color
+*/
+function hexToHwba(value) {
+	return convertRgbToHwba(convertHexToRgba(value));
+}
+/**
 * Convert a hex color to an _RGB_ color
 *
-* _If the value is unable to be converted, a black RGB color will be returned_
+* _If the value is unable to be converted, a black _RGB_ color will be returned_
 *
 * @param value Original value
 * @returns _RGB_ color
@@ -4527,7 +4723,7 @@ function hexToRgb(value) {
 /**
 * Convert a hex color to an _RGBA_ color
 *
-* _If the value is unable to be converted, a black RGBA color with an alpha channel (opacity) of `0` will be returned_
+* _If the value is unable to be converted, a black _RGBA_ color will be returned_
 *
 * @param value Original value
 * @returns _RGBA_ color
@@ -4537,16 +4733,31 @@ function hexToRgba(value) {
 }
 //#endregion
 //#region src/color/space/hsl.ts
-function convertHslToRgba(value) {
-	const hsl = isHslLike(value) ? getHslValue(value) : { ...DEFAULT_HSL };
+function convertHslToHwba(input) {
+	let { hue, lightness, saturation } = isHslLike(input) ? getHslValue(input) : { ...DEFAULT_HSL };
+	lightness /= 100;
+	saturation /= 100;
+	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)
+	};
+}
+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;
 	return {
-		alpha: getAlphaValue(value.alpha ?? 1),
-		blue: getHexValue(Math.round(getHexyValue(hue, lightness, saturation, 4))),
-		green: getHexValue(Math.round(getHexyValue(hue, lightness, saturation, 8))),
-		red: getHexValue(Math.round(getHexyValue(hue, lightness, saturation, 0)))
+		alpha: getAlphaValue(input?.alpha ?? 100),
+		blue: getHexValue(getHexyValue(hue, lightness, saturation, 4)),
+		green: getHexValue(getHexyValue(hue, lightness, saturation, 8)),
+		red: getHexValue(getHexyValue(hue, lightness, saturation, 0))
 	};
 }
 function getHexyValue(hue, lightness, saturation, value) {
@@ -4556,22 +4767,58 @@ function getHexyValue(hue, lightness, saturation, value) {
 function getHslValue(value) {
 	return {
 		hue: getDegrees(value.hue),
-		lightness: getPercentage(value.lightness),
-		saturation: getPercentage(value.saturation)
+		saturation: getPercentage(value.saturation),
+		lightness: getPercentage(value.lightness)
 	};
 }
+/**
+* Convert an _HSL(A)_ color to a hex color _(with optional alpha channel, i.e., opacity)_
+*
+* _If the value is unable to be converted, a black hex color will be returned_
+*
+* @param hsl _HSL(A)_ color
+* @param alpha Include alpha channel _(opacity)_? _(defaults to `false`)_
+* @returns Hex color string
+*/
 function hslToHex(hsl, alpha) {
 	return convertRgbToHex(convertHslToRgba(hsl), alpha ?? false);
 }
 /**
+* Convert an _HSL(A)_ color to an _HWB_ color
+*
+* _If the value is unable to be converted, a black _HWB_ color will be returned_
+*
+* @param hsl HSL(A) color
+* @returns _HWB_ color
+*/
+function hslToHwb(hsl) {
+	const { blackness, hue, whiteness } = convertHslToHwba(hsl);
+	return {
+		hue,
+		whiteness,
+		blackness
+	};
+}
+/**
+* Convert an _HSL(A)_ color to an _HWBA_ color
+*
+* _If the value is unable to be converted, a black _HWBA_ color will be returned_
+*
+* @param hsl HSL(A) color
+* @returns _HWBA_ color
+*/
+function hslToHwba(hsl) {
+	return convertHslToHwba(hsl);
+}
+/**
 * Convert an _HSL(A)_ color to an _RGB_ color
 *
-* _If the value is unable to be converted, a black RGB color will be returned_
+* _If the value is unable to be converted, a black _RGB_ color will be returned_
 *
 * _Thanks, https://github.com/color-js/color.js/blob/main/src/spaces/hsl.js#L61_
 *
 * @param hsl HSL(A) color
-* @returns RGB color
+* @returns _RGB_ color
 */
 function hslToRgb(hsl) {
 	const { blue, green, red } = convertHslToRgba(hsl);
@@ -4584,79 +4831,204 @@ function hslToRgb(hsl) {
 /**
 * Convert an _HSL(A)_ color to an _RGBA_ color
 *
-* _If the value is unable to be converted, a black RGBA color with an alpha channel (opactiy) of `0` will be returned_
+* _If the value is unable to be converted, a black _RGBA_ color will be returned_
 *
 * _Thanks, https://github.com/color-js/color.js/blob/main/src/spaces/hsl.js#L61_
 *
 * @param hsl HSL(A) color
-* @returns RGBA color
+* @returns _RGBA_ color
 */
 function hslToRgba(hsl) {
 	return convertHslToRgba(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;
+	if (blackness + whiteness > 1) {
+		const total = blackness + whiteness;
+		blackness /= total;
+		whiteness /= total;
+	}
+	const lightness = (1 - blackness + whiteness) / 2;
+	return {
+		hue,
+		saturation: getHwbSaturation(blackness, whiteness, lightness) * 100,
+		lightness: lightness * 100,
+		alpha: getAlphaValue(input?.alpha ?? 100)
+	};
+}
+function getHwbSaturation(blackness, whiteness, lightness) {
+	const hue = 1 - blackness - whiteness;
+	if (hue <= 0) return 0;
+	return hue / Math.min(2 * lightness, 2 - 2 * lightness);
+}
+function getHwbValue(value) {
+	return {
+		hue: getDegrees(value.hue),
+		whiteness: getPercentage(value.whiteness),
+		blackness: getPercentage(value.blackness)
+	};
+}
+/**
+* Convert an _HWB(A)_ color to a hex color _(with optional alpha channel, i.e., opacity)_
+*
+* _If the value is unable to be converted, a black hex color will be returned_
+*
+* @param hwb _HWB(A)_ color
+* @param alpha Include alpha channel _(opacity)_? _(defaults to `false`)_
+* @returns Hex color string
+*/
+function hwbToHex(hwb, alpha) {
+	return rgbToHex(hwbToRgb(hwb), alpha);
+}
+/**
+* Convert an _HWB(A)_ color to an _RGB_ color
+*
+* _If the value is unable to be converted, a black _RGB_ color will be returned_
+*
+* @param hwb _HWB(A)_ color
+* @returns _RGB_ color
+*/
+function hwbToHsl(hwb) {
+	const { hue, lightness, saturation } = convertHwbToHsl(hwb);
+	return {
+		hue,
+		lightness,
+		saturation
+	};
+}
+/**
+* Convert an _HWB(A)_ color to an _HSLA_ color
+*
+* _If the value is unable to be converted, a black _HSLA_ color will be returned_
+*
+* @param hwb _HWB(A)_ color
+* @returns _HSLA_ color
+*/
+function hwbToHsla(hwb) {
+	return convertHwbToHsl(hwb);
+}
+/**
+* Convert an _HWB(A)_ color to an _RGB_ color
+*
+* _If the value is unable to be converted, a black _RGB_ color will be returned_
+*
+* @param hwb _HWB(A)_ color
+* @returns _RGB_ color
+*/
+function hwbToRgb(hwb) {
+	return hslToRgb(hwbToHsl(hwb));
+}
+/**
+* Convert an _HWB(A)_ color to an _RGBA_ color
+*
+* _If the value is unable to be converted, a black _RGBA_ color will be returned_
+*
+* @param hwb _HWB(A)_ color
+* @returns _RGBA_ color
+*/
+function hwbToRgba(hwb) {
+	return hslToRgba(hwbToHsla(hwb));
+}
+//#endregion
 //#region src/color/misc/state.ts
 function getColorState(value) {
-	if (typeof value === "string") {
-		const normalized = getNormalizedHex(value, true);
-		const hex = normalized.slice(0, 6);
-		const rgb = hexToRgb(hex);
-		return {
-			hex,
-			rgb,
-			alpha: getAlpha(normalized.slice(6)),
-			hsl: rgbToHsl(rgb)
-		};
-	}
+	if (typeof value === "string") return getColorStateForHex(value);
 	if (isColor(value)) return {
 		hex: value.hex,
 		hsl: value.hsl,
+		hwb: value.hwb,
 		rgb: value.rgb,
 		alpha: getAlpha(value.alpha)
 	};
 	const state = {};
 	if (typeof value === "object" && value !== null) {
 		state.alpha = getAlpha(value.alpha);
-		if (KEYS_HSL.every((key) => key in value)) {
-			state.hsl = getHslValue(value);
-			state.rgb = hslToRgb(state.hsl);
-			state.hex = rgbToHex(state.rgb);
-			return state;
-		}
-		if (KEYS_RGB.every((key) => key in value)) {
-			state.rgb = getRgbValue(value);
-			state.hex = rgbToHex(state.rgb);
-			state.hsl = rgbToHsl(state.rgb);
-			return state;
-		}
+		if (KEYS_HSL.every((key) => key in value)) return getColorStateForHsl(state, value);
+		if (KEYS_HWB.every((key) => key in value)) return getColorStateForHwb(state, value);
+		if (KEYS_RGB.every((key) => key in value)) return getColorStateForRgb(state, value);
 	}
-	state.alpha ??= getAlpha(1);
-	state.hex ??= HEX_BLACK;
-	state.hsl ??= { ...DEFAULT_HSL };
-	state.rgb ??= { ...DEFAULT_RGB };
+	return getDefaultColorState(state);
+}
+function getColorStateForHex(value) {
+	const normalized = getNormalizedHex(value, true);
+	const hex = normalized.slice(0, 6);
+	const hsl = hexToHsl(hex);
+	return {
+		hex,
+		hsl,
+		alpha: getAlpha(normalized.slice(6)),
+		hwb: hslToHwb(hsl),
+		rgb: hslToRgb(hsl)
+	};
+}
+function getColorStateForHsl(state, value) {
+	state.hsl = getHslValue(value);
+	state.rgb = hslToRgb(state.hsl);
+	state.hex = hslToHex(state.hsl);
+	state.hwb = hslToHwb(state.hsl);
+	return state;
+}
+function getColorStateForHwb(state, value) {
+	state.hwb = getHwbValue(value);
+	state.hsl = hwbToHsl(state.hwb);
+	state.rgb = hwbToRgb(state.hwb);
+	state.hex = hwbToHex(state.hwb);
+	return state;
+}
+function getColorStateForRgb(state, value) {
+	state.rgb = getRgbValue(value);
+	state.hex = rgbToHex(state.rgb);
+	state.hsl = rgbToHsl(state.rgb);
+	state.hwb = rgbToHwb(state.rgb);
+	return state;
+}
+function getDefaultColorState(state) {
+	state.alpha = getAlpha(100);
+	state.hex = HEX_BLACK;
+	state.hsl = { ...DEFAULT_HSL };
+	state.hwb = { ...DEFAULT_HWB };
+	state.rgb = { ...DEFAULT_RGB };
 	return state;
 }
 function setHexColor(state, value, alpha) {
 	if (!isHexColor(value) || !alpha && value === state.hex) return;
 	const normalized = getNormalizedHex(value, true);
 	const hex = normalized.slice(0, 6);
-	const rgb = hexToRgb(hex);
+	const hsl = hexToHsl(hex);
 	state.hex = hex;
-	state.hsl = rgbToHsl(rgb);
-	state.rgb = rgb;
+	state.hsl = hsl;
+	state.rgb = hslToRgb(hsl);
+	state.hwb = hslToHwb(hsl);
 	if (alpha) state.alpha = getAlpha(normalized.slice(6));
 }
 function setHSLColor(state, value, alpha) {
 	if (!isHslLike(value)) return;
 	const hsl = {
 		hue: getDegrees(value.hue),
-		lightness: getPercentage(value.lightness),
-		saturation: getPercentage(value.saturation)
+		saturation: getPercentage(value.saturation),
+		lightness: getPercentage(value.lightness)
 	};
-	const rgb = hslToRgb(hsl);
-	state.hex = rgbToHex(rgb);
 	state.hsl = hsl;
-	state.rgb = rgb;
+	state.hex = hslToHex(hsl);
+	state.hwb = hslToHwb(hsl);
+	state.rgb = hslToRgb(hsl);
+	if (alpha) state.alpha = getAlpha(value.alpha);
+}
+function setHWBColor(state, value, alpha) {
+	if (!isHwbLike(value)) return;
+	const hwb = {
+		hue: getDegrees(value.hue),
+		whiteness: getPercentage(value.whiteness),
+		blackness: getPercentage(value.blackness)
+	};
+	state.hwb = hwb;
+	state.hex = hwbToHex(hwb);
+	state.hsl = hwbToHsl(hwb);
+	state.rgb = hwbToRgb(hwb);
 	if (alpha) state.alpha = getAlpha(value.alpha);
 }
 function setRGBColor(state, value, alpha) {
@@ -4666,9 +5038,11 @@ function setRGBColor(state, value, alpha) {
 		green: getHexValue(value.green),
 		red: getHexValue(value.red)
 	};
-	state.hex = rgbToHex(rgb);
-	state.hsl = rgbToHsl(rgb);
+	const hsl = rgbToHsl(rgb);
+	state.hsl = hsl;
 	state.rgb = rgb;
+	state.hex = hslToHex(hsl);
+	state.hwb = hslToHwb(hsl);
 	if (alpha) state.alpha = getAlpha(value.alpha);
 }
 //#endregion
@@ -4679,18 +5053,15 @@ function setRGBColor(state, value, alpha) {
 var Color = class {
 	#state;
 	/**
-	* Get the alpha channel _(opacity)_ of the color
+	* Get the alpha channel _(opacity)_ of the color as a percentage between `0` and `100`
 	*
-	* @returns Current alpha channel value between `0` and `1`
+	* @returns Current alpha channel value
 	*/
 	get alpha() {
 		return this.#state.alpha.value;
 	}
 	/**
-	* Set the alpha channel _(opacity)_ of the color, as:
-	*
-	* - A number between `0` and `1`, where `0` is fully transparent and `1` is fully opaque
-	* - A number between `0` and `100`, where `0` is fully transparent and `100` is fully opaque
+	* Set the alpha channel _(opacity)_ of the color as a percentage between `0` and `100`
 	*
 	* @param value New alpha channel value
 	*/
@@ -4745,7 +5116,7 @@ var Color = class {
 	* @returns Current color as an _HSL_ color
 	*/
 	get hsl() {
-		return this.#state.hsl;
+		return { ...this.#state.hsl };
 	}
 	/**
 	* Set colors from an _HSL_ color
@@ -4775,12 +5146,47 @@ var Color = class {
 		setHSLColor(this.#state, value, true);
 	}
 	/**
+	* Get the color as an _HWB_ color
+	*
+	* @returns Current color as an _HWB_ color
+	*/
+	get hwb() {
+		return { ...this.#state.hwb };
+	}
+	/**
+	* Set colors from an _HWB_ color
+	*
+	* @param value New _HWB_ color
+	*/
+	set hwb(value) {
+		setHWBColor(this.#state, value, false);
+	}
+	/**
+	* Get the color as an _HWBA_ color
+	*
+	* @returns Current color as an _HWBA_ color
+	*/
+	get hwba() {
+		return {
+			...this.#state.hwb,
+			alpha: this.#state.alpha.value
+		};
+	}
+	/**
+	* Set colors and alpha from an _HWBA_ color
+	*
+	* @param value New _HWBA_ color
+	*/
+	set hwba(value) {
+		setHWBColor(this.#state, value, true);
+	}
+	/**
 	* Get the color as an _RGB_ color
 	*
 	* @returns Current color as an _RGB_ color
 	*/
 	get rgb() {
-		return this.#state.rgb;
+		return { ...this.#state.rgb };
 	}
 	/**
 	* Set colors from an _RGB_ color
@@ -4829,7 +5235,16 @@ var Color = class {
 	* @returns _HSL(A)_ color string
 	*/
 	toHslString(alpha) {
-		return formatColor("hsl", this, alpha === true);
+		return formatHslColor(this, alpha === true);
+	}
+	/**
+	* Get the color as an _HWB(A)_ string
+	*
+	* @param alpha Include alpha channel _(opacity)_? _(defaults to `false`)_
+	* @returns _HWB(A)_ color string
+	*/
+	toHwbString(alpha) {
+		return formatHwbColor(this, alpha === true);
 	}
 	/**
 	* Get the color as an _RGB(A)_ string
@@ -4838,7 +5253,7 @@ var Color = class {
 	* @returns _RGB(A)_ color string
 	*/
 	toRgbString(alpha) {
-		return formatColor("rgb", this, alpha === true);
+		return formatRgbColor(this, alpha === true);
 	}
 	/**
 	* Get the color as a hex color string
@@ -4854,7 +5269,7 @@ var Color = class {
 /**
 * Get a _Color_ from any kind of value
 *
-* - Values that can be parsed are: hex(a) color strings, _HSL(A)_ color objects, and _RGB(A)_ color objects
+* - Values that can be parsed are: hex(a) color strings, as well as _HSL(A)_, _HWB(A)_, and _RGB(A)_ color objects
 * - If the value is unable to be parsed, a black _Color_ will be returned
 *
 * @param value Original value
@@ -5003,22 +5418,6 @@ function median(array, key) {
 function min(array, key) {
 	return getAggregated("min", array, key);
 }
-/**
-* Round a number
-*
-* @param value Number to round
-* @param decimals Number of decimal places to round to _(defaults to `0`)_
-* @returns Rounded number, or `Number.NaN` if the value if unable to be rounded
-*/
-function round(value, decimals) {
-	return roundNumber(Math.round, value, decimals);
-}
-function roundNumber(callback, value, decimals) {
-	if (typeof value !== "number") return NaN;
-	if (typeof decimals !== "number" || decimals < 1) return callback(value);
-	const mod = 10 ** decimals;
-	return callback((value + Number.EPSILON) * mod) / mod;
-}
 function sum(array, key) {
 	return getAggregated("sum", array, key);
 }
@@ -5062,7 +5461,7 @@ const PROMISE_MESSAGE_EXPECTATION_ATTEMPT = "Attempt expected a function or a pr
 const PROMISE_MESSAGE_EXPECTATION_RESULT = "toResult expected a Promise";
 const PROMISE_MESSAGE_EXPECTATION_TIMED = "Timed function expected a Promise";
 const PROMISE_MESSAGE_TIMEOUT = "Promise timed out";
-const PROMISE_STRATEGY_ALL = new Set(["complete", "first"]);
+const PROMISE_STRATEGY_ALL = /* @__PURE__ */ new Set(["complete", "first"]);
 const PROMISE_STRATEGY_DEFAULT = "complete";
 const PROMISE_TYPE_FULFILLED = "fulfilled";
 const PROMISE_TYPE_REJECTED = "rejected";
@@ -5354,7 +5753,7 @@ const EQUAL = "=";
 const EXPRESSION_ARRAY_SUFFIX = /\[\]$/;
 const EXPRESSION_BOOLEAN = /^(false|true)$/;
 const TRUE = "true";
-const TYPES = new Set([
+const TYPES = /* @__PURE__ */ new Set([
 	"boolean",
 	"number",
 	"string"
@@ -5957,4 +6356,4 @@ var SizedSet = class extends Set {
 	}
 };
 //#endregion
-export { CancelablePromise, Logger, PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, PromiseTimeoutError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, copy, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, filter, find, findLast, first, firstOrDefault, flatFreeze, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, getError, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hasValueResult, herald, hexToHsl, hexToHsla, hexToRgb, hexToRgba, hslToHex, hslToRgb, hslToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, interpolate, intersection, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFrozen, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isInstanceOf, isKey, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isSorted, isTypedArray, join, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, lowerCase, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, round, select, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };
+export { CancelablePromise, Logger, PROMISE_ABORT_EVENT, PROMISE_ABORT_OPTIONS, PROMISE_ERROR_NAME, PROMISE_MESSAGE_EXPECTATION_ATTEMPT, PROMISE_MESSAGE_EXPECTATION_RESULT, PROMISE_MESSAGE_EXPECTATION_TIMED, PROMISE_MESSAGE_TIMEOUT, PROMISE_STRATEGY_ALL, PROMISE_STRATEGY_DEFAULT, PROMISE_TYPE_FULFILLED, PROMISE_TYPE_REJECTED, PromiseTimeoutError, RetryError, SORT_DIRECTION_ASCENDING, SORT_DIRECTION_DESCENDING, SizedMap, SizedSet, assert, assertCondition, assertDefined, assertInstanceOf, assertIs, assertProperty, assign, asyncAttempt, asyncDebounce, asyncFlow, asyncMatchResult, asyncOnce, asyncPipe, asyncThrottle, attempt, attemptAsyncFlow, attemptAsyncPipe, attemptFlow, attemptPipe, attemptPromise, average, beacon, between, camelCase, cancelable, capitalize, ceil, chunk, clamp, clone, compact, compare, copy, count, debounce, deburr, dedent, delay, deregisterCloner, deregisterComparator, deregisterEqualizer, diff, difference, drop, endsWith, endsWithArray, equal, error, exclude, exists, filter, find, findLast, first, firstOrDefault, flatFreeze, flatten, floor, flow, freeze, fromQuery, toPromise as fromResult, toPromise, fuzzy, fuzzyMatch, getArray, getArrayComparison, getColor, getError, getForegroundColor, getHexColor, getHexaColor, getHslColor, getHslaColor, getHwbColor, getHwbaColor, getNormalizedHex, getNumber, getRandomBoolean, getRandomCharacters, getRandomColor, getRandomFloatingNumber as getRandomFloat, getRandomHex, getRandomInteger, getRandomItem, getRandomItems, getRgbColor, getRgbaColor, getSortedIndex, getString, getTimedPromise, getUuid, getValue, groupArraysBy, groupBy, handleResult, hasValue, hasValueResult, herald, hexToHsl, hexToHsla, hexToHwb, hexToHwba, hexToRgb, hexToRgba, hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba, hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba, ignoreKey, inMap, inSet, includes, includesArray, indexOf, indexOfArray, initializeAssigner, initializeEqualizer, initializeMerger, initializeNormalizer, initializeSorter, initializeTemplater, initializeTransformer, insert, interpolate, intersection, isArrayOrPlainObject, isColor, isConstructor, isEmpty, isError, isFrozen, isFulfilled, isHexColor, isHslColor, isHslLike, isHslaColor, isHwbColor, isHwbLike, isHwbaColor, isHwbaLike, isInstanceOf, isKey, isNonArrayOrPlainObject, isNonConstructor, isNonEmpty, isNonInstanceOf, isNonKey, isNonNullable, isNonNullableOrEmpty, isNonNullableOrWhitespace, isNonNumber, isNonNumerical, isNonObject, isNonPlainObject, isNonPrimitive, isNonTypedArray, isNullable, isNullableOrEmpty, isNullableOrWhitespace, isNumber, isNumerical, isObject, isOk, isPlainObject, isPrimitive, isRejected, isResult, isRgbColor, isRgbLike, isRgbaColor, isSorted, isTypedArray, join, kebabCase, keyedQueue, last, lastIndexOf, lastOrDefault, lowerCase, matchResult, max, median, memoize, merge, min, move, moveIndices, moveToIndex, noop, normalize, ok, omit, once, parse, partition, pascalCase, pick, pipe, promises, push, queue, range, registerCloner, registerComparator, registerEqualizer, resultPromises, retry, reverse, rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba, round, select, setValue, settlePromise, shake, shuffle, single, slice, smush, snakeCase, sort, splice, startsWith, startsWithArray, sum, swap, take, template, throttle, timed, times, titleCase, toMap, toMapArrays, toQuery, toRecord, toRecordArrays, toResult, toSet, toggle, transform, trim, truncate, tryDecode, tryEncode, union, unique, unsmush, unwrap, update, upperCase, words };