@soybeanjs/colord 0.0.1

package/dist/lab-CJHLdqfe.js

@@ -0,0 +1,128 @@
+import { _ as ALPHA_PRECISION, a as mul3x3, c as round, i as isPresent, l as M_D50_TO_D65, o as parseAlpha, t as clamp, u as M_D65_TO_D50, v as D50 } from "./utils-BgIyY6bK.js";
+import { i as xyzToRgb, n as rgbToXyz } from "./xyz-MII3ndWO.js";
+
+//#region src/models/lab.ts
+const EPSILON = 216 / 24389;
+const KAPPA = 24389 / 27;
+/**
+* Clamps LAB axis values as defined in CSS Color Level 4 specs.
+* https://www.w3.org/TR/css-color-4/#specifying-lab-lch
+*/
+const clampLab = (lab) => {
+	const { l, a, b, alpha } = lab;
+	return {
+		l: clamp(l, 0, 100),
+		a: clamp(a, -128, 127),
+		b: clamp(b, -128, 127),
+		alpha: clamp(alpha)
+	};
+};
+const roundLab = (lab) => {
+	const { l, a, b, alpha } = lab;
+	return {
+		l: round(l, 3),
+		a: round(a, 3),
+		b: round(b, 3),
+		alpha: round(alpha, ALPHA_PRECISION)
+	};
+};
+/**
+* Performs RGB → CIEXYZ → LAB color conversion
+* https://www.w3.org/TR/css-color-4/#color-conversion-code
+*/
+const rgbToLab = (rgb) => {
+	const xyzD65 = rgbToXyz(rgb);
+	const { alpha } = xyzD65;
+	const [x, y, z] = mul3x3(M_D65_TO_D50, [
+		xyzD65.x,
+		xyzD65.y,
+		xyzD65.z
+	]);
+	return xyzToLabRaw({
+		x,
+		y,
+		z,
+		alpha
+	});
+};
+/**
+* Performs LAB → CIEXYZ → RGB color conversion
+* https://www.w3.org/TR/css-color-4/#color-conversion-code
+*/
+const labToRgb = (lab) => {
+	const xyzD50 = labToXyzRaw(lab);
+	const [x, y, z] = mul3x3(M_D50_TO_D65, [
+		xyzD50.x,
+		xyzD50.y,
+		xyzD50.z
+	]);
+	return xyzToRgb({
+		x,
+		y,
+		z,
+		alpha: lab.alpha
+	});
+};
+function xyzToLabRaw(xyz) {
+	const { x, y, z, alpha } = xyz;
+	const xr = x / D50.x;
+	const yr = y / D50.y;
+	const zr = z / D50.z;
+	const f = (t) => t > EPSILON ? Math.cbrt(t) : (KAPPA * t + 16) / 116;
+	const fx = f(xr);
+	const fy = f(yr);
+	const fz = f(zr);
+	return {
+		l: 116 * fy - 16,
+		a: 500 * (fx - fy),
+		b: 200 * (fy - fz),
+		alpha
+	};
+}
+function labToXyzRaw(lab) {
+	const { l, a, b, alpha } = lab;
+	const fy = (l + 16) / 116;
+	const fx = a / 500 + fy;
+	const fz = fy - b / 200;
+	const f3 = (t) => t * t * t > EPSILON ? t * t * t : (116 * t - 16) / KAPPA;
+	const xr = f3(fx);
+	const yr = l > KAPPA * EPSILON ? ((l + 16) / 116) ** 3 : l / KAPPA;
+	const zr = f3(fz);
+	return {
+		x: xr * D50.x,
+		y: yr * D50.y,
+		z: zr * D50.z,
+		alpha
+	};
+}
+const parseLab = ({ l, a, b, alpha = 1 }) => {
+	if (!isPresent(l) || !isPresent(a) || !isPresent(b)) return null;
+	return labToRgb(clampLab({
+		l: Number(l),
+		a: Number(a),
+		b: Number(b),
+		alpha: Number(alpha)
+	}));
+};
+/**
+* Parsing syntax: oklab(L a b [/ alpha])
+* - L: <number|percentage> [0,100]
+* - a: <number> [-125,125]
+* - b: <number> [-125,125]
+* - alpha: <number|percentage> [0,1]
+*/
+const labMatcher = /^lab\(\s*([+-]?[\d.]+)%?\s+([+-]?[\d.]+)\s+([+-]?[\d.]+)(?:\s*\/\s*([+-]?[\d.]+%?))?\s*\)$/i;
+const parseLabString = (input) => {
+	const match = labMatcher.exec(input);
+	if (!match) return null;
+	const [_, l, a, b, alpha] = match;
+	return labToRgb(clampLab({
+		l: Number.parseFloat(l),
+		a: Number.parseFloat(a),
+		b: Number.parseFloat(b),
+		alpha: parseAlpha(alpha)
+	}));
+};
+
+//#endregion
+export { rgbToLab as a, parseLabString as i, labToRgb as n, roundLab as o, parseLab as r, clampLab as t };

