@luntta/swatch 3.0.0

package/src/spaces/a98.js

@@ -0,0 +1,55 @@
+// Adobe RGB (1998) / A98 color space.
+//
+// D65 white with a pure power-law transfer function (γ = 563/256 ≈
+// 2.19921875). Historically significant in print/photo pipelines for
+// its wider green reach compared to sRGB.
+//
+// Matrices from the CSS Color 4 sample code.
+
+import { multiplyMatrixVector } from "../util/matrix.js";
+import { registerSpace } from "../core/registry.js";
+
+const GAMMA = 563 / 256; // 2.19921875
+
+export function a98ToLinear(coords) {
+	const f = (v) => Math.sign(v) * Math.pow(Math.abs(v), GAMMA);
+	return [f(coords[0]), f(coords[1]), f(coords[2])];
+}
+
+export function linearToA98(lin) {
+	const f = (v) => Math.sign(v) * Math.pow(Math.abs(v), 1 / GAMMA);
+	return [f(lin[0]), f(lin[1]), f(lin[2])];
+}
+
+export const LINEAR_A98_TO_XYZ_D65 = [
+	[0.5766690429101305, 0.1855582379065463, 0.1882286462349947],
+	[0.29734497525053605, 0.6273635662554661, 0.07529145849399788],
+	[0.02703136138641234, 0.07068885253582723, 0.9913375368376388]
+];
+
+export const XYZ_D65_TO_LINEAR_A98 = [
+	[2.0415879038107465, -0.5650069742788596, -0.34473135077832957],
+	[-0.9692436362808795, 1.8759675015077202, 0.04155505740717557],
+	[0.013444280632031142, -0.11836239223101835, 1.0151749943912054]
+];
+
+export function linearA98ToXyz(lin) {
+	return multiplyMatrixVector(LINEAR_A98_TO_XYZ_D65, lin);
+}
+
+export function xyzToLinearA98(xyz) {
+	return multiplyMatrixVector(XYZ_D65_TO_LINEAR_A98, xyz);
+}
+
+registerSpace({
+	id: "a98",
+	channels: ["r", "g", "b"],
+	ranges: [
+		[0, 1],
+		[0, 1],
+		[0, 1]
+	],
+	white: "D65",
+	toXYZ: (coords) => linearA98ToXyz(a98ToLinear(coords)),
+	fromXYZ: (xyz) => linearToA98(xyzToLinearA98(xyz))
+});

package/src/spaces/cmyk.js

