color-map 2.2.0 → 2.3.0

package/cjs/parse-8mt2OMKf.js

@@ -0,0 +1,1508 @@
+// src/color/matrices.ts
+const srgbToXyz = [
+	506752 / 1228815,
+	87881 / 245763,
+	12673 / 70218,
+	87098 / 409605,
+	175762 / 245763,
+	12673 / 175545,
+	7918 / 409605,
+	87881 / 737289,
+	1001167 / 1053270
+];
+const xyzToSrgb = [
+	12831 / 3959,
+	-329 / 214,
+	-1974 / 3959,
+	-851781 / 878810,
+	1648619 / 878810,
+	36519 / 878810,
+	705 / 12673,
+	-2585 / 12673,
+	705 / 667
+];
+const p3ToXyz = [
+	608311 / 1250200,
+	189793 / 714400,
+	198249 / 1000160,
+	35783 / 156275,
+	247089 / 357200,
+	198249 / 2500400,
+	0,
+	32229 / 714400,
+	5220557 / 5000800
+];
+const xyzToP3 = [
+	446124 / 178915,
+	-333277 / 357830,
+	-72051 / 178915,
+	-14852 / 17905,
+	63121 / 35810,
+	423 / 17905,
+	11844 / 330415,
+	-50337 / 660830,
+	316169 / 330415
+];
+const a98ToXyz = [
+	573536 / 994567,
+	263643 / 1420810,
+	187206 / 994567,
+	591459 / 1989134,
+	6239551 / 9945670,
+	374412 / 4972835,
+	53769 / 1989134,
+	351524 / 4972835,
+	4929758 / 4972835
+];
+const xyzToA98 = [
+	1829569 / 896150,
+	-506331 / 896150,
+	-308931 / 896150,
+	-851781 / 878810,
+	1648619 / 878810,
+	36519 / 878810,
+	16779 / 1248040,
+	-147721 / 1248040,
+	1266979 / 1248040
+];
+const prophotoToXyzD50 = [
+	.7977666449006423,
+	.13518129740053308,
+	.0313477341283922,
+	.2880748288194013,
+	.711835234241873,
+	8993693872564e-17,
+	0,
+	0,
+	.8251046025104602
+];
+const xyzD50ToProphoto = [
+	1.3457868816471583,
+	-.25557208737979464,
+	-.05110186497554526,
+	-.5446307051249019,
+	1.5082477428451468,
+	.02052744743642139,
+	0,
+	0,
+	1.2119675456389452
+];
+const rec2020ToXyz = [
+	63426534 / 99577255,
+	20160776 / 139408157,
+	47086771 / 278816314,
+	26158966 / 99577255,
+	472592308 / 697040785,
+	8267143 / 139408157,
+	0,
+	19567812 / 697040785,
+	295819943 / 278816314
+];
+const xyzToRec2020 = [
+	30757411 / 17917100,
+	-6372589 / 17917100,
+	-4539589 / 17917100,
+	-19765991 / 29648200,
+	47925759 / 29648200,
+	467509 / 29648200,
+	792561 / 44930125,
+	-1921689 / 44930125,
+	42328811 / 44930125
+];
+const d65ToD50 = [
+	1.0479297925449969,
+	.022946870601609652,
+	-.05019226628920524,
+	.02962780877005599,
+	.9904344267538799,
+	-.017073799063418826,
+	-.009243040646204504,
+	.015055191490298152,
+	.7518742814281371
+];
+const d50ToD65 = [
+	.955473421488075,
+	-.02309845494876471,
+	.06325924320057072,
+	-.0283697093338637,
+	1.0099953980813041,
+	.021041441191917323,
+	.012314014864481998,
+	-.020507649298898964,
+	1.330365926242124
+];
+const xyzToLms = [
+	.819022437996703,
+	.3619062600528904,
+	-.1288737815209879,
+	.0329836539323885,
+	.9292868615863434,
+	.0361446663506424,
+	.0481771893596242,
+	.2642395317527308,
+	.6335478284694309
+];
+const lmsToOklab = [
+	.210454268309314,
+	.7936177747023054,
+	-.0040720430116193,
+	1.9779985324311684,
+	-2.42859224204858,
+	.450593709617411,
+	.0259040424655478,
+	.7827717124575296,
+	-.8086757549230774
+];
+const lmsToXyz = [
+	1.2268798758459243,
+	-.5578149944602171,
+	.2813910456659647,
+	-.0405757452148008,
+	1.112286803280317,
+	-.0717110580655164,
+	-.0763729366746601,
+	-.4214933324022432,
+	1.5869240198367816
+];
+const oklabToLms = [
+	1,
+	.3963377773761749,
+	.2158037573099136,
+	1,
+	-.1055613458156586,
+	-.0638541728258133,
+	1,
+	-.0894841775298119,
+	-1.2914855480194092
+];
+// src/color/math.ts
+/** `m` times the column vector (x, y, z). Takes numbers rather than a Vec3, so callers need no array. */
+function multiply(m, x, y, z) {
+	return [
+		m[0] * x + m[1] * y + m[2] * z,
+		m[3] * x + m[4] * y + m[5] * z,
+		m[6] * x + m[7] * y + m[8] * z
+	];
+}
+/** Keeps the sign, so out-of-gamut values survive the transfer function. */
+function signed(f) {
+	return (n) => n < 0 ? -f(-n) : f(n);
+}
+function normalizeHue(h) {
+	return (h % 360 + 360) % 360;
+}
+const D50 = [
+	.3457 / .3585,
+	1,
+	.2958 / .3585
+];
+/** The product of 3x3 matrices, left to right: `product(a, b)` applies `b` first. */
+function product(...ms) {
+	return ms.reduce((a, b) => {
+		const out = [];
+		for (let i = 0; i < 3; i++) for (let j = 0; j < 3; j++) out.push(a[i * 3] * b[j] + a[i * 3 + 1] * b[3 + j] + a[i * 3 + 2] * b[6 + j]);
+		return out;
+	});
+}
+// src/color/rgb.ts
+/** An RGB space: a transfer function, then a matrix to XYZ-D65. */
+function rgbSpace(id, toLinear, toGamma, toXyz, fromXyz) {
+	return {
+		id,
+		toXyz: (c) => multiply(toXyz, toLinear(c[0]), toLinear(c[1]), toLinear(c[2])),
+		fromXyz: (xyz) => {
+			const v = multiply(fromXyz, xyz[0], xyz[1], xyz[2]);
+			return [
+				toGamma(v[0]),
+				toGamma(v[1]),
+				toGamma(v[2])
+			];
+		}
+	};
+}
+// src/color/transfer.ts
+const identity = (n) => n;
+const srgbToLinear = signed((a) => a <= .04045 ? a / 12.92 : ((a + .055) / 1.055) ** 2.4);
+const srgbToGamma = signed((a) => a > .0031308 ? 1.055 * a ** (1 / 2.4) - .055 : 12.92 * a);
+const power = (gamma) => [signed((a) => a ** gamma), signed((a) => a ** (1 / gamma))];
+const prophotoToLinear = signed((a) => a <= 16 / 512 ? a / 16 : a ** 1.8);
+const prophotoToGamma = signed((a) => a >= 1 / 512 ? a ** (1 / 1.8) : 16 * a);
+// src/color/a98-rgb.ts
+const [toLinear$1, toGamma$1] = power(563 / 256);
+/**
+* The CSS `a98-rgb` space (Adobe RGB 1998). Components are red, green and blue in 0 to 1, with a 563/256 power transfer curve.
+* Pass it to `createConverter` and to the narrow helpers such as `createMix` and `createToGamut`.
+*/
+const a98Rgb = rgbSpace("a98-rgb", toLinear$1, toGamma$1, a98ToXyz, xyzToA98);
+// src/color/unknown-name.ts
+/**
+* The error for a name a caller wrote that the library does not know: it names
+* the value and lists the valid ones, in the style of `unknown color space`.
+*/
+function unknownName(what, value, valid) {
+	return /* @__PURE__ */ new Error(`color-map: unknown ${what} "${String(value)}"${valid.length ? `; use one of ${valid.join(", ")}` : ""}`);
+}
+/** `mode` itself when it is `light` or `dark`; any other value is an unknown mode. */
+function checkMode(mode) {
+	if (mode !== "light" && mode !== "dark") throw unknownName("mode", mode, ["light", "dark"]);
+	return mode;
+}
+// src/color/convert.ts
+/** Converts bare components between two spaces, through the XYZ-D65 hub. */
+function convertComponents(from, to, c) {
+	return from === to ? c : to.fromXyz(from.toXyz(c));
+}
+/** {@link ComponentsIn} over the spaces given. */
+function componentsOver(spaces) {
+	const byId = new Map(spaces.map((s) => [s.id, s]));
+	const find = (id) => {
+		const space = byId.get(id);
+		if (!space) throw unknownName("color space", id, [...byId.keys()]);
+		return space;
+	};
+	return (color, to) => {
+		if (color.colorSpace === to) return [...color.components];
+		const from = find(color.colorSpace);
+		const c = color.components;
+		return find(to).fromXyz(from.toXyz([
+			c[0] ?? 0,
+			c[1] ?? 0,
+			c[2] ?? 0
+		]));
+	};
+}
+/** `convert` over the spaces `componentsIn` knows: the color in `to`, keeping its alpha. */
+function convertWith(componentsIn, color, to) {
+	const result = {
+		colorSpace: to,
+		components: componentsIn(color, to)
+	};
+	if (color.alpha !== void 0) result.alpha = color.alpha;
+	return result;
+}
+/**
+* Builds `convert` over just the spaces given, so a bundle contains only those.
+* `none` components become 0 when the space changes.
+*/
+function createConverter(...spaces) {
+	const componentsIn = componentsOver(spaces);
+	return (color, to) => convertWith(componentsIn, color, to);
+}
+// src/color/oklab.ts
+/**
+* The CSS `oklab` space. Components are lightness in 0 to 1, then the a and b axes, which stay within about -0.4 to 0.4 for real colors.
+* Pass it to `createConverter` and to the narrow helpers such as `createMix` and `createToGamut`.
+*/
+const oklab = {
+	id: "oklab",
+	toXyz: (c) => {
+		const v = multiply(oklabToLms, c[0], c[1], c[2]);
+		return multiply(lmsToXyz, v[0] ** 3, v[1] ** 3, v[2] ** 3);
+	},
+	fromXyz: (xyz) => {
+		const v = multiply(xyzToLms, xyz[0], xyz[1], xyz[2]);
+		return multiply(lmsToOklab, Math.cbrt(v[0]), Math.cbrt(v[1]), Math.cbrt(v[2]));
+	}
+};
+// src/color/display-p3.ts
+/**
+* The CSS `display-p3` space. Components are red, green and blue in 0 to 1, with the sRGB transfer curve.
+* Pass it to `createConverter` and to the narrow helpers such as `createMix` and `createToGamut`.
+*/
+const displayP3 = rgbSpace("display-p3", srgbToLinear, srgbToGamma, p3ToXyz, xyzToP3);
+// src/color/display-p3-linear.ts
+/**
+* The CSS `display-p3-linear` space: Display P3 primaries without a transfer curve. Components are red, green and blue in 0 to 1.
+* Pass it to `createConverter` and to the narrow helpers such as `createMix` and `createToGamut`.
+*/
+const displayP3Linear = rgbSpace("display-p3-linear", identity, identity, p3ToXyz, xyzToP3);
+// src/color/srgb.ts
+/**
+* The CSS `srgb` space. Components are red, green and blue in 0 to 1, with the sRGB transfer curve.
+* Pass it to `createConverter` and to the narrow helpers such as `createMix` and `createToGamut`.
+*/
+const srgb = rgbSpace("srgb", srgbToLinear, srgbToGamma, srgbToXyz, xyzToSrgb);
+// src/color/hsl.ts
+function channel$1(t1, t2, sextant) {
+	const h = (sextant + 6) % 6;
+	if (h < 1) return (t2 - t1) * h + t1;
+	if (h < 3) return t2;
+	if (h < 4) return (t2 - t1) * (4 - h) + t1;
+	return t1;
+}
+/** CSS Color 4 hslToRgb. Hue in degrees, s and l in 0 to 1. */
+function hslToSrgb(h, s, l) {
+	const t2 = l <= .5 ? l * (s + 1) : l + s - l * s;
+	const t1 = l * 2 - t2;
+	const hue = normalizeHue(h) / 60;
+	return [
+		channel$1(t1, t2, hue + 2),
+		channel$1(t1, t2, hue),
+		channel$1(t1, t2, hue - 2)
+	];
+}
+/**
+* CSS Color 4 rgbToHsl. Returns hue in degrees, s and l in 0 to 1. For
+* out-of-gamut input the saturation can come out negative; it is made positive
+* and the hue turned by 180 degrees, unless `flipNegative` is false.
+*/
+function srgbToHsl([r, g, b], flipNegative = true) {
+	const max = Math.max(r, g, b);
+	const min = Math.min(r, g, b);
+	const l = (min + max) / 2;
+	const d = max - min;
+	let h = 0;
+	let s = 0;
+	if (d > 1e-9) {
+		s = l === 0 || l === 1 ? 0 : (max - l) / Math.min(l, 1 - l);
+		h = max === r ? (g - b) / d + (g < b ? 6 : 0) : max === g ? (b - r) / d + 2 : (r - g) / d + 4;
+		h *= 60;
+	}
+	if (s < 0) {
+		if (flipNegative) h += 180;
+		s = -s;
+	}
+	return [
+		normalizeHue(h),
+		s,
+		l
+	];
+}
+/**
+* The CSS `hsl` space. Components are hue in degrees, then saturation and lightness in 0 to 100.
+* Pass it to `createConverter` and to the narrow helpers such as `createMix` and `createToGamut`.
+*/
+const hsl = {
+	id: "hsl",
+	toXyz: ([h, s, l]) => srgb.toXyz(hslToSrgb(h, s / 100, l / 100)),
+	fromXyz: (xyz) => {
+		const [h, s, l] = srgbToHsl(srgb.fromXyz(xyz));
+		return [
+			h,
+			s * 100,
+			l * 100
+		];
+	}
+};
+// src/color/hwb.ts
+/**
+* The CSS `hwb` space. Components are hue in degrees, then whiteness and blackness in 0 to 100.
+* Pass it to `createConverter` and to the narrow helpers such as `createMix` and `createToGamut`.
+*/
+const hwb = {
+	id: "hwb",
+	toXyz: ([h, w, b]) => {
+		const white = w / 100;
+		const black = b / 100;
+		if (white + black >= 1) {
+			const gray = white / (white + black);
+			return srgb.toXyz([
+				gray,
+				gray,
+				gray
+			]);
+		}
+		const k = 1 - white - black;
+		const [red, green, blue] = hslToSrgb(h, 1, .5);
+		return srgb.toXyz([
+			red * k + white,
+			green * k + white,
+			blue * k + white
+		]);
+	},
+	fromXyz: (xyz) => {
+		const rgb = srgb.fromXyz(xyz);
+		return [
+			srgbToHsl(rgb, false)[0],
+			Math.min(...rgb) * 100,
+			(1 - Math.max(...rgb)) * 100
+		];
+	}
+};
+// src/color/lab.ts
+const EPSILON = 216 / 24389;
+const KAPPA = 24389 / 27;
+const finv = (f) => f ** 3 > EPSILON ? f ** 3 : (116 * f - 16) / KAPPA;
+const forward = (v) => v > EPSILON ? Math.cbrt(v) : (KAPPA * v + 16) / 116;
+/**
+* The CSS `lab` space (CIE Lab, D50 white). Components are lightness in 0 to 100, then the a and b axes, which are not bounded but stay near -125 to 125 for real colors.
+* Pass it to `createConverter` and to the narrow helpers such as `createMix` and `createToGamut`.
+*/
+const lab = {
+	id: "lab",
+	toXyz: ([l, a, b]) => {
+		const fy = (l + 16) / 116;
+		const y = l > KAPPA * EPSILON ? fy ** 3 : l / KAPPA;
+		const x = finv(fy + a / 500);
+		const z = finv(fy - b / 200);
+		return multiply(d50ToD65, x * D50[0], y * D50[1], z * D50[2]);
+	},
+	fromXyz: (xyz) => {
+		const [x, y, z] = multiply(d65ToD50, xyz[0], xyz[1], xyz[2]);
+		const fy = forward(y / D50[1]);
+		return [
+			116 * fy - 16,
+			500 * (forward(x / D50[0]) - fy),
+			200 * (fy - forward(z / D50[2]))
+		];
+	}
+};
+// src/color/polar.ts
+/** Wraps a rectangular Lab-like space as its polar (LCH-like) twin. */
+function polarSpace(id, base) {
+	return {
+		id,
+		toXyz: ([l, c, h]) => {
+			const r = h * Math.PI / 180;
+			return base.toXyz([
+				l,
+				c * Math.cos(r),
+				c * Math.sin(r)
+			]);
+		},
+		fromXyz: (xyz) => {
+			const [l, a, b] = base.fromXyz(xyz);
+			return [
+				l,
+				Math.hypot(a, b),
+				normalizeHue(Math.atan2(b, a) * 180 / Math.PI)
+			];
+		}
+	};
+}
+// src/color/lch.ts
+/**
+* The CSS `lch` space, the polar form of `lab`. Components are lightness in 0 to 100, chroma (not bounded, about 0 to 150) and hue in degrees.
+* Pass it to `createConverter` and to the narrow helpers such as `createMix` and `createToGamut`.
+*/
+const lch = polarSpace("lch", lab);
+// src/color/oklch.ts
+/**
+* The CSS `oklch` space, the polar form of `oklab`. Components are lightness in 0 to 1, chroma (about 0 to 0.4) and hue in degrees.
+* Pass it to `createConverter` and to the narrow helpers such as `createMix` and `createToGamut`.
+*/
+const oklch = polarSpace("oklch", oklab);
+// src/color/xyz-d50.ts
+/**
+* The CSS `xyz-d50` space (CIE XYZ, D50 white). Components are X, Y and Z, where Y is 1 for white.
+* Pass it to `createConverter` and to the narrow helpers such as `createMix` and `createToGamut`.
+*/
+const xyzD50 = {
+	id: "xyz-d50",
+	toXyz: (c) => multiply(d50ToD65, c[0], c[1], c[2]),
+	fromXyz: (xyz) => multiply(d65ToD50, xyz[0], xyz[1], xyz[2])
+};
+// src/color/prophoto-rgb.ts
+const d50 = rgbSpace("prophoto-rgb", prophotoToLinear, prophotoToGamma, prophotoToXyzD50, xyzD50ToProphoto);
+/**
+* The CSS `prophoto-rgb` space. Components are red, green and blue in 0 to 1. It is defined against a D50 white and converted through `xyzD50`.
+* Pass it to `createConverter` and to the narrow helpers such as `createMix` and `createToGamut`.
+*/
+const prophotoRgb = {
+	id: "prophoto-rgb",
+	toXyz: (c) => xyzD50.toXyz(d50.toXyz(c)),
+	fromXyz: (xyz) => d50.fromXyz(xyzD50.fromXyz(xyz))
+};
+// src/color/rec2020.ts
+const [toLinear, toGamma] = power(2.4);
+/**
+* The CSS `rec2020` space. Components are red, green and blue in 0 to 1, with a 2.4 power transfer curve.
+* Pass it to `createConverter` and to the narrow helpers such as `createMix` and `createToGamut`.
+*/
+const rec2020 = rgbSpace("rec2020", toLinear, toGamma, rec2020ToXyz, xyzToRec2020);
+// src/color/srgb-linear.ts
+/**
+* The CSS `srgb-linear` space: sRGB primaries without a transfer curve. Components are red, green and blue in 0 to 1.
+* Pass it to `createConverter` and to the narrow helpers such as `createMix` and `createToGamut`.
+*/
+const srgbLinear = rgbSpace("srgb-linear", identity, identity, srgbToXyz, xyzToSrgb);
+// src/color/xyz-d65.ts
+/** The hub every other space converts through. */
+const xyzD65 = {
+	id: "xyz-d65",
+	toXyz: (c) => c,
+	fromXyz: (xyz) => xyz
+};
+// src/color/spaces.ts
+/** Every space. Importing this pulls them all in; import single spaces to avoid that. */
+const spaces = {
+	srgb,
+	"srgb-linear": srgbLinear,
+	hsl,
+	hwb,
+	lab,
+	lch,
+	oklab,
+	oklch,
+	"display-p3": displayP3,
+	"display-p3-linear": displayP3Linear,
+	"a98-rgb": a98Rgb,
+	"prophoto-rgb": prophotoRgb,
+	rec2020,
+	"xyz-d50": xyzD50,
+	"xyz-d65": xyzD65
+};
+/** A color's components in any of the 15 spaces, as `convert` gives them, without the color object. */
+const componentsIn = componentsOver(Object.values(spaces));
+/** Converts a color to any of the 15 spaces. */
+const convert = createConverter(...Object.values(spaces));
+// src/color/compare.ts
+/** Euclidean distance in OKLab, the ΔEOK of CSS Color 4 gamut mapping. */
+function deltaEOk(a, b) {
+	return deltaEOkWith(componentsIn, a, b);
+}
+/** {@link deltaEOk} over the spaces `componentsIn` knows, which must include `oklab`. */
+function deltaEOkWith(componentsIn, a, b) {
+	const [l1, a1, b1] = componentsIn(a, "oklab");
+	const [l2, a2, b2] = componentsIn(b, "oklab");
+	return Math.hypot(l1 - l2, a1 - a2, b1 - b2);
+}
+/**
+* Builds {@link deltaEOk} over the spaces given, plus `oklab`, so a bundle
+* contains only those. A color in a space not given throws, naming that space.
+*/
+function createDeltaEOk(...spaces) {
+	const over = componentsOver([oklab, ...spaces]);
+	return (a, b) => deltaEOkWith(over, a, b);
+}
+const same = (x, y, epsilon) => x === y || x != null && y != null && Math.abs(x - y) <= epsilon;
+/**
+* True when both colors are the same within `epsilon` per component. Colors in
+* different spaces are compared in the first one's space. `none` equals only
+* `none`, and a missing alpha equals 1.
+*/
+function equals(a, b, epsilon = 1e-6) {
+	return equalsWith(componentsIn, a, b, epsilon);
+}
+function equalsWith(componentsIn, a, b, epsilon) {
+	const other = convertWith(componentsIn, b, a.colorSpace);
+	return same(a.alpha ?? 1, other.alpha ?? 1, epsilon) && a.components.every((c, i) => same(c, other.components[i], epsilon));
+}
+/**
+* Builds {@link equals} over the spaces given, so a bundle contains only those.
+* It needs no space of its own: give the spaces of both colors.
+*/
+function createEquals(...spaces) {
+	const over = componentsOver(spaces);
+	return (a, b, epsilon = 1e-6) => equalsWith(over, a, b, epsilon);
+}
+// src/color/gamut.ts
+const within = (components, epsilon) => components.every((c) => c >= -epsilon && c <= 1 + epsilon);
+/** True when every channel of `color`, seen in `gamut`, is within 0 to 1 (± `epsilon`). */
+function inGamut(color, gamut = "srgb", epsilon = 1e-6) {
+	return within(componentsIn(color, gamut), epsilon);
+}
+/**
+* Builds {@link inGamut} over the spaces given, plus `srgb`, so a bundle
+* contains only those. Give the gamut too when it is not `srgb`. A color or
+* gamut in a space not given throws, naming that space.
+*/
+function createInGamut(...spaces) {
+	const over = componentsOver([srgb, ...spaces]);
+	return (color, gamut = "srgb", epsilon = 1e-6) => within(over(color, gamut), epsilon);
+}
+/** `color` with `components`, which are in `gamut`, clamped to 0 to 1: what `convert` then a clamp gives. */
+function clipped(color, gamut, components) {
+	return withAlpha({
+		colorSpace: gamut,
+		components: components.map((c) => Math.min(1, Math.max(0, c)))
+	}, color);
+}
+/**
+* Maps a color into a gamut and returns it in its original space. `css` follows
+* CSS Color 4 section 13.2: reduce OKLCH chroma until the clipped color is
+* within a just-noticeable ΔEOK of 0.02.
+*/
+function toGamut(color, options = {}) {
+	return toGamutWith(componentsIn, color, options);
+}
+/**
+* Builds {@link toGamut} over the spaces given, plus `srgb`, `oklch` and
+* `oklab`, which the CSS method works in. Give the gamut too when it is not
+* `srgb`. A color or gamut in a space not given throws, naming that space.
+*/
+function createToGamut(...spaces) {
+	const over = componentsOver([
+		srgb,
+		oklch,
+		oklab,
+		...spaces
+	]);
+	return (color, options = {}) => toGamutWith(over, color, options);
+}
+/** {@link toGamut} over the spaces `componentsIn` knows, which must include `oklch` and `oklab`. */
+function toGamutWith(componentsIn, color, options) {
+	const { gamut = "srgb", method = "css" } = options;
+	const deltaEOk = (a, b) => deltaEOkWith(componentsIn, a, b);
+	const back = (c) => convertWith(componentsIn, c, color.colorSpace);
+	const fit = componentsIn(color, gamut);
+	if (within(fit, 1e-6)) return color;
+	if (method === "clip") return back(clipped(color, gamut, fit));
+	const origin = convertWith(componentsIn, color, "oklch");
+	const [lightness, chroma, hue] = origin.components;
+	if (lightness >= 1) return back(withAlpha({
+		colorSpace: gamut,
+		components: [
+			1,
+			1,
+			1
+		]
+	}, color));
+	if (lightness <= 0) return back(withAlpha({
+		colorSpace: gamut,
+		components: [
+			0,
+			0,
+			0
+		]
+	}, color));
+	const JND = .02;
+	const EPSILON = 1e-4;
+	if (gamut === "srgb") return back(reduceChromaInSrgb(origin, lightness, chroma, hue));
+	let min = 0;
+	let max = chroma;
+	let minInGamut = true;
+	let clip = clipped(origin, gamut, componentsIn(origin, gamut));
+	if (deltaEOk(clip, origin) < JND) return back(clip);
+	while (max - min > EPSILON) {
+		const mid = (min + max) / 2;
+		const current = withAlpha({
+			colorSpace: "oklch",
+			components: [
+				lightness,
+				mid,
+				hue
+			]
+		}, origin);
+		const inGamutSpace = componentsIn(current, gamut);
+		if (minInGamut && within(inGamutSpace, 1e-6)) {
+			min = mid;
+			continue;
+		}
+		clip = clipped(current, gamut, inGamutSpace);
+		const e = deltaEOk(clip, current);
+		if (e < JND) {
+			if (JND - e < EPSILON) return back(clip);
+			minInGamut = false;
+			min = mid;
+		} else max = mid;
+	}
+	/* v8 ignore next */
+	return back(clip);
+}
+function withAlpha(c, source) {
+	if (source.alpha !== void 0) c.alpha = source.alpha;
+	return c;
+}
+let lmsToLinear;
+let linearToLms;
+const LOW = -1e-6 / 12.92;
+const HIGH = ((1 + 1e-6 + .055) / 1.055) ** 2.4;
+const encode = (n) => n === 0 || n === 1 ? n : srgbToGamma(n);
+const clamp01 = (n) => Math.min(1, Math.max(0, n));
+/**
+* The CSS Color 4 section 13.2 search of `toGamut` for the `srgb` gamut, done in
+* linear sRGB so the loop has no hub conversion, `**` or trigonometry. Clipping
+* to 0 to 1 commutes with the monotone transfer curve, so it finds what the
+* generic path finds, up to rounding. Returns the mapped color in `srgb`.
+*/
+function reduceChromaInSrgb(origin, lightness, chroma, hue) {
+	const m = lmsToLinear ??= product(xyzToSrgb, lmsToXyz);
+	const n = linearToLms ??= product(xyzToLms, srgbToXyz);
+	const o = oklabToLms;
+	const k = lmsToOklab;
+	const l = lightness;
+	const radians = (hue ?? 0) * Math.PI / 180;
+	const cos = Math.cos(radians);
+	const sin = Math.sin(radians);
+	let r = 0;
+	let g = 0;
+	let b = 0;
+	let inside = false;
+	/** Puts the candidate of chroma `c` in linear sRGB into r, g, b (unclipped), and says if it is within the gamut. */
+	const place = (c) => {
+		const a = c * cos;
+		const bb = c * sin;
+		const x = l + o[1] * a + o[2] * bb;
+		const y = l + o[4] * a + o[5] * bb;
+		const z = l + o[7] * a + o[8] * bb;
+		const x3 = x * x * x;
+		const y3 = y * y * y;
+		const z3 = z * z * z;
+		r = m[0] * x3 + m[1] * y3 + m[2] * z3;
+		g = m[3] * x3 + m[4] * y3 + m[5] * z3;
+		b = m[6] * x3 + m[7] * y3 + m[8] * z3;
+		inside = r >= LOW && r <= HIGH && g >= LOW && g <= HIGH && b >= LOW && b <= HIGH;
+	};
+	/** Clips r, g, b and returns its ΔEOK to the candidate of chroma `c`. */
+	const clipAndMeasure = (c) => {
+		r = clamp01(r);
+		g = clamp01(g);
+		b = clamp01(b);
+		const x = Math.cbrt(n[0] * r + n[1] * g + n[2] * b);
+		const y = Math.cbrt(n[3] * r + n[4] * g + n[5] * b);
+		const z = Math.cbrt(n[6] * r + n[7] * g + n[8] * b);
+		const dl = k[0] * x + k[1] * y + k[2] * z - l;
+		const da = k[3] * x + k[4] * y + k[5] * z - c * cos;
+		const db = k[6] * x + k[7] * y + k[8] * z - c * sin;
+		return Math.sqrt(dl * dl + da * da + db * db);
+	};
+	const JND = .02;
+	const EPSILON = 1e-4;
+	let min = 0;
+	let max = chroma;
+	let minInGamut = true;
+	place(chroma ?? 0);
+	let clip;
+	let e = clipAndMeasure(chroma ?? 0);
+	clip = [
+		r,
+		g,
+		b
+	];
+	if (e >= JND) while (max - min > EPSILON) {
+		const mid = (min + max) / 2;
+		place(mid);
+		if (minInGamut && inside) {
+			min = mid;
+			continue;
+		}
+		e = clipAndMeasure(mid);
+		clip = [
+			r,
+			g,
+			b
+		];
+		if (e < JND) {
+			if (JND - e < EPSILON) break;
+			minInGamut = false;
+			min = mid;
+		} else max = mid;
+	}
+	return withAlpha({
+		colorSpace: "srgb",
+		components: clip.map(encode)
+	}, origin);
+}
+// src/color/named.ts
+const DATA = "aliceblue:f0f8ff,antiquewhite:faebd7,aqua:00ffff,aquamarine:7fffd4,azure:f0ffff,beige:f5f5dc,bisque:ffe4c4,black:000000,blanchedalmond:ffebcd,blue:0000ff,blueviolet:8a2be2,brown:a52a2a,burlywood:deb887,cadetblue:5f9ea0,chartreuse:7fff00,chocolate:d2691e,coral:ff7f50,cornflowerblue:6495ed,cornsilk:fff8dc,crimson:dc143c,cyan:00ffff,darkblue:00008b,darkcyan:008b8b,darkgoldenrod:b8860b,darkgray:a9a9a9,darkgreen:006400,darkgrey:a9a9a9,darkkhaki:bdb76b,darkmagenta:8b008b,darkolivegreen:556b2f,darkorange:ff8c00,darkorchid:9932cc,darkred:8b0000,darksalmon:e9967a,darkseagreen:8fbc8f,darkslateblue:483d8b,darkslategray:2f4f4f,darkslategrey:2f4f4f,darkturquoise:00ced1,darkviolet:9400d3,deeppink:ff1493,deepskyblue:00bfff,dimgray:696969,dimgrey:696969,dodgerblue:1e90ff,firebrick:b22222,floralwhite:fffaf0,forestgreen:228b22,fuchsia:ff00ff,gainsboro:dcdcdc,ghostwhite:f8f8ff,gold:ffd700,goldenrod:daa520,gray:808080,green:008000,greenyellow:adff2f,grey:808080,honeydew:f0fff0,hotpink:ff69b4,indianred:cd5c5c,indigo:4b0082,ivory:fffff0,khaki:f0e68c,lavender:e6e6fa,lavenderblush:fff0f5,lawngreen:7cfc00,lemonchiffon:fffacd,lightblue:add8e6,lightcoral:f08080,lightcyan:e0ffff,lightgoldenrodyellow:fafad2,lightgray:d3d3d3,lightgreen:90ee90,lightgrey:d3d3d3,lightpink:ffb6c1,lightsalmon:ffa07a,lightseagreen:20b2aa,lightskyblue:87cefa,lightslategray:778899,lightslategrey:778899,lightsteelblue:b0c4de,lightyellow:ffffe0,lime:00ff00,limegreen:32cd32,linen:faf0e6,magenta:ff00ff,maroon:800000,mediumaquamarine:66cdaa,mediumblue:0000cd,mediumorchid:ba55d3,mediumpurple:9370db,mediumseagreen:3cb371,mediumslateblue:7b68ee,mediumspringgreen:00fa9a,mediumturquoise:48d1cc,mediumvioletred:c71585,midnightblue:191970,mintcream:f5fffa,mistyrose:ffe4e1,moccasin:ffe4b5,navajowhite:ffdead,navy:000080,oldlace:fdf5e6,olive:808000,olivedrab:6b8e23,orange:ffa500,orangered:ff4500,orchid:da70d6,palegoldenrod:eee8aa,palegreen:98fb98,paleturquoise:afeeee,palevioletred:db7093,papayawhip:ffefd5,peachpuff:ffdab9,peru:cd853f,pink:ffc0cb,plum:dda0dd,powderblue:b0e0e6,purple:800080,rebeccapurple:663399,red:ff0000,rosybrown:bc8f8f,royalblue:4169e1,saddlebrown:8b4513,salmon:fa8072,sandybrown:f4a460,seagreen:2e8b57,seashell:fff5ee,sienna:a0522d,silver:c0c0c0,skyblue:87ceeb,slateblue:6a5acd,slategray:708090,slategrey:708090,snow:fffafa,springgreen:00ff7f,steelblue:4682b4,tan:d2b48c,teal:008080,thistle:d8bfd8,tomato:ff6347,turquoise:40e0d0,violet:ee82ee,wheat:f5deb3,white:ffffff,whitesmoke:f5f5f5,yellow:ffff00,yellowgreen:9acd32";
+let table;
+/** The 0xRRGGBB value of a CSS named color, or undefined. Built on first use. */
+function namedColor(name) {
+	table ??= new Map(DATA.split(",").map((p) => [p.slice(0, p.indexOf(":")), Number.parseInt(p.slice(p.indexOf(":") + 1), 16)]));
+	return table.get(name);
+}
+// src/color/parse.ts
+const NUMBER = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:e[+-]?\d+)?/;
+const UNITS = {
+	__proto__: null,
+	"": 1,
+	deg: 1,
+	grad: .9,
+	rad: 180 / Math.PI,
+	turn: 360
+};
+function fail(input, what, token) {
+	throw new Error(`color-map: cannot parse "${input}": ${what}${token === void 0 ? "" : ` "${token}"`}`);
+}
+function channel(token, spec, input) {
+	if (token === "none") return null;
+	const m = NUMBER.exec(token);
+	if (!m) return fail(input, "invalid value", token);
+	const n = Number(m[0]);
+	const rest = token.slice(m[0].length);
+	let value;
+	if (spec.hue) {
+		const unit = UNITS[rest];
+		if (unit === void 0) return fail(input, "invalid angle", token);
+		return n * unit;
+	}
+	if (rest === "%") value = n * spec.pct / 100;
+	else if (rest === "") value = n / (spec.div ?? 1);
+	else return fail(input, "invalid value", token);
+	return Math.min(spec.max ?? Number.POSITIVE_INFINITY, Math.max(spec.min ?? Number.NEGATIVE_INFINITY, value));
+}
+const SRGB = {
+	pct: 1,
+	div: 255
+};
+const PCT100 = {
+	pct: 100,
+	min: 0
+};
+const UNIT = { pct: 1 };
+const ALPHA = {
+	pct: 1,
+	min: 0,
+	max: 1
+};
+const HUE = {
+	pct: 0,
+	hue: true
+};
+const FUNCTIONS = {
+	__proto__: null,
+	rgb: {
+		space: "srgb",
+		channels: [
+			SRGB,
+			SRGB,
+			SRGB
+		]
+	},
+	hsl: {
+		space: "hsl",
+		channels: [
+			HUE,
+			PCT100,
+			PCT100
+		]
+	},
+	hwb: {
+		space: "hwb",
+		channels: [
+			HUE,
+			PCT100,
+			PCT100
+		]
+	},
+	lab: {
+		space: "lab",
+		channels: [
+			{
+				pct: 100,
+				min: 0,
+				max: 100
+			},
+			{ pct: 125 },
+			{ pct: 125 }
+		]
+	},
+	lch: {
+		space: "lch",
+		channels: [
+			{
+				pct: 100,
+				min: 0,
+				max: 100
+			},
+			{
+				pct: 150,
+				min: 0
+			},
+			HUE
+		]
+	},
+	oklab: {
+		space: "oklab",
+		channels: [
+			{
+				pct: 1,
+				min: 0,
+				max: 1
+			},
+			{ pct: .4 },
+			{ pct: .4 }
+		]
+	},
+	oklch: {
+		space: "oklch",
+		channels: [
+			{
+				pct: 1,
+				min: 0,
+				max: 1
+			},
+			{
+				pct: .4,
+				min: 0
+			},
+			HUE
+		]
+	}
+};
+/** The spaces `color()` names, by the name it uses: their own, and `xyz` for `xyz-d65`. */
+const COLOR_SPACES = {
+	__proto__: null,
+	xyz: "xyz-d65"
+};
+for (const id of [
+	"srgb",
+	"srgb-linear",
+	"display-p3",
+	"display-p3-linear",
+	"a98-rgb",
+	"prophoto-rgb",
+	"rec2020",
+	"xyz-d50",
+	"xyz-d65"
+]) COLOR_SPACES[id] = id;
+/** `currentcolor` and the CSS Color 4 system colors (canvas, canvastext, linktext, buttonface, ...). */
+const VALUES_NEEDING_RESOLVE = /^(?:currentcolor|(?:canvas|field|highlight|selecteditem|mark|accentcolor)(?:text)?|(?:link|visited|active|button|gray)text|button(?:face|border))$/;
+function hex(input) {
+	const digits = input.slice(1);
+	if (!/^(?:[\da-f]{3,4}|[\da-f]{6}|[\da-f]{8})$/.test(digits)) return fail(input, "invalid hex color");
+	const full = digits.length < 5 ? [...digits].map((d) => d + d).join("") : digits;
+	const byte = (i) => Number.parseInt(full.slice(i * 2, i * 2 + 2), 16) / 255;
+	const color = {
+		colorSpace: "srgb",
+		components: [
+			byte(0),
+			byte(1),
+			byte(2)
+		]
+	};
+	if (full.length === 8) color.alpha = byte(3);
+	return color;
+}
+const ALIASES = {
+	__proto__: null,
+	rgba: "rgb",
+	hsla: "hsl"
+};
+function functional(rawName, body, input) {
+	const name = ALIASES[rawName] ?? rawName;
+	const [main, alphaToken, ...extra] = body.split("/").map((s) => s.trim());
+	if (extra.length > 0) return fail(input, "more than one \"/\"");
+	const legacy = main.includes(",");
+	const tokens = (legacy ? main.split(",") : main.split(/\s+/)).map((s) => s.trim()).filter(Boolean);
+	let alpha = alphaToken;
+	if (legacy) {
+		if (name !== "rgb" && name !== "hsl") return fail(input, "the comma syntax is only for rgb() and hsl()");
+		if (alpha !== void 0) return fail(input, "cannot mix \",\" and \"/\"");
+		if (tokens.length === 4) alpha = tokens.pop();
+		if (tokens.includes("none")) return fail(input, "\"none\" is not allowed in the comma syntax");
+	}
+	let space;
+	let channels;
+	if (name === "color") {
+		const id = COLOR_SPACES[tokens.shift() ?? ""];
+		if (!id) return fail(input, "unknown color space", main.split(/\s+/)[0]);
+		space = id;
+		channels = [
+			UNIT,
+			UNIT,
+			UNIT
+		];
+	} else {
+		const fn = FUNCTIONS[name];
+		if (!fn) return fail(input, "unknown function", rawName);
+		({space, channels} = fn);
+	}
+	if (tokens.length !== 3) return fail(input, `expected 3 components, got ${tokens.length}`);
+	if (legacy) {
+		const percents = tokens.map((t) => t.endsWith("%"));
+		if (!(space === "hsl" ? !percents[0] && percents[1] && percents[2] : percents.every((p) => p === percents[0]))) return fail(input, "mixed numbers and percentages", tokens.join(", "));
+	}
+	const color = {
+		colorSpace: space,
+		components: tokens.map((t, i) => channel(t, channels[i], input))
+	};
+	if (alpha !== void 0) color.alpha = channel(alpha, ALPHA, input);
+	return color;
+}
+/**
+* Parses a CSS Color 4 color: hex, named colors, `transparent`, `rgb()`,
+* `hsl()`, `hwb()`, `lab()`, `lch()`, `oklab()`, `oklch()` and `color()`.
+* `none` becomes `null`. Values that need a context (`currentcolor`, system
+* colors) throw, because nothing here can resolve them.
+*/
+function parse(input) {
+	const text = input.trim().toLowerCase();
+	return scan(text) ?? parseGeneric(input, text);
+}
+/**
+* The regex-based parser: every accepted form, and every error message. `parse`
+* tries {@link scan} first, which takes only the plain valid forms and leaves
+* the rest, including every error, to this.
+*/
+function parseGeneric(input, text) {
+	if (text.startsWith("#")) return hex(text);
+	const fn = /^([a-z]+)\((.*)\)$/s.exec(text);
+	if (fn) return functional(fn[1], fn[2], input);
+	if (text === "transparent") return {
+		colorSpace: "srgb",
+		components: [
+			0,
+			0,
+			0
+		],
+		alpha: 0
+	};
+	const named = namedColor(text);
+	if (named !== void 0) return {
+		colorSpace: "srgb",
+		components: [
+			(named >> 16) / 255,
+			(named >> 8 & 255) / 255,
+			(named & 255) / 255
+		]
+	};
+	if (VALUES_NEEDING_RESOLVE.test(text)) return fail(input, "needs a context to resolve", text);
+	return fail(input, "not a color");
+}
+/** A color as given, or parsed with {@link parse} when it is a string. */
+const toColor = (c) => typeof c === "string" ? parse(c) : c;
+const isSpace = (c) => c === 32 || c === 9 || c === 10 || c === 13 || c === 12;
+const isDigit = (c) => c >= 48 && c <= 57;
+const hexValue = (c) => c >= 48 && c <= 57 ? c - 48 : c >= 97 && c <= 102 ? c - 87 : -1;
+let at = 0;
+let percent = false;
+function scanHex(text) {
+	const len = text.length;
+	if (len !== 4 && len !== 5 && len !== 7 && len !== 9) return void 0;
+	const short = len < 6;
+	const count = short ? len - 1 : (len - 1) / 2;
+	const bytes = [];
+	for (let i = 0; i < count; i++) {
+		let value;
+		if (short) {
+			const d = hexValue(text.charCodeAt(1 + i));
+			value = d * 17;
+			if (d < 0) return void 0;
+		} else {
+			const hi = hexValue(text.charCodeAt(1 + i * 2));
+			const lo = hexValue(text.charCodeAt(2 + i * 2));
+			if (hi < 0 || lo < 0) return void 0;
+			value = hi * 16 + lo;
+		}
+		bytes.push(value / 255);
+	}
+	const color = {
+		colorSpace: "srgb",
+		components: [
+			bytes[0],
+			bytes[1],
+			bytes[2]
+		]
+	};
+	if (count === 4) color.alpha = bytes[3];
+	return color;
+}
+/** Skips whitespace from `at` up to `end`. */
+function skip(text, end) {
+	while (at < end && isSpace(text.charCodeAt(at))) at++;
+}
+/** The end of the token that starts at `at`: it runs to whitespace, a comma, a slash or `end`. */
+function tokenEnd(text, end) {
+	let j = at;
+	while (j < end) {
+		const c = text.charCodeAt(j);
+		if (isSpace(c) || c === 44 || c === 47) break;
+		j++;
+	}
+	return j;
+}
+/**
+* Reads the token at `at` as {@link channel} would, or returns `undefined` when
+* it is anything but a plain valid one. Leaves `at` after the token.
+*/
+function scanChannel(text, end, spec) {
+	const s = at;
+	const e = tokenEnd(text, end);
+	at = e;
+	if (e === s) return void 0;
+	if (e - s === 4 && text.startsWith("none", s)) return null;
+	let j = s;
+	let c = text.charCodeAt(j);
+	if (c === 43 || c === 45) c = text.charCodeAt(++j);
+	let digits = 0;
+	while (isDigit(c)) {
+		c = text.charCodeAt(++j);
+		digits++;
+	}
+	if (c === 46) {
+		c = text.charCodeAt(++j);
+		while (isDigit(c)) {
+			c = text.charCodeAt(++j);
+			digits++;
+		}
+	}
+	if (digits === 0) return void 0;
+	if (c === 101) {
+		let k = j + 1;
+		let x = text.charCodeAt(k);
+		if (x === 43 || x === 45) x = text.charCodeAt(++k);
+		if (isDigit(x)) {
+			while (isDigit(text.charCodeAt(k))) k++;
+			j = k;
+		}
+	}
+	const n = Number(text.slice(s, j));
+	if (spec.hue) {
+		const unit = j === e ? 1 : UNITS[text.slice(j, e)];
+		return unit === void 0 ? void 0 : n * unit;
+	}
+	let value;
+	if (j === e) value = n / (spec.div ?? 1);
+	else if (e - j === 1 && text.charCodeAt(j) === 37) {
+		percent = true;
+		value = n * spec.pct / 100;
+	} else return void 0;
+	return Math.min(spec.max ?? Number.POSITIVE_INFINITY, Math.max(spec.min ?? Number.NEGATIVE_INFINITY, value));
+}
+/**
+* Parses the plain valid forms (hex, and the comma or space forms of the
+* functions) by char code, with no regex, split or per-token array. Anything
+* else returns `undefined`, so that {@link parseGeneric} handles it and says
+* why it is wrong.
+*/
+function scan(text) {
+	if (text.charCodeAt(0) === 35) return scanHex(text);
+	const end = text.length - 1;
+	if (text.charCodeAt(end) !== 41) return void 0;
+	let open = 0;
+	while (open < end) {
+		const c = text.charCodeAt(open);
+		if (c < 97 || c > 122) break;
+		open++;
+	}
+	if (open === 0 || text.charCodeAt(open) !== 40) return void 0;
+	const rawName = text.slice(0, open);
+	const name = ALIASES[rawName] ?? rawName;
+	let space;
+	let channels;
+	at = open + 1;
+	skip(text, end);
+	if (name === "color") {
+		const s = at;
+		while (at < end && !isSpace(text.charCodeAt(at))) at++;
+		const id = COLOR_SPACES[text.slice(s, at)];
+		if (!id) return void 0;
+		space = id;
+		channels = [
+			UNIT,
+			UNIT,
+			UNIT
+		];
+		skip(text, end);
+	} else {
+		const fn = FUNCTIONS[name];
+		if (!fn) return void 0;
+		({space, channels} = fn);
+	}
+	percent = false;
+	const c0 = scanChannel(text, end, channels[0]);
+	if (c0 === void 0) return void 0;
+	const p0 = percent;
+	skip(text, end);
+	const comma = text.charCodeAt(at) === 44;
+	if (comma && name !== "rgb" && name !== "hsl") return void 0;
+	let alpha;
+	let c1;
+	let c2;
+	let p1 = false;
+	let p2 = false;
+	if (comma) {
+		at++;
+		skip(text, end);
+		percent = false;
+		c1 = scanChannel(text, end, channels[1]);
+		p1 = percent;
+		skip(text, end);
+		if (text.charCodeAt(at++) !== 44) return void 0;
+		skip(text, end);
+		percent = false;
+		c2 = scanChannel(text, end, channels[2]);
+		p2 = percent;
+		skip(text, end);
+		if (c0 === null || c1 === void 0 || c1 === null || c2 === void 0 || c2 === null) return void 0;
+		if (!(space === "hsl" ? !p0 && p1 && p2 : p0 === p1 && p1 === p2)) return void 0;
+		if (at < end) {
+			if (text.charCodeAt(at++) !== 44) return void 0;
+			skip(text, end);
+			alpha = scanChannel(text, end, ALPHA);
+			if (alpha === void 0 || alpha === null) return void 0;
+			skip(text, end);
+		}
+	} else {
+		c1 = scanChannel(text, end, channels[1]);
+		skip(text, end);
+		c2 = scanChannel(text, end, channels[2]);
+		skip(text, end);
+		if (at < end) {
+			if (text.charCodeAt(at++) !== 47) return void 0;
+			skip(text, end);
+			alpha = scanChannel(text, end, ALPHA);
+			if (alpha === void 0) return void 0;
+			skip(text, end);
+		}
+	}
+	if (at !== end || c1 === void 0 || c2 === void 0) return void 0;
+	const color = {
+		colorSpace: space,
+		components: [
+			c0,
+			c1,
+			c2
+		]
+	};
+	if (alpha !== void 0) color.alpha = alpha;
+	return color;
+}
+Object.defineProperty(exports, "ALPHA", {
+	enumerable: true,
+	get: function() {
+		return ALPHA;
+	}
+});
+Object.defineProperty(exports, "COLOR_SPACES", {
+	enumerable: true,
+	get: function() {
+		return COLOR_SPACES;
+	}
+});
+Object.defineProperty(exports, "FUNCTIONS", {
+	enumerable: true,
+	get: function() {
+		return FUNCTIONS;
+	}
+});
+Object.defineProperty(exports, "UNIT", {
+	enumerable: true,
+	get: function() {
+		return UNIT;
+	}
+});
+Object.defineProperty(exports, "UNITS", {
+	enumerable: true,
+	get: function() {
+		return UNITS;
+	}
+});
+Object.defineProperty(exports, "VALUES_NEEDING_RESOLVE", {
+	enumerable: true,
+	get: function() {
+		return VALUES_NEEDING_RESOLVE;
+	}
+});
+Object.defineProperty(exports, "a98Rgb", {
+	enumerable: true,
+	get: function() {
+		return a98Rgb;
+	}
+});
+Object.defineProperty(exports, "channel", {
+	enumerable: true,
+	get: function() {
+		return channel;
+	}
+});
+Object.defineProperty(exports, "checkMode", {
+	enumerable: true,
+	get: function() {
+		return checkMode;
+	}
+});
+Object.defineProperty(exports, "componentsIn", {
+	enumerable: true,
+	get: function() {
+		return componentsIn;
+	}
+});
+Object.defineProperty(exports, "componentsOver", {
+	enumerable: true,
+	get: function() {
+		return componentsOver;
+	}
+});
+Object.defineProperty(exports, "convert", {
+	enumerable: true,
+	get: function() {
+		return convert;
+	}
+});
+Object.defineProperty(exports, "convertComponents", {
+	enumerable: true,
+	get: function() {
+		return convertComponents;
+	}
+});
+Object.defineProperty(exports, "convertWith", {
+	enumerable: true,
+	get: function() {
+		return convertWith;
+	}
+});
+Object.defineProperty(exports, "createConverter", {
+	enumerable: true,
+	get: function() {
+		return createConverter;
+	}
+});
+Object.defineProperty(exports, "createDeltaEOk", {
+	enumerable: true,
+	get: function() {
+		return createDeltaEOk;
+	}
+});
+Object.defineProperty(exports, "createEquals", {
+	enumerable: true,
+	get: function() {
+		return createEquals;
+	}
+});
+Object.defineProperty(exports, "createInGamut", {
+	enumerable: true,
+	get: function() {
+		return createInGamut;
+	}
+});
+Object.defineProperty(exports, "createToGamut", {
+	enumerable: true,
+	get: function() {
+		return createToGamut;
+	}
+});
+Object.defineProperty(exports, "deltaEOk", {
+	enumerable: true,
+	get: function() {
+		return deltaEOk;
+	}
+});
+Object.defineProperty(exports, "displayP3", {
+	enumerable: true,
+	get: function() {
+		return displayP3;
+	}
+});
+Object.defineProperty(exports, "displayP3Linear", {
+	enumerable: true,
+	get: function() {
+		return displayP3Linear;
+	}
+});
+Object.defineProperty(exports, "equals", {
+	enumerable: true,
+	get: function() {
+		return equals;
+	}
+});
+Object.defineProperty(exports, "fail", {
+	enumerable: true,
+	get: function() {
+		return fail;
+	}
+});
+Object.defineProperty(exports, "hsl", {
+	enumerable: true,
+	get: function() {
+		return hsl;
+	}
+});
+Object.defineProperty(exports, "hwb", {
+	enumerable: true,
+	get: function() {
+		return hwb;
+	}
+});
+Object.defineProperty(exports, "inGamut", {
+	enumerable: true,
+	get: function() {
+		return inGamut;
+	}
+});
+Object.defineProperty(exports, "lab", {
+	enumerable: true,
+	get: function() {
+		return lab;
+	}
+});
+Object.defineProperty(exports, "lch", {
+	enumerable: true,
+	get: function() {
+		return lch;
+	}
+});
+Object.defineProperty(exports, "normalizeHue", {
+	enumerable: true,
+	get: function() {
+		return normalizeHue;
+	}
+});
+Object.defineProperty(exports, "oklab", {
+	enumerable: true,
+	get: function() {
+		return oklab;
+	}
+});
+Object.defineProperty(exports, "oklch", {
+	enumerable: true,
+	get: function() {
+		return oklch;
+	}
+});
+Object.defineProperty(exports, "parse", {
+	enumerable: true,
+	get: function() {
+		return parse;
+	}
+});
+Object.defineProperty(exports, "prophotoRgb", {
+	enumerable: true,
+	get: function() {
+		return prophotoRgb;
+	}
+});
+Object.defineProperty(exports, "rec2020", {
+	enumerable: true,
+	get: function() {
+		return rec2020;
+	}
+});
+Object.defineProperty(exports, "spaces", {
+	enumerable: true,
+	get: function() {
+		return spaces;
+	}
+});
+Object.defineProperty(exports, "srgb", {
+	enumerable: true,
+	get: function() {
+		return srgb;
+	}
+});
+Object.defineProperty(exports, "srgbLinear", {
+	enumerable: true,
+	get: function() {
+		return srgbLinear;
+	}
+});
+Object.defineProperty(exports, "toColor", {
+	enumerable: true,
+	get: function() {
+		return toColor;
+	}
+});
+Object.defineProperty(exports, "toGamut", {
+	enumerable: true,
+	get: function() {
+		return toGamut;
+	}
+});
+Object.defineProperty(exports, "toGamutWith", {
+	enumerable: true,
+	get: function() {
+		return toGamutWith;
+	}
+});
+Object.defineProperty(exports, "unknownName", {
+	enumerable: true,
+	get: function() {
+		return unknownName;
+	}
+});
+Object.defineProperty(exports, "xyzD50", {
+	enumerable: true,
+	get: function() {
+		return xyzD50;
+	}
+});
+Object.defineProperty(exports, "xyzD65", {
+	enumerable: true,
+	get: function() {
+		return xyzD65;
+	}
+});
+
+//# sourceMappingURL=parse-8mt2OMKf.js.map