package/dist/manipulate-CeAgrUd6.js

@@ -0,0 +1,119 @@
+import { _ as ALPHA_PRECISION, c as round, i as isPresent, n as clampHue, o as parseAlpha, s as parseHue, t as clamp } from "./utils-BgIyY6bK.js";
+import { r as rgbToHsv, t as hsvToRgb } from "./hsv-UWMaaOSN.js";
+import { a as rgbToLab, n as labToRgb, t as clampLab } from "./lab-CJHLdqfe.js";
+
+//#region src/models/hsl.ts
+const clampHsl = (hsl) => {
+	const { h, s, l, alpha } = hsl;
+	return {
+		h: clampHue(h),
+		s: clamp(s, 0, 100),
+		l: clamp(l, 0, 100),
+		alpha: clamp(alpha)
+	};
+};
+const roundHsl = (hsl) => {
+	const { h, s, l, alpha } = hsl;
+	return {
+		h: round(h, 3),
+		s: round(s, 3),
+		l: round(l, 3),
+		alpha: round(alpha, ALPHA_PRECISION)
+	};
+};
+const hslToHsv = (hsl) => {
+	const { h, l, alpha } = hsl;
+	const s = hsl.s * (l < 50 ? l : 100 - l) / 100;
+	return {
+		h,
+		s: s > 0 ? 2 * s / (l + s) * 100 : 0,
+		v: l + s,
+		alpha
+	};
+};
+const hsvToHsl = ({ h, s, v, alpha }) => {
+	const hh = (200 - s) * v / 100;
+	return {
+		h,
+		s: hh > 0 && hh < 200 ? s * v / 100 / (hh <= 100 ? hh : 200 - hh) * 100 : 0,
+		l: hh / 2,
+		alpha
+	};
+};
+const hslToRgb = (hsl) => {
+	return hsvToRgb(hslToHsv(hsl));
+};
+const rgbToHsl = (rgb) => {
+	return hsvToHsl(rgbToHsv(rgb));
+};
+const parseHsl = ({ h, s, l, alpha = 1 }) => {
+	if (!isPresent(h) || !isPresent(s) || !isPresent(l)) return null;
+	return hslToRgb(clampHsl({
+		h: Number(h),
+		s: Number(s),
+		l: Number(l),
+		alpha: Number(alpha)
+	}));
+};
+const rgbToHslString = (rgb) => {
+	const { h, s, l, alpha } = roundHsl(rgbToHsl(rgb));
+	return alpha < 1 ? `hsl(${h}, ${s}%, ${l}%, ${alpha})` : `hsl(${h}, ${s}%, ${l}%)`;
+};
+const hslMatcher = /^hsl?\(\s*([+-]?[\d.]+)(deg|grad|rad|turn)?\s*[, ]\s*([+-]?[\d.]+)%\s*[, ]\s*([+-]?[\d.]+)%(?:\s*\/\s*([+-]?[\d.]+%?))?\s*\)$/i;
+const parseHslString = (input) => {
+	const match = hslMatcher.exec(input);
+	if (!match) return null;
+	const [, h, unit, s, l, alpha] = match;
+	return hslToRgb(clampHsl({
+		h: parseHue(h, unit),
+		s: Number.parseFloat(s),
+		l: Number.parseFloat(l),
+		alpha: parseAlpha(alpha)
+	}));
+};
+
+//#endregion
+//#region src/shared/manipulate.ts
+const changeAlpha = (rgb, alpha) => ({
+	r: rgb.r,
+	g: rgb.g,
+	b: rgb.b,
+	alpha
+});
+const invert = (rgb) => ({
+	r: 255 - rgb.r,
+	g: 255 - rgb.g,
+	b: 255 - rgb.b,
+	alpha: rgb.alpha
+});
+const lighten = (rgb, amount) => {
+	const hsl = rgbToHsl(rgb);
+	return {
+		h: hsl.h,
+		s: hsl.s,
+		l: clamp(hsl.l + amount * 100, 0, 100),
+		alpha: hsl.alpha
+	};
+};
+const mix = (rgb1, rgb2, ratio) => {
+	const lab1 = rgbToLab(rgb1);
+	const lab2 = rgbToLab(rgb2);
+	return labToRgb(clampLab({
+		l: lab1.l * (1 - ratio) + lab2.l * ratio,
+		a: lab1.a * (1 - ratio) + lab2.a * ratio,
+		b: lab1.b * (1 - ratio) + lab2.b * ratio,
+		alpha: lab1.alpha * (1 - ratio) + lab2.alpha * ratio
+	}));
+};
+const saturate = (rgb, amount) => {
+	const { h, s, l, alpha } = rgbToHsl(rgb);
+	return {
+		h,
+		s: clamp(s + amount * 100, 0, 100),
+		l,
+		alpha
+	};
+};
+
+//#endregion
+export { saturate as a, rgbToHsl as c, mix as i, rgbToHslString as l, invert as n, parseHsl as o, lighten as r, parseHslString as s, changeAlpha as t, roundHsl as u };

