color-map 2.2.0 → 2.3.1

package/esm/index.js

@@ -1,5 +1,54 @@
-import { createColors } from "./createColors.js";
-import { createColorsFromMap } from "./createColorsFromMap.js";
-import { rgbaString } from "./rgbaString.js";
-import { rgbHex } from "./rgbHex.js";
-export { createColors, createColorsFromMap, rgbHex, rgbaString };
+import { createColors as createColors$1 } from "./legacy/createColors.js";
+import { createColorsFromMap as createColorsFromMap$1 } from "./legacy/createColorsFromMap.js";
+import { rgbaString as rgbaString$1 } from "./legacy/rgbaString.js";
+import { rgbHex as rgbHex$1 } from "./legacy/rgbHex.js";
+import { a98Rgb } from "./color/a98-rgb.js";
+import { fromArgb, toArgb } from "./color/argb.js";
+import { convertComponents, createConverter } from "./color/convert.js";
+import { oklab } from "./color/oklab.js";
+import { displayP3 } from "./color/display-p3.js";
+import { displayP3Linear } from "./color/display-p3-linear.js";
+import { srgb } from "./color/srgb.js";
+import { hsl } from "./color/hsl.js";
+import { hwb } from "./color/hwb.js";
+import { lab } from "./color/lab.js";
+import { lch } from "./color/lch.js";
+import { oklch } from "./color/oklch.js";
+import { xyzD50 } from "./color/xyz-d50.js";
+import { prophotoRgb } from "./color/prophoto-rgb.js";
+import { rec2020 } from "./color/rec2020.js";
+import { srgbLinear } from "./color/srgb-linear.js";
+import { xyzD65 } from "./color/xyz-d65.js";
+import { convert, spaces } from "./color/spaces.js";
+import { createDeltaEOk, createEquals, deltaEOk, equals } from "./color/compare.js";
+import { createInGamut, createToGamut, inGamut, toGamut } from "./color/gamut.js";
+import { parse } from "./color/parse.js";
+import { contrast, createContrast, createFindContrast, createMeets, createOnColor, findContrast, meets, onColor, wcag2 } from "./color/contrast.js";
+import { parseExpr } from "./color/expr.js";
+import { createMix, mix } from "./color/mix.js";
+import { resolve } from "./color/resolve.js";
+import { createToHex, toCss, toHex } from "./color/serialize.js";
+import { MATERIAL_TONES, lstar, tonalPalette, toneColor } from "./scale/tone.js";
+import { darkVariant } from "./palette/dark.js";
+import { harmonize, harmony, inverse } from "./palette/harmony.js";
+import { semanticPalette } from "./palette/semantic.js";
+import { validate } from "./palette/validate.js";
+import { scaleFromBrand } from "./scale/brand.js";
+import { createContrastScale } from "./scale/contrast-scale.js";
+import { createGradient } from "./scale/gradient.js";
+import { createScale } from "./scale/scale.js";
+import { toCssVariables } from "./tokens/css.js";
+import { toDtcg, toDtcgValue } from "./tokens/dtcg.js";
+import { toTailwindTheme } from "./tokens/tailwind.js";
+// src/index.ts
+/** @deprecated Import it from `color-map/legacy`. The root stops exporting it in 3.0. */
+const createColors = createColors$1;
+/** @deprecated Use `createGradient` from `color-map`, or import it from `color-map/legacy`. The root stops exporting it in 3.0. */
+const createColorsFromMap = createColorsFromMap$1;
+/** @deprecated Import it from `color-map/legacy`, or use `toHex` from `color-map`. The root stops exporting it in 3.0. */
+const rgbHex = rgbHex$1;
+/** @deprecated Import it from `color-map/legacy`, or use `toCss` from `color-map`. The root stops exporting it in 3.0. */
+const rgbaString = rgbaString$1;
+export { MATERIAL_TONES, a98Rgb, contrast, convert, convertComponents, createColors, createColorsFromMap, createContrast, createContrastScale, createConverter, createDeltaEOk, createEquals, createFindContrast, createGradient, createInGamut, createMeets, createMix, createOnColor, createScale, createToGamut, createToHex, darkVariant, deltaEOk, displayP3, displayP3Linear, equals, findContrast, fromArgb, harmonize, harmony, hsl, hwb, inGamut, inverse, lab, lch, lstar, meets, mix, oklab, oklch, onColor, parse, parseExpr, prophotoRgb, rec2020, resolve, rgbHex, rgbaString, scaleFromBrand, semanticPalette, spaces, srgb, srgbLinear, toArgb, toCss, toCssVariables, toDtcg, toDtcgValue, toGamut, toHex, toTailwindTheme, tonalPalette, toneColor, validate, wcag2, xyzD50, xyzD65 };
+
+//# sourceMappingURL=index.js.map

