@lakuna/color 1.0.0

package/src/utility/deltaE76.ts

@@ -0,0 +1,30 @@
+import type Lab from "../types/Lab.js";
+import type Luv from "../types/Luv.js";
+
+/**
+ * Calculates the ΔE* CIE (CIE 1976) between two CIELAB values. Based on the EasyRGB pseudocode.
+ * @param color0 - The first color.
+ * @param color1 - The second color.
+ * @returns The difference between the colors.
+ * @see {@link https://en.wikipedia.org/wiki/Color_difference | Color difference}
+ * @public
+ */
+export default function deltaE76(color0: Lab, color1: Lab): number;
+
+/**
+ * Calculates the ΔE* CIE (CIE 1976) between two CIELUV values. Based on the EasyRGB pseudocode.
+ * @param color0 - The first color.
+ * @param color1 - The second color.
+ * @returns The difference between the colors.
+ * @see {@link https://en.wikipedia.org/wiki/Color_difference | Color difference}
+ * @public
+ */
+export default function deltaE76(color0: Luv, color1: Luv): number;
+
+export default function deltaE76(color0: Lab | Luv, color1: Lab | Luv): number {
+	return Math.hypot(
+		color0[0] - color1[0],
+		color0[1] - color1[1],
+		color0[2] - color1[2]
+	);
+}

package/src/utility/deltaE94.ts

@@ -0,0 +1,41 @@
+import type Lab from "../types/Lab.js";
+import type Lch from "../types/Lch.js";
+
+/**
+ * Calculates the ΔE* 1994 between two CIELAB values. Based on the EasyRGB pseudocode.
+ * @param color0 - The first color.
+ * @param color1 - The second color.
+ * @param weight - The CIELCH weights. Defaults to all ones.
+ * @returns The difference between the colors.
+ * @see {@link https://en.wikipedia.org/wiki/Color_difference | Color difference}
+ * @public
+ */
+export default function deltaE94(
+	color0: Lab,
+	color1: Lab,
+	weight: Lch = [1, 1, 1]
+): number {
+	// eslint-disable-next-line prefer-destructuring
+	const l0 = color0[0];
+	// eslint-disable-next-line prefer-destructuring
+	const a0 = color0[1];
+	// eslint-disable-next-line prefer-destructuring
+	const b0 = color0[2];
+	// eslint-disable-next-line prefer-destructuring
+	const l1 = color1[0];
+	// eslint-disable-next-line prefer-destructuring
+	const a1 = color1[1];
+	// eslint-disable-next-line prefer-destructuring
+	const b1 = color1[2];
+
+	const i0 = Math.hypot(a0, b0);
+	const i1 = l1 - l0;
+	const i2 = Math.hypot(a1, b1) - i0;
+	const i3 = Math.hypot(l0 - l1, a0 - a1, b0 - b1) ** 2 - i1 ** 2 - i2 ** 2;
+
+	return Math.hypot(
+		i1 / weight[0],
+		i2 / (weight[1] * (1 + 0.045 * i0)),
+		(i3 > 0 ? Math.sqrt(i3) : 0) / (weight[2] * (1 + 0.015 * i0))
+	);
+}

package/src/utility/deltaH.ts

