@trishchuk/coolors-mcp 1.0.0

package/dist/bin/server.js

@@ -0,0 +1,3292 @@
+#!/usr/bin/env node
+import {
+  CoolorsMcp
+} from "../chunk-IQ7NN26V.js";
+import {
+  DislikeAnalyzer,
+  Hct,
+  TonalPalette,
+  adjustTemperature,
+  blend,
+  colorDistance,
+  corePaletteFromRgb,
+  getContrastRatio,
+  harmonize,
+  hexToRgb,
+  hslToRgb,
+  labToRgb,
+  parseColor,
+  rgbToArgb,
+  rgbToHct,
+  rgbToHex,
+  rgbToHsl,
+  rgbToLab
+} from "../chunk-P3ARRKLS.js";
+
+// src/tools/color-conversion.tool.ts
+import { z } from "zod";
+var colorConversionTool = {
+  description: "Convert colors between different formats (hex, rgb, hsl, lab, hct)",
+  execute: async (args) => {
+    const rgb = parseColor(args.color);
+    if (!rgb) {
+      return `Invalid color format: ${args.color}`;
+    }
+    switch (args.to) {
+      case "hct": {
+        const hct = rgbToHct(rgb);
+        return `hct(${hct.h.toFixed(1)}, ${hct.c.toFixed(1)}, ${hct.t.toFixed(1)})`;
+      }
+      case "hex":
+        return rgbToHex(rgb);
+      case "hsl": {
+        const hsl = rgbToHsl(rgb);
+        return `hsl(${Math.round(hsl.h)}, ${Math.round(hsl.s)}%, ${Math.round(hsl.l)}%)`;
+      }
+      case "lab": {
+        const lab = rgbToLab(rgb);
+        return `lab(${lab.l.toFixed(2)}, ${lab.a.toFixed(2)}, ${lab.b.toFixed(2)})`;
+      }
+      case "rgb":
+        return `rgb(${Math.round(rgb.r * 255)}, ${Math.round(rgb.g * 255)}, ${Math.round(rgb.b * 255)})`;
+      default:
+        return `Invalid format: ${args.to}`;
+    }
+  },
+  name: "convert_color",
+  parameters: z.object({
+    color: z.string().describe("Color to convert (hex, rgb(), or hsl())"),
+    to: z.enum(["hex", "rgb", "hsl", "lab", "hct"]).describe("Target format")
+  })
+};
+
+// src/tools/color-distance.tool.ts
+import { z as z2 } from "zod";
+var colorDistanceTool = {
+  description: "Calculate perceptual distance between two colors using Delta E 2000",
+  execute: async (args) => {
+    const rgb1 = parseColor(args.color1);
+    const rgb2 = parseColor(args.color2);
+    if (!rgb1 || !rgb2) {
+      return `Invalid color format: ${!rgb1 ? args.color1 : args.color2}`;
+    }
+    const distance = colorDistance(rgb1, rgb2, {
+      metric: args.metric || "deltaE2000"
+    });
+    return `Distance between ${args.color1} and ${args.color2}: ${distance.toFixed(2)}`;
+  },
+  name: "color_distance",
+  parameters: z2.object({
+    color1: z2.string().describe("First color (hex, rgb, or hsl)"),
+    color2: z2.string().describe("Second color (hex, rgb, or hsl)"),
+    metric: z2.enum(["euclidean", "deltaE76", "deltaE94", "deltaE2000", "weighted"]).optional().default("deltaE2000").describe("Distance metric to use")
+  })
+};
+
+// src/tools/colors.ts
+import { formatHex, formatHsl, formatRgb, parse } from "culori";
+import { z as z3 } from "zod";
+
+// src/constants.ts
+var ColorFormat = /* @__PURE__ */ ((ColorFormat2) => {
+  ColorFormat2["HEX"] = "hex";
+  ColorFormat2["HSL"] = "hsl";
+  ColorFormat2["RGB"] = "rgb";
+  return ColorFormat2;
+})(ColorFormat || {});
+
+// src/tools/colors.ts
+var convertColor = {
+  description: "Convert a color from one format to another",
+  execute: async (args) => {
+    const { color, to = "hex" /* HEX */ } = args;
+    const parsed = parse(color);
+    if (!parsed) {
+      throw new Error(`Invalid color: ${color}`);
+    }
+    switch (to) {
+      case "hex" /* HEX */:
+        return formatHex(parsed);
+      case "hsl" /* HSL */:
+        return formatHsl(parsed);
+      case "rgb" /* RGB */:
+        return formatRgb(parsed);
+      default:
+        throw new Error(`Invalid output format: ${to}`);
+    }
+  },
+  name: "convertColor",
+  parameters: z3.object({
+    color: z3.string().describe("The color to convert"),
+    to: z3.nativeEnum(ColorFormat).optional().describe("The output format")
+  })
+};
+
+// src/tools/contrast-checker.tool.ts
+import { z as z4 } from "zod";
+var contrastCheckerTool = {
+  description: "Check WCAG contrast ratio between two colors",
+  execute: async (args) => {
+    const fg = parseColor(args.foreground);
+    const bg = parseColor(args.background);
+    if (!fg || !bg) {
+      return `Invalid color format: ${!fg ? args.foreground : args.background}`;
+    }
+    const ratio = getContrastRatio(fg, bg);
+    const aa = ratio >= 4.5;
+    const aaLarge = ratio >= 3;
+    const aaa = ratio >= 7;
+    const aaaLarge = ratio >= 4.5;
+    return `Contrast Ratio: ${ratio.toFixed(2)}:1
+WCAG AA: ${aa ? "\u2713 Pass" : "\u2717 Fail"} (normal text)
+WCAG AA: ${aaLarge ? "\u2713 Pass" : "\u2717 Fail"} (large text)
+WCAG AAA: ${aaa ? "\u2713 Pass" : "\u2717 Fail"} (normal text)
+WCAG AAA: ${aaaLarge ? "\u2713 Pass" : "\u2717 Fail"} (large text)`;
+  },
+  name: "check_contrast",
+  parameters: z4.object({
+    background: z4.string().describe("Background color"),
+    foreground: z4.string().describe("Foreground/text color")
+  })
+};
+
+// src/tools/dislike-analyzer.tool.ts
+var analyzeColorLikabilityTool = {
+  description: "Check if a color is universally disliked (dark yellow-green associated with biological waste) and get a fixed version if needed",
+  execute: async (args, _context) => {
+    const { autoFix = true, color } = args;
+    try {
+      const rgb = parseColor(color);
+      if (!rgb) {
+        return `Error: Invalid color format: ${color}`;
+      }
+      const argb = rgbToArgb(rgb);
+      const hct = Hct.fromInt(argb);
+      const isDisliked = DislikeAnalyzer.isDisliked(hct);
+      let output = `# Color Likability Analysis
+
+`;
+      output += `## Input Color: ${color}
+
+`;
+      output += `### HCT Values
+`;
+      output += `- Hue: ${hct.hue.toFixed(1)}\xB0
+`;
+      output += `- Chroma: ${hct.chroma.toFixed(1)}
+`;
+      output += `- Tone: ${hct.tone.toFixed(1)}
+
+`;
+      output += `### Analysis Result
+`;
+      if (isDisliked) {
+        output += `\u26A0\uFE0F **This color is universally disliked**
+
+`;
+        output += `This color falls in the "bile zone" - dark yellow-greens that are universally associated with biological waste and rotting food.
+
+`;
+        output += `**Reason:**
+`;
+        output += `- Hue is in yellow-green range (90-111\xB0): ${Math.round(hct.hue)}\xB0
+`;
+        output += `- Chroma is above threshold (>16): ${Math.round(hct.chroma)}
+`;
+        output += `- Tone is dark (<65): ${Math.round(hct.tone)}
+
+`;
+        if (autoFix) {
+          const fixed = DislikeAnalyzer.fixIfDisliked(hct);
+          const fixedArgb = fixed.toInt();
+          const fixedHex = "#" + [
+            fixedArgb >> 16 & 255,
+            fixedArgb >> 8 & 255,
+            fixedArgb & 255
+          ].map((x) => x.toString(16).padStart(2, "0")).join("");
+          output += `### Recommended Fix
+`;
+          output += `**Fixed Color:** ${fixedHex}
+`;
+          output += `- Hue: ${fixed.hue.toFixed(1)}\xB0 (preserved)
+`;
+          output += `- Chroma: ${fixed.chroma.toFixed(1)} (preserved)
+`;
+          output += `- Tone: ${fixed.tone.toFixed(1)} (lightened to 70)
+
+`;
+          output += `The fix preserves the hue and saturation but lightens the color to make it more pleasant.
+`;
+        }
+      } else {
+        output += `\u2705 **This color is likable**
+
+`;
+        output += `This color does not fall in the universally disliked range.
+`;
+        if (Math.round(hct.hue) >= 90 && Math.round(hct.hue) <= 111) {
+          if (Math.round(hct.chroma) <= 16) {
+            output += `- Although in yellow-green hue range, the low chroma (${Math.round(hct.chroma)}) makes it neutral and acceptable.
+`;
+          } else if (Math.round(hct.tone) >= 65) {
+            output += `- Although in yellow-green hue range, the light tone (${Math.round(hct.tone)}) makes it pleasant.
+`;
+          }
+        } else {
+          output += `- Hue (${Math.round(hct.hue)}\xB0) is outside the problematic yellow-green range.
+`;
+        }
+      }
+      return output;
+    } catch (error) {
+      return `Error analyzing color: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  },
+  inputSchema: {
+    properties: {
+      autoFix: {
+        description: "Automatically return fixed version if disliked (default: true)",
+        type: "boolean"
+      },
+      color: {
+        description: "Color to analyze (hex, rgb, hsl, etc.)",
+        type: "string"
+      }
+    },
+    required: ["color"],
+    type: "object"
+  },
+  name: "analyze_color_likability"
+};
+var fixDislikedColorsBatchTool = {
+  description: "Analyze and fix multiple colors, returning only liked versions",
+  execute: async (args, _context) => {
+    const { colors, includeAnalysis = false } = args;
+    try {
+      const results = [];
+      let dislikedCount = 0;
+      for (const color of colors) {
+        const rgb = parseColor(color);
+        if (!rgb) {
+          results.push({
+            error: "Invalid color format",
+            original: color
+          });
+          continue;
+        }
+        const argb = rgbToArgb(rgb);
+        const hct = Hct.fromInt(argb);
+        const isDisliked = DislikeAnalyzer.isDisliked(hct);
+        if (isDisliked) {
+          dislikedCount++;
+          const fixed = DislikeAnalyzer.fixIfDisliked(hct);
+          const fixedArgb = fixed.toInt();
+          const fixedHex = "#" + [
+            fixedArgb >> 16 & 255,
+            fixedArgb >> 8 & 255,
+            fixedArgb & 255
+          ].map((x) => x.toString(16).padStart(2, "0")).join("");
+          results.push({
+            fixed: fixedHex,
+            hct: includeAnalysis ? {
+              fixed: { c: fixed.chroma, h: fixed.hue, t: fixed.tone },
+              original: { c: hct.chroma, h: hct.hue, t: hct.tone }
+            } : void 0,
+            original: color,
+            wasDisliked: true
+          });
+        } else {
+          results.push({
+            fixed: color,
+            hct: includeAnalysis ? {
+              c: hct.chroma,
+              h: hct.hue,
+              t: hct.tone
+            } : void 0,
+            original: color,
+            wasDisliked: false
+          });
+        }
+      }
+      let output = `# Batch Color Likability Analysis
+
+`;
+      output += `## Summary
+`;
+      output += `- Total colors: ${colors.length}
+`;
+      output += `- Disliked colors found: ${dislikedCount}
+`;
+      output += `- Percentage disliked: ${(dislikedCount / colors.length * 100).toFixed(1)}%
+
+`;
+      output += `## Results
+
+`;
+      for (const result of results) {
+        if (result.error) {
+          output += `- **${result.original}**: \u274C ${result.error}
+`;
+        } else if (result.wasDisliked) {
+          output += `- **${result.original}** \u2192 **${result.fixed}** (fixed)
+`;
+          if (includeAnalysis && result.hct) {
+            output += `  - Original HCT: (${result.hct.original.h.toFixed(0)}\xB0, ${result.hct.original.c.toFixed(0)}, ${result.hct.original.t.toFixed(0)})
+`;
+            output += `  - Fixed HCT: (${result.hct.fixed.h.toFixed(0)}\xB0, ${result.hct.fixed.c.toFixed(0)}, ${result.hct.fixed.t.toFixed(0)})
+`;
+          }
+        } else {
+          output += `- **${result.original}** \u2713 (already liked)
+`;
+          if (includeAnalysis && result.hct) {
+            output += `  - HCT: (${result.hct.h.toFixed(0)}\xB0, ${result.hct.c.toFixed(0)}, ${result.hct.t.toFixed(0)})
+`;
+          }
+        }
+      }
+      if (dislikedCount > 0) {
+        output += `
+## Note
+`;
+        output += `Disliked colors have been automatically fixed by lightening their tone to 70 while preserving hue and chroma. `;
+        output += `This makes them more pleasant while maintaining their essential character.
+`;
+      }
+      return output;
+    } catch (error) {
+      return `Error processing colors: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  },
+  inputSchema: {
+    properties: {
+      colors: {
+        description: "Array of colors to analyze (hex, rgb, hsl, etc.)",
+        items: {
+          type: "string"
+        },
+        type: "array"
+      },
+      includeAnalysis: {
+        description: "Include detailed analysis for each color (default: false)",
+        type: "boolean"
+      }
+    },
+    required: ["colors"],
+    type: "object"
+  },
+  name: "fix_disliked_colors_batch"
+};
+
+// src/tools/gradient-generator.tool.ts
+import { z as z5 } from "zod";
+var gradientGeneratorTool = {
+  description: "Generate a smooth gradient between colors with multiple interpolation methods",
+  execute: async (args) => {
+    const {
+      colors,
+      easing = "linear",
+      format = "array",
+      interpolation = "lab",
+      steps
+    } = args;
+    if (colors.length < 2) {
+      return "Error: At least 2 colors are required for a gradient";
+    }
+    const parsedColors = [];
+    for (const color of colors) {
+      const parsed = parseColor(color);
+      if (!parsed) {
+        return `Invalid color format: ${color}`;
+      }
+      parsedColors.push(parsed);
+    }
+    const applyEasing = (t) => {
+      switch (easing) {
+        case "ease-in":
+          return t * t;
+        case "ease-in-out":
+          return t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t;
+        case "ease-out":
+          return t * (2 - t);
+        default:
+          return t;
+      }
+    };
+    const gradient = [];
+    const segmentSteps = Math.floor(steps / (colors.length - 1));
+    const extraSteps = steps % (colors.length - 1);
+    for (let segment = 0; segment < colors.length - 1; segment++) {
+      const start = parsedColors[segment];
+      const end = parsedColors[segment + 1];
+      const currentSteps = segmentSteps + (segment < extraSteps ? 1 : 0);
+      for (let step = 0; step < currentSteps; step++) {
+        const t = applyEasing(step / currentSteps);
+        let interpolatedColor;
+        switch (interpolation) {
+          case "hct": {
+            const startHct = Hct.fromInt(
+              255 << 24 | start.r << 16 | start.g << 8 | start.b
+            );
+            const endHct = Hct.fromInt(
+              255 << 24 | end.r << 16 | end.g << 8 | end.b
+            );
+            let hueDiff = endHct.hue - startHct.hue;
+            if (hueDiff > 180) hueDiff -= 360;
+            if (hueDiff < -180) hueDiff += 360;
+            const interpolatedHct = Hct.from(
+              (startHct.hue + hueDiff * t + 360) % 360,
+              startHct.chroma + (endHct.chroma - startHct.chroma) * t,
+              startHct.tone + (endHct.tone - startHct.tone) * t
+            );
+            const argb = interpolatedHct.toInt();
+            interpolatedColor = {
+              b: argb & 255,
+              g: argb >> 8 & 255,
+              r: argb >> 16 & 255
+            };
+            break;
+          }
+          case "hsl": {
+            const startHsl = rgbToHsl(start);
+            const endHsl = rgbToHsl(end);
+            let hueDiff = endHsl.h - startHsl.h;
+            if (hueDiff > 180) hueDiff -= 360;
+            if (hueDiff < -180) hueDiff += 360;
+            interpolatedColor = hslToRgb({
+              h: (startHsl.h + hueDiff * t + 360) % 360,
+              l: startHsl.l + (endHsl.l - startHsl.l) * t,
+              s: startHsl.s + (endHsl.s - startHsl.s) * t
+            });
+            break;
+          }
+          case "lab": {
+            const startLab = rgbToLab(start);
+            const endLab = rgbToLab(end);
+            interpolatedColor = labToRgb({
+              a: startLab.a + (endLab.a - startLab.a) * t,
+              b: startLab.b + (endLab.b - startLab.b) * t,
+              l: startLab.l + (endLab.l - startLab.l) * t
+            });
+            break;
+          }
+          case "lch": {
+            const startLab = rgbToLab(start);
+            const endLab = rgbToLab(end);
+            const startL = startLab.l;
+            const startC = Math.sqrt(
+              startLab.a * startLab.a + startLab.b * startLab.b
+            );
+            const startH = Math.atan2(startLab.b, startLab.a) * 180 / Math.PI;
+            const endL = endLab.l;
+            const endC = Math.sqrt(endLab.a * endLab.a + endLab.b * endLab.b);
+            const endH = Math.atan2(endLab.b, endLab.a) * 180 / Math.PI;
+            let hueDiff = endH - startH;
+            if (hueDiff > 180) hueDiff -= 360;
+            if (hueDiff < -180) hueDiff += 360;
+            const l = startL + (endL - startL) * t;
+            const c = startC + (endC - startC) * t;
+            const h = (startH + hueDiff * t) * Math.PI / 180;
+            interpolatedColor = labToRgb({
+              a: c * Math.cos(h),
+              b: c * Math.sin(h),
+              l
+            });
+            break;
+          }
+          case "rgb": {
+            interpolatedColor = {
+              b: Math.round(start.b + (end.b - start.b) * t),
+              g: Math.round(start.g + (end.g - start.g) * t),
+              r: Math.round(start.r + (end.r - start.r) * t)
+            };
+            break;
+          }
+          default:
+            interpolatedColor = start;
+        }
+        gradient.push(interpolatedColor);
+      }
+    }
+    gradient.push(parsedColors[parsedColors.length - 1]);
+    const hexColors = gradient.map(rgbToHex);
+    switch (format) {
+      case "css-linear": {
+        const stops = hexColors.map((color, i) => {
+          const percent = i / (hexColors.length - 1) * 100;
+          return `${color} ${percent.toFixed(1)}%`;
+        });
+        return `linear-gradient(90deg, ${stops.join(", ")})`;
+      }
+      case "css-radial": {
+        const stops = hexColors.map((color, i) => {
+          const percent = i / (hexColors.length - 1) * 100;
+          return `${color} ${percent.toFixed(1)}%`;
+        });
+        return `radial-gradient(circle, ${stops.join(", ")})`;
+      }
+      case "hex":
+        return hexColors.join(", ");
+      case "array":
+      default:
+        return `Generated gradient with ${steps} steps:
+${hexColors.map((color, i) => `${i + 1}. ${color}`).join("\n")}
+
+Interpolation: ${interpolation}
+Easing: ${easing}
+Input colors: ${colors.join(" \u2192 ")}`;
+    }
+  },
+  name: "generate_gradient",
+  parameters: z5.object({
+    colors: z5.array(z5.string()).min(2).describe("Colors to create gradient between (minimum 2)"),
+    easing: z5.enum(["linear", "ease-in", "ease-out", "ease-in-out"]).default("linear").describe("Easing function for gradient transition"),
+    format: z5.enum(["hex", "css-linear", "css-radial", "array"]).default("array").describe("Output format for the gradient"),
+    interpolation: z5.enum(["rgb", "hsl", "lab", "lch", "hct"]).default("lab").describe(
+      "Color space for interpolation (lab/lch/hct are perceptually smooth)"
+    ),
+    steps: z5.number().min(3).max(100).describe("Number of colors in the gradient")
+  })
+};
+
+// src/color/utils/math_utils.ts
+function clampInt(min, max, input) {
+  if (input < min) {
+    return min;
+  } else if (input > max) {
+    return max;
+  }
+  return input;
+}
+function differenceDegrees(a, b) {
+  return 180 - Math.abs(Math.abs(a - b) - 180);
+}
+function sanitizeDegreesInt(degrees) {
+  degrees = degrees % 360;
+  if (degrees < 0) {
+    degrees = degrees + 360;
+  }
+  return degrees;
+}
+
+// src/color/utils/color_utils.ts
+var SRGB_TO_XYZ = [
+  [0.41233895, 0.35762064, 0.18051042],
+  [0.2126, 0.7152, 0.0722],
+  [0.01932141, 0.11916382, 0.95034478]
+];
+var XYZ_TO_SRGB = [
+  [3.2413774792388685, -1.5376652402851851, -0.49885366846268053],
+  [-0.9691452513005321, 1.8758853451067872, 0.04156585616912061],
+  [0.05562093689691305, -0.20395524564742123, 1.0571799111220335]
+];
+var WHITE_POINT_D65 = [95.047, 100, 108.883];
+function alphaFromArgb(argb) {
+  return argb >> 24 & 255;
+}
+function argbFromLab(l, a, b) {
+  const whitePoint = WHITE_POINT_D65;
+  const fy = (l + 16) / 116;
+  const fx = a / 500 + fy;
+  const fz = fy - b / 200;
+  const xNormalized = labInvf(fx);
+  const yNormalized = labInvf(fy);
+  const zNormalized = labInvf(fz);
+  const x = xNormalized * whitePoint[0];
+  const y = yNormalized * whitePoint[1];
+  const z10 = zNormalized * whitePoint[2];
+  return argbFromXyz(x, y, z10);
+}
+function argbFromRgb(red, green, blue) {
+  return (255 << 24 | (red & 255) << 16 | (green & 255) << 8 | blue & 255) >>> 0;
+}
+function argbFromXyz(x, y, z10) {
+  const matrix = XYZ_TO_SRGB;
+  const linearR = matrix[0][0] * x + matrix[0][1] * y + matrix[0][2] * z10;
+  const linearG = matrix[1][0] * x + matrix[1][1] * y + matrix[1][2] * z10;
+  const linearB = matrix[2][0] * x + matrix[2][1] * y + matrix[2][2] * z10;
+  const r = delinearized(linearR);
+  const g = delinearized(linearG);
+  const b = delinearized(linearB);
+  return argbFromRgb(r, g, b);
+}
+function blueFromArgb(argb) {
+  return argb & 255;
+}
+function delinearized(rgbComponent) {
+  const normalized = rgbComponent / 100;
+  let delinearized2 = 0;
+  if (normalized <= 31308e-7) {
+    delinearized2 = normalized * 12.92;
+  } else {
+    delinearized2 = 1.055 * Math.pow(normalized, 1 / 2.4) - 0.055;
+  }
+  return clampInt(0, 255, Math.round(delinearized2 * 255));
+}
+function greenFromArgb(argb) {
+  return argb >> 8 & 255;
+}
+function labFromArgb(argb) {
+  const linearR = linearized(redFromArgb(argb));
+  const linearG = linearized(greenFromArgb(argb));
+  const linearB = linearized(blueFromArgb(argb));
+  const matrix = SRGB_TO_XYZ;
+  const x = matrix[0][0] * linearR + matrix[0][1] * linearG + matrix[0][2] * linearB;
+  const y = matrix[1][0] * linearR + matrix[1][1] * linearG + matrix[1][2] * linearB;
+  const z10 = matrix[2][0] * linearR + matrix[2][1] * linearG + matrix[2][2] * linearB;
+  const whitePoint = WHITE_POINT_D65;
+  const xNormalized = x / whitePoint[0];
+  const yNormalized = y / whitePoint[1];
+  const zNormalized = z10 / whitePoint[2];
+  const fx = labF(xNormalized);
+  const fy = labF(yNormalized);
+  const fz = labF(zNormalized);
+  const l = 116 * fy - 16;
+  const a = 500 * (fx - fy);
+  const b = 200 * (fy - fz);
+  return [l, a, b];
+}
+function linearized(rgbComponent) {
+  const normalized = rgbComponent / 255;
+  if (normalized <= 0.040449936) {
+    return normalized / 12.92 * 100;
+  } else {
+    return Math.pow((normalized + 0.055) / 1.055, 2.4) * 100;
+  }
+}
+function redFromArgb(argb) {
+  return argb >> 16 & 255;
+}
+function labF(t) {
+  const e = 216 / 24389;
+  const kappa = 24389 / 27;
+  if (t > e) {
+    return Math.pow(t, 1 / 3);
+  } else {
+    return (kappa * t + 16) / 116;
+  }
+}
+function labInvf(ft) {
+  const e = 216 / 24389;
+  const kappa = 24389 / 27;
+  const ft3 = ft * ft * ft;
+  if (ft3 > e) {
+    return ft3;
+  } else {
+    return (116 * ft - 16) / kappa;
+  }
+}
+
+// src/color/image-utils.ts
+function filterExtremeTones(pixels) {
+  return pixels.filter((pixel) => {
+    const r = redFromArgb(pixel);
+    const g = greenFromArgb(pixel);
+    const b = blueFromArgb(pixel);
+    const luminance = 0.299 * r + 0.587 * g + 0.114 * b;
+    return luminance > 12.75 && luminance < 242.25;
+  });
+}
+function imageDataToPixels(imageData) {
+  const pixels = [];
+  const data = imageData.data;
+  for (let i = 0; i < data.length; i += 4) {
+    const r = data[i];
+    const g = data[i + 1];
+    const b = data[i + 2];
+    const a = data[i + 3];
+    if (a < 255 * 0.01) continue;
+    const argb = argbFromRgb(r, g, b);
+    pixels.push(argb);
+  }
+  return pixels;
+}
+function samplePixels(pixels, maxPixels = 1e4) {
+  if (pixels.length <= maxPixels) {
+    return pixels;
+  }
+  const sampled = [];
+  const step = Math.ceil(pixels.length / maxPixels);
+  for (let i = 0; i < pixels.length; i += step) {
+    sampled.push(pixels[i]);
+  }
+  return sampled;
+}
+
+// src/color/quantize/lab_point_provider.ts
+var LabPointProvider = class {
+  /**
+   * Standard CIE 1976 delta E formula also takes the square root, unneeded
+   * here. This method is used by quantization algorithms to compare distance,
+   * and the relative ordering is the same, with or without a square root.
+   *
+   * This relatively minor optimization is helpful because this method is
+   * called at least once for each pixel in an image.
+   */
+  distance(from, to) {
+    const dL = from[0] - to[0];
+    const dA = from[1] - to[1];
+    const dB = from[2] - to[2];
+    return dL * dL + dA * dA + dB * dB;
+  }
+  /**
+   * Convert a color represented in ARGB to a 3-element array of L*a*b*
+   * coordinates of the color.
+   */
+  fromInt(argb) {
+    return labFromArgb(argb);
+  }
+  /**
+   * Convert a 3-element array to a color represented in ARGB.
+   */
+  toInt(point) {
+    return argbFromLab(point[0], point[1], point[2]);
+  }
+};
+
+// src/color/quantize/quantizer_wsmeans.ts
+var MAX_ITERATIONS = 10;
+var MIN_MOVEMENT_DISTANCE = 3;
+var DistanceAndIndex = class {
+  distance = -1;
+  index = -1;
+};
+var QuantizerWsmeans = class {
+  /**
+   * @param inputPixels Colors in ARGB format.
+   * @param startingClusters Defines the initial state of the quantizer. Passing
+   *     an empty array is fine, the implementation will create its own initial
+   *     state that leads to reproducible results for the same inputs.
+   *     Passing an array that is the result of Wu quantization leads to higher
+   *     quality results.
+   * @param maxColors The number of colors to divide the image into. A lower
+   *     number of colors may be returned.
+   * @return Colors in ARGB format.
+   */
+  static quantize(inputPixels, startingClusters, maxColors) {
+    const pixelToCount = /* @__PURE__ */ new Map();
+    const points = new Array();
+    const pixels = new Array();
+    const pointProvider = new LabPointProvider();
+    let pointCount = 0;
+    for (let i = 0; i < inputPixels.length; i++) {
+      const inputPixel = inputPixels[i];
+      const pixelCount = pixelToCount.get(inputPixel);
+      if (pixelCount === void 0) {
+        pointCount++;
+        points.push(pointProvider.fromInt(inputPixel));
+        pixels.push(inputPixel);
+        pixelToCount.set(inputPixel, 1);
+      } else {
+        pixelToCount.set(inputPixel, pixelCount + 1);
+      }
+    }
+    const counts = new Array();
+    for (let i = 0; i < pointCount; i++) {
+      const pixel = pixels[i];
+      const count = pixelToCount.get(pixel);
+      if (count !== void 0) {
+        counts[i] = count;
+      }
+    }
+    let clusterCount = Math.min(maxColors, pointCount);
+    if (startingClusters.length > 0) {
+      clusterCount = Math.min(clusterCount, startingClusters.length);
+    }
+    const clusters = new Array();
+    for (let i = 0; i < startingClusters.length; i++) {
+      clusters.push(pointProvider.fromInt(startingClusters[i]));
+    }
+    const additionalClustersNeeded = clusterCount - clusters.length;
+    if (startingClusters.length === 0 && additionalClustersNeeded > 0) {
+      for (let i = 0; i < additionalClustersNeeded; i++) {
+        const l = Math.random() * 100;
+        const a = Math.random() * (100 - -100 + 1) + -100;
+        const b = Math.random() * (100 - -100 + 1) + -100;
+        clusters.push([l, a, b]);
+      }
+    }
+    const clusterIndices = new Array();
+    for (let i = 0; i < pointCount; i++) {
+      clusterIndices.push(Math.floor(Math.random() * clusterCount));
+    }
+    const indexMatrix = new Array();
+    for (let i = 0; i < clusterCount; i++) {
+      indexMatrix.push(new Array());
+      for (let j = 0; j < clusterCount; j++) {
+        indexMatrix[i].push(0);
+      }
+    }
+    const distanceToIndexMatrix = new Array();
+    for (let i = 0; i < clusterCount; i++) {
+      distanceToIndexMatrix.push(new Array());
+      for (let j = 0; j < clusterCount; j++) {
+        distanceToIndexMatrix[i].push(new DistanceAndIndex());
+      }
+    }
+    const pixelCountSums = new Array();
+    for (let i = 0; i < clusterCount; i++) {
+      pixelCountSums.push(0);
+    }
+    for (let iteration = 0; iteration < MAX_ITERATIONS; iteration++) {
+      for (let i = 0; i < clusterCount; i++) {
+        for (let j = i + 1; j < clusterCount; j++) {
+          const distance = pointProvider.distance(clusters[i], clusters[j]);
+          distanceToIndexMatrix[j][i].distance = distance;
+          distanceToIndexMatrix[j][i].index = i;
+          distanceToIndexMatrix[i][j].distance = distance;
+          distanceToIndexMatrix[i][j].index = j;
+        }
+        distanceToIndexMatrix[i].sort();
+        for (let j = 0; j < clusterCount; j++) {
+          indexMatrix[i][j] = distanceToIndexMatrix[i][j].index;
+        }
+      }
+      let pointsMoved = 0;
+      for (let i = 0; i < pointCount; i++) {
+        const point = points[i];
+        const previousClusterIndex = clusterIndices[i];
+        const previousCluster = clusters[previousClusterIndex];
+        const previousDistance = pointProvider.distance(point, previousCluster);
+        let minimumDistance = previousDistance;
+        let newClusterIndex = -1;
+        for (let j = 0; j < clusterCount; j++) {
+          if (distanceToIndexMatrix[previousClusterIndex][j].distance >= 4 * previousDistance) {
+            continue;
+          }
+          const distance = pointProvider.distance(point, clusters[j]);
+          if (distance < minimumDistance) {
+            minimumDistance = distance;
+            newClusterIndex = j;
+          }
+        }
+        if (newClusterIndex !== -1) {
+          const distanceChange = Math.abs(
+            Math.sqrt(minimumDistance) - Math.sqrt(previousDistance)
+          );
+          if (distanceChange > MIN_MOVEMENT_DISTANCE) {
+            pointsMoved++;
+            clusterIndices[i] = newClusterIndex;
+          }
+        }
+      }
+      if (pointsMoved === 0 && iteration !== 0) {
+        break;
+      }
+      const componentASums = new Array(clusterCount).fill(0);
+      const componentBSums = new Array(clusterCount).fill(0);
+      const componentCSums = new Array(clusterCount).fill(0);
+      for (let i = 0; i < clusterCount; i++) {
+        pixelCountSums[i] = 0;
+      }
+      for (let i = 0; i < pointCount; i++) {
+        const clusterIndex = clusterIndices[i];
+        const point = points[i];
+        const count = counts[i];
+        pixelCountSums[clusterIndex] += count;
+        componentASums[clusterIndex] += point[0] * count;
+        componentBSums[clusterIndex] += point[1] * count;
+        componentCSums[clusterIndex] += point[2] * count;
+      }
+      for (let i = 0; i < clusterCount; i++) {
+        const count = pixelCountSums[i];
+        if (count === 0) {
+          clusters[i] = [0, 0, 0];
+          continue;
+        }
+        const a = componentASums[i] / count;
+        const b = componentBSums[i] / count;
+        const c = componentCSums[i] / count;
+        clusters[i] = [a, b, c];
+      }
+    }
+    const argbToPopulation = /* @__PURE__ */ new Map();
+    for (let i = 0; i < clusterCount; i++) {
+      const count = pixelCountSums[i];
+      if (count === 0) {
+        continue;
+      }
+      const possibleNewCluster = pointProvider.toInt(clusters[i]);
+      const existingCount = argbToPopulation.get(possibleNewCluster) || 0;
+      argbToPopulation.set(possibleNewCluster, existingCount + count);
+    }
+    return argbToPopulation;
+  }
+};
+
+// src/color/quantize/quantizer_map.ts
+var QuantizerMap = class {
+  /**
+   * @param pixels Colors in ARGB format.
+   * @return A Map with keys of ARGB colors, and values of the number of times
+   *     the color appears in the image.
+   */
+  static quantize(pixels) {
+    const countByColor = /* @__PURE__ */ new Map();
+    for (let i = 0; i < pixels.length; i++) {
+      const pixel = pixels[i];
+      const alpha = alphaFromArgb(pixel);
+      if (alpha < 255) {
+        continue;
+      }
+      countByColor.set(pixel, (countByColor.get(pixel) ?? 0) + 1);
+    }
+    return countByColor;
+  }
+};
+
+// src/color/quantize/quantizer_wu.ts
+var INDEX_BITS = 5;
+var SIDE_LENGTH = 33;
+var TOTAL_SIZE = 35937;
+var directions = {
+  BLUE: "blue",
+  GREEN: "green",
+  RED: "red"
+};
+var Box = class {
+  constructor(r0 = 0, r1 = 0, g0 = 0, g1 = 0, b0 = 0, b1 = 0, vol = 0) {
+    this.r0 = r0;
+    this.r1 = r1;
+    this.g0 = g0;
+    this.g1 = g1;
+    this.b0 = b0;
+    this.b1 = b1;
+    this.vol = vol;
+  }
+};
+var CreateBoxesResult = class {
+  /**
+   * @param requestedCount how many colors the caller asked to be returned from
+   *     quantization.
+   * @param resultCount the actual number of colors achieved from quantization.
+   *     May be lower than the requested count.
+   */
+  constructor(requestedCount, resultCount) {
+    this.requestedCount = requestedCount;
+    this.resultCount = resultCount;
+  }
+};
+var MaximizeResult = class {
+  constructor(cutLocation, maximum) {
+    this.cutLocation = cutLocation;
+    this.maximum = maximum;
+  }
+};
+var QuantizerWu = class {
+  constructor(weights = [], momentsR = [], momentsG = [], momentsB = [], moments = [], cubes = []) {
+    this.weights = weights;
+    this.momentsR = momentsR;
+    this.momentsG = momentsG;
+    this.momentsB = momentsB;
+    this.moments = moments;
+    this.cubes = cubes;
+  }
+  /**
+   * @param pixels Colors in ARGB format.
+   * @param maxColors The number of colors to divide the image into. A lower
+   *     number of colors may be returned.
+   * @return Colors in ARGB format.
+   */
+  quantize(pixels, maxColors) {
+    this.constructHistogram(pixels);
+    this.computeMoments();
+    const createBoxesResult = this.createBoxes(maxColors);
+    const results = this.createResult(createBoxesResult.resultCount);
+    return results;
+  }
+  bottom(cube, direction, moment) {
+    switch (direction) {
+      case directions.BLUE:
+        return -moment[this.getIndex(cube.r1, cube.g1, cube.b0)] + moment[this.getIndex(cube.r1, cube.g0, cube.b0)] + moment[this.getIndex(cube.r0, cube.g1, cube.b0)] - moment[this.getIndex(cube.r0, cube.g0, cube.b0)];
+      case directions.GREEN:
+        return -moment[this.getIndex(cube.r1, cube.g0, cube.b1)] + moment[this.getIndex(cube.r1, cube.g0, cube.b0)] + moment[this.getIndex(cube.r0, cube.g0, cube.b1)] - moment[this.getIndex(cube.r0, cube.g0, cube.b0)];
+      case directions.RED:
+        return -moment[this.getIndex(cube.r0, cube.g1, cube.b1)] + moment[this.getIndex(cube.r0, cube.g1, cube.b0)] + moment[this.getIndex(cube.r0, cube.g0, cube.b1)] - moment[this.getIndex(cube.r0, cube.g0, cube.b0)];
+      default:
+        throw new Error("unexpected direction $direction");
+    }
+  }
+  computeMoments() {
+    for (let r = 1; r < SIDE_LENGTH; r++) {
+      const area = Array.from({ length: SIDE_LENGTH }).fill(0);
+      const areaR = Array.from({ length: SIDE_LENGTH }).fill(0);
+      const areaG = Array.from({ length: SIDE_LENGTH }).fill(0);
+      const areaB = Array.from({ length: SIDE_LENGTH }).fill(0);
+      const area2 = Array.from({ length: SIDE_LENGTH }).fill(0);
+      for (let g = 1; g < SIDE_LENGTH; g++) {
+        let line = 0;
+        let lineR = 0;
+        let lineG = 0;
+        let lineB = 0;
+        let line2 = 0;
+        for (let b = 1; b < SIDE_LENGTH; b++) {
+          const index = this.getIndex(r, g, b);
+          line += this.weights[index];
+          lineR += this.momentsR[index];
+          lineG += this.momentsG[index];
+          lineB += this.momentsB[index];
+          line2 += this.moments[index];
+          area[b] += line;
+          areaR[b] += lineR;
+          areaG[b] += lineG;
+          areaB[b] += lineB;
+          area2[b] += line2;
+          const previousIndex = this.getIndex(r - 1, g, b);
+          this.weights[index] = this.weights[previousIndex] + area[b];
+          this.momentsR[index] = this.momentsR[previousIndex] + areaR[b];
+          this.momentsG[index] = this.momentsG[previousIndex] + areaG[b];
+          this.momentsB[index] = this.momentsB[previousIndex] + areaB[b];
+          this.moments[index] = this.moments[previousIndex] + area2[b];
+        }
+      }
+    }
+  }
+  constructHistogram(pixels) {
+    this.weights = Array.from({ length: TOTAL_SIZE }).fill(0);
+    this.momentsR = Array.from({ length: TOTAL_SIZE }).fill(0);
+    this.momentsG = Array.from({ length: TOTAL_SIZE }).fill(0);
+    this.momentsB = Array.from({ length: TOTAL_SIZE }).fill(0);
+    this.moments = Array.from({ length: TOTAL_SIZE }).fill(0);
+    const countByColor = QuantizerMap.quantize(pixels);
+    for (const [pixel, count] of countByColor.entries()) {
+      const red = redFromArgb(pixel);
+      const green = greenFromArgb(pixel);
+      const blue = blueFromArgb(pixel);
+      const bitsToRemove = 8 - INDEX_BITS;
+      const iR = (red >> bitsToRemove) + 1;
+      const iG = (green >> bitsToRemove) + 1;
+      const iB = (blue >> bitsToRemove) + 1;
+      const index = this.getIndex(iR, iG, iB);
+      this.weights[index] = (this.weights[index] ?? 0) + count;
+      this.momentsR[index] += count * red;
+      this.momentsG[index] += count * green;
+      this.momentsB[index] += count * blue;
+      this.moments[index] += count * (red * red + green * green + blue * blue);
+    }
+  }
+  createBoxes(maxColors) {
+    this.cubes = Array.from({ length: maxColors }).fill(0).map(() => new Box());
+    const volumeVariance = Array.from({ length: maxColors }).fill(0);
+    this.cubes[0].r0 = 0;
+    this.cubes[0].g0 = 0;
+    this.cubes[0].b0 = 0;
+    this.cubes[0].r1 = SIDE_LENGTH - 1;
+    this.cubes[0].g1 = SIDE_LENGTH - 1;
+    this.cubes[0].b1 = SIDE_LENGTH - 1;
+    let generatedColorCount = maxColors;
+    let next = 0;
+    for (let i = 1; i < maxColors; i++) {
+      if (this.cut(this.cubes[next], this.cubes[i])) {
+        volumeVariance[next] = this.cubes[next].vol > 1 ? this.variance(this.cubes[next]) : 0;
+        volumeVariance[i] = this.cubes[i].vol > 1 ? this.variance(this.cubes[i]) : 0;
+      } else {
+        volumeVariance[next] = 0;
+        i--;
+      }
+      next = 0;
+      let temp = volumeVariance[0];
+      for (let j = 1; j <= i; j++) {
+        if (volumeVariance[j] > temp) {
+          temp = volumeVariance[j];
+          next = j;
+        }
+      }
+      if (temp <= 0) {
+        generatedColorCount = i + 1;
+        break;
+      }
+    }
+    return new CreateBoxesResult(maxColors, generatedColorCount);
+  }
+  createResult(colorCount) {
+    const colors = [];
+    for (let i = 0; i < colorCount; ++i) {
+      const cube = this.cubes[i];
+      const weight = this.volume(cube, this.weights);
+      if (weight > 0) {
+        const r = Math.round(this.volume(cube, this.momentsR) / weight);
+        const g = Math.round(this.volume(cube, this.momentsG) / weight);
+        const b = Math.round(this.volume(cube, this.momentsB) / weight);
+        const color = 255 << 24 | (r & 255) << 16 | (g & 255) << 8 | b & 255;
+        colors.push(color);
+      }
+    }
+    return colors;
+  }
+  cut(one, two) {
+    const wholeR = this.volume(one, this.momentsR);
+    const wholeG = this.volume(one, this.momentsG);
+    const wholeB = this.volume(one, this.momentsB);
+    const wholeW = this.volume(one, this.weights);
+    const maxRResult = this.maximize(
+      one,
+      directions.RED,
+      one.r0 + 1,
+      one.r1,
+      wholeR,
+      wholeG,
+      wholeB,
+      wholeW
+    );
+    const maxGResult = this.maximize(
+      one,
+      directions.GREEN,
+      one.g0 + 1,
+      one.g1,
+      wholeR,
+      wholeG,
+      wholeB,
+      wholeW
+    );
+    const maxBResult = this.maximize(
+      one,
+      directions.BLUE,
+      one.b0 + 1,
+      one.b1,
+      wholeR,
+      wholeG,
+      wholeB,
+      wholeW
+    );
+    let direction;
+    const maxR = maxRResult.maximum;
+    const maxG = maxGResult.maximum;
+    const maxB = maxBResult.maximum;
+    if (maxR >= maxG && maxR >= maxB) {
+      if (maxRResult.cutLocation < 0) {
+        return false;
+      }
+      direction = directions.RED;
+    } else if (maxG >= maxR && maxG >= maxB) {
+      direction = directions.GREEN;
+    } else {
+      direction = directions.BLUE;
+    }
+    two.r1 = one.r1;
+    two.g1 = one.g1;
+    two.b1 = one.b1;
+    switch (direction) {
+      case directions.BLUE:
+        one.b1 = maxBResult.cutLocation;
+        two.r0 = one.r0;
+        two.g0 = one.g0;
+        two.b0 = one.b1;
+        break;
+      case directions.GREEN:
+        one.g1 = maxGResult.cutLocation;
+        two.r0 = one.r0;
+        two.g0 = one.g1;
+        two.b0 = one.b0;
+        break;
+      case directions.RED:
+        one.r1 = maxRResult.cutLocation;
+        two.r0 = one.r1;
+        two.g0 = one.g0;
+        two.b0 = one.b0;
+        break;
+      default:
+        throw new Error("unexpected direction " + direction);
+    }
+    one.vol = (one.r1 - one.r0) * (one.g1 - one.g0) * (one.b1 - one.b0);
+    two.vol = (two.r1 - two.r0) * (two.g1 - two.g0) * (two.b1 - two.b0);
+    return true;
+  }
+  getIndex(r, g, b) {
+    return (r << INDEX_BITS * 2) + (r << INDEX_BITS + 1) + r + (g << INDEX_BITS) + g + b;
+  }
+  maximize(cube, direction, first, last, wholeR, wholeG, wholeB, wholeW) {
+    const bottomR = this.bottom(cube, direction, this.momentsR);
+    const bottomG = this.bottom(cube, direction, this.momentsG);
+    const bottomB = this.bottom(cube, direction, this.momentsB);
+    const bottomW = this.bottom(cube, direction, this.weights);
+    let max = 0;
+    let cut = -1;
+    let halfR = 0;
+    let halfG = 0;
+    let halfB = 0;
+    let halfW = 0;
+    for (let i = first; i < last; i++) {
+      halfR = bottomR + this.top(cube, direction, i, this.momentsR);
+      halfG = bottomG + this.top(cube, direction, i, this.momentsG);
+      halfB = bottomB + this.top(cube, direction, i, this.momentsB);
+      halfW = bottomW + this.top(cube, direction, i, this.weights);
+      if (halfW === 0) {
+        continue;
+      }
+      let tempNumerator = (halfR * halfR + halfG * halfG + halfB * halfB) * 1;
+      let tempDenominator = halfW * 1;
+      let temp = tempNumerator / tempDenominator;
+      halfR = wholeR - halfR;
+      halfG = wholeG - halfG;
+      halfB = wholeB - halfB;
+      halfW = wholeW - halfW;
+      if (halfW === 0) {
+        continue;
+      }
+      tempNumerator = (halfR * halfR + halfG * halfG + halfB * halfB) * 1;
+      tempDenominator = halfW * 1;
+      temp += tempNumerator / tempDenominator;
+      if (temp > max) {
+        max = temp;
+        cut = i;
+      }
+    }
+    return new MaximizeResult(cut, max);
+  }
+  top(cube, direction, position, moment) {
+    switch (direction) {
+      case directions.BLUE:
+        return moment[this.getIndex(cube.r1, cube.g1, position)] - moment[this.getIndex(cube.r1, cube.g0, position)] - moment[this.getIndex(cube.r0, cube.g1, position)] + moment[this.getIndex(cube.r0, cube.g0, position)];
+      case directions.GREEN:
+        return moment[this.getIndex(cube.r1, position, cube.b1)] - moment[this.getIndex(cube.r1, position, cube.b0)] - moment[this.getIndex(cube.r0, position, cube.b1)] + moment[this.getIndex(cube.r0, position, cube.b0)];
+      case directions.RED:
+        return moment[this.getIndex(position, cube.g1, cube.b1)] - moment[this.getIndex(position, cube.g1, cube.b0)] - moment[this.getIndex(position, cube.g0, cube.b1)] + moment[this.getIndex(position, cube.g0, cube.b0)];
+      default:
+        throw new Error("unexpected direction $direction");
+    }
+  }
+  variance(cube) {
+    const dr = this.volume(cube, this.momentsR);
+    const dg = this.volume(cube, this.momentsG);
+    const db = this.volume(cube, this.momentsB);
+    const xx = this.moments[this.getIndex(cube.r1, cube.g1, cube.b1)] - this.moments[this.getIndex(cube.r1, cube.g1, cube.b0)] - this.moments[this.getIndex(cube.r1, cube.g0, cube.b1)] + this.moments[this.getIndex(cube.r1, cube.g0, cube.b0)] - this.moments[this.getIndex(cube.r0, cube.g1, cube.b1)] + this.moments[this.getIndex(cube.r0, cube.g1, cube.b0)] + this.moments[this.getIndex(cube.r0, cube.g0, cube.b1)] - this.moments[this.getIndex(cube.r0, cube.g0, cube.b0)];
+    const hypotenuse = dr * dr + dg * dg + db * db;
+    const volume = this.volume(cube, this.weights);
+    return xx - hypotenuse / volume;
+  }
+  volume(cube, moment) {
+    return moment[this.getIndex(cube.r1, cube.g1, cube.b1)] - moment[this.getIndex(cube.r1, cube.g1, cube.b0)] - moment[this.getIndex(cube.r1, cube.g0, cube.b1)] + moment[this.getIndex(cube.r1, cube.g0, cube.b0)] - moment[this.getIndex(cube.r0, cube.g1, cube.b1)] + moment[this.getIndex(cube.r0, cube.g1, cube.b0)] + moment[this.getIndex(cube.r0, cube.g0, cube.b1)] - moment[this.getIndex(cube.r0, cube.g0, cube.b0)];
+  }
+};
+
+// src/color/quantize/quantizer_celebi.ts
+var QuantizerCelebi = class {
+  /**
+   * @param pixels Colors in ARGB format.
+   * @param maxColors The number of colors to divide the image into. A lower
+   *     number of colors may be returned.
+   * @return Map with keys of colors in ARGB format, and values of number of
+   *     pixels in the original image that correspond to the color in the
+   *     quantized image.
+   */
+  static quantize(pixels, maxColors) {
+    const wu = new QuantizerWu();
+    const wuResult = wu.quantize(pixels, maxColors);
+    return QuantizerWsmeans.quantize(pixels, wuResult, maxColors);
+  }
+};
+
+// src/color/score/score.ts
+var SCORE_OPTION_DEFAULTS = {
+  desired: 4,
+  // 4 colors matches what Android wallpaper picker.
+  fallbackColorARGB: 4282549748,
+  // Google Blue.
+  filter: true
+  // Avoid unsuitable colors.
+};
+function compare(a, b) {
+  if (a.score > b.score) {
+    return -1;
+  } else if (a.score < b.score) {
+    return 1;
+  }
+  return 0;
+}
+var Score = class _Score {
+  static CUTOFF_CHROMA = 5;
+  static CUTOFF_EXCITED_PROPORTION = 0.01;
+  static TARGET_CHROMA = 48;
+  // A1 Chroma
+  static WEIGHT_CHROMA_ABOVE = 0.3;
+  static WEIGHT_CHROMA_BELOW = 0.1;
+  static WEIGHT_PROPORTION = 0.7;
+  constructor() {
+  }
+  /**
+   * Given a map with keys of colors and values of how often the color appears,
+   * rank the colors based on suitability for being used for a UI theme.
+   *
+   * @param colorsToPopulation map with keys of colors and values of how often
+   *     the color appears, usually from a source image.
+   * @param {ScoreOptions} options optional parameters.
+   * @return Colors sorted by suitability for a UI theme. The most suitable
+   *     color is the first item, the least suitable is the last. There will
+   *     always be at least one color returned. If all the input colors
+   *     were not suitable for a theme, a default fallback color will be
+   *     provided, Google Blue.
+   */
+  static score(colorsToPopulation, options) {
+    const { desired, fallbackColorARGB, filter } = {
+      ...SCORE_OPTION_DEFAULTS,
+      ...options
+    };
+    const colorsHct = [];
+    const huePopulation = new Array(360).fill(0);
+    let populationSum = 0;
+    for (const [argb, population] of colorsToPopulation.entries()) {
+      const hct = Hct.fromInt(argb);
+      colorsHct.push(hct);
+      const hue = Math.floor(hct.hue);
+      huePopulation[hue] += population;
+      populationSum += population;
+    }
+    const hueExcitedProportions = new Array(360).fill(0);
+    for (let hue = 0; hue < 360; hue++) {
+      const proportion = huePopulation[hue] / populationSum;
+      for (let i = hue - 14; i < hue + 16; i++) {
+        const neighborHue = sanitizeDegreesInt(i);
+        hueExcitedProportions[neighborHue] += proportion;
+      }
+    }
+    const scoredHct = new Array();
+    for (const hct of colorsHct) {
+      const hue = sanitizeDegreesInt(Math.round(hct.hue));
+      const proportion = hueExcitedProportions[hue];
+      if (filter && (hct.chroma < _Score.CUTOFF_CHROMA || proportion <= _Score.CUTOFF_EXCITED_PROPORTION)) {
+        continue;
+      }
+      const proportionScore = proportion * 100 * _Score.WEIGHT_PROPORTION;
+      const chromaWeight = hct.chroma < _Score.TARGET_CHROMA ? _Score.WEIGHT_CHROMA_BELOW : _Score.WEIGHT_CHROMA_ABOVE;
+      const chromaScore = (hct.chroma - _Score.TARGET_CHROMA) * chromaWeight;
+      const score = proportionScore + chromaScore;
+      scoredHct.push({ hct, score });
+    }
+    scoredHct.sort(compare);
+    const chosenColors = [];
+    for (let differenceDegrees2 = 90; differenceDegrees2 >= 15; differenceDegrees2--) {
+      chosenColors.length = 0;
+      for (const { hct } of scoredHct) {
+        const duplicateHue = chosenColors.find((chosenHct) => {
+          return differenceDegrees(hct.hue, chosenHct.hue) < differenceDegrees2;
+        });
+        if (!duplicateHue) {
+          chosenColors.push(hct);
+        }
+        if (chosenColors.length >= desired) break;
+      }
+      if (chosenColors.length >= desired) break;
+    }
+    const colors = [];
+    if (chosenColors.length === 0) {
+      colors.push(fallbackColorARGB);
+    }
+    for (const chosenHct of chosenColors) {
+      colors.push(chosenHct.toInt());
+    }
+    return colors;
+  }
+};
+
+// src/color/extract-colors.ts
+var QUALITY_SETTINGS = {
+  high: { maxPixels: 25e3, quantizeColors: 256 },
+  low: { maxPixels: 5e3, quantizeColors: 64 },
+  medium: { maxPixels: 1e4, quantizeColors: 128 }
+};
+function extractColors(imageData, options = {}) {
+  const {
+    filter = true,
+    fixDislikedColors = false,
+    maxColors = 5,
+    quality = "medium",
+    scoringEnabled = true
+  } = options;
+  const qualitySettings = QUALITY_SETTINGS[quality];
+  let pixels = imageDataToPixels(imageData);
+  pixels = samplePixels(pixels, qualitySettings.maxPixels);
+  if (filter) {
+    pixels = filterExtremeTones(pixels);
+  }
+  const quantized = QuantizerCelebi.quantize(
+    pixels,
+    qualitySettings.quantizeColors
+  );
+  let selectedColors;
+  if (scoringEnabled) {
+    selectedColors = Score.score(quantized, {
+      desired: maxColors,
+      filter
+    });
+  } else {
+    const sorted = Array.from(quantized.entries()).sort((a, b) => b[1] - a[1]).slice(0, maxColors).map((entry) => entry[0]);
+    selectedColors = sorted;
+  }
+  const totalPopulation = Array.from(quantized.values()).reduce(
+    (sum, pop) => sum + pop,
+    0
+  );
+  return selectedColors.map((argb) => {
+    let hct = Hct.fromInt(argb);
+    if (fixDislikedColors && DislikeAnalyzer.isDisliked(hct)) {
+      hct = DislikeAnalyzer.fixIfDisliked(hct);
+      argb = hct.toInt();
+    }
+    const r = redFromArgb(argb);
+    const g = greenFromArgb(argb);
+    const b = blueFromArgb(argb);
+    const population = quantized.get(argb) || 0;
+    return {
+      hct: { c: hct.chroma, h: hct.hue, t: hct.tone },
+      hex: rgbToHex2(r, g, b),
+      percentage: population / totalPopulation * 100,
+      population,
+      rgb: { b, g, r }
+    };
+  });
+}
+function extractThemePalette(imageData) {
+  const colors = extractColors(imageData, {
+    filter: true,
+    fixDislikedColors: true,
+    // Always fix disliked colors for themes
+    maxColors: 8,
+    quality: "high",
+    scoringEnabled: true
+  });
+  if (colors.length === 0) {
+    throw new Error("No colors could be extracted from image");
+  }
+  const result = {
+    primary: colors[0]
+  };
+  if (colors.length > 1) {
+    const primaryHue = colors[0].hct.h;
+    let maxHueDiff = 0;
+    let secondaryIndex = 1;
+    for (let i = 1; i < Math.min(colors.length, 4); i++) {
+      const hueDiff = Math.abs(hueDifference(primaryHue, colors[i].hct.h));
+      if (hueDiff > maxHueDiff) {
+        maxHueDiff = hueDiff;
+        secondaryIndex = i;
+      }
+    }
+    result.secondary = colors[secondaryIndex];
+    if (colors.length > 2) {
+      const secondaryHue = colors[secondaryIndex].hct.h;
+      let bestTertiaryIndex = -1;
+      let bestScore = 0;
+      for (let i = 1; i < colors.length; i++) {
+        if (i === secondaryIndex) continue;
+        const hue = colors[i].hct.h;
+        const primaryDiff = Math.abs(hueDifference(primaryHue, hue));
+        const secondaryDiff = Math.abs(hueDifference(secondaryHue, hue));
+        const score = Math.min(primaryDiff, secondaryDiff);
+        if (score > bestScore) {
+          bestScore = score;
+          bestTertiaryIndex = i;
+        }
+      }
+      if (bestTertiaryIndex !== -1) {
+        result.tertiary = colors[bestTertiaryIndex];
+      }
+    }
+  }
+  const neutral = colors.find((c) => c.hct.c < 20);
+  if (neutral) {
+    result.neutral = neutral;
+  }
+  const errorColor = colors.find((c) => c.hct.h >= 350 || c.hct.h <= 40);
+  if (errorColor) {
+    result.error = errorColor;
+  }
+  return result;
+}
+function hueDifference(h1, h2) {
+  const diff = Math.abs(h1 - h2);
+  return diff > 180 ? 360 - diff : diff;
+}
+function rgbToHex2(r, g, b) {
+  return "#" + [r, g, b].map((x) => Math.round(x).toString(16).padStart(2, "0")).join("");
+}
+
+// src/color/material-theme.ts
+function generateMaterialTheme(sourceColor, options = {}) {
+  const { fixDislikedColors = true } = options;
+  let source = parseColor(sourceColor);
+  if (!source) {
+    throw new Error(`Invalid color format: ${sourceColor}`);
+  }
+  if (fixDislikedColors) {
+    const sourceHct = Hct.fromInt(rgbToArgb(source));
+    if (DislikeAnalyzer.isDisliked(sourceHct)) {
+      const fixedHct = DislikeAnalyzer.fixIfDisliked(sourceHct);
+      const fixedArgb = fixedHct.toInt();
+      source = {
+        b: fixedArgb & 255,
+        g: fixedArgb >> 8 & 255,
+        r: fixedArgb >> 16 & 255
+      };
+    }
+  }
+  const corePalette = corePaletteFromRgb(source);
+  const lightScheme = {
+    background: rgbToHex(corePalette.neutral.tone(99)),
+    error: rgbToHex(corePalette.error.tone(40)),
+    errorContainer: rgbToHex(corePalette.error.tone(90)),
+    onBackground: rgbToHex(corePalette.neutral.tone(10)),
+    onError: rgbToHex(corePalette.error.tone(100)),
+    onErrorContainer: rgbToHex(corePalette.error.tone(10)),
+    onPrimary: rgbToHex(corePalette.primary.tone(100)),
+    onPrimaryContainer: rgbToHex(corePalette.primary.tone(10)),
+    onSecondary: rgbToHex(corePalette.secondary.tone(100)),
+    onSecondaryContainer: rgbToHex(corePalette.secondary.tone(10)),
+    onSurface: rgbToHex(corePalette.neutral.tone(10)),
+    onSurfaceVariant: rgbToHex(corePalette.neutralVariant.tone(30)),
+    onTertiary: rgbToHex(corePalette.tertiary.tone(100)),
+    onTertiaryContainer: rgbToHex(corePalette.tertiary.tone(10)),
+    outline: rgbToHex(corePalette.neutralVariant.tone(50)),
+    primary: rgbToHex(corePalette.primary.tone(40)),
+    primaryContainer: rgbToHex(corePalette.primary.tone(90)),
+    secondary: rgbToHex(corePalette.secondary.tone(40)),
+    secondaryContainer: rgbToHex(corePalette.secondary.tone(90)),
+    surface: rgbToHex(corePalette.neutral.tone(99)),
+    surfaceVariant: rgbToHex(corePalette.neutralVariant.tone(90)),
+    tertiary: rgbToHex(corePalette.tertiary.tone(40)),
+    tertiaryContainer: rgbToHex(corePalette.tertiary.tone(90))
+  };
+  const darkScheme = {
+    background: rgbToHex(corePalette.neutral.tone(10)),
+    error: rgbToHex(corePalette.error.tone(80)),
+    errorContainer: rgbToHex(corePalette.error.tone(30)),
+    onBackground: rgbToHex(corePalette.neutral.tone(90)),
+    onError: rgbToHex(corePalette.error.tone(20)),
+    onErrorContainer: rgbToHex(corePalette.error.tone(90)),
+    onPrimary: rgbToHex(corePalette.primary.tone(20)),
+    onPrimaryContainer: rgbToHex(corePalette.primary.tone(90)),
+    onSecondary: rgbToHex(corePalette.secondary.tone(20)),
+    onSecondaryContainer: rgbToHex(corePalette.secondary.tone(90)),
+    onSurface: rgbToHex(corePalette.neutral.tone(90)),
+    onSurfaceVariant: rgbToHex(corePalette.neutralVariant.tone(80)),
+    onTertiary: rgbToHex(corePalette.tertiary.tone(20)),
+    onTertiaryContainer: rgbToHex(corePalette.tertiary.tone(90)),
+    outline: rgbToHex(corePalette.neutralVariant.tone(60)),
+    primary: rgbToHex(corePalette.primary.tone(80)),
+    primaryContainer: rgbToHex(corePalette.primary.tone(30)),
+    secondary: rgbToHex(corePalette.secondary.tone(80)),
+    secondaryContainer: rgbToHex(corePalette.secondary.tone(30)),
+    surface: rgbToHex(corePalette.neutral.tone(10)),
+    surfaceVariant: rgbToHex(corePalette.neutralVariant.tone(30)),
+    tertiary: rgbToHex(corePalette.tertiary.tone(80)),
+    tertiaryContainer: rgbToHex(corePalette.tertiary.tone(30))
+  };
+  return {
+    schemes: {
+      dark: darkScheme,
+      light: lightScheme
+    },
+    sourceColor
+  };
+}
+
+// src/tools/image-extraction.tools.ts
+var extractImageColorsTool = {
+  description: "Extract dominant colors from an image. Input should be image data as an array of RGBA values.",
+  execute: async (args, _context) => {
+    const {
+      format = "json",
+      imageData,
+      maxColors = 5,
+      quality = "medium"
+    } = args;
+    try {
+      const data = imageData.data instanceof Uint8ClampedArray ? imageData.data : new Uint8ClampedArray(imageData.data);
+      const processedImageData = {
+        data,
+        height: imageData.height,
+        width: imageData.width
+      };
+      const colors = extractColors(processedImageData, {
+        filter: true,
+        maxColors,
+        quality,
+        scoringEnabled: true
+      });
+      switch (format) {
+        case "css":
+          return formatAsCSS(colors);
+        case "palette":
+          return formatAsPalette(colors);
+        case "json":
+        default:
+          return formatAsJSON(colors);
+      }
+    } catch (error) {
+      return `Error extracting colors: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  },
+  inputSchema: {
+    properties: {
+      format: {
+        description: "Output format: json, css, or palette (default: json)",
+        enum: ["json", "css", "palette"],
+        type: "string"
+      },
+      imageData: {
+        description: "Image data with RGBA values",
+        properties: {
+          data: {
+            description: "Flat array of RGBA values (0-255)",
+            items: { type: "number" },
+            type: "array"
+          },
+          height: {
+            description: "Image height in pixels",
+            type: "number"
+          },
+          width: {
+            description: "Image width in pixels",
+            type: "number"
+          }
+        },
+        required: ["data", "width", "height"],
+        type: "object"
+      },
+      maxColors: {
+        description: "Maximum number of colors to extract (default: 5)",
+        maximum: 20,
+        minimum: 1,
+        type: "number"
+      },
+      quality: {
+        description: "Extraction quality: low, medium, or high (default: medium)",
+        enum: ["low", "medium", "high"],
+        type: "string"
+      }
+    },
+    required: ["imageData"],
+    type: "object"
+  },
+  name: "extract_image_colors"
+};
+var generateThemeFromImageTool = {
+  description: "Generate a complete Material Design 3 theme from an image",
+  execute: async (args, _context) => {
+    const {
+      imageData,
+      includeCustomColors = true,
+      isDark = false
+    } = args;
+    try {
+      const data = imageData.data instanceof Uint8ClampedArray ? imageData.data : new Uint8ClampedArray(imageData.data);
+      const processedImageData = {
+        data,
+        height: imageData.height,
+        width: imageData.width
+      };
+      const palette = extractThemePalette(processedImageData);
+      const sourceColor = palette.primary.hex;
+      const theme = generateMaterialTheme(sourceColor, { isDark });
+      if (includeCustomColors && palette.secondary) {
+        theme.customColors = {
+          secondary: {
+            color: palette.secondary.hex,
+            hct: palette.secondary.hct,
+            population: palette.secondary.population
+          }
+        };
+        if (palette.tertiary) {
+          theme.customColors.tertiary = {
+            color: palette.tertiary.hex,
+            hct: palette.tertiary.hct,
+            population: palette.tertiary.population
+          };
+        }
+      }
+      let output = `# Material Design 3 Theme from Image
+
+`;
+      output += `## Source Colors
+`;
+      output += `- Primary: ${palette.primary.hex} (${palette.primary.percentage.toFixed(1)}%)
+`;
+      if (palette.secondary) {
+        output += `- Secondary: ${palette.secondary.hex} (${palette.secondary.percentage.toFixed(1)}%)
+`;
+      }
+      if (palette.tertiary) {
+        output += `- Tertiary: ${palette.tertiary.hex} (${palette.tertiary.percentage.toFixed(1)}%)
+`;
+      }
+      output += `
+## Theme Colors (${isDark ? "Dark" : "Light"} Mode)
+
+`;
+      output += `### Primary
+`;
+      output += `- primary: ${theme.schemes[isDark ? "dark" : "light"].primary}
+`;
+      output += `- onPrimary: ${theme.schemes[isDark ? "dark" : "light"].onPrimary}
+`;
+      output += `- primaryContainer: ${theme.schemes[isDark ? "dark" : "light"].primaryContainer}
+`;
+      output += `- onPrimaryContainer: ${theme.schemes[isDark ? "dark" : "light"].onPrimaryContainer}
+`;
+      output += `
+### Surface
+`;
+      output += `- surface: ${theme.schemes[isDark ? "dark" : "light"].surface}
+`;
+      output += `- onSurface: ${theme.schemes[isDark ? "dark" : "light"].onSurface}
+`;
+      output += `- surfaceVariant: ${theme.schemes[isDark ? "dark" : "light"].surfaceVariant}
+`;
+      output += `- onSurfaceVariant: ${theme.schemes[isDark ? "dark" : "light"].onSurfaceVariant}
+`;
+      output += `
+### Background
+`;
+      output += `- background: ${theme.schemes[isDark ? "dark" : "light"].background}
+`;
+      output += `- onBackground: ${theme.schemes[isDark ? "dark" : "light"].onBackground}
+`;
+      return output;
+    } catch (error) {
+      return `Error generating theme: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  },
+  inputSchema: {
+    properties: {
+      imageData: {
+        description: "Image data with RGBA values",
+        properties: {
+          data: {
+            description: "Flat array of RGBA values (0-255)",
+            items: { type: "number" },
+            type: "array"
+          },
+          height: {
+            description: "Image height in pixels",
+            type: "number"
+          },
+          width: {
+            description: "Image width in pixels",
+            type: "number"
+          }
+        },
+        required: ["data", "width", "height"],
+        type: "object"
+      },
+      includeCustomColors: {
+        description: "Include custom colors from image (default: true)",
+        type: "boolean"
+      },
+      isDark: {
+        description: "Generate dark theme (default: false for light theme)",
+        type: "boolean"
+      }
+    },
+    required: ["imageData"],
+    type: "object"
+  },
+  name: "generate_theme_from_image"
+};
+function formatAsCSS(colors) {
+  let css = ":root {\n";
+  colors.forEach((color, index) => {
+    css += `  --extracted-color-${index + 1}: ${color.hex}; /* ${color.percentage.toFixed(1)}% */
+`;
+  });
+  css += "}\n\n";
+  css += "/* Color Details */\n";
+  colors.forEach((color, index) => {
+    css += `/* Color ${index + 1}: ${color.hex}
+`;
+    css += `   RGB: rgb(${color.rgb.r}, ${color.rgb.g}, ${color.rgb.b})
+`;
+    css += `   HCT: hct(${color.hct.h.toFixed(1)}, ${color.hct.c.toFixed(1)}, ${color.hct.t.toFixed(1)})
+`;
+    css += `   Population: ${color.percentage.toFixed(1)}%
+`;
+    css += `*/
+
+`;
+  });
+  return css;
+}
+function formatAsJSON(colors) {
+  return JSON.stringify(colors, null, 2);
+}
+function formatAsPalette(colors) {
+  let output = "# Extracted Color Palette\n\n";
+  colors.forEach((color, index) => {
+    output += `## Color ${index + 1}
+`;
+    output += `- Hex: ${color.hex}
+`;
+    output += `- RGB: rgb(${color.rgb.r}, ${color.rgb.g}, ${color.rgb.b})
+`;
+    output += `- HCT: H:${color.hct.h.toFixed(1)}\xB0 C:${color.hct.c.toFixed(1)} T:${color.hct.t.toFixed(1)}
+`;
+    output += `- Usage: ${color.percentage.toFixed(1)}%
+
+`;
+  });
+  return output;
+}
+
+// src/tools/material-theme.tools.ts
+import { z as z6 } from "zod";
+var generateMaterialThemeTool = {
+  description: "Generate a complete Material Design 3 color theme from a source color",
+  execute: async (args) => {
+    const source = parseColor(args.sourceColor);
+    if (!source) {
+      return `Invalid color format: ${args.sourceColor}`;
+    }
+    const corePalette = corePaletteFromRgb(source);
+    const lightTheme = {
+      background: rgbToHex(corePalette.neutral.tone(99)),
+      error: rgbToHex(corePalette.error.tone(40)),
+      errorContainer: rgbToHex(corePalette.error.tone(90)),
+      onBackground: rgbToHex(corePalette.neutral.tone(10)),
+      onError: rgbToHex(corePalette.error.tone(100)),
+      onErrorContainer: rgbToHex(corePalette.error.tone(10)),
+      onPrimary: rgbToHex(corePalette.primary.tone(100)),
+      onPrimaryContainer: rgbToHex(corePalette.primary.tone(10)),
+      onSecondary: rgbToHex(corePalette.secondary.tone(100)),
+      onSecondaryContainer: rgbToHex(corePalette.secondary.tone(10)),
+      onSurface: rgbToHex(corePalette.neutral.tone(10)),
+      onSurfaceVariant: rgbToHex(corePalette.neutralVariant.tone(30)),
+      onTertiary: rgbToHex(corePalette.tertiary.tone(100)),
+      onTertiaryContainer: rgbToHex(corePalette.tertiary.tone(10)),
+      outline: rgbToHex(corePalette.neutralVariant.tone(50)),
+      primary: rgbToHex(corePalette.primary.tone(40)),
+      primaryContainer: rgbToHex(corePalette.primary.tone(90)),
+      secondary: rgbToHex(corePalette.secondary.tone(40)),
+      secondaryContainer: rgbToHex(corePalette.secondary.tone(90)),
+      surface: rgbToHex(corePalette.neutral.tone(99)),
+      surfaceVariant: rgbToHex(corePalette.neutralVariant.tone(90)),
+      tertiary: rgbToHex(corePalette.tertiary.tone(40)),
+      tertiaryContainer: rgbToHex(corePalette.tertiary.tone(90))
+    };
+    const darkTheme = {
+      background: rgbToHex(corePalette.neutral.tone(10)),
+      error: rgbToHex(corePalette.error.tone(80)),
+      errorContainer: rgbToHex(corePalette.error.tone(30)),
+      onBackground: rgbToHex(corePalette.neutral.tone(90)),
+      onError: rgbToHex(corePalette.error.tone(20)),
+      onErrorContainer: rgbToHex(corePalette.error.tone(90)),
+      onPrimary: rgbToHex(corePalette.primary.tone(20)),
+      onPrimaryContainer: rgbToHex(corePalette.primary.tone(90)),
+      onSecondary: rgbToHex(corePalette.secondary.tone(20)),
+      onSecondaryContainer: rgbToHex(corePalette.secondary.tone(90)),
+      onSurface: rgbToHex(corePalette.neutral.tone(90)),
+      onSurfaceVariant: rgbToHex(corePalette.neutralVariant.tone(80)),
+      onTertiary: rgbToHex(corePalette.tertiary.tone(20)),
+      onTertiaryContainer: rgbToHex(corePalette.tertiary.tone(90)),
+      outline: rgbToHex(corePalette.neutralVariant.tone(60)),
+      primary: rgbToHex(corePalette.primary.tone(80)),
+      primaryContainer: rgbToHex(corePalette.primary.tone(30)),
+      secondary: rgbToHex(corePalette.secondary.tone(80)),
+      secondaryContainer: rgbToHex(corePalette.secondary.tone(30)),
+      surface: rgbToHex(corePalette.neutral.tone(10)),
+      surfaceVariant: rgbToHex(corePalette.neutralVariant.tone(30)),
+      tertiary: rgbToHex(corePalette.tertiary.tone(80)),
+      tertiaryContainer: rgbToHex(corePalette.tertiary.tone(30))
+    };
+    let result = `Material Design 3 Theme
+Source Color: ${args.sourceColor}
+
+LIGHT THEME:
+${Object.entries(lightTheme).map(([key, value]) => `  ${key}: ${value}`).join("\n")}
+
+DARK THEME:
+${Object.entries(darkTheme).map(([key, value]) => `  ${key}: ${value}`).join("\n")}`;
+    if (args.includeCustomColors) {
+      result += `
+
+TONAL PALETTES:
+Primary: ${[0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 95, 99, 100].map((t) => rgbToHex(corePalette.primary.tone(t))).join(", ")}
+Secondary: ${[40, 80].map((t) => rgbToHex(corePalette.secondary.tone(t))).join(", ")}
+Tertiary: ${[40, 80].map((t) => rgbToHex(corePalette.tertiary.tone(t))).join(", ")}`;
+    }
+    return result;
+  },
+  name: "generate_material_theme",
+  parameters: z6.object({
+    includeCustomColors: z6.boolean().optional().default(false).describe("Include custom color palettes"),
+    sourceColor: z6.string().describe("Source color for theme generation")
+  })
+};
+var harmonizeColorsTool = {
+  description: "Harmonize colors to work better together using Material Design algorithms",
+  execute: async (args) => {
+    const colors = args.colors.map((c) => parseColor(c));
+    if (colors.some((c) => c === null)) {
+      return "One or more invalid color formats";
+    }
+    const validColors = colors;
+    const method = args.method || "harmonize";
+    const factor = args.factor || 0.5;
+    const results = [];
+    switch (method) {
+      case "blend": {
+        let result = validColors[0];
+        for (let i = 1; i < validColors.length; i++) {
+          result = blend(result, validColors[i], factor);
+        }
+        results.push(rgbToHex(result));
+        break;
+      }
+      case "harmonize": {
+        const source = validColors[0];
+        results.push(rgbToHex(source));
+        for (let i = 1; i < validColors.length; i++) {
+          results.push(rgbToHex(harmonize(validColors[i], source, factor)));
+        }
+        break;
+      }
+      case "temperature": {
+        const amount = (factor - 0.5) * 2;
+        for (const color of validColors) {
+          results.push(rgbToHex(adjustTemperature(color, amount)));
+        }
+        break;
+      }
+    }
+    return `Harmonized Colors (${method}):
+Original: ${args.colors.join(", ")}
+Result: ${results.join(", ")}`;
+  },
+  name: "harmonize_colors",
+  parameters: z6.object({
+    colors: z6.array(z6.string()).min(2).max(10).describe("Array of colors to harmonize"),
+    factor: z6.number().min(0).max(1).optional().default(0.5).describe("Harmonization strength (0-1)"),
+    method: z6.enum(["blend", "harmonize", "temperature"]).optional().default("harmonize").describe("Harmonization method")
+  })
+};
+var generateTonalPaletteTool = {
+  description: "Generate a Material Design tonal palette from a color",
+  execute: async (args) => {
+    const rgb = parseColor(args.color);
+    if (!rgb) {
+      return `Invalid color format: ${args.color}`;
+    }
+    const palette = TonalPalette.fromRgb(rgb);
+    const tones = args.tones || [
+      0,
+      10,
+      20,
+      30,
+      40,
+      50,
+      60,
+      70,
+      80,
+      90,
+      95,
+      99,
+      100
+    ];
+    const hct = rgbToHct(rgb);
+    const colors = tones.map((tone) => ({
+      hex: rgbToHex(palette.tone(tone)),
+      tone
+    }));
+    return `Tonal Palette for ${args.color}
+HCT: h=${hct.h.toFixed(1)}\xB0, c=${hct.c.toFixed(1)}, t=${hct.t.toFixed(1)}
+
+${colors.map(({ hex, tone }) => `Tone ${tone}: ${hex}`).join("\n")}`;
+  },
+  name: "generate_tonal_palette",
+  parameters: z6.object({
+    color: z6.string().describe("Base color for palette"),
+    tones: z6.array(z6.number()).optional().describe("Custom tone values (default: Material standard tones)")
+  })
+};
+
+// src/tools/palette-generator.tool.ts
+import { z as z7 } from "zod";
+var paletteGeneratorTool = {
+  description: "Generate a color palette from a base color",
+  execute: async (args) => {
+    const base = parseColor(args.baseColor);
+    if (!base) {
+      return `Invalid color format: ${args.baseColor}`;
+    }
+    const type = args.type || "monochromatic";
+    const count = args.count || 5;
+    const hsl = rgbToHsl(base);
+    const palette = [];
+    switch (type) {
+      case "analogous": {
+        const step = 30;
+        for (let i = 0; i < count; i++) {
+          const h = (hsl.h + (i - Math.floor(count / 2)) * step + 360) % 360;
+          const color = parseColor(`hsl(${h}, ${hsl.s}%, ${hsl.l}%)`);
+          if (color) palette.push(rgbToHex(color));
+        }
+        break;
+      }
+      case "complementary": {
+        palette.push(rgbToHex(base));
+        const complement = parseColor(
+          `hsl(${(hsl.h + 180) % 360}, ${hsl.s}%, ${hsl.l}%)`
+        );
+        if (complement) palette.push(rgbToHex(complement));
+        for (let i = 2; i < count; i++) {
+          const l = hsl.l + (i % 2 === 0 ? 20 : -20);
+          const h = i < count / 2 ? hsl.h : (hsl.h + 180) % 360;
+          const color = parseColor(
+            `hsl(${h}, ${hsl.s}%, ${Math.max(10, Math.min(90, l))}%)`
+          );
+          if (color) palette.push(rgbToHex(color));
+        }
+        break;
+      }
+      case "monochromatic": {
+        const step = 80 / (count - 1);
+        for (let i = 0; i < count; i++) {
+          const l = 10 + i * step;
+          const color = parseColor(`hsl(${hsl.h}, ${hsl.s}%, ${l}%)`);
+          if (color) palette.push(rgbToHex(color));
+        }
+        break;
+      }
+      case "tetradic": {
+        for (let i = 0; i < Math.min(4, count); i++) {
+          const h = (hsl.h + i * 90) % 360;
+          const color = parseColor(`hsl(${h}, ${hsl.s}%, ${hsl.l}%)`);
+          if (color) palette.push(rgbToHex(color));
+        }
+        for (let i = 4; i < count; i++) {
+          const baseIdx = i % 4;
+          const h = (hsl.h + baseIdx * 90) % 360;
+          const l = hsl.l + (i < 8 ? 15 : -15);
+          const color = parseColor(
+            `hsl(${h}, ${hsl.s}%, ${Math.max(10, Math.min(90, l))}%)`
+          );
+          if (color) palette.push(rgbToHex(color));
+        }
+        break;
+      }
+      case "triadic": {
+        for (let i = 0; i < Math.min(3, count); i++) {
+          const h = (hsl.h + i * 120) % 360;
+          const color = parseColor(`hsl(${h}, ${hsl.s}%, ${hsl.l}%)`);
+          if (color) palette.push(rgbToHex(color));
+        }
+        for (let i = 3; i < count; i++) {
+          const baseIdx = i % 3;
+          const h = (hsl.h + baseIdx * 120) % 360;
+          const l = hsl.l + (i < 6 ? 20 : -20);
+          const color = parseColor(
+            `hsl(${h}, ${hsl.s}%, ${Math.max(10, Math.min(90, l))}%)`
+          );
+          if (color) palette.push(rgbToHex(color));
+        }
+        break;
+      }
+    }
+    return `Generated ${type} palette:
+${palette.map((color, i) => `${i + 1}. ${color}`).join("\n")}`;
+  },
+  name: "generate_palette",
+  parameters: z7.object({
+    baseColor: z7.string().describe("Base color for palette generation"),
+    count: z7.number().min(3).max(10).default(5).describe("Number of colors to generate"),
+    type: z7.enum([
+      "monochromatic",
+      "analogous",
+      "complementary",
+      "triadic",
+      "tetradic"
+    ]).default("monochromatic").describe("Type of color palette")
+  })
+};
+
+// src/tools/palette-with-locks.tool.ts
+import { z as z8 } from "zod";
+var paletteWithLocksTool = {
+  description: "Generate a color palette while preserving specific locked colors",
+  execute: async (args) => {
+    const {
+      colorSpace = "hsl",
+      lockedColors,
+      mode = "harmony",
+      totalColors
+    } = args;
+    if (lockedColors.length >= totalColors) {
+      return `Error: Number of locked colors (${lockedColors.length}) must be less than total colors (${totalColors})`;
+    }
+    const parsedLocked = [];
+    for (const color of lockedColors) {
+      const parsed = parseColor(color);
+      if (!parsed) {
+        return `Invalid color format: ${color}`;
+      }
+      parsedLocked.push(parsed);
+    }
+    const palette = [];
+    const remainingSlots = totalColors - lockedColors.length;
+    lockedColors.forEach((color) => palette.push(color));
+    switch (mode) {
+      case "contrast": {
+        for (let i = 0; i < remainingSlots; i++) {
+          let bestColor = null;
+          let maxMinDistance = 0;
+          for (let attempt = 0; attempt < 100; attempt++) {
+            const candidate = {
+              b: Math.floor(Math.random() * 256),
+              g: Math.floor(Math.random() * 256),
+              r: Math.floor(Math.random() * 256)
+            };
+            let minDistance = Infinity;
+            for (const locked of parsedLocked) {
+              const dist = colorDistance(candidate, locked, "deltaE2000");
+              if (dist < minDistance) minDistance = dist;
+            }
+            if (minDistance > maxMinDistance) {
+              maxMinDistance = minDistance;
+              bestColor = candidate;
+            }
+          }
+          if (bestColor) {
+            palette.push(rgbToHex(bestColor));
+            parsedLocked.push(bestColor);
+          }
+        }
+        break;
+      }
+      case "gradient": {
+        if (parsedLocked.length < 2) {
+          return "Gradient mode requires at least 2 locked colors";
+        }
+        const steps = Math.floor(remainingSlots / (parsedLocked.length - 1));
+        for (let i = 0; i < parsedLocked.length - 1; i++) {
+          const start = parsedLocked[i];
+          const end = parsedLocked[i + 1];
+          for (let step = 1; step <= steps; step++) {
+            const t = step / (steps + 1);
+            if (colorSpace === "lab") {
+              const startLab = rgbToLab(start);
+              const endLab = rgbToLab(end);
+              const interpolated = labToRgb({
+                a: startLab.a + (endLab.a - startLab.a) * t,
+                b: startLab.b + (endLab.b - startLab.b) * t,
+                l: startLab.l + (endLab.l - startLab.l) * t
+              });
+              palette.push(rgbToHex(interpolated));
+            } else {
+              const startHsl = rgbToHsl(start);
+              const endHsl = rgbToHsl(end);
+              let hueDiff = endHsl.h - startHsl.h;
+              if (hueDiff > 180) hueDiff -= 360;
+              if (hueDiff < -180) hueDiff += 360;
+              const interpolated = hslToRgb({
+                h: (startHsl.h + hueDiff * t + 360) % 360,
+                l: startHsl.l + (endHsl.l - startHsl.l) * t,
+                s: startHsl.s + (endHsl.s - startHsl.s) * t
+              });
+              palette.push(rgbToHex(interpolated));
+            }
+          }
+        }
+        break;
+      }
+      case "harmony": {
+        const baseHsl = rgbToHsl(parsedLocked[0]);
+        const hueStep = 360 / totalColors;
+        for (let i = 0; i < remainingSlots; i++) {
+          let newHue = baseHsl.h;
+          let attempts = 0;
+          let bestColor = null;
+          let maxMinDistance = 0;
+          while (attempts < 36) {
+            newHue = (baseHsl.h + attempts * 10) % 360;
+            const candidate = hslToRgb({
+              h: newHue,
+              l: baseHsl.l + (Math.random() - 0.5) * 20,
+              s: baseHsl.s + (Math.random() - 0.5) * 20
+            });
+            let minDistance = Infinity;
+            for (const locked of parsedLocked) {
+              const dist = colorDistance(candidate, locked, "deltaE2000");
+              if (dist < minDistance) minDistance = dist;
+            }
+            if (minDistance > maxMinDistance && minDistance > 10) {
+              maxMinDistance = minDistance;
+              bestColor = candidate;
+            }
+            attempts++;
+          }
+          if (bestColor) {
+            palette.push(rgbToHex(bestColor));
+            parsedLocked.push(bestColor);
+          }
+        }
+        break;
+      }
+    }
+    const result = [];
+    const lockedSet = new Set(lockedColors.map((c) => c.toLowerCase()));
+    palette.forEach((color) => {
+      if (lockedSet.has(color.toLowerCase())) {
+        result.push(`${color} (locked)`);
+      } else {
+        result.push(color);
+      }
+    });
+    return `Generated palette with ${lockedColors.length} locked colors:
+${result.map((color, i) => `${i + 1}. ${color}`).join("\n")}
+
+Mode: ${mode}
+Color space: ${colorSpace}
+Total colors: ${totalColors}`;
+  },
+  name: "generate_palette_with_locks",
+  parameters: z8.object({
+    colorSpace: z8.enum(["hsl", "lab"]).default("hsl").describe("Color space for interpolation (affects gradient smoothness)"),
+    lockedColors: z8.array(z8.string()).min(1).describe("Colors that must be included in the palette"),
+    mode: z8.enum(["harmony", "contrast", "gradient"]).default("harmony").describe(
+      "Generation mode: harmony (similar), contrast (different), or gradient (smooth transition)"
+    ),
+    totalColors: z8.number().min(2).max(20).describe("Total number of colors in the final palette")
+  })
+};
+
+// src/tools/theme-matching.tools.ts
+import { z as z9 } from "zod";
+
+// src/theme/matcher.ts
+var DEFAULT_WEIGHTS = {
+  accessibility: 0.2,
+  perceptual: 0.6,
+  semantic: 0.2
+};
+var CONTEXT_MAX_DISTANCES = {
+  accent: 15,
+  // Moderate for brand consistency
+  background: 15,
+  // Moderate flexibility
+  border: 20,
+  // More flexibility
+  decorative: 30,
+  // Most flexible
+  shadow: 25,
+  // Even more flexibility
+  text: 10
+  // Strict for readability
+};
+function findBatchMatches(colors, themeVariables, options = {}) {
+  const results = /* @__PURE__ */ new Map();
+  for (const color of colors) {
+    results.set(color, findClosestThemeColor(color, themeVariables, options));
+  }
+  return results;
+}
+function findClosestThemeColor(inputColor, themeVariables, options = {}) {
+  let inputHct;
+  try {
+    const rgb = parseColorToRgb(inputColor);
+    inputHct = rgbToHct(rgb);
+  } catch {
+    console.error(`Failed to parse input color: ${inputColor}`);
+    return null;
+  }
+  const allVariables = flattenThemeVariables(themeVariables);
+  if (allVariables.length === 0) {
+    return null;
+  }
+  const candidates = allVariables.map((variable) => ({
+    distance: calculateHctDistance(inputHct, variable.hct),
+    score: 0,
+    // Will be calculated next
+    variable
+  }));
+  const maxDistance = options.maxDistance ?? (options.contextType ? CONTEXT_MAX_DISTANCES[options.contextType] : 30);
+  const validCandidates = candidates.filter((c) => c.distance <= maxDistance);
+  if (validCandidates.length === 0) {
+    return null;
+  }
+  const weights = options.weights ?? DEFAULT_WEIGHTS;
+  for (const candidate of validCandidates) {
+    candidate.score = calculateMatchScore(
+      inputHct,
+      candidate.variable,
+      candidate.distance,
+      weights,
+      options
+    );
+  }
+  validCandidates.sort((a, b) => b.score - a.score);
+  const best = validCandidates[0];
+  const alternatives = validCandidates.slice(1, 4).map((c) => ({
+    alternatives: [],
+    confidence: calculateConfidence(c.distance, c.score),
+    distance: c.distance,
+    semanticRole: c.variable.role,
+    value: c.variable.value,
+    variable: c.variable.name
+  }));
+  const accessibilityInfo = options.contextType === "text" || options.contextType === "background" ? calculateAccessibilityInfo(best.variable.value, themeVariables) : void 0;
+  return {
+    accessibilityInfo,
+    alternatives,
+    confidence: calculateConfidence(best.distance, best.score),
+    distance: best.distance,
+    semanticRole: best.variable.role,
+    value: best.variable.value,
+    variable: best.variable.name
+  };
+}
+function calculateAccessibilityInfo(color, themeVariables) {
+  const rgb = parseColorToRgb(color);
+  const backgrounds = findTypicalBackgrounds(themeVariables);
+  const foregrounds = findTypicalForegrounds(themeVariables);
+  let maxContrastBg = 0;
+  let maxContrastFg = 0;
+  for (const bg of backgrounds) {
+    const bgRgb = parseColorToRgb(bg.value);
+    const contrast = getContrastRatio(rgb, bgRgb);
+    maxContrastBg = Math.max(maxContrastBg, contrast);
+  }
+  for (const fg of foregrounds) {
+    const fgRgb = parseColorToRgb(fg.value);
+    const contrast = getContrastRatio(rgb, fgRgb);
+    maxContrastFg = Math.max(maxContrastFg, contrast);
+  }
+  return {
+    contrastWithBackground: maxContrastBg,
+    contrastWithForeground: maxContrastFg,
+    meetsAA: maxContrastBg >= 4.5 || maxContrastFg >= 4.5,
+    meetsAAA: maxContrastBg >= 7 || maxContrastFg >= 7
+  };
+}
+function calculateConfidence(distance, score) {
+  if (distance < 0.5) return 100;
+  if (distance < 1) return 98;
+  if (distance < 2) return 95;
+  const distanceConfidence = Math.max(0, 100 - distance * 2);
+  const scoreConfidence = score * 100;
+  return Math.round((distanceConfidence + scoreConfidence) / 2);
+}
+function calculateContextSemanticScore(context, role) {
+  if (!role) return 0.5;
+  switch (context) {
+    case "accent":
+      return role === "primary" || role === "secondary" ? 1 : 0.5;
+    case "background":
+      return role === "surface" || role === "background" ? 1 : 0.3;
+    case "border":
+      return role === "outline" ? 1 : role === "neutral" ? 0.4 : 0.2;
+    case "decorative":
+      return 0.7;
+    // Any role is acceptable
+    case "shadow":
+      return role === "shadow" ? 1 : 0.3;
+    case "text":
+      return role === "neutral" || role === "surface" ? 0.8 : 0.5;
+    default:
+      return 0.5;
+  }
+}
+function calculateHctDistance(color1, color2) {
+  const hueWeight = 1;
+  const chromaWeight = 1;
+  const toneWeight = 2;
+  let hueDiff = Math.abs(color1.h - color2.h);
+  if (hueDiff > 180) {
+    hueDiff = 360 - hueDiff;
+  }
+  hueDiff = hueDiff / 180;
+  const chromaDiff = Math.abs(color1.c - color2.c) / 120;
+  const toneDiff = Math.abs(color1.t - color2.t) / 100;
+  return Math.sqrt(
+    Math.pow(hueDiff * hueWeight, 2) + Math.pow(chromaDiff * chromaWeight, 2) + Math.pow(toneDiff * toneWeight, 2)
+  ) * 100;
+}
+function calculateMatchScore(inputHct, candidate, distance, weights, options) {
+  const perceptualScore = Math.max(0, 100 - distance) / 100;
+  let semanticScore = 0.5;
+  if (options.preferredRole && candidate.role) {
+    semanticScore = candidate.role === options.preferredRole ? 1 : 0.3;
+  } else if (options.contextType) {
+    semanticScore = calculateContextSemanticScore(
+      options.contextType,
+      candidate.role
+    );
+  }
+  let accessibilityScore = 0.5;
+  if (options.contextType === "text") {
+    accessibilityScore = candidate.tone < 30 || candidate.tone > 70 ? 1 : 0.3;
+  } else if (options.contextType === "background") {
+    accessibilityScore = candidate.tone >= 90 || candidate.tone <= 10 ? 1 : 0.5;
+  }
+  return perceptualScore * weights.perceptual + semanticScore * weights.semantic + accessibilityScore * weights.accessibility;
+}
+function findTypicalBackgrounds(theme) {
+  const backgrounds = [];
+  if (theme.surface) {
+    backgrounds.push(
+      ...theme.surface.filter((v) => v.tone >= 90 || v.tone <= 10)
+    );
+  }
+  if (theme.background) {
+    backgrounds.push(...theme.background);
+  }
+  if (theme.neutral) {
+    backgrounds.push(
+      ...theme.neutral.filter((v) => v.tone >= 95 || v.tone <= 5)
+    );
+  }
+  return backgrounds;
+}
+function findTypicalForegrounds(theme) {
+  const foregrounds = [];
+  if (theme.neutral) {
+    foregrounds.push(
+      ...theme.neutral.filter(
+        (v) => v.tone >= 20 && v.tone <= 40 || v.tone >= 60 && v.tone <= 80
+      )
+    );
+  }
+  if (theme.surface) {
+    foregrounds.push(
+      ...theme.surface.filter((v) => v.tone >= 10 && v.tone <= 30)
+    );
+  }
+  return foregrounds;
+}
+function flattenThemeVariables(theme) {
+  const variables = [];
+  if (theme.primary) variables.push(...theme.primary);
+  if (theme.secondary) variables.push(...theme.secondary);
+  if (theme.tertiary) variables.push(...theme.tertiary);
+  if (theme.error) variables.push(...theme.error);
+  if (theme.neutral) variables.push(...theme.neutral);
+  if (theme.surface) variables.push(...theme.surface);
+  if (theme.background) variables.push(...theme.background);
+  if (theme.outline) variables.push(...theme.outline);
+  if (theme.shadow) variables.push(...theme.shadow);
+  if (theme.custom) {
+    for (const customVars of Object.values(theme.custom)) {
+      variables.push(...customVars);
+    }
+  }
+  return variables;
+}
+function parseColorToRgb(color) {
+  color = color.trim();
+  if (color.startsWith("#")) {
+    return hexToRgb(color);
+  }
+  if (color.startsWith("rgb")) {
+    const match = color.match(/rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/);
+    if (match) {
+      return {
+        b: parseInt(match[3], 10) / 255,
+        g: parseInt(match[2], 10) / 255,
+        r: parseInt(match[1], 10) / 255
+      };
+    }
+  }
+  throw new Error(`Unable to parse color: ${color}`);
+}
+
+// src/theme/parser.ts
+function parseThemeVariables(css) {
+  const variables = [];
+  const varRegex = /--([\w-]+):\s*([^;]+);/g;
+  let match;
+  while ((match = varRegex.exec(css)) !== null) {
+    const [, name, value] = match;
+    const fullName = `--${name}`;
+    const trimmedValue = value.trim();
+    if (isColorValue(trimmedValue)) {
+      const colorValue = normalizeColorValue(trimmedValue);
+      if (colorValue) {
+        try {
+          const rgb = parseColorToRgb2(colorValue);
+          const hct = rgbToHct(rgb);
+          variables.push({
+            hct,
+            name: fullName,
+            role: detectSemanticRole(name),
+            tone: hct.t,
+            value: colorValue
+          });
+        } catch {
+          console.warn(
+            `Failed to parse color variable ${fullName}: ${trimmedValue}`
+          );
+        }
+      }
+    }
+  }
+  return organizeByRole(variables);
+}
+function detectSemanticRole(name) {
+  const lower = name.toLowerCase();
+  if (lower.includes("primary")) return "primary";
+  if (lower.includes("secondary")) return "secondary";
+  if (lower.includes("tertiary")) return "tertiary";
+  if (lower.includes("error") || lower.includes("danger")) return "error";
+  if (lower.includes("neutral") || lower.includes("gray")) return "neutral";
+  if (lower.includes("surface")) return "surface";
+  if (lower.includes("background") || lower.includes("bg")) return "background";
+  if (lower.includes("outline") || lower.includes("border")) return "outline";
+  if (lower.includes("shadow")) return "shadow";
+  return void 0;
+}
+function hslToRgb2(h, s, l) {
+  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, g, r };
+}
+function isColorValue(value) {
+  const trimmed = value.trim();
+  if (/^#[0-9a-fA-F]{3,8}$/.test(trimmed)) return true;
+  if (/^rgba?\(/.test(trimmed)) return true;
+  if (/^hsla?\(/.test(trimmed)) return true;
+  if (/^[a-z]+$/i.test(trimmed)) {
+    return isNamedColor(trimmed);
+  }
+  return false;
+}
+function isNamedColor(name) {
+  const namedColors = [
+    "black",
+    "white",
+    "red",
+    "green",
+    "blue",
+    "yellow",
+    "cyan",
+    "magenta",
+    "gray",
+    "grey",
+    "orange",
+    "purple",
+    "brown",
+    "pink",
+    "lime",
+    "navy",
+    "teal",
+    "silver",
+    "gold",
+    "indigo",
+    "violet",
+    "turquoise",
+    "coral"
+  ];
+  return namedColors.includes(name.toLowerCase());
+}
+function namedColorToHex(name) {
+  const colors = {
+    black: "#000000",
+    blue: "#0000ff",
+    brown: "#a52a2a",
+    coral: "#ff7f50",
+    cyan: "#00ffff",
+    gold: "#ffd700",
+    gray: "#808080",
+    green: "#008000",
+    grey: "#808080",
+    indigo: "#4b0082",
+    lime: "#00ff00",
+    magenta: "#ff00ff",
+    navy: "#000080",
+    orange: "#ffa500",
+    pink: "#ffc0cb",
+    purple: "#800080",
+    red: "#ff0000",
+    silver: "#c0c0c0",
+    teal: "#008080",
+    turquoise: "#40e0d0",
+    violet: "#ee82ee",
+    white: "#ffffff",
+    yellow: "#ffff00"
+  };
+  return colors[name.toLowerCase()] || "#000000";
+}
+function normalizeColorValue(value) {
+  const trimmed = value.trim();
+  if (/^#[0-9a-fA-F]{6}$/.test(trimmed)) {
+    return trimmed;
+  }
+  if (/^#[0-9a-fA-F]{3}$/.test(trimmed)) {
+    const [, r, g, b] = trimmed.match(/#(.)(.)(.)/);
+    return `#${r}${r}${g}${g}${b}${b}`;
+  }
+  if (/^rgba?\(/.test(trimmed)) {
+    return parseRgbString(trimmed);
+  }
+  if (/^hsla?\(/.test(trimmed)) {
+    return parseHslString(trimmed);
+  }
+  if (isNamedColor(trimmed)) {
+    return namedColorToHex(trimmed);
+  }
+  return null;
+}
+function organizeByRole(variables) {
+  const organized = {
+    custom: {}
+  };
+  for (const variable of variables) {
+    if (variable.role) {
+      const role = variable.role;
+      if (!organized[role]) {
+        organized[role] = [];
+      }
+      organized[role].push(variable);
+    } else {
+      const colorPattern = variable.name.match(/--(?:color-)?([a-z]+)-\d+/i);
+      const namedPattern = variable.name.match(/--([a-z]+)-[a-z]+/i);
+      if (colorPattern) {
+        const customRole = colorPattern[1].toLowerCase();
+        if (!organized.custom[customRole]) {
+          organized.custom[customRole] = [];
+        }
+        organized.custom[customRole].push(variable);
+      } else if (namedPattern) {
+        const customRole = namedPattern[1].toLowerCase();
+        const knownPatterns = [
+          "accent",
+          "neutral",
+          "success",
+          "warning",
+          "info"
+        ];
+        if (knownPatterns.some((p) => customRole.includes(p))) {
+          if (!organized.custom[customRole]) {
+            organized.custom[customRole] = [];
+          }
+          organized.custom[customRole].push(variable);
+        } else {
+          if (!organized.custom["uncategorized"]) {
+            organized.custom["uncategorized"] = [];
+          }
+          organized.custom["uncategorized"].push(variable);
+        }
+      } else {
+        if (!organized.custom["uncategorized"]) {
+          organized.custom["uncategorized"] = [];
+        }
+        organized.custom["uncategorized"].push(variable);
+      }
+    }
+  }
+  for (const role of Object.keys(organized)) {
+    if (Array.isArray(organized[role])) {
+      organized[role].sort(
+        (a, b) => a.tone - b.tone
+      );
+    } else if (role === "custom" && organized.custom) {
+      for (const customRole of Object.keys(organized.custom)) {
+        organized.custom[customRole].sort((a, b) => a.tone - b.tone);
+      }
+    }
+  }
+  return organized;
+}
+function parseColorToRgb2(color) {
+  if (color.startsWith("#")) {
+    return hexToRgb(color);
+  }
+  if (color.startsWith("rgb")) {
+    const match = color.match(/rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)/);
+    if (match) {
+      return {
+        b: parseInt(match[3], 10) / 255,
+        g: parseInt(match[2], 10) / 255,
+        r: parseInt(match[1], 10) / 255
+      };
+    }
+  }
+  throw new Error(`Unable to parse color: ${color}`);
+}
+function parseHslString(hsl) {
+  const match = hsl.match(/hsla?\((\d+),\s*(\d+)%,\s*(\d+)%/);
+  if (match) {
+    const h = parseInt(match[1], 10) / 360;
+    const s = parseInt(match[2], 10) / 100;
+    const l = parseInt(match[3], 10) / 100;
+    const rgb = hslToRgb2(h, s, l);
+    const r = Math.round(rgb.r * 255);
+    const g = Math.round(rgb.g * 255);
+    const b = Math.round(rgb.b * 255);
+    return `#${((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1)}`;
+  }
+  return null;
+}
+function parseRgbString(rgb) {
+  const match = rgb.match(/rgba?\((\d+),\s*(\d+),\s*(\d+)/);
+  if (match) {
+    const r = parseInt(match[1], 10);
+    const g = parseInt(match[2], 10);
+    const b = parseInt(match[3], 10);
+    return `#${((1 << 24) + (r << 16) + (g << 8) + b).toString(16).slice(1)}`;
+  }
+  return null;
+}
+
+// src/theme/refactor.ts
+var PROPERTY_CONTEXT_MAP = {
+  background: "background",
+  "background-color": "background",
+  border: "border",
+  "border-bottom-color": "border",
+  "border-color": "border",
+  "border-left-color": "border",
+  "border-right-color": "border",
+  "border-top-color": "border",
+  "box-shadow": "shadow",
+  color: "text",
+  fill: "decorative",
+  outline: "border",
+  "outline-color": "border",
+  "stop-color": "decorative",
+  stroke: "border",
+  "text-shadow": "shadow"
+};
+function generateRefactoringReport(result) {
+  const lines = [
+    "# CSS Refactoring Report",
+    "",
+    "## Summary",
+    `- Total colors found: ${result.statistics.totalColors}`,
+    `- Colors replaced: ${result.statistics.replacedColors}`,
+    `- Replacement rate: ${Math.round(result.statistics.replacedColors / result.statistics.totalColors * 100)}%`,
+    `- Average confidence: ${result.statistics.averageConfidence}%`,
+    `- Accessibility issues: ${result.statistics.accessibilityIssues}`,
+    "",
+    "## Replacements"
+  ];
+  const highConfidence = result.replacements.filter((r) => r.confidence >= 90);
+  const mediumConfidence = result.replacements.filter(
+    (r) => r.confidence >= 70 && r.confidence < 90
+  );
+  const lowConfidence = result.replacements.filter((r) => r.confidence < 70);
+  if (highConfidence.length > 0) {
+    lines.push("", "### High Confidence (\u226590%)");
+    for (const replacement of highConfidence) {
+      lines.push(
+        `- Line ${replacement.line}: ${replacement.originalColor} \u2192 ${replacement.cssVariable} (${replacement.confidence}%)`
+      );
+    }
+  }
+  if (mediumConfidence.length > 0) {
+    lines.push("", "### Medium Confidence (70-89%)");
+    for (const replacement of mediumConfidence) {
+      lines.push(
+        `- Line ${replacement.line}: ${replacement.originalColor} \u2192 ${replacement.cssVariable} (${replacement.confidence}%)`
+      );
+    }
+  }
+  if (lowConfidence.length > 0) {
+    lines.push("", "### Low Confidence (<70%)");
+    for (const replacement of lowConfidence) {
+      lines.push(
+        `- Line ${replacement.line}: ${replacement.originalColor} \u2192 ${replacement.cssVariable} (${replacement.confidence}%)`
+      );
+    }
+  }
+  if (result.warnings.length > 0) {
+    lines.push("", "## Warnings");
+    const warningsByType = result.warnings.reduce(
+      (acc, warning) => {
+        if (!acc[warning.type]) acc[warning.type] = [];
+        acc[warning.type].push(warning);
+        return acc;
+      },
+      {}
+    );
+    for (const [type, warnings] of Object.entries(warningsByType)) {
+      lines.push("", `### ${formatWarningType(type)}`);
+      for (const warning of warnings) {
+        lines.push(`- ${warning.message}`);
+        if (warning.suggestion) {
+          lines.push(`  Suggestion: ${warning.suggestion}`);
+        }
+      }
+    }
+  }
+  return lines.join("\n");
+}
+function refactorCss(css, themeVariables, options = {}) {
+  const {
+    addComments = true,
+    minConfidence = 70,
+    preserveOriginal = true
+  } = options;
+  const replacements = [];
+  const warnings = [];
+  let refactoredCss = css;
+  let totalColors = 0;
+  let replacedColors = 0;
+  let totalConfidence = 0;
+  let accessibilityIssues = 0;
+  const lines = css.split("\n");
+  const refactoredLines = [];
+  for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+    const line = lines[lineIndex];
+    let refactoredLine = line;
+    const propertyMatch = line.match(/^\s*([a-z-]+):\s*/i);
+    const property = propertyMatch ? propertyMatch[1].toLowerCase() : null;
+    const context = property ? PROPERTY_CONTEXT_MAP[property] : void 0;
+    const colorMatches = findColorsInLine(line);
+    for (const colorMatch of colorMatches) {
+      totalColors++;
+      const { color, end, start } = colorMatch;
+      const matchOptions = {
+        contextType: context,
+        weights: {
+          accessibility: context === "text" || context === "background" ? 0.3 : 0.1,
+          perceptual: 0.6,
+          semantic: context ? 0.3 : 0.2
+        }
+      };
+      const match = findClosestThemeColor(color, themeVariables, matchOptions);
+      if (match && match.confidence >= minConfidence) {
+        replacedColors++;
+        totalConfidence += match.confidence;
+        const replacement = {
+          column: start,
+          confidence: match.confidence,
+          context,
+          cssVariable: match.variable,
+          line: lineIndex + 1,
+          originalColor: color,
+          property: property || void 0
+        };
+        replacements.push(replacement);
+        if (match.accessibilityInfo && !match.accessibilityInfo.meetsAA) {
+          accessibilityIssues++;
+          warnings.push({
+            location: { column: start, line: lineIndex + 1 },
+            message: `Color ${color} replaced with ${match.variable} may have accessibility issues`,
+            type: "accessibility"
+          });
+        }
+        let replacementText = `var(${match.variable})`;
+        if (preserveOriginal && addComments) {
+          replacementText = `/* ${color} */ ${replacementText}`;
+        }
+        refactoredLine = refactoredLine.substring(0, start) + replacementText + refactoredLine.substring(end);
+      } else if (match && match.confidence < minConfidence) {
+        warnings.push({
+          location: { column: start, line: lineIndex + 1 },
+          message: `Low confidence match for ${color}: ${match.variable} (${match.confidence}%)`,
+          suggestion: `Consider using ${match.variable} or defining a new theme variable`,
+          type: "low-confidence"
+        });
+      } else {
+        warnings.push({
+          location: { column: start, line: lineIndex + 1 },
+          message: `No suitable theme variable found for ${color}`,
+          suggestion: "Consider adding this color to your theme",
+          type: "no-match"
+        });
+      }
+    }
+    refactoredLines.push(refactoredLine);
+  }
+  if (addComments && replacedColors > 0) {
+    const summaryComment = `/* CSS Refactored with Theme Variables
+ * Total colors found: ${totalColors}
+ * Colors replaced: ${replacedColors}
+ * Average confidence: ${Math.round(totalConfidence / replacedColors)}%
+ * Warnings: ${warnings.length}
+ */
+
+`;
+    refactoredCss = summaryComment + refactoredLines.join("\n");
+  } else {
+    refactoredCss = refactoredLines.join("\n");
+  }
+  return {
+    original: css,
+    refactored: refactoredCss,
+    replacements,
+    statistics: {
+      accessibilityIssues,
+      averageConfidence: replacedColors > 0 ? Math.round(totalConfidence / replacedColors) : 0,
+      replacedColors,
+      totalColors
+    },
+    warnings
+  };
+}
+function findColorsInLine(line) {
+  const colors = [];
+  let match;
+  const hexRegex = /#[0-9a-fA-F]{3,8}/g;
+  while ((match = hexRegex.exec(line)) !== null) {
+    colors.push({
+      color: match[0],
+      end: match.index + match[0].length,
+      start: match.index
+    });
+  }
+  const rgbRegex = /rgba?\(\s*\d+\s*,\s*\d+\s*,\s*\d+(?:\s*,\s*[\d.]+)?\s*\)/g;
+  while ((match = rgbRegex.exec(line)) !== null) {
+    colors.push({
+      color: match[0],
+      end: match.index + match[0].length,
+      start: match.index
+    });
+  }
+  const hslRegex = /hsla?\([^)]+\)/g;
+  while ((match = hslRegex.exec(line)) !== null) {
+    colors.push({
+      color: match[0],
+      end: match.index + match[0].length,
+      start: match.index
+    });
+  }
+  colors.sort((a, b) => a.start - b.start);
+  const uniqueColors = [];
+  let lastEnd = -1;
+  for (const color of colors) {
+    if (color.start >= lastEnd) {
+      uniqueColors.push(color);
+      lastEnd = color.end;
+    }
+  }
+  return uniqueColors;
+}
+function formatWarningType(type) {
+  const formats = {
+    accessibility: "Accessibility Concerns",
+    "low-confidence": "Low Confidence Matches",
+    "no-match": "No Matches Found",
+    "semantic-mismatch": "Semantic Mismatches"
+  };
+  return formats[type] || type;
+}
+
+// src/tools/theme-matching.tools.ts
+var matchThemeColorTool = {
+  description: "Find the closest matching theme variable for a given color",
+  execute: async (args) => {
+    const themeVariables = parseThemeVariables(args.themeCSS);
+    const match = findClosestThemeColor(args.color, themeVariables, {
+      contextType: args.context
+    });
+    if (!match) {
+      return "No matching theme variable found";
+    }
+    const minConfidence = args.minConfidence ?? 70;
+    if (match.confidence < minConfidence) {
+      return `Best match below confidence threshold:
+Variable: ${match.variable}
+Distance: ${match.distance.toFixed(2)}
+Confidence: ${match.confidence}%
+
+Consider adding a new theme variable for this color.`;
+    }
+    let result = `Best Match:
+Variable: ${match.variable}
+Value: ${match.value}
+Distance: ${match.distance.toFixed(2)}
+Confidence: ${match.confidence}%`;
+    if (match.semanticRole) {
+      result += `
+Semantic Role: ${match.semanticRole}`;
+    }
+    if (match.accessibilityInfo) {
+      result += `
+
+Accessibility:
+Contrast with background: ${match.accessibilityInfo.contrastWithBackground.toFixed(2)}
+Contrast with foreground: ${match.accessibilityInfo.contrastWithForeground.toFixed(2)}
+Meets AA: ${match.accessibilityInfo.meetsAA ? "Yes" : "No"}
+Meets AAA: ${match.accessibilityInfo.meetsAAA ? "Yes" : "No"}`;
+    }
+    if (match.alternatives.length > 0) {
+      result += `
+
+Alternatives:`;
+      for (const alt of match.alternatives) {
+        result += `
+- ${alt.variable} (confidence: ${alt.confidence}%)`;
+      }
+    }
+    return result;
+  },
+  name: "match_theme_color",
+  parameters: z9.object({
+    color: z9.string().describe("Color to match (hex, rgb, hsl)"),
+    context: z9.enum(["text", "background", "border", "shadow", "accent", "decorative"]).optional().describe("Usage context for better matching"),
+    minConfidence: z9.number().min(0).max(100).optional().default(70).describe("Minimum confidence threshold (0-100)"),
+    themeCSS: z9.string().describe("CSS containing theme variables")
+  })
+};
+var refactorCssWithThemeTool = {
+  description: "Refactor CSS to use theme variables instead of hardcoded colors",
+  execute: async (args) => {
+    const themeVariables = parseThemeVariables(args.themeCSS);
+    const result = refactorCss(args.css, themeVariables, {
+      addComments: args.preserveOriginal ?? true,
+      minConfidence: args.minConfidence ?? 70,
+      preserveOriginal: args.preserveOriginal ?? true
+    });
+    let output = `Refactoring Complete!
+
+Statistics:
+- Total colors found: ${result.statistics.totalColors}
+- Colors replaced: ${result.statistics.replacedColors}
+- Average confidence: ${result.statistics.averageConfidence}%
+- Accessibility issues: ${result.statistics.accessibilityIssues}
+
+Refactored CSS:
+----------------------------------------
+${result.refactored}
+----------------------------------------`;
+    if (result.warnings.length > 0) {
+      output += `
+
+Warnings (${result.warnings.length}):`;
+      for (const warning of result.warnings.slice(0, 5)) {
+        output += `
+- ${warning.message}`;
+        if (warning.suggestion) {
+          output += `
+  Suggestion: ${warning.suggestion}`;
+        }
+      }
+      if (result.warnings.length > 5) {
+        output += `
+... and ${result.warnings.length - 5} more warnings`;
+      }
+    }
+    if (args.generateReport) {
+      output += `
+
+${generateRefactoringReport(result)}`;
+    }
+    return output;
+  },
+  name: "refactor_css_with_theme",
+  parameters: z9.object({
+    css: z9.string().describe("CSS content to refactor"),
+    generateReport: z9.boolean().optional().default(false).describe("Generate detailed refactoring report"),
+    minConfidence: z9.number().min(0).max(100).optional().default(70).describe("Minimum confidence for replacements"),
+    preserveOriginal: z9.boolean().optional().default(true).describe("Keep original values as comments"),
+    themeCSS: z9.string().describe("CSS containing theme variables")
+  })
+};
+var matchThemeColorsBatchTool = {
+  description: "Find theme matches for multiple colors at once",
+  execute: async (args) => {
+    const themeVariables = parseThemeVariables(args.themeCSS);
+    const matches = findBatchMatches(args.colors, themeVariables, {
+      contextType: args.context
+    });
+    let result = `Theme Color Matches:
+`;
+    let matchCount = 0;
+    let totalConfidence = 0;
+    for (const [color, match] of matches.entries()) {
+      if (match) {
+        matchCount++;
+        totalConfidence += match.confidence;
+        result += `
+${color} \u2192 ${match.variable} (${match.confidence}%)`;
+      } else {
+        result += `
+${color} \u2192 No match found`;
+      }
+    }
+    result += `
+
+Summary:
+- Matched: ${matchCount}/${args.colors.length}
+- Average confidence: ${matchCount > 0 ? Math.round(totalConfidence / matchCount) : 0}%`;
+    return result;
+  },
+  name: "match_theme_colors_batch",
+  parameters: z9.object({
+    colors: z9.array(z9.string()).min(1).max(50).describe("Array of colors to match"),
+    context: z9.enum(["text", "background", "border", "shadow", "accent", "decorative"]).optional().describe("Usage context for all colors"),
+    themeCSS: z9.string().describe("CSS containing theme variables")
+  })
+};
+var generateThemeCssTool = {
+  description: "Generate CSS custom properties for a complete theme from a source color",
+  execute: async (args) => {
+    const source = parseColor(args.sourceColor);
+    if (!source) {
+      return `Invalid color format: ${args.sourceColor}`;
+    }
+    const corePalette = corePaletteFromRgb(source);
+    const tones = args.includeTones || [
+      0,
+      10,
+      20,
+      30,
+      40,
+      50,
+      60,
+      70,
+      80,
+      90,
+      95,
+      99,
+      100
+    ];
+    const prefix = args.prefix || "color";
+    let css = `:root {
+`;
+    css += `  /* Primary Colors */
+`;
+    for (const tone of tones) {
+      const color = rgbToHex(corePalette.primary.tone(tone));
+      css += `  --${prefix}-primary-${tone}: ${color};
+`;
+    }
+    css += `
+  /* Secondary Colors */
+`;
+    for (const tone of tones) {
+      const color = rgbToHex(corePalette.secondary.tone(tone));
+      css += `  --${prefix}-secondary-${tone}: ${color};
+`;
+    }
+    css += `
+  /* Tertiary Colors */
+`;
+    for (const tone of tones) {
+      const color = rgbToHex(corePalette.tertiary.tone(tone));
+      css += `  --${prefix}-tertiary-${tone}: ${color};
+`;
+    }
+    css += `
+  /* Error Colors */
+`;
+    for (const tone of tones) {
+      const color = rgbToHex(corePalette.error.tone(tone));
+      css += `  --${prefix}-error-${tone}: ${color};
+`;
+    }
+    css += `
+  /* Neutral Colors */
+`;
+    for (const tone of tones) {
+      const color = rgbToHex(corePalette.neutral.tone(tone));
+      css += `  --${prefix}-neutral-${tone}: ${color};
+`;
+    }
+    css += `
+  /* Neutral Variant Colors */
+`;
+    for (const tone of tones) {
+      const color = rgbToHex(corePalette.neutralVariant.tone(tone));
+      css += `  --${prefix}-neutral-variant-${tone}: ${color};
+`;
+    }
+    css += `}
+
+`;
+    css += `/* Semantic Color Mappings (Light Theme) */
+`;
+    css += `:root {
+`;
+    css += `  --${prefix}-primary: var(--${prefix}-primary-40);
+`;
+    css += `  --${prefix}-on-primary: var(--${prefix}-primary-100);
+`;
+    css += `  --${prefix}-primary-container: var(--${prefix}-primary-90);
+`;
+    css += `  --${prefix}-on-primary-container: var(--${prefix}-primary-10);
+`;
+    css += `  
+`;
+    css += `  --${prefix}-secondary: var(--${prefix}-secondary-40);
+`;
+    css += `  --${prefix}-on-secondary: var(--${prefix}-secondary-100);
+`;
+    css += `  --${prefix}-secondary-container: var(--${prefix}-secondary-90);
+`;
+    css += `  --${prefix}-on-secondary-container: var(--${prefix}-secondary-10);
+`;
+    css += `  
+`;
+    css += `  --${prefix}-background: var(--${prefix}-neutral-99);
+`;
+    css += `  --${prefix}-on-background: var(--${prefix}-neutral-10);
+`;
+    css += `  --${prefix}-surface: var(--${prefix}-neutral-99);
+`;
+    css += `  --${prefix}-on-surface: var(--${prefix}-neutral-10);
+`;
+    css += `}
+`;
+    return css;
+  },
+  name: "generate_theme_css",
+  parameters: z9.object({
+    includeTones: z9.array(z9.number()).optional().describe(
+      "Tone values to include (default: 0,10,20,30,40,50,60,70,80,90,95,99,100)"
+    ),
+    prefix: z9.string().optional().default("color").describe(
+      "Prefix for CSS variables (e.g., 'color' \u2192 --color-primary-50)"
+    ),
+    sourceColor: z9.string().describe("Source color for theme generation")
+  })
+};
+
+// src/bin/server.ts
+var server = new CoolorsMcp({
+  instructions: "Advanced color operations server with Material Design 3 support, CSS theme matching, image extraction, and accessibility compliance. Uses HCT color space for perceptually accurate operations.",
+  name: "coolors-mcp",
+  version: "1.0.0"
+});
+server.addTool(colorConversionTool);
+server.addTool(colorDistanceTool);
+server.addTool(contrastCheckerTool);
+server.addTool(paletteGeneratorTool);
+server.addTool(paletteWithLocksTool);
+server.addTool(gradientGeneratorTool);
+server.addTool(generateMaterialThemeTool);
+server.addTool(harmonizeColorsTool);
+server.addTool(generateTonalPaletteTool);
+server.addTool(matchThemeColorTool);
+server.addTool(refactorCssWithThemeTool);
+server.addTool(matchThemeColorsBatchTool);
+server.addTool(generateThemeCssTool);
+server.addTool(extractImageColorsTool);
+server.addTool(generateThemeFromImageTool);
+server.addTool(analyzeColorLikabilityTool);
+server.addTool(fixDislikedColorsBatchTool);
+server.start().catch((error) => {
+  console.error("Failed to start server:", error);
+  process.exit(1);
+});
+/**
+ * @license
+ * Copyright 2021 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+//# sourceMappingURL=server.js.map