package/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["legacyCreateColors","legacyCreateColorsFromMap","legacyRgbHex","legacyRgbaString"],"sources":["../src/index.ts"],"sourcesContent":["// The root re-exports the four subpaths, which stay the stable contract. The\n// legacy names stay here through 2.x, deprecated in favor of `color-map/legacy`,\n// and leave the root in 3.0. They are aliases rather than `export *` so that the\n// deprecation shows only at the root and not in `color-map/legacy`.\nimport {\n\ttype Alpha as LegacyAlpha,\n\ttype ColorMap as LegacyColorMap,\n\ttype RGB as LegacyRGB,\n\ttype RGBA as LegacyRGBA,\n\tcreateColors as legacyCreateColors,\n\tcreateColorsFromMap as legacyCreateColorsFromMap,\n\trgbaString as legacyRgbaString,\n\trgbHex as legacyRgbHex\n} from './legacy/index.js'\n\nexport * from './color/index.js'\nexport * from './palette/index.js'\nexport * from './scale/index.js'\nexport * from './tokens/index.js'\n\n/** @deprecated Import it from `color-map/legacy`. The root stops exporting it in 3.0. */\nexport const createColors = legacyCreateColors\n/** @deprecated Use `createGradient` from `color-map`, or import it from `color-map/legacy`. The root stops exporting it in 3.0. */\nexport const createColorsFromMap = legacyCreateColorsFromMap\n/** @deprecated Import it from `color-map/legacy`, or use `toHex` from `color-map`. The root stops exporting it in 3.0. */\nexport const rgbHex = legacyRgbHex\n/** @deprecated Import it from `color-map/legacy`, or use `toCss` from `color-map`. The root stops exporting it in 3.0. */\nexport const rgbaString = legacyRgbaString\n\n/** @deprecated Import it from `color-map/legacy`. The root stops exporting it in 3.0. */\nexport type Alpha = LegacyAlpha\n/** @deprecated Import it from `color-map/legacy`. The root stops exporting it in 3.0. */\nexport type ColorMap = LegacyColorMap\n/** @deprecated Import it from `color-map/legacy`. The root stops exporting it in 3.0. */\nexport type RGB = LegacyRGB\n/** @deprecated Import it from `color-map/legacy`. The root stops exporting it in 3.0. */\nexport type RGBA = LegacyRGBA\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqBA,MAAa,eAAeA;;AAE5B,MAAa,sBAAsBC;;AAEnC,MAAa,SAASC;;AAEtB,MAAa,aAAaC"}

package/esm/legacy/createColors.d.ts

@@ -0,0 +1,9 @@
+import { Alpha, RGB, RGBA } from "./interfaces.js";
+/**
+ * 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`.
+ */
+export declare function createColors(from: RGB | RGBA, to: RGB | RGBA, shades: number, alpha?: Alpha): RGBA[];
+//# sourceMappingURL=createColors.d.ts.map

package/esm/legacy/createColors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createColors.d.ts","names":[],"sources":["../../src/legacy/createColors.ts"],"mappings":";;;;;;;wBAQgB,aACf,MAAM,MAAM,MACZ,IAAI,MAAM,MACV,gBACA,QAAO,QAIL"}

package/esm/{createColors.js → legacy/createColors.js}

@@ -1,4 +1,10 @@
-//#region ts/createColors.ts
+// 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 = [
@@ -21,7 +27,6 @@ function createColors(from, to, shades, alpha = [from.length === 4 ? from[3] : t
 	}
 	return rgba;
 }
-//#endregion
 export { createColors };
 
 //# sourceMappingURL=createColors.js.map

package/esm/legacy/createColors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createColors.js","names":[],"sources":["../../src/legacy/createColors.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"],"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"}

package/esm/legacy/createColorsFromMap.d.ts

@@ -0,0 +1,9 @@
+import { Alpha, ColorMap, RGBA } from "./interfaces.js";
+/**
+ * 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.
+ */
+export declare function createColorsFromMap(colormap: ColorMap, shades: number, alpha?: Alpha): RGBA[];
+//# sourceMappingURL=createColorsFromMap.d.ts.map

package/esm/legacy/createColorsFromMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createColorsFromMap.d.ts","names":[],"sources":["../../src/legacy/createColorsFromMap.ts"],"mappings":";;;;;;;wBASgB,oBAAoB,UAAU,UAAU,gBAAgB,QAAQ,QAAQ"}

package/esm/{createColorsFromMap.js → legacy/createColorsFromMap.js}

@@ -1,7 +1,10 @@
 import { createColors } from "./createColors.js";
-//#region ts/createColorsFromMap.ts
+// 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.`);
@@ -16,7 +19,6 @@ function createColorsFromMap(colormap, shades, alpha) {
 	}
 	return result;
 }
-//#endregion
 export { createColorsFromMap };
 
 //# sourceMappingURL=createColorsFromMap.js.map

package/esm/legacy/createColorsFromMap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createColorsFromMap.js","names":[],"sources":["../../src/legacy/createColorsFromMap.ts"],"sourcesContent":["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"],"mappings":";;;;;;;;AASA,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"}

package/esm/legacy/index.d.ts

