color-map 2.2.0 → 2.3.1

package/cjs/contrast-XjF5Rwui.js

@@ -0,0 +1,293 @@
+const require_parse = require("./parse-8mt2OMKf.js");
+// src/color/contrast.ts
+/** Relative luminance (WCAG 2): the Y of the color in XYZ-D65, with white at 1. */
+function luminance(componentsIn, color) {
+	return Math.max(0, componentsIn(color, "xyz-d65")[1]);
+}
+/** Lays a translucent color over `bg`, in `srgb`, the way a browser paints it. */
+function flatten(componentsIn, fg, bg) {
+	const alpha = fg.alpha === null ? 0 : fg.alpha ?? 1;
+	if (alpha >= 1) return fg;
+	const f = componentsIn(fg, "srgb");
+	const b = componentsIn(bg, "srgb");
+	return {
+		colorSpace: "srgb",
+		components: f.map((x, i) => x * alpha + b[i] * (1 - alpha))
+	};
+}
+/**
+* WCAG 2 contrast ratio, 1 to 21. A translucent `fg` is laid over `bg` first;
+* `bg` is taken as opaque.
+*/
+const wcag2 = /* @__PURE__ */ wcag2Over(require_parse.componentsIn);
+/** WCAG 2 over the spaces `componentsIn` knows, which must include `srgb` and `xyz-d65`. */
+function wcag2Over(componentsIn) {
+	return Object.assign((fg, bg) => {
+		const a = luminance(componentsIn, flatten(componentsIn, fg, bg)) + .05;
+		const b = luminance(componentsIn, bg) + .05;
+		return a > b ? a / b : b / a;
+	}, {
+		algorithm: "wcag2",
+		thresholds: {
+			AA: 4.5,
+			"AA-large": 3,
+			AAA: 7,
+			"AAA-large": 4.5,
+			"non-text": 3
+		},
+		polarity: "symmetric"
+	});
+}
+/** The measure `algo` names: `wcag2` or a function; anything else is an unknown name. */
+function pick(algo) {
+	return pickFrom(wcag2, algo);
+}
+/** {@link pick}, with `builtin` as what `wcag2` names. */
+function pickFrom(builtin, algo) {
+	if (algo === "wcag2") return builtin;
+	if (typeof algo !== "function") throw require_parse.unknownName("contrast algorithm", algo, ["wcag2"]);
+	return algo;
+}
+/** A {@link ContrastKit} over `needed` and `spaces`. */
+function contrastKit(needed, spaces) {
+	const over = require_parse.componentsOver([...needed, ...spaces]);
+	return {
+		componentsIn: over,
+		wcag2: wcag2Over(over)
+	};
+}
+/**
+* Contrast of `fg` on `bg`. Colors may be CSS strings. The default is WCAG 2;
+* pass a {@link ContrastFn} to use another measure (see the APCA recipe).
+*/
+function contrast(fg, bg, algo = "wcag2") {
+	return pick(algo)(require_parse.toColor(fg), require_parse.toColor(bg));
+}
+/**
+* Builds {@link contrast} over the spaces given, plus `srgb` and `xyz-d65`,
+* which WCAG 2 works in, so a bundle contains only those. It takes color
+* objects, not strings, so it does not carry `parse`. A color in a space not
+* given throws, naming that space.
+*/
+function createContrast(...spaces) {
+	const kit = contrastKit([require_parse.srgb, require_parse.xyzD65], spaces);
+	return (fg, bg, algo = "wcag2") => pickFrom(kit.wcag2, algo)(fg, bg);
+}
+/**
+* True when `fg` on `bg` reaches `level`: a number, or a name from the
+* algorithm's thresholds (WCAG 2: `AA`, `AA-large`, `AAA`, `AAA-large`,
+* `non-text`). A signed measure such as APCA is compared by magnitude.
+*/
+function meets(fg, bg, level, algo = "wcag2") {
+	const fn = pick(algo);
+	const target = levelOf(fn, level);
+	return Math.abs(fn(require_parse.toColor(fg), require_parse.toColor(bg))) >= target;
+}
+/**
+* Builds {@link meets} over the spaces given, plus `srgb` and `xyz-d65`, which
+* WCAG 2 works in, so a bundle contains only those. It takes color objects,
+* not strings, so it does not carry `parse`. A color in a space not given
+* throws, naming that space.
+*/
+function createMeets(...spaces) {
+	const kit = contrastKit([require_parse.srgb, require_parse.xyzD65], spaces);
+	return (fg, bg, level, algo = "wcag2") => {
+		const fn = pickFrom(kit.wcag2, algo);
+		return Math.abs(fn(fg, bg)) >= levelOf(fn, level);
+	};
+}
+/** The contrast `level` stands for under `fn`: the number itself, or one of its thresholds by name. */
+function levelOf(fn, level) {
+	const named = typeof level === "number" ? level : fn.thresholds?.[level];
+	const target = typeof named === "number" ? named : void 0;
+	if (target === void 0) throw require_parse.unknownName("contrast level", level, Object.keys(fn.thresholds ?? {}));
+	return target;
+}
+const STEPS = 32;
+/**
+* Finds the color closest in lightness to `bg` (OKLCH L, at the given hue and
+* chroma) that reaches `target` contrast against it, by binary search. It looks
+* the preferred way first, then the other. The returned `contrast` is measured
+* on the final, gamut-mapped color, and `met` says whether it reaches `target`.
+*/
+function findContrast(bg, target, options = {}) {
+	return findContrastWith({
+		componentsIn: require_parse.componentsIn,
+		wcag2
+	}, require_parse.toColor(bg), target, options);
+}
+/**
+* Builds {@link findContrast} over the spaces given, plus `srgb`, `xyz-d65`,
+* `oklch` and `oklab`, which WCAG 2 and gamut mapping work in, so a bundle
+* contains only those. It takes a color object, not a string, so it does not
+* carry `parse`. A color in a space not given throws, naming that space.
+*/
+function createFindContrast(...spaces) {
+	const kit = contrastKit([
+		require_parse.srgb,
+		require_parse.xyzD65,
+		require_parse.oklch,
+		require_parse.oklab
+	], spaces);
+	return (bg, target, options = {}) => findContrastWith(kit, bg, target, options);
+}
+function findContrastWith({ componentsIn, wcag2 }, back, target, options) {
+	const fn = pickFrom(wcag2, options.contrast ?? "wcag2");
+	const lch = componentsIn(back, "oklch");
+	const l0 = lch[0];
+	const hue = options.hue ?? lch[2];
+	const chroma = options.chroma ?? 0;
+	const at = (l) => {
+		const color = require_parse.toGamutWith(componentsIn, {
+			colorSpace: "oklch",
+			components: [
+				l,
+				chroma,
+				hue
+			]
+		}, {});
+		const value = fn(color, back);
+		return {
+			color,
+			contrast: value,
+			met: Math.abs(value) >= target
+		};
+	};
+	const first = options.direction ?? (l0 > .5 ? "darker" : "lighter");
+	let best;
+	for (const side of [first, first === "darker" ? "lighter" : "darker"]) {
+		const far = side === "darker" ? 0 : 1;
+		const end = at(far);
+		if (!end.met) {
+			if (!best || Math.abs(end.contrast) > Math.abs(best.contrast)) best = end;
+			continue;
+		}
+		let [lo, hi] = [l0, far];
+		let found = end;
+		for (let i = 0; i < STEPS; i++) {
+			const mid = (lo + hi) / 2;
+			const candidate = at(mid);
+			if (candidate.met) {
+				hi = mid;
+				found = candidate;
+			} else lo = mid;
+		}
+		return found;
+	}
+	return {
+		...best,
+		met: false
+	};
+}
+/**
+* The text color for `bg`, by the Radix rule: white, unless white's contrast
+* on `bg` is under `target`, then a near-black tinted with the hue of `bg`
+* (OKLCH lightness 0.2). When neither reaches `target`, whichever contrasts more.
+*/
+function onColor(bg, options = {}) {
+	return onColorWith({
+		componentsIn: require_parse.componentsIn,
+		wcag2
+	}, require_parse.toColor(bg), options);
+}
+/**
+* Builds {@link onColor} over the spaces given, plus `srgb`, `xyz-d65`,
+* `oklch` and `oklab`, which WCAG 2 and gamut mapping work in, so a bundle
+* contains only those. It takes a color object, not a string, so it does not
+* carry `parse`. A color in a space not given throws, naming that space.
+*/
+function createOnColor(...spaces) {
+	const kit = contrastKit([
+		require_parse.srgb,
+		require_parse.xyzD65,
+		require_parse.oklch,
+		require_parse.oklab
+	], spaces);
+	return (bg, options = {}) => onColorWith(kit, bg, options);
+}
+function onColorWith({ componentsIn, wcag2 }, back, options) {
+	const fn = pickFrom(wcag2, options.contrast ?? "wcag2");
+	const target = options.target ?? 4.5;
+	const white = {
+		colorSpace: "srgb",
+		components: [
+			1,
+			1,
+			1
+		]
+	};
+	const whiteScore = Math.abs(fn(white, back));
+	if (whiteScore >= target) return white;
+	const hue = componentsIn(back, "oklch")[2];
+	const dark = require_parse.toGamutWith(componentsIn, {
+		colorSpace: "oklch",
+		components: [
+			.2,
+			options.chroma ?? .03,
+			hue
+		]
+	}, {});
+	return Math.abs(fn(dark, back)) >= whiteScore ? dark : white;
+}
+Object.defineProperty(exports, "contrast", {
+	enumerable: true,
+	get: function() {
+		return contrast;
+	}
+});
+Object.defineProperty(exports, "createContrast", {
+	enumerable: true,
+	get: function() {
+		return createContrast;
+	}
+});
+Object.defineProperty(exports, "createFindContrast", {
+	enumerable: true,
+	get: function() {
+		return createFindContrast;
+	}
+});
+Object.defineProperty(exports, "createMeets", {
+	enumerable: true,
+	get: function() {
+		return createMeets;
+	}
+});
+Object.defineProperty(exports, "createOnColor", {
+	enumerable: true,
+	get: function() {
+		return createOnColor;
+	}
+});
+Object.defineProperty(exports, "findContrast", {
+	enumerable: true,
+	get: function() {
+		return findContrast;
+	}
+});
+Object.defineProperty(exports, "meets", {
+	enumerable: true,
+	get: function() {
+		return meets;
+	}
+});
+Object.defineProperty(exports, "onColor", {
+	enumerable: true,
+	get: function() {
+		return onColor;
+	}
+});
+Object.defineProperty(exports, "pick", {
+	enumerable: true,
+	get: function() {
+		return pick;
+	}
+});
+Object.defineProperty(exports, "wcag2", {
+	enumerable: true,
+	get: function() {
+		return wcag2;
+	}
+});
+
+//# sourceMappingURL=contrast-XjF5Rwui.js.map