@@ -0,0 +1,75 @@
+// CMYK — naive device-independent conversion.
+//
+// WARNING: this is the textbook "no profile" CMYK that every color
+// library ships. It has no relationship to any real printer's behavior,
+// which requires an ICC profile and a specific ink set. For on-screen
+// use (CMYK-as-quadruple in CSS pipelines, CMYK-ish color picker math),
+// it's fine; for print production, run it through a real CMS.
+
+import { registerSpace, getSpace } from "../core/registry.js";
+
+export function srgbToCmyk(rgb) {
+	const [r, g, b] = rgb;
+	const k = 1 - Math.max(r, g, b);
+	if (k >= 1 - 1e-12) return [0, 0, 0, 1];
+	const c = (1 - r - k) / (1 - k);
+	const m = (1 - g - k) / (1 - k);
+	const y = (1 - b - k) / (1 - k);
+	return [c, m, y, k];
+}
+
+export function cmykToSrgb(cmyk) {
+	const [c, m, y, k] = cmyk;
+	return [(1 - c) * (1 - k), (1 - m) * (1 - k), (1 - y) * (1 - k)];
+}
+
+// CMYK is 4-channel, which doesn't fit the 3-channel canonical state.
+// We store it in a 3-channel shell by stashing K in the conversion
+// shortcut layer: the registry treats cmyk as { c, m, y } plus a
+// separate `_k` stored via the second-channel pattern... wait, that
+// breaks the invariant.
+//
+// Simpler: cmyk is stored as [c, m, y] internally with K derived on
+// conversion. To preserve all four values for a user who constructs
+// from {c, m, y, k}, we embed k into the space by treating the storage
+// as 3D and converting deterministically on the way in/out — losing a
+// degree of freedom. This matches colorjs.io's approach: CMYK is a
+// "view" not a "storage" space. parse/objects.js therefore immediately
+// converts {c,m,y,k} into sRGB and stores it as srgb.
+//
+// For registration purposes, CMYK is still a registered space so
+// `c.cmyk` and `c.to('cmyk')` work — it converts sRGB on demand.
+// Channels on the stored state are [c, m, y]; K is computed at read
+// time by re-running srgbToCmyk on the round-tripped sRGB coords.
+
+export function srgbToCmykTriplet(rgb) {
+	// Store [c, m, y] compressed without K; the sRGB round-trip
+	// loses the K degree of freedom which is fine since device-
+	// independent CMYK is a view, not a storage space.
+	const [c, m, y, k] = srgbToCmyk(rgb);
+	// Fold K into CMY for the 3-channel view:
+	return [c + k - c * k, m + k - m * k, y + k - y * k];
+}
+
+export function cmykTripletToSrgb(cmy) {
+	// Inverse of the folded-K representation.
+	return [1 - cmy[0], 1 - cmy[1], 1 - cmy[2]];
+}
+
+registerSpace({
+	id: "cmyk",
+	channels: ["c", "m", "y"],
+	ranges: [
+		[0, 1],
+		[0, 1],
+		[0, 1]
+	],
+	white: "D65",
+	toXYZ: (coords) => getSpace("srgb").toXYZ(cmykTripletToSrgb(coords)),
+	fromXYZ: (xyz) => srgbToCmykTriplet(getSpace("srgb").fromXYZ(xyz)),
+	shortcuts: {
+		srgb: (coords) => cmykTripletToSrgb(coords)
+	}
+});
+
+getSpace("srgb").shortcuts.cmyk = (coords) => srgbToCmykTriplet(coords);

package/src/spaces/display-p3.js

@@ -0,0 +1,50 @@
+// Display P3 color space.
+//
+// P3 primaries + D65 white, using the same transfer function as sRGB
+// (the 0.04045 knee, γ ≈ 2.4). P3 is the default wide-gamut space for
+// modern displays; Apple adopted it industry-wide and CSS Color 4
+// standardizes it under `color(display-p3 r g b)`.
+//
+// Matrices from the CSS Color 4 sample code
+// (https://www.w3.org/TR/css-color-4/#color-conversion-code).
+
+import { multiplyMatrixVector } from "../util/matrix.js";
+import { registerSpace } from "../core/registry.js";
+import { srgbToLinear, linearToSrgb } from "./srgb.js";
+
+export const LINEAR_P3_TO_XYZ_D65 = [
+	[0.4865709486482162, 0.26566769316909306, 0.1982172852343625],
+	[0.2289745640697488, 0.6917385218365064, 0.079286914093745],
+	[0.0, 0.04511338185890264, 1.043944368900976]
+];
+
+export const XYZ_D65_TO_LINEAR_P3 = [
+	[2.493496911941425, -0.9313836179191239, -0.40271078445071684],
+	[-0.8294889695615747, 1.7626640603183463, 0.023624685841943577],
+	[0.03584583024378447, -0.07617238926804182, 0.9568845240076872]
+];
+
+export function linearP3ToXyz(lin) {
+	return multiplyMatrixVector(LINEAR_P3_TO_XYZ_D65, lin);
+}
+
+export function xyzToLinearP3(xyz) {
+	return multiplyMatrixVector(XYZ_D65_TO_LINEAR_P3, xyz);
+}
+
+// Display P3 uses the sRGB EOTF, so we reuse the sRGB helpers.
+export const p3ToLinear = srgbToLinear;
+export const linearToP3 = linearToSrgb;
+
+registerSpace({
+	id: "display-p3",
+	channels: ["r", "g", "b"],
+	ranges: [
+		[0, 1],
+		[0, 1],
+		[0, 1]
+	],
+	white: "D65",
+	toXYZ: (coords) => linearP3ToXyz(p3ToLinear(coords)),
+	fromXYZ: (xyz) => linearToP3(xyzToLinearP3(xyz))
+});

