color-map 2.1.0 → 2.3.0

package/cjs/legacy/index.js

@@ -0,0 +1,75 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+// src/legacy/createColors.ts
+/**
+* Creates `shades` colors that step evenly from `from` to `to`. Red, green and
+* blue are rounded to whole numbers. Without `alpha`, the alpha of each end
+* comes from its own fourth value, then from the other end, then is 1.
+* Every result is an `RGBA`.
+*/
+function createColors(from, to, shades, alpha = [from.length === 4 ? from[3] : to.length === 4 ? to[3] : 1, to.length === 4 ? to[3] : from.length === 4 ? from[3] : 1]) {
+	const start = [...from];
+	const diff = [
+		to[0] - from[0],
+		to[1] - from[1],
+		to[2] - from[2],
+		alpha[1] - alpha[0]
+	];
+	if (start.length === 3) start.push(alpha[0]);
+	const inc = 1 / Math.max(shades - 1, 1);
+	const rgba = [];
+	for (let i = 0; i < shades; i++) {
+		const color = [
+			Math.round(start[0] + i * diff[0] * inc),
+			Math.round(start[1] + i * diff[1] * inc),
+			Math.round(start[2] + i * diff[2] * inc),
+			start[3] + i * diff[3] * inc
+		];
+		rgba.push(color);
+	}
+	return rgba;
+}
+// src/legacy/createColorsFromMap.ts
+/**
+* Create colors with specified color map.
+*
+* @deprecated Use `createGradient` from `color-map`. Each of its stops
+* carries its own alpha, and `{ in: 'srgb' }` comes close to these results.
+*/
+function createColorsFromMap(colormap, shades, alpha) {
+	if (shades < colormap.length) throw new Error(`Requires at least ${colormap.length} shades.`);
+	const result = [];
+	const steps = [];
+	for (let i = 0; i < colormap.length; i++) steps.push(Math.round(colormap[i].index * shades));
+	for (let i = 0; i < colormap.length - 1; i++) {
+		const n = steps[i + 1] - steps[i];
+		const from = colormap[i].rgb;
+		const to = colormap[i + 1].rgb;
+		result.push(...createColors(from, to, n, alpha));
+	}
+	return result;
+}
+// src/legacy/rgbaString.ts
+/** Formats an `RGBA` as a CSS `rgba(r,g,b,a)` string, with no spaces. */
+function rgbaString(rgba) {
+	return "rgba(" + rgba.join(",") + ")";
+}
+// src/legacy/rgbHex.ts
+/**
+* Convert `RGB` to `#rgb`
+* JavaScript note: no check for array length, use it properly.
+*/
+function rgbHex(rgb) {
+	let hex = "#";
+	for (let i = 0; i < 3; i++) hex += d2h(rgb[i]);
+	return hex;
+}
+function d2h(d) {
+	const s = (+d).toString(16);
+	return s.length < 2 ? "0" + s : s;
+}
+exports.createColors = createColors;
+exports.createColorsFromMap = createColorsFromMap;
+exports.rgbHex = rgbHex;
+exports.rgbaString = rgbaString;
+
+//# sourceMappingURL=index.js.map

