@pixerate/editor 0.161.0 → 0.162.0

package/dist/{chunk-UKCJ43YL.cjs → chunk-ES3UEVUT.cjs}

@@ -5,720 +5,22 @@
 
 
 
-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;
-}
+
+
+
+
+
+
+
+
+
+var _chunkS6X2QRVUcjs = require('./chunk-S6X2QRVU.cjs');
 
 // src/color/vision.ts
 var CVD = {
@@ -738,16 +40,16 @@ var CVD = {
     [4733e-6, 0.691367, 0.3039]
   ]
 };
-var clamp013 = (v) => Math.max(0, Math.min(1, v));
+var clamp01 = (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 lr = _chunkS6X2QRVUcjs.srgbToLinear.call(void 0, c.r);
+  const lg = _chunkS6X2QRVUcjs.srgbToLinear.call(void 0, c.g);
+  const lb = _chunkS6X2QRVUcjs.srgbToLinear.call(void 0, 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));
+  const r = _chunkS6X2QRVUcjs.linearToSrgb.call(void 0, clamp01(m[0][0] * lr + m[0][1] * lg + m[0][2] * lb));
+  const g = _chunkS6X2QRVUcjs.linearToSrgb.call(void 0, clamp01(m[1][0] * lr + m[1][1] * lg + m[1][2] * lb));
+  const b = _chunkS6X2QRVUcjs.linearToSrgb.call(void 0, clamp01(m[2][0] * lr + m[2][1] * lg + m[2][2] * lb));
   return { r, g, b, a: c.a };
 }
 function checkPaletteColors(colors, options = {}) {
@@ -755,8 +57,8 @@ function checkPaletteColors(colors, options = {}) {
   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 parsed = colors.map((c) => _chunkS6X2QRVUcjs.parseColor.call(void 0, c));
+  const surfaceParsed = _chunkS6X2QRVUcjs.parseColor.call(void 0, surfaceStr);
   const skipped = colors.filter((_, i) => !parsed[i]);
   const issues = [];
   const closest = {};
@@ -766,7 +68,7 @@ function checkPaletteColors(colors, options = {}) {
     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]);
+        const distance = _chunkS6X2QRVUcjs.deltaEOK.call(void 0, seen[a], seen[b]);
         if (!best || distance < best.distance) {
           best = {
             a,
@@ -790,7 +92,7 @@ function checkPaletteColors(colors, options = {}) {
   const contrast = colors.map((_, i) => {
     const c = parsed[i];
     if (!c || !surfaceParsed) return null;
-    const ratio = contrastRatio(c, surfaceParsed);
+    const ratio = _chunkS6X2QRVUcjs.contrastRatio.call(void 0, c, surfaceParsed);
     return Math.round(ratio * 100) / 100;
   });
   contrast.forEach((ratio, i) => {
@@ -814,7 +116,7 @@ var HARMONY_KINDS = [
   "monochromatic"
 ];
 var HEX_6 = /^#?([0-9a-f]{6})$/i;
-function parseHex2(value, what = "color") {
+function parseHex(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);
@@ -850,12 +152,12 @@ function hueToWheel(hue, wheel) {
 }
 function colorHarmony(base, kind, options = {}) {
   const wheel = _nullishCoalesce(options.wheel, () => ( "ryb"));
-  const rgb = parseHex2(base, "base");
-  const hsv = rgbToHsv(rgb);
+  const rgb = parseHex(base, "base");
+  const hsv = _chunkS6X2QRVUcjs.rgbToHsv.call(void 0, 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 };
+    return { color: toHex(_chunkS6X2QRVUcjs.hsvToRgb.call(void 0, { ...hsv, h: wheelToHue(a, wheel) })), angle: Math.round(a * 10) / 10 };
   };
   const spread = _nullishCoalesce(options.spread, () => ( 30));
   const offsets = {
@@ -867,10 +169,10 @@ function colorHarmony(base, kind, options = {}) {
     square: [0, 90, 180, 270]
   };
   if (kind === "monochromatic") {
-    const hsl = rgbToHsl(rgb);
+    const hsl = _chunkS6X2QRVUcjs.rgbToHsl.call(void 0, 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)) });
+      const c = d === 0 ? rgb : _chunkS6X2QRVUcjs.hslToRgb.call(void 0, { ...hsl, l: Math.min(0.97, Math.max(0.03, hsl.l + d)) });
       return { color: toHex(c), angle: Math.round(start * 10) / 10 };
     });
   }
@@ -881,17 +183,17 @@ function colorHarmony(base, kind, options = {}) {
 
 // src/color/mix.ts
 function mixColors(from, to, t, options = {}) {
-  const c1 = parseColor(from);
-  const c2 = parseColor(to);
+  const c1 = _chunkS6X2QRVUcjs.parseColor.call(void 0, from);
+  const c2 = _chunkS6X2QRVUcjs.parseColor.call(void 0, 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);
+    const lab1 = _chunkS6X2QRVUcjs.rgbToOklab.call(void 0, c1);
+    const lab2 = _chunkS6X2QRVUcjs.rgbToOklab.call(void 0, 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));
+      return _chunkS6X2QRVUcjs.formatHex.call(void 0, _chunkS6X2QRVUcjs.oklabToRgb.call(void 0, lab3));
     }
     const premul = (k) => lab1[k] * lab1.alpha + (lab2[k] * lab2.alpha - lab1[k] * lab1.alpha) * t;
     const lab = {
@@ -900,11 +202,11 @@ function mixColors(from, to, t, options = {}) {
       b: premul("b") / alpha,
       alpha
     };
-    return formatHex(oklabToRgb(lab));
+    return _chunkS6X2QRVUcjs.formatHex.call(void 0, _chunkS6X2QRVUcjs.oklabToRgb.call(void 0, lab));
   }
   if (space === "oklch") {
-    const lch1 = oklabToOklch(rgbToOklab(c1));
-    const lch2 = oklabToOklch(rgbToOklab(c2));
+    const lch1 = _chunkS6X2QRVUcjs.oklabToOklch.call(void 0, _chunkS6X2QRVUcjs.rgbToOklab.call(void 0, c1));
+    const lch2 = _chunkS6X2QRVUcjs.oklabToOklch.call(void 0, _chunkS6X2QRVUcjs.rgbToOklab.call(void 0, c2));
     let h1 = lch1.h;
     let h2 = lch2.h;
     const diff = h2 - h1;
@@ -913,41 +215,41 @@ function mixColors(from, to, t, options = {}) {
     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 })));
+      return _chunkS6X2QRVUcjs.formatHex.call(void 0, _chunkS6X2QRVUcjs.oklabToRgb.call(void 0, _chunkS6X2QRVUcjs.oklchToOklab.call(void 0, { 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 })));
+    return _chunkS6X2QRVUcjs.formatHex.call(void 0, _chunkS6X2QRVUcjs.oklabToRgb.call(void 0, _chunkS6X2QRVUcjs.oklchToOklab.call(void 0, { 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);
+    const lr1 = _chunkS6X2QRVUcjs.srgbToLinear.call(void 0, c1.r);
+    const lg1 = _chunkS6X2QRVUcjs.srgbToLinear.call(void 0, c1.g);
+    const lb1 = _chunkS6X2QRVUcjs.srgbToLinear.call(void 0, c1.b);
+    const lr2 = _chunkS6X2QRVUcjs.srgbToLinear.call(void 0, c2.r);
+    const lg2 = _chunkS6X2QRVUcjs.srgbToLinear.call(void 0, c2.g);
+    const lb2 = _chunkS6X2QRVUcjs.srgbToLinear.call(void 0, 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),
+      return _chunkS6X2QRVUcjs.formatHex.call(void 0, {
+        r: _chunkS6X2QRVUcjs.linearToSrgb.call(void 0, lr1 + (lr2 - lr1) * t),
+        g: _chunkS6X2QRVUcjs.linearToSrgb.call(void 0, lg1 + (lg2 - lg1) * t),
+        b: _chunkS6X2QRVUcjs.linearToSrgb.call(void 0, 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),
+    return _chunkS6X2QRVUcjs.formatHex.call(void 0, {
+      r: _chunkS6X2QRVUcjs.linearToSrgb.call(void 0, premulR2 / alpha),
+      g: _chunkS6X2QRVUcjs.linearToSrgb.call(void 0, premulG2 / alpha),
+      b: _chunkS6X2QRVUcjs.linearToSrgb.call(void 0, premulB2 / alpha),
       a: alpha
     });
   }
   if (alpha <= 1e-9) {
-    return formatHex({
+    return _chunkS6X2QRVUcjs.formatHex.call(void 0, {
       r: c1.r + (c2.r - c1.r) * t,
       g: c1.g + (c2.g - c1.g) * t,
       b: c1.b + (c2.b - c1.b) * t,
@@ -957,7 +259,7 @@ function mixColors(from, to, t, options = {}) {
   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({
+  return _chunkS6X2QRVUcjs.formatHex.call(void 0, {
     r: premulR / alpha,
     g: premulG / alpha,
     b: premulB / alpha,
@@ -967,9 +269,9 @@ function mixColors(from, to, t, options = {}) {
 
 // src/color/recent.ts
 function pushRecentColor(list, color, max = 12) {
-  const normal = normalizeColor(color);
+  const normal = _chunkS6X2QRVUcjs.normalizeColor.call(void 0, color);
   if (!normal) return list.slice();
-  const next = [normal, ...list.filter((c) => normalizeColor(c) !== normal)];
+  const next = [normal, ...list.filter((c) => _chunkS6X2QRVUcjs.normalizeColor.call(void 0, c) !== normal)];
   return next.slice(0, max);
 }
 
@@ -985,7 +287,7 @@ function isDualColor(value) {
 function parseDualColor(input) {
   if (input === null || input === void 0) return null;
   if (isDualColor(input)) {
-    if (parseColor(input.light) === null || parseColor(input.dark) === null) {
+    if (_chunkS6X2QRVUcjs.parseColor.call(void 0, input.light) === null || _chunkS6X2QRVUcjs.parseColor.call(void 0, input.dark) === null) {
       return null;
     }
     return { light: input.light, dark: input.dark };
@@ -1019,12 +321,12 @@ function parseDualColor(input) {
       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) {
+      if (_chunkS6X2QRVUcjs.parseColor.call(void 0, lightPart) === null || _chunkS6X2QRVUcjs.parseColor.call(void 0, darkPart) === null) {
         return null;
       }
       return { light: lightPart, dark: darkPart };
     }
-    if (parseColor(trimmed) !== null) {
+    if (_chunkS6X2QRVUcjs.parseColor.call(void 0, trimmed) !== null) {
       return { light: trimmed, dark: trimmed };
     }
   }
@@ -1033,8 +335,8 @@ function parseDualColor(input) {
 function normalizeDualColor(input) {
   const parsed = parseDualColor(input);
   if (!parsed) return null;
-  const light = normalizeColor(parsed.light);
-  const dark = normalizeColor(parsed.dark);
+  const light = _chunkS6X2QRVUcjs.normalizeColor.call(void 0, parsed.light);
+  const dark = _chunkS6X2QRVUcjs.normalizeColor.call(void 0, parsed.dark);
   if (!light || !dark) return null;
   return { light, dark };
 }
@@ -1044,58 +346,58 @@ function resolveColor(value, scheme) {
   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));
+  const light = _nullishCoalesce(_chunkS6X2QRVUcjs.normalizeColor.call(void 0, value.light), () => ( value.light));
+  const dark = _nullishCoalesce(_chunkS6X2QRVUcjs.normalizeColor.call(void 0, 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);
+  const light = _chunkS6X2QRVUcjs.normalizeColor.call(void 0, value.light);
+  const dark = _chunkS6X2QRVUcjs.normalizeColor.call(void 0, 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));
+  const normColor = _nullishCoalesce(_chunkS6X2QRVUcjs.normalizeColor.call(void 0, 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);
+  const fromScheme = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _2 => _2.from]), () => ( "light"));
+  const baseRgba = _chunkS6X2QRVUcjs.parseColor.call(void 0, 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)) {
+  if (_optionalChain([options, 'optionalAccess', _3 => _3.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 baseHex = _chunkS6X2QRVUcjs.formatHex.call(void 0, baseRgba);
+  const lab = _chunkS6X2QRVUcjs.rgbToOklab.call(void 0, baseRgba);
+  const lch = _chunkS6X2QRVUcjs.oklabToOklch.call(void 0, 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])) {
+  if (_optionalChain([options, 'optionalAccess', _4 => _4.surfaces])) {
     const surfaces = options.surfaces;
-    const fromSurfaceRgba = parseColor(surfaces[fromScheme]);
+    const fromSurfaceRgba = _chunkS6X2QRVUcjs.parseColor.call(void 0, 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 targetSurfaceRgba = _chunkS6X2QRVUcjs.parseColor.call(void 0, surfaces[targetScheme]);
+    const targetRatio = _chunkS6X2QRVUcjs.contrastRatio.call(void 0, baseRgba, fromSurfaceRgba);
+    const targetSurfaceL = _chunkS6X2QRVUcjs.oklabToOklch.call(void 0, _chunkS6X2QRVUcjs.rgbToOklab.call(void 0, 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 candRgb = _chunkS6X2QRVUcjs.toSrgbGamut.call(void 0, 
+        _chunkS6X2QRVUcjs.oklabToRgb.call(void 0, _chunkS6X2QRVUcjs.oklchToOklab.call(void 0, { l: candL, c: targetC, h: targetH, alpha: baseRgba.a }))
       );
-      const ratio = contrastRatio(candRgb, targetSurfaceRgba);
+      const ratio = _chunkS6X2QRVUcjs.contrastRatio.call(void 0, 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) {
@@ -1103,20 +405,20 @@ function deriveDualColor(color, options) {
         bestL = candL;
       }
     }
-    const finalRgba = toSrgbGamut(
-      oklabToRgb(oklchToOklab({ l: bestL, c: targetC, h: targetH, alpha: baseRgba.a }))
+    const finalRgba = _chunkS6X2QRVUcjs.toSrgbGamut.call(void 0, 
+      _chunkS6X2QRVUcjs.oklabToRgb.call(void 0, _chunkS6X2QRVUcjs.oklchToOklab.call(void 0, { l: bestL, c: targetC, h: targetH, alpha: baseRgba.a }))
     );
-    derivedHex = formatHex(finalRgba);
+    derivedHex = _chunkS6X2QRVUcjs.formatHex.call(void 0, finalRgba);
   } else {
-    const finalRgba = toSrgbGamut(
-      oklabToRgb(oklchToOklab({ l: startL, c: targetC, h: targetH, alpha: baseRgba.a }))
+    const finalRgba = _chunkS6X2QRVUcjs.toSrgbGamut.call(void 0, 
+      _chunkS6X2QRVUcjs.oklabToRgb.call(void 0, _chunkS6X2QRVUcjs.oklchToOklab.call(void 0, { l: startL, c: targetC, h: targetH, alpha: baseRgba.a }))
     );
-    derivedHex = formatHex(finalRgba);
+    derivedHex = _chunkS6X2QRVUcjs.formatHex.call(void 0, 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 large = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _5 => _5.large]), () => ( false));
   const requiredRatio = large ? 3 : 4.5;
   const fg = normalizeDualColor(foreground);
   const bg = normalizeDualColor(background);
@@ -1126,14 +428,14 @@ function checkDualColorContrast(foreground, background, options) {
   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 lightFg = _chunkS6X2QRVUcjs.parseColor.call(void 0, lightFgHex);
+  const lightBg = _chunkS6X2QRVUcjs.parseColor.call(void 0, lightBgHex);
+  const darkFg = _chunkS6X2QRVUcjs.parseColor.call(void 0, darkFgHex);
+  const darkBg = _chunkS6X2QRVUcjs.parseColor.call(void 0, darkBgHex);
+  const lightRatio = Math.round(_chunkS6X2QRVUcjs.contrastRatio.call(void 0, lightFg, lightBg) * 100) / 100;
+  const darkRatio = Math.round(_chunkS6X2QRVUcjs.contrastRatio.call(void 0, darkFg, darkBg) * 100) / 100;
+  const lightLevel = _chunkS6X2QRVUcjs.contrastLevel.call(void 0, lightRatio, { large });
+  const darkLevel = _chunkS6X2QRVUcjs.contrastLevel.call(void 0, darkRatio, { large });
   const issues = [];
   if (lightLevel === "fail") {
     issues.push(
@@ -1156,9 +458,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"));
+  const selector = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _6 => _6.selector]), () => ( ":root"));
+  const strategy = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _7 => _7.strategy]), () => ( "light-dark"));
+  const darkSelector = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _8 => _8.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 ";").`);
@@ -1250,7 +552,7 @@ function requireColor(input, name) {
   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);
+  const parsed = _chunkS6X2QRVUcjs.parseColor.call(void 0, input);
   if (!parsed) {
     fail(`"${input}" is not a colour I can read; use hex (#2a4b8d), rgb(), hsl(), oklch() or a CSS colour name.`);
   }
@@ -1263,28 +565,7 @@ function requireDualColor(input, name) {
   }
   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;
-}
+var findAccessibleLightness = (fg, bg, large) => _chunkS6X2QRVUcjs.suggestAccessibleForeground.call(void 0, fg, bg, { large });
 function createColorToolProvider(options = {}) {
   const id = _nullishCoalesce(options.id, () => ( "color"));
   const namespace = _nullishCoalesce(options.namespace, () => ( "color"));
@@ -1304,18 +585,18 @@ function createColorToolProvider(options = {}) {
     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 inGamut = _chunkS6X2QRVUcjs.inSrgbGamut.call(void 0, rgba);
+      const mappedRgba = inGamut ? rgba : _chunkS6X2QRVUcjs.toSrgbGamut.call(void 0, rgba);
+      const hsl = _chunkS6X2QRVUcjs.rgbToHsl.call(void 0, mappedRgba);
+      const oklab = _chunkS6X2QRVUcjs.rgbToOklab.call(void 0, rgba);
+      const oklch = _chunkS6X2QRVUcjs.oklabToOklch.call(void 0, oklab);
       const formats = ["hex", "rgb", "hsl", "oklab", "oklch"];
       const css = {};
       for (const f of formats) {
-        css[f] = formatColor(rgba, f);
+        css[f] = _chunkS6X2QRVUcjs.formatColor.call(void 0, rgba, f);
       }
       return {
-        hex: formatHex(mappedRgba),
+        hex: _chunkS6X2QRVUcjs.formatHex.call(void 0, mappedRgba),
         alpha: Math.round(rgba.a * 1e3) / 1e3,
         rgb: {
           r: Math.round(Math.min(1, Math.max(0, mappedRgba.r)) * 255),
@@ -1334,8 +615,8 @@ function createColorToolProvider(options = {}) {
         },
         css,
         inSrgbGamut: inGamut,
-        ...inGamut ? {} : { gamutMappedHex: formatHex(mappedRgba) },
-        relativeLuminance: Math.round(relativeLuminance(mappedRgba) * 1e4) / 1e4
+        ...inGamut ? {} : { gamutMappedHex: _chunkS6X2QRVUcjs.formatHex.call(void 0, mappedRgba) },
+        relativeLuminance: Math.round(_chunkS6X2QRVUcjs.relativeLuminance.call(void 0, mappedRgba) * 1e4) / 1e4
       };
     }
   };
@@ -1358,35 +639,11 @@ function createColorToolProvider(options = {}) {
       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 ratio = Math.round(_chunkS6X2QRVUcjs.contrastRatio.call(void 0, fg, bg) * 100) / 100;
+      const level = _chunkS6X2QRVUcjs.contrastLevel.call(void 0, 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;
-          }
-        }
-      }
+      const suggestion = passesAA ? void 0 : _chunkS6X2QRVUcjs.suggestAccessibleForeground.call(void 0, fg, bg, { large });
       return {
         ratio,
         level,
@@ -1468,7 +725,7 @@ function createColorToolProvider(options = {}) {
     handler: (args) => {
       const { base, kind, wheel = "rgb", spread } = args;
       const rgba = requireColor(base, "base");
-      const hex = formatHex(toSrgbGamut(rgba));
+      const hex = _chunkS6X2QRVUcjs.formatHex.call(void 0, _chunkS6X2QRVUcjs.toSrgbGamut.call(void 0, rgba));
       if (!HARMONY_KINDS.includes(kind)) {
         fail(`Unknown harmony kind "${kind}"; expected one of ${HARMONY_KINDS.join(", ")}.`);
       }
@@ -1573,10 +830,10 @@ function createColorToolProvider(options = {}) {
         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;
+      const lightSurfaceRgba = _chunkS6X2QRVUcjs.parseColor.call(void 0, resolvedSurfaces.light);
+      const darkSurfaceRgba = _chunkS6X2QRVUcjs.parseColor.call(void 0, resolvedSurfaces.dark);
+      const lightRatio = Math.round(_chunkS6X2QRVUcjs.contrastRatio.call(void 0, _chunkS6X2QRVUcjs.parseColor.call(void 0, derived.light), lightSurfaceRgba) * 100) / 100;
+      const darkRatio = Math.round(_chunkS6X2QRVUcjs.contrastRatio.call(void 0, _chunkS6X2QRVUcjs.parseColor.call(void 0, derived.dark), darkSurfaceRgba) * 100) / 100;
       return {
         light: derived.light,
         dark: derived.dark,
@@ -1619,16 +876,16 @@ function createColorToolProvider(options = {}) {
       const res = checkDualColorContrast(fg, bg, { large });
       let suggestion;
       if (res.light.level === "fail") {
-        const lightFg = parseColor(fg.light);
-        const lightBg = parseColor(bg.light);
+        const lightFg = _chunkS6X2QRVUcjs.parseColor.call(void 0, fg.light);
+        const lightBg = _chunkS6X2QRVUcjs.parseColor.call(void 0, 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 darkFg = _chunkS6X2QRVUcjs.parseColor.call(void 0, fg.dark);
+        const darkBg = _chunkS6X2QRVUcjs.parseColor.call(void 0, bg.dark);
         const fixed = findAccessibleLightness(darkFg, darkBg, large);
         if (fixed) {
           suggestion = { ..._nullishCoalesce(suggestion, () => ( {})), dark: fixed };
@@ -1712,13 +969,13 @@ function pickerStateFromColor(input, previous) {
   if (typeof input === "object" && "r" in input && "g" in input && "b" in input) {
     rgba = input;
   } else if (typeof input === "string") {
-    rgba = parseColor(input);
+    rgba = _chunkS6X2QRVUcjs.parseColor.call(void 0, input);
   } else {
     return null;
   }
   if (!rgba) return null;
-  const clampedRgba = toSrgbGamut(rgba);
-  const hsva = rgbToHsv(clampedRgba);
+  const clampedRgba = _chunkS6X2QRVUcjs.toSrgbGamut.call(void 0, rgba);
+  const hsva = _chunkS6X2QRVUcjs.rgbToHsv.call(void 0, clampedRgba);
   let h = hsva.h;
   let s = hsva.s;
   const v = hsva.v;
@@ -1739,13 +996,13 @@ function pickerStateFromColor(input, previous) {
   };
 }
 function pickerStateToHex(state, forceAlpha = false) {
-  const rgba = hsvToRgb({
+  const rgba = _chunkS6X2QRVUcjs.hsvToRgb.call(void 0, {
     h: state.h,
     s: state.s,
     v: state.v,
     alpha: state.alpha
   });
-  const hex = formatHex(rgba);
+  const hex = _chunkS6X2QRVUcjs.formatHex.call(void 0, rgba);
   if (forceAlpha && hex.length === 7) {
     return hex + "ff";
   }
@@ -1834,13 +1091,13 @@ function pickerKeyStep(state, target, key, shift) {
   }
 }
 function pickerAreaBackground(state) {
-  const pureHueRgb = hsvToRgb({ h: state.h, s: 1, v: 1, alpha: 1 });
-  const hueHex = formatHex(pureHueRgb);
+  const pureHueRgb = _chunkS6X2QRVUcjs.hsvToRgb.call(void 0, { h: state.h, s: 1, v: 1, alpha: 1 });
+  const hueHex = _chunkS6X2QRVUcjs.formatHex.call(void 0, 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);
+  const opaqueRgb = _chunkS6X2QRVUcjs.hsvToRgb.call(void 0, { h: state.h, s: state.s, v: state.v, alpha: 1 });
+  const hex = _chunkS6X2QRVUcjs.formatHex.call(void 0, 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%)";
@@ -1885,29 +1142,4 @@ function dualPickerView(value, scheme) {
 
 
 
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-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;
+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;