@@ -0,0 +1,6 @@
+import { createColors } from "./createColors.js";
+import { createColorsFromMap } from "./createColorsFromMap.js";
+import { Alpha, ColorMap, RGB, RGBA } from "./interfaces.js";
+import { rgbaString } from "./rgbaString.js";
+import { rgbHex } from "./rgbHex.js";
+export { type Alpha, type ColorMap, type RGB, type RGBA, createColors, createColorsFromMap, rgbHex, rgbaString };

package/esm/legacy/index.js

@@ -0,0 +1,5 @@
+import { createColors } from "./createColors.js";
+import { createColorsFromMap } from "./createColorsFromMap.js";
+import { rgbaString } from "./rgbaString.js";
+import { rgbHex } from "./rgbHex.js";
+export { createColors, createColorsFromMap, rgbHex, rgbaString };

package/esm/legacy/interfaces.d.ts

@@ -0,0 +1,19 @@
+/** Red, green and blue as whole numbers in 0 to 255. */
+export type RGB = [number, number, number];
+/** Red, green and blue as whole numbers in 0 to 255, then alpha in 0 to 1. */
+export type RGBA = [number, number, number, number];
+/** The alpha at the start and at the end of a run of colors, each in 0 to 1. */
+export type Alpha = [number, number];
+/** The segments of a gradient, in order, for `createColorsFromMap`. Each has an `index` and an `rgb`. */
+export type ColorMap = {
+  /**
+   * Defines how fast or slow the `rgb` values will change from one segment to the next.
+   * i.e. the steepness of the gradient between two segments.
+   */
+  index: number;
+  /**
+   * RGB or RGBA. if RGBA, this alpha will be used instead of the alpha specified in the call.
+   */
+  rgb: RGB | RGBA;
+}[];
+//# sourceMappingURL=interfaces.d.ts.map

package/esm/legacy/interfaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interfaces.d.ts","names":[],"sources":["../../src/legacy/interfaces.ts"],"mappings":";YACY;;YAEA;;YAEA;;YAGA;;;;;EAKX;;;;EAIA,KAAK,MAAM"}

package/esm/{rgbHex.d.ts → legacy/rgbHex.d.ts}

@@ -1,10 +1,7 @@
 import { RGB, RGBA } from "./interfaces.js";
-//#region ts/rgbHex.d.ts
 /**
  * Convert `RGB` to `#rgb`
  * JavaScript note: no check for array length, use it properly.
  */
-declare function rgbHex(rgb: RGB | RGBA): string;
-//#endregion
-export { rgbHex };
+export declare function rgbHex(rgb: RGB | RGBA): string;
 //# sourceMappingURL=rgbHex.d.ts.map

package/esm/legacy/rgbHex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rgbHex.d.ts","names":[],"sources":["../../src/legacy/rgbHex.ts"],"mappings":";;;;;wBAMgB,OAAO,KAAK,MAAM"}

package/esm/{rgbHex.js → legacy/rgbHex.js}

@@ -1,4 +1,4 @@
-//#region ts/rgbHex.ts
+// src/legacy/rgbHex.ts
 /**
 * Convert `RGB` to `#rgb`
 * JavaScript note: no check for array length, use it properly.
@@ -12,7 +12,6 @@ function d2h(d) {
 	const s = (+d).toString(16);
 	return s.length < 2 ? "0" + s : s;
 }
-//#endregion
 export { rgbHex };
 
 //# sourceMappingURL=rgbHex.js.map

package/esm/legacy/rgbHex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rgbHex.js","names":[],"sources":["../../src/legacy/rgbHex.ts"],"sourcesContent":["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":";;;;;AAMA,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/esm/legacy/rgbaString.d.ts

@@ -0,0 +1,4 @@
+import { RGBA } from "./interfaces.js";
+/** Formats an `RGBA` as a CSS `rgba(r,g,b,a)` string, with no spaces. */
+export declare function rgbaString(rgba: RGBA): string;
+//# sourceMappingURL=rgbaString.d.ts.map

package/esm/{rgbaString.d.ts.map → legacy/rgbaString.d.ts.map}

@@ -1 +1 @@
-{"version":3,"file":"rgbaString.d.ts","names":[],"sources":["../ts/rgbaString.ts"],"mappings":";;iBAEgB,WAAW,MAAM"}
+{"version":3,"file":"rgbaString.d.ts","names":[],"sources":["../../src/legacy/rgbaString.ts"],"mappings":";;wBAGgB,WAAW,MAAM"}

package/esm/legacy/rgbaString.js

@@ -0,0 +1,8 @@
+// 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(",") + ")";
+}
+export { rgbaString };
+
+//# sourceMappingURL=rgbaString.js.map

package/esm/legacy/rgbaString.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"rgbaString.js","names":[],"sources":["../../src/legacy/rgbaString.ts"],"sourcesContent":["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"],"mappings":";;AAGA,SAAgB,WAAW,MAAY;CACtC,OAAO,UAAU,KAAK,KAAK,GAAG,IAAI;AACnC"}

package/esm/palette/dark.d.ts

