@pixerate/editor 0.237.0 → 0.239.0

package/dist/gradient/index.js

@@ -1,755 +1,42 @@
+import {
+  GRADIENT_PRESETS,
+  angleFromPointer,
+  checkGradient,
+  createGradient,
+  distributeGradientStops,
+  fitGradientStops,
+  gradientKeyStep,
+  gradientMidpointRemap,
+  gradientToCss,
+  gradientToCssFallback,
+  gradientToSvgDef,
+  gradientTrackBackground,
+  insertGradientStop,
+  isDualColorValue,
+  isDualGradient,
+  normalizeGradient,
+  parseCssGradient,
+  removeGradientStop,
+  resolveGradient,
+  reverseGradient,
+  sampleGradient,
+  sampleGradientFromLine,
+  simplifyGradientStops,
+  stopFromTrackPosition,
+  trackPositionFromStop,
+  updateGradientStop
+} from "../chunk-KMPM5JM5.js";
 import {
   HistoryManager
 } from "../chunk-RNSANXPT.js";
+import "../chunk-BP6KSGVD.js";
+import "../chunk-6ADHGQ73.js";
 import {
-  formatDualColor,
-  isDualColor,
-  mixColors,
-  normalizeDualColor,
-  resolveColor
-} from "../chunk-7272D3K2.js";
-import {
-  deltaEOK,
-  inSrgbGamut
-} from "../chunk-YBAPT7NL.js";
-import {
-  contrastRatio,
-  parseColor
-} from "../chunk-MHLU6GRJ.js";
+  isColor
+} from "../chunk-JEGJP4OW.js";
+import "../chunk-F67XMVDI.js";
 import "../chunk-6ONMQ6WF.js";
 
