@pixerate/editor 0.146.0 → 0.148.0

package/dist/chunk-UKCJ43YL.cjs

@@ -0,0 +1,1913 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+
+var _chunkIPJ3TEYRcjs = require('./chunk-IPJ3TEYR.cjs');
+
+// src/color/convert.ts
+function srgbToLinear(v) {
+  const sign = Math.sign(v);
+  const abs = Math.abs(v);
+  return sign * (abs <= 0.04045 ? abs / 12.92 : ((abs + 0.055) / 1.055) ** 2.4);
+}
+function linearToSrgb(v) {
+  const sign = Math.sign(v);
+  const abs = Math.abs(v);
+  return sign * (abs <= 31308e-7 ? 12.92 * abs : 1.055 * abs ** (1 / 2.4) - 0.055);
+}
+function rgbToHsl(rgba) {
+  const { r, g, b, a } = rgba;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const d = max - min;
+  const l = (max + min) / 2;
+  let h = 0;
+  if (d > 0) {
+    if (max === r) h = 60 * ((g - b) / d % 6);
+    else if (max === g) h = 60 * ((b - r) / d + 2);
+    else h = 60 * ((r - g) / d + 4);
+  }
+  if (h < 0) h += 360;
+  const s = d === 0 ? 0 : d / (1 - Math.abs(2 * l - 1));
+  return { h, s, l, alpha: a };
+}
+function hslToRgb(hsla) {
+  const { h, s, l, alpha } = hsla;
+  const hh = (h % 360 + 360) % 360 / 60;
+  const c = (1 - Math.abs(2 * l - 1)) * s;
+  const x = c * (1 - Math.abs(hh % 2 - 1));
+  const m = l - c / 2;
+  let r = 0;
+  let g = 0;
+  let b = 0;
+  if (hh < 1) {
+    r = c;
+    g = x;
+    b = 0;
+  } else if (hh < 2) {
+    r = x;
+    g = c;
+    b = 0;
+  } else if (hh < 3) {
+    r = 0;
+    g = c;
+    b = x;
+  } else if (hh < 4) {
+    r = 0;
+    g = x;
+    b = c;
+  } else if (hh < 5) {
+    r = x;
+    g = 0;
+    b = c;
+  } else {
+    r = c;
+    g = 0;
+    b = x;
+  }
+  return { r: r + m, g: g + m, b: b + m, a: alpha };
+}
+function rgbToHsv(rgba) {
+  const { r, g, b, a } = rgba;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const d = max - min;
+  let h = 0;
+  if (d > 0) {
+    if (max === r) h = 60 * ((g - b) / d % 6);
+    else if (max === g) h = 60 * ((b - r) / d + 2);
+    else h = 60 * ((r - g) / d + 4);
+  }
+  if (h < 0) h += 360;
+  const s = max === 0 ? 0 : d / max;
+  return { h, s, v: max, alpha: a };
+}
+function hsvToRgb(hsva) {
+  const { h, s, v, alpha } = hsva;
+  const hh = (h % 360 + 360) % 360 / 60;
+  const c = v * s;
+  const x = c * (1 - Math.abs(hh % 2 - 1));
+  const m = v - c;
+  let r = 0;
+  let g = 0;
+  let b = 0;
+  if (hh < 1) {
+    r = c;
+    g = x;
+    b = 0;
+  } else if (hh < 2) {
+    r = x;
+    g = c;
+    b = 0;
+  } else if (hh < 3) {
+    r = 0;
+    g = c;
+    b = x;
+  } else if (hh < 4) {
+    r = 0;
+    g = x;
+    b = c;
+  } else if (hh < 5) {
+    r = x;
+    g = 0;
+    b = c;
+  } else {
+    r = c;
+    g = 0;
+    b = x;
+  }
+  return { r: r + m, g: g + m, b: b + m, a: alpha };
+}
+function rgbToOklab(rgba) {
+  const lr = srgbToLinear(rgba.r);
+  const lg = srgbToLinear(rgba.g);
+  const lb = srgbToLinear(rgba.b);
+  const l = Math.cbrt(0.4122214708 * lr + 0.5363325363 * lg + 0.0514459929 * lb);
+  const m = Math.cbrt(0.2119034982 * lr + 0.6806995451 * lg + 0.1073969566 * lb);
+  const s = Math.cbrt(0.0883024619 * lr + 0.2817188376 * lg + 0.6299787005 * lb);
+  return {
+    l: 0.2104542553 * l + 0.793617785 * m - 0.0040720468 * s,
+    a: 1.9779984951 * l - 2.428592205 * m + 0.4505937099 * s,
+    b: 0.0259040371 * l + 0.7827717662 * m - 0.808675766 * s,
+    alpha: rgba.a
+  };
+}
+function oklabToRgb(lab) {
+  const l_ = lab.l + 0.3963377774 * lab.a + 0.2158037573 * lab.b;
+  const m_ = lab.l - 0.1055613458 * lab.a - 0.0638541728 * lab.b;
+  const s_ = lab.l - 0.0894841775 * lab.a - 1.291485548 * lab.b;
+  const l = l_ ** 3;
+  const m = m_ ** 3;
+  const s = s_ ** 3;
+  return {
+    r: linearToSrgb(4.0767416621 * l - 3.3077115913 * m + 0.2309699292 * s),
+    g: linearToSrgb(-1.2684380046 * l + 2.6097574011 * m - 0.3413193965 * s),
+    b: linearToSrgb(-0.0041960863 * l - 0.7034186147 * m + 1.707614701 * s),
+    a: lab.alpha
+  };
+}
+function oklabToOklch(lab) {
+  const c = Math.hypot(lab.a, lab.b);
+  let h = 0;
+  if (c >= 1e-6) {
+    h = Math.atan2(lab.b, lab.a) * 180 / Math.PI;
+    if (h < 0) h += 360;
+    if (h >= 360) h -= 360;
+  }
+  return { l: lab.l, c, h, alpha: lab.alpha };
+}
+function oklchToOklab(lch) {
+  const rad = lch.h * Math.PI / 180;
+  return {
+    l: lch.l,
+    a: lch.c * Math.cos(rad),
+    b: lch.c * Math.sin(rad),
+    alpha: lch.alpha
+  };
+}
+var D65_XYZ = _chunkIPJ3TEYRcjs.xyToXyz.call(void 0, _chunkIPJ3TEYRcjs.D65_XY);
+var SRGB_TO_XYZ = _chunkIPJ3TEYRcjs.rgbToXyzMatrix.call(void 0, [0.64, 0.33], [0.3, 0.6], [0.15, 0.06], D65_XYZ);
+var P3_TO_XYZ = _chunkIPJ3TEYRcjs.rgbToXyzMatrix.call(void 0, [0.68, 0.32], [0.265, 0.69], [0.15, 0.06], D65_XYZ);
+var XYZ_TO_SRGB = _chunkIPJ3TEYRcjs.invert.call(void 0, SRGB_TO_XYZ);
+var XYZ_TO_P3 = _chunkIPJ3TEYRcjs.invert.call(void 0, P3_TO_XYZ);
+var P3_TO_SRGB_MAT = _chunkIPJ3TEYRcjs.mul.call(void 0, XYZ_TO_SRGB, P3_TO_XYZ);
+var SRGB_TO_P3_MAT = _chunkIPJ3TEYRcjs.mul.call(void 0, XYZ_TO_P3, SRGB_TO_XYZ);
+function linearSrgbToDisplayP3(rgb) {
+  const out = _chunkIPJ3TEYRcjs.apply.call(void 0, SRGB_TO_P3_MAT, [rgb.r, rgb.g, rgb.b]);
+  return { r: out[0], g: out[1], b: out[2], a: rgb.a };
+}
+function displayP3ToLinearSrgb(rgb) {
+  const out = _chunkIPJ3TEYRcjs.apply.call(void 0, P3_TO_SRGB_MAT, [rgb.r, rgb.g, rgb.b]);
+  return { r: out[0], g: out[1], b: out[2], a: rgb.a };
+}
+
+// src/color/named.ts
+var NAMED_COLORS = {
+  aliceblue: "#f0f8ff",
+  antiquewhite: "#faebd7",
+  aqua: "#00ffff",
+  aquamarine: "#7fffd4",
+  azure: "#f0ffff",
+  beige: "#f5f5dc",
+  bisque: "#ffe4c4",
+  black: "#000000",
+  blanchedalmond: "#ffebcd",
+  blue: "#0000ff",
+  blueviolet: "#8a2be2",
+  brown: "#a52a2a",
+  burlywood: "#deb887",
+  cadetblue: "#5f9ea0",
+  chartreuse: "#7fff00",
+  chocolate: "#d2691e",
+  coral: "#ff7f50",
+  cornflowerblue: "#6495ed",
+  cornsilk: "#fff8dc",
+  crimson: "#dc143c",
+  cyan: "#00ffff",
+  darkblue: "#00008b",
+  darkcyan: "#008b8b",
+  darkgoldenrod: "#b8860b",
+  darkgray: "#a9a9a9",
+  darkgreen: "#006400",
+  darkgrey: "#a9a9a9",
+  darkkhaki: "#bdb76b",
+  darkmagenta: "#8b008b",
+  darkolivegreen: "#556b2f",
+  darkorange: "#ff8c00",
+  darkorchid: "#9932cc",
+  darkred: "#8b0000",
+  darksalmon: "#e9967a",
+  darkseagreen: "#8fbc8f",
+  darkslateblue: "#483d8b",
+  darkslategray: "#2f4f4f",
+  darkslategrey: "#2f4f4f",
+  darkturquoise: "#00ced1",
+  darkviolet: "#9400d3",
+  deeppink: "#ff1493",
+  deepskyblue: "#00bfff",
+  dimgray: "#696969",
+  dimgrey: "#696969",
+  dodgerblue: "#1e90ff",
+  firebrick: "#b22222",
+  floralwhite: "#fffaf0",
+  forestgreen: "#228b22",
+  fuchsia: "#ff00ff",
+  gainsboro: "#dcdcdc",
+  ghostwhite: "#f8f8ff",
+  gold: "#ffd700",
+  goldenrod: "#daa520",
+  gray: "#808080",
+  green: "#008000",
+  greenyellow: "#adff2f",
+  grey: "#808080",
+  honeydew: "#f0fff0",
+  hotpink: "#ff69b4",
+  indianred: "#cd5c5c",
+  indigo: "#4b0082",
+  ivory: "#fffff0",
+  khaki: "#f0e68c",
+  lavender: "#e6e6fa",
+  lavenderblush: "#fff0f5",
+  lawngreen: "#7cfc00",
+  lemonchiffon: "#fffacd",
+  lightblue: "#add8e6",
+  lightcoral: "#f08080",
+  lightcyan: "#e0ffff",
+  lightgoldenrodyellow: "#fafad2",
+  lightgray: "#d3d3d3",
+  lightgreen: "#90ee90",
+  lightgrey: "#d3d3d3",
+  lightpink: "#ffb6c1",
+  lightsalmon: "#ffa07a",
+  lightseagreen: "#20b2aa",
+  lightskyblue: "#87cefa",
+  lightslategray: "#778899",
+  lightslategrey: "#778899",
+  lightsteelblue: "#b0c4de",
+  lightyellow: "#ffffe0",
+  lime: "#00ff00",
+  limegreen: "#32cd32",
+  linen: "#faf0e6",
+  magenta: "#ff00ff",
+  maroon: "#800000",
+  mediumaquamarine: "#66cdaa",
+  mediumblue: "#0000cd",
+  mediumorchid: "#ba55d3",
+  mediumpurple: "#9370db",
+  mediumseagreen: "#3cb371",
+  mediumslateblue: "#7b68ee",
+  mediumspringgreen: "#00fa9a",
+  mediumturquoise: "#48d1cc",
+  mediumvioletred: "#c71585",
+  midnightblue: "#191970",
+  mintcream: "#f5fffa",
+  mistyrose: "#ffe4e1",
+  moccasin: "#ffe4b5",
+  navajowhite: "#ffdead",
+  navy: "#000080",
+  oldlace: "#fdf5e6",
+  olive: "#808000",
+  olivedrab: "#6b8e23",
+  orange: "#ffa500",
+  orangered: "#ff4500",
+  orchid: "#da70d6",
+  palegoldenrod: "#eee8aa",
+  palegreen: "#98fb98",
+  paleturquoise: "#afeeee",
+  palevioletred: "#db7093",
+  papayawhip: "#ffefd5",
+  peachpuff: "#ffdab9",
+  peru: "#cd853f",
+  pink: "#ffc0cb",
+  plum: "#dda0dd",
+  powderblue: "#b0e0e6",
+  purple: "#800080",
+  rebeccapurple: "#663399",
+  red: "#ff0000",
+  rosybrown: "#bc8f8f",
+  royalblue: "#4169e1",
+  saddlebrown: "#8b4513",
+  salmon: "#fa8072",
+  sandybrown: "#f4a460",
+  seagreen: "#2e8b57",
+  seashell: "#fff5ee",
+  sienna: "#a0522d",
+  silver: "#c0c0c0",
+  skyblue: "#87ceeb",
+  slateblue: "#6a5acd",
+  slategray: "#708090",
+  slategrey: "#708090",
+  snow: "#fffafa",
+  springgreen: "#00ff7f",
+  steelblue: "#4682b4",
+  tan: "#d2b48c",
+  teal: "#008080",
+  thistle: "#d8bfd8",
+  tomato: "#ff6347",
+  transparent: "#00000000",
+  turquoise: "#40e0d0",
+  violet: "#ee82ee",
+  wheat: "#f5deb3",
+  white: "#ffffff",
+  whitesmoke: "#f5f5f5",
+  yellow: "#ffff00",
+  yellowgreen: "#9acd32"
+};
+
+// src/color/parse.ts
+var HEX_RE = /^#([0-9a-f]{3}|[0-9a-f]{4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+var RGB_RE = /^rgba?\(([^()]*)\)$/i;
+var HSL_RE = /^hsla?\(([^()]*)\)$/i;
+var OKLAB_RE = /^oklab\(([^()]*)\)$/i;
+var OKLCH_RE = /^oklch\(([^()]*)\)$/i;
+var COLOR_FN_RE = /^color\(([^()]*)\)$/i;
+function parsePercentOrNumber(v, scale) {
+  const text = v.trim();
+  const isPct = text.endsWith("%");
+  const num = Number(isPct ? text.slice(0, -1) : text);
+  if (!Number.isFinite(num)) return null;
+  return isPct ? num / 100 : num / scale;
+}
+function parseAlpha(v) {
+  if (v === void 0 || v.trim() === "") return 1;
+  const text = v.trim();
+  const isPct = text.endsWith("%");
+  const num = Number(isPct ? text.slice(0, -1) : text);
+  if (!Number.isFinite(num)) return null;
+  return isPct ? num / 100 : num;
+}
+function parseAngle(v) {
+  const text = v.trim().toLowerCase();
+  if (text.endsWith("deg")) {
+    const num2 = Number(text.slice(0, -3));
+    return Number.isFinite(num2) ? num2 : null;
+  }
+  if (text.endsWith("turn")) {
+    const num2 = Number(text.slice(0, -4));
+    return Number.isFinite(num2) ? num2 * 360 : null;
+  }
+  if (text.endsWith("rad")) {
+    const num2 = Number(text.slice(0, -3));
+    return Number.isFinite(num2) ? num2 * 180 / Math.PI : null;
+  }
+  const num = Number(text);
+  return Number.isFinite(num) ? num : null;
+}
+function splitParts(inner) {
+  const slashIndex = inner.indexOf("/");
+  let mainStr = inner;
+  let alphaPart;
+  if (slashIndex !== -1) {
+    mainStr = inner.slice(0, slashIndex);
+    alphaPart = inner.slice(slashIndex + 1);
+  }
+  const parts = mainStr.trim().split(/[\s,]+/).filter(Boolean);
+  return { parts, alphaPart };
+}
+function parseColor(input) {
+  if (typeof input === "string") {
+    const text = input.trim();
+    if (text.length === 0 || text.length > 200) return null;
+    const lower = text.toLowerCase();
+    const namedHex = NAMED_COLORS[lower];
+    if (namedHex) {
+      return parseHex(namedHex);
+    }
+    const hexMatch = HEX_RE.exec(text);
+    if (hexMatch) {
+      return parseHex(hexMatch[0]);
+    }
+    const rgbMatch = RGB_RE.exec(text);
+    if (rgbMatch) {
+      const { parts, alphaPart } = splitParts(rgbMatch[1]);
+      let alphaVal = 1;
+      if (alphaPart !== void 0) {
+        alphaVal = parseAlpha(alphaPart);
+      } else if (parts.length === 4) {
+        alphaVal = parseAlpha(parts.pop());
+      }
+      if (parts.length !== 3 || alphaVal === null) return null;
+      const r = parsePercentOrNumber(parts[0], 255);
+      const g = parsePercentOrNumber(parts[1], 255);
+      const b = parsePercentOrNumber(parts[2], 255);
+      if (r === null || g === null || b === null) return null;
+      return { r, g, b, a: alphaVal };
+    }
+    const hslMatch = HSL_RE.exec(text);
+    if (hslMatch) {
+      const { parts, alphaPart } = splitParts(hslMatch[1]);
+      let alphaVal = 1;
+      if (alphaPart !== void 0) {
+        alphaVal = parseAlpha(alphaPart);
+      } else if (parts.length === 4) {
+        alphaVal = parseAlpha(parts.pop());
+      }
+      if (parts.length !== 3 || alphaVal === null) return null;
+      const h = parseAngle(parts[0]);
+      const s = parsePercentOrNumber(parts[1], 100);
+      const l = parsePercentOrNumber(parts[2], 100);
+      if (h === null || s === null || l === null) return null;
+      return hslToRgb({ h, s, l, alpha: alphaVal });
+    }
+    const oklabMatch = OKLAB_RE.exec(text);
+    if (oklabMatch) {
+      const { parts, alphaPart } = splitParts(oklabMatch[1]);
+      let alphaVal = 1;
+      if (alphaPart !== void 0) {
+        alphaVal = parseAlpha(alphaPart);
+      } else if (parts.length === 4) {
+        alphaVal = parseAlpha(parts.pop());
+      }
+      if (parts.length !== 3 || alphaVal === null) return null;
+      const l = parsePercentOrNumber(parts[0], 1);
+      const a = parsePercentOrNumber(parts[1], 1);
+      const b = parsePercentOrNumber(parts[2], 1);
+      if (l === null || a === null || b === null) return null;
+      return oklabToRgb({ l, a, b, alpha: alphaVal });
+    }
+    const oklchMatch = OKLCH_RE.exec(text);
+    if (oklchMatch) {
+      const { parts, alphaPart } = splitParts(oklchMatch[1]);
+      let alphaVal = 1;
+      if (alphaPart !== void 0) {
+        alphaVal = parseAlpha(alphaPart);
+      } else if (parts.length === 4) {
+        alphaVal = parseAlpha(parts.pop());
+      }
+      if (parts.length !== 3 || alphaVal === null) return null;
+      const l = parsePercentOrNumber(parts[0], 1);
+      const c = parsePercentOrNumber(parts[1], 1);
+      const h = parseAngle(parts[2]);
+      if (l === null || c === null || h === null) return null;
+      return oklabToRgb(oklchToOklab({ l, c, h, alpha: alphaVal }));
+    }
+    const colorMatch = COLOR_FN_RE.exec(text);
+    if (colorMatch) {
+      const { parts, alphaPart } = splitParts(colorMatch[1]);
+      if (parts.length < 4) return null;
+      const space = parts[0].toLowerCase();
+      let alphaVal = 1;
+      if (alphaPart !== void 0) {
+        alphaVal = parseAlpha(alphaPart);
+      } else if (parts.length === 5) {
+        alphaVal = parseAlpha(parts.pop());
+      }
+      if (parts.length !== 4 || alphaVal === null) return null;
+      const c1 = parsePercentOrNumber(parts[1], 1);
+      const c2 = parsePercentOrNumber(parts[2], 1);
+      const c3 = parsePercentOrNumber(parts[3], 1);
+      if (c1 === null || c2 === null || c3 === null) return null;
+      if (space === "srgb") {
+        return { r: c1, g: c2, b: c3, a: alphaVal };
+      }
+      if (space === "srgb-linear") {
+        return {
+          r: linearToSrgb(c1),
+          g: linearToSrgb(c2),
+          b: linearToSrgb(c3),
+          a: alphaVal
+        };
+      }
+      if (space === "display-p3") {
+        const linP3R = srgbToLinear(c1);
+        const linP3G = srgbToLinear(c2);
+        const linP3B = srgbToLinear(c3);
+        const linSrgb = displayP3ToLinearSrgb({ r: linP3R, g: linP3G, b: linP3B, a: alphaVal });
+        return {
+          r: linearToSrgb(linSrgb.r),
+          g: linearToSrgb(linSrgb.g),
+          b: linearToSrgb(linSrgb.b),
+          a: alphaVal
+        };
+      }
+      return null;
+    }
+    return null;
+  }
+  if (typeof input === "object" && input !== null) {
+    const obj = input;
+    if (Array.isArray(obj.components)) {
+      const space = obj.colorSpace;
+      if (space === void 0 || space === "srgb") {
+        const [r2, g2, b2] = obj.components;
+        const a2 = typeof obj.alpha === "number" && Number.isFinite(obj.alpha) ? obj.alpha : 1;
+        if ([r2, g2, b2].every((v) => typeof v === "number" && Number.isFinite(v))) {
+          return { r: r2, g: g2, b: b2, a: a2 };
+        }
+      }
+      if (typeof obj.hex === "string") {
+        const base = parseColor(obj.hex);
+        if (!base) return null;
+        const a2 = typeof obj.alpha === "number" && Number.isFinite(obj.alpha) ? obj.alpha : 1;
+        return { r: base.r, g: base.g, b: base.b, a: a2 };
+      }
+      return null;
+    }
+    const { r, g, b } = obj;
+    const a = obj.a === void 0 ? 1 : obj.a;
+    if ([r, g, b, a].every((v) => typeof v === "number" && Number.isFinite(v))) {
+      return { r, g, b, a };
+    }
+  }
+  return null;
+}
+function parseHex(hex) {
+  let raw = hex.trim();
+  if (raw.startsWith("#")) raw = raw.slice(1);
+  if (raw.length === 3 || raw.length === 4) {
+    raw = [...raw].map((c) => c + c).join("");
+  }
+  if (raw.length !== 6 && raw.length !== 8) return null;
+  const r = parseInt(raw.slice(0, 2), 16) / 255;
+  const g = parseInt(raw.slice(2, 4), 16) / 255;
+  const b = parseInt(raw.slice(4, 6), 16) / 255;
+  const a = raw.length === 8 ? parseInt(raw.slice(6, 8), 16) / 255 : 1;
+  return { r, g, b, a };
+}
+function isColor(input) {
+  return parseColor(input) !== null;
+}
+
+// src/color/gamut.ts
+var clamp01 = (v) => Math.min(1, Math.max(0, v));
+function inSrgbGamut(c, epsilon = 1e-5) {
+  return c.r >= -epsilon && c.r <= 1 + epsilon && c.g >= -epsilon && c.g <= 1 + epsilon && c.b >= -epsilon && c.b <= 1 + epsilon;
+}
+function deltaEOK(a, b) {
+  const la = rgbToOklab(a);
+  const lb = rgbToOklab(b);
+  return Math.hypot(la.l - lb.l, la.a - lb.a, la.b - lb.b);
+}
+function toSrgbGamut(c) {
+  const lch = oklabToOklch(rgbToOklab(c));
+  if (lch.l >= 1) return { r: 1, g: 1, b: 1, a: c.a };
+  if (lch.l <= 0) return { r: 0, g: 0, b: 0, a: c.a };
+  if (inSrgbGamut(c)) {
+    return { r: clamp01(c.r), g: clamp01(c.g), b: clamp01(c.b), a: c.a };
+  }
+  let low = 0;
+  let high = lch.c;
+  let clippedCandidate = { r: clamp01(c.r), g: clamp01(c.g), b: clamp01(c.b), a: c.a };
+  const JND = 0.02;
+  const EPS = 1e-4;
+  for (let i = 0; i < 30; i++) {
+    const mid = (low + high) / 2;
+    const candidate = oklabToRgb(oklchToOklab({ l: lch.l, c: mid, h: lch.h, alpha: c.a }));
+    const clipped = {
+      r: clamp01(candidate.r),
+      g: clamp01(candidate.g),
+      b: clamp01(candidate.b),
+      a: c.a
+    };
+    clippedCandidate = clipped;
+    const dE = deltaEOK(candidate, clipped);
+    if (dE < JND) {
+      if (JND - dE < EPS) {
+        return clipped;
+      }
+      low = mid;
+    } else {
+      high = mid;
+    }
+    if (high - low < 1e-4) {
+      break;
+    }
+  }
+  return clippedCandidate;
+}
+
+// src/color/format.ts
+var clamp012 = (v) => Math.min(1, Math.max(0, v));
+var byte = (v) => Math.round(clamp012(v) * 255);
+var hex2 = (n) => n.toString(16).padStart(2, "0");
+var round2 = (n) => (Math.round(n * 100) / 100).toString();
+function formatHex(c) {
+  const mapped = toSrgbGamut(c);
+  const head = `#${hex2(byte(mapped.r))}${hex2(byte(mapped.g))}${hex2(byte(mapped.b))}`;
+  const alpha = byte(mapped.a);
+  return alpha === 255 ? head : head + hex2(alpha);
+}
+function formatColor(c, format) {
+  switch (format) {
+    case "hex":
+      return formatHex(c);
+    case "rgb": {
+      const inGamut = toSrgbGamut(c);
+      const r = byte(inGamut.r);
+      const g = byte(inGamut.g);
+      const b = byte(inGamut.b);
+      return c.a < 1 ? `rgb(${r} ${g} ${b} / ${round2(c.a)})` : `rgb(${r} ${g} ${b})`;
+    }
+    case "hsl": {
+      const hsl = rgbToHsl(toSrgbGamut(c));
+      const h = (Math.round(hsl.h * 100) / 100).toString();
+      const s = (Math.round(hsl.s * 1e4) / 100).toString();
+      const l = (Math.round(hsl.l * 1e4) / 100).toString();
+      return c.a < 1 ? `hsl(${h} ${s}% ${l}% / ${round2(c.a)})` : `hsl(${h} ${s}% ${l}%)`;
+    }
+    case "oklch": {
+      const lch = oklabToOklch(rgbToOklab(c));
+      const l = (lch.l * 100).toFixed(2);
+      const ch = lch.c.toFixed(4);
+      const h = lch.h.toFixed(2);
+      return c.a < 1 ? `oklch(${l}% ${ch} ${h} / ${round2(c.a)})` : `oklch(${l}% ${ch} ${h})`;
+    }
+    case "oklab": {
+      const lab = rgbToOklab(c);
+      const l = (lab.l * 100).toFixed(2);
+      const a = lab.a.toFixed(4);
+      const b = lab.b.toFixed(4);
+      return c.a < 1 ? `oklab(${l}% ${a} ${b} / ${round2(c.a)})` : `oklab(${l}% ${a} ${b})`;
+    }
+    case "p3": {
+      const linSrgb = {
+        r: srgbToLinear(c.r),
+        g: srgbToLinear(c.g),
+        b: srgbToLinear(c.b),
+        a: c.a
+      };
+      const linP3 = linearSrgbToDisplayP3(linSrgb);
+      const r = linearToSrgb(linP3.r).toFixed(4);
+      const g = linearToSrgb(linP3.g).toFixed(4);
+      const b = linearToSrgb(linP3.b).toFixed(4);
+      return c.a < 1 ? `color(display-p3 ${r} ${g} ${b} / ${round2(c.a)})` : `color(display-p3 ${r} ${g} ${b})`;
+    }
+  }
+}
+function normalizeColor(input) {
+  const parsed = parseColor(input);
+  return parsed ? formatHex(parsed) : null;
+}
+
+// src/color/contrast.ts
+var BLACK = { r: 0, g: 0, b: 0, a: 1 };
+var WHITE = { r: 1, g: 1, b: 1, a: 1 };
+function composite(fg, bg) {
+  const a = fg.a + bg.a * (1 - fg.a);
+  if (a === 0) return { r: 0, g: 0, b: 0, a: 0 };
+  return {
+    r: (fg.r * fg.a + bg.r * bg.a * (1 - fg.a)) / a,
+    g: (fg.g * fg.a + bg.g * bg.a * (1 - fg.a)) / a,
+    b: (fg.b * fg.a + bg.b * bg.a * (1 - fg.a)) / a,
+    a
+  };
+}
+function relativeLuminance(c) {
+  const r = srgbToLinear(c.r);
+  const g = srgbToLinear(c.g);
+  const b = srgbToLinear(c.b);
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+function contrastRatio(foreground, background) {
+  let bg = background;
+  if (bg.a < 1) {
+    bg = composite(bg, WHITE);
+  }
+  let fg = foreground;
+  if (fg.a < 1) {
+    fg = composite(fg, bg);
+  }
+  const lum1 = relativeLuminance(fg);
+  const lum2 = relativeLuminance(bg);
+  const brighter = Math.max(lum1, lum2);
+  const darker = Math.min(lum1, lum2);
+  return (brighter + 0.05) / (darker + 0.05);
+}
+function contrastLevel(ratio, options) {
+  const large = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _2 => _2.large]), () => ( false));
+  if (large) {
+    if (ratio >= 4.5) return "AAA";
+    if (ratio >= 3) return "AA";
+    return "fail";
+  }
+  if (ratio >= 7) return "AAA";
+  if (ratio >= 4.5) return "AA";
+  return "fail";
+}
+function readableTextColor(background, candidates = [BLACK, WHITE]) {
+  let bestCandidate = _nullishCoalesce(candidates[0], () => ( BLACK));
+  let bestRatio = -1;
+  for (const candidate of candidates) {
+    const ratio = contrastRatio(candidate, background);
+    if (ratio > bestRatio) {
+      bestRatio = ratio;
+      bestCandidate = candidate;
+    }
+  }
+  return bestCandidate;
+}
+
+// src/color/vision.ts
+var CVD = {
+  protanopia: [
+    [0.152286, 1.052583, -0.204868],
+    [0.114503, 0.786281, 0.099216],
+    [-3882e-6, -0.048116, 1.051998]
+  ],
+  deuteranopia: [
+    [0.367322, 0.860646, -0.227968],
+    [0.280085, 0.672501, 0.047413],
+    [-0.01182, 0.04294, 0.968881]
+  ],
+  tritanopia: [
+    [1.255528, -0.076749, -0.178779],
+    [-0.078411, 0.930809, 0.147602],
+    [4733e-6, 0.691367, 0.3039]
+  ]
+};
+var clamp013 = (v) => Math.max(0, Math.min(1, v));
+function simulateColorVision(c, vision) {
+  if (vision === "normal") return c;
+  const lr = srgbToLinear(c.r);
+  const lg = srgbToLinear(c.g);
+  const lb = srgbToLinear(c.b);
+  const m = CVD[vision];
+  const r = linearToSrgb(clamp013(m[0][0] * lr + m[0][1] * lg + m[0][2] * lb));
+  const g = linearToSrgb(clamp013(m[1][0] * lr + m[1][1] * lg + m[1][2] * lb));
+  const b = linearToSrgb(clamp013(m[2][0] * lr + m[2][1] * lg + m[2][2] * lb));
+  return { r, g, b, a: c.a };
+}
+function checkPaletteColors(colors, options = {}) {
+  const surfaceStr = _nullishCoalesce(options.surface, () => ( "#ffffff"));
+  const minDistance = _nullishCoalesce(options.minDistance, () => ( 0.08));
+  const minContrast = _nullishCoalesce(options.minContrast, () => ( 1.5));
+  const visions = _nullishCoalesce(options.visions, () => ( ["normal", "protanopia", "deuteranopia", "tritanopia"]));
+  const parsed = colors.map((c) => parseColor(c));
+  const surfaceParsed = parseColor(surfaceStr);
+  const skipped = colors.filter((_, i) => !parsed[i]);
+  const issues = [];
+  const closest = {};
+  for (const vision of visions) {
+    const seen = parsed.map((c) => c ? simulateColorVision(c, vision) : null);
+    let best;
+    for (let a = 0; a < seen.length; a++) {
+      for (let b = a + 1; b < seen.length; b++) {
+        if (!seen[a] || !seen[b]) continue;
+        const distance = deltaEOK(seen[a], seen[b]);
+        if (!best || distance < best.distance) {
+          best = {
+            a,
+            b,
+            colors: [colors[a], colors[b]],
+            distance: Math.round(distance * 1e3) / 1e3
+          };
+        }
+      }
+    }
+    if (best) {
+      closest[vision] = best;
+      if (best.distance < minDistance) {
+        const who = vision === "normal" ? "" : ` with ${vision}`;
+        issues.push(
+          `Colours ${best.a + 1} (${best.colors[0]}) and ${best.b + 1} (${best.colors[1]}) are hard to tell apart${who} (distance ${best.distance}, want at least ${minDistance}).`
+        );
+      }
+    }
+  }
+  const contrast = colors.map((_, i) => {
+    const c = parsed[i];
+    if (!c || !surfaceParsed) return null;
+    const ratio = contrastRatio(c, surfaceParsed);
+    return Math.round(ratio * 100) / 100;
+  });
+  contrast.forEach((ratio, i) => {
+    if (ratio !== null && ratio < minContrast) {
+      issues.push(
+        `Colour ${i + 1} (${colors[i]}) barely stands out from the background ${surfaceStr} (contrast ${ratio}:1, want at least ${minContrast}:1).`
+      );
+    }
+  });
+  return { ok: issues.length === 0, closest, contrast, issues, skipped };
+}
+
+// src/color/harmony.ts
+var HARMONY_KINDS = [
+  "complementary",
+  "split-complementary",
+  "analogous",
+  "triadic",
+  "tetradic",
+  "square",
+  "monochromatic"
+];
+var HEX_6 = /^#?([0-9a-f]{6})$/i;
+function parseHex2(value, what = "color") {
+  const m = typeof value === "string" ? HEX_6.exec(value.trim()) : null;
+  if (!m) throw new Error(`${what} is ${JSON.stringify(value)}; use #rrggbb, e.g. "#2a4b8d".`);
+  const n = parseInt(m[1], 16);
+  return { r: (n >> 16 & 255) / 255, g: (n >> 8 & 255) / 255, b: (n & 255) / 255, a: 1 };
+}
+function toHex(c) {
+  return "#" + [c.r, c.g, c.b].map((v) => Math.round(Math.min(1, Math.max(0, v)) * 255).toString(16).padStart(2, "0")).join("");
+}
+var RYB_STOPS = [
+  [0, 0],
+  [60, 30],
+  [120, 60],
+  [180, 120],
+  [240, 240],
+  [300, 280],
+  [360, 360]
+];
+function piecewise(v, from) {
+  const x = (v % 360 + 360) % 360;
+  const to = from === 0 ? 1 : 0;
+  for (let i = 1; i < RYB_STOPS.length; i++) {
+    const a = RYB_STOPS[i - 1];
+    const b = RYB_STOPS[i];
+    if (x <= b[from]) return a[to] + (x - a[from]) / (b[from] - a[from]) * (b[to] - a[to]);
+  }
+  return x;
+}
+function wheelToHue(angle, wheel) {
+  return wheel === "rgb" ? (angle % 360 + 360) % 360 : piecewise(angle, 0);
+}
+function hueToWheel(hue, wheel) {
+  return wheel === "rgb" ? (hue % 360 + 360) % 360 : piecewise(hue, 1);
+}
+function colorHarmony(base, kind, options = {}) {
+  const wheel = _nullishCoalesce(options.wheel, () => ( "ryb"));
+  const rgb = parseHex2(base, "base");
+  const hsv = rgbToHsv(rgb);
+  const start = hueToWheel(hsv.h, wheel);
+  const at = (angle) => {
+    const a = (angle % 360 + 360) % 360;
+    return { color: toHex(hsvToRgb({ ...hsv, h: wheelToHue(a, wheel) })), angle: Math.round(a * 10) / 10 };
+  };
+  const spread = _nullishCoalesce(options.spread, () => ( 30));
+  const offsets = {
+    complementary: [0, 180],
+    "split-complementary": [0, 180 - spread, 180 + spread],
+    analogous: [0, -spread, spread],
+    triadic: [0, 120, 240],
+    tetradic: [0, 60, 180, 240],
+    square: [0, 90, 180, 270]
+  };
+  if (kind === "monochromatic") {
+    const hsl = rgbToHsl(rgb);
+    const steps = [0, -0.3, -0.15, 0.15, 0.3];
+    return steps.map((d) => {
+      const c = d === 0 ? rgb : hslToRgb({ ...hsl, l: Math.min(0.97, Math.max(0.03, hsl.l + d)) });
+      return { color: toHex(c), angle: Math.round(start * 10) / 10 };
+    });
+  }
+  return offsets[kind].map(
+    (o, i) => i === 0 ? { color: toHex(rgb), angle: Math.round(start * 10) / 10 } : at(start + o)
+  );
+}
+
+// src/color/mix.ts
+function mixColors(from, to, t, options = {}) {
+  const c1 = parseColor(from);
+  const c2 = parseColor(to);
+  if (!c1 || !c2) return null;
+  const space = _nullishCoalesce(options.space, () => ( "oklab"));
+  const alpha = c1.a + (c2.a - c1.a) * t;
+  if (space === "oklab") {
+    const lab1 = rgbToOklab(c1);
+    const lab2 = rgbToOklab(c2);
+    if (alpha <= 1e-9) {
+      const lab3 = { l: lab1.l + (lab2.l - lab1.l) * t, a: 0, b: 0, alpha: 0 };
+      return formatHex(oklabToRgb(lab3));
+    }
+    const premul = (k) => lab1[k] * lab1.alpha + (lab2[k] * lab2.alpha - lab1[k] * lab1.alpha) * t;
+    const lab = {
+      l: premul("l") / alpha,
+      a: premul("a") / alpha,
+      b: premul("b") / alpha,
+      alpha
+    };
+    return formatHex(oklabToRgb(lab));
+  }
+  if (space === "oklch") {
+    const lch1 = oklabToOklch(rgbToOklab(c1));
+    const lch2 = oklabToOklch(rgbToOklab(c2));
+    let h1 = lch1.h;
+    let h2 = lch2.h;
+    const diff = h2 - h1;
+    if (diff > 180) h2 -= 360;
+    else if (diff < -180) h2 += 360;
+    const h = ((h1 + (h2 - h1) * t) % 360 + 360) % 360;
+    if (alpha <= 1e-9) {
+      const l2 = lch1.l + (lch2.l - lch1.l) * t;
+      return formatHex(oklabToRgb(oklchToOklab({ l: l2, c: 0, h: 0, alpha: 0 })));
+    }
+    const lPremul = lch1.l * lch1.alpha + (lch2.l * lch2.alpha - lch1.l * lch1.alpha) * t;
+    const cPremul = lch1.c * lch1.alpha + (lch2.c * lch2.alpha - lch1.c * lch1.alpha) * t;
+    const l = lPremul / alpha;
+    const c = cPremul / alpha;
+    return formatHex(oklabToRgb(oklchToOklab({ l, c, h, alpha })));
+  }
+  if (space === "srgb-linear") {
+    const lr1 = srgbToLinear(c1.r);
+    const lg1 = srgbToLinear(c1.g);
+    const lb1 = srgbToLinear(c1.b);
+    const lr2 = srgbToLinear(c2.r);
+    const lg2 = srgbToLinear(c2.g);
+    const lb2 = srgbToLinear(c2.b);
+    if (alpha <= 1e-9) {
+      return formatHex({
+        r: linearToSrgb(lr1 + (lr2 - lr1) * t),
+        g: linearToSrgb(lg1 + (lg2 - lg1) * t),
+        b: linearToSrgb(lb1 + (lb2 - lb1) * t),
+        a: 0
+      });
+    }
+    const premulR2 = lr1 * c1.a + (lr2 * c2.a - lr1 * c1.a) * t;
+    const premulG2 = lg1 * c1.a + (lg2 * c2.a - lg1 * c1.a) * t;
+    const premulB2 = lb1 * c1.a + (lb2 * c2.a - lb1 * c1.a) * t;
+    return formatHex({
+      r: linearToSrgb(premulR2 / alpha),
+      g: linearToSrgb(premulG2 / alpha),
+      b: linearToSrgb(premulB2 / alpha),
+      a: alpha
+    });
+  }
+  if (alpha <= 1e-9) {
+    return formatHex({
+      r: c1.r + (c2.r - c1.r) * t,
+      g: c1.g + (c2.g - c1.g) * t,
+      b: c1.b + (c2.b - c1.b) * t,
+      a: 0
+    });
+  }
+  const premulR = c1.r * c1.a + (c2.r * c2.a - c1.r * c1.a) * t;
+  const premulG = c1.g * c1.a + (c2.g * c2.a - c1.g * c1.a) * t;
+  const premulB = c1.b * c1.a + (c2.b * c2.a - c1.b * c1.a) * t;
+  return formatHex({
+    r: premulR / alpha,
+    g: premulG / alpha,
+    b: premulB / alpha,
+    a: alpha
+  });
+}
+
+// src/color/recent.ts
+function pushRecentColor(list, color, max = 12) {
+  const normal = normalizeColor(color);
+  if (!normal) return list.slice();
+  const next = [normal, ...list.filter((c) => normalizeColor(c) !== normal)];
+  return next.slice(0, max);
+}
+
+// src/color/dual.ts
+var DEFAULT_SCHEME_SURFACES = {
+  light: "#ffffff",
+  dark: "#0b0b0f"
+};
+var clamp = (v, min, max) => Math.min(max, Math.max(min, v));
+function isDualColor(value) {
+  return typeof value === "object" && value !== null && typeof value.light === "string" && typeof value.dark === "string";
+}
+function parseDualColor(input) {
+  if (input === null || input === void 0) return null;
+  if (isDualColor(input)) {
+    if (parseColor(input.light) === null || parseColor(input.dark) === null) {
+      return null;
+    }
+    return { light: input.light, dark: input.dark };
+  }
+  if (typeof input === "string") {
+    const trimmed = input.trim();
+    if (trimmed.toLowerCase().startsWith("light-dark(") && trimmed.endsWith(")")) {
+      const inner = trimmed.slice("light-dark(".length, -1).trim();
+      if (inner.toLowerCase().includes("light-dark(")) {
+        return null;
+      }
+      let depth = 0;
+      let commaIndex = -1;
+      for (let i = 0; i < inner.length; i++) {
+        const char = inner[i];
+        if (char === "(") {
+          depth++;
+        } else if (char === ")") {
+          depth--;
+          if (depth < 0) return null;
+        } else if (char === "," && depth === 0) {
+          if (commaIndex !== -1) {
+            return null;
+          }
+          commaIndex = i;
+        }
+      }
+      if (depth !== 0 || commaIndex === -1) {
+        return null;
+      }
+      const lightPart = inner.slice(0, commaIndex).trim();
+      const darkPart = inner.slice(commaIndex + 1).trim();
+      if (!lightPart || !darkPart) return null;
+      if (parseColor(lightPart) === null || parseColor(darkPart) === null) {
+        return null;
+      }
+      return { light: lightPart, dark: darkPart };
+    }
+    if (parseColor(trimmed) !== null) {
+      return { light: trimmed, dark: trimmed };
+    }
+  }
+  return null;
+}
+function normalizeDualColor(input) {
+  const parsed = parseDualColor(input);
+  if (!parsed) return null;
+  const light = normalizeColor(parsed.light);
+  const dark = normalizeColor(parsed.dark);
+  if (!light || !dark) return null;
+  return { light, dark };
+}
+function resolveColor(value, scheme) {
+  const normalized = normalizeDualColor(value);
+  if (!normalized) return null;
+  return scheme === "dark" ? normalized.dark : normalized.light;
+}
+function formatDualColor(value) {
+  const light = _nullishCoalesce(normalizeColor(value.light), () => ( value.light));
+  const dark = _nullishCoalesce(normalizeColor(value.dark), () => ( value.dark));
+  if (light === dark) {
+    return light;
+  }
+  return `light-dark(${light}, ${dark})`;
+}
+function isSameInBothSchemes(value) {
+  const light = normalizeColor(value.light);
+  const dark = normalizeColor(value.dark);
+  if (!light || !dark) return value.light === value.dark;
+  return light === dark;
+}
+function setDualColorSide(value, scheme, color) {
+  const base = _nullishCoalesce(normalizeDualColor(value), () => ( { light: "#000000", dark: "#000000" }));
+  const normColor = _nullishCoalesce(normalizeColor(color), () => ( color));
+  return {
+    light: scheme === "light" ? normColor : base.light,
+    dark: scheme === "dark" ? normColor : base.dark
+  };
+}
+function deriveDualColor(color, options) {
+  const fromScheme = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _3 => _3.from]), () => ( "light"));
+  const baseRgba = parseColor(color);
+  if (!baseRgba) {
+    throw new Error(`"${String(color)}" is not a colour; pass hex, rgb(), hsl(), oklch() or a CSS colour name.`);
+  }
+  if (_optionalChain([options, 'optionalAccess', _4 => _4.surfaces]) && !normalizeDualColor(options.surfaces)) {
+    throw new Error('The surfaces need a readable light and dark colour, e.g. { light: "#ffffff", dark: "#0b0b0f" }.');
+  }
+  const baseHex = formatHex(baseRgba);
+  const lab = rgbToOklab(baseRgba);
+  const lch = oklabToOklch(lab);
+  const startL = clamp(1.05 - lch.l, 0.12, 0.95);
+  const targetC = lch.c * 0.9;
+  const targetH = lch.h;
+  let derivedHex;
+  if (_optionalChain([options, 'optionalAccess', _5 => _5.surfaces])) {
+    const surfaces = options.surfaces;
+    const fromSurfaceRgba = parseColor(surfaces[fromScheme]);
+    const targetScheme = fromScheme === "light" ? "dark" : "light";
+    const targetSurfaceRgba = parseColor(surfaces[targetScheme]);
+    const targetRatio = contrastRatio(baseRgba, fromSurfaceRgba);
+    const targetSurfaceL = oklabToOklch(rgbToOklab(targetSurfaceRgba)).l;
+    const preferHigherL = targetSurfaceL < 0.5;
+    let bestDiff = Infinity;
+    let bestL = startL;
+    for (let candL = 0.05; candL <= 0.98; candL += 5e-3) {
+      const candRgb = toSrgbGamut(
+        oklabToRgb(oklchToOklab({ l: candL, c: targetC, h: targetH, alpha: baseRgba.a }))
+      );
+      const ratio = contrastRatio(candRgb, targetSurfaceRgba);
+      const diff = Math.abs(ratio - targetRatio);
+      const isBetter = diff < bestDiff - 1e-4 || Math.abs(diff - bestDiff) <= 1e-4 && (preferHigherL ? candL > bestL : candL < bestL);
+      if (isBetter) {
+        bestDiff = diff;
+        bestL = candL;
+      }
+    }
+    const finalRgba = toSrgbGamut(
+      oklabToRgb(oklchToOklab({ l: bestL, c: targetC, h: targetH, alpha: baseRgba.a }))
+    );
+    derivedHex = formatHex(finalRgba);
+  } else {
+    const finalRgba = toSrgbGamut(
+      oklabToRgb(oklchToOklab({ l: startL, c: targetC, h: targetH, alpha: baseRgba.a }))
+    );
+    derivedHex = formatHex(finalRgba);
+  }
+  return fromScheme === "light" ? { light: baseHex, dark: derivedHex } : { light: derivedHex, dark: baseHex };
+}
+function checkDualColorContrast(foreground, background, options) {
+  const large = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _6 => _6.large]), () => ( false));
+  const requiredRatio = large ? 3 : 4.5;
+  const fg = normalizeDualColor(foreground);
+  const bg = normalizeDualColor(background);
+  if (!fg) throw new Error(`The foreground "${describeValue(foreground)}" is not a colour, light-dark() or { light, dark }.`);
+  if (!bg) throw new Error(`The background "${describeValue(background)}" is not a colour, light-dark() or { light, dark }.`);
+  const lightFgHex = fg.light;
+  const lightBgHex = bg.light;
+  const darkFgHex = fg.dark;
+  const darkBgHex = bg.dark;
+  const lightFg = parseColor(lightFgHex);
+  const lightBg = parseColor(lightBgHex);
+  const darkFg = parseColor(darkFgHex);
+  const darkBg = parseColor(darkBgHex);
+  const lightRatio = Math.round(contrastRatio(lightFg, lightBg) * 100) / 100;
+  const darkRatio = Math.round(contrastRatio(darkFg, darkBg) * 100) / 100;
+  const lightLevel = contrastLevel(lightRatio, { large });
+  const darkLevel = contrastLevel(darkRatio, { large });
+  const issues = [];
+  if (lightLevel === "fail") {
+    issues.push(
+      `In light mode, ${lightFgHex} on ${lightBgHex} has a contrast of ${lightRatio.toFixed(1)} (needs ${requiredRatio} for AA).`
+    );
+  }
+  if (darkLevel === "fail") {
+    issues.push(
+      `In dark mode, ${darkFgHex} on ${darkBgHex} has a contrast of ${darkRatio.toFixed(1)} (needs ${requiredRatio} for AA).`
+    );
+  }
+  return {
+    light: { ratio: lightRatio, level: lightLevel },
+    dark: { ratio: darkRatio, level: darkLevel },
+    issues
+  };
+}
+var CSS_VARIABLE_NAME = /^[A-Za-z_][A-Za-z0-9_-]*$/;
+function describeValue(value) {
+  return typeof value === "string" ? value : _nullishCoalesce(JSON.stringify(value), () => ( String(value)));
+}
+function dualColorsToCss(colors, options) {
+  const selector = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _7 => _7.selector]), () => ( ":root"));
+  const strategy = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _8 => _8.strategy]), () => ( "light-dark"));
+  const darkSelector = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _9 => _9.darkSelector]), () => ( ".dark"));
+  for (const [label, sel] of [["selector", selector], ["darkSelector", darkSelector]]) {
+    if (!sel.trim() || /[{};]/.test(sel)) {
+      throw new Error(`The ${label} "${sel}" is not a CSS selector (it can't be empty or contain "{", "}" or ";").`);
+    }
+  }
+  const normalized = {};
+  for (const [key, value] of Object.entries(colors)) {
+    if (!CSS_VARIABLE_NAME.test(key)) {
+      throw new Error(`"${key}" is not a CSS variable name; use letters, digits, "-" and "_" without the leading "--" (e.g. "brand-color").`);
+    }
+    const dual = normalizeDualColor(value);
+    if (!dual) throw new Error(`"${key}" has "${describeValue(value)}", which is not a colour, light-dark() or { light, dark }.`);
+    normalized[key] = dual;
+  }
+  const sortedKeys = Object.keys(normalized).sort();
+  switch (strategy) {
+    case "light-dark": {
+      const lines = [
+        `${selector} {`,
+        ...selector === ":root" ? ["  color-scheme: light dark;"] : [],
+        ...sortedKeys.map((k) => {
+          return `  --${k}: ${formatDualColor(normalized[k])};`;
+        }),
+        "}"
+      ];
+      return lines.join("\n");
+    }
+    case "media": {
+      const lightLines = [
+        `${selector} {`,
+        ...sortedKeys.map((k) => `  --${k}: ${normalized[k].light};`),
+        "}"
+      ];
+      const darkLines = [
+        `@media (prefers-color-scheme: dark) {`,
+        `  ${selector} {`,
+        ...sortedKeys.map((k) => `    --${k}: ${normalized[k].dark};`),
+        `  }`,
+        `}`
+      ];
+      return `${lightLines.join("\n")}
+
+${darkLines.join("\n")}`;
+    }
+    case "class": {
+      const lightLines = [
+        `${selector} {`,
+        ...sortedKeys.map((k) => `  --${k}: ${normalized[k].light};`),
+        "}"
+      ];
+      const darkLines = [
+        `${darkSelector} {`,
+        ...sortedKeys.map((k) => `  --${k}: ${normalized[k].dark};`),
+        "}"
+      ];
+      return `${lightLines.join("\n")}
+
+${darkLines.join("\n")}`;
+    }
+  }
+}
+
+// src/color/tools.ts
+var READ = { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false };
+var fail = (message) => {
+  throw new Error(message);
+};
+var COLOR_PARAM_DESC = "Any CSS colour: hex, rgb(), hsl(), oklch(), oklab(), color(display-p3 \u2026) or a name.";
+var DUAL_COLOR_PARAM_DESC = "Any CSS colour, light-dark(#light, #dark) string, or { light, dark } object.";
+var DUAL_COLOR_SCHEMA = {
+  oneOf: [
+    { type: "string", description: "Plain CSS colour or light-dark() syntax." },
+    {
+      type: "object",
+      properties: {
+        light: { type: "string", description: "CSS colour for light scheme." },
+        dark: { type: "string", description: "CSS colour for dark scheme." }
+      },
+      required: ["light", "dark"],
+      additionalProperties: false
+    }
+  ],
+  description: DUAL_COLOR_PARAM_DESC
+};
+function requireColor(input, name) {
+  if (typeof input === "string" && input.trim().toLowerCase().startsWith("light-dark(")) {
+    fail("This is a dual colour (light-dark); use check_dual_color_contrast, or pass one half.");
+  }
+  if (typeof input !== "string" || !input.trim()) {
+    fail(`"${String(input)}" is not a colour I can read; use hex (#2a4b8d), rgb(), hsl(), oklch() or a CSS colour name.`);
+  }
+  const parsed = parseColor(input);
+  if (!parsed) {
+    fail(`"${input}" is not a colour I can read; use hex (#2a4b8d), rgb(), hsl(), oklch() or a CSS colour name.`);
+  }
+  return parsed;
+}
+function requireDualColor(input, name) {
+  const parsed = normalizeDualColor(input);
+  if (!parsed) {
+    fail(`"${String(input)}" is not a dual colour I can read; use a CSS colour, light-dark(), or { light, dark }.`);
+  }
+  return parsed;
+}
+function findAccessibleLightness(fg, bg, large) {
+  const lab = rgbToOklab(fg);
+  const lch = oklabToOklch(lab);
+  for (let d = 0.01; d <= 1; d += 0.01) {
+    const downL = Math.max(0, lch.l - d);
+    const upL = Math.min(1, lch.l + d);
+    const downCand = toSrgbGamut(oklabToRgb(oklchToOklab({ ...lch, l: downL })));
+    const upCand = toSrgbGamut(oklabToRgb(oklchToOklab({ ...lch, l: upL })));
+    const downRatio = contrastRatio(downCand, bg);
+    const upRatio = contrastRatio(upCand, bg);
+    const downPass = contrastLevel(downRatio, { large }) !== "fail";
+    const upPass = contrastLevel(upRatio, { large }) !== "fail";
+    if (downPass && upPass) {
+      return formatHex(downRatio >= upRatio ? downCand : upCand);
+    } else if (downPass) {
+      return formatHex(downCand);
+    } else if (upPass) {
+      return formatHex(upCand);
+    }
+  }
+  return void 0;
+}
+function createColorToolProvider(options = {}) {
+  const id = _nullishCoalesce(options.id, () => ( "color"));
+  const namespace = _nullishCoalesce(options.namespace, () => ( "color"));
+  const inspectColor = {
+    name: "inspect_color",
+    title: "Inspect colour",
+    description: "Inspects a colour string across multiple colour spaces and formats, reporting hex, sRGB channels, HSL, OKLCH, wide-gamut status, gamut-mapped fallback, and relative luminance.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        color: { type: "string", description: COLOR_PARAM_DESC }
+      },
+      required: ["color"],
+      additionalProperties: false
+    },
+    annotations: { title: "Inspect colour", ...READ },
+    handler: (args) => {
+      const { color } = args;
+      const rgba = requireColor(color, "color");
+      const inGamut = inSrgbGamut(rgba);
+      const mappedRgba = inGamut ? rgba : toSrgbGamut(rgba);
+      const hsl = rgbToHsl(mappedRgba);
+      const oklab = rgbToOklab(rgba);
+      const oklch = oklabToOklch(oklab);
+      const formats = ["hex", "rgb", "hsl", "oklab", "oklch"];
+      const css = {};
+      for (const f of formats) {
+        css[f] = formatColor(rgba, f);
+      }
+      return {
+        hex: formatHex(mappedRgba),
+        alpha: Math.round(rgba.a * 1e3) / 1e3,
+        rgb: {
+          r: Math.round(Math.min(1, Math.max(0, mappedRgba.r)) * 255),
+          g: Math.round(Math.min(1, Math.max(0, mappedRgba.g)) * 255),
+          b: Math.round(Math.min(1, Math.max(0, mappedRgba.b)) * 255)
+        },
+        hsl: {
+          h: Math.round(hsl.h * 10) / 10,
+          s: Math.round(hsl.s * 1e3) / 1e3,
+          l: Math.round(hsl.l * 1e3) / 1e3
+        },
+        oklch: {
+          l: Math.round(oklch.l * 1e3) / 1e3,
+          c: Math.round(oklch.c * 1e3) / 1e3,
+          h: Math.round(oklch.h * 10) / 10
+        },
+        css,
+        inSrgbGamut: inGamut,
+        ...inGamut ? {} : { gamutMappedHex: formatHex(mappedRgba) },
+        relativeLuminance: Math.round(relativeLuminance(mappedRgba) * 1e4) / 1e4
+      };
+    }
+  };
+  const checkColorContrast = {
+    name: "check_color_contrast",
+    title: "Check colour contrast",
+    description: "Calculates WCAG 2 contrast ratio between foreground and background colours, checks AA and AAA thresholds, and suggests an adjusted foreground when contrast fails.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        foreground: { type: "string", description: `Foreground text colour. ${COLOR_PARAM_DESC}` },
+        background: { type: "string", description: `Background surface colour. ${COLOR_PARAM_DESC}` },
+        large: { type: "boolean", description: "Whether the text is large (at least 18pt / 24px regular, or 14pt / 18.5px bold). Default false." }
+      },
+      required: ["foreground", "background"],
+      additionalProperties: false
+    },
+    annotations: { title: "Check colour contrast", ...READ },
+    handler: (args) => {
+      const { foreground, background, large = false } = args;
+      const fg = requireColor(foreground, "foreground");
+      const bg = requireColor(background, "background");
+      const ratio = Math.round(contrastRatio(fg, bg) * 100) / 100;
+      const level = contrastLevel(ratio, { large });
+      const passesAA = level === "AA" || level === "AAA";
+      const passesAAA = level === "AAA";
+      let suggestion;
+      if (!passesAA) {
+        const lab = rgbToOklab(fg);
+        const lch = oklabToOklch(lab);
+        for (let d = 0.01; d <= 1; d += 0.01) {
+          const downL = Math.max(0, lch.l - d);
+          const upL = Math.min(1, lch.l + d);
+          const downCand = toSrgbGamut(oklabToRgb(oklchToOklab({ ...lch, l: downL })));
+          const upCand = toSrgbGamut(oklabToRgb(oklchToOklab({ ...lch, l: upL })));
+          const downRatio = contrastRatio(downCand, bg);
+          const upRatio = contrastRatio(upCand, bg);
+          const downPass = contrastLevel(downRatio, { large }) !== "fail";
+          const upPass = contrastLevel(upRatio, { large }) !== "fail";
+          if (downPass && upPass) {
+            suggestion = formatHex(downRatio >= upRatio ? downCand : upCand);
+            break;
+          } else if (downPass) {
+            suggestion = formatHex(downCand);
+            break;
+          } else if (upPass) {
+            suggestion = formatHex(upCand);
+            break;
+          }
+        }
+      }
+      return {
+        ratio,
+        level,
+        passesAA,
+        passesAAA,
+        ...suggestion ? { suggestion } : {}
+      };
+    }
+  };
+  const checkColorPalette = {
+    name: "check_color_palette",
+    title: "Check colour palette",
+    description: "Audits a palette of colours for mutual distinctness under normal vision and colour-vision deficiencies (protanopia, deuteranopia, tritanopia), and checks contrast against a surface.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        colors: {
+          type: "array",
+          items: { type: "string" },
+          minItems: 2,
+          description: "List of at least two palette colours to check."
+        },
+        surface: { type: "string", description: `Background / surface colour (default '#ffffff'). ${COLOR_PARAM_DESC}` },
+        minDistance: { type: "number", description: "Minimum perceptual OKLab distance between series colours (default 0.08)." },
+        minContrast: { type: "number", description: "Minimum contrast ratio against the surface (default 1.5)." },
+        visions: {
+          type: "array",
+          items: { type: "string", enum: ["normal", "protanopia", "deuteranopia", "tritanopia"] },
+          description: "Colour-vision conditions to simulate (defaults to all)."
+        }
+      },
+      required: ["colors"],
+      additionalProperties: false
+    },
+    annotations: { title: "Check colour palette", ...READ },
+    handler: (args) => {
+      const { colors, surface, minDistance, minContrast, visions } = args;
+      if (!Array.isArray(colors) || colors.length < 2) {
+        fail("Palette check requires an array of at least 2 colours.");
+      }
+      for (const c of colors) {
+        requireColor(c, "colors item");
+      }
+      if (surface !== void 0) {
+        requireColor(surface, "surface");
+      }
+      return checkPaletteColors(colors, {
+        surface,
+        minDistance,
+        minContrast,
+        visions
+      });
+    }
+  };
+  const suggestColorHarmony = {
+    name: "suggest_color_harmony",
+    title: "Suggest colour harmony",
+    description: "Generates harmonic colour combinations (complementary, split-complementary, analogous, triadic, tetradic, square, monochromatic) on an RGB or artistic RYB colour wheel.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        base: { type: "string", description: `Base colour. ${COLOR_PARAM_DESC}` },
+        kind: {
+          type: "string",
+          enum: [...HARMONY_KINDS],
+          description: "Harmony arrangement kind."
+        },
+        wheel: {
+          type: "string",
+          enum: ["rgb", "ryb"],
+          description: 'Colour wheel model: "rgb" (default) or "ryb" (artistic / painterly).'
+        },
+        spread: { type: "number", description: "Angular spread in degrees for analogous or split-complementary harmonies (default 30)." }
+      },
+      required: ["base", "kind"],
+      additionalProperties: false
+    },
+    annotations: { title: "Suggest colour harmony", ...READ },
+    handler: (args) => {
+      const { base, kind, wheel = "rgb", spread } = args;
+      const rgba = requireColor(base, "base");
+      const hex = formatHex(toSrgbGamut(rgba));
+      if (!HARMONY_KINDS.includes(kind)) {
+        fail(`Unknown harmony kind "${kind}"; expected one of ${HARMONY_KINDS.join(", ")}.`);
+      }
+      const result = colorHarmony(hex, kind, {
+        wheel,
+        spread
+      });
+      return {
+        colors: result.map((c) => ({ hex: c.color, angle: c.angle }))
+      };
+    }
+  };
+  const blendColors = {
+    name: "blend_colors",
+    title: "Blend colours",
+    description: "Interpolates between two colours in OKLab, OKLCH, sRGB, or sRGB-linear colour space, either at a single factor t (0\u20131) or as a multi-step gradient ramp.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        from: { type: "string", description: `Start colour. ${COLOR_PARAM_DESC}` },
+        to: { type: "string", description: `End colour. ${COLOR_PARAM_DESC}` },
+        t: { type: "number", description: "Blend position between 0 and 1 (required unless steps is provided)." },
+        space: {
+          type: "string",
+          enum: ["oklab", "oklch", "srgb", "srgb-linear"],
+          description: 'Colour space for interpolation (default "oklab").'
+        },
+        steps: {
+          type: "integer",
+          minimum: 2,
+          maximum: 32,
+          description: "When provided, returns this number of evenly spaced colours (2\u201332) from start to end, ignoring t."
+        }
+      },
+      required: ["from", "to"],
+      additionalProperties: false
+    },
+    annotations: { title: "Blend colours", ...READ },
+    handler: (args) => {
+      const { from, to, t, space = "oklab", steps } = args;
+      requireColor(from, "from");
+      requireColor(to, "to");
+      const validSpaces = ["oklab", "oklch", "srgb", "srgb-linear"];
+      if (!validSpaces.includes(space)) {
+        fail(`Unknown space "${space}"; expected one of ${validSpaces.join(", ")}.`);
+      }
+      if (steps !== void 0) {
+        if (!Number.isInteger(steps) || steps < 2 || steps > 32) {
+          fail(`"steps" must be an integer between 2 and 32, got ${steps}.`);
+        }
+        const colors = [];
+        for (let i = 0; i < steps; i++) {
+          const factor = i / (steps - 1);
+          const mixed = mixColors(from, to, factor, { space });
+          if (mixed) colors.push(mixed);
+        }
+        return { colors };
+      }
+      if (t === void 0 || typeof t !== "number" || !Number.isFinite(t) || t < 0 || t > 1) {
+        fail(`"t" must be a number between 0 and 1, got ${t}.`);
+      }
+      return {
+        color: mixColors(from, to, t, { space })
+      };
+    }
+  };
+  const deriveDualColorTool = {
+    name: "derive_dual_color",
+    title: "Derive dual colour",
+    description: "Automatically derives the opposing scheme colour (light or dark) from a base colour, optionally preserving contrast against specified background surfaces.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        color: DUAL_COLOR_SCHEMA,
+        from: {
+          type: "string",
+          enum: ["light", "dark"],
+          description: "Which scheme the base colour belongs to ('light' or 'dark'). Default 'light'."
+        },
+        surfaces: {
+          ...DUAL_COLOR_SCHEMA,
+          description: "Background surfaces for light and dark schemes. Default is { light: '#ffffff', dark: '#0b0b0f' }."
+        },
+        keepContrast: {
+          type: "boolean",
+          description: "Whether to preserve contrast against the scheme surface. Default true."
+        }
+      },
+      required: ["color"],
+      additionalProperties: false
+    },
+    annotations: { title: "Derive dual colour", ...READ },
+    handler: (args) => {
+      const { color, from = "light", surfaces, keepContrast = true } = args;
+      if (from !== "light" && from !== "dark") {
+        fail(`"from" must be 'light' or 'dark', got "${from}".`);
+      }
+      const baseDual = requireDualColor(color, "color");
+      const baseHex = from === "dark" ? baseDual.dark : baseDual.light;
+      const resolvedSurfaces = surfaces ? requireDualColor(surfaces, "surfaces") : DEFAULT_SCHEME_SURFACES;
+      const derived = deriveDualColor(baseHex, {
+        from,
+        surfaces: keepContrast ? resolvedSurfaces : void 0
+      });
+      const lightSurfaceRgba = parseColor(resolvedSurfaces.light);
+      const darkSurfaceRgba = parseColor(resolvedSurfaces.dark);
+      const lightRatio = Math.round(contrastRatio(parseColor(derived.light), lightSurfaceRgba) * 100) / 100;
+      const darkRatio = Math.round(contrastRatio(parseColor(derived.dark), darkSurfaceRgba) * 100) / 100;
+      return {
+        light: derived.light,
+        dark: derived.dark,
+        css: formatDualColor(derived),
+        contrast: {
+          light: lightRatio,
+          dark: darkRatio
+        }
+      };
+    }
+  };
+  const checkDualColorContrastTool = {
+    name: "check_dual_color_contrast",
+    title: "Check dual colour contrast",
+    description: "Checks WCAG contrast compliance for a foreground and background dual colour across both light and dark modes, reporting issues and suggesting lightness fixes.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        foreground: {
+          ...DUAL_COLOR_SCHEMA,
+          description: `Foreground text colour. ${DUAL_COLOR_PARAM_DESC}`
+        },
+        background: {
+          ...DUAL_COLOR_SCHEMA,
+          description: `Background surface colour. ${DUAL_COLOR_PARAM_DESC}`
+        },
+        large: {
+          type: "boolean",
+          description: "Whether the text is large (at least 18pt / 24px regular, or 14pt / 18.5px bold). Default false."
+        }
+      },
+      required: ["foreground", "background"],
+      additionalProperties: false
+    },
+    annotations: { title: "Check dual colour contrast", ...READ },
+    handler: (args) => {
+      const { foreground, background, large = false } = args;
+      const fg = requireDualColor(foreground, "foreground");
+      const bg = requireDualColor(background, "background");
+      const res = checkDualColorContrast(fg, bg, { large });
+      let suggestion;
+      if (res.light.level === "fail") {
+        const lightFg = parseColor(fg.light);
+        const lightBg = parseColor(bg.light);
+        const fixed = findAccessibleLightness(lightFg, lightBg, large);
+        if (fixed) {
+          suggestion = { ..._nullishCoalesce(suggestion, () => ( {})), light: fixed };
+        }
+      }
+      if (res.dark.level === "fail") {
+        const darkFg = parseColor(fg.dark);
+        const darkBg = parseColor(bg.dark);
+        const fixed = findAccessibleLightness(darkFg, darkBg, large);
+        if (fixed) {
+          suggestion = { ..._nullishCoalesce(suggestion, () => ( {})), dark: fixed };
+        }
+      }
+      return {
+        ...res,
+        ...suggestion ? { suggestion } : {}
+      };
+    }
+  };
+  const exportDualColorsCssTool = {
+    name: "export_dual_colors_css",
+    title: "Export dual colours CSS",
+    description: "Generates CSS custom property declarations for a collection of dual colours using light-dark(), media query, or class-based dark mode strategies.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        colors: {
+          type: "object",
+          minProperties: 1,
+          additionalProperties: DUAL_COLOR_SCHEMA,
+          description: "Dictionary of variable names (without --) to colour values (plain colour, light-dark() string, or { light, dark } object)."
+        },
+        selector: {
+          type: "string",
+          description: "CSS selector for the ruleset. Default ':root'."
+        },
+        strategy: {
+          type: "string",
+          enum: ["light-dark", "media", "class"],
+          description: "CSS export strategy ('light-dark', 'media', or 'class'). Default 'light-dark'."
+        },
+        darkSelector: {
+          type: "string",
+          description: "Dark mode CSS selector when using 'class' strategy. Default '.dark'."
+        }
+      },
+      required: ["colors"],
+      additionalProperties: false
+    },
+    annotations: { title: "Export dual colours CSS", ...READ },
+    handler: (args) => {
+      const { colors, selector = ":root", strategy = "light-dark", darkSelector = ".dark" } = args;
+      if (!colors || typeof colors !== "object" || Object.keys(colors).length === 0) {
+        fail('"colors" must be an object with at least one colour property.');
+      }
+      for (const [k, v] of Object.entries(colors)) {
+        if (!normalizeDualColor(v)) {
+          fail(`Property "${k}" contains invalid colour "${String(v)}".`);
+        }
+      }
+      const css = dualColorsToCss(colors, { selector, strategy, darkSelector });
+      return { css };
+    }
+  };
+  return {
+    id,
+    namespace,
+    title: "Colour",
+    description: "Inspect colours, check contrast and accessibility, audit palettes, suggest harmonies, and interpolate colour blends.",
+    skill: "pixerate-color",
+    tools: [
+      inspectColor,
+      checkColorContrast,
+      checkColorPalette,
+      suggestColorHarmony,
+      blendColors,
+      deriveDualColorTool,
+      checkDualColorContrastTool,
+      exportDualColorsCssTool
+    ]
+  };
+}
+
+// src/color/picker.ts
+var clamp2 = (val, min, max) => Math.max(min, Math.min(max, val));
+function pickerStateFromColor(input, previous) {
+  if (input === null || input === void 0) return null;
+  let rgba;
+  if (typeof input === "object" && "r" in input && "g" in input && "b" in input) {
+    rgba = input;
+  } else if (typeof input === "string") {
+    rgba = parseColor(input);
+  } else {
+    return null;
+  }
+  if (!rgba) return null;
+  const clampedRgba = toSrgbGamut(rgba);
+  const hsva = rgbToHsv(clampedRgba);
+  let h = hsva.h;
+  let s = hsva.s;
+  const v = hsva.v;
+  const alpha = _nullishCoalesce(rgba.a, () => ( 1));
+  if (previous) {
+    if (v <= 1e-4) {
+      h = previous.h;
+      s = previous.s;
+    } else if (s <= 1e-4) {
+      h = previous.h;
+    }
+  }
+  return {
+    h: clamp2(h, 0, 360) % 360,
+    s: clamp2(s, 0, 1),
+    v: clamp2(v, 0, 1),
+    alpha: clamp2(alpha, 0, 1)
+  };
+}
+function pickerStateToHex(state, forceAlpha = false) {
+  const rgba = hsvToRgb({
+    h: state.h,
+    s: state.s,
+    v: state.v,
+    alpha: state.alpha
+  });
+  const hex = formatHex(rgba);
+  if (forceAlpha && hex.length === 7) {
+    return hex + "ff";
+  }
+  return hex;
+}
+function pickerStateFromArea(state, x, y) {
+  return {
+    ...state,
+    s: clamp2(x, 0, 1),
+    v: clamp2(1 - y, 0, 1)
+  };
+}
+function pickerStateFromHue(state, t) {
+  const clampedT = clamp2(t, 0, 1);
+  const h = clampedT >= 1 ? 0 : clampedT * 360;
+  return {
+    ...state,
+    h
+  };
+}
+function pickerStateFromAlpha(state, t) {
+  return {
+    ...state,
+    alpha: clamp2(t, 0, 1)
+  };
+}
+function pickerKeyStep(state, target, key, shift) {
+  const step = shift ? 0.1 : 0.01;
+  const hueStep = shift ? 10 : 1;
+  switch (target) {
+    case "area": {
+      if (key === "ArrowLeft") {
+        return { ...state, s: clamp2(state.s - step, 0, 1) };
+      }
+      if (key === "ArrowRight") {
+        return { ...state, s: clamp2(state.s + step, 0, 1) };
+      }
+      if (key === "ArrowDown") {
+        return { ...state, v: clamp2(state.v - step, 0, 1) };
+      }
+      if (key === "ArrowUp") {
+        return { ...state, v: clamp2(state.v + step, 0, 1) };
+      }
+      if (key === "Home") {
+        return { ...state, s: 0, v: 1 };
+      }
+      if (key === "End") {
+        return { ...state, s: 1, v: 0 };
+      }
+      return null;
+    }
+    case "hue": {
+      if (key === "ArrowLeft" || key === "ArrowDown") {
+        const nextH = (state.h - hueStep + 360) % 360;
+        return { ...state, h: nextH };
+      }
+      if (key === "ArrowRight" || key === "ArrowUp") {
+        const nextH = (state.h + hueStep) % 360;
+        return { ...state, h: nextH };
+      }
+      if (key === "Home") {
+        return { ...state, h: 0 };
+      }
+      if (key === "End") {
+        return { ...state, h: 359 };
+      }
+      return null;
+    }
+    case "alpha": {
+      if (key === "ArrowLeft" || key === "ArrowDown") {
+        return { ...state, alpha: clamp2(state.alpha - step, 0, 1) };
+      }
+      if (key === "ArrowRight" || key === "ArrowUp") {
+        return { ...state, alpha: clamp2(state.alpha + step, 0, 1) };
+      }
+      if (key === "Home") {
+        return { ...state, alpha: 0 };
+      }
+      if (key === "End") {
+        return { ...state, alpha: 1 };
+      }
+      return null;
+    }
+    default:
+      return null;
+  }
+}
+function pickerAreaBackground(state) {
+  const pureHueRgb = hsvToRgb({ h: state.h, s: 1, v: 1, alpha: 1 });
+  const hueHex = formatHex(pureHueRgb);
+  return `linear-gradient(to top, #000, transparent), linear-gradient(to right, #fff, ${hueHex})`;
+}
+function pickerAlphaBackground(state) {
+  const opaqueRgb = hsvToRgb({ h: state.h, s: state.s, v: state.v, alpha: 1 });
+  const hex = formatHex(opaqueRgb);
+  return `linear-gradient(to right, transparent, ${hex})`;
+}
+var PICKER_HUE_BACKGROUND = "linear-gradient(to right, #ff0000 0%, #ffff00 17%, #00ff00 33%, #00ffff 50%, #0000ff 67%, #ff00ff 83%, #ff0000 100%)";
+function dualPickerView(value, scheme) {
+  const norm = _nullishCoalesce(normalizeDualColor(value), () => ( { light: "#000000", dark: "#000000" }));
+  const otherScheme = scheme === "light" ? "dark" : "light";
+  return {
+    color: norm[scheme],
+    linked: norm.light === norm.dark,
+    other: norm[otherScheme]
+  };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.srgbToLinear = srgbToLinear; exports.linearToSrgb = linearToSrgb; exports.rgbToHsl = rgbToHsl; exports.hslToRgb = hslToRgb; exports.rgbToHsv = rgbToHsv; exports.hsvToRgb = hsvToRgb; exports.rgbToOklab = rgbToOklab; exports.oklabToRgb = oklabToRgb; exports.oklabToOklch = oklabToOklch; exports.oklchToOklab = oklchToOklab; exports.linearSrgbToDisplayP3 = linearSrgbToDisplayP3; exports.displayP3ToLinearSrgb = displayP3ToLinearSrgb; exports.NAMED_COLORS = NAMED_COLORS; exports.parseColor = parseColor; exports.isColor = isColor; exports.inSrgbGamut = inSrgbGamut; exports.deltaEOK = deltaEOK; exports.toSrgbGamut = toSrgbGamut; exports.formatHex = formatHex; exports.formatColor = formatColor; exports.normalizeColor = normalizeColor; exports.relativeLuminance = relativeLuminance; exports.contrastRatio = contrastRatio; exports.contrastLevel = contrastLevel; exports.readableTextColor = readableTextColor; exports.simulateColorVision = simulateColorVision; exports.checkPaletteColors = checkPaletteColors; exports.HARMONY_KINDS = HARMONY_KINDS; exports.wheelToHue = wheelToHue; exports.hueToWheel = hueToWheel; exports.colorHarmony = colorHarmony; exports.mixColors = mixColors; exports.pushRecentColor = pushRecentColor; exports.DEFAULT_SCHEME_SURFACES = DEFAULT_SCHEME_SURFACES; exports.isDualColor = isDualColor; exports.parseDualColor = parseDualColor; exports.normalizeDualColor = normalizeDualColor; exports.resolveColor = resolveColor; exports.formatDualColor = formatDualColor; exports.isSameInBothSchemes = isSameInBothSchemes; exports.setDualColorSide = setDualColorSide; exports.deriveDualColor = deriveDualColor; exports.checkDualColorContrast = checkDualColorContrast; exports.dualColorsToCss = dualColorsToCss; exports.createColorToolProvider = createColorToolProvider; exports.pickerStateFromColor = pickerStateFromColor; exports.pickerStateToHex = pickerStateToHex; exports.pickerStateFromArea = pickerStateFromArea; exports.pickerStateFromHue = pickerStateFromHue; exports.pickerStateFromAlpha = pickerStateFromAlpha; exports.pickerKeyStep = pickerKeyStep; exports.pickerAreaBackground = pickerAreaBackground; exports.pickerAlphaBackground = pickerAlphaBackground; exports.PICKER_HUE_BACKGROUND = PICKER_HUE_BACKGROUND; exports.dualPickerView = dualPickerView;