package/dist/plugins/a11y.d.ts

@@ -0,0 +1,41 @@
+import { r as AnyColor } from "../colord-xpgrVWRV.js";
+import { t as Plugin } from "../extend-DrPfn2Q1.js";
+
+//#region src/plugins/a11y.d.ts
+interface ReadabilityOptions {
+  level?: 'AA' | 'AAA';
+  size?: 'normal' | 'large';
+}
+declare module '../colord' {
+  interface Colord {
+    /**
+     * Returns the relative luminance of a color,
+     * normalized to 0 for darkest black and 1 for lightest white.
+     * https://www.w3.org/TR/WCAG20/#relativeluminancedef
+     * https://developer.mozilla.org/en-US/docs/Web/Accessibility/Understanding_Colors_and_Luminance
+     */
+    luminance(): number;
+    /**
+     * Calculates a contrast ratio for a color pair.
+     * This luminance difference is expressed as a ratio ranging
+     * from 1 (e.g. white on white) to 21 (e.g., black on a white).
+     * WCAG requires a ratio of at least 4.5 for normal text and 3 for large text.
+     * https://www.w3.org/TR/UNDERSTANDING-WCAG20/visual-audio-contrast-contrast.html
+     * https://webaim.org/articles/contrast/
+     */
+    contrast(color2?: AnyColor | Colord): number;
+    /**
+     * Checks that a background and text color pair conforms to WCAG 2.0 requirements.
+     * https://www.w3.org/TR/UNDERSTANDING-WCAG20/visual-audio-contrast-contrast.html
+     */
+    isReadable(color2?: AnyColor | Colord, options?: ReadabilityOptions): boolean;
+  }
+}
+/**
+ * A plugin adding accessibility and color contrast utilities.
+ * Follows Web Content Accessibility Guidelines 2.0.
+ * https://www.w3.org/TR/WCAG20/
+ */
+declare const a11yPlugin: Plugin;
+//#endregion
+export { a11yPlugin, a11yPlugin as default };

package/dist/plugins/a11y.js