-// src/gradient/model.ts
-function clamp(v, min, max) {
-  return Math.max(min, Math.min(max, v));
-}
-function gradientMidpointRemap(u, m) {
-  const mid = clamp(m, 0.05, 0.95);
-  if (Math.abs(mid - 0.5) < 1e-6) return u;
-  return u <= mid ? 0.5 * u / mid : 0.5 + 0.5 * (u - mid) / (1 - mid);
-}
-function normalizeGradient(input) {
-  if (typeof input === "string") {
-    const parsed = parseCssGradient(input);
-    if (!parsed) {
-      return { error: `Could not parse CSS gradient: "${input}".` };
-    }
-    return { gradient: parsed };
-  }
-  if (!input || typeof input !== "object") {
-    return { error: "Gradient must be an object." };
-  }
-  const obj = input;
-  const type = obj.type === "radial" || obj.type === "conic" ? obj.type : "linear";
-  if (!Array.isArray(obj.stops)) {
-    return { error: "Gradient stops must be an array." };
-  }
-  if (obj.stops.length < 2) {
-    return { error: `A gradient needs at least 2 stops; it has ${obj.stops.length}.` };
-  }
-  const usedIds = /* @__PURE__ */ new Set();
-  for (const s of obj.stops) {
-    if (s && typeof s === "object" && typeof s.id === "string" && s.id.trim()) {
-      usedIds.add(s.id.trim());
-    }
-  }
-  let nextIdIndex = 1;
-  const getNextId = () => {
-    while (usedIds.has(`s${nextIdIndex}`)) {
-      nextIdIndex++;
-    }
-    const id = `s${nextIdIndex}`;
-    usedIds.add(id);
-    nextIdIndex++;
-    return id;
-  };
-  const stops = [];
-  for (let i = 0; i < obj.stops.length; i++) {
-    const s = obj.stops[i];
-    if (!s || typeof s !== "object") {
-      return { error: `Stop at index ${i} must be an object.` };
-    }
-    const rawStop = s;
-    let normColor = null;
-    if (typeof rawStop.color === "string" || rawStop.color && typeof rawStop.color === "object") {
-      const dual = normalizeDualColor(rawStop.color);
-      if (dual) {
-        normColor = formatDualColor(dual);
-      }
-    }
-    if (!normColor) {
-      return { error: `Stop at index ${i} has an invalid colour.` };
-    }
-    let offset = Number(rawStop.offset);
-    if (!Number.isFinite(offset)) {
-      offset = obj.stops.length === 1 ? 0 : i / (obj.stops.length - 1);
-    }
-    offset = clamp(offset, 0, 1);
-    const id = typeof rawStop.id === "string" && rawStop.id.trim() ? rawStop.id.trim() : getNextId();
-    const stop = {
-      id,
-      offset,
-      color: normColor
-    };
-    if (rawStop.midpoint !== void 0 && rawStop.midpoint !== null) {
-      const m = Number(rawStop.midpoint);
-      if (Number.isFinite(m)) {
-        stop.midpoint = clamp(m, 0.05, 0.95);
-      }
-    }
-    stops.push(stop);
-  }
-  stops.sort((a, b) => a.offset - b.offset);
-  const gradient = {
-    type,
-    stops
-  };
-  if (type === "linear" || type === "conic") {
-    if (obj.angle !== void 0 && Number.isFinite(Number(obj.angle))) {
-      gradient.angle = (Number(obj.angle) % 360 + 360) % 360;
-    } else {
-      gradient.angle = type === "linear" ? 180 : 0;
-    }
-  }
-  if (type === "radial" || type === "conic") {
-    if (obj.center && typeof obj.center === "object") {
-      const cx = Number(obj.center.x);
-      const cy = Number(obj.center.y);
-      gradient.center = {
-        x: Number.isFinite(cx) ? clamp(cx, 0, 1) : 0.5,
-        y: Number.isFinite(cy) ? clamp(cy, 0, 1) : 0.5
-      };
-    } else {
-      gradient.center = { x: 0.5, y: 0.5 };
-    }
-  }
-  if (type === "radial") {
-    gradient.shape = obj.shape === "circle" ? "circle" : "ellipse";
-  }
-  const allowedInterp = ["srgb", "srgb-linear", "oklab", "oklch"];
-  if (obj.interpolation && allowedInterp.includes(obj.interpolation)) {
-    gradient.interpolation = obj.interpolation;
-  } else {
-    gradient.interpolation = "oklab";
-  }
-  if (obj.repeating) {
-    gradient.repeating = true;
-  }
-  return { gradient };
-}
-function createGradient(colorsOrOptions, options) {
-  if (Array.isArray(colorsOrOptions)) {
-    const colors = colorsOrOptions;
-    const resolvedColors = colors.length >= 2 ? colors : colors.length === 1 ? [colors[0], colors[0]] : ["#000000", "#ffffff"];
-    const stops = resolvedColors.map((color, i) => ({
-      id: `s${i + 1}`,
-      offset: i / (resolvedColors.length - 1),
-      color: formatDualColor(normalizeDualColor(color) ?? { light: "#000000", dark: "#000000" })
-    }));
-    const res2 = normalizeGradient({
-      ...options,
-      stops
-    });
-    if ("error" in res2) {
-      throw new Error(res2.error);
-    }
-    return res2.gradient;
-  }
-  if (colorsOrOptions && typeof colorsOrOptions === "object" && !Array.isArray(colorsOrOptions)) {
-    const raw = colorsOrOptions;
-    let stops = raw.stops;
-    if (!stops || stops.length === 0) {
-      stops = [
-        { id: "s1", offset: 0, color: "#000000" },
-        { id: "s2", offset: 1, color: "#ffffff" }
-      ];
-    } else if (typeof stops[0] === "string") {
-      const strStops = stops;
-      stops = strStops.map((color, i) => ({
-        id: `s${i + 1}`,
-        offset: i / (strStops.length - 1),
-        color
-      }));
-    }
-    const res2 = normalizeGradient({
-      ...raw,
-      stops
-    });
-    if ("error" in res2) {
-      throw new Error(res2.error);
-    }
-    return res2.gradient;
-  }
-  const res = normalizeGradient({
-    ...options,
-    stops: [
-      { id: "s1", offset: 0, color: "#000000" },
-      { id: "s2", offset: 1, color: "#ffffff" }
-    ]
-  });
-  if ("error" in res) {
-    throw new Error(res.error);
-  }
-  return res.gradient;
-}
-function isDualColorValue(val) {
-  if (typeof val === "string") {
-    return val.trim().toLowerCase().startsWith("light-dark(");
-  }
-  if (isDualColor(val)) {
-    return val.light !== val.dark;
-  }
-  return false;
-}
-function isDualGradient(g) {
-  return g.stops.some((s) => isDualColorValue(s.color));
-}
-function resolveGradient(g, scheme) {
-  return {
-    ...g,
-    center: g.center ? { ...g.center } : void 0,
-    stops: g.stops.map((s) => ({
-      ...s,
-      color: resolveColor(s.color, scheme) ?? s.color
-    }))
-  };
-}
-function sampleGradient(g, t, scheme = "light") {
-  const resolved = resolveGradient(g, scheme);
-  const clampedT = clamp(t, 0, 1);
-  const stops = resolved.stops;
-  if (clampedT <= stops[0].offset) {
-    return stops[0].color;
-  }
-  if (clampedT >= stops[stops.length - 1].offset) {
-    return stops[stops.length - 1].color;
-  }
-  let i = 0;
-  while (i < stops.length - 1 && stops[i + 1].offset < clampedT) {
-    i++;
-  }
-  const s0 = stops[i];
-  const s1 = stops[i + 1];
-  const span = s1.offset - s0.offset;
-  if (span <= 1e-6) {
-    return s1.color;
-  }
-  let u = (clampedT - s0.offset) / span;
-  if (s0.midpoint !== void 0) {
-    u = gradientMidpointRemap(u, s0.midpoint);
-  }
-  const mixed = mixColors(s0.color, s1.color, u, { space: g.interpolation ?? "oklab" });
-  return mixed ?? s0.color;
-}
-function insertGradientStop(g, offset, color) {
-  const clampedOffset = clamp(offset, 0, 1);
-  const stopColor = color !== void 0 ? color : sampleGradient(g, clampedOffset, "light");
-  const used = new Set(g.stops.map((s) => s.id));
-  let idx = 1;
-  while (used.has(`s${idx}`)) idx++;
-  const id = `s${idx}`;
-  const newStop = {
-    id,
-    offset: clampedOffset,
-    color: stopColor
-  };
-  const stops = [...g.stops, newStop];
-  const res = normalizeGradient({ ...g, stops });
-  if ("error" in res) throw new Error(res.error);
-  const added = res.gradient.stops.find((s) => s.id === id);
-  return { gradient: res.gradient, stop: added };
-}
-function listValidIds(g) {
-  return g.stops.map((s) => `"${s.id}"`).join(", ");
-}
-function updateGradientStop(g, id, patch) {
-  const index = g.stops.findIndex((s) => s.id === id);
-  if (index === -1) {
-    throw new Error(`Stop "${id}" not found. Valid stop IDs are: ${listValidIds(g)}.`);
-  }
-  const stops = g.stops.map((s, i) => i === index ? { ...s, ...patch } : s);
-  const res = normalizeGradient({ ...g, stops });
-  if ("error" in res) throw new Error(res.error);
-  return res.gradient;
-}
-function removeGradientStop(g, id) {
-  if (g.stops.length <= 2) {
-    throw new Error("A gradient needs at least 2 stops; add one with add_gradient_stop before removing this one.");
-  }
-  const index = g.stops.findIndex((s) => s.id === id);
-  if (index === -1) {
-    throw new Error(`Stop "${id}" not found. Valid stop IDs are: ${listValidIds(g)}.`);
-  }
-  const stops = g.stops.filter((s) => s.id !== id);
-  const res = normalizeGradient({ ...g, stops });
-  if ("error" in res) throw new Error(res.error);
-  return res.gradient;
-}
-function reverseGradient(g) {
-  const reversedStops = g.stops.map((s) => ({
-    ...s,
-    offset: Math.round((1 - s.offset) * 1e4) / 1e4,
-    midpoint: s.midpoint !== void 0 ? Math.round((1 - s.midpoint) * 1e4) / 1e4 : void 0
-  }));
-  reversedStops.sort((a, b) => a.offset - b.offset);
-  return {
-    ...g,
-    center: g.center ? { ...g.center } : void 0,
-    stops: reversedStops
-  };
-}
-function distributeGradientStops(g) {
-  const n = g.stops.length;
-  const distributed = g.stops.map((s, i) => ({
-    ...s,
-    offset: Math.round(i / (n - 1) * 1e4) / 1e4
-  }));
-  return {
-    ...g,
-    center: g.center ? { ...g.center } : void 0,
-    stops: distributed
-  };
-}
-function formatPercent(fraction) {
-  const pct = Math.round(fraction * 1e3) / 10;
-  return `${pct}%`;
-}
-function gradientToCss(g) {
-  const prefix = g.repeating ? `repeating-${g.type}-gradient` : `${g.type}-gradient`;
-  const parts = [];
-  const interpPrefix = g.interpolation && g.interpolation !== "srgb" ? `in ${g.interpolation} ` : "";
-  if (g.type === "linear") {
-    const angle = g.angle !== void 0 ? `${g.angle}deg` : "180deg";
-    parts.push(`${interpPrefix}${angle}`.trim());
-  } else if (g.type === "radial") {
-    const shape = g.shape ?? "ellipse";
-    const cx = g.center ? formatPercent(g.center.x) : "50%";
-    const cy = g.center ? formatPercent(g.center.y) : "50%";
-    parts.push(`${interpPrefix}${shape} at ${cx} ${cy}`.trim());
-  } else if (g.type === "conic") {
-    const angle = g.angle !== void 0 ? `from ${g.angle}deg` : "from 0deg";
-    const cx = g.center ? formatPercent(g.center.x) : "50%";
-    const cy = g.center ? formatPercent(g.center.y) : "50%";
-    parts.push(`${interpPrefix}${angle} at ${cx} ${cy}`.trim());
-  }
-  for (let i = 0; i < g.stops.length; i++) {
-    const s = g.stops[i];
-    parts.push(`${s.color} ${formatPercent(s.offset)}`);
-    if (s.midpoint !== void 0 && i < g.stops.length - 1) {
-      const next = g.stops[i + 1];
-      const midOffset = s.offset + (next.offset - s.offset) * s.midpoint;
-      parts.push(formatPercent(midOffset));
-    }
-  }
-  return `${prefix}(${parts.join(", ")})`;
-}
-function gradientToCssFallback(g, steps = 16, scheme = "light") {
-  const prefix = g.repeating ? `repeating-${g.type}-gradient` : `${g.type}-gradient`;
-  const parts = [];
-  if (g.type === "linear") {
-    const angle = g.angle !== void 0 ? `${g.angle}deg` : "180deg";
-    parts.push(angle);
-  } else if (g.type === "radial") {
-    const shape = g.shape ?? "ellipse";
-    const cx = g.center ? formatPercent(g.center.x) : "50%";
-    const cy = g.center ? formatPercent(g.center.y) : "50%";
-    parts.push(`${shape} at ${cx} ${cy}`);
-  } else if (g.type === "conic") {
-    const angle = g.angle !== void 0 ? `from ${g.angle}deg` : "from 0deg";
-    const cx = g.center ? formatPercent(g.center.x) : "50%";
-    const cy = g.center ? formatPercent(g.center.y) : "50%";
-    parts.push(`${angle} at ${cx} ${cy}`);
-  }
-  for (let i = 0; i <= steps; i++) {
-    const t = i / steps;
-    const color = sampleGradient(g, t, scheme);
-    parts.push(`${color} ${formatPercent(t)}`);
-  }
-  return `${prefix}(${parts.join(", ")})`;
-}
-function splitCssArgs(str) {
-  const parts = [];
-  let depth = 0;
-  let current = "";
-  for (let i = 0; i < str.length; i++) {
-    const char = str[i];
-    if (char === "(") depth++;
-    else if (char === ")") depth = Math.max(0, depth - 1);
-    if (char === "," && depth === 0) {
-      if (current.trim()) parts.push(current.trim());
-      current = "";
-    } else {
-      current += char;
-    }
-  }
-  if (current.trim()) parts.push(current.trim());
-  return parts;
-}
-function parseCssAngle(val) {
-  const trimmed = val.trim().toLowerCase();
-  if (trimmed.endsWith("deg")) return parseFloat(trimmed);
-  if (trimmed.endsWith("turn")) return parseFloat(trimmed) * 360;
-  if (trimmed.endsWith("rad")) return parseFloat(trimmed) * 180 / Math.PI;
-  if (trimmed.startsWith("to ")) {
-    const dir = trimmed.slice(3).trim();
-    if (dir === "bottom") return 180;
-    if (dir === "top") return 0;
-    if (dir === "right") return 90;
-    if (dir === "left") return 270;
-    if (dir === "bottom right" || dir === "right bottom") return 135;
-    if (dir === "bottom left" || dir === "left bottom") return 225;
-    if (dir === "top right" || dir === "right top") return 45;
-    if (dir === "top left" || dir === "left top") return 315;
-  }
-  const n = parseFloat(trimmed);
-  return Number.isFinite(n) ? n : 180;
-}
-function parseCssGradient(css) {
-  if (typeof css !== "string") return null;
-  const trimmed = css.trim();
-  const match = trimmed.match(/^(repeating-)?(linear|radial|conic)-gradient\s*\(([\s\S]*)\)$/i);
-  if (!match) return null;
-  const repeating = Boolean(match[1]);
-  const type = match[2].toLowerCase();
-  const body = match[3];
-  const rawArgs = splitCssArgs(body);
-  if (rawArgs.length === 0) return null;
-  let angle = type === "linear" ? 180 : 0;
-  let center = type !== "linear" ? { x: 0.5, y: 0.5 } : void 0;
-  let shape = type === "radial" ? "ellipse" : void 0;
-  let interpolation = "srgb";
-  let stopStartIndex = 0;
-  let first = rawArgs[0].trim();
-  const inMatch = first.match(/^in\s+([a-z0-9-]+)\s*(.*)$/i);
-  if (inMatch) {
-    const space = inMatch[1].toLowerCase();
-    if (space === "oklab" || space === "oklch" || space === "srgb" || space === "srgb-linear") {
-      interpolation = space;
-    }
-    first = inMatch[2].trim();
-    if (!first) {
-      stopStartIndex = 1;
-      first = rawArgs[1]?.trim() ?? "";
-    }
-  }
-  if (first) {
-    if (type === "linear") {
-      if (first.endsWith("deg") || first.endsWith("turn") || first.endsWith("rad") || first.startsWith("to ")) {
-        angle = parseCssAngle(first);
-        stopStartIndex = stopStartIndex === 0 ? 1 : 2;
-      }
-    } else if (type === "radial") {
-      if (first.includes("circle") || first.includes("ellipse") || first.includes("at ")) {
-        if (first.includes("circle")) shape = "circle";
-        if (first.includes("ellipse")) shape = "ellipse";
-        const atIdx = first.indexOf("at ");
-        if (atIdx !== -1) {
-          const posParts = first.slice(atIdx + 3).trim().split(/\s+/);
-          if (posParts[0]) center = { x: parsePos(posParts[0]), y: posParts[1] ? parsePos(posParts[1]) : parsePos(posParts[0]) };
-        }
-        stopStartIndex = stopStartIndex === 0 ? 1 : 2;
-      }
-    } else if (type === "conic") {
-      if (first.includes("from ") || first.includes("at ")) {
-        const fromMatch = first.match(/from\s+([0-9.]+(?:deg|turn|rad)?)/i);
-        if (fromMatch) angle = parseCssAngle(fromMatch[1]);
-        const atIdx = first.indexOf("at ");
-        if (atIdx !== -1) {
-          const posParts = first.slice(atIdx + 3).trim().split(/\s+/);
-          if (posParts[0]) center = { x: parsePos(posParts[0]), y: posParts[1] ? parsePos(posParts[1]) : parsePos(posParts[0]) };
-        }
-        stopStartIndex = stopStartIndex === 0 ? 1 : 2;
-      }
-    }
-  }
-  const stopArgs = rawArgs.slice(stopStartIndex);
-  if (stopArgs.length === 0) return null;
-  const items = [];
-  for (const str of stopArgs) {
-    const s = str.trim();
-    if (/^([0-9.]+)%$/.test(s)) {
-      items.push({ kind: "hint", offset: parseFloat(s) / 100 });
-      continue;
-    }
-    const posMatch = s.match(/\s+([0-9.]+)%$/);
-    if (posMatch) {
-      const colorStr = s.slice(0, posMatch.index).trim();
-      const offset = parseFloat(posMatch[1]) / 100;
-      items.push({ kind: "stop", color: colorStr, offset });
-    } else {
-      items.push({ kind: "stop", color: s });
-    }
-  }
-  const rawStops = items.filter((it) => it.kind === "stop");
-  if (rawStops.length < 2) return null;
-  for (let i = 0; i < rawStops.length; i++) {
-    if (rawStops[i].offset === void 0) {
-      if (i === 0) rawStops[i].offset = 0;
-      else if (i === rawStops.length - 1) rawStops[i].offset = 1;
-      else {
-        let nextIdx = i + 1;
-        while (nextIdx < rawStops.length && rawStops[nextIdx].offset === void 0) {
-          nextIdx++;
-        }
-        const nextOffset = nextIdx < rawStops.length ? rawStops[nextIdx].offset : 1;
-        const prevOffset = rawStops[i - 1].offset ?? 0;
-        const count = nextIdx - (i - 1);
-        for (let k = i; k < nextIdx; k++) {
-          rawStops[k].offset = prevOffset + (k - (i - 1)) / count * (nextOffset - prevOffset);
-        }
-        i = nextIdx - 1;
-      }
-    }
-  }
-  const finalStops = [];
-  let stopIdx = 0;
-  for (let i = 0; i < items.length; i++) {
-    const it = items[i];
-    if (it.kind === "stop") {
-      const stop = {
-        id: `s${stopIdx + 1}`,
-        offset: clamp(it.offset ?? 0, 0, 1),
-        color: it.color
-      };
-      if (i + 1 < items.length && items[i + 1].kind === "hint") {
-        const hintOffset = items[i + 1].offset;
-        const nextStopItem = items.slice(i + 2).find((x) => x.kind === "stop");
-        if (nextStopItem && nextStopItem.offset !== void 0) {
-          const span = nextStopItem.offset - stop.offset;
-          if (span > 0) {
-            stop.midpoint = clamp((hintOffset - stop.offset) / span, 0.05, 0.95);
-          }
-        }
-      }
-      finalStops.push(stop);
-      stopIdx++;
-    }
-  }
-  const res = normalizeGradient({
-    type,
-    angle,
-    center,
-    shape,
-    interpolation,
-    repeating,
-    stops: finalStops
-  });
-  return "gradient" in res ? res.gradient : null;
-}
-function parsePos(str) {
-  const s = str.trim();
-  if (s.endsWith("%")) return clamp(parseFloat(s) / 100, 0, 1);
-  const val = parseFloat(s);
-  return Number.isFinite(val) ? clamp(val, 0, 1) : 0.5;
-}
-function gradientToSvgDef(g, id, scheme = "light") {
-  const steps = 32;
-  const stopsXml = [];
-  for (let i = 0; i <= steps; i++) {
-    const t = i / steps;
-    const color = sampleGradient(g, t, scheme);
-    stopsXml.push(`		<stop offset="${formatPercent(t)}" stop-color="${color}" />`);
-  }
-  if (g.type === "radial") {
-    const cx = g.center ? formatPercent(g.center.x) : "50%";
-    const cy = g.center ? formatPercent(g.center.y) : "50%";
-    const r = g.shape === "circle" ? "50%" : "70.7%";
-    return `<radialGradient id="${id}" cx="${cx}" cy="${cy}" r="${r}">
-${stopsXml.join("\n")}
-</radialGradient>`;
-  }
-  if (g.type === "conic") {
-    return `<!-- Note: SVG does not natively support conic gradients; rendering as linear fallback -->
-<linearGradient id="${id}" x1="0%" y1="0%" x2="100%" y2="0%">
-${stopsXml.join("\n")}
-</linearGradient>`;
-  }
-  const angle = g.angle ?? 180;
-  const rad = (90 - angle) * Math.PI / 180;
-  const dx = Math.cos(rad);
-  const dy = -Math.sin(rad);
-  const x1 = formatPercent(0.5 - dx * 0.5);
-  const y1 = formatPercent(0.5 - dy * 0.5);
-  const x2 = formatPercent(0.5 + dx * 0.5);
-  const y2 = formatPercent(0.5 + dy * 0.5);
-  return `<linearGradient id="${id}" x1="${x1}" y1="${y1}" x2="${x2}" y2="${y2}">
-${stopsXml.join("\n")}
-</linearGradient>`;
-}
-function checkGradient(g, options = {}) {
-  const dual = isDualGradient(g) || isDualColor(options.surface) || isDualColor(options.text);
-  if (dual) {
-    const lightG = resolveGradient(g, "light");
-    const darkG = resolveGradient(g, "dark");
-    const lightText = options.text ? resolveColor(options.text, "light") ?? void 0 : void 0;
-    const darkText = options.text ? resolveColor(options.text, "dark") ?? void 0 : void 0;
-    const checkScheme = (grad, txt, schemeName) => {
-      const issues2 = [];
-      for (let i = 0; i < grad.stops.length - 1; i++) {
-        const gap = grad.stops[i + 1].offset - grad.stops[i].offset;
-        if (gap < 5e-3) {
-          issues2.push(`[${schemeName}] Stops "${grad.stops[i].id}" and "${grad.stops[i + 1].id}" are too close (gap < 0.005).`);
-        }
-        const c1 = parseColor(grad.stops[i].color);
-        const c2 = parseColor(grad.stops[i + 1].color);
-        if (c1 && c2 && gap < 0.05) {
-          const dE = deltaEOK(c1, c2);
-          if (dE > 0.5) {
-            issues2.push(
-              `[${schemeName}] Banding risk between stops "${grad.stops[i].id}" and "${grad.stops[i + 1].id}" (\u0394EOK = ${dE.toFixed(2)} across gap ${gap.toFixed(3)}).`
-            );
-          }
-        }
-      }
-      for (const s of grad.stops) {
-        const c = parseColor(s.color);
-        if (c && !inSrgbGamut(c)) {
-          issues2.push(`[${schemeName}] Stop "${s.id}" colour ${s.color} is outside standard sRGB gamut.`);
-        }
-      }
-      let lowest;
-      if (txt) {
-        const parsedTxt = parseColor(txt);
-        if (parsedTxt) {
-          let minRatio = Infinity;
-          for (let step = 0; step <= 32; step++) {
-            const sample = parseColor(sampleGradient(grad, step / 32, schemeName));
-            if (sample) {
-              const r = contrastRatio(parsedTxt, sample);
-              if (r < minRatio) minRatio = r;
-            }
-          }
-          lowest = Math.round(minRatio * 100) / 100;
-        }
-      }
-      return { issues: issues2, lowest };
-    };
-    const lRes = checkScheme(lightG, lightText, "light");
-    const dRes = checkScheme(darkG, darkText, "dark");
-    return {
-      issues: [...lRes.issues, ...dRes.issues],
-      lowestTextContrast: lRes.lowest !== void 0 && dRes.lowest !== void 0 ? { light: lRes.lowest, dark: dRes.lowest } : void 0
-    };
-  }
-  const issues = [];
-  for (let i = 0; i < g.stops.length - 1; i++) {
-    const gap = g.stops[i + 1].offset - g.stops[i].offset;
-    if (gap < 5e-3) {
-      issues.push(`Stops "${g.stops[i].id}" and "${g.stops[i + 1].id}" are too close (gap < 0.005).`);
-    }
-    const c1 = parseColor(g.stops[i].color);
-    const c2 = parseColor(g.stops[i + 1].color);
-    if (c1 && c2 && gap < 0.05) {
-      const dE = deltaEOK(c1, c2);
-      if (dE > 0.5) {
-        issues.push(
-          `Banding risk between stops "${g.stops[i].id}" and "${g.stops[i + 1].id}" (\u0394EOK = ${dE.toFixed(2)} across gap ${gap.toFixed(3)}).`
-        );
-      }
-    }
-  }
-  for (const s of g.stops) {
-    const c = parseColor(s.color);
-    if (c && !inSrgbGamut(c)) {
-      issues.push(`Stop "${s.id}" colour ${s.color} is outside standard sRGB gamut.`);
-    }
-  }
-  let lowestTextContrast;
-  if (options.text) {
-    const parsedTxt = parseColor(options.text);
-    if (parsedTxt) {
-      let minRatio = Infinity;
-      for (let step = 0; step <= 32; step++) {
-        const sample = parseColor(sampleGradient(g, step / 32, "light"));
-        if (sample) {
-          const r = contrastRatio(parsedTxt, sample);
-          if (r < minRatio) minRatio = r;
-        }
-      }
-      lowestTextContrast = Math.round(minRatio * 100) / 100;
-    }
-  }
-  return { issues, lowestTextContrast };
-}
-var GRADIENT_PRESETS = Object.freeze({
-  sunset: {
-    type: "linear",
-    angle: 90,
-    interpolation: "oklab",
-    stops: [
-      { id: "s1", offset: 0, color: "#f97316" },
-      { id: "s2", offset: 1, color: "#ec4899" }
-    ]
-  },
-  ocean: {
-    type: "linear",
-    angle: 180,
-    interpolation: "oklab",
-    stops: [
-      { id: "s1", offset: 0, color: "#06b6d4" },
-      { id: "s2", offset: 1, color: "#3b82f6" }
-    ]
-  },
-  "mono-fade": {
-    type: "linear",
-    angle: 180,
-    interpolation: "oklab",
-    stops: [
-      { id: "s1", offset: 0, color: "#ffffff" },
-      { id: "s2", offset: 1, color: "#000000" }
-    ]
-  },
-  "transparent-fade": {
-    type: "linear",
-    angle: 180,
-    interpolation: "oklab",
-    stops: [
-      { id: "s1", offset: 0, color: "#000000ff" },
-      { id: "s2", offset: 1, color: "#00000000" }
-    ]
-  },
-  aurora: {
-    type: "linear",
-    angle: 135,
-    interpolation: "oklab",
-    stops: [
-      { id: "s1", offset: 0, color: "#10b981" },
-      { id: "s2", offset: 0.5, color: "#06b6d4" },
-      { id: "s3", offset: 1, color: "#8b5cf6" }
-    ]
-  },
-  neon: {
-    type: "linear",
-    angle: 90,
-    interpolation: "oklab",
-    stops: [
-      { id: "s1", offset: 0, color: "#f43f5e" },
-      { id: "s2", offset: 1, color: "#8b5cf6" }
-    ]
-  },
-  radial: {
-    type: "radial",
-    shape: "ellipse",
-    center: { x: 0.5, y: 0.5 },
-    interpolation: "oklab",
-    stops: [
-      { id: "s1", offset: 0, color: "#ffffff" },
-      { id: "s2", offset: 1, color: "#000000" }
-    ]
-  },
-  conic: {
-    type: "conic",
-    angle: 0,
-    center: { x: 0.5, y: 0.5 },
-    interpolation: "oklab",
-    stops: [
-      { id: "s1", offset: 0, color: "#f43f5e" },
-      { id: "s2", offset: 0.33, color: "#eab308" },
-      { id: "s3", offset: 0.66, color: "#06b6d4" },
-      { id: "s4", offset: 1, color: "#f43f5e" }
-    ]
-  }
-});
-
 // src/gradient/controller.ts
 var GRADIENT_TYPES = ["linear", "radial", "conic"];
 var GRADIENT_INTERPOLATIONS = ["oklab", "oklch", "srgb", "srgb-linear"];