@@ -0,0 +1,39 @@
+import type Lab from "../types/Lab.js";
+import type Luv from "../types/Luv.js";
+
+/**
+ * Calculates the ΔH* between two CIELAB values. Based on the EasyRGB pseudocode.
+ * @param color0 - The first color.
+ * @param color1 - The second color.
+ * @returns The difference between the colors.
+ * @see {@link https://en.wikipedia.org/wiki/Color_difference | Color difference}
+ * @public
+ */
+export default function deltaH(color0: Lab, color1: Lab): number;
+
+/**
+ * Calculates the ΔH* between two CIELUV values. Based on the EasyRGB pseudocode.
+ * @param color0 - The first color.
+ * @param color1 - The second color.
+ * @returns The difference between the colors.
+ * @see {@link https://en.wikipedia.org/wiki/Color_difference | Color difference}
+ * @public
+ */
+export default function deltaH(color0: Luv, color1: Luv): number;
+
+export default function deltaH(color0: Lab | Luv, color1: Lab | Luv): number {
+	// eslint-disable-next-line prefer-destructuring
+	const a0 = color0[1];
+	// eslint-disable-next-line prefer-destructuring
+	const b0 = color0[2];
+	// eslint-disable-next-line prefer-destructuring
+	const a1 = color1[1];
+	// eslint-disable-next-line prefer-destructuring
+	const b1 = color1[2];
+
+	return Math.sqrt(
+		(a1 - a0) ** 2 +
+			(b1 - b0) ** 2 -
+			(Math.hypot(a1, b1) - Math.hypot(a0, b0)) ** 2
+	);
+}

package/src/utility/getReference.ts

@@ -0,0 +1,95 @@
+import StandardIlluminant from "./StandardIlluminant.js";
+import type Xyz from "../types/Xyz.js";
+
+/**
+ * Get an XYZ (tristimulus) reference value of a perfect reflecting diffuser, scaled such that the white point has a Y value of 100.
+ * @param standardIlluminant - The standard illuminant and observer pair.
+ * @returns An XYZ (tristimulus) reference value of a perfect reflecting diffuser.
+ */
+export default function getReference(
+	standardIlluminant: StandardIlluminant
+): Xyz {
+	switch (standardIlluminant) {
+		case StandardIlluminant.A_10:
+			return [111.144, 100, 35.2];
+		case StandardIlluminant.A_2:
+			return [109.85, 100, 35.585];
+		case StandardIlluminant.B_10:
+			return [99.178, 100, 84.3493];
+		case StandardIlluminant.B_2:
+			return [99.0927, 100, 85.313];
+		case StandardIlluminant.C_10:
+			return [97.285, 100, 116.145];
+		case StandardIlluminant.C_2:
+			return [98.074, 100, 118.232];
+		case StandardIlluminant.D50_10:
+			return [96.72, 100, 81.427];
+		case StandardIlluminant.D50_2:
+			return [96.422, 100, 82.521];
+		case StandardIlluminant.D55_10:
+			return [95.799, 100, 90.926];
+		case StandardIlluminant.D55_2:
+			return [95.682, 100, 92.149];
+		case StandardIlluminant.D65_10:
+			return [94.811, 100, 107.304];
+		case StandardIlluminant.D65_2:
+			return [95.047, 100, 108.883];
+		case StandardIlluminant.D75_10:
+			return [94.416, 100, 120.641];
+		case StandardIlluminant.D75_2:
+			return [94.972, 100, 122.638];
+		case StandardIlluminant.E_10:
+		case StandardIlluminant.E_2:
+			return [100, 100, 100];
+		case StandardIlluminant.F1_10:
+			return [94.791, 100, 103.191];
+		case StandardIlluminant.F1_2:
+			return [92.834, 100, 103.665];
+		case StandardIlluminant.F2_10:
+			return [103.28, 100, 69.026];
+		case StandardIlluminant.F2_2:
+			return [99.187, 100, 67.395];
+		case StandardIlluminant.F3_10:
+			return [108.968, 100, 51.965];
+		case StandardIlluminant.F3_2:
+			return [103.754, 100, 49.861];
+		case StandardIlluminant.F4_10:
+			return [114.961, 100, 40.963];
+		case StandardIlluminant.F4_2:
+			return [109.147, 100, 38.813];
+		case StandardIlluminant.F5_10:
+			return [93.369, 100, 98.636];
+		case StandardIlluminant.F5_2:
+			return [90.872, 100, 98.723];
+		case StandardIlluminant.F6_10:
+			return [102.148, 100, 62.074];
+		case StandardIlluminant.F6_2:
+			return [97.309, 100, 60.191];
+		case StandardIlluminant.F7_10:
+			return [95.792, 100, 107.687];
+		case StandardIlluminant.F7_2:
+			return [95.044, 100, 108.755];
+		case StandardIlluminant.F8_10:
+			return [97.115, 100, 81.135];
+		case StandardIlluminant.F8_2:
+			return [96.413, 100, 82.333];
+		case StandardIlluminant.F9_10:
+			return [102.116, 100, 67.826];
+		case StandardIlluminant.F9_2:
+			return [100.365, 100, 67.868];
+		case StandardIlluminant.F10_10:
+			return [99.001, 100, 83.134];
+		case StandardIlluminant.F10_2:
+			return [96.174, 100, 81.712];
+		case StandardIlluminant.F11_10:
+			return [103.866, 100, 65.627];
+		case StandardIlluminant.F11_2:
+			return [100.966, 100, 64.37];
+		case StandardIlluminant.F12_10:
+			return [111.428, 100, 40.353];
+		case StandardIlluminant.F12_2:
+			return [108.046, 100, 39.228];
+		default:
+			throw new RangeError("Unknown enumeration value.");
+	}
+}