package/cjs/legacy/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/legacy/createColors.ts","../../src/legacy/createColorsFromMap.ts","../../src/legacy/rgbaString.ts","../../src/legacy/rgbHex.ts"],"sourcesContent":["import type { Alpha, RGB, RGBA } from './interfaces.js'\n\n/**\n * Creates `shades` colors that step evenly from `from` to `to`. Red, green and\n * blue are rounded to whole numbers. Without `alpha`, the alpha of each end\n * comes from its own fourth value, then from the other end, then is 1.\n * Every result is an `RGBA`.\n */\nexport function createColors(\n\tfrom: RGB | RGBA,\n\tto: RGB | RGBA,\n\tshades: number,\n\talpha: Alpha = [\n\t\tfrom.length === 4 ? from[3] : to.length === 4 ? to[3] : 1,\n\t\tto.length === 4 ? to[3] : from.length === 4 ? from[3] : 1\n\t]\n): RGBA[] {\n\tconst start = [...from]\n\tconst diff = [to[0] - from[0], to[1] - from[1], to[2] - from[2], alpha[1] - alpha[0]]\n\n\tif (start.length === 3) start.push(alpha[0])\n\n\tconst inc = 1 / Math.max(shades - 1, 1)\n\n\tconst rgba: any[] = []\n\tfor (let i = 0; i < shades; i++) {\n\t\tconst color = [\n\t\t\tMath.round(start[0] + i * diff[0] * inc),\n\t\t\tMath.round(start[1] + i * diff[1] * inc),\n\t\t\tMath.round(start[2] + i * diff[2] * inc),\n\t\t\tstart[3] + i * diff[3] * inc\n\t\t]\n\t\trgba.push(color)\n\t}\n\treturn rgba\n}\n","import { createColors } from './createColors.js'\nimport type { Alpha, ColorMap, RGBA } from './interfaces.js'\n\n/**\n * Create colors with specified color map.\n *\n * @deprecated Use `createGradient` from `color-map`. Each of its stops\n * carries its own alpha, and `{ in: 'srgb' }` comes close to these results.\n */\nexport function createColorsFromMap(colormap: ColorMap, shades: number, alpha?: Alpha): RGBA[] {\n\tif (shades < colormap.length) {\n\t\tthrow new Error(`Requires at least ${colormap.length} shades.`)\n\t}\n\n\tconst result: RGBA[] = []\n\tconst steps: number[] = []\n\tfor (let i = 0; i < colormap.length; i++) {\n\t\tsteps.push(Math.round(colormap[i].index * shades))\n\t}\n\n\tfor (let i = 0; i < colormap.length - 1; i++) {\n\t\tconst n = steps[i + 1] - steps[i]\n\t\tconst from = colormap[i].rgb\n\t\tconst to = colormap[i + 1].rgb\n\t\tresult.push(...createColors(from, to, n, alpha))\n\t}\n\n\treturn result\n}\n","import type { RGBA } from './interfaces.js'\n\n/** Formats an `RGBA` as a CSS `rgba(r,g,b,a)` string, with no spaces. */\nexport function rgbaString(rgba: RGBA) {\n\treturn 'rgba(' + rgba.join(',') + ')'\n}\n","import type { RGB, RGBA } from './interfaces.js'\n\n/**\n * Convert `RGB` to `#rgb`\n * JavaScript note: no check for array length, use it properly.\n */\nexport function rgbHex(rgb: RGB | RGBA) {\n\tlet hex = '#'\n\tfor (let i = 0; i < 3; i++) {\n\t\thex += d2h(rgb[i])\n\t}\n\treturn hex\n}\n\nfunction d2h(d: number) {\n\tconst s = (+d).toString(16)\n\treturn s.length < 2 ? '0' + s : s\n}\n"],"mappings":";;;;;;;;AAQA,SAAgB,aACf,MACA,IACA,QACA,QAAe,CACd,KAAK,WAAW,IAAI,KAAK,KAAK,GAAG,WAAW,IAAI,GAAG,KAAK,GACxD,GAAG,WAAW,IAAI,GAAG,KAAK,KAAK,WAAW,IAAI,KAAK,KAAK,CACzD,GACS;CACT,MAAM,QAAQ,CAAC,GAAG,IAAI;CACtB,MAAM,OAAO;EAAC,GAAG,KAAK,KAAK;EAAI,GAAG,KAAK,KAAK;EAAI,GAAG,KAAK,KAAK;EAAI,MAAM,KAAK,MAAM;CAAE;CAEpF,IAAI,MAAM,WAAW,GAAG,MAAM,KAAK,MAAM,EAAE;CAE3C,MAAM,MAAM,IAAI,KAAK,IAAI,SAAS,GAAG,CAAC;CAEtC,MAAM,OAAc,CAAC;CACrB,KAAK,IAAI,IAAI,GAAG,IAAI,QAAQ,KAAK;EAChC,MAAM,QAAQ;GACb,KAAK,MAAM,MAAM,KAAK,IAAI,KAAK,KAAK,GAAG;GACvC,KAAK,MAAM,MAAM,KAAK,IAAI,KAAK,KAAK,GAAG;GACvC,KAAK,MAAM,MAAM,KAAK,IAAI,KAAK,KAAK,GAAG;GACvC,MAAM,KAAK,IAAI,KAAK,KAAK;EAC1B;EACA,KAAK,KAAK,KAAK;CAChB;CACA,OAAO;AACR;;;;;;;;AC1BA,SAAgB,oBAAoB,UAAoB,QAAgB,OAAuB;CAC9F,IAAI,SAAS,SAAS,QACrB,MAAM,IAAI,MAAM,qBAAqB,SAAS,OAAO,SAAS;CAG/D,MAAM,SAAiB,CAAC;CACxB,MAAM,QAAkB,CAAC;CACzB,KAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,KACpC,MAAM,KAAK,KAAK,MAAM,SAAS,EAAE,CAAC,QAAQ,MAAM,CAAC;CAGlD,KAAK,IAAI,IAAI,GAAG,IAAI,SAAS,SAAS,GAAG,KAAK;EAC7C,MAAM,IAAI,MAAM,IAAI,KAAK,MAAM;EAC/B,MAAM,OAAO,SAAS,EAAE,CAAC;EACzB,MAAM,KAAK,SAAS,IAAI,EAAE,CAAC;EAC3B,OAAO,KAAK,GAAG,aAAa,MAAM,IAAI,GAAG,KAAK,CAAC;CAChD;CAEA,OAAO;AACR;;;ACzBA,SAAgB,WAAW,MAAY;CACtC,OAAO,UAAU,KAAK,KAAK,GAAG,IAAI;AACnC;;;;;;ACCA,SAAgB,OAAO,KAAiB;CACvC,IAAI,MAAM;CACV,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KACtB,OAAO,IAAI,IAAI,EAAE;CAElB,OAAO;AACR;AAEA,SAAS,IAAI,GAAW;CACvB,MAAM,KAAK,CAAC,EAAA,CAAG,SAAS,EAAE;CAC1B,OAAO,EAAE,SAAS,IAAI,MAAM,IAAI;AACjC"}

package/cjs/mix-Cs4owSbW.js