package/cjs/contrast-XjF5Rwui.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contrast-XjF5Rwui.js","names":["componentsIn","unknownName","componentsOver","toColor","srgb","xyzD65","oklch","oklab","toGamutWith"],"sources":["../src/color/contrast.ts"],"sourcesContent":["import { type ComponentsIn, componentsOver } from './convert.js'\nimport { toGamutWith } from './gamut.js'\nimport { oklab } from './oklab.js'\nimport { oklch } from './oklch.js'\nimport { toColor } from './parse.js'\nimport { componentsIn } from './spaces.js'\nimport { srgb } from './srgb.js'\nimport type { Color, Space } from './types.js'\nimport { unknownName } from './unknown-name.js'\nimport { xyzD65 } from './xyz-d65.js'\n\n/**\n * A contrast measure: `(fg, bg) => number`, plus what a caller needs to use it\n * without knowing the algorithm. Any plain `(fg, bg) => number` also works\n * wherever a `ContrastFn` is taken; the extra fields are optional.\n */\nexport interface ContrastFn {\n\t(fg: Color, bg: Color): number\n\t/** A label for messages and output, for example `wcag2`. */\n\treadonly algorithm?: string\n\t/** Named targets, for example `{ AA: 4.5 }`, which `meets` accepts as a level. */\n\treadonly thresholds?: Readonly<Record<string, number>>\n\t/** `symmetric` when swapping fg and bg gives the same number; `signed` when the sign says which is lighter. */\n\treadonly polarity?: 'symmetric' | 'signed'\n}\n\n/** The contrast algorithms built in. */\nexport type ContrastAlgorithm = 'wcag2'\n\n/** Either a built-in name or a {@link ContrastFn}. */\nexport type ContrastOption = ContrastAlgorithm | ContrastFn\n\ntype ColorInput = Color | string\n\n/** Relative luminance (WCAG 2): the Y of the color in XYZ-D65, with white at 1. */\nfunction luminance(componentsIn: ComponentsIn, color: Color): number {\n\treturn Math.max(0, componentsIn(color, 'xyz-d65')[1] as number)\n}\n\n/** Lays a translucent color over `bg`, in `srgb`, the way a browser paints it. */\nfunction flatten(componentsIn: ComponentsIn, fg: Color, bg: Color): Color {\n\tconst alpha = fg.alpha === null ? 0 : (fg.alpha ?? 1)\n\tif (alpha >= 1) return fg\n\tconst f = componentsIn(fg, 'srgb')\n\tconst b = componentsIn(bg, 'srgb')\n\treturn { colorSpace: 'srgb', components: f.map((x, i) => (x as number) * alpha + (b[i] as number) * (1 - alpha)) }\n}\n\n/**\n * WCAG 2 contrast ratio, 1 to 21. A translucent `fg` is laid over `bg` first;\n * `bg` is taken as opaque.\n */\nexport const wcag2: ContrastFn = /* @__PURE__ */ wcag2Over(componentsIn)\n\n/** WCAG 2 over the spaces `componentsIn` knows, which must include `srgb` and `xyz-d65`. */\nfunction wcag2Over(componentsIn: ComponentsIn): ContrastFn {\n\treturn Object.assign(\n\t\t(fg: Color, bg: Color): number => {\n\t\t\tconst a = luminance(componentsIn, flatten(componentsIn, fg, bg)) + 0.05\n\t\t\tconst b = luminance(componentsIn, bg) + 0.05\n\t\t\treturn a > b ? a / b : b / a\n\t\t},\n\t\t{\n\t\t\talgorithm: 'wcag2',\n\t\t\tthresholds: { AA: 4.5, 'AA-large': 3, AAA: 7, 'AAA-large': 4.5, 'non-text': 3 },\n\t\t\tpolarity: 'symmetric'\n\t\t} as const\n\t)\n}\n\n/** The measure `algo` names: `wcag2` or a function; anything else is an unknown name. */\nexport function pick(algo: ContrastOption): ContrastFn {\n\treturn pickFrom(wcag2, algo)\n}\n\n/** {@link pick}, with `builtin` as what `wcag2` names. */\nfunction pickFrom(builtin: ContrastFn, algo: ContrastOption): ContrastFn {\n\tif (algo === 'wcag2') return builtin\n\tif (typeof algo !== 'function') throw unknownName('contrast algorithm', algo, ['wcag2'])\n\treturn algo\n}\n\n/** What a narrow contrast helper works over: its spaces and its own `wcag2`. */\ninterface ContrastKit {\n\tcomponentsIn: ComponentsIn\n\twcag2: ContrastFn\n}\n\n/** A {@link ContrastKit} over `needed` and `spaces`. */\nfunction contrastKit(needed: Space[], spaces: Space[]): ContrastKit {\n\tconst over = componentsOver([...needed, ...spaces])\n\treturn { componentsIn: over, wcag2: wcag2Over(over) }\n}\n\n/**\n * Contrast of `fg` on `bg`. Colors may be CSS strings. The default is WCAG 2;\n * pass a {@link ContrastFn} to use another measure (see the APCA recipe).\n */\nexport function contrast(fg: ColorInput, bg: ColorInput, algo: ContrastOption = 'wcag2'): number {\n\treturn pick(algo)(toColor(fg), toColor(bg))\n}\n\n/**\n * Builds {@link contrast} over the spaces given, plus `srgb` and `xyz-d65`,\n * which WCAG 2 works in, so a bundle contains only those. It takes color\n * objects, not strings, so it does not carry `parse`. A color in a space not\n * given throws, naming that space.\n */\nexport function createContrast(...spaces: Space[]): (fg: Color, bg: Color, algo?: ContrastOption) => number {\n\tconst kit = contrastKit([srgb, xyzD65], spaces)\n\treturn (fg, bg, algo = 'wcag2') => pickFrom(kit.wcag2, algo)(fg, bg)\n}\n\n/**\n * True when `fg` on `bg` reaches `level`: a number, or a name from the\n * algorithm's thresholds (WCAG 2: `AA`, `AA-large`, `AAA`, `AAA-large`,\n * `non-text`). A signed measure such as APCA is compared by magnitude.\n */\nexport function meets(fg: ColorInput, bg: ColorInput, level: number | string, algo: ContrastOption = 'wcag2'): boolean {\n\tconst fn = pick(algo)\n\tconst target = levelOf(fn, level)\n\treturn Math.abs(fn(toColor(fg), toColor(bg))) >= target\n}\n\n/**\n * Builds {@link meets} over the spaces given, plus `srgb` and `xyz-d65`, which\n * WCAG 2 works in, so a bundle contains only those. It takes color objects,\n * not strings, so it does not carry `parse`. A color in a space not given\n * throws, naming that space.\n */\nexport function createMeets(\n\t...spaces: Space[]\n): (fg: Color, bg: Color, level: number | string, algo?: ContrastOption) => boolean {\n\tconst kit = contrastKit([srgb, xyzD65], spaces)\n\treturn (fg, bg, level, algo = 'wcag2') => {\n\t\tconst fn = pickFrom(kit.wcag2, algo)\n\t\treturn Math.abs(fn(fg, bg)) >= levelOf(fn, level)\n\t}\n}\n\n/** The contrast `level` stands for under `fn`: the number itself, or one of its thresholds by name. */\nfunction levelOf(fn: ContrastFn, level: number | string): number {\n\tconst named = typeof level === 'number' ? level : fn.thresholds?.[level]\n\t// A name that is not the algorithm's own (`constructor`) finds something that is not a number.\n\tconst target = typeof named === 'number' ? named : undefined\n\tif (target === undefined) throw unknownName('contrast level', level, Object.keys(fn.thresholds ?? {}))\n\treturn target\n}\n\n/** Options for `findContrast` and the function `createFindContrast` returns. */\nexport interface FindContrastOptions {\n\t/** Hue of the result, in OKLCH degrees. Default: the hue of `bg`. */\n\thue?: number\n\t/** Chroma of the result, in OKLCH. Default 0. The result is mapped into the gamut. */\n\tchroma?: number\n\t/** Which way to look first from `bg`. Default: darker on a light `bg`, lighter on a dark one. */\n\tdirection?: 'lighter' | 'darker'\n\t/** Default `wcag2`. */\n\tcontrast?: ContrastOption\n}\n\n/** What `findContrast` returns: the color it found and whether it reached the target. */\nexport interface FoundContrast {\n\t/** The color, in `srgb` and inside the gamut. */\n\tcolor: Color\n\t/** The contrast it achieves against `bg`, as the algorithm reports it. */\n\tcontrast: number\n\t/** False when no lightness reaches `target`; `color` is then the best one found. */\n\tmet: boolean\n}\n\nconst STEPS = 32\n\n/**\n * Finds the color closest in lightness to `bg` (OKLCH L, at the given hue and\n * chroma) that reaches `target` contrast against it, by binary search. It looks\n * the preferred way first, then the other. The returned `contrast` is measured\n * on the final, gamut-mapped color, and `met` says whether it reaches `target`.\n */\nexport function findContrast(bg: ColorInput, target: number, options: FindContrastOptions = {}): FoundContrast {\n\treturn findContrastWith({ componentsIn, wcag2 }, toColor(bg), target, options)\n}\n\n/**\n * Builds {@link findContrast} over the spaces given, plus `srgb`, `xyz-d65`,\n * `oklch` and `oklab`, which WCAG 2 and gamut mapping work in, so a bundle\n * contains only those. It takes a color object, not a string, so it does not\n * carry `parse`. A color in a space not given throws, naming that space.\n */\nexport function createFindContrast(\n\t...spaces: Space[]\n): (bg: Color, target: number, options?: FindContrastOptions) => FoundContrast {\n\tconst kit = contrastKit([srgb, xyzD65, oklch, oklab], spaces)\n\treturn (bg, target, options = {}) => findContrastWith(kit, bg, target, options)\n}\n\nfunction findContrastWith(\n\t{ componentsIn, wcag2 }: ContrastKit,\n\tback: Color,\n\ttarget: number,\n\toptions: FindContrastOptions\n): FoundContrast {\n\tconst fn = pickFrom(wcag2, options.contrast ?? 'wcag2')\n\tconst lch = componentsIn(back, 'oklch')\n\tconst l0 = lch[0] as number\n\tconst hue = options.hue ?? (lch[2] as number)\n\tconst chroma = options.chroma ?? 0\n\tconst at = (l: number): FoundContrast => {\n\t\tconst color = toGamutWith(componentsIn, { colorSpace: 'oklch', components: [l, chroma, hue] }, {})\n\t\tconst value = fn(color, back)\n\t\treturn { color, contrast: value, met: Math.abs(value) >= target }\n\t}\n\tconst first = options.direction ?? (l0 > 0.5 ? 'darker' : 'lighter')\n\tlet best: FoundContrast | undefined\n\tfor (const side of [first, first === 'darker' ? 'lighter' : 'darker']) {\n\t\tconst far = side === 'darker' ? 0 : 1\n\t\tconst end = at(far)\n\t\tif (!end.met) {\n\t\t\tif (!best || Math.abs(end.contrast) > Math.abs(best.contrast)) best = end\n\t\t\tcontinue\n\t\t}\n\t\t// `lo` is on the bg side and fails or is the bg itself; `hi` always passes.\n\t\tlet [lo, hi] = [l0, far]\n\t\tlet found = end\n\t\tfor (let i = 0; i < STEPS; i++) {\n\t\t\tconst mid = (lo + hi) / 2\n\t\t\tconst candidate = at(mid)\n\t\t\tif (candidate.met) {\n\t\t\t\thi = mid\n\t\t\t\tfound = candidate\n\t\t\t} else lo = mid\n\t\t}\n\t\treturn found\n\t}\n\treturn { ...(best as FoundContrast), met: false }\n}\n\n/** Options for `onColor` and the function `createOnColor` returns. */\nexport interface OnColorOptions {\n\t/** The contrast the text needs. Default 4.5 for WCAG 2. */\n\ttarget?: number\n\t/** How much of the background's hue the dark text carries, as OKLCH chroma. Default 0.03. */\n\tchroma?: number\n\t/** Default `wcag2`. */\n\tcontrast?: ContrastOption\n}\n\n/**\n * The text color for `bg`, by the Radix rule: white, unless white's contrast\n * on `bg` is under `target`, then a near-black tinted with the hue of `bg`\n * (OKLCH lightness 0.2). When neither reaches `target`, whichever contrasts more.\n */\nexport function onColor(bg: ColorInput, options: OnColorOptions = {}): Color {\n\treturn onColorWith({ componentsIn, wcag2 }, toColor(bg), options)\n}\n\n/**\n * Builds {@link onColor} over the spaces given, plus `srgb`, `xyz-d65`,\n * `oklch` and `oklab`, which WCAG 2 and gamut mapping work in, so a bundle\n * contains only those. It takes a color object, not a string, so it does not\n * carry `parse`. A color in a space not given throws, naming that space.\n */\nexport function createOnColor(...spaces: Space[]): (bg: Color, options?: OnColorOptions) => Color {\n\tconst kit = contrastKit([srgb, xyzD65, oklch, oklab], spaces)\n\treturn (bg, options = {}) => onColorWith(kit, bg, options)\n}\n\nfunction onColorWith({ componentsIn, wcag2 }: ContrastKit, back: Color, options: OnColorOptions): Color {\n\tconst fn = pickFrom(wcag2, options.contrast ?? 'wcag2')\n\tconst target = options.target ?? 4.5\n\tconst white: Color = { colorSpace: 'srgb', components: [1, 1, 1] }\n\tconst whiteScore = Math.abs(fn(white, back))\n\tif (whiteScore >= target) return white\n\tconst hue = componentsIn(back, 'oklch')[2] as number\n\tconst dark = toGamutWith(componentsIn, { colorSpace: 'oklch', components: [0.2, options.chroma ?? 0.03, hue] }, {})\n\treturn Math.abs(fn(dark, back)) >= whiteScore ? dark : white\n}\n"],"mappings":"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"}

package/cjs/gamut-CG1J2aat.d.ts

@@ -0,0 +1,158 @@
+/** The spaces a {@link Color} can be in. Names are the CSS ones. */
+type ColorSpaceId = 'srgb' | 'srgb-linear' | 'hsl' | 'hwb' | 'lab' | 'lch' | 'oklab' | 'oklch' | 'display-p3' | 'display-p3-linear' | 'a98-rgb' | 'prophoto-rgb' | 'rec2020' | 'xyz-d50' | 'xyz-d65';
+/** A component value. `null` stands for the CSS keyword `none`. */
+type Component = number | null;
+/**
+ * A color as plain JSON. Component ranges follow CSS: `srgb` is 0 to 1, `hsl`
+ * and `hwb` take hue in degrees and the rest in 0 to 100, `lab` and `lch` take
+ * L in 0 to 100, `oklab` and `oklch` take L in 0 to 1. A missing `alpha` is 1.
+ */
+interface Color {
+  colorSpace: ColorSpaceId;
+  components: Component[];
+  alpha?: Component;
+}
+/** Three numbers: the components of a color without alpha, or a point in XYZ. */
+type Vec3 = [number, number, number];
+/** A color space, defined by its conversion to and from the XYZ-D65 hub. */
+interface Space {
+  id: ColorSpaceId;
+  toXyz(c: Vec3): Vec3;
+  fromXyz(xyz: Vec3): Vec3;
+}
+/**
+ * A contrast measure: `(fg, bg) => number`, plus what a caller needs to use it
+ * without knowing the algorithm. Any plain `(fg, bg) => number` also works
+ * wherever a `ContrastFn` is taken; the extra fields are optional.
+ */
+interface ContrastFn {
+  (fg: Color, bg: Color): number;
+  /** A label for messages and output, for example `wcag2`. */
+  readonly algorithm?: string;
+  /** Named targets, for example `{ AA: 4.5 }`, which `meets` accepts as a level. */
+  readonly thresholds?: Readonly<Record<string, number>>;
+  /** `symmetric` when swapping fg and bg gives the same number; `signed` when the sign says which is lighter. */
+  readonly polarity?: 'symmetric' | 'signed';
+}
+/** The contrast algorithms built in. */
+type ContrastAlgorithm = 'wcag2';
+/** Either a built-in name or a {@link ContrastFn}. */
+type ContrastOption = ContrastAlgorithm | ContrastFn;
+type ColorInput = Color | string;
+/**
+ * WCAG 2 contrast ratio, 1 to 21. A translucent `fg` is laid over `bg` first;
+ * `bg` is taken as opaque.
+ */
+declare const wcag2: ContrastFn;
+/**
+ * Contrast of `fg` on `bg`. Colors may be CSS strings. The default is WCAG 2;
+ * pass a {@link ContrastFn} to use another measure (see the APCA recipe).
+ */
+declare function contrast(fg: ColorInput, bg: ColorInput, algo?: ContrastOption): number;
+/**
+ * Builds {@link contrast} over the spaces given, plus `srgb` and `xyz-d65`,
+ * which WCAG 2 works in, so a bundle contains only those. It takes color
+ * objects, not strings, so it does not carry `parse`. A color in a space not
+ * given throws, naming that space.
+ */
+declare function createContrast(...spaces: Space[]): (fg: Color, bg: Color, algo?: ContrastOption) => number;
+/**
+ * True when `fg` on `bg` reaches `level`: a number, or a name from the
+ * algorithm's thresholds (WCAG 2: `AA`, `AA-large`, `AAA`, `AAA-large`,
+ * `non-text`). A signed measure such as APCA is compared by magnitude.
+ */
+declare function meets(fg: ColorInput, bg: ColorInput, level: number | string, algo?: ContrastOption): boolean;
+/**
+ * Builds {@link meets} over the spaces given, plus `srgb` and `xyz-d65`, which
+ * WCAG 2 works in, so a bundle contains only those. It takes color objects,
+ * not strings, so it does not carry `parse`. A color in a space not given
+ * throws, naming that space.
+ */
+declare function createMeets(...spaces: Space[]): (fg: Color, bg: Color, level: number | string, algo?: ContrastOption) => boolean;
+/** Options for `findContrast` and the function `createFindContrast` returns. */
+interface FindContrastOptions {
+  /** Hue of the result, in OKLCH degrees. Default: the hue of `bg`. */
+  hue?: number;
+  /** Chroma of the result, in OKLCH. Default 0. The result is mapped into the gamut. */
+  chroma?: number;
+  /** Which way to look first from `bg`. Default: darker on a light `bg`, lighter on a dark one. */
+  direction?: 'lighter' | 'darker';
+  /** Default `wcag2`. */
+  contrast?: ContrastOption;
+}
+/** What `findContrast` returns: the color it found and whether it reached the target. */
+interface FoundContrast {
+  /** The color, in `srgb` and inside the gamut. */
+  color: Color;
+  /** The contrast it achieves against `bg`, as the algorithm reports it. */
+  contrast: number;
+  /** False when no lightness reaches `target`; `color` is then the best one found. */
+  met: boolean;
+}
+/**
+ * Finds the color closest in lightness to `bg` (OKLCH L, at the given hue and
+ * chroma) that reaches `target` contrast against it, by binary search. It looks
+ * the preferred way first, then the other. The returned `contrast` is measured
+ * on the final, gamut-mapped color, and `met` says whether it reaches `target`.
+ */
+declare function findContrast(bg: ColorInput, target: number, options?: FindContrastOptions): FoundContrast;
+/**
+ * Builds {@link findContrast} over the spaces given, plus `srgb`, `xyz-d65`,
+ * `oklch` and `oklab`, which WCAG 2 and gamut mapping work in, so a bundle
+ * contains only those. It takes a color object, not a string, so it does not
+ * carry `parse`. A color in a space not given throws, naming that space.
+ */
+declare function createFindContrast(...spaces: Space[]): (bg: Color, target: number, options?: FindContrastOptions) => FoundContrast;
+/** Options for `onColor` and the function `createOnColor` returns. */
+interface OnColorOptions {
+  /** The contrast the text needs. Default 4.5 for WCAG 2. */
+  target?: number;
+  /** How much of the background's hue the dark text carries, as OKLCH chroma. Default 0.03. */
+  chroma?: number;
+  /** Default `wcag2`. */
+  contrast?: ContrastOption;
+}
+/**
+ * The text color for `bg`, by the Radix rule: white, unless white's contrast
+ * on `bg` is under `target`, then a near-black tinted with the hue of `bg`
+ * (OKLCH lightness 0.2). When neither reaches `target`, whichever contrasts more.
+ */
+declare function onColor(bg: ColorInput, options?: OnColorOptions): Color;
+/**
+ * Builds {@link onColor} over the spaces given, plus `srgb`, `xyz-d65`,
+ * `oklch` and `oklab`, which WCAG 2 and gamut mapping work in, so a bundle
+ * contains only those. It takes a color object, not a string, so it does not
+ * carry `parse`. A color in a space not given throws, naming that space.
+ */
+declare function createOnColor(...spaces: Space[]): (bg: Color, options?: OnColorOptions) => Color;
+/** The bounded RGB spaces a color can be tested or mapped against. */
+type GamutId = 'srgb' | 'srgb-linear' | 'display-p3' | 'display-p3-linear' | 'a98-rgb' | 'prophoto-rgb' | 'rec2020';
+/** True when every channel of `color`, seen in `gamut`, is within 0 to 1 (± `epsilon`). */
+declare function inGamut(color: Color, gamut?: GamutId, epsilon?: number): boolean;
+/**
+ * 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.
+ */
+declare function createInGamut(...spaces: Space[]): (color: Color, gamut?: GamutId, epsilon?: number) => boolean;
+/** Options for `toGamut` and the function `createToGamut` returns. */
+interface ToGamutOptions {
+  /** The gamut to fit into. Default `srgb`. */
+  gamut?: GamutId;
+  /** `css` is the CSS Color 4 OKLCH chroma reduction. `clip` clamps each channel. Default `css`. */
+  method?: 'css' | 'clip';
+}
+/**
+ * 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.
+ */
+declare function toGamut(color: Color, options?: ToGamutOptions): Color;
+/**
+ * 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.
+ */
+declare function createToGamut(...spaces: Space[]): (color: Color, options?: ToGamutOptions) => Color;
+export { ColorSpaceId as C, Vec3 as E, Color as S, Space as T, createOnColor as _, inGamut as a, onColor as b, ContrastFn as c, FoundContrast as d, OnColorOptions as f, createMeets as g, createFindContrast as h, createToGamut as i, ContrastOption as l, createContrast as m, ToGamutOptions as n, toGamut as o, contrast as p, createInGamut as r, ContrastAlgorithm as s, GamutId as t, FindContrastOptions as u, findContrast as v, Component as w, wcag2 as x, meets as y };
+//# sourceMappingURL=gamut-CG1J2aat.d.ts.map

package/cjs/gamut-CG1J2aat.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gamut-CG1J2aat.d.ts","names":[],"sources":["../src/color/types.ts","../src/color/contrast.ts","../src/color/gamut.ts"],"mappings":";KACY;;KAkBA;;;;;;UAOK;EAChB,YAAY;EACZ,YAAY;EACZ,QAAQ;;;KAIG;;UAGK;EAChB,IAAI;EACJ,MAAM,GAAG,OAAO;EAChB,QAAQ,KAAK,OAAO;;;;;;;UCvBJ;GACf,IAAI,OAAO,IAAI;;WAEP;;WAEA,aAAa,SAAS;;WAEtB;;;KAIE;;KAGA,iBAAiB,oBAAoB;KAE5C,aAAa;;;;;cAoBL,OAAO;;;;;iBA8CJ,SAAS,IAAI,YAAY,IAAI,YAAY,OAAM;;;;;;;iBAU/C,kBAAkB,QAAQ,WAAW,IAAI,OAAO,IAAI,OAAO,OAAO;;;;;;iBAUlE,MAAM,IAAI,YAAY,IAAI,YAAY,wBAAwB,OAAM;;;;;;;iBAYpE,eACZ,QAAQ,WACR,IAAI,OAAO,IAAI,OAAO,wBAAwB,OAAO;;UAkBxC;;EAEhB;;EAEA;;EAEA;;EAEA,WAAW;;;UAIK;;EAEhB,OAAO;;EAEP;;EAEA;;;;;;;;iBAWe,aAAa,IAAI,YAAY,gBAAgB,UAAS,sBAA2B;;;;;;;iBAUjF,sBACZ,QAAQ,WACR,IAAI,OAAO,gBAAgB,UAAU,wBAAwB;;UA+ChD;;EAEhB;;EAEA;;EAEA,WAAW;;;;;;;iBAQI,QAAQ,IAAI,YAAY,UAAS,iBAAsB;;;;;;;iBAUvD,iBAAiB,QAAQ,WAAW,IAAI,OAAO,UAAU,mBAAmB;;KC1PhF;;iBAaI,QAAQ,OAAO,OAAO,QAAO,SAAkB;;;;;;iBAS/C,iBAAiB,QAAQ,WAAW,OAAO,OAAO,QAAQ,SAAS;;UAMlE;;EAEhB,QAAQ;;EAER;;;;;;;iBAgBe,QAAQ,OAAO,OAAO,UAAS,iBAAsB;;;;;;iBASrD,iBAAiB,QAAQ,WAAW,OAAO,OAAO,UAAU,mBAAmB"}

package/cjs/index-BcEqCPHz.d.ts

@@ -0,0 +1,137 @@
+import { S as Color, l as ContrastOption, t as GamutId } from "./gamut-CG1J2aat.js";
+import { n as MixOptions } from "./mix-DGlKoUw4.js";
+/** Options for `scaleFromBrand`. */
+interface BrandScaleOptions {
+  /** `light` runs from a near-white step 1 to dark text; `dark` the other way. Default `light`. */
+  mode?: 'light' | 'dark';
+  /** The page background, whose lightness step 1 takes. Default near-white, or near-black in `dark`. */
+  background?: Color | string;
+  /** The gamut steps other than 9 must fit. Default `srgb`. */
+  gamut?: GamutId;
+}
+/**
+ * A 12-step UI scale from one brand color, after Radix's palette generator:
+ * the brand color is step 9 exactly (returned as given, never remapped), steps
+ * 1 to 8 run from the background to it, step 10 is its hover state, and steps
+ * 11 and 12 are low- and high-contrast text. Hue is the brand's throughout.
+ * Radix's generator also borrows the shape of the nearest of its hand-tuned
+ * scales; this one uses a single fixed shape instead.
+ */
+declare function scaleFromBrand(brand: Color | string, options?: BrandScaleOptions): Color[];
+/** Options for `createContrastScale`. */
+interface ContrastScaleOptions {
+  /** The color the scale is built around: its hue and chroma carry to every step. */
+  seed: Color | string;
+  /** What every step is measured against. */
+  background: Color | string;
+  /** Target contrast per step, in order, or a record of named targets (`{ text: 7, border: 3 }`). */
+  targets: number[] | Record<string, number>;
+  /** Default `wcag2`. */
+  contrast?: ContrastOption;
+  /** Which way to look first from the background. Default: darker on a light background, lighter on a dark one. */
+  direction?: 'lighter' | 'darker';
+}
+/** One step of a contrast scale: the target it was given and the color and contrast it got. */
+interface ContrastStep {
+  /** The key in a record of targets; otherwise the step's index as a string. */
+  name: string;
+  target: number;
+  color: Color;
+  /** The contrast the color achieves, measured on the color itself. */
+  contrast: number;
+  /** False when no lightness reaches `target`; `color` is then the best one found. */
+  met: boolean;
+}
+/**
+ * A Leonardo-style scale: each step is the color nearest the background's
+ * lightness, at the seed's hue and chroma, that reaches its target contrast.
+ * Contrast is the same across hues, which a fixed-lightness scale cannot give.
+ */
+declare function createContrastScale(options: ContrastScaleOptions): ContrastStep[];
+/** A color at a position on the gradient line. */
+interface GradientStop {
+  /** A CSS color string or a color object. Its alpha is the stop's alpha. */
+  color: Color | string;
+  /**
+   * Where the stop sits, with 0 the start and 1 the end; it may fall outside
+   * 0 to 1. Leave it out to spread the stop evenly between its neighbors, as
+   * CSS gradients do.
+   */
+  at?: number;
+}
+/** `in` and `hue` work as they do in `mix()`. The default space is `oklab`. */
+type GradientOptions = MixOptions;
+/**
+ * Builds `count` colors, evenly spaced from 0 to 1 along a gradient through
+ * `stops`, the way a CSS gradient blends them: each pair of neighboring stops
+ * is mixed with `mix()`, so `in` and `hue` work as they do there. A stop is
+ * `{ color, at? }`, or a bare color when it needs no position. Before the
+ * first stop and after the last, the color holds; where two stops share a
+ * position, the color changes there and the sample at that position takes the
+ * later stop. Colors come back in the `in` space, default `oklab`.
+ *
+ * Alpha comes from each stop's color, 1 when the color has none, so
+ * `rgb(0 0 255 / 0.2)` is a stop at alpha 0.2. Alpha is interpolated linearly
+ * between stops, and the other components are premultiplied by it, so a
+ * transparent stop does not pull its neighbor's color toward its own. A color
+ * whose alpha is 1 has no `alpha` key; a `none` alpha takes the neighboring
+ * stop's.
+ *
+ * ```ts
+ * createGradient([{ color: 'blue', at: 0 }, { color: 'lime', at: 0.6 }, { color: 'yellow', at: 1 }], 72)
+ * createGradient(['blue', 'lime'], 5, { in: 'oklch' })
+ * ```
+ */
+declare function createGradient(stops: readonly (GradientStop | Color | string)[], count: number, options?: GradientOptions): Color[];
+/** The built-in step curves. */
+type ScalePreset = 'tailwind-11' | 'radix-12' | 'tone-13' | 'even';
+/** Options for `createScale`. Only `seed` is required. */
+interface ScaleOptions {
+  /** The color the scale is built around. Its hue and chroma set the anchor step. */
+  seed: Color | string;
+  /**
+   * A preset, or a number of steps for an even scale. Default `tailwind-11`.
+   * `tone-13` steps are CIE L* tones, so any two steps whose tones differ by
+   * 40 reach contrast 3 and by 50 about 4.5.
+   */
+  steps?: ScalePreset | number;
+  /** Overrides the curve's lightness, one per step: OKLCH L 0 to 1 (L* tones 0 to 100 for `tone-13`). */
+  lightness?: number[];
+  /** Overrides chroma, as a multiplier of the seed's chroma, one per step. */
+  chroma?: number[];
+  /** Overrides hue drift, as degrees added to the seed's hue, one per step; a number is applied to every step. */
+  hueShift?: number[] | number;
+  /** The gamut every step must fit. Default `srgb`. */
+  gamut?: GamutId;
+}
+/**
+ * Builds a scale from light to dark around `seed`: one color per step, in
+ * OKLCH, mapped into `gamut`. The preset gives each step's lightness, chroma
+ * (relative to the seed's) and hue drift; pass `lightness`, `chroma` or
+ * `hueShift` to replace any of them.
+ */
+declare function createScale(options: ScaleOptions): Color[];
+/** CIE L* (0 to 100) of a color: its relative luminance on the CIELAB lightness curve. */
+declare function lstar(color: Color): number;
+/** Material's tones: 0 is black, 100 is white. */
+declare const MATERIAL_TONES: readonly number[];
+/** Options for `tonalPalette`. */
+interface TonalPaletteOptions {
+  /** The gamut the colors must fit. Default `srgb`. */
+  gamut?: GamutId;
+}
+/**
+ * The color at CIE L* `tone` with the given OKLCH hue and chroma, mapped into
+ * the gamut. OKLCH lightness is searched until the *mapped* color lands on
+ * `tone`, so chroma tapers where the gamut narrows and the tone stays true.
+ */
+declare function toneColor(tone: number, chroma: number, hue: number, gamut?: GamutId): Color;
+/**
+ * A tonal palette, as in Material: one OKLCH hue and chroma held across L*
+ * tones. Two colors whose tones differ by 40 or more reach WCAG 2 contrast 3,
+ * and by 50 or more about 4.5 (4.48 at the worst pair, 100 against 50), so a
+ * pair can be picked by tone alone. Default tones are Material's 13.
+ */
+declare function tonalPalette(hue: number, chroma: number, tones?: readonly number[], options?: TonalPaletteOptions): Color[];
+export { toneColor as a, createScale as c, createGradient as d, ContrastScaleOptions as f, scaleFromBrand as g, BrandScaleOptions as h, tonalPalette as i, GradientOptions as l, createContrastScale as m, TonalPaletteOptions as n, ScaleOptions as o, ContrastStep as p, lstar as r, ScalePreset as s, MATERIAL_TONES as t, GradientStop as u };
+//# sourceMappingURL=index-BcEqCPHz.d.ts.map

package/cjs/index-BcEqCPHz.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-BcEqCPHz.d.ts","names":[],"sources":["../src/scale/brand.ts","../src/scale/contrast-scale.ts","../src/scale/gradient.ts","../src/scale/scale.ts","../src/scale/tone.ts"],"mappings":";;;UAQiB;;EAEhB;;EAEA,aAAa;;EAEb,QAAQ;;;;;;;;;;iBAgBO,eAAe,OAAO,gBAAgB,UAAS,oBAAyB;;UCxBvE;;EAEhB,MAAM;;EAEN,YAAY;;EAEZ,oBAAoB;;EAEpB,WAAW;;EAEX;;;UAIgB;;EAEhB;EACA;EACA,OAAO;;EAEP;;EAEA;;;;;;;iBAQe,oBAAoB,SAAS,uBAAuB;;UC/BnD;;EAEhB,OAAO;;;;;;EAMP;;;KAIW,kBAAkB;;;;;;;;;;;;;;;;;;;;;;iBAqDd,eACf,iBAAiB,eAAe,mBAChC,eACA,UAAS,kBACP;;KCjES;;UA2DK;;EAEhB,MAAM;;;;;;EAMN,QAAQ;;EAER;;EAEA;;EAEA;;EAEA,QAAQ;;;;;;;;iBAoBO,YAAY,SAAS,eAAe;;iBCnGpC,MAAM,OAAO;;cAMhB;;UAGI;;EAEhB,QAAQ;;;;;;;iBAQO,UAAU,cAAc,gBAAgB,aAAa,QAAO,UAAmB;;;;;;;iBAqC/E,aACf,aACA,gBACA,2BACA,UAAS,sBACP"}