package/src/spaces/hsl.js

@@ -0,0 +1,93 @@
+// HSL — the CSS HSL color space, defined against gamma-encoded sRGB.
+//
+// H in [0, 360) degrees; S and L in [0, 100] percent (CSS convention).
+// Ports the conversion math from v2 `_RGBAToHSLA` (src/swatch.js:808-873) and
+// `_HSLToRGB` (src/swatch.js:546-613) but operates on unit-RGB coords
+// instead of 0..255 ints.
+
+import { registerSpace, getSpace } from "../core/registry.js";
+
+// Unit-RGB → HSL. rgb coords in [0, 1]; output h in [0, 360), s/l in [0, 100].
+export function srgbToHsl(rgb) {
+	const r = rgb[0];
+	const g = rgb[1];
+	const b = rgb[2];
+	const max = Math.max(r, g, b);
+	const min = Math.min(r, g, b);
+	const delta = max - min;
+	let h = 0;
+	let s = 0;
+	const l = (max + min) / 2;
+
+	if (delta !== 0) {
+		s = delta / (1 - Math.abs(2 * l - 1));
+		if (max === r) {
+			h = ((g - b) / delta) % 6;
+		} else if (max === g) {
+			h = (b - r) / delta + 2;
+		} else {
+			h = (r - g) / delta + 4;
+		}
+		h *= 60;
+		if (h < 0) h += 360;
+	}
+
+	return [h, s * 100, l * 100];
+}
+
+// HSL → unit-RGB.
+export function hslToSrgb(hsl) {
+	const h = ((hsl[0] % 360) + 360) % 360;
+	const s = hsl[1] / 100;
+	const l = hsl[2] / 100;
+	const c = (1 - Math.abs(2 * l - 1)) * s;
+	const x = c * (1 - Math.abs(((h / 60) % 2) - 1));
+	const m = l - c / 2;
+	let r1 = 0;
+	let g1 = 0;
+	let b1 = 0;
+	if (h < 60) {
+		r1 = c;
+		g1 = x;
+	} else if (h < 120) {
+		r1 = x;
+		g1 = c;
+	} else if (h < 180) {
+		g1 = c;
+		b1 = x;
+	} else if (h < 240) {
+		g1 = x;
+		b1 = c;
+	} else if (h < 300) {
+		r1 = x;
+		b1 = c;
+	} else {
+		r1 = c;
+		b1 = x;
+	}
+	return [r1 + m, g1 + m, b1 + m];
+}
+
+registerSpace({
+	id: "hsl",
+	channels: ["h", "s", "l"],
+	ranges: [
+		[0, 360],
+		[0, 100],
+		[0, 100]
+	],
+	white: "D65",
+	toXYZ: (coords) => {
+		const rgb = hslToSrgb(coords);
+		return getSpace("srgb").toXYZ(rgb);
+	},
+	fromXYZ: (xyz) => {
+		const rgb = getSpace("srgb").fromXYZ(xyz);
+		return srgbToHsl(rgb);
+	},
+	shortcuts: {
+		srgb: (coords) => hslToSrgb(coords)
+	}
+});
+
+getSpace("srgb").shortcuts.hsl = (coords) => srgbToHsl(coords);

package/src/spaces/hsluv.js