@@ -0,0 +1,158 @@
+const require_parse = require("./parse-8mt2OMKf.js");
+// src/color/mix.ts
+/** Index of the hue component, for the polar spaces. */
+const HUE_AT = {
+	__proto__: null,
+	hsl: 0,
+	hwb: 0,
+	lch: 2,
+	oklch: 2
+};
+/**
+* Which components are "analogous" (CSS Color 4 section 4.4): a `none` in one
+* space carries to the analogous component of another. One letter per
+* component; the RGB spaces share `RGB` and the XYZ ones `XYZ`.
+*/
+const ANALOGOUS = {
+	__proto__: null,
+	hsl: "hcl",
+	hwb: "hwk",
+	lab: "lab",
+	lch: "lch",
+	oklab: "lab",
+	oklch: "lch",
+	"xyz-d50": "XYZ",
+	"xyz-d65": "XYZ"
+};
+const analogous = (id) => ANALOGOUS[id] ?? "RGB";
+/** Converts, keeping `none` on components that have an analogous one in the source. */
+function convertKeepingNone(componentsIn, color, space) {
+	const out = require_parse.convertWith(componentsIn, color, space);
+	if (color.colorSpace !== space && color.components.includes(null)) {
+		const from = analogous(color.colorSpace);
+		const to = analogous(space);
+		out.components = out.components.map((c, i) => color.components[from.indexOf(to[i])] === null ? null : c);
+	}
+	return out;
+}
+/**
+* Chroma below which a converted hue is powerless and so `none`, per polar
+* space. Follows colorjs.io, which treats a hue as powerless when both Lab
+* axes are under 1/100000 of their reference extent: 0.8 for Oklab (a, b in
+* -0.4 to 0.4) gives 8e-6, 250 for Lab (-125 to 125) gives 0.0025.
+*/
+const POWERLESS = {
+	__proto__: null,
+	oklch: 8e-6,
+	lch: .0025,
+	hsl: 1e-4
+};
+/**
+* Converts for interpolation. A hue that conversion produced for a gray
+* becomes `none`, so it takes the other color's hue; a hue the author wrote
+* (the color already in `space`) stays as written.
+*/
+function prepare(componentsIn, color, space) {
+	const out = convertKeepingNone(componentsIn, color, space);
+	if (color.colorSpace === space || space !== "hwb" && POWERLESS[space] === void 0) return out;
+	const [, x, y] = out.components;
+	const epsilon = POWERLESS[space];
+	if (typeof x === "number" && (space === "hwb" ? typeof y === "number" && x + y > 99.9999 : epsilon !== void 0 && x < epsilon)) out.components[HUE_AT[space]] = null;
+	return out;
+}
+const HUE_METHODS = [
+	"shorter",
+	"longer",
+	"increasing",
+	"decreasing"
+];
+/** Fixes up two hues so they interpolate by `method` (section 12.4). */
+function fixHues(h1, h2, method) {
+	let a = require_parse.normalizeHue(h1);
+	let b = require_parse.normalizeHue(h2);
+	const d = b - a;
+	if (method === "shorter") {
+		if (d > 180) a += 360;
+		else if (d < -180) b += 360;
+	} else if (method === "longer") {
+		if (d > 0 && d < 180) a += 360;
+		else if (d > -180 && d <= 0) b += 360;
+	} else if (method === "increasing") {
+		if (b < a) b += 360;
+	} else if (method !== "decreasing") throw require_parse.unknownName("hue method", method, HUE_METHODS);
+	else if (a < b) a += 360;
+	return [a, b];
+}
+/**
+* Interpolates two colors the way CSS does (Color 4 section 13): in the space
+* `in`, with premultiplied alpha, `none` taking the other color's value, and
+* the chosen hue method. `t` is the weight of `b`, 0 to 1 (outside it
+* extrapolates). Strings are parsed with `parse`.
+*
+* A hue that conversion makes powerless (chroma under 8e-6 in `oklch`, 0.0025
+* in `lch`, saturation under 1e-4 in `hsl`, whiteness plus blackness filling `hwb`; for example white) becomes `none`, so it takes the other color's
+* hue. A hue you wrote in the target space stays as written.
+*/
+function mix(a, b, t = .5, options = {}) {
+	return mixWith(require_parse.componentsIn, require_parse.toColor(a), require_parse.toColor(b), t, options);
+}
+/**
+* Builds {@link mix} over the spaces given, plus `oklab`, the default `in`, so
+* a bundle contains only those. Give the `in` space too when it is not
+* `oklab`. It takes color objects, not strings, so it does not carry `parse`;
+* pass strings through `parse` first. A color in a space not given throws,
+* naming that space.
+*/
+function createMix(...spaces) {
+	const over = require_parse.componentsOver([require_parse.oklab, ...spaces]);
+	return (a, b, t = .5, options = {}) => mixWith(over, a, b, t, options);
+}
+/** {@link mix} of two colors over the spaces `componentsIn` knows. */
+function mixWith(componentsIn, a, b, t, options) {
+	const space = options.in ?? "oklab";
+	const c1 = prepare(componentsIn, a, space);
+	const c2 = prepare(componentsIn, b, space);
+	const alpha1 = c1.alpha === void 0 ? 1 : c1.alpha;
+	const alpha2 = c2.alpha === void 0 ? 1 : c2.alpha;
+	const a1 = alpha1 ?? alpha2;
+	const p1 = a1 ?? 1;
+	const p2 = alpha2 ?? alpha1 ?? 1;
+	const alpha = p1 * (1 - t) + p2 * t;
+	const hueAt = HUE_AT[space];
+	const method = options.hue ?? "shorter";
+	const components = [];
+	for (let i = 0; i < c1.components.length; i++) {
+		const x = c1.components[i];
+		const y = c2.components[i];
+		const u = x ?? y;
+		const v = y ?? x;
+		if (u === null || v === null) components.push(null);
+		else if (i === hueAt) {
+			const [h1, h2] = fixHues(u, v, method);
+			components.push(require_parse.normalizeHue(h1 * (1 - t) + h2 * t));
+		} else {
+			const premultiplied = u * p1 * (1 - t) + v * p2 * t;
+			components.push(alpha === 0 ? premultiplied : premultiplied / alpha);
+		}
+	}
+	const result = {
+		colorSpace: space,
+		components
+	};
+	if (a1 === null || alpha !== 1) result.alpha = a1 === null ? null : alpha;
+	return result;
+}
+Object.defineProperty(exports, "createMix", {
+	enumerable: true,
+	get: function() {
+		return createMix;
+	}
+});
+Object.defineProperty(exports, "mix", {
+	enumerable: true,
+	get: function() {
+		return mix;
+	}
+});
+
+//# sourceMappingURL=mix-Cs4owSbW.js.map

