@pixerate/editor 0.161.0 → 0.162.0

package/dist/chunk-4VU4CP7R.js

@@ -0,0 +1,769 @@
+import {
+  D65_XY,
+  apply,
+  invert,
+  mul,
+  rgbToXyzMatrix,
+  xyToXyz
+} from "./chunk-6ONMQ6WF.js";
+
+// 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 = xyToXyz(D65_XY);
+var SRGB_TO_XYZ = rgbToXyzMatrix([0.64, 0.33], [0.3, 0.6], [0.15, 0.06], D65_XYZ);
+var P3_TO_XYZ = rgbToXyzMatrix([0.68, 0.32], [0.265, 0.69], [0.15, 0.06], D65_XYZ);
+var XYZ_TO_SRGB = invert(SRGB_TO_XYZ);
+var XYZ_TO_P3 = invert(P3_TO_XYZ);
+var P3_TO_SRGB_MAT = mul(XYZ_TO_SRGB, P3_TO_XYZ);
+var SRGB_TO_P3_MAT = mul(XYZ_TO_P3, SRGB_TO_XYZ);
+function linearSrgbToDisplayP3(rgb) {
+  const out = apply(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 = apply(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 = options?.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 = 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/suggest.ts
+function suggestAccessibleForeground(foreground, background, options = {}) {
+  const large = options.large ?? false;
+  const lch = oklabToOklch(rgbToOklab(foreground));
+  const asHex = (l) => parseColor(formatHex(toSrgbGamut(oklabToRgb(oklchToOklab({ ...lch, l })))));
+  for (let d = 0.01; d <= 1; d += 0.01) {
+    const downCand = asHex(Math.max(0, lch.l - d));
+    const upCand = asHex(Math.min(1, lch.l + d));
+    const downRatio = contrastRatio(downCand, background);
+    const upRatio = contrastRatio(upCand, background);
+    const downPass = contrastLevel(downRatio, { large }) !== "fail";
+    const upPass = contrastLevel(upRatio, { large }) !== "fail";
+    if (downPass && upPass) return formatHex(downRatio >= upRatio ? downCand : upCand);
+    if (downPass) return formatHex(downCand);
+    if (upPass) return formatHex(upCand);
+  }
+  return void 0;
+}
+
+export {
+  srgbToLinear,
+  linearToSrgb,
+  rgbToHsl,
+  hslToRgb,
+  rgbToHsv,
+  hsvToRgb,
+  rgbToOklab,
+  oklabToRgb,
+  oklabToOklch,
+  oklchToOklab,
+  linearSrgbToDisplayP3,
+  displayP3ToLinearSrgb,
+  NAMED_COLORS,
+  parseColor,
+  isColor,
+  inSrgbGamut,
+  deltaEOK,
+  toSrgbGamut,
+  formatHex,
+  formatColor,
+  normalizeColor,
+  relativeLuminance,
+  contrastRatio,
+  contrastLevel,
+  readableTextColor,
+  suggestAccessibleForeground
+};