package/src/utility/hexToRgb.ts

@@ -0,0 +1,11 @@
+import type Rgb from "../types/Rgb.js";
+
+/**
+ * Split a hexadecimal value into sRGB values.
+ * @param hex - The hexidecimal representation of the number (i.e. `0x50c878`).
+ * @returns R, G, and B sRGB values (each in the range `[0x00,0xff]`), in that order.
+ * @public
+ */
+export default function hexToRgb(hex: number): Rgb {
+	return [(hex >> 16) & 0xff, (hex >> 8) & 0xff, hex & 0xff];
+}

package/src/utility/hslToRgb.ts

@@ -0,0 +1,53 @@
+import type Hsl from "../types/Hsl.js";
+import type Rgb from "../types/Rgb.js";
+
+/**
+ * Converts the given hue data to RGB data.
+ * @param v0 - The first piecewise value.
+ * @param v1 - The second piecewise value.
+ * @param h - The third piecewise value.
+ * @returns The piecewise result.
+ * @internal
+ */
+const hueToRgb = (v0: number, v1: number, h: number): number => {
+	const i0 = h < 0 ? h + 1 : h > 1 ? h - 1 : h;
+	const i1 = 6 * i0;
+	const i2 = v1 - v0;
+	return i1 < 1
+		? v0 + i2 * i1
+		: 2 * i0 < 1
+			? v1
+			: 3 * i0 < 2
+				? v0 + i2 * (2 / 3 - i0) * 6
+				: v0;
+};
+
+/**
+ * Convert the given HSL color to an sRGB color. Based on the EasyRGB pseudo-code.
+ * @param color - The HSL color.
+ * @returns An sRGB color.
+ * @public
+ */
+export default function hslToRgb(color: Hsl): Rgb {
+	// eslint-disable-next-line prefer-destructuring
+	const h = color[0];
+	// eslint-disable-next-line prefer-destructuring
+	const s = color[1];
+	// eslint-disable-next-line prefer-destructuring
+	const l = color[2];
+
+	const i0 = l * 0xff;
+
+	if (s === 0) {
+		return [i0, i0, i0];
+	}
+
+	const i1 = l < 0.5 ? l * (1 + s) : l + s - s * l;
+	const i2 = 2 * l - i1;
+
+	return [
+		0xff * hueToRgb(i2, i1, h + 1 / 3),
+		0xff * hueToRgb(i2, i1, h),
+		0xff * hueToRgb(i2, i1, h - 1 / 3)
+	];
+}

package/src/utility/hsvToRgb.ts