@@ -0,0 +1,211 @@
+// HSLuv — perceptually uniform alternative to HSL.
+//
+// Ported from the canonical reference at https://github.com/hsluv/hsluv
+// (Alexei Boronine, MIT License). HSLuv is CIELuv under a polar
+// transform with the chroma normalized against the maximum possible
+// chroma for each (L, H) in the sRGB gamut — so S = 100 always means
+// "as saturated as sRGB will allow" at that lightness/hue, and lines
+// of constant L are perceptually flat.
+//
+// The intermediate CIELuv space is registered too (as id 'luv').
+//
+// We register HSLuv with a direct srgb shortcut so there is no
+// precision-losing round-trip through the generic XYZ hub when the
+// user reads `.hsluv` or calls `.to('hsluv')` from an sRGB source.
+
+import { registerSpace, getSpace } from "../core/registry.js";
+
+// sRGB linear ↔ XYZ matrices per the HSLuv reference (BT.709,
+// numerically identical to src/spaces/srgb.js within ~1e-6).
+const M = [
+	[3.240969941904521, -1.537383177570093, -0.498610760293],
+	[-0.96924363628087, 1.87596750150772, 0.041555057407175],
+	[0.055630079696993, -0.20397695888897, 1.056971514242878]
+];
+const M_INV = [
+	[0.41239079926595, 0.35758433938387, 0.18048078840183],
+	[0.21263900587151, 0.71516867876775, 0.07219231536073],
+	[0.01933081871559, 0.11919477979462, 0.9505321522496]
+];
+
+const REF_U = 0.19783000664283;
+const REF_V = 0.46831999493879;
+const KAPPA = 903.2962962;
+const EPSILON = 0.0088564516;
+
+function dotProduct(row, v) {
+	return row[0] * v[0] + row[1] * v[1] + row[2] * v[2];
+}
+
+function srgbLinearToRgb(lin) {
+	// Matches the sRGB EOTF; copied here so hsluv is self-contained.
+	const f = (v) =>
+		Math.abs(v) <= 0.0031308
+			? 12.92 * v
+			: Math.sign(v) * (1.055 * Math.pow(Math.abs(v), 1 / 2.4) - 0.055);
+	return [f(lin[0]), f(lin[1]), f(lin[2])];
+}
+
+function rgbToSrgbLinear(rgb) {
+	const f = (v) =>
+		Math.abs(v) <= 0.04045
+			? v / 12.92
+			: Math.sign(v) * Math.pow((Math.abs(v) + 0.055) / 1.055, 2.4);
+	return [f(rgb[0]), f(rgb[1]), f(rgb[2])];
+}
+
+// Get the 6 lines in the (u, v) plane that bound the sRGB gamut for
+// the given L value.
+function getBounds(L) {
+	const result = [];
+	const sub1 = Math.pow(L + 16, 3) / 1560896;
+	const sub2 = sub1 > EPSILON ? sub1 : L / KAPPA;
+	for (let channel = 0; channel < 3; channel++) {
+		const m1 = M[channel][0];
+		const m2 = M[channel][1];
+		const m3 = M[channel][2];
+		for (let t = 0; t < 2; t++) {
+			const top1 = (284517 * m1 - 94839 * m3) * sub2;
+			const top2 =
+				(838422 * m3 + 769860 * m2 + 731718 * m1) * L * sub2 - 769860 * t * L;
+			const bottom = (632260 * m3 - 126452 * m2) * sub2 + 126452 * t;
+			result.push({ slope: top1 / bottom, intercept: top2 / bottom });
+		}
+	}
+	return result;
+}
+
+function lengthOfRayUntilIntersect(theta, line) {
+	return line.intercept / (Math.sin(theta) - line.slope * Math.cos(theta));
+}
+
+function maxChromaForLH(L, H) {
+	const hrad = (H / 360) * Math.PI * 2;
+	let min = Infinity;
+	for (const bound of getBounds(L)) {
+		const length = lengthOfRayUntilIntersect(hrad, bound);
+		if (length >= 0 && length < min) min = length;
+	}
+	return min;
+}
+
+function yToL(Y) {
+	if (Y <= EPSILON) return Y * KAPPA;
+	return 116 * Math.cbrt(Y) - 16;
+}
+
+function lToY(L) {
+	if (L <= 8) return L / KAPPA;
+	return Math.pow((L + 16) / 116, 3);
+}
+
+// XYZ (D65, Y=1 for white) → CIELuv.
+export function xyzToLuv(xyz) {
+	const [X, Y, Z] = xyz;
+	const divisor = X + 15 * Y + 3 * Z;
+	if (divisor === 0) return [0, 0, 0];
+	const varU = (4 * X) / divisor;
+	const varV = (9 * Y) / divisor;
+	const L = yToL(Y);
+	if (L === 0) return [0, 0, 0];
+	const U = 13 * L * (varU - REF_U);
+	const V = 13 * L * (varV - REF_V);
+	return [L, U, V];
+}
+
+export function luvToXyz(luv) {
+	const [L, U, V] = luv;
+	if (L === 0) return [0, 0, 0];
+	const varU = U / (13 * L) + REF_U;
+	const varV = V / (13 * L) + REF_V;
+	const Y = lToY(L);
+	const X = -(9 * Y * varU) / ((varU - 4) * varV - varU * varV);
+	const Z = (9 * Y - 15 * varV * Y - varV * X) / (3 * varV);
+	return [X, Y, Z];
+}
+
+function luvToLchuv(luv) {
+	const [L, U, V] = luv;
+	const C = Math.sqrt(U * U + V * V);
+	let H;
+	if (C < 1e-8) {
+		H = 0;
+	} else {
+		H = (Math.atan2(V, U) * 180) / Math.PI;
+		if (H < 0) H += 360;
+	}
+	return [L, C, H];
+}
+
+function lchuvToLuv(lch) {
+	const [L, C, H] = lch;
+	const hrad = (H * Math.PI) / 180;
+	return [L, Math.cos(hrad) * C, Math.sin(hrad) * C];
+}
+
+function hsluvToLchuv(hsl) {
+	const [H, S, L] = hsl;
+	if (L > 99.9999999) return [100, 0, H];
+	if (L < 0.00000001) return [0, 0, H];
+	const max = maxChromaForLH(L, H);
+	const C = (max / 100) * S;
+	return [L, C, H];
+}
+
+function lchuvToHsluv(lch) {
+	const [L, C, H] = lch;
+	if (L > 99.9999999) return [H, 0, 100];
+	if (L < 0.00000001) return [H, 0, 0];
+	const max = maxChromaForLH(L, H);
+	const S = (C / max) * 100;
+	return [H, S, L];
+}
+
+// HSLuv → sRGB (using HSLuv's internal matrices).
+export function hsluvToSrgb(hsluv) {
+	const lch = hsluvToLchuv(hsluv);
+	const luv = lchuvToLuv(lch);
+	const xyz = luvToXyz(luv);
+	const lin = [dotProduct(M[0], xyz), dotProduct(M[1], xyz), dotProduct(M[2], xyz)];
+	return srgbLinearToRgb(lin);
+}
+
+export function srgbToHsluv(rgb) {
+	const lin = rgbToSrgbLinear(rgb);
+	const xyz = [
+		dotProduct(M_INV[0], lin),
+		dotProduct(M_INV[1], lin),
+		dotProduct(M_INV[2], lin)
+	];
+	const luv = xyzToLuv(xyz);
+	const lch = luvToLchuv(luv);
+	return lchuvToHsluv(lch);
+}
+
+// Register CIELuv as a standalone space.
+registerSpace({
+	id: "luv",
+	channels: ["l", "u", "v"],
+	white: "D65",
+	toXYZ: (coords) => luvToXyz(coords),
+	fromXYZ: (xyz) => xyzToLuv(xyz)
+});
+
+// Register HSLuv with a direct sRGB shortcut.
+registerSpace({
+	id: "hsluv",
+	channels: ["h", "s", "l"],
+	ranges: [
+		[0, 360],
+		[0, 100],
+		[0, 100]
+	],
+	white: "D65",
+	toXYZ: (coords) => getSpace("srgb").toXYZ(hsluvToSrgb(coords)),
+	fromXYZ: (xyz) => srgbToHsluv(getSpace("srgb").fromXYZ(xyz)),
+	shortcuts: {
+		srgb: (coords) => hsluvToSrgb(coords)
+	}
+});
+
+getSpace("srgb").shortcuts.hsluv = (coords) => srgbToHsluv(coords);