@@ -0,0 +1,35 @@
+import { c as round, r as floor } from "../utils-BgIyY6bK.js";
+import "../rgb-CfVJB1Bj.js";
+import { i as getLuminance, n as getContrast } from "../get-BFaklfVd.js";
+
+//#region src/plugins/a11y.ts
+/**
+* A plugin adding accessibility and color contrast utilities.
+* Follows Web Content Accessibility Guidelines 2.0.
+* https://www.w3.org/TR/WCAG20/
+*/
+const a11yPlugin = (ColordClass) => {
+	/**
+	* Returns WCAG text color contrast requirement.
+	* Read explanation here https://webaim.org/resources/contrastchecker/
+	*/
+	const getMinimalContrast = ({ level = "AA", size = "normal" }) => {
+		if (level === "AAA" && size === "normal") return 7;
+		if (level === "AA" && size === "large") return 3;
+		return 4.5;
+	};
+	ColordClass.prototype.luminance = function luminance() {
+		return round(getLuminance(this.rgb), 2);
+	};
+	ColordClass.prototype.contrast = function contrast(color2 = "#FFF") {
+		const instance2 = color2 instanceof ColordClass ? color2 : new ColordClass(color2);
+		return floor(getContrast(this.rgb, instance2.toRgb()), 2);
+	};
+	ColordClass.prototype.isReadable = function isReadable(color2 = "#FFF", options = {}) {
+		return this.contrast(color2) >= getMinimalContrast(options);
+	};
+};
+var a11y_default = a11yPlugin;
+
+//#endregion
+export { a11yPlugin, a11y_default as default };

package/dist/plugins/cmyk.d.ts

@@ -0,0 +1,27 @@
+import { i as CmykColor } from "../colord-xpgrVWRV.js";
+import { t as Plugin } from "../extend-DrPfn2Q1.js";
+
+//#region src/plugins/cmyk.d.ts
+declare module '../colord' {
+  interface Colord {
+    /**
+     * Converts a color to CMYK color space and returns an object.
+     * https://drafts.csswg.org/css-color/#cmyk-colors
+     * https://lea.verou.me/2009/03/cmyk-colors-in-css-useful-or-useless/
+     */
+    toCmyk(): CmykColor;
+    /**
+     * Converts a color to CMYK color space and returns a string.
+     * https://developer.mozilla.org/en-US/docs/Web/CSS/color_value/device-cmyk()
+     */
+    toCmykString(): string;
+  }
+}
+/**
+ * A plugin adding support for CMYK color space.
+ * https://lea.verou.me/2009/03/cmyk-colors-in-css-useful-or-useless/
+ * https://en.wikipedia.org/wiki/CMYK_color_model
+ */
+declare const cmykPlugin: Plugin;
+//#endregion
+export { cmykPlugin, cmykPlugin as default };

package/dist/plugins/cmyk.js