@@ -0,0 +1,44 @@
+import type Hsv from "../types/Hsv.js";
+import type Rgb from "../types/Rgb.js";
+
+/**
+ * Convert the given HSV color to an sRGB color. Based on the EasyRGB pseudo-code.
+ * @param color - The HSV color.
+ * @returns An sRGB color.
+ * @public
+ */
+export default function hsvToRgb(color: Hsv): Rgb {
+	// eslint-disable-next-line prefer-destructuring
+	const s = color[1];
+	// eslint-disable-next-line prefer-destructuring
+	const v = color[2];
+
+	const i0 = v * 0xff;
+
+	if (s === 0) {
+		return [i0, i0, i0];
+	}
+
+	const i1 = color[0] * 6;
+	const i2 = i1 === 6 ? 0 : i1;
+	const i3 = Math.floor(i2);
+	const i4 = i2 - i3;
+	const i5 = v * (1 - s * (1 - i4)) * 0xff;
+	const i6 = v * (1 - s) * 0xff;
+
+	if (i3 === 0) {
+		return [i0, i5, i6];
+	}
+
+	if (i3 === 2) {
+		return [i6, i0, i5];
+	}
+
+	if (i3 === 4) {
+		return [i5, i6, i0];
+	}
+
+	const i7 = v * (1 - s * i4) * 0xff;
+
+	return i3 === 1 ? [i7, i0, i6] : i3 === 3 ? [i6, i7, i0] : [i0, i6, i7];
+}

package/src/utility/hunterToXyz.ts

@@ -0,0 +1,33 @@
+import type Hunter from "../types/Hunter.js";
+import StandardIlluminant from "./StandardIlluminant.js";
+import type Xyz from "../types/Xyz.js";
+import getReference from "./getReference.js";
+
+/**
+ * Convert the given Hunter Lab color to a CIEXYZ color. Based on the EasyRGB pseudo-code.
+ * @param color - The Hunter Lab color.
+ * @param ref - A standard illuminant that represents the white point.
+ * @returns A CIEXYZ color.
+ * @public
+ */
+export default function hunterToXyz(
+	color: Hunter,
+	ref: Xyz = getReference(StandardIlluminant.D65_2)
+): Xyz {
+	// eslint-disable-next-line prefer-destructuring
+	const rx = ref[0];
+	// eslint-disable-next-line prefer-destructuring
+	const ry = ref[1];
+	// eslint-disable-next-line prefer-destructuring
+	const rz = ref[2];
+
+	const y = (color[0] / ry) ** 2 * 100;
+	const i0 = y / ry;
+	const i1 = Math.sqrt(i0);
+
+	return [
+		((color[1] / (0.88365987 * (ry + rx))) * i1 + i0) * rx, // `175 / 198.04`
+		y,
+		-((color[2] / (0.32093898 * (ry + rz))) * i1 - i0) * rz // `70 / 218.11`
+	];
+}

package/src/utility/labToLch.ts

@@ -0,0 +1,24 @@
+import type Lab from "../types/Lab.js";
+import type Lch from "../types/Lch.js";
+import type Luv from "../types/Luv.js";
+
+/**
+ * Convert the given CIELAB or CIELUV color to a CIELCh(ab) or CIELCh(uv) (respectively) color. Based on the EasyRGB pseudo-code.
+ * @param color - The CIELAB or CIELUV color.
+ * @returns A CIELCh color.
+ * @public
+ */
+export default function labToLch(color: Lab | Luv): Lch {
+	// eslint-disable-next-line prefer-destructuring
+	const a = color[1];
+	// eslint-disable-next-line prefer-destructuring
+	const b = color[2];
+
+	const i0 = Math.atan2(b, a);
+
+	return [
+		color[0],
+		Math.hypot(a, b),
+		i0 > 0 ? i0 * 57.29577951 : 360 - Math.abs(i0) * 57.29577951 // `180 / Math.PI`
+	];
+}

package/src/utility/labToXyz.ts

