@oscarpalmer/atoms 0.188.0 → 0.189.0

package/src/color/constants.ts

@@ -1,4 +1,4 @@
-import type {Alpha, ColorProperty, ColorSpace, HSLColor, RGBColor} from './models';
+import type {Alpha, HSLAColor, HSLColor, HWBAColor, HWBColor, RGBAColor, RGBColor} from './models';
 
 // #region Variables
 
@@ -6,21 +6,25 @@ export const ALPHA_FULL_HEX_SHORT = 'f';
 
 export const ALPHA_FULL_HEX_LONG = `${ALPHA_FULL_HEX_SHORT}${ALPHA_FULL_HEX_SHORT}`;
 
-export const ALPHA_FULL_VALUE = 1;
-
 export const ALPHA_NONE_HEX = '00';
 
 export const ALPHA_NONE_VALUE = 0;
 
 export const DEFAULT_ALPHA: Alpha = {
 	hex: ALPHA_FULL_HEX_LONG,
-	value: ALPHA_FULL_VALUE,
+	value: 100,
 };
 
 export const DEFAULT_HSL: HSLColor = {
 	hue: 0,
-	lightness: 0,
 	saturation: 0,
+	lightness: 0,
+};
+
+export const DEFAULT_HWB: HWBColor = {
+	hue: 0,
+	whiteness: 0,
+	blackness: 100,
 };
 
 export const DEFAULT_RGB: RGBColor = {
@@ -43,13 +47,17 @@ export const LENGTH_LONG = 6;
 
 export const LENGTH_SHORT = 3;
 
-export const KEYS_HSL: ColorProperty[] = ['hue', 'saturation', 'lightness'];
+export const KEYS_HSL: Array<keyof HSLColor> = ['hue', 'saturation', 'lightness'];
+
+export const KEYS_HSLA: Array<keyof HSLAColor> = [...KEYS_HSL, 'alpha'];
+
+export const KEYS_HWB: Array<keyof HWBColor> = ['hue', 'whiteness', 'blackness'];
 
-export const KEYS_HSLA: ColorProperty[] = [...KEYS_HSL, 'alpha'];
+export const KEYS_HWBA: Array<keyof HWBAColor> = [...KEYS_HWB, 'alpha'];
 
-export const KEYS_RGB: ColorProperty[] = ['red', 'green', 'blue'];
+export const KEYS_RGB: Array<keyof RGBColor> = ['red', 'green', 'blue'];
 
-export const KEYS_RGBA: ColorProperty[] = [...KEYS_RGB, 'alpha'];
+export const KEYS_RGBA: Array<keyof RGBAColor> = [...KEYS_RGB, 'alpha'];
 
 export const MAX_DEGREE = 360;
 
@@ -57,10 +65,6 @@ export const MAX_HEX = 255;
 
 export const MAX_PERCENT = 100;
 
-export const SPACE_HSL: ColorSpace = 'hsl';
-
-export const SPACE_RGB: ColorSpace = 'rgb';
-
 // https://www.w3.org/TR/WCAG20/#relativeluminancedef
 
 export const SRGB_LUMINANCE_BLUE = 0.0722;

package/src/color/index.ts

@@ -1,13 +1,13 @@
 import {Color} from './instance';
 import {isColor} from './misc/is';
-import type {HSLAColor, HSLColor, RGBAColor, RGBColor} from './models';
+import type {HSLAColor, HSLColor, HWBColor, HWBAColor, RGBAColor, RGBColor} from './models';
 
 // #region Functions
 
 /**
  * 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
@@ -27,6 +27,8 @@ export {
 	getHexColor,
 	getHslaColor,
 	getHslColor,
+	getHwbColor,
+	getHwbaColor,
 	getRgbaColor,
 	getRgbColor,
 } from './misc/get';
@@ -37,14 +39,27 @@ export {
 	isHslColor,
 	isHslLike,
 	isHslaColor,
+	isHwbColor,
+	isHwbLike,
+	isHwbaColor,
+	isHwbaLike,
 	isRgbColor,
 	isRgbLike,
 	isRgbaColor,
 } from './misc/is';
 
-export {getNormalizedHex, hexToHsl, hexToHsla, hexToRgb, hexToRgba} from './space/hex';
-export {hslToHex, hslToRgb, hslToRgba} from './space/hsl';
-export {rgbToHex, rgbToHsl, rgbToHsla} from './space/rgb';
-export type {Color, HSLAColor, HSLColor, RGBAColor, RGBColor};
+export {
+	getNormalizedHex,
+	hexToHsl,
+	hexToHsla,
+	hexToHwb,
+	hexToHwba,
+	hexToRgb,
+	hexToRgba,
+} from './space/hex';
+export {hslToHex, hslToHwb, hslToHwba, hslToRgb, hslToRgba} from './space/hsl';
+export {hwbToHex, hwbToHsl, hwbToHsla, hwbToRgb, hwbToRgba} from './space/hwb';
+export {rgbToHex, rgbToHsl, rgbToHsla, rgbToHwb, rgbToHwba} from './space/rgb';
+export type {Color, HSLAColor, HSLColor, HWBAColor, HWBColor, RGBAColor, RGBColor};
 
 // #endregion

package/src/color/instance.ts

@@ -1,8 +1,15 @@
-import {SPACE_HSL, SPACE_RGB} from './constants';
-import {formatColor} from './misc';
+import {formatHslColor, formatHwbColor, formatRgbColor} from './misc';
 import {getAlpha} from './misc/alpha';
-import {getColorState, setHexColor, setHSLColor, setRGBColor} from './misc/state';
-import type {ColorState, HSLAColor, HSLColor, RGBAColor, RGBColor} from './models';
+import {getColorState, setHexColor, setHSLColor, setHWBColor, setRGBColor} from './misc/state';
+import type {
+	ColorState,
+	HSLAColor,
+	HSLColor,
+	HWBAColor,
+	HWBColor,
+	RGBAColor,
+	RGBColor,
+} from './models';
 
 // #region Types
 
@@ -20,19 +27,16 @@ export class Color {
 	readonly #state: ColorState;
 
 	/**
-	 * 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(): number {
 		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
 	 */
@@ -94,7 +98,7 @@ export class Color {
 	 * @returns Current color as an _HSL_ color
 	 */
 	get hsl(): HSLColor {
-		return this.#state.hsl;
+		return {...this.#state.hsl};
 	}
 
 	/**
@@ -127,13 +131,52 @@ export class Color {
 		setHSLColor(this.#state, value, true);
 	}
 
+	/**
+	 * Get the color as an _HWB_ color
+	 *
+	 * @returns Current color as an _HWB_ color
+	 */
+	get hwb(): HWBColor {
+		return {...this.#state.hwb};
+	}
+
+	/**
+	 * Set colors from an _HWB_ color
+	 *
+	 * @param value New _HWB_ color
+	 */
+	set hwb(value: HWBColor) {
+		setHWBColor(this.#state, value, false);
+	}
+
+	/**
+	 * Get the color as an _HWBA_ color
+	 *
+	 * @returns Current color as an _HWBA_ color
+	 */
+	get hwba(): HWBAColor {
+		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: HWBAColor) {
+		setHWBColor(this.#state, value, true);
+	}
+
 	/**
 	 * Get the color as an _RGB_ color
 	 *
 	 * @returns Current color as an _RGB_ color
 	 */
 	get rgb(): RGBColor {
-		return this.#state.rgb;
+		return {...this.#state.rgb};
 	}
 
 	/**
@@ -191,7 +234,17 @@ export class Color {
 	 * @returns _HSL(A)_ color string
 	 */
 	toHslString(alpha?: boolean): string {
-		return formatColor(SPACE_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?: boolean): string {
+		return formatHwbColor(this, alpha === true);
 	}
 
 	/**
@@ -201,7 +254,7 @@ export class Color {
 	 * @returns _RGB(A)_ color string
 	 */
 	toRgbString(alpha?: boolean): string {
-		return formatColor(SPACE_RGB, this, alpha === true);
+		return formatRgbColor(this, alpha === true);
 	}
 
 	/**

package/src/color/misc/alpha.ts

@@ -1,6 +1,6 @@
+import {round} from '../../internal/math/misc';
 import {
 	ALPHA_FULL_HEX_LONG,
-	ALPHA_FULL_VALUE,
 	ALPHA_NONE_HEX,
 	ALPHA_NONE_VALUE,
 	DEFAULT_ALPHA,
@@ -31,11 +31,11 @@ export function getAlphaHexadecimal(value: number): string {
 		return ALPHA_NONE_HEX;
 	}
 
-	if (value === ALPHA_FULL_VALUE) {
+	if (value === MAX_PERCENT) {
 		return ALPHA_FULL_HEX_LONG;
 	}
 
-	return Math.round(value * MAX_HEX).toString(16);
+	return round(value * MAX_HEX).toString(16);
 }
 
 function getAlphaFromValue(value: number): Alpha {
@@ -48,15 +48,11 @@ function getAlphaFromValue(value: number): Alpha {
 }
 
 export function getAlphaValue(original: number): number {
-	if (Number.isNaN(original) || original >= MAX_PERCENT || original === ALPHA_FULL_VALUE) {
-		return ALPHA_FULL_VALUE;
+	if (Number.isNaN(original) || original >= MAX_PERCENT) {
+		return MAX_PERCENT;
 	}
 
-	if (original < ALPHA_NONE_VALUE) {
-		return ALPHA_NONE_VALUE;
-	}
-
-	return original <= ALPHA_FULL_VALUE ? original : original / MAX_PERCENT;
+	return original <= ALPHA_NONE_VALUE ? ALPHA_NONE_VALUE : original;
 }
 
 // #endregion

package/src/color/misc/get.ts

@@ -1,3 +1,4 @@
+import {round} from '../../internal/math/misc';
 import {clamp} from '../../number';
 import {
 	HEX_BLACK,
@@ -16,25 +17,45 @@ import {
 	SRGB_LUMINANCE_THRESHOLD,
 } from '../constants';
 import {Color} from '../instance';
-import type {HSLAColor, HSLColor, RGBAColor, RGBColor} from '../models';
+import type {HSLAColor, HSLColor, HWBAColor, HWBColor, RGBAColor, RGBColor} from '../models';
 import {getColorState} from './state';
 
 // #region Functions
 
-function getClampedValue(value: unknown, minimum: number, maximum: number): number {
-	return typeof value === 'number' ? clamp(value, minimum, maximum) : minimum;
+function getClampedValue(
+	value: unknown,
+	minimum: number,
+	maximum: number,
+	rounding?: boolean,
+): number {
+	return typeof value === 'number' && !Number.isNaN(value)
+		? clamp((rounding ?? false) ? round(value) : value, minimum, maximum)
+		: minimum;
 }
 
+/**
+ * Get a foreground color _(usually text)_ based on a background color's luminance as an unprefixed hex color string
+ *
+ * - 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 white foreground color will be returned
+ *
+ * @param value Original value
+ * @returns Foreground color
+ */
+export function getForegroundColor(value: unknown, hex: true): string;
+
 /**
  * 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
+ * - 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 white foreground color will be returned
  *
  * @param value Original value
  * @returns Foreground color
  */
-export function getForegroundColor(value: unknown): Color {
+export function getForegroundColor(value: unknown): Color;
+
+export function getForegroundColor(value: unknown, hex?: unknown): string | Color {
 	const state = getColorState(value);
 	const {blue, green, red} = state.rgb;
 
@@ -58,14 +79,16 @@ export function getForegroundColor(value: unknown): Color {
 		SRGB_LUMINANCE_BLUE * values[0];
 
 	// Rudimentary and ureliable?; implement APCA for more reliable results?
-	return new Color(luminance > SRGB_LUMINANCE_THRESHOLD ? HEX_BLACK : HEX_WHITE);
+	const color = luminance > SRGB_LUMINANCE_THRESHOLD ? 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, _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
+ * - 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
@@ -79,7 +102,7 @@ export function getHexaColor(value: unknown): string {
 /**
  * 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
+ * - 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
@@ -90,7 +113,7 @@ export function getHexColor(value: unknown): string {
 }
 
 export function getHexValue(value: unknown): number {
-	return getClampedValue(value, 0, MAX_HEX);
+	return getClampedValue(value, 0, MAX_HEX, true);
 }
 
 export function getDegrees(value: unknown): number {
@@ -100,8 +123,8 @@ export function getDegrees(value: unknown): number {
 /**
  * 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
+ * - 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
@@ -115,10 +138,41 @@ export function getHslaColor(value: unknown): HSLAColor {
 	};
 }
 
+/**
+ * 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
+ */
+export function getHwbColor(value: unknown): HWBColor {
+	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
+ */
+export function getHwbaColor(value: unknown): HWBAColor {
+	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, _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 cannot be parsed, a black _HSL_ color will be returned
  *
  * @param value Original value
@@ -135,8 +189,8 @@ export function getPercentage(value: unknown): number {
 /**
  * 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
+ * - 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
@@ -153,7 +207,7 @@ export function getRgbaColor(value: unknown): RGBAColor {
 /**
  * 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
+ * - 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

package/src/color/misc/index.ts

@@ -1,29 +1,30 @@
-import {join} from '../../internal/string';
-import {KEYS_HSL, KEYS_RGB} from '../constants';
+import {round} from '../../internal/math/misc';
 import type {Color} from '../instance';
-import type {ColorProperty, ColorSpace} from '../models';
 
 // #region Functions
 
-export function formatColor(space: ColorSpace, color: Color, alpha: boolean): string {
-	const suffix = alpha ? ` / ${color.alpha}` : '';
-	const value = color[space];
+export function formatHslColor(color: Color, alpha: boolean): string {
+	const {hue, lightness, saturation} = color.hsl;
 
-	return `${space}(${join(
-		keys[space].map(key => value[key as never]),
-		SPACE,
-	)}${suffix})`;
+	const suffix = alpha ? ` / ${color.alpha}%` : '';
+
+	return `hsl(${hue}deg ${saturation}% ${lightness}%${suffix})`;
 }
 
-// #endregion
+export function formatHwbColor(color: Color, alpha: boolean): string {
+	const {blackness, hue, whiteness} = color.hwb;
+
+	const suffix = alpha ? ` / ${color.alpha}%` : '';
 
-// #region Variables
+	return `hwb(${hue}deg ${whiteness}% ${blackness}%${suffix})`;
+}
+
+export function formatRgbColor(color: Color, alpha: boolean): string {
+	const {blue, green, red} = color.rgb;
 
-const SPACE = ' ';
+	const suffix = alpha ? ` / ${color.alpha}%` : '';
 
-const keys: Record<ColorSpace, ColorProperty[]> = {
-	hsl: KEYS_HSL,
-	rgb: KEYS_RGB,
-};
+	return `rgb(${red} ${green} ${blue}${suffix})`;
+}
 
 // #endregion

package/src/color/misc/is.ts

@@ -1,12 +1,13 @@
 import {between} from '../../internal/number';
 import type {PlainObject} from '../../models';
 import {
-	ALPHA_FULL_VALUE,
 	ALPHA_NONE_VALUE,
 	EXPRESSION_HEX_LONG,
 	EXPRESSION_HEX_SHORT,
 	KEYS_HSL,
 	KEYS_HSLA,
+	KEYS_HWB,
+	KEYS_HWBA,
 	KEYS_RGB,
 	KEYS_RGBA,
 	LENGTH_LONG,
@@ -16,7 +17,15 @@ import {
 	MAX_PERCENT,
 } from '../constants';
 import type {Color} from '../index';
-import type {ColorProperty, HSLAColor, HSLColor, RGBAColor, RGBColor} from '../models';
+import type {
+	ColorProperty,
+	HSLAColor,
+	HSLColor,
+	HWBAColor,
+	HWBColor,
+	RGBAColor,
+	RGBColor,
+} from '../models';
 
 // ##region Functions
 
@@ -25,7 +34,7 @@ function hasKeys(value: unknown, keys: ColorProperty[]): boolean {
 }
 
 function isAlpha(value: unknown): value is number {
-	return typeof value === 'number' && between(value, ALPHA_NONE_VALUE, ALPHA_FULL_VALUE);
+	return typeof value === 'number' && between(value, ALPHA_NONE_VALUE, MAX_PERCENT);
 }
 
 function isBytey(value: unknown): value is number {
@@ -116,6 +125,16 @@ export function isHslaColor(value: unknown): value is HSLAColor {
 	return isColorValue(value, KEYS_HSLA);
 }
 
+/**
+ * Is the value like an _HSLA_ color?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is like an _HSLA_ color, otherwise `false`
+ */
+export function isHslaLike(value: unknown): value is Record<keyof HSLAColor, unknown> {
+	return hasKeys(value, KEYS_HSLA);
+}
+
 /**
  * Is the value an _HSL_ color?
  *
@@ -126,10 +145,56 @@ export function isHslColor(value: unknown): value is HSLColor {
 	return isColorValue(value, KEYS_HSLA) || isColorValue(value, KEYS_HSL);
 }
 
+/**
+ * Is the value like an _HSL_ color?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is like an _HSL_ color, otherwise `false`
+ */
 export function isHslLike(value: unknown): value is Record<keyof HSLColor, unknown> {
 	return hasKeys(value, KEYS_HSL);
 }
 
+/**
+ * Is the value an _HWBA_ color?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is an _HWBA_ color, otherwise `false`
+ */
+export function isHwbaColor(value: unknown): value is HWBAColor {
+	return isColorValue(value, KEYS_HWBA);
+}
+
+/**
+ * Is the value like an _HWBA_ color?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is like an _HWBA_ color, otherwise `false`
+ */
+export function isHwbaLike(value: unknown): value is Record<keyof HWBAColor, unknown> {
+	return hasKeys(value, KEYS_HWBA);
+}
+
+/**
+ * Is the value an _HWB_ color?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is an _HWB_ color, otherwise `false`
+ */
+export function isHwbColor(value: unknown): value is HWBColor {
+	return isColorValue(value, KEYS_HWB) || isColorValue(value, KEYS_HWBA);
+}
+
+/**
+ * Is the value like an _HWB_ color?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is like an _HWB_ color, otherwise `false`
+ */
+export function isHwbLike(value: unknown): value is Record<keyof HWBColor, unknown> {
+	return hasKeys(value, KEYS_HWB);
+}
+
 /**
  * Is the value an _RGBA_ color?
  *
@@ -140,6 +205,16 @@ export function isRgbaColor(value: unknown): value is RGBAColor {
 	return isColorValue(value, KEYS_RGBA);
 }
 
+/**
+ * Is the value like an _RGBA_ color?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is like an _RGBA_ color, otherwise `false`
+ */
+export function isRgbaLike(value: unknown): value is Record<keyof RGBAColor, unknown> {
+	return hasKeys(value, KEYS_RGBA);
+}
+
 /**
  * Is the value an _RGB_ color?
  *
@@ -150,6 +225,12 @@ export function isRgbColor(value: unknown): value is RGBColor {
 	return isColorValue(value, KEYS_RGBA) || isColorValue(value, KEYS_RGB);
 }
 
+/**
+ * Is the value like an _RGB_ color?
+ *
+ * @param value Value to check
+ * @returns `true` if the value is like an _RGB_ color, otherwise `false`
+ */
 export function isRgbLike(value: unknown): value is Record<keyof RGBColor, unknown> {
 	return hasKeys(value, KEYS_RGB);
 }
@@ -164,12 +245,14 @@ function isPercentage(value: unknown): value is number {
 
 const validators: Record<ColorProperty, (value: unknown) => value is number> = {
 	alpha: isAlpha,
+	blackness: isPercentage,
 	blue: isBytey,
 	green: isBytey,
 	hue: isDegree,
 	lightness: isPercentage,
 	saturation: isPercentage,
 	red: isBytey,
+	whiteness: isPercentage,
 };
 
 // #endregion