@@ -1431,6 +718,57 @@ function createGradientToolProvider(controller, options = {}) {
           };
         }
       },
+      {
+        name: "set_gradient_from_samples",
+        title: "Set Gradient From Sampled Colours",
+        description: "Fits the fewest stops that reproduce colours sampled along a line (from a photo, painting or shape, e.g. image sample_gradient or your own picks) and makes them the gradient's stops, keeping its type, angle and centre and switching interpolation to oklab. Noise is smoothed first; stops are added where the colour turns most until every sample is within tolerance. One undo step. Returns the gradient, its CSS, the stop count and the largest error left (OKLab \u0394E).",
+        inputSchema: {
+          type: "object",
+          properties: {
+            samples: {
+              type: "array",
+              minItems: 2,
+              maxItems: 1024,
+              description: "Colours in order along the line.",
+              items: {
+                type: "object",
+                properties: {
+                  offset: { type: "number", minimum: 0, maximum: 1, description: "Position along the line, 0..1." },
+                  color: { type: "string", description: "Any CSS colour (hex, rgb(), oklch(), named\u2026)." }
+                },
+                required: ["offset", "color"],
+                additionalProperties: false
+              }
+            },
+            tolerance: { type: "number", exclusiveMinimum: 0, maximum: 1, description: "Largest error left, OKLab \u0394E (default 0.06; 0.02 is a just-noticeable step, lower keeps more stops)." },
+            minStops: { type: "integer", minimum: 2, maximum: 64, description: "Fewest stops (default 2)." },
+            maxStops: { type: "integer", minimum: 2, maximum: 64, description: "Most stops (default 5)." },
+            smoothing: { type: "integer", minimum: 0, maximum: 16, description: "Samples on each side averaged into each one to ignore grain and texture (default 2; 0 fits the raw colours)." }
+          },
+          required: ["samples"],
+          additionalProperties: false
+        },
+        annotations: writeIdempotentTool("Set Gradient From Sampled Colours"),
+        handler: async (args) => {
+          const unreadable = args.samples.findIndex((x) => !isColor(x.color));
+          if (unreadable >= 0) fail(`samples[${unreadable}].color ${JSON.stringify(args.samples[unreadable].color)} is not a CSS colour.`);
+          let fit;
+          try {
+            fit = fitGradientStops(args.samples, {
+              tolerance: args.tolerance,
+              minStops: args.minStops,
+              maxStops: args.maxStops,
+              smoothing: args.smoothing
+            });
+          } catch (e) {
+            return fail(e.message);
+          }
+          const res = controller.setGradient({ ...controller.getGradient(), stops: fit.stops, interpolation: "oklab" }, "Gradient From Samples");
+          if (!res.ok) fail(res.message);
+          const gradient = controller.getGradient();
+          return { gradient, css: gradientToCss(gradient), stopCount: gradient.stops.length, maxError: fit.maxError };
+        }
+      },
       {
         name: "apply_gradient_preset",
         title: "Apply Gradient Preset",
@@ -1472,56 +810,6 @@ function createGradientToolProvider(controller, options = {}) {
     tools: () => tools
   };
 }