@@ -0,0 +1,29 @@
+import type Lab from "../types/Lab.js";
+import StandardIlluminant from "./StandardIlluminant.js";
+import type Xyz from "../types/Xyz.js";
+import getReference from "./getReference.js";
+
+/**
+ * Convert the given CIELAB color to a CIEXYZ color. Based on the EasyRGB pseudo-code.
+ * @param color - The CIELAB color.
+ * @param ref - A standard illuminant that represents the white point.
+ * @returns A CIEXYZ color.
+ * @public
+ */
+export default function labToXyz(
+	color: Lab,
+	ref: Xyz = getReference(StandardIlluminant.D65_2)
+): Xyz {
+	const i0 = (color[0] + 16) / 116;
+	const i1 = i0 ** 3;
+	const i2 = color[1] / 500 + i0;
+	const i3 = i2 ** 3;
+	const i4 = i0 - color[2] / 200;
+	const i5 = i4 ** 3;
+
+	return [
+		(i3 > 0.008856 ? i3 : (i2 - 0.13793103) / 7.787) * ref[0], // `16 / 116`
+		(i1 > 0.008856 ? i1 : (i0 - 0.13793103) / 7.787) * ref[1], // `16 / 116`
+		(i5 > 0.008856 ? i5 : (i4 - 0.13793103) / 7.787) * ref[2] // `16 / 116`
+	];
+}

package/src/utility/lchToLab.ts

@@ -0,0 +1,18 @@
+import type Lab from "../types/Lab.js";
+import type Lch from "../types/Lch.js";
+import type Luv from "../types/Luv.js";
+
+/**
+ * Convert the given CIELCh(ab) or CIELCh(uv) color to a CIELAB or CIELUV (respectively) color. Based on the EasyRGB pseudo-code.
+ * @param color - The CIELCh color.
+ * @returns A CIELAB or CIELUV color.
+ * @public
+ */
+export default function lchToLab(color: Lch): Lab | Luv {
+	// eslint-disable-next-line prefer-destructuring
+	const c = color[1];
+	// eslint-disable-next-line prefer-destructuring
+	const h = color[2];
+
+	return [color[0], Math.cos(h * 0.01745329) * c, Math.sin(h * 0.01745329) * c]; // `Math.PI / 180`
+}

package/src/utility/luvToXyz.ts

@@ -0,0 +1,35 @@
+import type Luv from "../types/Luv.js";
+import StandardIlluminant from "./StandardIlluminant.js";
+import type Xyz from "../types/Xyz.js";
+import getReference from "./getReference.js";
+
+/**
+ * Convert the given CIELUV color to a CIEXYZ color. Based on the EasyRGB pseudo-code.
+ * @param color - The CIELUV color.
+ * @param ref - A standard illuminant that represents the white point.
+ * @returns A CIEXYZ color.
+ * @public
+ */
+export default function luvToXyz(
+	color: Luv,
+	ref: Xyz = getReference(StandardIlluminant.D65_2)
+): Xyz {
+	// eslint-disable-next-line prefer-destructuring
+	const l = color[0];
+	// eslint-disable-next-line prefer-destructuring
+	const rx = ref[0];
+	// eslint-disable-next-line prefer-destructuring
+	const ry = ref[1];
+
+	const i0 = (l + 16) / 116;
+	const i1 = i0 ** 3;
+	const i2 = 13 * l;
+	const i3 = rx + 15 * ry + 3 * ref[2];
+	const i4 = color[1] / i2 + (4 * rx) / i3;
+	const i5 = color[2] / i2 + (9 * ry) / i3;
+	const y = (i1 > 0.008856 ? i1 : (i0 - 0.13793103) / 7.787) * 100; // `16 / 166`
+	const i6 = 9 * y;
+	const x = -(i6 * i4) / ((i4 - 4) * i5 - i4 * i5);
+
+	return [x, y, (i6 - 15 * i5 * y - i5 * x) / (3 * i5)];
+}

package/src/utility/relativeLuminance.ts

@@ -0,0 +1,25 @@
+import type Rgb from "../types/Rgb.js";
+
+/**
+ * The piecewise function that is used internally for calculating relative luminance.
+ * @param a - The value in a channel of a color.
+ * @returns The piecewise value.
+ * @internal
+ */
+const piecewise = (a: number) =>
+	a > 0.04045 ? ((a + 0.055) / 1.055) ** 2.4 : a / 12.92;
+
+/**
+ * Calculate the relative luminance of an sRGB color.
+ * @param color - The sRGB color.
+ * @returns The relative luminance of the sRGB color.
+ * @see {@link https://www.w3.org/WAI/GL/wiki/Relative_luminance | Relative luminance}
+ * @public
+ */
+export default function relativeLuminance(color: Rgb): number {
+	return (
+		0.2126 * piecewise(color[0] / 0xff) +
+		0.7152 * piecewise(color[1] / 0xff) +
+		0.0722 * piecewise(color[2] / 0xff)
+	);
+}