package/src/spaces/hsv.js

@@ -0,0 +1,78 @@
+// HSV / HSB space (Hue, Saturation, Value/Brightness).
+//
+// Defined on top of sRGB: H in degrees, S and V in 0..100 (percent-
+// like units) to match the conventions used by the rest of the library.
+//
+// Bidirectional shortcut to sRGB bypasses the XYZ hub. toXYZ / fromXYZ
+// still route through sRGB for the conversion graph fallback.
+
+import { registerSpace, getSpace } from "../core/registry.js";
+
+export function srgbToHsv(rgb) {
+	const [r, g, b] = rgb;
+	const max = Math.max(r, g, b);
+	const min = Math.min(r, g, b);
+	const delta = max - min;
+	let h = 0;
+	if (delta !== 0) {
+		if (max === r) h = 60 * (((g - b) / delta) % 6);
+		else if (max === g) h = 60 * ((b - r) / delta + 2);
+		else h = 60 * ((r - g) / delta + 4);
+	}
+	if (h < 0) h += 360;
+	const s = max === 0 ? 0 : (delta / max) * 100;
+	const v = max * 100;
+	return [h, s, v];
+}
+
+export function hsvToSrgb(hsv) {
+	const [h, sPct, vPct] = hsv;
+	const s = sPct / 100;
+	const v = vPct / 100;
+	const c = v * s;
+	const hp = ((h % 360) + 360) % 360 / 60;
+	const x = c * (1 - Math.abs((hp % 2) - 1));
+	let r1 = 0,
+		g1 = 0,
+		b1 = 0;
+	if (hp < 1) {
+		r1 = c;
+		g1 = x;
+	} else if (hp < 2) {
+		r1 = x;
+		g1 = c;
+	} else if (hp < 3) {
+		g1 = c;
+		b1 = x;
+	} else if (hp < 4) {
+		g1 = x;
+		b1 = c;
+	} else if (hp < 5) {
+		r1 = x;
+		b1 = c;
+	} else {
+		r1 = c;
+		b1 = x;
+	}
+	const m = v - c;
+	return [r1 + m, g1 + m, b1 + m];
+}
+
+registerSpace({
+	id: "hsv",
+	channels: ["h", "s", "v"],
+	ranges: [
+		[0, 360],
+		[0, 100],
+		[0, 100]
+	],
+	white: "D65",
+	toXYZ: (coords) => getSpace("srgb").toXYZ(hsvToSrgb(coords)),
+	fromXYZ: (xyz) => srgbToHsv(getSpace("srgb").fromXYZ(xyz)),
+	shortcuts: {
+		srgb: (coords) => hsvToSrgb(coords)
+	}
+});
+
+// Patch reverse shortcut on sRGB now that HSV exists.
+getSpace("srgb").shortcuts.hsv = (coords) => srgbToHsv(coords);

