@trishchuk/coolors-mcp 1.0.0

package/dist/chunk-P3ARRKLS.js

@@ -0,0 +1,1214 @@
+// src/color/types.ts
+var ColorFormat = /* @__PURE__ */ ((ColorFormat2) => {
+  ColorFormat2["HEX"] = "hex";
+  ColorFormat2["HSL"] = "hsl";
+  ColorFormat2["HSV"] = "hsv";
+  ColorFormat2["LAB"] = "lab";
+  ColorFormat2["RGB"] = "rgb";
+  ColorFormat2["XYZ"] = "xyz";
+  return ColorFormat2;
+})(ColorFormat || {});
+var ColorConstants = {
+  /**
+   * D65 illuminant reference white point
+   */
+  D65: {
+    X: 95.047,
+    Y: 100,
+    Z: 108.883
+  },
+  /**
+   * Epsilon for LAB conversion
+   */
+  EPSILON: 8856e-6,
+  /**
+   * Kappa for LAB conversion
+   */
+  KAPPA: 903.3
+};
+
+// src/color/conversions.ts
+function argbToRgb(argb) {
+  const r = argb >> 16 & 255;
+  const g = argb >> 8 & 255;
+  const b = argb & 255;
+  return { b, g, r };
+}
+function hexToRgb(hex) {
+  const cleanHex = hex.replace("#", "");
+  const fullHex = cleanHex.length === 3 ? cleanHex.split("").map((c) => c + c).join("") : cleanHex;
+  const num = parseInt(fullHex, 16);
+  return {
+    b: num & 255,
+    g: num >> 8 & 255,
+    r: num >> 16 & 255
+  };
+}
+function hslToRgb(hsl) {
+  const h = hsl.h / 360;
+  const s = hsl.s / 100;
+  const l = hsl.l / 100;
+  let b, g, r;
+  if (s === 0) {
+    r = g = b = l;
+  } else {
+    const hue2rgb = (p2, q2, t) => {
+      if (t < 0) t += 1;
+      if (t > 1) t -= 1;
+      if (t < 1 / 6) return p2 + (q2 - p2) * 6 * t;
+      if (t < 1 / 2) return q2;
+      if (t < 2 / 3) return p2 + (q2 - p2) * (2 / 3 - t) * 6;
+      return p2;
+    };
+    const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+    const p = 2 * l - q;
+    r = hue2rgb(p, q, h + 1 / 3);
+    g = hue2rgb(p, q, h);
+    b = hue2rgb(p, q, h - 1 / 3);
+  }
+  return {
+    b: Math.round(b * 255),
+    g: Math.round(g * 255),
+    r: Math.round(r * 255)
+  };
+}
+function hsvToRgb(hsv) {
+  const h = hsv.h / 360;
+  const s = hsv.s / 100;
+  const v = hsv.v / 100;
+  const i = Math.floor(h * 6);
+  const f = h * 6 - i;
+  const p = v * (1 - s);
+  const q = v * (1 - f * s);
+  const t = v * (1 - (1 - f) * s);
+  let b, g, r;
+  switch (i % 6) {
+    case 0:
+      r = v;
+      g = t;
+      b = p;
+      break;
+    case 1:
+      r = q;
+      g = v;
+      b = p;
+      break;
+    case 2:
+      r = p;
+      g = v;
+      b = t;
+      break;
+    case 3:
+      r = p;
+      g = q;
+      b = v;
+      break;
+    case 4:
+      r = t;
+      g = p;
+      b = v;
+      break;
+    case 5:
+      r = v;
+      g = p;
+      b = q;
+      break;
+    default:
+      r = 0;
+      g = 0;
+      b = 0;
+  }
+  return {
+    b: Math.round(b * 255),
+    g: Math.round(g * 255),
+    r: Math.round(r * 255)
+  };
+}
+function labToRgb(lab) {
+  return xyzToRgb(labToXyz(lab));
+}
+function labToXyz(lab) {
+  const { D65, EPSILON, KAPPA } = ColorConstants;
+  const fy = (lab.l + 16) / 116;
+  const fx = lab.a / 500 + fy;
+  const fz = fy - lab.b / 200;
+  const x3 = Math.pow(fx, 3);
+  const y3 = Math.pow(fy, 3);
+  const z3 = Math.pow(fz, 3);
+  const x = x3 > EPSILON ? x3 : (116 * fx - 16) / KAPPA;
+  const y = lab.l > KAPPA * EPSILON ? y3 : lab.l / KAPPA;
+  const z = z3 > EPSILON ? z3 : (116 * fz - 16) / KAPPA;
+  return {
+    x: x * D65.X,
+    y: y * D65.Y,
+    z: z * D65.Z
+  };
+}
+function parseColor(color) {
+  const trimmed = color.trim().toLowerCase();
+  if (trimmed.startsWith("#")) {
+    try {
+      return hexToRgb(trimmed);
+    } catch {
+      return null;
+    }
+  }
+  const rgbMatch = trimmed.match(/^rgba?\((\d+),\s*(\d+),\s*(\d+)/);
+  if (rgbMatch) {
+    return {
+      b: parseInt(rgbMatch[3], 10),
+      g: parseInt(rgbMatch[2], 10),
+      r: parseInt(rgbMatch[1], 10)
+    };
+  }
+  const hslMatch = trimmed.match(/^hsla?\((\d+),\s*(\d+)%,\s*(\d+)%/);
+  if (hslMatch) {
+    return hslToRgb({
+      h: parseInt(hslMatch[1], 10),
+      l: parseInt(hslMatch[3], 10),
+      s: parseInt(hslMatch[2], 10)
+    });
+  }
+  return null;
+}
+function rgbToArgb(rgb) {
+  const r = Math.round(Math.max(0, Math.min(255, rgb.r)));
+  const g = Math.round(Math.max(0, Math.min(255, rgb.g)));
+  const b = Math.round(Math.max(0, Math.min(255, rgb.b)));
+  return (255 << 24 | r << 16 | g << 8 | b) >>> 0;
+}
+function rgbToHex(rgb) {
+  const toHex = (n) => {
+    const hex = Math.round(Math.max(0, Math.min(255, n))).toString(16);
+    return hex.length === 1 ? "0" + hex : hex;
+  };
+  return `#${toHex(rgb.r)}${toHex(rgb.g)}${toHex(rgb.b)}`;
+}
+function rgbToHsl(rgb) {
+  const r = rgb.r / 255;
+  const g = rgb.g / 255;
+  const b = rgb.b / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const diff = max - min;
+  let h = 0;
+  let s = 0;
+  const l = (max + min) / 2;
+  if (diff !== 0) {
+    s = l > 0.5 ? diff / (2 - max - min) : diff / (max + min);
+    switch (max) {
+      case b:
+        h = ((r - g) / diff + 4) / 6;
+        break;
+      case g:
+        h = ((b - r) / diff + 2) / 6;
+        break;
+      case r:
+        h = ((g - b) / diff + (g < b ? 6 : 0)) / 6;
+        break;
+    }
+  }
+  return {
+    h: Math.round(h * 360),
+    l: Math.round(l * 100),
+    s: Math.round(s * 100)
+  };
+}
+function rgbToHsv(rgb) {
+  const r = rgb.r / 255;
+  const g = rgb.g / 255;
+  const b = rgb.b / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const diff = max - min;
+  let h = 0;
+  const s = max === 0 ? 0 : diff / max;
+  const v = max;
+  if (diff !== 0) {
+    switch (max) {
+      case b:
+        h = ((r - g) / diff + 4) / 6;
+        break;
+      case g:
+        h = ((b - r) / diff + 2) / 6;
+        break;
+      case r:
+        h = ((g - b) / diff + (g < b ? 6 : 0)) / 6;
+        break;
+    }
+  }
+  return {
+    h: Math.round(h * 360),
+    s: Math.round(s * 100),
+    v: Math.round(v * 100)
+  };
+}
+function rgbToLab(rgb) {
+  return xyzToLab(rgbToXyz(rgb));
+}
+function rgbToXyz(rgb) {
+  let r = rgb.r / 255;
+  let g = rgb.g / 255;
+  let b = rgb.b / 255;
+  r = r > 0.04045 ? Math.pow((r + 0.055) / 1.055, 2.4) : r / 12.92;
+  g = g > 0.04045 ? Math.pow((g + 0.055) / 1.055, 2.4) : g / 12.92;
+  b = b > 0.04045 ? Math.pow((b + 0.055) / 1.055, 2.4) : b / 12.92;
+  r *= 100;
+  g *= 100;
+  b *= 100;
+  return {
+    x: r * 0.4124564 + g * 0.3575761 + b * 0.1804375,
+    y: r * 0.2126729 + g * 0.7151522 + b * 0.072175,
+    z: r * 0.0193339 + g * 0.119192 + b * 0.9503041
+  };
+}
+function xyzToLab(xyz) {
+  const { D65, EPSILON, KAPPA } = ColorConstants;
+  const x = xyz.x / D65.X;
+  const y = xyz.y / D65.Y;
+  const z = xyz.z / D65.Z;
+  const fx = x > EPSILON ? Math.cbrt(x) : (KAPPA * x + 16) / 116;
+  const fy = y > EPSILON ? Math.cbrt(y) : (KAPPA * y + 16) / 116;
+  const fz = z > EPSILON ? Math.cbrt(z) : (KAPPA * z + 16) / 116;
+  return {
+    a: 500 * (fx - fy),
+    b: 200 * (fy - fz),
+    l: 116 * fy - 16
+  };
+}
+function xyzToRgb(xyz) {
+  const x = xyz.x / 100;
+  const y = xyz.y / 100;
+  const z = xyz.z / 100;
+  let r = x * 3.2404542 + y * -1.5371385 + z * -0.4985314;
+  let g = x * -0.969266 + y * 1.8760108 + z * 0.041556;
+  let b = x * 0.0556434 + y * -0.2040259 + z * 1.0572252;
+  r = r > 31308e-7 ? 1.055 * Math.pow(r, 1 / 2.4) - 0.055 : 12.92 * r;
+  g = g > 31308e-7 ? 1.055 * Math.pow(g, 1 / 2.4) - 0.055 : 12.92 * g;
+  b = b > 31308e-7 ? 1.055 * Math.pow(b, 1 / 2.4) - 0.055 : 12.92 * b;
+  return {
+    b: Math.round(Math.max(0, Math.min(255, b * 255))),
+    g: Math.round(Math.max(0, Math.min(255, g * 255))),
+    r: Math.round(Math.max(0, Math.min(255, r * 255)))
+  };
+}
+
+// src/color/hct/hct-solver.ts
+function hct(hue, chroma, tone) {
+  return {
+    c: Math.max(0, chroma),
+    h: sanitizeDegrees(hue),
+    t: Math.max(0, Math.min(100, tone))
+  };
+}
+function hctToRgb(hct2) {
+  const hue = sanitizeDegrees(hct2.h);
+  const chroma = Math.max(0, hct2.c);
+  const tone = Math.max(0, Math.min(100, hct2.t));
+  if (chroma < 1e-4 || tone < 0.5 || tone > 99.5) {
+    const gray2 = tone / 100 * 255;
+    return { b: gray2, g: gray2, r: gray2 };
+  }
+  const lstar = tone;
+  let bestRgb = null;
+  let low = 0;
+  let high = chroma;
+  const epsilon = 0.01;
+  while (high - low > epsilon) {
+    const mid = (low + high) / 2;
+    const a = mid * Math.cos(hue * Math.PI / 180);
+    const b = mid * Math.sin(hue * Math.PI / 180);
+    const xyz = labToXyz({ a, b, l: lstar });
+    const rgb = xyzToRgb(xyz);
+    if (isInGamut(rgb)) {
+      bestRgb = rgb;
+      low = mid;
+    } else {
+      high = mid;
+    }
+  }
+  if (bestRgb) {
+    return clampRgb(bestRgb);
+  }
+  for (let c = chroma; c >= 0; c -= 1) {
+    const a = c * Math.cos(hue * Math.PI / 180);
+    const b = c * Math.sin(hue * Math.PI / 180);
+    const xyz = labToXyz({ a, b, l: lstar });
+    const rgb = xyzToRgb(xyz);
+    if (isInGamut(rgb)) {
+      return clampRgb(rgb);
+    }
+  }
+  const gray = tone / 100 * 255;
+  return { b: gray, g: gray, r: gray };
+}
+function maxChroma(hue, tone) {
+  if (tone <= 0 || tone >= 100) return 0;
+  const hueCycle = hue % 360 / 360;
+  const redBoost = Math.sin(hueCycle * Math.PI * 2) * 0.2 + 1;
+  const toneFactor = Math.sin(tone / 100 * Math.PI);
+  return toneFactor * 120 * redBoost;
+}
+function rgbToHct(rgb) {
+  const xyz = rgbToXyz(rgb);
+  const lab = xyzToLab(xyz);
+  const tone = lab.l;
+  const chroma = Math.sqrt(lab.a * lab.a + lab.b * lab.b);
+  let hue = Math.atan2(lab.b, lab.a) * 180 / Math.PI;
+  if (hue < 0) {
+    hue += 360;
+  }
+  return {
+    c: chroma,
+    h: sanitizeDegrees(hue),
+    t: tone
+  };
+}
+function clampRgb(rgb) {
+  return {
+    b: Math.round(Math.max(0, Math.min(255, rgb.b))),
+    g: Math.round(Math.max(0, Math.min(255, rgb.g))),
+    r: Math.round(Math.max(0, Math.min(255, rgb.r)))
+  };
+}
+function isInGamut(rgb) {
+  return rgb.r >= 0 && rgb.r <= 255 && rgb.g >= 0 && rgb.g <= 255 && rgb.b >= 0 && rgb.b <= 255;
+}
+function sanitizeDegrees(degrees) {
+  return (degrees % 360 + 360) % 360;
+}
+
+// src/color/hct/hct-class.ts
+var Hct = class _Hct {
+  get chroma() {
+    return this._chroma;
+  }
+  /**
+   * Set the chroma of this color. Chroma may decrease because chroma has a
+   * different maximum for any given hue and tone.
+   * @param newChroma 0 <= newChroma < ?
+   */
+  set chroma(newChroma) {
+    const rgb = hctToRgb({ c: newChroma, h: this._hue, t: this._tone });
+    this._argb = rgbToArgb(rgb);
+    const hct2 = rgbToHct(rgb);
+    this._hue = hct2.h;
+    this._chroma = hct2.c;
+    this._tone = hct2.t;
+  }
+  get hue() {
+    return this._hue;
+  }
+  /**
+   * Set the hue of this color. Chroma may decrease because chroma has a
+   * different maximum for any given hue and tone.
+   * @param newHue 0 <= newHue < 360; invalid values are corrected.
+   */
+  set hue(newHue) {
+    const rgb = hctToRgb({ c: this._chroma, h: newHue, t: this._tone });
+    this._argb = rgbToArgb(rgb);
+    const hct2 = rgbToHct(rgb);
+    this._hue = hct2.h;
+    this._chroma = hct2.c;
+    this._tone = hct2.t;
+  }
+  get tone() {
+    return this._tone;
+  }
+  /**
+   * Set the tone of this color. Chroma may decrease because chroma has a
+   * different maximum for any given hue and tone.
+   * @param newTone 0 <= newTone <= 100; invalid values are corrected.
+   */
+  set tone(newTone) {
+    const rgb = hctToRgb({ c: this._chroma, h: this._hue, t: newTone });
+    this._argb = rgbToArgb(rgb);
+    const hct2 = rgbToHct(rgb);
+    this._hue = hct2.h;
+    this._chroma = hct2.c;
+    this._tone = hct2.t;
+  }
+  _argb;
+  _chroma;
+  _hue;
+  _tone;
+  constructor(argb) {
+    this._argb = argb;
+    const rgb = argbToRgb(argb);
+    const hct2 = rgbToHct(rgb);
+    this._hue = hct2.h;
+    this._chroma = hct2.c;
+    this._tone = hct2.t;
+  }
+  /**
+   * Create an HCT color from hue, chroma, and tone.
+   * @param hue 0 <= hue < 360; invalid values are corrected.
+   * @param chroma 0 <= chroma < ?; Chroma may decrease because chroma has a
+   *     different maximum for any given hue and tone.
+   * @param tone 0 <= tone <= 100; invalid values are corrected.
+   * @return HCT representation of a color in default viewing conditions.
+   */
+  static from(hue, chroma, tone) {
+    const rgb = hctToRgb({ c: chroma, h: hue, t: tone });
+    const argb = rgbToArgb(rgb);
+    return new _Hct(argb);
+  }
+  /**
+   * Create an HCT color from a color.
+   * @param argb ARGB representation of a color.
+   * @return HCT representation of a color in default viewing conditions
+   */
+  static fromInt(argb) {
+    return new _Hct(argb);
+  }
+  /**
+   * @return ARGB representation of an HCT color.
+   */
+  toInt() {
+    return this._argb;
+  }
+};
+
+// src/color/dislike/dislike-analyzer.ts
+var DislikeAnalyzer = class _DislikeAnalyzer {
+  /**
+   * Analyze a batch of colors and return statistics
+   * @param colors Array of HCT colors
+   * @return Statistics about disliked colors
+   */
+  static analyzeBatch(colors) {
+    const dislikedIndices = [];
+    colors.forEach((color, index) => {
+      if (_DislikeAnalyzer.isDisliked(color)) {
+        dislikedIndices.push(index);
+      }
+    });
+    return {
+      disliked: dislikedIndices.length,
+      dislikedIndices,
+      percentage: dislikedIndices.length / colors.length * 100,
+      total: colors.length
+    };
+  }
+  /**
+   * Fix all disliked colors in a batch
+   * @param colors Array of HCT colors
+   * @return Array with disliked colors fixed
+   */
+  static fixBatch(colors) {
+    return colors.map((color) => _DislikeAnalyzer.fixIfDisliked(color));
+  }
+  /**
+   * If a color is disliked, lighten it to make it likable.
+   *
+   * @param hct A color to be judged.
+   * @return A new color if the original color is disliked, or the original
+   *   color if it is acceptable.
+   */
+  static fixIfDisliked(hct2) {
+    if (_DislikeAnalyzer.isDisliked(hct2)) {
+      return Hct.from(hct2.hue, hct2.chroma, 70);
+    }
+    return hct2;
+  }
+  /**
+   * Fix a hex color if it's disliked
+   * @param hex Hex color string
+   * @return Fixed hex color or original if not disliked
+   */
+  static fixIfDislikedHex(hex) {
+    const argb = parseInt(hex.replace("#", ""), 16) | 4278190080;
+    const hct2 = Hct.fromInt(argb);
+    const fixed = _DislikeAnalyzer.fixIfDisliked(hct2);
+    if (fixed === hct2) {
+      return hex;
+    }
+    const fixedArgb = fixed.toInt();
+    const r = fixedArgb >> 16 & 255;
+    const g = fixedArgb >> 8 & 255;
+    const b = fixedArgb & 255;
+    return "#" + [r, g, b].map((x) => x.toString(16).padStart(2, "0")).join("");
+  }
+  /**
+   * Returns true if a color is disliked.
+   *
+   * @param hct A color to be judged.
+   * @return Whether the color is disliked.
+   *
+   * Disliked is defined as a dark yellow-green that is not neutral.
+   * Specifically: hue 90-111°, chroma > 16, tone < 65
+   */
+  static isDisliked(hct2) {
+    const huePasses = Math.round(hct2.hue) >= 90 && Math.round(hct2.hue) <= 111;
+    const chromaPasses = Math.round(hct2.chroma) > 16;
+    const tonePasses = Math.round(hct2.tone) < 65;
+    return huePasses && chromaPasses && tonePasses;
+  }
+  /**
+   * Check if a color is in the "bile zone" - universally disliked colors
+   * @param hex Hex color string
+   * @return Whether the color is disliked
+   */
+  static isDislikedHex(hex) {
+    const hct2 = Hct.fromInt(parseInt(hex.replace("#", ""), 16) | 4278190080);
+    return _DislikeAnalyzer.isDisliked(hct2);
+  }
+};
+
+// src/color/hct/harmonization.ts
+function adjustTemperature(color, amount) {
+  const hctColor = rgbToHct(color);
+  const isWarm = hctColor.h <= 60 || hctColor.h >= 300;
+  let newHue;
+  if (amount > 0) {
+    newHue = isWarm ? circularInterpolate(hctColor.h, 30, Math.min(amount, 1)) : circularInterpolate(hctColor.h, 30, Math.min(amount * 2, 1));
+  } else {
+    newHue = !isWarm ? circularInterpolate(hctColor.h, 210, Math.min(-amount, 1)) : circularInterpolate(hctColor.h, 210, Math.min(-amount * 2, 1));
+  }
+  return hctToRgb(hct(newHue, hctColor.c, hctColor.t));
+}
+function analogous(color, angle = 30, count = 2) {
+  const hctColor = rgbToHct(color);
+  const colors = [];
+  for (let i = 1; i <= count; i++) {
+    colors.push(
+      hctToRgb(
+        hct(
+          sanitizeDegreesDouble(hctColor.h + angle * i),
+          hctColor.c,
+          hctColor.t
+        )
+      )
+    );
+    colors.push(
+      hctToRgb(
+        hct(
+          sanitizeDegreesDouble(hctColor.h - angle * i),
+          hctColor.c,
+          hctColor.t
+        )
+      )
+    );
+  }
+  return colors;
+}
+function blend(from, to, amount) {
+  const fromHct = rgbToHct(from);
+  const toHct = rgbToHct(to);
+  const h = circularInterpolate(fromHct.h, toHct.h, amount);
+  const c = fromHct.c + (toHct.c - fromHct.c) * amount;
+  const t = fromHct.t + (toHct.t - fromHct.t) * amount;
+  return hctToRgb(hct(h, c, t));
+}
+function doubleComplementary(color1, color2) {
+  const hct1 = rgbToHct(color1);
+  const hct2 = rgbToHct(color2);
+  return [
+    color1,
+    color2,
+    hctToRgb(hct((hct1.h + 180) % 360, hct1.c, hct1.t)),
+    hctToRgb(hct((hct2.h + 180) % 360, hct2.c, hct2.t))
+  ];
+}
+function gradient(from, to, steps) {
+  const colors = [];
+  for (let i = 0; i < steps; i++) {
+    const amount = i / (steps - 1);
+    colors.push(blend(from, to, amount));
+  }
+  return colors;
+}
+function harmonize(design, source, factor = 0.5) {
+  const fromHct = rgbToHct(design);
+  const toHct = rgbToHct(source);
+  const diffDegrees = differenceDegrees(fromHct.h, toHct.h);
+  const rotationDegrees = Math.min(diffDegrees * factor, 15);
+  const outputHue = sanitizeDegreesDouble(
+    fromHct.h + rotationDegrees * rotationDirection(fromHct.h, toHct.h)
+  );
+  return hctToRgb(hct(outputHue, fromHct.c, fromHct.t));
+}
+function splitComplementary(color, angle = 30) {
+  const hctColor = rgbToHct(color);
+  const complement = (hctColor.h + 180) % 360;
+  return [
+    color,
+    hctToRgb(
+      hct(sanitizeDegreesDouble(complement - angle), hctColor.c, hctColor.t)
+    ),
+    hctToRgb(
+      hct(sanitizeDegreesDouble(complement + angle), hctColor.c, hctColor.t)
+    )
+  ];
+}
+function tetradic(color) {
+  const hctColor = rgbToHct(color);
+  return [
+    color,
+    hctToRgb(hct((hctColor.h + 90) % 360, hctColor.c, hctColor.t)),
+    hctToRgb(hct((hctColor.h + 180) % 360, hctColor.c, hctColor.t)),
+    hctToRgb(hct((hctColor.h + 270) % 360, hctColor.c, hctColor.t))
+  ];
+}
+function circularInterpolate(from, to, amount) {
+  const difference = to - from;
+  const distance = Math.abs(difference);
+  if (distance > 180) {
+    if (difference > 0) {
+      from += 360;
+    } else {
+      to += 360;
+    }
+  }
+  return sanitizeDegreesDouble(from + (to - from) * amount);
+}
+function differenceDegrees(a, b) {
+  return Math.abs((a - b + 180) % 360 - 180);
+}
+function rotationDirection(from, to) {
+  const difference = to - from;
+  const normalized = (difference + 180) % 360 - 180;
+  return normalized >= 0 ? 1 : -1;
+}
+function sanitizeDegreesDouble(degrees) {
+  return (degrees % 360 + 360) % 360;
+}
+
+// src/color/hct/tonal-palette.ts
+var MATERIAL_TONES = [
+  0,
+  10,
+  20,
+  30,
+  40,
+  50,
+  60,
+  70,
+  80,
+  90,
+  95,
+  99,
+  100
+];
+var EXTENDED_TONES = [
+  0,
+  5,
+  10,
+  15,
+  20,
+  25,
+  30,
+  35,
+  40,
+  45,
+  50,
+  55,
+  60,
+  65,
+  70,
+  75,
+  80,
+  85,
+  90,
+  92,
+  94,
+  96,
+  98,
+  99,
+  100
+];
+var TonalPalette = class _TonalPalette {
+  constructor(hue, chroma) {
+    this.hue = hue;
+    this.chroma = chroma;
+  }
+  /**
+   * Get extended tones for more options
+   */
+  get extendedTones() {
+    const tones = {};
+    for (const t of EXTENDED_TONES) {
+      tones[t] = this.tone(t);
+    }
+    return tones;
+  }
+  /**
+   * Get all Material 3 standard tones
+   */
+  get materialTones() {
+    const tones = {};
+    for (const t of MATERIAL_TONES) {
+      tones[t] = this.tone(t);
+    }
+    return tones;
+  }
+  cache = /* @__PURE__ */ new Map();
+  /**
+   * Create a tonal palette from an HCT color
+   */
+  static fromHct(color) {
+    return new _TonalPalette(color.h, color.c);
+  }
+  /**
+   * Create a tonal palette from an RGB color
+   */
+  static fromRgb(rgb) {
+    const hctColor = rgbToHct(rgb);
+    return new _TonalPalette(hctColor.h, hctColor.c);
+  }
+  /**
+   * Get the color at a specific tone
+   */
+  tone(tone) {
+    if (this.cache.has(tone)) {
+      return this.cache.get(tone);
+    }
+    const color = hctToRgb(hct(this.hue, this.chroma, tone));
+    this.cache.set(tone, color);
+    return color;
+  }
+};
+function analogousPalette(source, count = 5, hueShift = 30) {
+  const sourceHct = rgbToHct(source);
+  const palettes = [];
+  const startHue = sourceHct.h - hueShift * Math.floor(count / 2);
+  for (let i = 0; i < count; i++) {
+    const hue = (startHue + i * hueShift + 360) % 360;
+    palettes.push(new TonalPalette(hue, sourceHct.c));
+  }
+  return palettes;
+}
+function complementaryPalette(source) {
+  const sourceHct = rgbToHct(source);
+  return [
+    new TonalPalette(sourceHct.h, sourceHct.c),
+    new TonalPalette((sourceHct.h + 180) % 360, sourceHct.c)
+  ];
+}
+function corePaletteFromRgb(source) {
+  const sourceHct = rgbToHct(source);
+  const primary = new TonalPalette(sourceHct.h, Math.max(48, sourceHct.c));
+  const secondary = new TonalPalette(
+    sourceHct.h,
+    Math.max(16, sourceHct.c / 3)
+  );
+  const tertiary = new TonalPalette(
+    (sourceHct.h + 60) % 360,
+    Math.max(24, sourceHct.c / 2)
+  );
+  const error = new TonalPalette(25, 84);
+  const neutral = new TonalPalette(sourceHct.h, Math.min(4, sourceHct.c / 12));
+  const neutralVariant = new TonalPalette(
+    sourceHct.h,
+    Math.min(8, sourceHct.c / 6)
+  );
+  return {
+    error,
+    neutral,
+    neutralVariant,
+    primary,
+    secondary,
+    tertiary
+  };
+}
+function monochromaticPalette(source, tones = MATERIAL_TONES) {
+  const palette = TonalPalette.fromRgb(source);
+  return tones.map((t) => palette.tone(t));
+}
+function triadicPalette(source) {
+  const sourceHct = rgbToHct(source);
+  return [
+    new TonalPalette(sourceHct.h, sourceHct.c),
+    new TonalPalette((sourceHct.h + 120) % 360, sourceHct.c),
+    new TonalPalette((sourceHct.h + 240) % 360, sourceHct.c)
+  ];
+}
+
+// src/color/hct/types.ts
+var STANDARD_CONDITIONS = {
+  aw: 29.98,
+  c: 0.69,
+  fl: 0.388,
+  flRoot: 0.789,
+  n: 0.184,
+  nbb: 1.017,
+  nc: 1,
+  ncb: 1.017,
+  rgbD: [1.021, 0.986, 0.934],
+  z: 1.909
+};
+
+// src/color/metrics.ts
+function areColorsSimilar(color1, color2, threshold = 2.3) {
+  const distance = colorDistance(color1, color2, { metric: "deltaE2000" });
+  return distance <= threshold;
+}
+function colorDistance(color1, color2, options) {
+  const metric = options?.metric ?? "deltaE2000";
+  switch (metric) {
+    case "deltaE76": {
+      const lab1 = rgbToLab(color1);
+      const lab2 = rgbToLab(color2);
+      return deltaE76(lab1, lab2);
+    }
+    case "deltaE94": {
+      const lab1 = rgbToLab(color1);
+      const lab2 = rgbToLab(color2);
+      return deltaE94(lab1, lab2, options?.deltaE94);
+    }
+    case "euclidean":
+      return euclideanDistance(color1, color2);
+    case "weighted":
+      return weightedRgbDistance(color1, color2, options?.weights);
+    case "deltaE2000":
+    default: {
+      const lab1 = rgbToLab(color1);
+      const lab2 = rgbToLab(color2);
+      return deltaE2000(lab1, lab2);
+    }
+  }
+}
+function deltaE2000(lab1, lab2) {
+  const deg2rad = (deg) => deg * (Math.PI / 180);
+  const rad2deg = (rad) => rad * (180 / Math.PI);
+  const kL = 1;
+  const kC = 1;
+  const kH = 1;
+  const C1 = Math.sqrt(lab1.a * lab1.a + lab1.b * lab1.b);
+  const C2 = Math.sqrt(lab2.a * lab2.a + lab2.b * lab2.b);
+  const Cbar = (C1 + C2) / 2;
+  const G = 0.5 * (1 - Math.sqrt(Math.pow(Cbar, 7) / (Math.pow(Cbar, 7) + Math.pow(25, 7))));
+  const a1p = lab1.a * (1 + G);
+  const a2p = lab2.a * (1 + G);
+  const C1p = Math.sqrt(a1p * a1p + lab1.b * lab1.b);
+  const C2p = Math.sqrt(a2p * a2p + lab2.b * lab2.b);
+  let h1p = Math.atan2(lab1.b, a1p);
+  let h2p = Math.atan2(lab2.b, a2p);
+  if (h1p < 0) h1p += 2 * Math.PI;
+  if (h2p < 0) h2p += 2 * Math.PI;
+  h1p = rad2deg(h1p);
+  h2p = rad2deg(h2p);
+  const dLp = lab2.l - lab1.l;
+  const dCp = C2p - C1p;
+  let dhp = h2p - h1p;
+  if (dhp > 180) dhp -= 360;
+  if (dhp < -180) dhp += 360;
+  const dHp = 2 * Math.sqrt(C1p * C2p) * Math.sin(deg2rad(dhp) / 2);
+  const Lbar = (lab1.l + lab2.l) / 2;
+  const Cpbar = (C1p + C2p) / 2;
+  let hpbar = (h1p + h2p) / 2;
+  if (Math.abs(h1p - h2p) > 180) {
+    if (h1p + h2p < 360) {
+      hpbar += 180;
+    } else {
+      hpbar -= 180;
+    }
+  }
+  const T = 1 - 0.17 * Math.cos(deg2rad(hpbar - 30)) + 0.24 * Math.cos(deg2rad(2 * hpbar)) + 0.32 * Math.cos(deg2rad(3 * hpbar + 6)) - 0.2 * Math.cos(deg2rad(4 * hpbar - 63));
+  const dTheta = 30 * Math.exp(-Math.pow((hpbar - 275) / 25, 2));
+  const RC = 2 * Math.sqrt(Math.pow(Cpbar, 7) / (Math.pow(Cpbar, 7) + Math.pow(25, 7)));
+  const RT = -RC * Math.sin(2 * deg2rad(dTheta));
+  const SL = 1 + 0.015 * Math.pow(Lbar - 50, 2) / Math.sqrt(20 + Math.pow(Lbar - 50, 2));
+  const SC = 1 + 0.045 * Cpbar;
+  const SH = 1 + 0.015 * Cpbar * T;
+  const dLpKlSl = dLp / (kL * SL);
+  const dCpKcSc = dCp / (kC * SC);
+  const dHpKhSh = dHp / (kH * SH);
+  return Math.sqrt(
+    dLpKlSl * dLpKlSl + dCpKcSc * dCpKcSc + dHpKhSh * dHpKhSh + RT * dCpKcSc * dHpKhSh
+  );
+}
+function deltaE76(lab1, lab2) {
+  const dL = lab1.l - lab2.l;
+  const da = lab1.a - lab2.a;
+  const db = lab1.b - lab2.b;
+  return Math.sqrt(dL * dL + da * da + db * db);
+}
+function deltaE94(lab1, lab2, options) {
+  const kL = options?.kL ?? 1;
+  const kC = options?.kC ?? 1;
+  const kH = options?.kH ?? 1;
+  const dL = lab1.l - lab2.l;
+  const da = lab1.a - lab2.a;
+  const db = lab1.b - lab2.b;
+  const C1 = Math.sqrt(lab1.a * lab1.a + lab1.b * lab1.b);
+  const C2 = Math.sqrt(lab2.a * lab2.a + lab2.b * lab2.b);
+  const dC = C1 - C2;
+  const dH2 = da * da + db * db - dC * dC;
+  const dH = dH2 > 0 ? Math.sqrt(dH2) : 0;
+  const SL = 1;
+  const SC = 1 + 0.045 * C1;
+  const SH = 1 + 0.015 * C1;
+  const dLKlSl = dL / (kL * SL);
+  const dCKcSc = dC / (kC * SC);
+  const dHKhSh = dH / (kH * SH);
+  return Math.sqrt(dLKlSl * dLKlSl + dCKcSc * dCKcSc + dHKhSh * dHKhSh);
+}
+function euclideanDistance(color1, color2) {
+  const dr = color1.r - color2.r;
+  const dg = color1.g - color2.g;
+  const db = color1.b - color2.b;
+  return Math.sqrt(dr * dr + dg * dg + db * db);
+}
+function findMostDifferentColor(baseColor, colors, options) {
+  if (colors.length === 0) return null;
+  let maxDistance = -Infinity;
+  let mostDifferent = colors[0];
+  for (const color of colors) {
+    const distance = colorDistance(baseColor, color, options);
+    if (distance > maxDistance) {
+      maxDistance = distance;
+      mostDifferent = color;
+    }
+  }
+  return mostDifferent;
+}
+function findMostSimilarColor(baseColor, colors, options) {
+  if (colors.length === 0) return null;
+  let minDistance = Infinity;
+  let mostSimilar = colors[0];
+  for (const color of colors) {
+    const distance = colorDistance(baseColor, color, options);
+    if (distance < minDistance) {
+      minDistance = distance;
+      mostSimilar = color;
+    }
+  }
+  return mostSimilar;
+}
+function weightedRgbDistance(color1, color2, weights) {
+  const wr = weights?.r ?? 0.3;
+  const wg = weights?.g ?? 0.59;
+  const wb = weights?.b ?? 0.11;
+  const dr = (color1.r - color2.r) * wr;
+  const dg = (color1.g - color2.g) * wg;
+  const db = (color1.b - color2.b) * wb;
+  return Math.sqrt(dr * dr + dg * dg + db * db);
+}
+
+// src/color/utils.ts
+function clampHsl(hsl) {
+  return {
+    h: clamp(hsl.h, 0, 360),
+    l: clamp(hsl.l, 0, 100),
+    s: clamp(hsl.s, 0, 100)
+  };
+}
+function clampHsv(hsv) {
+  return {
+    h: clamp(hsv.h, 0, 360),
+    s: clamp(hsv.s, 0, 100),
+    v: clamp(hsv.v, 0, 100)
+  };
+}
+function clampRgb2(rgb) {
+  return {
+    b: clamp(rgb.b, 0, 255),
+    g: clamp(rgb.g, 0, 255),
+    r: clamp(rgb.r, 0, 255)
+  };
+}
+function darken(rgb, amount) {
+  const hsl = rgbToHsl(rgb);
+  hsl.l = clamp(hsl.l - amount, 0, 100);
+  return parseColor(formatHsl(hsl)) || rgb;
+}
+function desaturate(rgb, amount) {
+  const hsl = rgbToHsl(rgb);
+  hsl.s = clamp(hsl.s - amount, 0, 100);
+  return parseColor(formatHsl(hsl)) || rgb;
+}
+function formatColor(rgb, format = "hex") {
+  switch (format) {
+    case "hex":
+      return rgbToHex(rgb);
+    case "hsl":
+      return formatHsl(rgbToHsl(rgb));
+    case "hsv": {
+      const hsv = rgbToHsv(rgb);
+      return `hsv(${hsv.h}, ${hsv.s}%, ${hsv.v}%)`;
+    }
+    case "rgb":
+      return formatRgb(rgb);
+    default:
+      return rgbToHex(rgb);
+  }
+}
+function formatHsl(hsl, alpha) {
+  if (alpha !== void 0) {
+    return `hsla(${hsl.h}, ${hsl.s}%, ${hsl.l}%, ${alpha})`;
+  }
+  return `hsl(${hsl.h}, ${hsl.s}%, ${hsl.l}%)`;
+}
+function formatRgb(rgb, alpha) {
+  if (alpha !== void 0) {
+    return `rgba(${rgb.r}, ${rgb.g}, ${rgb.b}, ${alpha})`;
+  }
+  return `rgb(${rgb.r}, ${rgb.g}, ${rgb.b})`;
+}
+function getComplementary(rgb) {
+  const hsl = rgbToHsl(rgb);
+  hsl.h = (hsl.h + 180) % 360;
+  return parseColor(formatHsl(hsl)) || rgb;
+}
+function getContrastRatio(color1, color2) {
+  const lum1 = getLuminance(color1);
+  const lum2 = getLuminance(color2);
+  const lighter = Math.max(lum1, lum2);
+  const darker = Math.min(lum1, lum2);
+  return (lighter + 0.05) / (darker + 0.05);
+}
+function getLuminance(rgb) {
+  const rsRGB = rgb.r / 255;
+  const gsRGB = rgb.g / 255;
+  const bsRGB = rgb.b / 255;
+  const r = rsRGB <= 0.03928 ? rsRGB / 12.92 : Math.pow((rsRGB + 0.055) / 1.055, 2.4);
+  const g = gsRGB <= 0.03928 ? gsRGB / 12.92 : Math.pow((gsRGB + 0.055) / 1.055, 2.4);
+  const b = bsRGB <= 0.03928 ? bsRGB / 12.92 : Math.pow((bsRGB + 0.055) / 1.055, 2.4);
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+function invertColor(rgb) {
+  return {
+    b: 255 - rgb.b,
+    g: 255 - rgb.g,
+    r: 255 - rgb.r
+  };
+}
+function isDark(rgb, threshold = 0.5) {
+  return getLuminance(rgb) < threshold;
+}
+function isLight(rgb, threshold = 0.5) {
+  return getLuminance(rgb) >= threshold;
+}
+function isValidHex(hex) {
+  const cleanHex = hex.replace("#", "");
+  return /^[0-9A-Fa-f]{3}$|^[0-9A-Fa-f]{6}$/.test(cleanHex);
+}
+function isValidHsl(hsl) {
+  return hsl.h >= 0 && hsl.h <= 360 && hsl.s >= 0 && hsl.s <= 100 && hsl.l >= 0 && hsl.l <= 100;
+}
+function isValidHsv(hsv) {
+  return hsv.h >= 0 && hsv.h <= 360 && hsv.s >= 0 && hsv.s <= 100 && hsv.v >= 0 && hsv.v <= 100;
+}
+function isValidRgb(rgb) {
+  return rgb.r >= 0 && rgb.r <= 255 && rgb.g >= 0 && rgb.g <= 255 && rgb.b >= 0 && rgb.b <= 255;
+}
+function lighten(rgb, amount) {
+  const hsl = rgbToHsl(rgb);
+  hsl.l = clamp(hsl.l + amount, 0, 100);
+  return parseColor(formatHsl(hsl)) || rgb;
+}
+function meetsContrastAA(color1, color2, largeText = false) {
+  const ratio = getContrastRatio(color1, color2);
+  return largeText ? ratio >= 3 : ratio >= 4.5;
+}
+function meetsContrastAAA(color1, color2, largeText = false) {
+  const ratio = getContrastRatio(color1, color2);
+  return largeText ? ratio >= 4.5 : ratio >= 7;
+}
+function mixColors(color1, color2, weight = 0.5) {
+  const w = clamp(weight, 0, 1);
+  const w2 = 1 - w;
+  return {
+    b: Math.round(color1.b * w + color2.b * w2),
+    g: Math.round(color1.g * w + color2.g * w2),
+    r: Math.round(color1.r * w + color2.r * w2)
+  };
+}
+function randomColor() {
+  return {
+    b: Math.floor(Math.random() * 256),
+    g: Math.floor(Math.random() * 256),
+    r: Math.floor(Math.random() * 256)
+  };
+}
+function saturate(rgb, amount) {
+  const hsl = rgbToHsl(rgb);
+  hsl.s = clamp(hsl.s + amount, 0, 100);
+  return parseColor(formatHsl(hsl)) || rgb;
+}
+function toGrayscale(rgb) {
+  const gray = Math.round(0.299 * rgb.r + 0.587 * rgb.g + 0.114 * rgb.b);
+  return { b: gray, g: gray, r: gray };
+}
+function clamp(value, min, max) {
+  return Math.max(min, Math.min(max, value));
+}
+
+export {
+  ColorFormat,
+  ColorConstants,
+  argbToRgb,
+  hexToRgb,
+  hslToRgb,
+  hsvToRgb,
+  labToRgb,
+  labToXyz,
+  parseColor,
+  rgbToArgb,
+  rgbToHex,
+  rgbToHsl,
+  rgbToHsv,
+  rgbToLab,
+  rgbToXyz,
+  xyzToLab,
+  xyzToRgb,
+  hct,
+  hctToRgb,
+  maxChroma,
+  rgbToHct,
+  Hct,
+  DislikeAnalyzer,
+  adjustTemperature,
+  analogous,
+  blend,
+  doubleComplementary,
+  gradient,
+  harmonize,
+  splitComplementary,
+  tetradic,
+  MATERIAL_TONES,
+  EXTENDED_TONES,
+  TonalPalette,
+  analogousPalette,
+  complementaryPalette,
+  corePaletteFromRgb,
+  monochromaticPalette,
+  triadicPalette,
+  STANDARD_CONDITIONS,
+  areColorsSimilar,
+  colorDistance,
+  deltaE2000,
+  deltaE76,
+  deltaE94,
+  euclideanDistance,
+  findMostDifferentColor,
+  findMostSimilarColor,
+  weightedRgbDistance,
+  clampHsl,
+  clampHsv,
+  clampRgb2 as clampRgb,
+  darken,
+  desaturate,
+  formatColor,
+  formatHsl,
+  formatRgb,
+  getComplementary,
+  getContrastRatio,
+  getLuminance,
+  invertColor,
+  isDark,
+  isLight,
+  isValidHex,
+  isValidHsl,
+  isValidHsv,
+  isValidRgb,
+  lighten,
+  meetsContrastAA,
+  meetsContrastAAA,
+  mixColors,
+  randomColor,
+  saturate,
+  toGrayscale
+};
+//# sourceMappingURL=chunk-P3ARRKLS.js.map