package/src/utility/rgbToCmy.ts

@@ -0,0 +1,12 @@
+import type Cmy from "../types/Cmy.js";
+import type Rgb from "../types/Rgb.js";
+
+/**
+ * Convert the given sRGB color to a CMY color. Based on the EasyRGB pseudo-code.
+ * @param color - The sRGB color.
+ * @returns A CMY color.
+ * @public
+ */
+export default function rgbToCmy(color: Rgb): Cmy {
+	return [1 - color[0] / 0xff, 1 - color[1] / 0xff, 1 - color[2] / 0xff];
+}

package/src/utility/rgbToHsl.ts

@@ -0,0 +1,38 @@
+import type Hsl from "../types/Hsl.js";
+import type Rgb from "../types/Rgb.js";
+
+/**
+ * Convert the given sRGB color to an HSL color. Based on the EasyRGB pseudo-code.
+ * @param color - The sRGB color.
+ * @returns An HSL color.
+ * @public
+ */
+export default function rgbToHsl(color: Rgb): Hsl {
+	const i0 = color[0] / 0xff;
+	const i1 = color[1] / 0xff;
+	const i2 = color[2] / 0xff;
+	const i3 = Math.min(i0, i1, i2);
+	const i4 = Math.max(i0, i1, i2);
+	const l = (i4 + i3) / 2;
+	const i5 = i4 - i3;
+
+	if (i5 === 0) {
+		return [0, 0, l];
+	}
+
+	const s = l < 0.5 ? i5 / (i4 + i3) : i5 / (2 - i4 - i3);
+	const i6 = ((i4 - i0) / 6 + i5 / 2) / i5;
+	const i7 = ((i4 - i1) / 6 + i5 / 2) / i5;
+	const i8 = ((i4 - i2) / 6 + i5 / 2) / i5;
+	const i9 =
+		i0 === i4
+			? i8 - i7
+			: i1 === i4
+				? 1 / 3 + i6 - i8
+				: i2 === i4
+					? 2 / 3 + i7 - i6
+					: 0;
+	const h = i9 < 0 ? i9 + 1 : i9 > 1 ? i9 - 1 : i9;
+
+	return [h, s, l];
+}

package/src/utility/rgbToHsv.ts

@@ -0,0 +1,35 @@
+import type Hsv from "../types/Hsv.js";
+import type Rgb from "../types/Rgb.js";
+
+/**
+ * Convert the given sRGB color to an HSV color. Based on the EasyRGB pseudo-code.
+ * @param color - The sRGB color.
+ * @returns An HSV color.
+ * @public
+ */
+export default function rgbToHsv(color: Rgb): Hsv {
+	const i0 = color[0] / 0xff;
+	const i1 = color[1] / 0xff;
+	const i2 = color[2] / 0xff;
+	const v = Math.max(i0, i1, i2);
+	const i3 = v - Math.min(i0, i1, i2);
+
+	if (i3 === 0) {
+		return [0, 0, v];
+	}
+
+	const i4 = i3 / 2;
+	const i5 = ((v - i0) / 6 + i4) / i3;
+	const i6 = ((v - i1) / 6 + i4) / i3;
+	const i7 = ((v - i2) / 6 + i4) / i3;
+	const i8 =
+		i0 === v
+			? i7 - i6
+			: i1 === v
+				? 0.33333333 + i5 - i7 // `1 / 3`
+				: i2 === v
+					? 0.66666666 + i6 - i5 // `2 / 3`
+					: 0;
+
+	return [i8 < 0 ? i8 + 1 : i8 > 1 ? i8 - 1 : i8, i3 / v, v];
+}

