@oscarpalmer/atoms 0.188.1 → 0.189.1

package/dist/color/misc/state.mjs

@@ -1,72 +1,106 @@
-import { DEFAULT_HSL, DEFAULT_RGB, HEX_BLACK, KEYS_HSL, KEYS_RGB } from "../constants.mjs";
+import { DEFAULT_HSL, DEFAULT_HWB, DEFAULT_RGB, HEX_BLACK, KEYS_HSL, KEYS_HWB, KEYS_RGB } from "../constants.mjs";
 import { getAlpha } from "./alpha.mjs";
-import { isColor, isHexColor, isHslLike, isRgbLike } from "./is.mjs";
 import { getDegrees, getHexValue, getPercentage } from "./get.mjs";
-import { getRgbValue, rgbToHex, rgbToHsl } from "../space/rgb.mjs";
-import { getNormalizedHex, hexToRgb } from "../space/hex.mjs";
-import { getHslValue, hslToRgb } from "../space/hsl.mjs";
+import { isColor, isHexColor, isHslLike, isHwbLike, isRgbLike } from "./is.mjs";
+import { getRgbValue, rgbToHex, rgbToHsl, rgbToHwb } from "../space/rgb.mjs";
+import { getNormalizedHex, hexToHsl } from "../space/hex.mjs";
+import { getHslValue, hslToHex, hslToHwb, hslToRgb } from "../space/hsl.mjs";
+import { getHwbValue, hwbToHex, hwbToHsl, hwbToRgb } from "../space/hwb.mjs";
 //#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) {
@@ -76,10 +110,12 @@ 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
-export { getColorState, setHSLColor, setHexColor, setRGBColor };
+export { getColorState, setHSLColor, setHWBColor, setHexColor, setRGBColor };

package/dist/color/models.d.mts

@@ -30,6 +30,21 @@ type HSLColor = {
    */
   saturation: number;
 };
+type HWBColor = {
+  /**
+   * Blackness of the color _(in percentage; 0-100)_
+   */
+  blackness: number;
+  /**
+   * Hue of the color _(in degrees; 0-360)_
+   */
+  hue: number;
+  /**
+   * Whiteness of the color _(in percentage; 0-100)_
+   */
+  whiteness: number;
+};
+type HWBAColor = HWBColor & ColorWithAlpha;
 /**
  * An _RGB_ color with an alpha channel _(opacity)_
  */
@@ -51,13 +66,14 @@ type RGBColor = {
    */
   red: number;
 };
-type ColorProperty = 'alpha' | 'blue' | 'green' | 'hue' | 'lightness' | 'red' | 'saturation';
+type ColorProperty = 'alpha' | keyof HSLColor | keyof HWBColor | keyof RGBColor;
 type ColorSpace = 'hsl' | 'rgb';
 type ColorState = {
   alpha: Alpha;
   hex: string;
   hsl: HSLColor;
+  hwb: HWBColor;
   rgb: RGBColor;
 };
 //#endregion
-export { Alpha, ColorProperty, ColorSpace, ColorState, HSLAColor, HSLColor, RGBAColor, RGBColor };
+export { Alpha, ColorProperty, ColorSpace, ColorState, HSLAColor, HSLColor, HWBAColor, HWBColor, RGBAColor, RGBColor };

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

@@ -1,5 +1,4 @@
-import { HSLAColor, HSLColor, RGBAColor, RGBColor } from "../models.mjs";
-
+import { HSLAColor, HSLColor, HWBAColor, HWBColor, RGBAColor, RGBColor } from "../models.mjs";
 //#region src/color/space/hex.d.ts
 /**
  * Get the normalized hex color from a value
@@ -11,12 +10,46 @@ import { HSLAColor, HSLColor, RGBAColor, RGBColor } from "../models.mjs";
  * @returns Normalized hex color
  */
 declare function getNormalizedHex(value: unknown, alpha?: boolean): string;
+/**
+ * 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
+ */
 declare function hexToHsl(value: string): HSLColor;
+/**
+ * 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
+ */
 declare function hexToHsla(value: string): HSLAColor;
+/**
+ * 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
+ */
+declare function hexToHwb(value: string): HWBColor;
+/**
+ * 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
+ */
+declare function hexToHwba(value: string): HWBAColor;
 /**
  * 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
@@ -25,11 +58,11 @@ declare function hexToRgb(value: string): RGBColor;
 /**
  * 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
  */
 declare function hexToRgba(value: string): RGBAColor;
 //#endregion
