@utilix-tech/sdk 0.1.0

package/dist/tools/color.cjs

@@ -0,0 +1,1122 @@
+'use strict';
+
+// src/tools/color.ts
+var NAMED_COLORS_CONVERTER = {
+  red: "#FF0000",
+  green: "#008000",
+  blue: "#0000FF",
+  white: "#FFFFFF",
+  black: "#000000",
+  yellow: "#FFFF00",
+  orange: "#FFA500",
+  purple: "#800080",
+  pink: "#FFC0CB",
+  cyan: "#00FFFF",
+  magenta: "#FF00FF",
+  brown: "#A52A2A",
+  gray: "#808080",
+  grey: "#808080",
+  lime: "#00FF00",
+  indigo: "#4B0082",
+  violet: "#EE82EE",
+  silver: "#C0C0C0",
+  gold: "#FFD700",
+  navy: "#000080"
+};
+function hexToRgb(hex) {
+  const clean = hex.replace("#", "");
+  let r, g, b;
+  if (clean.length === 3) {
+    r = parseInt(clean[0] + clean[0], 16);
+    g = parseInt(clean[1] + clean[1], 16);
+    b = parseInt(clean[2] + clean[2], 16);
+  } else if (clean.length === 6) {
+    r = parseInt(clean.slice(0, 2), 16);
+    g = parseInt(clean.slice(2, 4), 16);
+    b = parseInt(clean.slice(4, 6), 16);
+  } else {
+    throw new Error(`Invalid hex: ${hex}`);
+  }
+  return { r, g, b };
+}
+function rgbToHex(rgb) {
+  const toHex = (n) => Math.round(Math.min(255, Math.max(0, n))).toString(16).padStart(2, "0").toUpperCase();
+  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 delta = max - min;
+  let h = 0;
+  let s = 0;
+  const l = (max + min) / 2;
+  if (delta !== 0) {
+    s = delta / (1 - Math.abs(2 * l - 1));
+    if (max === r) {
+      h = (g - b) / delta % 6;
+    } else if (max === g) {
+      h = (b - r) / delta + 2;
+    } else {
+      h = (r - g) / delta + 4;
+    }
+    h = h * 60;
+    if (h < 0) h += 360;
+  }
+  return {
+    h: Math.round(h),
+    s: Math.round(s * 100),
+    l: Math.round(l * 100)
+  };
+}
+function hslToRgb(hsl) {
+  const h = hsl.h;
+  const s = hsl.s / 100;
+  const l = hsl.l / 100;
+  const c = (1 - Math.abs(2 * l - 1)) * s;
+  const x = c * (1 - Math.abs(h / 60 % 2 - 1));
+  const m = l - c / 2;
+  let r = 0, g = 0, b = 0;
+  if (h < 60) {
+    r = c;
+    g = x;
+    b = 0;
+  } else if (h < 120) {
+    r = x;
+    g = c;
+    b = 0;
+  } else if (h < 180) {
+    r = 0;
+    g = c;
+    b = x;
+  } else if (h < 240) {
+    r = 0;
+    g = x;
+    b = c;
+  } else if (h < 300) {
+    r = x;
+    g = 0;
+    b = c;
+  } else {
+    r = c;
+    g = 0;
+    b = x;
+  }
+  return {
+    r: Math.round((r + m) * 255),
+    g: Math.round((g + m) * 255),
+    b: Math.round((b + m) * 255)
+  };
+}
+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 delta = max - min;
+  let h = 0;
+  const s = max === 0 ? 0 : delta / max;
+  const v = max;
+  if (delta !== 0) {
+    if (max === r) {
+      h = (g - b) / delta % 6;
+    } else if (max === g) {
+      h = (b - r) / delta + 2;
+    } else {
+      h = (r - g) / delta + 4;
+    }
+    h = h * 60;
+    if (h < 0) h += 360;
+  }
+  return {
+    h: Math.round(h),
+    s: Math.round(s * 100),
+    v: Math.round(v * 100)
+  };
+}
+function hsvToRgb(hsv) {
+  const h = hsv.h;
+  const s = hsv.s / 100;
+  const v = hsv.v / 100;
+  const c = v * s;
+  const x = c * (1 - Math.abs(h / 60 % 2 - 1));
+  const m = v - c;
+  let r = 0, g = 0, b = 0;
+  if (h < 60) {
+    r = c;
+    g = x;
+    b = 0;
+  } else if (h < 120) {
+    r = x;
+    g = c;
+    b = 0;
+  } else if (h < 180) {
+    r = 0;
+    g = c;
+    b = x;
+  } else if (h < 240) {
+    r = 0;
+    g = x;
+    b = c;
+  } else if (h < 300) {
+    r = x;
+    g = 0;
+    b = c;
+  } else {
+    r = c;
+    g = 0;
+    b = x;
+  }
+  return {
+    r: Math.round((r + m) * 255),
+    g: Math.round((g + m) * 255),
+    b: Math.round((b + m) * 255)
+  };
+}
+function buildConverterResult(rgb) {
+  const hex = rgbToHex(rgb);
+  const hsl = rgbToHsl(rgb);
+  const hsv = rgbToHsv(rgb);
+  return {
+    hex,
+    rgb,
+    hsl,
+    hsv,
+    css: {
+      hex: hex.toLowerCase(),
+      rgb: `rgb(${rgb.r}, ${rgb.g}, ${rgb.b})`,
+      hsl: `hsl(${hsl.h}, ${hsl.s}%, ${hsl.l}%)`
+    },
+    valid: true
+  };
+}
+function converterErrorResult(error) {
+  return {
+    hex: "",
+    rgb: { r: 0, g: 0, b: 0 },
+    hsl: { h: 0, s: 0, l: 0 },
+    hsv: { h: 0, s: 0, v: 0 },
+    css: { hex: "", rgb: "", hsl: "" },
+    valid: false,
+    error
+  };
+}
+function parseColor(input) {
+  if (!input || !input.trim()) {
+    return converterErrorResult("Empty input");
+  }
+  const trimmed = input.trim().toLowerCase();
+  const namedHex = NAMED_COLORS_CONVERTER[trimmed];
+  if (namedHex) {
+    try {
+      const rgb = hexToRgb(namedHex);
+      return buildConverterResult(rgb);
+    } catch {
+      return converterErrorResult(`Failed to parse named color: ${trimmed}`);
+    }
+  }
+  const hexMatch = trimmed.match(/^#([0-9a-f]{3}|[0-9a-f]{6})$/);
+  if (hexMatch) {
+    try {
+      const rgb = hexToRgb(trimmed);
+      return buildConverterResult(rgb);
+    } catch {
+      return converterErrorResult(`Invalid hex color: ${input}`);
+    }
+  }
+  const rgbMatch = trimmed.match(/^rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/);
+  if (rgbMatch) {
+    const r = parseInt(rgbMatch[1]);
+    const g = parseInt(rgbMatch[2]);
+    const b = parseInt(rgbMatch[3]);
+    if (r > 255 || g > 255 || b > 255) {
+      return converterErrorResult("RGB values must be 0\u2013255");
+    }
+    return buildConverterResult({ r, g, b });
+  }
+  const hslMatch = trimmed.match(/^hsla?\(\s*(\d+)\s*,\s*([\d.]+)%?\s*,\s*([\d.]+)%?/);
+  if (hslMatch) {
+    const h = parseInt(hslMatch[1]);
+    const s = parseFloat(hslMatch[2]);
+    const l = parseFloat(hslMatch[3]);
+    if (h > 360 || s > 100 || l > 100) {
+      return converterErrorResult("HSL values out of range");
+    }
+    const rgb = hslToRgb({ h, s, l });
+    return buildConverterResult(rgb);
+  }
+  return converterErrorResult(`Unrecognized color format: ${input}`);
+}
+var PALETTE_TYPES = [
+  "complementary",
+  "analogous",
+  "triadic",
+  "tetradic",
+  "split-complementary",
+  "monochromatic",
+  "shades"
+];
+function paletteWrapHue(h) {
+  return (h % 360 + 360) % 360;
+}
+function paletteClamp(value, min, max) {
+  return Math.min(max, Math.max(min, value));
+}
+function hexToHsl(hex) {
+  let cleaned = hex.trim();
+  if (!/^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/.test(cleaned)) {
+    throw new Error("Invalid hex color");
+  }
+  if (cleaned.length === 4) {
+    cleaned = "#" + cleaned[1] + cleaned[1] + cleaned[2] + cleaned[2] + cleaned[3] + cleaned[3];
+  }
+  const r = parseInt(cleaned.slice(1, 3), 16) / 255;
+  const g = parseInt(cleaned.slice(3, 5), 16) / 255;
+  const b = parseInt(cleaned.slice(5, 7), 16) / 255;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const delta = max - min;
+  let h = 0;
+  let s = 0;
+  const l = (max + min) / 2;
+  if (delta !== 0) {
+    s = delta / (1 - Math.abs(2 * l - 1));
+    if (max === r) {
+      h = ((g - b) / delta + (g < b ? 6 : 0)) * 60;
+    } else if (max === g) {
+      h = ((b - r) / delta + 2) * 60;
+    } else {
+      h = ((r - g) / delta + 4) * 60;
+    }
+  }
+  return {
+    h: Math.round(h * 10) / 10,
+    s: Math.round(s * 1e3) / 10,
+    l: Math.round(l * 1e3) / 10
+  };
+}
+function hslToHex(h, s, l) {
+  const sn = s / 100;
+  const ln = l / 100;
+  const c = (1 - Math.abs(2 * ln - 1)) * sn;
+  const x = c * (1 - Math.abs(h / 60 % 2 - 1));
+  const m = ln - c / 2;
+  let r = 0, g = 0, b = 0;
+  if (h >= 0 && h < 60) {
+    r = c;
+    g = x;
+    b = 0;
+  } else if (h >= 60 && h < 120) {
+    r = x;
+    g = c;
+    b = 0;
+  } else if (h >= 120 && h < 180) {
+    r = 0;
+    g = c;
+    b = x;
+  } else if (h >= 180 && h < 240) {
+    r = 0;
+    g = x;
+    b = c;
+  } else if (h >= 240 && h < 300) {
+    r = x;
+    g = 0;
+    b = c;
+  } else {
+    r = c;
+    g = 0;
+    b = x;
+  }
+  const clampHex = (v) => Math.max(0, Math.min(255, Math.round(v))).toString(16).padStart(2, "0");
+  return `#${clampHex((r + m) * 255)}${clampHex((g + m) * 255)}${clampHex((b + m) * 255)}`;
+}
+function paletteMakeColor(hsl, label) {
+  return {
+    hex: hslToHex(hsl.h, hsl.s, hsl.l),
+    hsl,
+    label
+  };
+}
+function paletteIsValidHex(hex) {
+  return /^#([0-9A-Fa-f]{3}|[0-9A-Fa-f]{6})$/.test(hex.trim());
+}
+function generatePalette(hex, type) {
+  if (!paletteIsValidHex(hex)) {
+    return { error: "Invalid hex color" };
+  }
+  const base = hexToHsl(hex);
+  const { h, s, l } = base;
+  let colors;
+  switch (type) {
+    case "complementary": {
+      colors = [
+        paletteMakeColor(base, "Base"),
+        paletteMakeColor({ h: paletteWrapHue(h + 180), s, l }, "Complement")
+      ];
+      break;
+    }
+    case "analogous": {
+      colors = [
+        paletteMakeColor({ h: paletteWrapHue(h - 30), s, l }, "Analogous -30\xB0"),
+        paletteMakeColor(base, "Base"),
+        paletteMakeColor({ h: paletteWrapHue(h + 30), s, l }, "Analogous +30\xB0")
+      ];
+      break;
+    }
+    case "triadic": {
+      colors = [
+        paletteMakeColor(base, "Base"),
+        paletteMakeColor({ h: paletteWrapHue(h + 120), s, l }, "Triadic 1"),
+        paletteMakeColor({ h: paletteWrapHue(h + 240), s, l }, "Triadic 2")
+      ];
+      break;
+    }
+    case "tetradic": {
+      colors = [
+        paletteMakeColor(base, "Base"),
+        paletteMakeColor({ h: paletteWrapHue(h + 90), s, l }, "Tetradic 1"),
+        paletteMakeColor({ h: paletteWrapHue(h + 180), s, l }, "Tetradic 2"),
+        paletteMakeColor({ h: paletteWrapHue(h + 270), s, l }, "Tetradic 3")
+      ];
+      break;
+    }
+    case "split-complementary": {
+      colors = [
+        paletteMakeColor(base, "Base"),
+        paletteMakeColor({ h: paletteWrapHue(h + 150), s, l }, "Split Complement 1"),
+        paletteMakeColor({ h: paletteWrapHue(h + 210), s, l }, "Split Complement 2")
+      ];
+      break;
+    }
+    case "monochromatic": {
+      const lightnessSteps = [
+        { offset: -30, label: "Lighter 2" },
+        { offset: -15, label: "Lighter 1" },
+        { offset: 0, label: "Base" },
+        { offset: 15, label: "Darker 1" },
+        { offset: 30, label: "Darker 2" }
+      ];
+      colors = lightnessSteps.map(
+        ({ offset, label }) => paletteMakeColor({ h, s, l: paletteClamp(l + offset, 0, 100) }, label)
+      );
+      break;
+    }
+    case "shades": {
+      colors = Array.from({ length: 8 }, (_, i) => {
+        const lightness = Math.round(10 + i * 80 / 7);
+        return paletteMakeColor({ h, s, l: lightness }, `Shade ${i + 1}`);
+      });
+      break;
+    }
+  }
+  return {
+    type,
+    baseHex: hex.trim(),
+    colors
+  };
+}
+function contrastParseColor(color) {
+  const trimmed = color.trim();
+  const shortHexMatch = trimmed.match(
+    /^#([0-9a-fA-F])([0-9a-fA-F])([0-9a-fA-F])$/
+  );
+  if (shortHexMatch) {
+    return {
+      r: parseInt(shortHexMatch[1] + shortHexMatch[1], 16),
+      g: parseInt(shortHexMatch[2] + shortHexMatch[2], 16),
+      b: parseInt(shortHexMatch[3] + shortHexMatch[3], 16)
+    };
+  }
+  const fullHexMatch = trimmed.match(
+    /^#([0-9a-fA-F]{2})([0-9a-fA-F]{2})([0-9a-fA-F]{2})$/
+  );
+  if (fullHexMatch) {
+    return {
+      r: parseInt(fullHexMatch[1], 16),
+      g: parseInt(fullHexMatch[2], 16),
+      b: parseInt(fullHexMatch[3], 16)
+    };
+  }
+  const rgbMatch = trimmed.match(
+    /^rgb\(\s*(\d{1,3})\s*,\s*(\d{1,3})\s*,\s*(\d{1,3})\s*\)$/
+  );
+  if (rgbMatch) {
+    const r = parseInt(rgbMatch[1], 10);
+    const g = parseInt(rgbMatch[2], 10);
+    const b = parseInt(rgbMatch[3], 10);
+    if (r > 255 || g > 255 || b > 255) return null;
+    return { r, g, b };
+  }
+  return null;
+}
+function lineariseChannel(c255) {
+  const sRGB = c255 / 255;
+  if (sRGB <= 0.04045) {
+    return sRGB / 12.92;
+  }
+  return Math.pow((sRGB + 0.055) / 1.055, 2.4);
+}
+function hexToLinearRgb(hex) {
+  const parsed = contrastParseColor(hex);
+  if (!parsed) {
+    throw new Error("Invalid color format");
+  }
+  return {
+    r: lineariseChannel(parsed.r),
+    g: lineariseChannel(parsed.g),
+    b: lineariseChannel(parsed.b)
+  };
+}
+function relativeLuminance(r, g, b) {
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+function checkContrast(color1, color2) {
+  const parsed1 = contrastParseColor(color1);
+  if (!parsed1) return { error: "Invalid color format" };
+  const parsed2 = contrastParseColor(color2);
+  if (!parsed2) return { error: "Invalid color format" };
+  const linear1 = {
+    r: lineariseChannel(parsed1.r),
+    g: lineariseChannel(parsed1.g),
+    b: lineariseChannel(parsed1.b)
+  };
+  const linear2 = {
+    r: lineariseChannel(parsed2.r),
+    g: lineariseChannel(parsed2.g),
+    b: lineariseChannel(parsed2.b)
+  };
+  const lum1 = relativeLuminance(linear1.r, linear1.g, linear1.b);
+  const lum2 = relativeLuminance(linear2.r, linear2.g, linear2.b);
+  const L1 = Math.max(lum1, lum2);
+  const L2 = Math.min(lum1, lum2);
+  const ratio = (L1 + 0.05) / (L2 + 0.05);
+  const aa = {
+    normal: ratio >= 4.5,
+    large: ratio >= 3,
+    ui: ratio >= 3
+  };
+  const aaa = {
+    normal: ratio >= 7,
+    large: ratio >= 4.5
+  };
+  let level;
+  if (aaa.normal) {
+    level = "AAA";
+  } else if (aa.normal) {
+    level = "AA";
+  } else if (aa.large) {
+    level = "AA Large";
+  } else {
+    level = "Fail";
+  }
+  return {
+    ratio,
+    ratioString: ratio.toFixed(2) + ":1",
+    aa,
+    aaa,
+    level
+  };
+}
+var NAMED_COLORS = {
+  black: "#000000",
+  white: "#ffffff",
+  red: "#ff0000",
+  green: "#008000",
+  blue: "#0000ff",
+  yellow: "#ffff00",
+  cyan: "#00ffff",
+  magenta: "#ff00ff",
+  orange: "#ffa500",
+  purple: "#800080",
+  pink: "#ffc0cb",
+  brown: "#a52a2a",
+  gray: "#808080",
+  grey: "#808080",
+  lime: "#00ff00",
+  navy: "#000080",
+  teal: "#008080",
+  silver: "#c0c0c0",
+  gold: "#ffd700",
+  coral: "#ff7f50"
+};
+function hexToRgbPicker(hex) {
+  const clean = hex.replace("#", "");
+  if (clean.length === 3) {
+    const r = parseInt(clean[0] + clean[0], 16);
+    const g = parseInt(clean[1] + clean[1], 16);
+    const b = parseInt(clean[2] + clean[2], 16);
+    if (isNaN(r) || isNaN(g) || isNaN(b)) return null;
+    return { r, g, b };
+  }
+  if (clean.length === 6) {
+    const r = parseInt(clean.slice(0, 2), 16);
+    const g = parseInt(clean.slice(2, 4), 16);
+    const b = parseInt(clean.slice(4, 6), 16);
+    if (isNaN(r) || isNaN(g) || isNaN(b)) return null;
+    return { r, g, b };
+  }
+  return null;
+}
+function rgbToHexPicker(rgb) {
+  const toHex = (n) => Math.round(Math.max(0, Math.min(255, n))).toString(16).padStart(2, "0");
+  return `#${toHex(rgb.r)}${toHex(rgb.g)}${toHex(rgb.b)}`;
+}
+function rgbToHslPicker(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 l = (max + min) / 2;
+  if (max === min) return { h: 0, s: 0, l: Math.round(l * 100) };
+  const d = max - min;
+  const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+  let h;
+  if (max === r) h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
+  else if (max === g) h = ((b - r) / d + 2) / 6;
+  else h = ((r - g) / d + 4) / 6;
+  return {
+    h: Math.round(h * 360),
+    s: Math.round(s * 100),
+    l: Math.round(l * 100)
+  };
+}
+function hslToRgbPicker(hsl) {
+  const h = hsl.h / 360;
+  const s = hsl.s / 100;
+  const l = hsl.l / 100;
+  if (s === 0) {
+    const v = Math.round(l * 255);
+    return { r: v, g: v, b: v };
+  }
+  const hue2rgb = (p2, q2, t) => {
+    let tt = t;
+    if (tt < 0) tt += 1;
+    if (tt > 1) tt -= 1;
+    if (tt < 1 / 6) return p2 + (q2 - p2) * 6 * tt;
+    if (tt < 1 / 2) return q2;
+    if (tt < 2 / 3) return p2 + (q2 - p2) * (2 / 3 - tt) * 6;
+    return p2;
+  };
+  const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+  const p = 2 * l - q;
+  return {
+    r: Math.round(hue2rgb(p, q, h + 1 / 3) * 255),
+    g: Math.round(hue2rgb(p, q, h) * 255),
+    b: Math.round(hue2rgb(p, q, h - 1 / 3) * 255)
+  };
+}
+function rgbToHsvPicker(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 d = max - min;
+  const v = max;
+  const s = max === 0 ? 0 : d / max;
+  let h = 0;
+  if (max !== min) {
+    if (max === r) h = ((g - b) / d + (g < b ? 6 : 0)) / 6;
+    else if (max === g) h = ((b - r) / d + 2) / 6;
+    else h = ((r - g) / d + 4) / 6;
+  }
+  return {
+    h: Math.round(h * 360),
+    s: Math.round(s * 100),
+    v: Math.round(v * 100)
+  };
+}
+function hsvToRgbPicker(hsv) {
+  const h = hsv.h / 360;
+  const s = hsv.s / 100;
+  const v = hsv.v / 100;
+  if (s === 0) {
+    const val = Math.round(v * 255);
+    return { r: val, g: val, b: val };
+  }
+  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 r, g, b;
+  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;
+    default:
+      r = v;
+      g = p;
+      b = q;
+  }
+  return {
+    r: Math.round(r * 255),
+    g: Math.round(g * 255),
+    b: Math.round(b * 255)
+  };
+}
+function rgbToCmyk(rgb) {
+  const r = rgb.r / 255;
+  const g = rgb.g / 255;
+  const b = rgb.b / 255;
+  const k = 1 - Math.max(r, g, b);
+  if (k === 1) return { c: 0, m: 0, y: 0, k: 100 };
+  const c = (1 - r - k) / (1 - k);
+  const m = (1 - g - k) / (1 - k);
+  const y = (1 - b - k) / (1 - k);
+  return {
+    c: Math.round(c * 100),
+    m: Math.round(m * 100),
+    y: Math.round(y * 100),
+    k: Math.round(k * 100)
+  };
+}
+function pickerFindNearestNamedColor(rgb) {
+  let nearest;
+  let minDist = Infinity;
+  for (const [name, hex] of Object.entries(NAMED_COLORS)) {
+    if (name === "grey") continue;
+    const c = hexToRgbPicker(hex);
+    if (!c) continue;
+    const dist = Math.sqrt(
+      Math.pow(rgb.r - c.r, 2) + Math.pow(rgb.g - c.g, 2) + Math.pow(rgb.b - c.b, 2)
+    );
+    if (dist < minDist) {
+      minDist = dist;
+      nearest = name;
+    }
+  }
+  if (minDist < 30) return nearest;
+  return void 0;
+}
+function pickerBuildColorResult(rgb) {
+  const hex = rgbToHexPicker(rgb);
+  const hsl = rgbToHslPicker(rgb);
+  const hsv = rgbToHsvPicker(rgb);
+  const cmyk = rgbToCmyk(rgb);
+  const name = pickerFindNearestNamedColor(rgb);
+  return { hex, rgb, hsl, hsv, cmyk, name };
+}
+function parseColorPicker(input) {
+  const trimmed = input.trim().toLowerCase();
+  if (NAMED_COLORS[trimmed]) {
+    const rgb = hexToRgbPicker(NAMED_COLORS[trimmed]);
+    if (!rgb) return { error: `Invalid named color: ${trimmed}` };
+    return pickerBuildColorResult(rgb);
+  }
+  if (trimmed.startsWith("#")) {
+    const rgb = hexToRgbPicker(trimmed);
+    if (!rgb) return { error: `Invalid hex color: ${input}` };
+    return pickerBuildColorResult(rgb);
+  }
+  const rgbMatch = trimmed.match(/^rgb\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$/);
+  if (rgbMatch) {
+    const r = parseInt(rgbMatch[1]);
+    const g = parseInt(rgbMatch[2]);
+    const b = parseInt(rgbMatch[3]);
+    if (r > 255 || g > 255 || b > 255)
+      return { error: "RGB values must be between 0 and 255" };
+    return pickerBuildColorResult({ r, g, b });
+  }
+  const hslMatch = trimmed.match(
+    /^hsl\(\s*(\d+)\s*,\s*(\d+)%?\s*,\s*(\d+)%?\s*\)$/
+  );
+  if (hslMatch) {
+    const h = parseInt(hslMatch[1]);
+    const s = parseInt(hslMatch[2]);
+    const l = parseInt(hslMatch[3]);
+    if (h > 360 || s > 100 || l > 100)
+      return { error: "HSL values out of range" };
+    const rgb = hslToRgbPicker({ h, s, l });
+    return pickerBuildColorResult(rgb);
+  }
+  return { error: `Unable to parse color: ${input}` };
+}
+function shadesClamp(n, min, max) {
+  return Math.min(Math.max(n, min), max);
+}
+function shadesNormalizeHex(hex) {
+  let h = hex.trim().replace(/^#/, "");
+  if (h.length === 3) {
+    h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2];
+  }
+  return h;
+}
+function hexToRgbShades(hex) {
+  const h = shadesNormalizeHex(hex);
+  return {
+    r: parseInt(h.slice(0, 2), 16),
+    g: parseInt(h.slice(2, 4), 16),
+    b: parseInt(h.slice(4, 6), 16)
+  };
+}
+function rgbToHexShades(r, g, b) {
+  const toHex = (n) => Math.round(shadesClamp(n, 0, 255)).toString(16).padStart(2, "0");
+  return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+}
+function hexToHslShades(hex) {
+  const { r, g, b } = hexToRgbShades(hex);
+  const rn = r / 255;
+  const gn = g / 255;
+  const bn = b / 255;
+  const max = Math.max(rn, gn, bn);
+  const min = Math.min(rn, gn, bn);
+  const delta = max - min;
+  let h = 0;
+  let s = 0;
+  const l = (max + min) / 2;
+  if (delta !== 0) {
+    s = delta / (1 - Math.abs(2 * l - 1));
+    if (max === rn) {
+      h = (gn - bn) / delta % 6;
+    } else if (max === gn) {
+      h = (bn - rn) / delta + 2;
+    } else {
+      h = (rn - gn) / delta + 4;
+    }
+    h = h * 60;
+    if (h < 0) h += 360;
+  }
+  return {
+    h: Math.round(h),
+    s: Math.round(s * 100),
+    l: Math.round(l * 100)
+  };
+}
+function hslToHexShades(h, s, l) {
+  const sn = s / 100;
+  const ln = l / 100;
+  const c = (1 - Math.abs(2 * ln - 1)) * sn;
+  const x = c * (1 - Math.abs(h / 60 % 2 - 1));
+  const m = ln - c / 2;
+  let r = 0, g = 0, b = 0;
+  if (h < 60) {
+    r = c;
+    g = x;
+    b = 0;
+  } else if (h < 120) {
+    r = x;
+    g = c;
+    b = 0;
+  } else if (h < 180) {
+    r = 0;
+    g = c;
+    b = x;
+  } else if (h < 240) {
+    r = 0;
+    g = x;
+    b = c;
+  } else if (h < 300) {
+    r = x;
+    g = 0;
+    b = c;
+  } else {
+    r = c;
+    g = 0;
+    b = x;
+  }
+  return rgbToHexShades((r + m) * 255, (g + m) * 255, (b + m) * 255);
+}
+function generateShades(hex, steps = 5) {
+  const { h, s, l } = hexToHslShades(hex);
+  const shades = [];
+  const step = l / (steps + 1);
+  for (let i = 1; i <= steps; i++) {
+    const newL = Math.max(0, l - step * i);
+    shades.push(hslToHexShades(h, s, newL));
+  }
+  return shades;
+}
+function generateTints(hex, steps = 5) {
+  const { h, s, l } = hexToHslShades(hex);
+  const tints = [];
+  const step = (100 - l) / (steps + 1);
+  for (let i = 1; i <= steps; i++) {
+    const newL = Math.min(100, l + step * i);
+    tints.push(hslToHexShades(h, s, newL));
+  }
+  return tints;
+}
+function generateScale(hex, steps = 5) {
+  return {
+    tints: generateTints(hex, steps),
+    base: hex.startsWith("#") ? hex : `#${hex}`,
+    shades: generateShades(hex, steps)
+  };
+}
+function getContrastColor(hex) {
+  const { r, g, b } = hexToRgbShades(hex);
+  const toLinear = (c) => {
+    const sRGB = c / 255;
+    return sRGB <= 0.03928 ? sRGB / 12.92 : Math.pow((sRGB + 0.055) / 1.055, 2.4);
+  };
+  const luminance = 0.2126 * toLinear(r) + 0.7152 * toLinear(g) + 0.0722 * toLinear(b);
+  return luminance < 0.179 ? "#ffffff" : "#000000";
+}
+function colorName(hex) {
+  const { h, s, l } = hexToHslShades(hex);
+  if (l < 15) return "gray";
+  if (l > 90) return "gray";
+  if (s < 15) return "gray";
+  if (h >= 20 && h <= 40 && s < 60 && l < 40) return "brown";
+  if (h < 15 || h >= 345) return "red";
+  if (h < 25) return "orange";
+  if (h < 45) return "orange";
+  if (h < 65) return "yellow";
+  if (h < 155) return "green";
+  if (h < 185) return "cyan";
+  if (h < 200) return "teal";
+  if (h < 255) return "blue";
+  if (h < 290) return "purple";
+  if (h < 315) return "pink";
+  if (h < 345) return "pink";
+  return "red";
+}
+function hexToRgbBlend(hex) {
+  const cleaned = hex.startsWith("#") ? hex.slice(1) : hex;
+  let r, g, b;
+  if (cleaned.length === 3) {
+    r = parseInt(cleaned[0] + cleaned[0], 16);
+    g = parseInt(cleaned[1] + cleaned[1], 16);
+    b = parseInt(cleaned[2] + cleaned[2], 16);
+  } else if (cleaned.length === 6) {
+    r = parseInt(cleaned.slice(0, 2), 16);
+    g = parseInt(cleaned.slice(2, 4), 16);
+    b = parseInt(cleaned.slice(4, 6), 16);
+  } else {
+    return { error: `Invalid hex color: ${hex}` };
+  }
+  if (isNaN(r) || isNaN(g) || isNaN(b)) {
+    return { error: `Invalid hex color: ${hex}` };
+  }
+  if (!/^[0-9a-fA-F]+$/.test(cleaned)) {
+    return { error: `Invalid hex color: ${hex}` };
+  }
+  return { r, g, b };
+}
+function rgbToHexBlend(r, g, b) {
+  const clamp = (v) => Math.max(0, Math.min(255, Math.round(v)));
+  return "#" + [clamp(r), clamp(g), clamp(b)].map((v) => v.toString(16).padStart(2, "0")).join("");
+}
+function hexToHslBlend(hex) {
+  const rgb = hexToRgbBlend(hex);
+  if (typeof rgb === "object" && "error" in rgb) return 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 delta = max - min;
+  let h = 0;
+  let s = 0;
+  const l = (max + min) / 2;
+  if (delta !== 0) {
+    s = delta / (1 - Math.abs(2 * l - 1));
+    if (max === r) {
+      h = (g - b) / delta % 6;
+    } else if (max === g) {
+      h = (b - r) / delta + 2;
+    } else {
+      h = (r - g) / delta + 4;
+    }
+    h = h * 60;
+    if (h < 0) h += 360;
+  }
+  return {
+    h: Math.round(h * 100) / 100,
+    s: Math.round(s * 100 * 100) / 100,
+    l: Math.round(l * 100 * 100) / 100
+  };
+}
+function hslToHexBlend(h, s, l) {
+  const sNorm = s / 100;
+  const lNorm = l / 100;
+  const c = (1 - Math.abs(2 * lNorm - 1)) * sNorm;
+  const x = c * (1 - Math.abs(h / 60 % 2 - 1));
+  const m = lNorm - c / 2;
+  let r = 0, g = 0, b = 0;
+  if (h >= 0 && h < 60) {
+    r = c;
+    g = x;
+    b = 0;
+  } else if (h >= 60 && h < 120) {
+    r = x;
+    g = c;
+    b = 0;
+  } else if (h >= 120 && h < 180) {
+    r = 0;
+    g = c;
+    b = x;
+  } else if (h >= 180 && h < 240) {
+    r = 0;
+    g = x;
+    b = c;
+  } else if (h >= 240 && h < 300) {
+    r = x;
+    g = 0;
+    b = c;
+  } else {
+    r = c;
+    g = 0;
+    b = x;
+  }
+  return rgbToHexBlend(
+    Math.round((r + m) * 255),
+    Math.round((g + m) * 255),
+    Math.round((b + m) * 255)
+  );
+}
+function blendColors(color1, color2, steps = 5, mode = "rgb") {
+  const rgb1Result = hexToRgbBlend(color1);
+  if (typeof rgb1Result === "object" && "error" in rgb1Result) return rgb1Result;
+  const rgb2Result = hexToRgbBlend(color2);
+  if (typeof rgb2Result === "object" && "error" in rgb2Result) return rgb2Result;
+  if (steps < 1) return { error: "steps must be at least 1" };
+  if (steps === 1)
+    return [color1.toLowerCase().startsWith("#") ? color1 : "#" + color1];
+  const result = [];
+  if (mode === "rgb") {
+    const c1 = rgb1Result;
+    const c2 = rgb2Result;
+    for (let i = 0; i < steps; i++) {
+      const t = i / (steps - 1);
+      result.push(
+        rgbToHexBlend(
+          c1.r + (c2.r - c1.r) * t,
+          c1.g + (c2.g - c1.g) * t,
+          c1.b + (c2.b - c1.b) * t
+        )
+      );
+    }
+  } else {
+    const hsl1Result = hexToHslBlend(color1);
+    if (typeof hsl1Result === "object" && "error" in hsl1Result)
+      return hsl1Result;
+    const hsl2Result = hexToHslBlend(color2);
+    if (typeof hsl2Result === "object" && "error" in hsl2Result)
+      return hsl2Result;
+    const c1 = hsl1Result;
+    const c2 = hsl2Result;
+    let dh = c2.h - c1.h;
+    if (dh > 180) dh -= 360;
+    if (dh < -180) dh += 360;
+    for (let i = 0; i < steps; i++) {
+      const t = i / (steps - 1);
+      let h = c1.h + dh * t;
+      if (h < 0) h += 360;
+      if (h >= 360) h -= 360;
+      result.push(
+        hslToHexBlend(
+          h,
+          c1.s + (c2.s - c1.s) * t,
+          c1.l + (c2.l - c1.l) * t
+        )
+      );
+    }
+  }
+  return result;
+}
+function mixColors(color1, color2, ratio = 0.5) {
+  const rgb1Result = hexToRgbBlend(color1);
+  if (typeof rgb1Result === "object" && "error" in rgb1Result) return rgb1Result;
+  const rgb2Result = hexToRgbBlend(color2);
+  if (typeof rgb2Result === "object" && "error" in rgb2Result) return rgb2Result;
+  const c1 = rgb1Result;
+  const c2 = rgb2Result;
+  return rgbToHexBlend(
+    c1.r + (c2.r - c1.r) * ratio,
+    c1.g + (c2.g - c1.g) * ratio,
+    c1.b + (c2.b - c1.b) * ratio
+  );
+}
+function complementaryColor(hex) {
+  const hslResult = hexToHslBlend(hex);
+  if (typeof hslResult === "object" && "error" in hslResult) return hslResult;
+  const { h, s, l } = hslResult;
+  const newH = (h + 180) % 360;
+  return hslToHexBlend(newH, s, l);
+}
+function analogousColors(hex, angle = 30) {
+  const hslResult = hexToHslBlend(hex);
+  if (typeof hslResult === "object" && "error" in hslResult) return hslResult;
+  const { h, s, l } = hslResult;
+  const h1 = (h + angle + 360) % 360;
+  const h2 = (h - angle + 360) % 360;
+  return [hslToHexBlend(h1, s, l), hslToHexBlend(h2, s, l)];
+}
+function triadicColors(hex) {
+  const hslResult = hexToHslBlend(hex);
+  if (typeof hslResult === "object" && "error" in hslResult) return hslResult;
+  const { h, s, l } = hslResult;
+  const h1 = (h + 120) % 360;
+  const h2 = (h + 240) % 360;
+  return [hslToHexBlend(h1, s, l), hslToHexBlend(h2, s, l)];
+}
+
+exports.NAMED_COLORS = NAMED_COLORS;
+exports.PALETTE_TYPES = PALETTE_TYPES;
+exports.analogousColors = analogousColors;
+exports.blendColors = blendColors;
+exports.checkContrast = checkContrast;
+exports.colorName = colorName;
+exports.complementaryColor = complementaryColor;
+exports.generatePalette = generatePalette;
+exports.generateScale = generateScale;
+exports.generateShades = generateShades;
+exports.generateTints = generateTints;
+exports.getContrastColor = getContrastColor;
+exports.hexToHsl = hexToHsl;
+exports.hexToHslBlend = hexToHslBlend;
+exports.hexToHslShades = hexToHslShades;
+exports.hexToLinearRgb = hexToLinearRgb;
+exports.hexToRgb = hexToRgb;
+exports.hexToRgbBlend = hexToRgbBlend;
+exports.hexToRgbPicker = hexToRgbPicker;
+exports.hexToRgbShades = hexToRgbShades;
+exports.hslToHex = hslToHex;
+exports.hslToHexBlend = hslToHexBlend;
+exports.hslToHexShades = hslToHexShades;
+exports.hslToRgb = hslToRgb;
+exports.hslToRgbPicker = hslToRgbPicker;
+exports.hsvToRgb = hsvToRgb;
+exports.hsvToRgbPicker = hsvToRgbPicker;
+exports.mixColors = mixColors;
+exports.parseColor = parseColor;
+exports.parseColorPicker = parseColorPicker;
+exports.relativeLuminance = relativeLuminance;
+exports.rgbToCmyk = rgbToCmyk;
+exports.rgbToHex = rgbToHex;
+exports.rgbToHexBlend = rgbToHexBlend;
+exports.rgbToHexPicker = rgbToHexPicker;
+exports.rgbToHexShades = rgbToHexShades;
+exports.rgbToHsl = rgbToHsl;
+exports.rgbToHslPicker = rgbToHslPicker;
+exports.rgbToHsv = rgbToHsv;
+exports.rgbToHsvPicker = rgbToHsvPicker;
+exports.triadicColors = triadicColors;