package/src/utility/rgbToXyz.ts

@@ -0,0 +1,23 @@
+import type Rgb from "../types/Rgb.js";
+import type Xyz from "../types/Xyz.js";
+
+/**
+ * Convert the given sRGB color to a CIEXYZ color. Based on the EasyRGB pseudo-code.
+ * @param color - The sRGB color.
+ * @returns A CIEXYZ color.
+ * @public
+ */
+export default function rgbToXyz(color: Rgb): Xyz {
+	const i0 = color[0] / 0xff;
+	const i1 = color[1] / 0xff;
+	const i2 = color[2] / 0xff;
+	const i3 = (i0 > 0.04045 ? ((i0 + 0.055) / 1.055) ** 2.4 : i0 / 12.92) * 100;
+	const i4 = (i1 > 0.04045 ? ((i1 + 0.055) / 1.055) ** 2.4 : i1 / 12.92) * 100;
+	const i5 = (i2 > 0.04045 ? ((i2 + 0.055) / 1.055) ** 2.4 : i2 / 12.92) * 100;
+
+	return [
+		i3 * 0.4124 + i4 * 0.3576 + i5 * 0.1805,
+		i3 * 0.2126 + i4 * 0.7152 + i5 * 0.0722,
+		i3 * 0.0193 + i4 * 0.1192 + i5 * 0.9505
+	];
+}

package/src/utility/xyzToAdobe.ts

@@ -0,0 +1,20 @@
+import type Adobe from "../types/Adobe.js";
+import type Xyz from "../types/Xyz.js";
+
+/**
+ * Convert the given CIEXYZ D65/2° standard illuminant color to an Adobe RGB color. Based on the EasyRGB pseudo-code.
+ * @param color - The CIEXYZ color.
+ * @returns An Adobe RGB color.
+ * @public
+ */
+export default function xyzToAdobe(color: Xyz): Adobe {
+	const i0 = color[0] / 100;
+	const i1 = color[1] / 100;
+	const i2 = color[2] / 100;
+
+	return [
+		(i0 * 2.04137 + i1 * -0.56495 + i2 * -0.34469) ** 0.45470693 * 0xff, // `1 / 2.19921875`
+		(i0 * -0.96927 + i1 * 1.87601 + i2 * 0.04156) ** 0.45470693 * 0xff, // `1 / 2.19921875`
+		(i0 * 0.01345 + i1 * -0.11839 + i2 * 1.01541) ** 0.45470693 * 0xff // `1 / 2.19921875`
+	];
+}

package/src/utility/xyzToHunter.ts

@@ -0,0 +1,32 @@
+import type Hunter from "../types/Hunter.js";
+import StandardIlluminant from "./StandardIlluminant.js";
+import type Xyz from "../types/Xyz.js";
+import getReference from "./getReference.js";
+
+/**
+ * Convert the given CIEXYZ color to a Hunter Lab color. Based on the EasyRGB pseudo-code.
+ * @param color - The CIEXYZ color.
+ * @param ref - A standard illuminant that represents the white point.
+ * @returns A Hunter Lab color.
+ * @public
+ */
+export default function xyzToHunter(
+	color: Xyz,
+	ref: Xyz = getReference(StandardIlluminant.D65_2)
+): Hunter {
+	// eslint-disable-next-line prefer-destructuring
+	const rx = ref[0];
+	// eslint-disable-next-line prefer-destructuring
+	const ry = ref[1];
+	// eslint-disable-next-line prefer-destructuring
+	const rz = ref[2];
+
+	const i2 = color[1] / ry;
+	const i3 = Math.sqrt(i2);
+
+	return [
+		100 * i3,
+		0.88365987 * (ry + rx) * ((color[0] / rx - i2) / i3), // `175 / 198.04`
+		0.32093898 * (ry + rz) * ((i2 - color[2] / rz) / i3) // `70 / 218.11`
+	];
+}