@@ -0,0 +1,23 @@
+import { GamutId } from "../color/gamut.js";
+import { Color } from "../color/types.js";
+/** How `darkVariant` builds a dark scale from a light one: `mirror`, `tone-swap` or `lightness-invert`. */
+export type DarkStrategy = 'mirror' | 'tone-swap' | 'lightness-invert';
+/** Options for `darkVariant`. */
+export interface DarkVariantOptions {
+  /** The gamut every color must fit. Default `srgb`. */
+  gamut?: GamutId;
+}
+/**
+ * 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.
+ */
+export declare function darkVariant(scale: readonly Color[], strategy?: DarkStrategy, options?: DarkVariantOptions): Color[];
+//# sourceMappingURL=dark.d.ts.map

package/esm/palette/dark.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dark.d.ts","names":[],"sources":["../../src/palette/dark.ts"],"mappings":";;;YAOY;;iBAKK;;EAEhB,QAAQ;;;;;;;;;;;;;;wBAeO,YACf,gBAAgB,SAChB,WAAU,cACV,UAAS,qBACP"}

package/esm/palette/dark.js

@@ -0,0 +1,54 @@
+import { toGamut } from "../color/gamut.js";
+import { componentsIn } from "../color/spaces.js";
+import { unknownName } from "../color/unknown-name.js";
+import { lstar, toneColor } from "../scale/tone.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 unknownName("dark variant strategy", strategy, STRATEGIES);
+	if (strategy === "mirror") return [...scale].reverse();
+	if (strategy === "tone-swap") return scale.map((c) => {
+		const [, chroma, hue] = componentsIn(c, "oklch");
+		return withAlpha(toneColor(100 - lstar(c), chroma, hue ?? 0, gamut), c);
+	});
+	const oklch = scale.map((c) => 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(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
+	};
+}
+export { darkVariant };
+
+//# sourceMappingURL=dark.js.map

package/esm/palette/dark.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dark.js","names":[],"sources":["../../src/palette/dark.ts"],"sourcesContent":["import { type GamutId, toGamut } from '../color/gamut.js'\nimport { componentsIn } from '../color/spaces.js'\nimport type { Color } from '../color/types.js'\nimport { unknownName } from '../color/unknown-name.js'\nimport { lstar, toneColor } from '../scale/tone.js'\n\n/** How `darkVariant` builds a dark scale from a light one: `mirror`, `tone-swap` or `lightness-invert`. */\nexport type DarkStrategy = 'mirror' | 'tone-swap' | 'lightness-invert'\n\nconst STRATEGIES: readonly string[] = ['mirror', 'tone-swap', 'lightness-invert']\n\n/** Options for `darkVariant`. */\nexport interface DarkVariantOptions {\n\t/** The gamut every color must fit. Default `srgb`. */\n\tgamut?: GamutId\n}\n\n/**\n * A dark version of a light scale (ordered light to dark), with the same\n * number of steps.\n * - `mirror`: step n takes the color of step N+1-n, so the scale runs dark to\n *   light and step 1 is the old last step. Colors are unchanged.\n * - `tone-swap`: each color keeps its OKLCH hue and chroma and takes the CIE\n *   L* tone 100 minus its own, as Material swaps tone 40 for 80. Contrast\n *   between two steps is kept roughly the same.\n * - `lightness-invert`: OKLCH lightness is reflected within the scale's own\n *   range, keeping step order, with chroma eased by 10% to curb vibration on\n *   dark backgrounds.\n */\nexport function darkVariant(\n\tscale: readonly Color[],\n\tstrategy: DarkStrategy = 'tone-swap',\n\toptions: DarkVariantOptions = {}\n): Color[] {\n\tconst { gamut = 'srgb' } = options\n\tif (!STRATEGIES.includes(strategy)) throw unknownName('dark variant strategy', strategy, STRATEGIES)\n\tif (strategy === 'mirror') return [...scale].reverse()\n\tif (strategy === 'tone-swap') {\n\t\treturn scale.map((c) => {\n\t\t\tconst [, chroma, hue] = componentsIn(c, 'oklch') as [number, number, number | null]\n\t\t\treturn withAlpha(toneColor(100 - lstar(c), chroma, hue ?? 0, gamut), c)\n\t\t})\n\t}\n\tconst oklch = scale.map((c) => componentsIn(c, 'oklch') as [number, number, number | null])\n\tconst ls = oklch.map((c) => c[0])\n\tconst sum = Math.min(...ls) + Math.max(...ls)\n\treturn scale.map((c, i) => {\n\t\tconst [l, chroma, hue] = oklch[i] as [number, number, number | null]\n\t\treturn withAlpha(toGamut({ colorSpace: 'oklch', components: [sum - l, chroma * 0.9, hue] }, { gamut }), c)\n\t})\n}\n\nfunction withAlpha(color: Color, from: Color): Color {\n\treturn from.alpha === undefined ? color : { ...color, alpha: from.alpha }\n}\n"],"mappings":";;;;;AASA,MAAM,aAAgC;CAAC;CAAU;CAAa;AAAkB;;;;;;;;;;;;;AAoBhF,SAAgB,YACf,OACA,WAAyB,aACzB,UAA8B,CAAC,GACrB;CACV,MAAM,EAAE,QAAQ,WAAW;CAC3B,IAAI,CAAC,WAAW,SAAS,QAAQ,GAAG,MAAM,YAAY,yBAAyB,UAAU,UAAU;CACnG,IAAI,aAAa,UAAU,OAAO,CAAC,GAAG,KAAK,CAAC,CAAC,QAAQ;CACrD,IAAI,aAAa,aAChB,OAAO,MAAM,KAAK,MAAM;EACvB,MAAM,GAAG,QAAQ,OAAO,aAAa,GAAG,OAAO;EAC/C,OAAO,UAAU,UAAU,MAAM,MAAM,CAAC,GAAG,QAAQ,OAAO,GAAG,KAAK,GAAG,CAAC;CACvE,CAAC;CAEF,MAAM,QAAQ,MAAM,KAAK,MAAM,aAAa,GAAG,OAAO,CAAoC;CAC1F,MAAM,KAAK,MAAM,KAAK,MAAM,EAAE,EAAE;CAChC,MAAM,MAAM,KAAK,IAAI,GAAG,EAAE,IAAI,KAAK,IAAI,GAAG,EAAE;CAC5C,OAAO,MAAM,KAAK,GAAG,MAAM;EAC1B,MAAM,CAAC,GAAG,QAAQ,OAAO,MAAM;EAC/B,OAAO,UAAU,QAAQ;GAAE,YAAY;GAAS,YAAY;IAAC,MAAM;IAAG,SAAS;IAAK;GAAG;EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,CAAC;CAC1G,CAAC;AACF;AAEA,SAAS,UAAU,OAAc,MAAoB;CACpD,OAAO,KAAK,UAAU,KAAA,IAAY,QAAQ;EAAE,GAAG;EAAO,OAAO,KAAK;CAAM;AACzE"}

package/esm/palette/harmony.d.ts

@@ -0,0 +1,56 @@
+import { GamutId } from "../color/gamut.js";
+import { Color } from "../color/types.js";
+type ColorInput = Color | string;
+/** The hue rotations, in degrees, that each scheme adds to the base color. */
+declare const SCHEMES: {
+  readonly __proto__: null;
+  readonly complementary: readonly [0, 180];
+  readonly split: readonly [0, 150, 210];
+  readonly analogous: readonly [-30, 0, 30];
+  readonly triadic: readonly [0, 120, 240];
+  readonly tetradic: readonly [0, 90, 180, 270];
+};
+/** A harmony scheme `harmony` accepts: `complementary`, `split`, `analogous`, `triadic` or `tetradic`. */
+export type HarmonyScheme = keyof typeof SCHEMES;
+/** Spaces with a hue channel that a scheme can rotate in. */
+export type HarmonySpace = 'oklch' | 'lch' | 'hsl' | 'hwb';
+/** Options for `harmony`. */
+export interface HarmonyOptions {
+  /** The space whose hue is rotated. Default `oklch`, which keeps perceived lightness steady. */
+  space?: HarmonySpace;
+  /** The gamut every color must fit. Default `srgb`. */
+  gamut?: GamutId;
+}
+/**
+ * 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.
+ */
+export declare function harmony(color: ColorInput, scheme: HarmonyScheme, options?: HarmonyOptions): Color[];
+/** Options for `harmonize`. */
+export interface HarmonizeOptions {
+  /** The most the hue may move, in degrees. Default 15. */
+  max?: number;
+  /** The share of the hue difference to move. Default 0.5. */
+  factor?: number;
+  /** The gamut the result must fit. Default `srgb`. */
+  gamut?: GamutId;
+}
+/**
+ * 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.
+ */
+export declare function harmonize(color: ColorInput, toward: ColorInput, options?: HarmonizeOptions): Color;
+/**
+ * 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.
+ */
+export declare function inverse(color: ColorInput, mode?: 'lightness' | 'rgb'): Color;
+//# sourceMappingURL=harmony.d.ts.map

package/esm/palette/harmony.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"harmony.d.ts","names":[],"sources":["../../src/palette/harmony.ts"],"mappings":";;KAOK,aAAa;;cAGZ;WACL;WACA;WACA;WACA;WACA;WACA;;;YAIW,6BAA6B;;YAG7B;;iBAGK;;EAEhB,QAAQ;;EAER,QAAQ;;;;;;;;;;wBAeO,QAAQ,OAAO,YAAY,QAAQ,eAAe,UAAS,iBAAsB;;iBAkBhF;;EAEhB;;EAEA;;EAEA,QAAQ;;;;;;;;wBASO,UAAU,OAAO,YAAY,QAAQ,YAAY,UAAS,mBAAwB;;;;;;;wBAoBlF,QAAQ,OAAO,YAAY,6BAA0C"}

package/esm/palette/harmony.js