-
-// src/gradient/editor.ts
-function stopFromTrackPosition(g, x) {
-  return Math.max(0, Math.min(1, Math.round(x * 1e3) / 1e3));
-}
-function trackPositionFromStop(stop) {
-  return Math.max(0, Math.min(1, stop.offset));
-}
-function gradientKeyStep(g, id, key, shift = false) {
-  const stop = g.stops.find((s) => s.id === id);
-  if (!stop) return null;
-  const step = shift ? 0.1 : 0.01;
-  switch (key) {
-    case "ArrowLeft":
-    case "ArrowDown": {
-      const offset = Math.max(0, Math.round((stop.offset - step) * 1e3) / 1e3);
-      return { stopId: id, offset };
-    }
-    case "ArrowRight":
-    case "ArrowUp": {
-      const offset = Math.min(1, Math.round((stop.offset + step) * 1e3) / 1e3);
-      return { stopId: id, offset };
-    }
-    case "Delete":
-    case "Backspace": {
-      return { stopId: id, remove: true };
-    }
-    default:
-      return null;
-  }
-}
-function angleFromPointer(center, point, snapStep) {
-  const dx = point.x - center.x;
-  const dy = point.y - center.y;
-  let deg = Math.atan2(dx, -dy) * 180 / Math.PI;
-  if (deg < 0) deg += 360;
-  if (snapStep && snapStep > 0) {
-    deg = Math.round(deg / snapStep) * snapStep;
-    if (deg >= 360) deg -= 360;
-  }
-  return Math.round(deg);
-}
-function gradientTrackBackground(g) {
-  const linearCopy = {
-    ...g,
-    type: "linear",
-    angle: 90
-  };
-  return gradientToCss(linearCopy);
-}
 export {
   GRADIENT_INTERPOLATIONS,
   GRADIENT_PRESETS,
@@ -1532,6 +820,7 @@ export {
   createGradient,
   createGradientToolProvider,
   distributeGradientStops,
+  fitGradientStops,
   gradientKeyStep,
   gradientMidpointRemap,
   gradientToCss,
@@ -1547,6 +836,8 @@ export {
   resolveGradient,
   reverseGradient,
   sampleGradient,
+  sampleGradientFromLine,
+  simplifyGradientStops,
   stopFromTrackPosition,
   trackPositionFromStop,
   updateGradientStop