package/src/spaces/hwb.js

@@ -0,0 +1,48 @@
+// HWB (Hue, Whiteness, Blackness) — CSS Color 4 definition.
+//
+// H in degrees (same as HSL/HSV); W and B are percentage-like 0..100
+// units representing how much white / black is mixed in. When W + B
+// >= 100, the result is a neutral grey W/(W+B).
+//
+// Converts through HSV (sharing the hue) per the CSS spec.
+
+import { registerSpace, getSpace } from "../core/registry.js";
+import { srgbToHsv, hsvToSrgb } from "./hsv.js";
+
+export function srgbToHwb(rgb) {
+	const [h] = srgbToHsv(rgb);
+	const w = Math.min(rgb[0], rgb[1], rgb[2]) * 100;
+	const b = (1 - Math.max(rgb[0], rgb[1], rgb[2])) * 100;
+	return [h, w, b];
+}
+
+export function hwbToSrgb(hwb) {
+	const [h, wPct, blPct] = hwb;
+	const w = wPct / 100;
+	const bl = blPct / 100;
+	if (w + bl >= 1) {
+		const gray = w / (w + bl);
+		return [gray, gray, gray];
+	}
+	const base = hsvToSrgb([h, 100, 100]);
+	const scale = 1 - w - bl;
+	return [base[0] * scale + w, base[1] * scale + w, base[2] * scale + w];
+}
+
+registerSpace({
+	id: "hwb",
+	channels: ["h", "w", "b"],
+	ranges: [
+		[0, 360],
+		[0, 100],
+		[0, 100]
+	],
+	white: "D65",
+	toXYZ: (coords) => getSpace("srgb").toXYZ(hwbToSrgb(coords)),
+	fromXYZ: (xyz) => srgbToHwb(getSpace("srgb").fromXYZ(xyz)),
+	shortcuts: {
+		srgb: (coords) => hwbToSrgb(coords)
+	}
+});
+
+getSpace("srgb").shortcuts.hwb = (coords) => srgbToHwb(coords);