@@ -0,0 +1,121 @@
+import { _ as ALPHA_PRECISION, c as round, i as isPresent, o as parseAlpha, t as clamp } from "../utils-BgIyY6bK.js";
+
+//#region src/models/cmyk.ts
+/**
+* Clamps the CMYK color object values.
+*/
+const clampCmyk = (cmyk) => {
+	const { c, m, y, k, alpha } = cmyk;
+	return {
+		c: clamp(c, 0, 100),
+		m: clamp(m, 0, 100),
+		y: clamp(y, 0, 100),
+		k: clamp(k, 0, 100),
+		alpha: clamp(alpha)
+	};
+};
+/**
+* Rounds the CMYK color object values.
+*/
+const roundCmyk = (cmyk) => {
+	const { c, m, y, k, alpha } = cmyk;
+	return {
+		c: round(c, 2),
+		m: round(m, 2),
+		y: round(y, 2),
+		k: round(k, 2),
+		alpha: round(alpha, ALPHA_PRECISION)
+	};
+};
+/**
+* Transforms the CMYK color object to RGB.
+* https://www.rapidtables.com/convert/color/cmyk-to-rgb.html
+*/
+function cmykToRgb(cmyk) {
+	const { c, m, y, k, alpha } = cmyk;
+	return {
+		r: round(255 * (1 - c / 100) * (1 - k / 100)),
+		g: round(255 * (1 - m / 100) * (1 - k / 100)),
+		b: round(255 * (1 - y / 100) * (1 - k / 100)),
+		alpha
+	};
+}
+/**
+* Convert RGB Color Model object to CMYK.
+* https://www.rapidtables.com/convert/color/rgb-to-cmyk.html
+*/
+function rgbToCmyk(rgb) {
+	const { r, g, b, alpha } = rgb;
+	const k = 1 - Math.max(r / 255, g / 255, b / 255);
+	const c = (1 - r / 255 - k) / (1 - k);
+	const m = (1 - g / 255 - k) / (1 - k);
+	const y = (1 - b / 255 - k) / (1 - k);
+	return {
+		c: Number.isNaN(c) ? 0 : round(c * 100),
+		m: Number.isNaN(m) ? 0 : round(m * 100),
+		y: Number.isNaN(y) ? 0 : round(y * 100),
+		k: round(k * 100),
+		alpha
+	};
+}
+/**
+* Parses the CMYK color object into RGB.
+*/
+function parseCmyk({ c, m, y, k, alpha = 1 }) {
+	if (!isPresent(c) || !isPresent(m) || !isPresent(y) || !isPresent(k)) return null;
+	return cmykToRgb(clampCmyk({
+		c: Number(c),
+		m: Number(m),
+		y: Number(y),
+		k: Number(k),
+		alpha: Number(alpha)
+	}));
+}
+const cmykMatcher = /^device-cmyk\(\s*([\d.]+%?)\s*[, ]\s*([\d.]+%?)\s*[, ]\s*([\d.]+%?)\s*[, ]\s*([\d.]+%?)(?:\s*\/\s*([\d.]+%?))?\s*\)$/i;
+/**
+* Parses a valid CMYK CSS color function/string
+* https://www.w3.org/TR/css-color-4/#device-cmyk
+*/
+const parseCmykString = (input) => {
+	const match = cmykMatcher.exec(input);
+	if (!match) return null;
+	const [, c, m, y, k, al] = match;
+	return cmykToRgb(clampCmyk({
+		c: parseValue(c),
+		m: parseValue(m),
+		y: parseValue(y),
+		k: parseValue(k),
+		alpha: al ? parseAlpha(al) : 1
+	}));
+};
+function parseValue(str) {
+	const isPercent = str.endsWith("%");
+	const num = Number.parseFloat(isPercent ? str.slice(0, -1) : str);
+	return isPercent ? num : num * 100;
+}
+function rgbToCmykString(rgb) {
+	const { c, m, y, k, alpha } = roundCmyk(rgbToCmyk(rgb));
+	return alpha < 1 ? `device-cmyk(${c}% ${m}% ${y}% ${k}% / ${alpha})` : `device-cmyk(${c}% ${m}% ${y}% ${k}%)`;
+}
+
+//#endregion
+//#region src/plugins/cmyk.ts
+/**
+* A plugin adding support for CMYK color space.
+* https://lea.verou.me/2009/03/cmyk-colors-in-css-useful-or-useless/
+* https://en.wikipedia.org/wiki/CMYK_color_model
+*/
+const cmykPlugin = (ColordClass, parsers) => {
+	ColordClass.prototype.toCmyk = function toCmyk() {
+		return roundCmyk(rgbToCmyk(this.rgb));
+	};
+	ColordClass.prototype.toCmykString = function toCmykString() {
+		return rgbToCmykString(this.rgb);
+	};
+	parsers.object.push([parseCmyk, "cmyk"]);
+	parsers.string.push([parseCmykString, "cmyk"]);
+};
+var cmyk_default = cmykPlugin;
+
+//#endregion
+export { cmykPlugin, cmyk_default as default };

package/dist/plugins/harmonies.d.ts

