@pixerate/editor 0.238.0 → 0.239.0

package/dist/chunk-S6OT6CTS.cjs

@@ -0,0 +1,936 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+
+
+
+var _chunk7PT4RJL5cjs = require('./chunk-7PT4RJL5.cjs');
+
+
+
+
+var _chunkPPFJHTW5cjs = require('./chunk-PPFJHTW5.cjs');
+
+
+
+var _chunkRD7RX52Gcjs = require('./chunk-RD7RX52G.cjs');
+
+
+
+var _chunk7AHBW2CQcjs = require('./chunk-7AHBW2CQ.cjs');
+
+// 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 = _chunk7PT4RJL5cjs.normalizeDualColor.call(void 0, rawStop.color);
+      if (dual) {
+        normColor = _chunk7PT4RJL5cjs.formatDualColor.call(void 0, 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: _chunk7PT4RJL5cjs.formatDualColor.call(void 0, _nullishCoalesce(_chunk7PT4RJL5cjs.normalizeDualColor.call(void 0, 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 (_chunk7PT4RJL5cjs.isDualColor.call(void 0, 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: _nullishCoalesce(_chunk7PT4RJL5cjs.resolveColor.call(void 0, 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 = _chunk7PT4RJL5cjs.mixColors.call(void 0, s0.color, s1.color, u, { space: _nullishCoalesce(g.interpolation, () => ( "oklab")) });
+  return _nullishCoalesce(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 = _nullishCoalesce(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 = _nullishCoalesce(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 = _nullishCoalesce(_optionalChain([rawArgs, 'access', _ => _[1], 'optionalAccess', _2 => _2.trim, 'call', _3 => _3()]), () => ( ""));
+    }
+  }
+  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 = _nullishCoalesce(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(_nullishCoalesce(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 = _nullishCoalesce(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) || _chunk7PT4RJL5cjs.isDualColor.call(void 0, options.surface) || _chunk7PT4RJL5cjs.isDualColor.call(void 0, options.text);
+  if (dual) {
+    const lightG = resolveGradient(g, "light");
+    const darkG = resolveGradient(g, "dark");
+    const lightText = options.text ? _nullishCoalesce(_chunk7PT4RJL5cjs.resolveColor.call(void 0, options.text, "light"), () => ( void 0)) : void 0;
+    const darkText = options.text ? _nullishCoalesce(_chunk7PT4RJL5cjs.resolveColor.call(void 0, 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 = _chunkRD7RX52Gcjs.parseColor.call(void 0, grad.stops[i].color);
+        const c2 = _chunkRD7RX52Gcjs.parseColor.call(void 0, grad.stops[i + 1].color);
+        if (c1 && c2 && gap < 0.05) {
+          const dE = _chunkPPFJHTW5cjs.deltaEOK.call(void 0, 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 = _chunkRD7RX52Gcjs.parseColor.call(void 0, s.color);
+        if (c && !_chunkPPFJHTW5cjs.inSrgbGamut.call(void 0, c)) {
+          issues2.push(`[${schemeName}] Stop "${s.id}" colour ${s.color} is outside standard sRGB gamut.`);
+        }
+      }
+      let lowest;
+      if (txt) {
+        const parsedTxt = _chunkRD7RX52Gcjs.parseColor.call(void 0, txt);
+        if (parsedTxt) {
+          let minRatio = Infinity;
+          for (let step = 0; step <= 32; step++) {
+            const sample = _chunkRD7RX52Gcjs.parseColor.call(void 0, sampleGradient(grad, step / 32, schemeName));
+            if (sample) {
+              const r = _chunkRD7RX52Gcjs.contrastRatio.call(void 0, 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 = _chunkRD7RX52Gcjs.parseColor.call(void 0, g.stops[i].color);
+    const c2 = _chunkRD7RX52Gcjs.parseColor.call(void 0, g.stops[i + 1].color);
+    if (c1 && c2 && gap < 0.05) {
+      const dE = _chunkPPFJHTW5cjs.deltaEOK.call(void 0, 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 = _chunkRD7RX52Gcjs.parseColor.call(void 0, s.color);
+    if (c && !_chunkPPFJHTW5cjs.inSrgbGamut.call(void 0, c)) {
+      issues.push(`Stop "${s.id}" colour ${s.color} is outside standard sRGB gamut.`);
+    }
+  }
+  let lowestTextContrast;
+  if (options.text) {
+    const parsedTxt = _chunkRD7RX52Gcjs.parseColor.call(void 0, options.text);
+    if (parsedTxt) {
+      let minRatio = Infinity;
+      for (let step = 0; step <= 32; step++) {
+        const sample = _chunkRD7RX52Gcjs.parseColor.call(void 0, sampleGradient(g, step / 32, "light"));
+        if (sample) {
+          const r = _chunkRD7RX52Gcjs.contrastRatio.call(void 0, 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/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);
+}
+
+// src/gradient/sample.ts
+var DEFAULT_TOLERANCE = 0.06;
+function toRgba(color) {
+  if (typeof color === "string") return _chunkRD7RX52Gcjs.parseColor.call(void 0, color);
+  if (Array.isArray(color) && color.length >= 4 && color.slice(0, 4).every((v) => Number.isFinite(v))) {
+    return { r: color[0] / 255, g: color[1] / 255, b: color[2] / 255, a: color[3] / 255 };
+  }
+  return null;
+}
+var dist = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2], (a[3] - b[3]) * 0.5);
+function lerpAt(a, b, t) {
+  const u = b.t - a.t > 1e-9 ? (t - a.t) / (b.t - a.t) : 0;
+  return [0, 1, 2, 3].map((k) => a.v[k] + (b.v[k] - a.v[k]) * u);
+}
+function worst(samples, i0, i1) {
+  let index = -1;
+  let error = 0;
+  for (let i = i0 + 1; i < i1; i++) {
+    const e = dist(samples[i].v, lerpAt(samples[i0], samples[i1], samples[i].t));
+    if (e > error) {
+      error = e;
+      index = i;
+    }
+  }
+  return { index, error };
+}
+function maxErrorOf(samples, at) {
+  let e = 0;
+  for (let k = 0; k + 1 < at.length; k++) e = Math.max(e, worst(samples, at[k], at[k + 1]).error);
+  return e;
+}
+function fitGradientStops(samples, options = {}) {
+  const tolerance = _nullishCoalesce(options.tolerance, () => ( DEFAULT_TOLERANCE));
+  if (!(tolerance > 0 && tolerance <= 1)) throw new Error(`tolerance ${tolerance} is out of range; use a \u0394E above 0 and at most 1 (0.02 is a just-noticeable step).`);
+  const minStops = Math.max(2, Math.floor(_nullishCoalesce(options.minStops, () => ( 2))));
+  const maxStops = Math.floor(_nullishCoalesce(options.maxStops, () => ( Math.max(5, minStops))));
+  if (!(maxStops >= minStops)) throw new Error(`maxStops ${options.maxStops} is below minStops ${minStops}.`);
+  const smoothing = Math.max(0, Math.floor(_nullishCoalesce(options.smoothing, () => ( 2))));
+  const raw = [];
+  for (const s of samples) {
+    if (!s || !Number.isFinite(s.offset)) continue;
+    const c = toRgba(s.color);
+    if (!c) continue;
+    const lab2 = _chunk7AHBW2CQcjs.rgbToOklab.call(void 0, { ...c, a: _nullishCoalesce(c.a, () => ( 1)) });
+    raw.push({ t: Math.min(1, Math.max(0, s.offset)), v: [lab2.l, lab2.a, lab2.b, _nullishCoalesce(c.a, () => ( 1))] });
+  }
+  if (raw.length < 2) throw new Error(`Need at least two readable samples to make a gradient; got ${raw.length}.`);
+  raw.sort((a, b) => a.t - b.t);
+  const lab = raw.map((s, i) => {
+    const r = Math.min(smoothing, i, raw.length - 1 - i);
+    const v = [0, 0, 0, 0];
+    for (let j = i - r; j <= i + r; j++) for (let k = 0; k < 4; k++) v[k] += raw[j].v[k] / (2 * r + 1);
+    return { t: s.t, v };
+  });
+  const at = [0, lab.length - 1];
+  while (at.length < maxStops) {
+    let best = { index: -1, error: 0 };
+    for (let k = 0; k + 1 < at.length; k++) {
+      const w = worst(lab, at[k], at[k + 1]);
+      if (w.error > best.error) best = w;
+    }
+    if (best.index < 0 && at.length < minStops) {
+      let k = 0;
+      for (let j = 1; j + 1 < at.length; j++) if (at[j + 1] - at[j] > at[k + 1] - at[k]) k = j;
+      if (at[k + 1] - at[k] > 1) best = { index: at[k] + at[k + 1] >> 1, error: 0 };
+    }
+    if (best.index < 0 || best.error <= tolerance && at.length >= minStops) break;
+    at.push(best.index);
+    at.sort((a, b) => a - b);
+  }
+  for (let k = 1; k + 1 < at.length && at.length > minStops; ) {
+    if (worst(lab, at[k - 1], at[k + 1]).error <= tolerance) at.splice(k, 1);
+    else k++;
+  }
+  const stops = at.map((i, k) => {
+    const [l, a, b, alpha] = lab[i].v;
+    const color = _chunkPPFJHTW5cjs.formatHex.call(void 0, _chunk7AHBW2CQcjs.oklabToRgb.call(void 0, { l, a, b, alpha: Math.min(1, Math.max(0, alpha)) }));
+    return { id: `s${k + 1}`, offset: k === 0 ? 0 : k === at.length - 1 ? 1 : Math.round(lab[i].t * 1e3) / 1e3, color };
+  });
+  return { stops, maxError: Math.round(maxErrorOf(lab, at) * 1e4) / 1e4 };
+}
+function simplifyGradientStops(samples, options) {
+  return fitGradientStops(samples, options).stops;
+}
+function sampleGradientFromLine(readPixel, start, end, options = {}) {
+  const count = Math.floor(_nullishCoalesce(options.sampleCount, () => ( 32)));
+  if (!(count >= 2 && count <= 1024)) throw new Error(`sampleCount ${options.sampleCount} is out of range; use 2..1024.`);
+  if (![start.x, start.y, end.x, end.y].every(Number.isFinite)) throw new Error("start and end need finite x and y.");
+  const length = Math.hypot(end.x - start.x, end.y - start.y);
+  if (length < 1e-9) throw new Error("start and end are the same point; drag a line to sample along.");
+  const angle = angleFromPointer(start, end, options.snapStep);
+  const to = options.snapStep ? { x: start.x + Math.sin(angle * Math.PI / 180) * length, y: start.y - Math.cos(angle * Math.PI / 180) * length } : end;
+  const samples = [];
+  for (let i = 0; i < count; i++) {
+    const t = i / (count - 1);
+    const color = readPixel({ x: start.x + (to.x - start.x) * t, y: start.y + (to.y - start.y) * t });
+    if (color !== null && color !== void 0) samples.push({ offset: t, color });
+  }
+  if (samples.length < 2) return null;
+  const { stops } = fitGradientStops(samples, options);
+  const res = normalizeGradient({ type: "linear", angle, stops, interpolation: "oklab" });
+  if ("error" in res) throw new Error(res.error);
+  return res.gradient;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.gradientMidpointRemap = gradientMidpointRemap; exports.normalizeGradient = normalizeGradient; exports.createGradient = createGradient; exports.isDualColorValue = isDualColorValue; exports.isDualGradient = isDualGradient; exports.resolveGradient = resolveGradient; exports.sampleGradient = sampleGradient; exports.insertGradientStop = insertGradientStop; exports.updateGradientStop = updateGradientStop; exports.removeGradientStop = removeGradientStop; exports.reverseGradient = reverseGradient; exports.distributeGradientStops = distributeGradientStops; exports.gradientToCss = gradientToCss; exports.gradientToCssFallback = gradientToCssFallback; exports.parseCssGradient = parseCssGradient; exports.gradientToSvgDef = gradientToSvgDef; exports.checkGradient = checkGradient; exports.GRADIENT_PRESETS = GRADIENT_PRESETS; exports.stopFromTrackPosition = stopFromTrackPosition; exports.trackPositionFromStop = trackPositionFromStop; exports.gradientKeyStep = gradientKeyStep; exports.angleFromPointer = angleFromPointer; exports.gradientTrackBackground = gradientTrackBackground; exports.fitGradientStops = fitGradientStops; exports.simplifyGradientStops = simplifyGradientStops; exports.sampleGradientFromLine = sampleGradientFromLine;