-export { getNormalizedHex, hexToHsl, hexToHsla, hexToRgb, hexToRgba };
+export { getNormalizedHex, hexToHsl, hexToHsla, hexToHwb, hexToHwba, hexToRgb, hexToRgba };

package/dist/color/space/hex.mjs

@@ -1,7 +1,8 @@
 import { join } from "../../internal/string.mjs";
 import { ALPHA_FULL_HEX_LONG, EXPRESSION_HEX_LONG, EXPRESSION_PREFIX, HEX_BLACK } from "../constants.mjs";
+import { getHexValue, getPercentage } from "../misc/get.mjs";
 import { isHexColor } from "../misc/is.mjs";
-import { convertRgbToHsla } from "./rgb.mjs";
+import { convertRgbToHsla, convertRgbToHwba } from "./rgb.mjs";
 //#region src/color/space/hex.ts
 function convertHexToRgba(value) {
 	const normalized = getNormalizedHex(value, true);
@@ -10,10 +11,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])
 	};
 }
 /**
@@ -29,9 +30,21 @@ 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)));
+	if (normalized.length < 6) {
+		const hex = normalized.slice(0, 3);
+		const a = includeAlpha ? normalized[3] ?? "f" : "";
+		return join(`${hex}${a}`.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 {
@@ -40,13 +53,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
@@ -62,7 +110,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
@@ -71,4 +119,4 @@ function hexToRgba(value) {
 	return convertHexToRgba(value);
 }
 //#endregion
-export { getNormalizedHex, hexToHsl, hexToHsla, hexToRgb, hexToRgba };
+export { getNormalizedHex, hexToHsl, hexToHsla, hexToHwb, hexToHwba, hexToRgb, hexToRgba };

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

@@ -1,29 +1,55 @@
-import { HSLAColor, HSLColor, RGBAColor, RGBColor } from "../models.mjs";
-
+import { HSLAColor, HSLColor, HWBAColor, HWBColor, RGBAColor, RGBColor } from "../models.mjs";
 //#region src/color/space/hsl.d.ts
 declare function getHslValue(value: Record<keyof HSLColor, unknown>): HSLColor;
+/**
+ * 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
+ */
 declare function hslToHex(hsl: HSLAColor | HSLColor, alpha?: boolean): string;
+/**
+ * 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
+ */
+declare function hslToHwb(hsl: HSLAColor | HSLColor): HWBColor;
+/**
+ * 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
+ */
+declare function hslToHwba(hsl: HSLAColor | HSLColor): HWBAColor;
 /**
  * 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
  */
 declare function hslToRgb(hsl: HSLAColor | HSLColor): RGBColor;
 /**
  * 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
  */
 declare function hslToRgba(hsl: HSLAColor | HSLColor): RGBAColor;
 //#endregion
-export { getHslValue, hslToHex, hslToRgb, hslToRgba };
+export { getHslValue, hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba };

package/dist/color/space/hsl.mjs

@@ -1,19 +1,34 @@
 import { DEFAULT_HSL } from "../constants.mjs";
 import { getAlphaValue } from "../misc/alpha.mjs";
-import { isHslLike } from "../misc/is.mjs";
 import { getDegrees, getHexValue, getPercentage } from "../misc/get.mjs";
+import { isHslLike } from "../misc/is.mjs";
 import { convertRgbToHex } from "./rgb.mjs";
 //#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) {
@@ -23,22 +38,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);
@@ -51,15 +102,15 @@ 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
-export { getHslValue, hslToHex, hslToRgb, hslToRgba };
+export { getHslValue, hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba };

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

@@ -0,0 +1,52 @@
+import { HSLAColor, HSLColor, HWBAColor, HWBColor, RGBAColor, RGBColor } from "../models.mjs";
+//#region src/color/space/hwb.d.ts
+declare function convertHwbToHsl(input: HWBAColor | HWBColor): HSLAColor;
+declare function getHwbValue(value: Record<keyof HWBColor, unknown>): HWBColor;
+/**
+ * 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
+ */
+declare function hwbToHex(hwb: HWBAColor | HWBColor, alpha?: boolean): string;
+/**
+ * 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
+ */
+declare function hwbToHsl(hwb: HWBAColor | HWBColor): HSLColor;
+/**
+ * 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
+ */
+declare function hwbToHsla(hwb: HWBAColor | HWBColor): HSLAColor;
+/**
+ * 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
+ */
+declare function hwbToRgb(hwb: HWBAColor | HWBColor): RGBColor;
+/**
+ * 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
+ */
+declare function hwbToRgba(hwb: HWBAColor | HWBColor): RGBAColor;
+//#endregion
+export { convertHwbToHsl, getHwbValue, hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba };