color-map 2.1.0 → 2.3.0

package/cjs/index-CGKCqRqD.d.ts

@@ -0,0 +1,111 @@
+import { S as Color, l as ContrastOption, t as GamutId } from "./gamut-CG1J2aat.js";
+import { t as RolePair } from "./semantic-CrEIo8tS.js";
+/** How `darkVariant` builds a dark scale from a light one: `mirror`, `tone-swap` or `lightness-invert`. */
+type DarkStrategy = 'mirror' | 'tone-swap' | 'lightness-invert';
+/** Options for `darkVariant`. */
+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.
+ */
+declare function darkVariant(scale: readonly Color[], strategy?: DarkStrategy, options?: DarkVariantOptions): Color[];
+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`. */
+type HarmonyScheme = keyof typeof SCHEMES;
+/** Spaces with a hue channel that a scheme can rotate in. */
+type HarmonySpace = 'oklch' | 'lch' | 'hsl' | 'hwb';
+/** Options for `harmony`. */
+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.
+ */
+declare function harmony(color: ColorInput, scheme: HarmonyScheme, options?: HarmonyOptions): Color[];
+/** Options for `harmonize`. */
+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.
+ */
+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.
+ */
+declare function inverse(color: ColorInput, mode?: 'lightness' | 'rgb'): Color;
+/** What `validate` accepts: a {@link SemanticPalette}, or any object with role pairs and/or scales. */
+interface PaletteLike {
+  roles?: Record<string, RolePair>;
+  scales?: Record<string, readonly Color[]>;
+}
+/** Options for `validate`. */
+interface ValidateOptions {
+  /** The measure used to re-check each pair. Default `wcag2`. */
+  contrast?: ContrastOption;
+  /** The target for a pair that carries none. Default 4.5. */
+  target?: number;
+  /** The gamut colors must fit; a color outside it was clipped or never mapped. Default `srgb`. */
+  gamut?: GamutId;
+}
+/** One problem `validate` found in a palette. */
+interface PaletteIssue {
+  kind: 'contrast' | 'lightness' | 'gamut';
+  /** Where: `roles.danger`, `scales.primary[3]`. */
+  path: string;
+  message: string;
+}
+/** What `validate` returns: `ok` is true when `issues` is empty. */
+interface ValidateResult {
+  ok: boolean;
+  issues: PaletteIssue[];
+}
+/**
+ * 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).
+ */
+declare function validate(palette: PaletteLike, options?: ValidateOptions): ValidateResult;
+export { validate as a, HarmonyScheme as c, harmony as d, inverse as f, darkVariant as h, ValidateResult as i, HarmonySpace as l, DarkVariantOptions as m, PaletteLike as n, HarmonizeOptions as o, DarkStrategy as p, ValidateOptions as r, HarmonyOptions as s, PaletteIssue as t, harmonize as u };
+//# sourceMappingURL=index-CGKCqRqD.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-CGKCqRqD.d.ts","names":[],"sources":["../src/palette/dark.ts","../src/palette/harmony.ts","../src/palette/validate.ts"],"mappings":";;;KAOY;;UAKK;;EAEhB,QAAQ;;;;;;;;;;;;;;iBAeO,YACf,gBAAgB,SAChB,WAAU,cACV,UAAS,qBACP;KC1BE,aAAa;;cAGZ;WACL;WACA;WACA;WACA;WACA;WACA;;;KAIW,6BAA6B;;KAG7B;;UAGK;;EAEhB,QAAQ;;EAER,QAAQ;;;;;;;;;;iBAeO,QAAQ,OAAO,YAAY,QAAQ,eAAe,UAAS,iBAAsB;;UAkBhF;;EAEhB;;EAEA;;EAEA,QAAQ;;;;;;;;iBASO,UAAU,OAAO,YAAY,QAAQ,YAAY,UAAS,mBAAwB;;;;;;;iBAoBlF,QAAQ,OAAO,YAAY,6BAA0C;;UC3FpE;EAChB,QAAQ,eAAe;EACvB,SAAS,wBAAwB;;;UAIjB;;EAEhB,WAAW;;EAEX;;EAEA,QAAQ;;;UAIQ;EAChB;;EAEA;EACA;;;UAIgB;EAChB;EACA,QAAQ;;;;;;;;;iBAUO,SAAS,SAAS,aAAa,UAAS,kBAAuB"}

package/cjs/index-Cv3iUUYE.d.ts

@@ -0,0 +1,171 @@
+import { C as ColorSpaceId, E as Vec3, S as Color, T as Space } from "./gamut-CG1J2aat.js";
+import { t as HueMethod } from "./mix-DGlKoUw4.js";
+/**
+ * The CSS `a98-rgb` space (Adobe RGB 1998). Components are red, green and blue in 0 to 1, with a 563/256 power transfer curve.
+ * Pass it to `createConverter` and to the narrow helpers such as `createMix` and `createToGamut`.
+ */
+declare const a98Rgb: Space;
+/** An sRGB color from a 32-bit ARGB integer, as Material Color Utilities uses. */
+declare function fromArgb(argb: number): Color;
+/** The unsigned 32-bit ARGB integer for an sRGB color. Convert other spaces to `srgb` first. */
+declare function toArgb(color: Color): number;
+/** Converts bare components between two spaces, through the XYZ-D65 hub. */
+declare function convertComponents(from: Space, to: Space, c: Vec3): Vec3;
+/**
+ * Builds `convert` over just the spaces given, so a bundle contains only those.
+ * `none` components become 0 when the space changes.
+ */
+declare function createConverter(...spaces: Space[]): (color: Color, to: ColorSpaceId) => Color;
+/** Euclidean distance in OKLab, the ΔEOK of CSS Color 4 gamut mapping. */
+declare function deltaEOk(a: Color, b: Color): number;
+/**
+ * Builds {@link deltaEOk} over the spaces given, plus `oklab`, so a bundle
+ * contains only those. A color in a space not given throws, naming that space.
+ */
+declare function createDeltaEOk(...spaces: Space[]): (a: Color, b: Color) => number;
+/**
+ * True when both colors are the same within `epsilon` per component. Colors in
+ * different spaces are compared in the first one's space. `none` equals only
+ * `none`, and a missing alpha equals 1.
+ */
+declare function equals(a: Color, b: Color, epsilon?: number): boolean;
+/**
+ * Builds {@link equals} over the spaces given, so a bundle contains only those.
+ * It needs no space of its own: give the spaces of both colors.
+ */
+declare function createEquals(...spaces: Space[]): (a: Color, b: Color, epsilon?: number) => boolean;
+/**
+ * The CSS `display-p3` space. Components are red, green and blue in 0 to 1, with the sRGB transfer curve.
+ * Pass it to `createConverter` and to the narrow helpers such as `createMix` and `createToGamut`.
+ */
+declare const displayP3: Space;
+/**
+ * The CSS `display-p3-linear` space: Display P3 primaries without a transfer curve. Components are red, green and blue in 0 to 1.
+ * Pass it to `createConverter` and to the narrow helpers such as `createMix` and `createToGamut`.
+ */
+declare const displayP3Linear: Space;
+/** A color that needs a context to become concrete: see {@link resolve}. */
+type ColorExpr = Color | {
+  type: 'currentcolor';
+} | {
+  type: 'system';
+  name: string;
+} | {
+  type: 'light-dark';
+  light: ColorExpr;
+  dark: ColorExpr;
+} | {
+  type: 'contrast-color';
+  color: ColorExpr;
+} | {
+  type: 'color-mix';
+  space: ColorSpaceId;
+  hue?: HueMethod;
+  /** Exactly two. `percent` is 0 to 100, absent when not written. */
+  items: {
+    color: ColorExpr;
+    percent?: number;
+  }[];
+} | {
+  /** `rgb(from red r g b)` and the like. The channels are kept as written, for `resolve` to evaluate. */
+  type: 'relative';
+  /** The function name: `rgb`, `hsl`, `hwb`, `lab`, `lch`, `oklab`, `oklch` or `color`. */
+  fn: string;
+  space: ColorSpaceId;
+  from: ColorExpr;
+  channels: [string, string, string];
+  alpha?: string;
+};
+/**
+ * Parses any CSS Color 4 or 5 color into a {@link ColorExpr}: everything
+ * `parse` takes, plus `currentcolor`, system colors, `light-dark()`,
+ * `color-mix()`, `contrast-color()` and relative colors such as
+ * `oklch(from #3b82f6 calc(l + 0.1) c h)`. A concrete color comes back as a
+ * plain {@link Color}; the rest are nodes that {@link resolve} turns into one.
+ */
+declare function parseExpr(input: string): ColorExpr;
+/**
+ * The CSS `hsl` space. Components are hue in degrees, then saturation and lightness in 0 to 100.
+ * Pass it to `createConverter` and to the narrow helpers such as `createMix` and `createToGamut`.
+ */
+declare const hsl: Space;
+/**
+ * The CSS `hwb` space. Components are hue in degrees, then whiteness and blackness in 0 to 100.
+ * Pass it to `createConverter` and to the narrow helpers such as `createMix` and `createToGamut`.
+ */
+declare const hwb: Space;
+/**
+ * The CSS `lab` space (CIE Lab, D50 white). Components are lightness in 0 to 100, then the a and b axes, which are not bounded but stay near -125 to 125 for real colors.
+ * Pass it to `createConverter` and to the narrow helpers such as `createMix` and `createToGamut`.
+ */
+declare const lab: Space;
+/**
+ * The CSS `lch` space, the polar form of `lab`. Components are lightness in 0 to 100, chroma (not bounded, about 0 to 150) and hue in degrees.
+ * Pass it to `createConverter` and to the narrow helpers such as `createMix` and `createToGamut`.
+ */
+declare const lch: Space;
+/**
+ * The CSS `oklab` space. Components are lightness in 0 to 1, then the a and b axes, which stay within about -0.4 to 0.4 for real colors.
+ * Pass it to `createConverter` and to the narrow helpers such as `createMix` and `createToGamut`.
+ */
+declare const oklab: Space;
+/**
+ * The CSS `oklch` space, the polar form of `oklab`. Components are lightness in 0 to 1, chroma (about 0 to 0.4) and hue in degrees.
+ * Pass it to `createConverter` and to the narrow helpers such as `createMix` and `createToGamut`.
+ */
+declare const oklch: Space;
+/**
+ * Parses a CSS Color 4 color: hex, named colors, `transparent`, `rgb()`,
+ * `hsl()`, `hwb()`, `lab()`, `lch()`, `oklab()`, `oklch()` and `color()`.
+ * `none` becomes `null`. Values that need a context (`currentcolor`, system
+ * colors) throw, because nothing here can resolve them.
+ */
+declare function parse(input: string): Color;
+/**
+ * The CSS `prophoto-rgb` space. Components are red, green and blue in 0 to 1. It is defined against a D50 white and converted through `xyzD50`.
+ * Pass it to `createConverter` and to the narrow helpers such as `createMix` and `createToGamut`.
+ */
+declare const prophotoRgb: Space;
+/**
+ * The CSS `rec2020` space. Components are red, green and blue in 0 to 1, with a 2.4 power transfer curve.
+ * Pass it to `createConverter` and to the narrow helpers such as `createMix` and `createToGamut`.
+ */
+declare const rec2020: Space;
+/** What `resolve` needs from its surroundings to settle `currentcolor`, `light-dark()` and system colors. */
+interface ResolveContext {
+  /** What `currentcolor` means. */
+  currentColor?: string | ColorExpr;
+  /** Which side `light-dark()` takes. Default `light`. */
+  colorScheme?: 'light' | 'dark';
+  /** What each system color (`canvas`, `buttontext`, ...) means, by lowercase name. */
+  systemColors?: Record<string, string | ColorExpr>;
+}
+/**
+ * Turns a color, a CSS string or a {@link ColorExpr} into a concrete {@link Color}.
+ * `currentcolor`, system colors and `light-dark()` read `context`; nothing is
+ * guessed, so a missing entry throws and names the value.
+ */
+declare function resolve(input: string | ColorExpr, context?: ResolveContext): Color;
+/** Every space. Importing this pulls them all in; import single spaces to avoid that. */
+declare const spaces: Record<ColorSpaceId, Space>;
+/** Converts a color to any of the 15 spaces. */
+declare const convert: (color: Color, to: ColorSpaceId) => Color;
+/**
+ * The CSS `srgb` space. Components are red, green and blue in 0 to 1, with the sRGB transfer curve.
+ * Pass it to `createConverter` and to the narrow helpers such as `createMix` and `createToGamut`.
+ */
+declare const srgb: Space;
+/**
+ * The CSS `srgb-linear` space: sRGB primaries without a transfer curve. Components are red, green and blue in 0 to 1.
+ * Pass it to `createConverter` and to the narrow helpers such as `createMix` and `createToGamut`.
+ */
+declare const srgbLinear: Space;
+/**
+ * The CSS `xyz-d50` space (CIE XYZ, D50 white). Components are X, Y and Z, where Y is 1 for white.
+ * Pass it to `createConverter` and to the narrow helpers such as `createMix` and `createToGamut`.
+ */
+declare const xyzD50: Space;
+/** The hub every other space converts through. */
+declare const xyzD65: Space;
+export { a98Rgb as A, createEquals as C, createConverter as D, convertComponents as E, fromArgb as O, createDeltaEOk as S, equals as T, hsl as _, convert as a, displayP3Linear as b, resolve as c, parse as d, oklch as f, hwb as g, lab as h, srgb as i, toArgb as k, rec2020 as l, lch as m, xyzD50 as n, spaces as o, oklab as p, srgbLinear as r, ResolveContext as s, xyzD65 as t, prophotoRgb as u, ColorExpr as v, deltaEOk as w, displayP3 as x, parseExpr as y };
+//# sourceMappingURL=index-Cv3iUUYE.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-Cv3iUUYE.d.ts","names":["_$__types_js0.Space","_$__types_js0.Space","_$__types_js0.Space","_$__types_js0.Space","_$__types_js0.Space","_$__types_js0.Space","_$__types_js0.Color","_$__types_js0.Space","_$__types_js0.Space"],"sources":["../src/color/a98-rgb.ts","../src/color/argb.ts","../src/color/convert.ts","../src/color/compare.ts","../src/color/display-p3.ts","../src/color/display-p3-linear.ts","../src/color/expr.ts","../src/color/hsl.ts","../src/color/hwb.ts","../src/color/lab.ts","../src/color/lch.ts","../src/color/oklab.ts","../src/color/oklch.ts","../src/color/parse.ts","../src/color/prophoto-rgb.ts","../src/color/rec2020.ts","../src/color/resolve.ts","../src/color/spaces.ts","../src/color/srgb.ts","../src/color/srgb-linear.ts","../src/color/xyz-d50.ts","../src/color/xyz-d65.ts"],"mappings":";;;;;;cAUa,QAAAA;;iBCLG,SAAS,eAAe;;iBAUxB,OAAO,OAAO;;iBCXd,kBAAkB,MAAM,OAAO,IAAI,OAAO,GAAG,OAAO;;;;;iBAmCpD,mBAAmB,QAAQ,WAAW,OAAO,OAAO,IAAI,iBAAiB;;iBCjCzE,SAAS,GAAG,OAAO,GAAG;;;;;iBAetB,kBAAkB,QAAQ,WAAW,GAAG,OAAO,GAAG;;;;;;iBAalD,OAAO,GAAG,OAAO,GAAG,OAAO;;;;;iBAe3B,gBAAgB,QAAQ,WAAW,GAAG,OAAO,GAAG,OAAO;;;;;cCzC1D,WAAAC;;;;;cCAA,iBAAAC;;KCHD,YACT;EACE;;EACA;EAAgB;;EAChB;EAAoB,OAAO;EAAW,MAAM;;EAC5C;EAAwB,OAAO;;EAEjC;EACA,OAAO;EACP,MAAM;;EAEN;IAAS,OAAO;IAAW;;;;EAI3B;;EAEA;EACA,OAAO;EACP,MAAM;EACN;EACA;;;;;;;;;iBAgHa,UAAU,gBAAgB;;;;;cCzF7B,KAAK;;;;;cCzCL,KAAK;;;;;cCML,KAAK;;;;;cCPL,KAAAC;;;;;cCCA,OAAO;;;;;cCDP,OAAAC;;;;;;;iBCqIG,MAAM,gBAAgB;;;;;cC/HzB,aAAa;;;;;cCHb,SAAAC;;UCDI;;EAEhB,wBAAwB;;EAExB;;EAEA,eAAe,wBAAwB;;;;;;;iBA2DxB,QAAQ,gBAAgB,WAAW,UAAS,iBAAsB;;cCvDrE,QAAQ,OAAO,cAAc;;cAsB7B,UAAO,OAAPC,OAAO,IAAA,iBAAAA;;;;;cCjCP,MAAAC;;;;;cCAA,YAAAC;;;;;cCAA,QAAQ;;cCLR,QAAQ"}

package/cjs/index-Dw43Hj4v.d.ts

@@ -0,0 +1,41 @@
+/** Red, green and blue as whole numbers in 0 to 255. */
+type RGB = [number, number, number];
+/** Red, green and blue as whole numbers in 0 to 255, then alpha in 0 to 1. */
+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. */
+type Alpha = [number, number];
+/** The segments of a gradient, in order, for `createColorsFromMap`. Each has an `index` and an `rgb`. */
+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;
+}[];
+/**
+ * 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`.
+ */
+declare function createColors(from: RGB | RGBA, to: RGB | RGBA, shades: number, alpha?: Alpha): RGBA[];
+/**
+ * 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.
+ */
+declare function createColorsFromMap(colormap: ColorMap, shades: number, alpha?: Alpha): RGBA[];
+/** Formats an `RGBA` as a CSS `rgba(r,g,b,a)` string, with no spaces. */
+declare function rgbaString(rgba: RGBA): string;
+/**
+ * Convert `RGB` to `#rgb`
+ * JavaScript note: no check for array length, use it properly.
+ */
+declare function rgbHex(rgb: RGB | RGBA): string;
+export { Alpha as a, RGBA as c, createColors as i, rgbaString as n, ColorMap as o, createColorsFromMap as r, RGB as s, rgbHex as t };
+//# sourceMappingURL=index-Dw43Hj4v.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-Dw43Hj4v.d.ts","names":[],"sources":["../src/legacy/interfaces.ts","../src/legacy/createColors.ts","../src/legacy/createColorsFromMap.ts","../src/legacy/rgbaString.ts","../src/legacy/rgbHex.ts"],"mappings":";KACY;;KAEA;;KAEA;;KAGA;;;;;EAKX;;;;EAIA,KAAK,MAAM;;;;;;;;iBCTI,aACf,MAAM,MAAM,MACZ,IAAI,MAAM,MACV,gBACA,QAAO,QAIL;;;;;;;iBCPa,oBAAoB,UAAU,UAAU,gBAAgB,QAAQ,QAAQ;;iBCNxE,WAAW,MAAM;;;;;iBCGjB,OAAO,KAAK,MAAM"}

package/cjs/index-Dy8UARqO.d.ts

@@ -0,0 +1,72 @@
+import { t as ToCssOptions } from "./serialize-C69DAmoE.js";
+import { C as ColorSpaceId, S as Color } from "./gamut-CG1J2aat.js";
+import { n as SemanticPalette } from "./semantic-CrEIo8tS.js";
+/**
+ * What the exporters accept: a color, a CSS color string, an array of them (a
+ * scale), or an object of any of these nested to any depth. A `SemanticPalette`
+ * works as is: its `scales` and its role pairs export, its `meta` and ratios do not.
+ */
+type TokenTree = SemanticPalette | Color | string | readonly TokenTree[] | {
+  readonly [name: string]: TokenTree;
+};
+/** Options for `toCssVariables`. It also takes the options of `toCss`. */
+interface CssVariablesOptions extends ToCssOptions {
+  /** The first part of every name. Default `color`, so `primary.500` becomes `--color-primary-500`. */
+  prefix?: string;
+  /** The rule's selector. Default `:root`. */
+  selector?: string;
+  /** Convert every color to this space first. Default: print each in its own space. */
+  space?: ColorSpaceId;
+}
+/**
+ * Exports colors as CSS custom properties in one rule:
+ * `:root {\n\t--color-primary-500: oklch(0.62 0.19 260);\n}`.
+ */
+declare function toCssVariables(tree: TokenTree, options?: CssVariablesOptions): string;
+/** Options for `toDtcg` and `toDtcgValue`. */
+interface DtcgOptions {
+  /** Add the `hex` fallback (an sRGB `#rrggbb`, gamut-mapped when the color is outside sRGB). Default `true`. */
+  hex?: boolean;
+}
+/** A color value as DTCG 2025.10 defines it. */
+interface DtcgColorValue {
+  colorSpace: Exclude<ColorSpaceId, 'display-p3-linear'>;
+  components: (number | 'none')[];
+  alpha?: number | 'none';
+  hex?: string;
+}
+/** A DTCG color token: a `$type` of `color` and its {@link DtcgColorValue}. */
+interface DtcgToken {
+  $type: 'color';
+  $value: DtcgColorValue;
+}
+/** A DTCG group: named tokens and nested groups, as `toDtcg` returns for a token tree. */
+interface DtcgGroup {
+  [name: string]: DtcgToken | DtcgGroup;
+}
+/** One color as a DTCG color value. `display-p3-linear` is not a DTCG space, so it becomes `display-p3`. */
+declare function toDtcgValue(color: Color, options?: DtcgOptions): DtcgColorValue;
+/**
+ * Exports colors as a DTCG 2025.10 token file: nested groups whose leaves are
+ * `{ "$type": "color", "$value": { colorSpace, components, alpha?, hex? } }`.
+ * `none` components print as `"none"`, as the format asks. The result is plain
+ * JSON, so `JSON.stringify` writes the file.
+ */
+declare function toDtcg(tree: TokenTree, options?: DtcgOptions): DtcgGroup;
+/** Options for `toTailwindTheme`. It also takes the options of `toCss`. */
+interface TailwindThemeOptions extends Omit<CssVariablesOptions, 'selector' | 'prefix'> {
+  /** The theme variable namespace. Default `color`, which makes `bg-primary-500` and `text-primary-500` work. */
+  namespace?: string;
+  /** Write `@theme inline`, so utilities hold the value instead of a `var()` reference. */
+  inline?: boolean;
+  /** Default `oklch`, the space Tailwind v4's own palette uses. */
+  space?: ColorSpaceId;
+}
+/**
+ * Exports colors as a Tailwind v4 `@theme` block. Paste it into the CSS file
+ * that has `@import "tailwindcss"`. An array of 11 colors gets the keys
+ * 50 to 950, so a `tailwind-11` scale reads like Tailwind's own.
+ */
+declare function toTailwindTheme(tree: TokenTree, options?: TailwindThemeOptions): string;
+export { DtcgOptions as a, toDtcgValue as c, TokenTree as d, DtcgGroup as i, CssVariablesOptions as l, toTailwindTheme as n, DtcgToken as o, DtcgColorValue as r, toDtcg as s, TailwindThemeOptions as t, toCssVariables as u };
+//# sourceMappingURL=index-Dy8UARqO.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index-Dy8UARqO.d.ts","names":[],"sources":["../src/tokens/tokens.ts","../src/tokens/css.ts","../src/tokens/dtcg.ts","../src/tokens/tailwind.ts"],"mappings":";;;;;;;;KASY,YAAY,kBAAkB,0BAA0B;YAA0B,eAAe;;;UCH5F,4BAA4B;;EAE5C;;EAEA;;EAEA,QAAQ;;;;;;iBAeO,eAAe,MAAM,WAAW,UAAS;;UCpBxC;;EAEhB;;;UAIgB;EAChB,YAAY,QAAQ;EACpB;EACA;EACA;;;UAIgB;EAChB;EACA,QAAQ;;;UAIQ;GACf,eAAe,YAAY;;;iBAMb,YAAY,OAAO,OAAO,UAAS,cAAmB;;;;;;;iBAiBtD,OAAO,MAAM,WAAW,UAAS,cAAmB;;UC9CnD,6BAA6B,KAAK;;EAElD;;EAEA;;EAEA,QAAQ;;;;;;;iBAQO,gBAAgB,MAAM,WAAW,UAAS"}

package/cjs/index.d.ts

@@ -1,5 +1,27 @@
-export * from './createColors.js';
-export * from './createColorsFromMap.js';
-export type { Alpha, ColorMap, RGB, RGBA } from './interfaces.js';
-export * from './rgbHex.js';
-export * from './rgbaString.js';
+import { C as ColorSpaceId, E as Vec3, S as Color, T as Space, _ as createOnColor, a as inGamut, b as onColor, c as ContrastFn, d as FoundContrast, f as OnColorOptions, g as createMeets, h as createFindContrast, i as createToGamut, l as ContrastOption, m as createContrast, n as ToGamutOptions, o as toGamut, p as contrast, r as createInGamut, s as ContrastAlgorithm, t as GamutId, u as FindContrastOptions, v as findContrast, w as Component, x as wcag2, y as meets } from "./gamut-CG1J2aat.js";
+import { A as a98Rgb, C as createEquals, D as createConverter, E as convertComponents, O as fromArgb, S as createDeltaEOk, T as equals, _ as hsl, a as convert, b as displayP3Linear, c as resolve, d as parse, f as oklch, g as hwb, h as lab, i as srgb, k as toArgb, l as rec2020, m as lch, n as xyzD50, o as spaces, p as oklab, r as srgbLinear, s as ResolveContext, t as xyzD65, u as prophotoRgb, v as ColorExpr, w as deltaEOk, x as displayP3, y as parseExpr } from "./index-Cv3iUUYE.js";
+import { i as mix, n as MixOptions, r as createMix, t as HueMethod } from "./mix-DGlKoUw4.js";
+import { i as toHex, n as createToHex, r as toCss, t as ToCssOptions } from "./serialize-C69DAmoE.js";
+import { a as Alpha$1, c as RGBA$1, i as createColors$1, n as rgbaString$1, o as ColorMap$1, r as createColorsFromMap$1, s as RGB$1, t as rgbHex$1 } from "./index-Dw43Hj4v.js";
+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";
+import { a as toneColor, c as createScale, d as createGradient, f as ContrastScaleOptions, g as scaleFromBrand, h as BrandScaleOptions, i as tonalPalette, l as GradientOptions, m as createContrastScale, n as TonalPaletteOptions, o as ScaleOptions, p as ContrastStep, r as lstar, s as ScalePreset, t as MATERIAL_TONES, u as GradientStop } from "./index-BcEqCPHz.js";
+import { a as DtcgOptions, c as toDtcgValue, d as TokenTree, i as DtcgGroup, l as CssVariablesOptions, n as toTailwindTheme, o as DtcgToken, r as DtcgColorValue, s as toDtcg, t as TailwindThemeOptions, u as toCssVariables } from "./index-Dy8UARqO.js";
+/** @deprecated Import it from `color-map/legacy`. The root stops exporting it in 3.0. */
+export declare const createColors: typeof createColors$1;
+/** @deprecated Use `createGradient` from `color-map`, or import it from `color-map/legacy`. The root stops exporting it in 3.0. */
+export declare const createColorsFromMap: typeof createColorsFromMap$1;
+/** @deprecated Import it from `color-map/legacy`, or use `toHex` from `color-map`. The root stops exporting it in 3.0. */
+export declare const rgbHex: typeof rgbHex$1;
+/** @deprecated Import it from `color-map/legacy`, or use `toCss` from `color-map`. The root stops exporting it in 3.0. */
+export declare const rgbaString: typeof rgbaString$1;
+/** @deprecated Import it from `color-map/legacy`. The root stops exporting it in 3.0. */
+export type Alpha = Alpha$1;
+/** @deprecated Import it from `color-map/legacy`. The root stops exporting it in 3.0. */
+export type ColorMap = ColorMap$1;
+/** @deprecated Import it from `color-map/legacy`. The root stops exporting it in 3.0. */
+export type RGB = RGB$1;
+/** @deprecated Import it from `color-map/legacy`. The root stops exporting it in 3.0. */
+export type RGBA = RGBA$1;
+export { type BrandScaleOptions, type Color, type ColorExpr, type ColorSpaceId, type Component, type ContrastAlgorithm, type ContrastFn, type ContrastOption, type ContrastScaleOptions, type ContrastStep, type CssVariablesOptions, type DarkStrategy, type DarkVariantOptions, type DtcgColorValue, type DtcgGroup, type DtcgOptions, type DtcgToken, type FindContrastOptions, type FoundContrast, type GamutId, type GradientOptions, type GradientStop, type HarmonizeOptions, type HarmonyOptions, type HarmonyScheme, type HarmonySpace, type HueMethod, MATERIAL_TONES, type MixOptions, type OnColorOptions, type PaletteIssue, type PaletteLike, type ResolveContext, type RolePair, type ScaleOptions, type ScalePreset, type SemanticPalette, type SemanticPaletteOptions, type SemanticRole, type Space, type TailwindThemeOptions, type ToCssOptions, type ToGamutOptions, type TokenTree, type TonalPaletteOptions, type ValidateOptions, type ValidateResult, type Vec3, a98Rgb, contrast, convert, convertComponents, 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, scaleFromBrand, semanticPalette, spaces, srgb, srgbLinear, toArgb, toCss, toCssVariables, toDtcg, toDtcgValue, toGamut, toHex, toTailwindTheme, tonalPalette, toneColor, validate, wcag2, xyzD50, xyzD65 };
+//# sourceMappingURL=index.d.ts.map