@@ -0,0 +1,19 @@
+import { t as Plugin } from "../extend-DrPfn2Q1.js";
+
+//#region src/plugins/harmonies.d.ts
+type HarmonyType = 'analogous' | 'complementary' | 'double-split-complementary' | 'rectangle' | 'split-complementary' | 'tetradic' | 'triadic';
+declare module '../colord' {
+  interface Colord {
+    /**
+     * Returns an array of harmony colors as `Colord` instances.
+     */
+    harmonies(type?: HarmonyType): Colord[];
+  }
+}
+/**
+ * A plugin adding functionality to generate harmony colors.
+ * https://en.wikipedia.org/wiki/Harmony_(color)
+ */
+declare const harmoniesPlugin: Plugin;
+//#endregion
+export { HarmonyType, harmoniesPlugin as default, harmoniesPlugin };

package/dist/plugins/harmonies.js

@@ -0,0 +1,54 @@
+//#region src/plugins/harmonies.ts
+/**
+* A plugin adding functionality to generate harmony colors.
+* https://en.wikipedia.org/wiki/Harmony_(color)
+*/
+const harmoniesPlugin = (ColordClass) => {
+	/**
+	* Harmony colors are colors with particular hue shift of the original color.
+	*/
+	const hueShifts = {
+		analogous: [
+			-30,
+			0,
+			30
+		],
+		complementary: [0, 180],
+		"double-split-complementary": [
+			-30,
+			0,
+			30,
+			150,
+			210
+		],
+		rectangle: [
+			0,
+			60,
+			180,
+			240
+		],
+		tetradic: [
+			0,
+			90,
+			180,
+			270
+		],
+		triadic: [
+			0,
+			120,
+			240
+		],
+		"split-complementary": [
+			0,
+			150,
+			210
+		]
+	};
+	ColordClass.prototype.harmonies = function harmonies(type = "complementary") {
+		return hueShifts[type].map((shift) => this.rotate(shift));
+	};
+};
+var harmonies_default = harmoniesPlugin;
+
+//#endregion
+export { harmonies_default as default, harmoniesPlugin };

package/dist/plugins/hwb.d.ts

@@ -0,0 +1,26 @@
+import { c as HwbColor } from "../colord-xpgrVWRV.js";
+import { t as Plugin } from "../extend-DrPfn2Q1.js";
+
+//#region src/plugins/hwb.d.ts
+declare module '../colord' {
+  interface Colord {
+    /**
+     * Converts a color to HWB (Hue-Whiteness-Blackness) color space and returns an object.
+     * https://en.wikipedia.org/wiki/HWB_color_model
+     */
+    toHwb(): HwbColor;
+    /**
+     * Converts a color to HWB (Hue-Whiteness-Blackness) color space and returns a string.
+     * https://www.w3.org/TR/css-color-4/#the-hwb-notation
+     */
+    toHwbString(): string;
+  }
+}
+/**
+ * A plugin adding support for HWB (Hue-Whiteness-Blackness) color model.
+ * https://en.wikipedia.org/wiki/HWB_color_model
+ * https://www.w3.org/TR/css-color-4/#the-hwb-notation
+ */
+declare const hwbPlugin: Plugin;
+//#endregion
+export { hwbPlugin as default, hwbPlugin };

package/dist/plugins/hwb.js