@@ -0,0 +1,115 @@
+import { toGamut } from "../color/gamut.js";
+import { normalizeHue } from "../color/math.js";
+import { toColor } from "../color/parse.js";
+import { convert } from "../color/spaces.js";
+import { unknownName } from "../color/unknown-name.js";
+// 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 unknownName("harmony scheme", scheme, Object.keys(SCHEMES));
+	if (!HUE_SPACES.includes(space)) throw unknownName("harmony space", space, HUE_SPACES);
+	const base = toColor(color);
+	const inSpace = 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] = normalizeHue(hue + angle);
+		return 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 = convert(toColor(color), "oklch");
+	const to = convert(toColor(toward), "oklch");
+	const h0 = from.components[2] ?? 0;
+	const h1 = to.components[2] ?? h0;
+	const diff = normalizeHue(h1 - h0 + 180) - 180;
+	const rotation = Math.min(Math.abs(diff) * factor, max) * Math.sign(diff);
+	const components = [...from.components];
+	components[2] = normalizeHue(h0 + rotation);
+	return 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 = toColor(color);
+	if (mode === "rgb") {
+		const c = convert(base, "srgb");
+		return toGamut({
+			...c,
+			components: c.components.map((x) => 1 - x)
+		});
+	}
+	const c = convert(base, "oklch");
+	return toGamut({
+		...c,
+		components: [
+			1 - c.components[0],
+			c.components[1],
+			c.components[2]
+		]
+	});
+}
+export { harmonize, harmony, inverse };
+
+//# sourceMappingURL=harmony.js.map