package/cjs/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["legacyCreateColors","legacyCreateColorsFromMap","legacyRgbHex","legacyRgbaString","LegacyAlpha","LegacyColorMap","LegacyRGB","LegacyRGBA"],"sources":["../src/index.ts"],"mappings":";;;;;;;;;;qBAqBa,qBAAYA;;qBAEZ,4BAAmBC;;qBAEnB,eAAMC;;qBAEN,mBAAUC;;YAGX,QAAQC;;YAER,WAAWC;;YAEX,MAAMC;;YAEN,OAAOC"}

package/cjs/index.js

@@ -1,21 +1,90 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./createColors.js"), exports);
-__exportStar(require("./createColorsFromMap.js"), exports);
-__exportStar(require("./rgbHex.js"), exports);
-__exportStar(require("./rgbaString.js"), exports);
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_legacy_index = require("./legacy/index.js");
+const require_parse = require("./parse-8mt2OMKf.js");
+const require_color = require("./color-wNrkrhC7.js");
+const require_contrast = require("./contrast-XjF5Rwui.js");
+const require_mix = require("./mix-Cs4owSbW.js");
+const require_serialize = require("./serialize-Ci2X0cPN.js");
+const require_tone = require("./tone-BAhu-QzQ.js");
+const require_palette = require("./palette-DyFV_KoJ.js");
+const require_scale = require("./scale-Cq9pXrc1.js");
+const require_tokens = require("./tokens-CzXxaMgM.js");
+// src/index.ts
+/** @deprecated Import it from `color-map/legacy`. The root stops exporting it in 3.0. */
+const createColors = require_legacy_index.createColors;
+/** @deprecated Use `createGradient` from `color-map`, or import it from `color-map/legacy`. The root stops exporting it in 3.0. */
+const createColorsFromMap = require_legacy_index.createColorsFromMap;
+/** @deprecated Import it from `color-map/legacy`, or use `toHex` from `color-map`. The root stops exporting it in 3.0. */
+const rgbHex = require_legacy_index.rgbHex;
+/** @deprecated Import it from `color-map/legacy`, or use `toCss` from `color-map`. The root stops exporting it in 3.0. */
+const rgbaString = require_legacy_index.rgbaString;
+exports.MATERIAL_TONES = require_tone.MATERIAL_TONES;
+exports.a98Rgb = require_parse.a98Rgb;
+exports.contrast = require_contrast.contrast;
+exports.convert = require_parse.convert;
+exports.convertComponents = require_parse.convertComponents;
+exports.createColors = createColors;
+exports.createColorsFromMap = createColorsFromMap;
+exports.createContrast = require_contrast.createContrast;
+exports.createContrastScale = require_scale.createContrastScale;
+exports.createConverter = require_parse.createConverter;
+exports.createDeltaEOk = require_parse.createDeltaEOk;
+exports.createEquals = require_parse.createEquals;
+exports.createFindContrast = require_contrast.createFindContrast;
+exports.createGradient = require_scale.createGradient;
+exports.createInGamut = require_parse.createInGamut;
+exports.createMeets = require_contrast.createMeets;
+exports.createMix = require_mix.createMix;
+exports.createOnColor = require_contrast.createOnColor;
+exports.createScale = require_scale.createScale;
+exports.createToGamut = require_parse.createToGamut;
+exports.createToHex = require_serialize.createToHex;
+exports.darkVariant = require_palette.darkVariant;
+exports.deltaEOk = require_parse.deltaEOk;
+exports.displayP3 = require_parse.displayP3;
+exports.displayP3Linear = require_parse.displayP3Linear;
+exports.equals = require_parse.equals;
+exports.findContrast = require_contrast.findContrast;
+exports.fromArgb = require_color.fromArgb;
+exports.harmonize = require_palette.harmonize;
+exports.harmony = require_palette.harmony;
+exports.hsl = require_parse.hsl;
+exports.hwb = require_parse.hwb;
+exports.inGamut = require_parse.inGamut;
+exports.inverse = require_palette.inverse;
+exports.lab = require_parse.lab;
+exports.lch = require_parse.lch;
+exports.lstar = require_tone.lstar;
+exports.meets = require_contrast.meets;
+exports.mix = require_mix.mix;
+exports.oklab = require_parse.oklab;
+exports.oklch = require_parse.oklch;
+exports.onColor = require_contrast.onColor;
+exports.parse = require_parse.parse;
+exports.parseExpr = require_color.parseExpr;
+exports.prophotoRgb = require_parse.prophotoRgb;
+exports.rec2020 = require_parse.rec2020;
+exports.resolve = require_color.resolve;
+exports.rgbHex = rgbHex;
+exports.rgbaString = rgbaString;
+exports.scaleFromBrand = require_scale.scaleFromBrand;
+exports.semanticPalette = require_palette.semanticPalette;
+exports.spaces = require_parse.spaces;
+exports.srgb = require_parse.srgb;
+exports.srgbLinear = require_parse.srgbLinear;
+exports.toArgb = require_color.toArgb;
+exports.toCss = require_serialize.toCss;
+exports.toCssVariables = require_tokens.toCssVariables;
+exports.toDtcg = require_tokens.toDtcg;
+exports.toDtcgValue = require_tokens.toDtcgValue;
+exports.toGamut = require_parse.toGamut;
+exports.toHex = require_serialize.toHex;
+exports.toTailwindTheme = require_tokens.toTailwindTheme;
+exports.tonalPalette = require_tone.tonalPalette;
+exports.toneColor = require_tone.toneColor;
+exports.validate = require_palette.validate;
+exports.wcag2 = require_contrast.wcag2;
+exports.xyzD50 = require_parse.xyzD50;
+exports.xyzD65 = require_parse.xyzD65;
+
 //# sourceMappingURL=index.js.map

package/cjs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../ts/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,oDAAiC;AACjC,2DAAwC;AAExC,8CAA2B;AAC3B,kDAA+B"}
+{"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,qBAAAA;;AAE5B,MAAa,sBAAsBC,qBAAAA;;AAEnC,MAAa,SAASC,qBAAAA;;AAEtB,MAAa,aAAaC,qBAAAA"}

package/cjs/legacy/index.d.ts

@@ -0,0 +1,2 @@
+import { a as Alpha, c as RGBA, i as createColors, n as rgbaString, o as ColorMap, r as createColorsFromMap, s as RGB, t as rgbHex } from "../index-Dw43Hj4v.js";
+export { type Alpha, type ColorMap, type RGB, type RGBA, createColors, createColorsFromMap, rgbHex, rgbaString };