@@ -0,0 +1,92 @@
+import { _ as ALPHA_PRECISION, c as round, i as isPresent, n as clampHue, o as parseAlpha, s as parseHue, t as clamp } from "../utils-BgIyY6bK.js";
+import { r as rgbToHsv, t as hsvToRgb } from "../hsv-UWMaaOSN.js";
+
+//#region src/models/hwb.ts
+const clampHwb = (hwb) => {
+	const { h, w, b, alpha } = hwb;
+	return {
+		h: clampHue(h),
+		w: clamp(w, 0, 100),
+		b: clamp(b, 0, 100),
+		alpha: clamp(alpha)
+	};
+};
+const roundHwb = (hwb) => {
+	const { h, w, b, alpha } = hwb;
+	return {
+		h: round(h, 3),
+		w: round(w, 3),
+		b: round(b, 3),
+		alpha: round(alpha, ALPHA_PRECISION)
+	};
+};
+const rgbToHwb = (rgb) => {
+	const { r, g, b: rb, alpha } = rgb;
+	const { h } = rgbToHsv(rgb);
+	return {
+		h,
+		w: Math.min(r, g, rb) / 255 * 100,
+		b: 100 - Math.max(r, g, rb) / 255 * 100,
+		alpha
+	};
+};
+const hwbToRgb = (hwb) => {
+	const { h, w, b, alpha } = hwb;
+	return hsvToRgb({
+		h,
+		s: b === 100 ? 0 : 100 - w / (100 - b) * 100,
+		v: 100 - b,
+		alpha
+	});
+};
+const parseHwb = ({ h, w, b, alpha = 1 }) => {
+	if (!isPresent(h) || !isPresent(w) || !isPresent(b)) return null;
+	return hwbToRgb(clampHwb({
+		h: Number(h),
+		w: Number(w),
+		b: Number(b),
+		alpha: Number(alpha)
+	}));
+};
+const hwbaMatcher = /^hwb\(\s*([+-]?[\d.]+)(deg|grad|rad|turn)?\s*[, ]\s*([+-]?[\d.]+)%\s*[, ]\s*([+-]?[\d.]+)%(?:\s*\/\s*([+-]?[\d.]+%?))?\s*\)$/i;
+/**
+* Parses a valid HWB[A] CSS color function/string
+* https://www.w3.org/TR/css-color-4/#the-hwb-notation
+*/
+const parseHwbString = (input) => {
+	const match = hwbaMatcher.exec(input);
+	if (!match) return null;
+	const [, h, unit, w, b, alpha] = match;
+	return hwbToRgb(clampHwb({
+		h: parseHue(h, unit),
+		w: Number.parseFloat(w),
+		b: Number.parseFloat(b),
+		alpha: parseAlpha(alpha)
+	}));
+};
+const rgbToHwbString = (rgb) => {
+	const { h, w, b, alpha } = roundHwb(rgbToHwb(rgb));
+	return alpha < 1 ? `hwb(${h} ${w}% ${b}% / ${alpha})` : `hwb(${h} ${w}% ${b}%)`;
+};
+
+//#endregion
+//#region src/plugins/hwb.ts
+/**
+* A plugin adding support for HWB (Hue-Whiteness-Blackness) color model.
+* https://en.wikipedia.org/wiki/HWB_color_model
+* https://www.w3.org/TR/css-color-4/#the-hwb-notation
+*/
+const hwbPlugin = (ColordClass, parsers) => {
+	ColordClass.prototype.toHwb = function toHwb() {
+		return roundHwb(rgbToHwb(this.rgb));
+	};
+	ColordClass.prototype.toHwbString = function toHwbString() {
+		return rgbToHwbString(this.rgb);
+	};
+	parsers.string.push([parseHwbString, "hwb"]);
+	parsers.object.push([parseHwb, "hwb"]);
+};
+var hwb_default = hwbPlugin;
+
+//#endregion
+export { hwb_default as default, hwbPlugin };

package/dist/plugins/lab.d.ts

@@ -0,0 +1,26 @@
+import { r as AnyColor, u as LabColor } from "../colord-xpgrVWRV.js";
+import { t as Plugin } from "../extend-DrPfn2Q1.js";
+
+//#region src/plugins/lab.d.ts
+declare module '../colord' {
+  interface Colord {
+    /**
+     * Converts a color to CIELAB color space and returns an object.
+     * The object always includes `alpha` value [0, 1].
+     */
+    toLab(): LabColor;
+    /**
+     * Calculates the perceived color difference for two colors according to
+     * [Delta E2000](https://en.wikipedia.org/wiki/Color_difference#CIEDE2000).
+     * Returns a value in [0, 1] range.
+     */
+    delta(color?: AnyColor | Colord): number;
+  }
+}
+/**
+ * A plugin adding support for CIELAB color space.
+ * https://en.wikipedia.org/wiki/CIELAB_color_space
+ */
+declare const labPlugin: Plugin;
+//#endregion
+export { labPlugin as default, labPlugin };