package/cjs/mix-Cs4owSbW.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mix-Cs4owSbW.js","names":["convertWith","normalizeHue","unknownName","componentsIn","toColor","componentsOver","oklab"],"sources":["../src/color/mix.ts"],"sourcesContent":["import { type ComponentsIn, componentsOver, convertWith } from './convert.js'\nimport { normalizeHue } from './math.js'\nimport { oklab } from './oklab.js'\nimport { toColor } from './parse.js'\nimport { componentsIn } from './spaces.js'\nimport type { Color, ColorSpaceId, Component, Space } from './types.js'\nimport { unknownName } from './unknown-name.js'\n\n/** How `mix` travels around the hue circle (CSS Color 4 section 12.4). */\nexport type HueMethod = 'shorter' | 'longer' | 'increasing' | 'decreasing'\n\n/** Options for `mix` and the function `createMix` returns. */\nexport interface MixOptions {\n\t/** The space to interpolate in. Default `oklab`, which is what `color-mix()` uses. */\n\tin?: ColorSpaceId\n\t/** How hues are interpolated, in the polar spaces. Default `shorter`. */\n\thue?: HueMethod\n}\n\n/** Index of the hue component, for the polar spaces. */\nconst HUE_AT: Record<string, number> = { __proto__: null as never, hsl: 0, hwb: 0, lch: 2, oklch: 2 }\n\n/**\n * Which components are \"analogous\" (CSS Color 4 section 4.4): a `none` in one\n * space carries to the analogous component of another. One letter per\n * component; the RGB spaces share `RGB` and the XYZ ones `XYZ`.\n */\nconst ANALOGOUS: Record<string, string> = {\n\t__proto__: null as never,\n\thsl: 'hcl',\n\thwb: 'hwk',\n\tlab: 'lab',\n\tlch: 'lch',\n\toklab: 'lab',\n\toklch: 'lch',\n\t'xyz-d50': 'XYZ',\n\t'xyz-d65': 'XYZ'\n}\nconst analogous = (id: ColorSpaceId): string => ANALOGOUS[id] ?? 'RGB'\n\n/** Converts, keeping `none` on components that have an analogous one in the source. */\nfunction convertKeepingNone(componentsIn: ComponentsIn, color: Color, space: ColorSpaceId): Color {\n\tconst out = convertWith(componentsIn, color, space)\n\t// Nothing to carry when no component is `none`, the common case.\n\tif (color.colorSpace !== space && color.components.includes(null)) {\n\t\tconst from = analogous(color.colorSpace)\n\t\tconst to = analogous(space)\n\t\tout.components = out.components.map((c, i) => (color.components[from.indexOf(to[i])] === null ? null : c))\n\t}\n\treturn out\n}\n\n/**\n * Chroma below which a converted hue is powerless and so `none`, per polar\n * space. Follows colorjs.io, which treats a hue as powerless when both Lab\n * axes are under 1/100000 of their reference extent: 0.8 for Oklab (a, b in\n * -0.4 to 0.4) gives 8e-6, 250 for Lab (-125 to 125) gives 0.0025.\n */\nconst POWERLESS: Record<string, number> = { __proto__: null as never, oklch: 8e-6, lch: 0.0025, hsl: 1e-4 }\n\n/**\n * Converts for interpolation. A hue that conversion produced for a gray\n * becomes `none`, so it takes the other color's hue; a hue the author wrote\n * (the color already in `space`) stays as written.\n */\nfunction prepare(componentsIn: ComponentsIn, color: Color, space: ColorSpaceId): Color {\n\tconst out = convertKeepingNone(componentsIn, color, space)\n\t// A space with no powerless entry (and not `hwb`) has no hue to lose.\n\tif (color.colorSpace === space || (space !== 'hwb' && POWERLESS[space] === undefined)) return out\n\tconst [, x, y] = out.components\n\tconst epsilon = POWERLESS[space]\n\tconst gray =\n\t\ttypeof x === 'number' &&\n\t\t(space === 'hwb' ? typeof y === 'number' && x + y > 100 - 1e-4 : epsilon !== undefined && x < epsilon)\n\tif (gray) out.components[HUE_AT[space] as number] = null\n\treturn out\n}\n\nconst HUE_METHODS = ['shorter', 'longer', 'increasing', 'decreasing']\n\n/** Fixes up two hues so they interpolate by `method` (section 12.4). */\nfunction fixHues(h1: number, h2: number, method: HueMethod): [number, number] {\n\tlet a = normalizeHue(h1)\n\tlet b = normalizeHue(h2)\n\tconst d = b - a\n\tif (method === 'shorter') {\n\t\tif (d > 180) a += 360\n\t\telse if (d < -180) b += 360\n\t} else if (method === 'longer') {\n\t\tif (d > 0 && d < 180) a += 360\n\t\telse if (d > -180 && d <= 0) b += 360\n\t} else if (method === 'increasing') {\n\t\tif (b < a) b += 360\n\t} else if (method !== 'decreasing') throw unknownName('hue method', method, HUE_METHODS)\n\telse if (a < b) a += 360\n\treturn [a, b]\n}\n\n/**\n * Interpolates two colors the way CSS does (Color 4 section 13): in the space\n * `in`, with premultiplied alpha, `none` taking the other color's value, and\n * the chosen hue method. `t` is the weight of `b`, 0 to 1 (outside it\n * extrapolates). Strings are parsed with `parse`.\n *\n * A hue that conversion makes powerless (chroma under 8e-6 in `oklch`, 0.0025\n * in `lch`, saturation under 1e-4 in `hsl`, whiteness plus blackness filling `hwb`; for example white) becomes `none`, so it takes the other color's\n * hue. A hue you wrote in the target space stays as written.\n */\nexport function mix(a: Color | string, b: Color | string, t = 0.5, options: MixOptions = {}): Color {\n\treturn mixWith(componentsIn, toColor(a), toColor(b), t, options)\n}\n\n/**\n * Builds {@link mix} over the spaces given, plus `oklab`, the default `in`, so\n * a bundle contains only those. Give the `in` space too when it is not\n * `oklab`. It takes color objects, not strings, so it does not carry `parse`;\n * pass strings through `parse` first. A color in a space not given throws,\n * naming that space.\n */\nexport function createMix(...spaces: Space[]): (a: Color, b: Color, t?: number, options?: MixOptions) => Color {\n\tconst over = componentsOver([oklab, ...spaces])\n\treturn (a, b, t = 0.5, options = {}) => mixWith(over, a, b, t, options)\n}\n\n/** {@link mix} of two colors over the spaces `componentsIn` knows. */\nfunction mixWith(componentsIn: ComponentsIn, a: Color, b: Color, t: number, options: MixOptions): Color {\n\tconst space = options.in ?? 'oklab'\n\tconst c1 = prepare(componentsIn, a, space)\n\tconst c2 = prepare(componentsIn, b, space)\n\t// A `none` takes the other side's value; both `none` stays `none`.\n\tconst alpha1 = c1.alpha === undefined ? 1 : c1.alpha\n\tconst alpha2 = c2.alpha === undefined ? 1 : c2.alpha\n\tconst a1 = alpha1 ?? alpha2\n\tconst p1 = a1 ?? 1\n\tconst p2 = alpha2 ?? alpha1 ?? 1\n\tconst alpha = p1 * (1 - t) + p2 * t\n\tconst hueAt = HUE_AT[space]\n\tconst method = options.hue ?? 'shorter'\n\tconst components: Component[] = []\n\tfor (let i = 0; i < c1.components.length; i++) {\n\t\tconst x = c1.components[i] as Component\n\t\tconst y = c2.components[i] as Component\n\t\tconst u = x ?? y\n\t\tconst v = y ?? x\n\t\tif (u === null || v === null) {\n\t\t\tcomponents.push(null)\n\t\t} else if (i === hueAt) {\n\t\t\tconst [h1, h2] = fixHues(u, v, method)\n\t\t\tcomponents.push(normalizeHue(h1 * (1 - t) + h2 * t))\n\t\t} else {\n\t\t\tconst premultiplied = u * p1 * (1 - t) + v * p2 * t\n\t\t\tcomponents.push(alpha === 0 ? premultiplied : premultiplied / alpha)\n\t\t}\n\t}\n\tconst result: Color = { colorSpace: space, components }\n\tif (a1 === null || alpha !== 1) result.alpha = a1 === null ? null : alpha\n\treturn result\n}\n"],"mappings":"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"}

package/cjs/mix-DGlKoUw4.d.ts

@@ -0,0 +1,31 @@
+import { C as ColorSpaceId, S as Color, T as Space } from "./gamut-CG1J2aat.js";
+/** How `mix` travels around the hue circle (CSS Color 4 section 12.4). */
+type HueMethod = 'shorter' | 'longer' | 'increasing' | 'decreasing';
+/** Options for `mix` and the function `createMix` returns. */
+interface MixOptions {
+  /** The space to interpolate in. Default `oklab`, which is what `color-mix()` uses. */
+  in?: ColorSpaceId;
+  /** How hues are interpolated, in the polar spaces. Default `shorter`. */
+  hue?: HueMethod;
+}
+/**
+ * Interpolates two colors the way CSS does (Color 4 section 13): in the space
+ * `in`, with premultiplied alpha, `none` taking the other color's value, and
+ * the chosen hue method. `t` is the weight of `b`, 0 to 1 (outside it
+ * extrapolates). Strings are parsed with `parse`.
+ *
+ * A hue that conversion makes powerless (chroma under 8e-6 in `oklch`, 0.0025
+ * in `lch`, saturation under 1e-4 in `hsl`, whiteness plus blackness filling `hwb`; for example white) becomes `none`, so it takes the other color's
+ * hue. A hue you wrote in the target space stays as written.
+ */
+declare function mix(a: Color | string, b: Color | string, t?: number, options?: MixOptions): Color;
+/**
+ * Builds {@link mix} over the spaces given, plus `oklab`, the default `in`, so
+ * a bundle contains only those. Give the `in` space too when it is not
+ * `oklab`. It takes color objects, not strings, so it does not carry `parse`;
+ * pass strings through `parse` first. A color in a space not given throws,
+ * naming that space.
+ */
+declare function createMix(...spaces: Space[]): (a: Color, b: Color, t?: number, options?: MixOptions) => Color;
+export { mix as i, MixOptions as n, createMix as r, HueMethod as t };
+//# sourceMappingURL=mix-DGlKoUw4.d.ts.map

package/cjs/mix-DGlKoUw4.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mix-DGlKoUw4.d.ts","names":[],"sources":["../src/color/mix.ts"],"mappings":";;KASY;;UAGK;;EAEhB,KAAK;;EAEL,MAAM;;;;;;;;;;;;iBA4FS,IAAI,GAAG,gBAAgB,GAAG,gBAAgB,YAAS,UAAS,aAAkB;;;;;;;;iBAW9E,aAAa,QAAQ,WAAW,GAAG,OAAO,GAAG,OAAO,YAAY,UAAU,eAAe"}

package/cjs/package.json

@@ -1 +1 @@
-{"type":"commonjs"}
+{ "type": "commonjs" }

package/cjs/palette/index.d.ts

@@ -0,0 +1,3 @@
+import { a as validate, c as HarmonyScheme, d as harmony, f as inverse, h as darkVariant, i as ValidateResult, l as HarmonySpace, m as DarkVariantOptions, n as PaletteLike, o as HarmonizeOptions, p as DarkStrategy, r as ValidateOptions, s as HarmonyOptions, t as PaletteIssue, u as harmonize } from "../index-CGKCqRqD.js";
+import { a as semanticPalette, i as SemanticRole, n as SemanticPalette, r as SemanticPaletteOptions, t as RolePair } from "../semantic-CrEIo8tS.js";
+export { type DarkStrategy, type DarkVariantOptions, type HarmonizeOptions, type HarmonyOptions, type HarmonyScheme, type HarmonySpace, type PaletteIssue, type PaletteLike, type RolePair, type SemanticPalette, type SemanticPaletteOptions, type SemanticRole, type ValidateOptions, type ValidateResult, darkVariant, harmonize, harmony, inverse, semanticPalette, validate };

package/cjs/palette/index.js

@@ -0,0 +1,8 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_palette = require("../palette-DyFV_KoJ.js");
+exports.darkVariant = require_palette.darkVariant;
+exports.harmonize = require_palette.harmonize;
+exports.harmony = require_palette.harmony;
+exports.inverse = require_palette.inverse;
+exports.semanticPalette = require_palette.semanticPalette;
+exports.validate = require_palette.validate;

package/cjs/palette-DyFV_KoJ.js

@@ -0,0 +1,332 @@
+const require_parse = require("./parse-8mt2OMKf.js");
+const require_tone = require("./tone-BAhu-QzQ.js");
+const require_contrast = require("./contrast-XjF5Rwui.js");
+// src/palette/dark.ts
+const STRATEGIES = [
+	"mirror",
+	"tone-swap",
+	"lightness-invert"
+];
+/**
+* A dark version of a light scale (ordered light to dark), with the same
+* number of steps.
+* - `mirror`: step n takes the color of step N+1-n, so the scale runs dark to
+*   light and step 1 is the old last step. Colors are unchanged.
+* - `tone-swap`: each color keeps its OKLCH hue and chroma and takes the CIE
+*   L* tone 100 minus its own, as Material swaps tone 40 for 80. Contrast
+*   between two steps is kept roughly the same.
+* - `lightness-invert`: OKLCH lightness is reflected within the scale's own
+*   range, keeping step order, with chroma eased by 10% to curb vibration on
+*   dark backgrounds.
+*/
+function darkVariant(scale, strategy = "tone-swap", options = {}) {
+	const { gamut = "srgb" } = options;
+	if (!STRATEGIES.includes(strategy)) throw require_parse.unknownName("dark variant strategy", strategy, STRATEGIES);
+	if (strategy === "mirror") return [...scale].reverse();
+	if (strategy === "tone-swap") return scale.map((c) => {
+		const [, chroma, hue] = require_parse.componentsIn(c, "oklch");
+		return withAlpha(require_tone.toneColor(100 - require_tone.lstar(c), chroma, hue ?? 0, gamut), c);
+	});
+	const oklch = scale.map((c) => require_parse.componentsIn(c, "oklch"));
+	const ls = oklch.map((c) => c[0]);
+	const sum = Math.min(...ls) + Math.max(...ls);
+	return scale.map((c, i) => {
+		const [l, chroma, hue] = oklch[i];
+		return withAlpha(require_parse.toGamut({
+			colorSpace: "oklch",
+			components: [
+				sum - l,
+				chroma * .9,
+				hue
+			]
+		}, { gamut }), c);
+	});
+}
+function withAlpha(color, from) {
+	return from.alpha === void 0 ? color : {
+		...color,
+		alpha: from.alpha
+	};
+}
+// src/palette/harmony.ts
+/** The hue rotations, in degrees, that each scheme adds to the base color. */
+const SCHEMES = {
+	__proto__: null,
+	complementary: [0, 180],
+	split: [
+		0,
+		150,
+		210
+	],
+	analogous: [
+		-30,
+		0,
+		30
+	],
+	triadic: [
+		0,
+		120,
+		240
+	],
+	tetradic: [
+		0,
+		90,
+		180,
+		270
+	]
+};
+const HUE_SPACES = [
+	"oklch",
+	"lch",
+	"hsl",
+	"hwb"
+];
+const hueIndex = (space) => space === "hsl" || space === "hwb" ? 0 : 2;
+/**
+* The colors of a harmony: `color` rotated around the hue wheel of `space`,
+* with lightness and chroma held, in the order of the scheme's angles
+* (`complementary` 0 and 180; `split` 0, 150, 210; `analogous` -30, 0, 30;
+* `triadic` 0, 120, 240; `tetradic` 0, 90, 180, 270). The color itself is the
+* entry at angle 0, returned as given. Rotated colors are mapped into `gamut`.
+* The same angle looks different in `hsl` and `oklch`, so name the space.
+*/
+function harmony(color, scheme, options = {}) {
+	const { space = "oklch", gamut = "srgb" } = options;
+	const angles = SCHEMES[scheme];
+	if (!angles) throw require_parse.unknownName("harmony scheme", scheme, Object.keys(SCHEMES));
+	if (!HUE_SPACES.includes(space)) throw require_parse.unknownName("harmony space", space, HUE_SPACES);
+	const base = require_parse.toColor(color);
+	const inSpace = require_parse.convert(base, space);
+	const at = hueIndex(space);
+	const hue = inSpace.components[at] ?? 0;
+	return angles.map((angle) => {
+		if (angle === 0) return base;
+		const components = [...inSpace.components];
+		components[at] = require_parse.normalizeHue(hue + angle);
+		return require_parse.toGamut({
+			...inSpace,
+			components
+		}, { gamut });
+	});
+}
+/**
+* Nudges `color`'s hue toward `toward`, as Material's `Blend.harmonize` does:
+* by half the hue difference, but at most 15 degrees, in OKLCH, keeping
+* lightness and chroma. Use it to make a status color feel at home with a
+* brand color without changing its meaning.
+*/
+function harmonize(color, toward, options = {}) {
+	const { max = 15, factor = .5, gamut = "srgb" } = options;
+	const from = require_parse.convert(require_parse.toColor(color), "oklch");
+	const to = require_parse.convert(require_parse.toColor(toward), "oklch");
+	const h0 = from.components[2] ?? 0;
+	const h1 = to.components[2] ?? h0;
+	const diff = require_parse.normalizeHue(h1 - h0 + 180) - 180;
+	const rotation = Math.min(Math.abs(diff) * factor, max) * Math.sign(diff);
+	const components = [...from.components];
+	components[2] = require_parse.normalizeHue(h0 + rotation);
+	return require_parse.toGamut({
+		...from,
+		components
+	}, { gamut });
+}
+/**
+* The opposite of a color. `lightness` flips OKLCH lightness (L becomes 1 - L)
+* and keeps hue and chroma, so light turns dark without changing its hue;
+* `rgb` inverts each sRGB channel, which also turns the hue to its complement.
+* Alpha is kept. The result is mapped into sRGB.
+*/
+function inverse(color, mode = "lightness") {
+	const base = require_parse.toColor(color);
+	if (mode === "rgb") {
+		const c = require_parse.convert(base, "srgb");
+		return require_parse.toGamut({
+			...c,
+			components: c.components.map((x) => 1 - x)
+		});
+	}
+	const c = require_parse.convert(base, "oklch");
+	return require_parse.toGamut({
+		...c,
+		components: [
+			1 - c.components[0],
+			c.components[1],
+			c.components[2]
+		]
+	});
+}
+// src/palette/semantic.ts
+const BG_TONE = {
+	primary: [40, 80],
+	primaryContainer: [90, 30],
+	surface: [98, 6],
+	surfaceVariant: [90, 30]
+};
+const FG_TONE = {
+	primary: [100, 20],
+	primaryContainer: [10, 90],
+	surface: [10, 90],
+	surfaceVariant: [30, 80]
+};
+const STATUS = {
+	success: 145,
+	warning: 85,
+	danger: 25,
+	info: 240
+};
+/**
+* A role-based palette from one brand color: primary and its container, four
+* status colors (success, warning, danger, info) harmonized toward the brand's
+* hue, a surface and a variant tinted by the brand hue, and an outline. Every
+* pair is built from L* tones, so a 50-tone gap or more reaches about 4.5 on
+* WCAG 2 (the worst pair, 100 on 50, gives 4.48). Each pair records the ratio
+* it reached; a foreground that falls short of `target` is replaced by the
+* closest one that meets it, and `validate` reports any that cannot.
+*/
+function semanticPalette(options) {
+	const { mode = "light", contrast = "wcag2", target = 4.5, gamut = "srgb" } = options;
+	const fn = require_contrast.pick(contrast);
+	const dark = require_parse.checkMode(mode) === "dark";
+	const i = dark ? 1 : 0;
+	const brand = require_parse.toColor(options.brand);
+	const [, c, h] = require_parse.componentsIn(brand, "oklch");
+	const hue = h ?? 0;
+	const chroma = Math.max(c, .04);
+	const tint = .015;
+	const pair = (bg, fgTone, fgChroma, need = target) => {
+		let fg = require_tone.toneColor(fgTone, fgChroma, hue, gamut);
+		let ratio = Math.abs(fn(fg, bg));
+		if (ratio < need) {
+			const found = require_contrast.findContrast(bg, need, {
+				contrast: fn,
+				chroma: fgChroma,
+				hue
+			});
+			fg = found.color;
+			ratio = Math.abs(found.contrast);
+		}
+		return {
+			bg,
+			fg,
+			ratio,
+			target: need
+		};
+	};
+	const status = (name) => {
+		const base = require_tone.toneColor(BG_TONE.primary[i], .14, STATUS[name], gamut);
+		return pair(harmonize(base, brand, { gamut }), FG_TONE.primary[i], .02);
+	};
+	const surface = require_tone.toneColor(BG_TONE.surface[i], tint, hue, gamut);
+	const outline = pair(surface, dark ? 60 : 50, tint, 3);
+	return {
+		meta: {
+			mode,
+			contrast: fn.algorithm ?? "custom",
+			target,
+			gamut
+		},
+		scales: {
+			primary: require_tone.tonalPalette(hue, chroma, void 0, { gamut }),
+			neutral: require_tone.tonalPalette(hue, tint, void 0, { gamut })
+		},
+		roles: {
+			primary: pair(require_tone.toneColor(BG_TONE.primary[i], chroma, hue, gamut), FG_TONE.primary[i], .02),
+			primaryContainer: pair(require_tone.toneColor(BG_TONE.primaryContainer[i], chroma, hue, gamut), FG_TONE.primaryContainer[i], .02),
+			success: status("success"),
+			warning: status("warning"),
+			danger: status("danger"),
+			info: status("info"),
+			surface: pair(surface, FG_TONE.surface[i], tint),
+			surfaceVariant: pair(require_tone.toneColor(BG_TONE.surfaceVariant[i], tint, hue, gamut), FG_TONE.surfaceVariant[i], tint),
+			outline
+		}
+	};
+}
+// src/palette/validate.ts
+/**
+* Checks a palette and lists what is wrong, so an agent can fix it:
+* - `contrast`: a role pair whose measured contrast is under its target;
+* - `lightness`: a scale whose OKLCH lightness does not change steadily in one
+*   direction from one step to the next;
+* - `gamut`: a color outside the gamut (it would be clipped on display).
+*/
+function validate(palette, options = {}) {
+	const { contrast = "wcag2", target = 4.5, gamut = "srgb" } = options;
+	const fn = require_contrast.pick(contrast);
+	const issues = [];
+	const outside = (path, color) => {
+		if (!require_parse.inGamut(color, gamut)) issues.push({
+			kind: "gamut",
+			path,
+			message: `${path} is outside ${gamut}`
+		});
+	};
+	for (const [name, p] of Object.entries(palette.roles ?? {})) {
+		const need = p.target ?? target;
+		const ratio = Math.abs(fn(p.fg, p.bg));
+		if (ratio < need) issues.push({
+			kind: "contrast",
+			path: `roles.${name}`,
+			message: `roles.${name} reaches ${ratio.toFixed(2)}, needs ${need}`
+		});
+		outside(`roles.${name}.bg`, p.bg);
+		outside(`roles.${name}.fg`, p.fg);
+	}
+	for (const [name, scale] of Object.entries(palette.scales ?? {})) {
+		const ls = scale.map((c) => require_parse.componentsIn(c, "oklch")[0]);
+		const steps = ls.slice(1).map((l, k) => l - ls[k]);
+		const direction = Math.sign(steps.find((d) => d !== 0) ?? 0);
+		steps.forEach((d, k) => {
+			if (Math.sign(d) !== direction || Math.abs(d) < 1e-9) issues.push({
+				kind: "lightness",
+				path: `scales.${name}[${k + 1}]`,
+				message: `scales.${name} lightness does not change steadily at step ${k + 1}`
+			});
+		});
+		scale.forEach((c, k) => {
+			outside(`scales.${name}[${k}]`, c);
+		});
+	}
+	return {
+		ok: issues.length === 0,
+		issues
+	};
+}
+Object.defineProperty(exports, "darkVariant", {
+	enumerable: true,
+	get: function() {
+		return darkVariant;
+	}
+});
+Object.defineProperty(exports, "harmonize", {
+	enumerable: true,
+	get: function() {
+		return harmonize;
+	}
+});
+Object.defineProperty(exports, "harmony", {
+	enumerable: true,
+	get: function() {
+		return harmony;
+	}
+});
+Object.defineProperty(exports, "inverse", {
+	enumerable: true,
+	get: function() {
+		return inverse;
+	}
+});
+Object.defineProperty(exports, "semanticPalette", {
+	enumerable: true,
+	get: function() {
+		return semanticPalette;
+	}
+});
+Object.defineProperty(exports, "validate", {
+	enumerable: true,
+	get: function() {
+		return validate;
+	}
+});
+
+//# sourceMappingURL=palette-DyFV_KoJ.js.map