package/src/spaces/lab.js

@@ -0,0 +1,70 @@
+// CIE Lab color space.
+//
+// Two variants are registered:
+//
+//   lab      — D65 reference white (our default; matches what v2 used).
+//   lab-d50  — D50 reference white (the CSS Color 4 specified variant).
+//
+// Both follow the standard CIE L*a*b* transfer functions. L is on a 0..100
+// scale; a and b are signed.
+//
+// Porting reference: v2 `_XYZToLab` at src/swatch.js:1463-1482 and `_labToRGB`
+// at src/swatch.js:1098-1128.
+
+import { registerSpace } from "../core/registry.js";
+import { D65, D50, adaptD50ToD65, adaptD65ToD50 } from "./xyz.js";
+
+const KAPPA = 24389 / 27; // (29/3)^3
+const EPSILON = 216 / 24389; // (6/29)^3
+const DELTA = 6 / 29;
+
+function labForward(xyz, white) {
+	const f = (t) =>
+		t > EPSILON ? Math.cbrt(t) : (KAPPA * t + 16) / 116;
+	const fx = f(xyz[0] / white[0]);
+	const fy = f(xyz[1] / white[1]);
+	const fz = f(xyz[2] / white[2]);
+	return [116 * fy - 16, 500 * (fx - fy), 200 * (fy - fz)];
+}
+
+function labInverse(lab, white) {
+	const fy = (lab[0] + 16) / 116;
+	const fx = lab[1] / 500 + fy;
+	const fz = fy - lab[2] / 200;
+	const finv = (t) =>
+		t > DELTA ? t * t * t : 3 * DELTA * DELTA * (t - 4 / 29);
+	return [
+		white[0] * finv(fx),
+		white[1] * finv(fy),
+		white[2] * finv(fz)
+	];
+}
+
+// Lab D65 — the v2 default; all existing tests expect this.
+registerSpace({
+	id: "lab",
+	channels: ["l", "a", "b"],
+	ranges: [
+		[0, 100],
+		[-125, 125],
+		[-125, 125]
+	],
+	white: "D65",
+	toXYZ: (coords) => labInverse(coords, D65),
+	fromXYZ: (xyz) => labForward(xyz, D65)
+});
+
+// Lab D50 — CSS Color 4 lab() uses this. Bradford-adapts to D65 on the
+// way to the hub.
+registerSpace({
+	id: "lab-d50",
+	channels: ["l", "a", "b"],
+	ranges: [
+		[0, 100],
+		[-125, 125],
+		[-125, 125]
+	],
+	white: "D50",
+	toXYZ: (coords) => adaptD50ToD65(labInverse(coords, D50)),
+	fromXYZ: (xyz) => labForward(adaptD65ToD50(xyz), D50)
+});