package/esm/palette/harmony.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"harmony.js","names":[],"sources":["../../src/palette/harmony.ts"],"sourcesContent":["import { type GamutId, toGamut } from '../color/gamut.js'\nimport { normalizeHue } from '../color/math.js'\nimport { toColor } from '../color/parse.js'\nimport { convert } from '../color/spaces.js'\nimport type { Color } from '../color/types.js'\nimport { unknownName } from '../color/unknown-name.js'\n\ntype ColorInput = Color | string\n\n/** The hue rotations, in degrees, that each scheme adds to the base color. */\nconst SCHEMES = {\n\t__proto__: null,\n\tcomplementary: [0, 180],\n\tsplit: [0, 150, 210],\n\tanalogous: [-30, 0, 30],\n\ttriadic: [0, 120, 240],\n\ttetradic: [0, 90, 180, 270]\n} as const\n\n/** A harmony scheme `harmony` accepts: `complementary`, `split`, `analogous`, `triadic` or `tetradic`. */\nexport type HarmonyScheme = keyof typeof SCHEMES\n\n/** Spaces with a hue channel that a scheme can rotate in. */\nexport type HarmonySpace = 'oklch' | 'lch' | 'hsl' | 'hwb'\n\n/** Options for `harmony`. */\nexport interface HarmonyOptions {\n\t/** The space whose hue is rotated. Default `oklch`, which keeps perceived lightness steady. */\n\tspace?: HarmonySpace\n\t/** The gamut every color must fit. Default `srgb`. */\n\tgamut?: GamutId\n}\n\nconst HUE_SPACES: readonly string[] = ['oklch', 'lch', 'hsl', 'hwb']\n\nconst hueIndex = (space: HarmonySpace): number => (space === 'hsl' || space === 'hwb' ? 0 : 2)\n\n/**\n * The colors of a harmony: `color` rotated around the hue wheel of `space`,\n * with lightness and chroma held, in the order of the scheme's angles\n * (`complementary` 0 and 180; `split` 0, 150, 210; `analogous` -30, 0, 30;\n * `triadic` 0, 120, 240; `tetradic` 0, 90, 180, 270). The color itself is the\n * entry at angle 0, returned as given. Rotated colors are mapped into `gamut`.\n * The same angle looks different in `hsl` and `oklch`, so name the space.\n */\nexport function harmony(color: ColorInput, scheme: HarmonyScheme, options: HarmonyOptions = {}): Color[] {\n\tconst { space = 'oklch', gamut = 'srgb' } = options\n\tconst angles = SCHEMES[scheme]\n\tif (!angles) throw unknownName('harmony scheme', scheme, Object.keys(SCHEMES))\n\tif (!HUE_SPACES.includes(space)) throw unknownName('harmony space', space, HUE_SPACES)\n\tconst base = toColor(color)\n\tconst inSpace = convert(base, space)\n\tconst at = hueIndex(space)\n\tconst hue = (inSpace.components[at] as number | null) ?? 0\n\treturn angles.map((angle) => {\n\t\tif (angle === 0) return base\n\t\tconst components = [...inSpace.components]\n\t\tcomponents[at] = normalizeHue(hue + angle)\n\t\treturn toGamut({ ...inSpace, components }, { gamut })\n\t})\n}\n\n/** Options for `harmonize`. */\nexport interface HarmonizeOptions {\n\t/** The most the hue may move, in degrees. Default 15. */\n\tmax?: number\n\t/** The share of the hue difference to move. Default 0.5. */\n\tfactor?: number\n\t/** The gamut the result must fit. Default `srgb`. */\n\tgamut?: GamutId\n}\n\n/**\n * Nudges `color`'s hue toward `toward`, as Material's `Blend.harmonize` does:\n * by half the hue difference, but at most 15 degrees, in OKLCH, keeping\n * lightness and chroma. Use it to make a status color feel at home with a\n * brand color without changing its meaning.\n */\nexport function harmonize(color: ColorInput, toward: ColorInput, options: HarmonizeOptions = {}): Color {\n\tconst { max = 15, factor = 0.5, gamut = 'srgb' } = options\n\tconst from = convert(toColor(color), 'oklch')\n\tconst to = convert(toColor(toward), 'oklch')\n\tconst h0 = (from.components[2] as number | null) ?? 0\n\tconst h1 = (to.components[2] as number | null) ?? h0\n\t// Signed shortest way round, -180 to 180.\n\tconst diff = normalizeHue(h1 - h0 + 180) - 180\n\tconst rotation = Math.min(Math.abs(diff) * factor, max) * Math.sign(diff)\n\tconst components = [...from.components]\n\tcomponents[2] = normalizeHue(h0 + rotation)\n\treturn toGamut({ ...from, components }, { gamut })\n}\n\n/**\n * The opposite of a color. `lightness` flips OKLCH lightness (L becomes 1 - L)\n * and keeps hue and chroma, so light turns dark without changing its hue;\n * `rgb` inverts each sRGB channel, which also turns the hue to its complement.\n * Alpha is kept. The result is mapped into sRGB.\n */\nexport function inverse(color: ColorInput, mode: 'lightness' | 'rgb' = 'lightness'): Color {\n\tconst base = toColor(color)\n\tif (mode === 'rgb') {\n\t\tconst c = convert(base, 'srgb')\n\t\treturn toGamut({ ...c, components: c.components.map((x) => 1 - (x as number)) })\n\t}\n\tconst c = convert(base, 'oklch')\n\treturn toGamut({ ...c, components: [1 - (c.components[0] as number), c.components[1], c.components[2]] })\n}\n"],"mappings":";;;;;;;AAUA,MAAM,UAAU;CACf,WAAW;CACX,eAAe,CAAC,GAAG,GAAG;CACtB,OAAO;EAAC;EAAG;EAAK;CAAG;CACnB,WAAW;EAAC;EAAK;EAAG;CAAE;CACtB,SAAS;EAAC;EAAG;EAAK;CAAG;CACrB,UAAU;EAAC;EAAG;EAAI;EAAK;CAAG;AAC3B;AAgBA,MAAM,aAAgC;CAAC;CAAS;CAAO;CAAO;AAAK;AAEnE,MAAM,YAAY,UAAiC,UAAU,SAAS,UAAU,QAAQ,IAAI;;;;;;;;;AAU5F,SAAgB,QAAQ,OAAmB,QAAuB,UAA0B,CAAC,GAAY;CACxG,MAAM,EAAE,QAAQ,SAAS,QAAQ,WAAW;CAC5C,MAAM,SAAS,QAAQ;CACvB,IAAI,CAAC,QAAQ,MAAM,YAAY,kBAAkB,QAAQ,OAAO,KAAK,OAAO,CAAC;CAC7E,IAAI,CAAC,WAAW,SAAS,KAAK,GAAG,MAAM,YAAY,iBAAiB,OAAO,UAAU;CACrF,MAAM,OAAO,QAAQ,KAAK;CAC1B,MAAM,UAAU,QAAQ,MAAM,KAAK;CACnC,MAAM,KAAK,SAAS,KAAK;CACzB,MAAM,MAAO,QAAQ,WAAW,OAAyB;CACzD,OAAO,OAAO,KAAK,UAAU;EAC5B,IAAI,UAAU,GAAG,OAAO;EACxB,MAAM,aAAa,CAAC,GAAG,QAAQ,UAAU;EACzC,WAAW,MAAM,aAAa,MAAM,KAAK;EACzC,OAAO,QAAQ;GAAE,GAAG;GAAS;EAAW,GAAG,EAAE,MAAM,CAAC;CACrD,CAAC;AACF;;;;;;;AAkBA,SAAgB,UAAU,OAAmB,QAAoB,UAA4B,CAAC,GAAU;CACvG,MAAM,EAAE,MAAM,IAAI,SAAS,IAAK,QAAQ,WAAW;CACnD,MAAM,OAAO,QAAQ,QAAQ,KAAK,GAAG,OAAO;CAC5C,MAAM,KAAK,QAAQ,QAAQ,MAAM,GAAG,OAAO;CAC3C,MAAM,KAAM,KAAK,WAAW,MAAwB;CACpD,MAAM,KAAM,GAAG,WAAW,MAAwB;CAElD,MAAM,OAAO,aAAa,KAAK,KAAK,GAAG,IAAI;CAC3C,MAAM,WAAW,KAAK,IAAI,KAAK,IAAI,IAAI,IAAI,QAAQ,GAAG,IAAI,KAAK,KAAK,IAAI;CACxE,MAAM,aAAa,CAAC,GAAG,KAAK,UAAU;CACtC,WAAW,KAAK,aAAa,KAAK,QAAQ;CAC1C,OAAO,QAAQ;EAAE,GAAG;EAAM;CAAW,GAAG,EAAE,MAAM,CAAC;AAClD;;;;;;;AAQA,SAAgB,QAAQ,OAAmB,OAA4B,aAAoB;CAC1F,MAAM,OAAO,QAAQ,KAAK;CAC1B,IAAI,SAAS,OAAO;EACnB,MAAM,IAAI,QAAQ,MAAM,MAAM;EAC9B,OAAO,QAAQ;GAAE,GAAG;GAAG,YAAY,EAAE,WAAW,KAAK,MAAM,IAAK,CAAY;EAAE,CAAC;CAChF;CACA,MAAM,IAAI,QAAQ,MAAM,OAAO;CAC/B,OAAO,QAAQ;EAAE,GAAG;EAAG,YAAY;GAAC,IAAK,EAAE,WAAW;GAAe,EAAE,WAAW;GAAI,EAAE,WAAW;EAAE;CAAE,CAAC;AACzG"}

package/esm/palette/index.d.ts

@@ -0,0 +1,5 @@
+import { DarkStrategy, DarkVariantOptions, darkVariant } from "./dark.js";
+import { HarmonizeOptions, HarmonyOptions, HarmonyScheme, HarmonySpace, harmonize, harmony, inverse } from "./harmony.js";
+import { RolePair, SemanticPalette, SemanticPaletteOptions, SemanticRole, semanticPalette } from "./semantic.js";
+import { PaletteIssue, PaletteLike, ValidateOptions, ValidateResult, validate } from "./validate.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/esm/palette/index.js

@@ -0,0 +1,5 @@
+import { darkVariant } from "./dark.js";
+import { harmonize, harmony, inverse } from "./harmony.js";
+import { semanticPalette } from "./semantic.js";
+import { validate } from "./validate.js";
+export { darkVariant, harmonize, harmony, inverse, semanticPalette, validate };

package/esm/palette/semantic.d.ts

@@ -0,0 +1,53 @@
+import { ContrastOption } from "../color/contrast.js";
+import { GamutId } from "../color/gamut.js";
+import { Color } from "../color/types.js";
+/** A background, the foreground drawn on it, and the contrast they reach. */
+export interface RolePair {
+  bg: Color;
+  fg: Color;
+  /** The contrast of `fg` on `bg`, as the algorithm reports it (absolute value). */
+  ratio: number;
+  /** The contrast the pair was built to reach. */
+  target: number;
+}
+/** Options for `semanticPalette`. Only `brand` is required. */
+export interface SemanticPaletteOptions {
+  /** The brand color; it sets the hue of the primary, the neutrals and the harmonized status colors. */
+  brand: Color | string;
+  /** Default `light`. */
+  mode?: 'light' | 'dark';
+  /** The contrast measure. Default `wcag2`. */
+  contrast?: ContrastOption;
+  /** The contrast text pairs must reach. Default 4.5, which fits WCAG 2 (pass about 60 for APCA Lc). */
+  target?: number;
+  /** The gamut every color must fit. Default `srgb`. */
+  gamut?: GamutId;
+}
+/** A role in a {@link SemanticPalette}. Each role holds a {@link RolePair}. */
+export type SemanticRole = 'primary' | 'primaryContainer' | 'success' | 'warning' | 'danger' | 'info' | 'surface' | 'surfaceVariant' | 'outline';
+/** What `semanticPalette` returns: the settings it used, the tonal scales it built from, and a pair for each role. */
+export interface SemanticPalette {
+  meta: {
+    mode: 'light' | 'dark';
+    contrast: string;
+    target: number;
+    gamut: GamutId;
+  };
+  /** Material's 13 tones, dark to light, in the brand's hue (`primary`) and a faint tint of it (`neutral`). */
+  scales: {
+    primary: Color[];
+    neutral: Color[];
+  };
+  roles: Record<SemanticRole, RolePair>;
+}
+/**
+ * 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.
+ */
+export declare function semanticPalette(options: SemanticPaletteOptions): SemanticPalette;
+//# sourceMappingURL=semantic.d.ts.map

package/esm/palette/semantic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic.d.ts","names":[],"sources":["../../src/palette/semantic.ts"],"mappings":";;;;iBAUiB;EAChB,IAAI;EACJ,IAAI;;EAEJ;;EAEA;;;iBAIgB;;EAEhB,OAAO;;EAEP;;EAEA,WAAW;;EAEX;;EAEA,QAAQ;;;YAIG;;iBAYK;EAChB;IAAQ;IAAwB;IAAkB;IAAgB,OAAO;;;EAEzE;IAAU,SAAS;IAAS,SAAS;;EACrC,OAAO,OAAO,cAAc;;;;;;;;;;;wBAmBb,gBAAgB,SAAS,yBAAyB"}