@holoscript/core 8.0.8 → 8.0.9

package/dist/chunk-UCVZXQ63.js

@@ -0,0 +1,724 @@
+import { __esm } from './chunk-W4GABFCR.js';
+
+// src/color/perceptualColor.ts
+function srgbToLinearChannel(c) {
+  return c <= 0.04045 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+}
+function linearToSrgbChannel(c) {
+  return c <= 31308e-7 ? 12.92 * c : 1.055 * Math.pow(c, 1 / 2.4) - 0.055;
+}
+function srgbToLinear([r, g, b]) {
+  return [srgbToLinearChannel(r), srgbToLinearChannel(g), srgbToLinearChannel(b)];
+}
+function linearToSrgb([r, g, b]) {
+  return [linearToSrgbChannel(r), linearToSrgbChannel(g), linearToSrgbChannel(b)];
+}
+function linearRgbToXyz([r, g, b]) {
+  const x = (0.4124564 * r + 0.3575761 * g + 0.1804375 * b) * 100;
+  const y = (0.2126729 * r + 0.7151522 * g + 0.072175 * b) * 100;
+  const z = (0.0193339 * r + 0.119192 * g + 0.9503041 * b) * 100;
+  return [x, y, z];
+}
+function xyzToLinearRgb([x, y, z]) {
+  const xs = x / 100;
+  const ys = y / 100;
+  const zs = z / 100;
+  const r = 3.2404542 * xs - 1.5371385 * ys - 0.4985314 * zs;
+  const g = -0.969266 * xs + 1.8760108 * ys + 0.041556 * zs;
+  const b = 0.0556434 * xs - 0.2040259 * ys + 1.0572252 * zs;
+  return [r, g, b];
+}
+function labF(t) {
+  return t > LAB_EPS ? Math.cbrt(t) : (LAB_KAPPA * t + 16) / 116;
+}
+function labFInv(t) {
+  const t3 = t * t * t;
+  return t3 > LAB_EPS ? t3 : (116 * t - 16) / LAB_KAPPA;
+}
+function xyzToLab([x, y, z]) {
+  const fx = labF(x / Xn);
+  const fy = labF(y / Yn);
+  const fz = labF(z / Zn);
+  return { L: 116 * fy - 16, a: 500 * (fx - fy), b: 200 * (fy - fz) };
+}
+function labToXyz({ L, a, b }) {
+  const fy = (L + 16) / 116;
+  const fx = fy + a / 500;
+  const fz = fy - b / 200;
+  return [Xn * labFInv(fx), Yn * labFInv(fy), Zn * labFInv(fz)];
+}
+function srgbToLab(rgb) {
+  return xyzToLab(linearRgbToXyz(srgbToLinear(rgb)));
+}
+function labToSrgb(lab) {
+  return linearToSrgb(xyzToLinearRgb(labToXyz(lab)));
+}
+function deltaE2000(lab1, lab2) {
+  const { L: L1, a: a1, b: b1 } = lab1;
+  const { L: L2, a: a2, b: b2 } = lab2;
+  const C1 = Math.hypot(a1, b1);
+  const C2 = Math.hypot(a2, b2);
+  const Cbar = (C1 + C2) / 2;
+  const Cbar7 = Math.pow(Cbar, 7);
+  const G = 0.5 * (1 - Math.sqrt(Cbar7 / (Cbar7 + 6103515625)));
+  const a1p = (1 + G) * a1;
+  const a2p = (1 + G) * a2;
+  const C1p = Math.hypot(a1p, b1);
+  const C2p = Math.hypot(a2p, b2);
+  const h1p = hueAngleDeg(a1p, b1);
+  const h2p = hueAngleDeg(a2p, b2);
+  const dLp = L2 - L1;
+  const dCp = C2p - C1p;
+  let dhp;
+  if (C1p * C2p === 0) {
+    dhp = 0;
+  } else if (Math.abs(h2p - h1p) <= 180) {
+    dhp = h2p - h1p;
+  } else if (h2p - h1p > 180) {
+    dhp = h2p - h1p - 360;
+  } else {
+    dhp = h2p - h1p + 360;
+  }
+  const dHp = 2 * Math.sqrt(C1p * C2p) * Math.sin(dhp * DEG2RAD / 2);
+  const Lbarp = (L1 + L2) / 2;
+  const Cbarp = (C1p + C2p) / 2;
+  let hbarp;
+  if (C1p * C2p === 0) {
+    hbarp = h1p + h2p;
+  } else if (Math.abs(h1p - h2p) <= 180) {
+    hbarp = (h1p + h2p) / 2;
+  } else if (h1p + h2p < 360) {
+    hbarp = (h1p + h2p + 360) / 2;
+  } else {
+    hbarp = (h1p + h2p - 360) / 2;
+  }
+  const T = 1 - 0.17 * Math.cos((hbarp - 30) * DEG2RAD) + 0.24 * Math.cos(2 * hbarp * DEG2RAD) + 0.32 * Math.cos((3 * hbarp + 6) * DEG2RAD) - 0.2 * Math.cos((4 * hbarp - 63) * DEG2RAD);
+  const dTheta = 30 * Math.exp(-(((hbarp - 275) / 25) ** 2));
+  const Cbarp7 = Math.pow(Cbarp, 7);
+  const Rc = 2 * Math.sqrt(Cbarp7 / (Cbarp7 + 6103515625));
+  const Lbarp50sq = (Lbarp - 50) ** 2;
+  const Sl = 1 + 0.015 * Lbarp50sq / Math.sqrt(20 + Lbarp50sq);
+  const Sc = 1 + 0.045 * Cbarp;
+  const Sh = 1 + 0.015 * Cbarp * T;
+  const Rt = -Math.sin(2 * dTheta * DEG2RAD) * Rc;
+  const dL = dLp / Sl;
+  const dC = dCp / Sc;
+  const dH = dHp / Sh;
+  return Math.sqrt(dL * dL + dC * dC + dH * dH + Rt * dC * dH);
+}
+function hueAngleDeg(a, b) {
+  if (a === 0 && b === 0) return 0;
+  const deg = Math.atan2(b, a) * RAD2DEG;
+  return deg >= 0 ? deg : deg + 360;
+}
+function dampen(x, tau = DEFAULT_DAMPENING) {
+  if (!isFinite(tau)) return x;
+  return tau * Math.log1p(x / tau);
+}
+function arcLengthDeltaE2000(A, B, steps = 24) {
+  const n = Math.max(1, Math.floor(steps));
+  let total = 0;
+  let prev = A;
+  for (let i = 1; i <= n; i++) {
+    const t = i / n;
+    const cur = {
+      L: A.L + (B.L - A.L) * t,
+      a: A.a + (B.a - A.a) * t,
+      b: A.b + (B.b - A.b) * t
+    };
+    total += deltaE2000(prev, cur);
+    prev = cur;
+  }
+  return total;
+}
+function offsetLab(c, offsets) {
+  return { L: c.L + offsets[0], a: c.a + offsets[1], b: c.b + offsets[2] };
+}
+function squaredDeltaAtOffset(center, offsets) {
+  const d = deltaE2000(center, offsetLab(center, offsets));
+  return d * d;
+}
+function clampLabPoint(c) {
+  return {
+    L: Math.min(100, Math.max(0, c.L)),
+    a: Math.min(200, Math.max(-200, c.a)),
+    b: Math.min(200, Math.max(-200, c.b))
+  };
+}
+function interpolateLab(A, B, t) {
+  return {
+    L: A.L + (B.L - A.L) * t,
+    a: A.a + (B.a - A.a) * t,
+    b: A.b + (B.b - A.b) * t
+  };
+}
+function labDelta(A, B) {
+  return [B.L - A.L, B.a - A.a, B.b - A.b];
+}
+function metricTensorDeltaE2000(center, options = {}) {
+  const epsilon = Math.max(Math.abs(options.epsilon ?? 1e-3), 1e-9);
+  const regularization = Math.max(0, options.regularization ?? 1e-12);
+  const epsilonSq = epsilon * epsilon;
+  const metric = [
+    [0, 0, 0],
+    [0, 0, 0],
+    [0, 0, 0]
+  ];
+  for (let i = 0; i < 3; i++) {
+    const plus = [0, 0, 0];
+    const minus = [0, 0, 0];
+    plus[i] = epsilon;
+    minus[i] = -epsilon;
+    metric[i][i] = (squaredDeltaAtOffset(center, plus) + squaredDeltaAtOffset(center, minus)) / (2 * epsilonSq) + regularization;
+  }
+  for (let i = 0; i < 3; i++) {
+    for (let j = i + 1; j < 3; j++) {
+      const pp = [0, 0, 0];
+      const pm = [0, 0, 0];
+      const mp = [0, 0, 0];
+      const mm = [0, 0, 0];
+      pp[i] = epsilon;
+      pp[j] = epsilon;
+      pm[i] = epsilon;
+      pm[j] = -epsilon;
+      mp[i] = -epsilon;
+      mp[j] = epsilon;
+      mm[i] = -epsilon;
+      mm[j] = -epsilon;
+      const gij = (squaredDeltaAtOffset(center, pp) + squaredDeltaAtOffset(center, mm) - squaredDeltaAtOffset(center, pm) - squaredDeltaAtOffset(center, mp)) / (8 * epsilonSq);
+      metric[i][j] = gij;
+      metric[j][i] = gij;
+    }
+  }
+  return metric;
+}
+function labMetricQuadraticForm(vector, metric) {
+  let total = 0;
+  for (let i = 0; i < 3; i++) {
+    for (let j = 0; j < 3; j++) total += vector[i] * metric[i][j] * vector[j];
+  }
+  return total;
+}
+function metricTensorArcLengthDeltaE2000(A, B, steps = 24, options = {}) {
+  const n = Math.max(1, Math.floor(steps));
+  let total = 0;
+  let prev = A;
+  for (let i = 1; i <= n; i++) {
+    const cur = interpolateLab(A, B, i / n);
+    const mid = interpolateLab(prev, cur, 0.5);
+    const metric = metricTensorDeltaE2000(mid, options);
+    total += Math.sqrt(Math.max(0, labMetricQuadraticForm(labDelta(prev, cur), metric)));
+    prev = cur;
+  }
+  return total;
+}
+function metricSegmentEnergy(A, B, options = {}) {
+  const mid = interpolateLab(A, B, 0.5);
+  const metric = metricTensorDeltaE2000(mid, options);
+  return Math.max(0, labMetricQuadraticForm(labDelta(A, B), metric));
+}
+function metricPathEnergy(path, options) {
+  let total = 0;
+  for (let i = 1; i < path.length; i++) total += metricSegmentEnergy(path[i - 1], path[i], options);
+  return total;
+}
+function metricPathLength(path, options) {
+  let total = 0;
+  for (let i = 1; i < path.length; i++) {
+    total += Math.sqrt(metricSegmentEnergy(path[i - 1], path[i], options));
+  }
+  return total;
+}
+function withCoordinate(c, coordinate, value) {
+  return coordinate === "L" ? { ...c, L: value } : coordinate === "a" ? { ...c, a: value } : { ...c, b: value };
+}
+function perturbPathCoordinate(path, index, coordinate, delta, clamp) {
+  const next = path.slice();
+  const point = path[index];
+  const value = coordinate === "L" ? point.L : coordinate === "a" ? point.a : point.b;
+  const moved = withCoordinate(point, coordinate, value + delta);
+  next[index] = clamp ? clampLabPoint(moved) : moved;
+  return next;
+}
+function solveDeltaE2000Geodesic(A, B, options = {}) {
+  const segments = Math.max(1, Math.floor(options.segments ?? 12));
+  const iterations = Math.max(0, Math.floor(options.iterations ?? 40));
+  const stepSize = Math.max(0, options.stepSize ?? 0.02);
+  const gradientStep = Math.max(1e-6, options.gradientStep ?? 0.05);
+  const maxCoordinateStep = Math.max(0, options.maxCoordinateStep ?? 0.35);
+  const clamp = options.clampLab ?? true;
+  const metricOptions = {
+    epsilon: options.epsilon,
+    regularization: options.regularization
+  };
+  const path = [];
+  for (let i = 0; i <= segments; i++) path.push(interpolateLab(A, B, i / segments));
+  for (let iteration = 0; iteration < iterations; iteration++) {
+    let accepted = 0;
+    for (let i = 1; i < path.length - 1; i++) {
+      const before = metricPathEnergy(path, metricOptions);
+      let candidatePoint = path[i];
+      for (const coordinate of LAB_COORDINATES) {
+        const plus = perturbPathCoordinate(path, i, coordinate, gradientStep, clamp);
+        const minus = perturbPathCoordinate(path, i, coordinate, -gradientStep, clamp);
+        const gradient = (metricPathEnergy(plus, metricOptions) - metricPathEnergy(minus, metricOptions)) / (2 * gradientStep);
+        const rawMove = -stepSize * gradient;
+        const move = Math.min(maxCoordinateStep, Math.max(-maxCoordinateStep, rawMove));
+        const value = coordinate === "L" ? candidatePoint.L : coordinate === "a" ? candidatePoint.a : candidatePoint.b;
+        candidatePoint = withCoordinate(candidatePoint, coordinate, value + move);
+        if (clamp) candidatePoint = clampLabPoint(candidatePoint);
+      }
+      const candidate = path.slice();
+      candidate[i] = candidatePoint;
+      if (metricPathEnergy(candidate, metricOptions) <= before + 1e-12) {
+        path[i] = candidatePoint;
+        accepted++;
+      }
+    }
+    if (accepted === 0) break;
+  }
+  return {
+    path,
+    length: metricPathLength(path, metricOptions),
+    straightLength: metricTensorArcLengthDeltaE2000(A, B, segments, metricOptions),
+    energy: metricPathEnergy(path, metricOptions),
+    iterations
+  };
+}
+function erfApprox(x) {
+  const sign = x < 0 ? -1 : 1;
+  const absX = Math.abs(x);
+  const a1 = 0.254829592;
+  const a2 = -0.284496736;
+  const a3 = 1.421413741;
+  const a4 = -1.453152027;
+  const a5 = 1.061405429;
+  const p = 0.3275911;
+  const t = 1 / (1 + p * absX);
+  const y = 1 - ((((a5 * t + a4) * t + a3) * t + a2) * t + a1) * t * Math.exp(-absX * absX);
+  return sign * y;
+}
+function normalCdf(x) {
+  return 0.5 * (1 + erfApprox(x / Math.SQRT2));
+}
+function clampProbability(p) {
+  return Math.min(1 - 1e-12, Math.max(1e-12, p));
+}
+function lanlGrayChoiceProbability(row, options = {}) {
+  const dampening = options.dampening ?? DEFAULT_DAMPENING;
+  const noise = Math.max(1e-9, Math.abs(options.noise ?? DEFAULT_LANL_GRAY_NOISE));
+  const d1 = Math.abs(row.Ls - row.Lt1);
+  const d2 = Math.abs(row.Ls - row.Lt2);
+  return clampProbability(normalCdf((dampen(d2, dampening) - dampen(d1, dampening)) / noise));
+}
+function lanlGrayNegativeLogLikelihood(rows, options = {}) {
+  let total = 0;
+  for (const row of rows) {
+    if (row.count <= 0) continue;
+    const choseT2 = Math.min(row.count, Math.max(0, row.choseT2));
+    const p = lanlGrayChoiceProbability(row, options);
+    total -= choseT2 * Math.log(p) + (row.count - choseT2) * Math.log(1 - p);
+  }
+  return total;
+}
+function lanlGrayMeanAccuracy(rows, options = {}) {
+  let weightedAccuracy = 0;
+  let totalCount = 0;
+  for (const row of rows) {
+    if (row.count <= 0) continue;
+    const predictedT2 = lanlGrayChoiceProbability(row, options) * row.count;
+    weightedAccuracy += row.count * (1 - Math.abs(row.choseT2 - predictedT2) / row.count);
+    totalCount += row.count;
+  }
+  return totalCount > 0 ? weightedAccuracy / totalCount : 0;
+}
+function fitLanlGrayAchromaticModel(rows, options = {}) {
+  if (rows.length === 0) {
+    throw new Error("fitLanlGrayAchromaticModel requires at least one aggregate row");
+  }
+  const dampeningCandidates = options.dampeningCandidates ?? [
+    10,
+    15,
+    20,
+    30,
+    45,
+    60,
+    90,
+    DAMPENING_OFF
+  ];
+  const noiseCandidates = options.noiseCandidates ?? [4, 6, 8, 10, 12, 15, 20];
+  let best;
+  for (const dampening of dampeningCandidates) {
+    for (const noise of noiseCandidates) {
+      const negativeLogLikelihood = lanlGrayNegativeLogLikelihood(rows, { dampening, noise });
+      if (!best || negativeLogLikelihood < best.negativeLogLikelihood) {
+        best = {
+          dampening,
+          noise,
+          negativeLogLikelihood,
+          meanAccuracy: lanlGrayMeanAccuracy(rows, { dampening, noise }),
+          rows: rows.length
+        };
+      }
+    }
+  }
+  if (!best) {
+    throw new Error("fitLanlGrayAchromaticModel requires at least one dampening and noise candidate");
+  }
+  return best;
+}
+function perceptualDistance(a, b, options = {}) {
+  const { dampening = DEFAULT_DAMPENING, steps = 24 } = options;
+  const g = arcLengthDeltaE2000(srgbToLab(a), srgbToLab(b), steps);
+  return dampen(g, dampening);
+}
+function nearestNeutral(c) {
+  const lab = srgbToLab(c);
+  return labToSrgb({ L: lab.L, a: 0, b: 0 });
+}
+function lightness(c) {
+  return srgbToLab(c).L;
+}
+function chroma(c) {
+  const lab = srgbToLab(c);
+  return Math.hypot(lab.a, lab.b);
+}
+function hue(c) {
+  const lab = srgbToLab(c);
+  return hueAngleDeg(lab.a, lab.b);
+}
+function perceptualLerp(a, b, t) {
+  const la = srgbToLab(a);
+  const lb = srgbToLab(b);
+  const u = Math.min(1, Math.max(0, t));
+  return labToSrgb({
+    L: la.L + (lb.L - la.L) * u,
+    a: la.a + (lb.a - la.a) * u,
+    b: la.b + (lb.b - la.b) * u
+  });
+}
+var DAMPENING_OFF, DEFAULT_DAMPENING, DEFAULT_LANL_GRAY_NOISE, Xn, Yn, Zn, LAB_EPS, LAB_KAPPA, DEG2RAD, RAD2DEG, LAB_COORDINATES;
+var init_perceptualColor = __esm({
+  "src/color/perceptualColor.ts"() {
+    DAMPENING_OFF = Number.POSITIVE_INFINITY;
+    DEFAULT_DAMPENING = 30;
+    DEFAULT_LANL_GRAY_NOISE = 10;
+    Xn = 95.047;
+    Yn = 100;
+    Zn = 108.883;
+    LAB_EPS = 216 / 24389;
+    LAB_KAPPA = 24389 / 27;
+    DEG2RAD = Math.PI / 180;
+    RAD2DEG = 180 / Math.PI;
+    LAB_COORDINATES = ["L", "a", "b"];
+  }
+});
+
+// src/color/reference/lanlGrayAchromatic.ts
+var LANL_GRAY_ACHROMATIC_SOURCE, LANL_GRAY_ACHROMATIC_AGGREGATES;
+var init_lanlGrayAchromatic = __esm({
+  "src/color/reference/lanlGrayAchromatic.ts"() {
+    LANL_GRAY_ACHROMATIC_SOURCE = {
+      repo: "https://github.com/lanl/color",
+      dataUrl: "https://raw.githubusercontent.com/lanl/color/main/Gray_Experiment/data/gray_complete_data_release.csv",
+      path: "Gray_Experiment/data/gray_complete_data_release.csv",
+      sha: "37fe92222edd4e081ed142ce3d7ca7ed40b6e4dc",
+      columns: ["trial", "Ls", "Lt1", "Lt2", "R"],
+      license: "BSD-3-Clause",
+      deposited: "2022-01-28",
+      note: "Compact aggregate fixture sampled from the official LANL achromatic gray-axis response data; the full CSV stays upstream."
+    };
+    LANL_GRAY_ACHROMATIC_AGGREGATES = [
+      { Ls: 30, Lt1: 15, Lt2: 35, count: 287, choseT2: 37 },
+      { Ls: 30, Lt1: 25, Lt2: 45, count: 249, choseT2: 166 },
+      { Ls: 30, Lt1: 12.5, Lt2: 37.5, count: 304, choseT2: 69 },
+      { Ls: 30, Lt1: 22.5, Lt2: 47.5, count: 304, choseT2: 158 },
+      { Ls: 30, Lt1: 10, Lt2: 40, count: 249, choseT2: 74 },
+      { Ls: 30, Lt1: 20, Lt2: 50, count: 249, choseT2: 121 },
+      { Ls: 30, Lt1: 7.5, Lt2: 42.5, count: 299, choseT2: 73 },
+      { Ls: 30, Lt1: 17.5, Lt2: 52.5, count: 299, choseT2: 127 },
+      { Ls: 30, Lt1: 5, Lt2: 45, count: 304, choseT2: 72 },
+      { Ls: 30, Lt1: 15, Lt2: 55, count: 304, choseT2: 123 },
+      { Ls: 30, Lt1: 2.5, Lt2: 47.5, count: 299, choseT2: 62 },
+      { Ls: 30, Lt1: 12.5, Lt2: 57.5, count: 299, choseT2: 126 },
+      { Ls: 30, Lt1: 0, Lt2: 50, count: 287, choseT2: 59 },
+      { Ls: 30, Lt1: 10, Lt2: 60, count: 249, choseT2: 111 },
+      { Ls: 50, Lt1: 35, Lt2: 55, count: 287, choseT2: 51 },
+      { Ls: 50, Lt1: 45, Lt2: 65, count: 249, choseT2: 175 },
+      { Ls: 50, Lt1: 32.5, Lt2: 57.5, count: 299, choseT2: 69 },
+      { Ls: 50, Lt1: 42.5, Lt2: 67.5, count: 299, choseT2: 222 },
+      { Ls: 50, Lt1: 30, Lt2: 60, count: 249, choseT2: 84 },
+      { Ls: 50, Lt1: 40, Lt2: 70, count: 249, choseT2: 179 },
+      { Ls: 50, Lt1: 27.5, Lt2: 62.5, count: 299, choseT2: 80 },
+      { Ls: 50, Lt1: 37.5, Lt2: 72.5, count: 304, choseT2: 198 },
+      { Ls: 50, Lt1: 25, Lt2: 65, count: 299, choseT2: 75 },
+      { Ls: 50, Lt1: 35, Lt2: 75, count: 299, choseT2: 204 },
+      { Ls: 50, Lt1: 22.5, Lt2: 67.5, count: 304, choseT2: 82 },
+      { Ls: 50, Lt1: 32.5, Lt2: 77.5, count: 299, choseT2: 187 },
+      { Ls: 50, Lt1: 20, Lt2: 70, count: 287, choseT2: 57 },
+      { Ls: 50, Lt1: 30, Lt2: 80, count: 249, choseT2: 155 },
+      { Ls: 70, Lt1: 55, Lt2: 75, count: 287, choseT2: 76 },
+      { Ls: 70, Lt1: 65, Lt2: 85, count: 249, choseT2: 192 },
+      { Ls: 70, Lt1: 52.5, Lt2: 77.5, count: 299, choseT2: 115 },
+      { Ls: 70, Lt1: 62.5, Lt2: 87.5, count: 304, choseT2: 239 },
+      { Ls: 70, Lt1: 50, Lt2: 80, count: 249, choseT2: 102 },
+      { Ls: 70, Lt1: 60, Lt2: 90, count: 249, choseT2: 185 },
+      { Ls: 70, Lt1: 47.5, Lt2: 82.5, count: 299, choseT2: 104 },
+      { Ls: 70, Lt1: 57.5, Lt2: 92.5, count: 299, choseT2: 215 },
+      { Ls: 70, Lt1: 45, Lt2: 85, count: 304, choseT2: 126 },
+      { Ls: 70, Lt1: 55, Lt2: 95, count: 304, choseT2: 232 },
+      { Ls: 70, Lt1: 42.5, Lt2: 87.5, count: 299, choseT2: 133 },
+      { Ls: 70, Lt1: 52.5, Lt2: 97.5, count: 304, choseT2: 223 },
+      { Ls: 70, Lt1: 40, Lt2: 90, count: 287, choseT2: 108 },
+      { Ls: 70, Lt1: 50, Lt2: 100, count: 249, choseT2: 173 }
+    ];
+  }
+});
+
+// src/color/index.ts
+var init_color = __esm({
+  "src/color/index.ts"() {
+    init_perceptualColor();
+    init_lanlGrayAchromatic();
+  }
+});
+
+// src/compiler/PerceptualColorPass.ts
+function clamp01(value) {
+  return Math.max(0, Math.min(1, value));
+}
+function clampByte(value) {
+  return Math.max(0, Math.min(255, Math.round(value)));
+}
+function normalizeHexColor(color) {
+  const trimmed = color.trim();
+  const match = /^#?([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/.exec(trimmed);
+  if (!match) {
+    throw new Error(`Unsupported color format: ${color}`);
+  }
+  const hex = match[1];
+  if (hex.length === 3) {
+    return `#${hex.split("").map((c) => c + c).join("")}`.toUpperCase();
+  }
+  return `#${hex}`.toUpperCase();
+}
+function hexToSrgb(color) {
+  const hex = normalizeHexColor(color).slice(1);
+  return [
+    Number.parseInt(hex.slice(0, 2), 16) / 255,
+    Number.parseInt(hex.slice(2, 4), 16) / 255,
+    Number.parseInt(hex.slice(4, 6), 16) / 255
+  ];
+}
+function srgbToHex(rgb) {
+  const [r, g, b] = rgb.map((c) => clampByte(clamp01(c) * 255));
+  return `#${[r, g, b].map((c) => c.toString(16).padStart(2, "0")).join("")}`.toUpperCase();
+}
+function finiteNumber(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+function normalizedStops(stops, warnings) {
+  if (stops.length === 0) {
+    warnings.push("No colors supplied; using viridis fallback.");
+    return normalizedStops(SCIENTIFIC_COLOR_MAPS.viridis, warnings);
+  }
+  const rawStops = stops.map((stop, index) => {
+    if (typeof stop === "string") {
+      return {
+        t: stops.length === 1 ? 0 : index / (stops.length - 1),
+        color: stop
+      };
+    }
+    return stop;
+  });
+  const normalized = [];
+  for (const stop of rawStops) {
+    try {
+      normalized.push({
+        t: clamp01(finiteNumber(stop.t, 0)),
+        color: normalizeHexColor(stop.color)
+      });
+    } catch (error) {
+      warnings.push(error instanceof Error ? error.message : "Invalid color stop skipped.");
+    }
+  }
+  if (normalized.length === 0) {
+    warnings.push("All supplied colors were invalid; using viridis fallback.");
+    return normalizedStops(SCIENTIFIC_COLOR_MAPS.viridis, warnings);
+  }
+  if (normalized.length === 1) {
+    normalized.push({ t: 1, color: normalized[0].color });
+  }
+  normalized.sort((a, b) => a.t - b.t);
+  normalized[0] = { ...normalized[0], t: 0 };
+  normalized[normalized.length - 1] = { ...normalized[normalized.length - 1], t: 1 };
+  return normalized;
+}
+function findSegment(stops, t) {
+  for (let i = 0; i < stops.length - 1; i++) {
+    if (t >= stops[i].t && t <= stops[i + 1].t) {
+      return [stops[i], stops[i + 1]];
+    }
+  }
+  return [stops[stops.length - 2], stops[stops.length - 1]];
+}
+function deltas(colors, options) {
+  const values = [];
+  for (let i = 1; i < colors.length; i++) {
+    values.push(perceptualDistance(hexToSrgb(colors[i - 1]), hexToSrgb(colors[i]), options));
+  }
+  return values;
+}
+function stats(values) {
+  if (values.length === 0) return { minDeltaE: 0, maxDeltaE: 0, meanDeltaE: 0 };
+  const minDeltaE = Math.min(...values);
+  const maxDeltaE = Math.max(...values);
+  const meanDeltaE = values.reduce((sum, value) => sum + value, 0) / values.length;
+  return { minDeltaE, maxDeltaE, meanDeltaE };
+}
+function buildPerceptualGradient(stops, options = {}) {
+  const warnings = [];
+  const normalized = normalizedStops(stops, warnings);
+  const steps = Math.max(2, Math.floor(finiteNumber(options.steps, 7)));
+  const colors = [];
+  const sampledStops = [];
+  for (let i = 0; i < steps; i++) {
+    const t = steps === 1 ? 0 : i / (steps - 1);
+    const [a, b] = findSegment(normalized, t);
+    const localT = b.t === a.t ? 0 : (t - a.t) / (b.t - a.t);
+    const color = t <= 0 ? a.color : t >= 1 ? b.color : srgbToHex(perceptualLerp(hexToSrgb(a.color), hexToSrgb(b.color), localT));
+    colors.push(color);
+    sampledStops.push({ t, color });
+  }
+  const distanceOptions = {
+    dampening: options.dampening ?? DEFAULT_DAMPENING,
+    steps: options.arcSteps ?? 24
+  };
+  const deltaE = deltas(colors, distanceOptions);
+  return {
+    stops: sampledStops,
+    colors,
+    deltaE,
+    ...stats(deltaE)
+  };
+}
+function buildPerceptualPalette(colors, options = {}) {
+  const warnings = [];
+  const normalized = normalizedStops(colors, warnings).map((stop) => stop.color);
+  const distanceOptions = {
+    dampening: options.dampening ?? DEFAULT_DAMPENING,
+    steps: options.arcSteps ?? 24
+  };
+  const pairwiseDeltaE = deltas(normalized, distanceOptions);
+  const neutral = options.neutralAxis === true ? normalized.map((color) => srgbToHex(nearestNeutral(hexToSrgb(color)))) : void 0;
+  return {
+    colors: normalized,
+    pairwiseDeltaE,
+    ...stats(pairwiseDeltaE),
+    nearestNeutral: neutral
+  };
+}
+function resolveColorMap(colorMap, warnings) {
+  if (typeof colorMap === "string") {
+    const key = colorMap.trim().toLowerCase();
+    const stops = SCIENTIFIC_COLOR_MAPS[key];
+    if (stops) return { name: key, stops };
+    warnings.push(`Unknown color map "${colorMap}"; using viridis.`);
+    return { name: "viridis", stops: SCIENTIFIC_COLOR_MAPS.viridis };
+  }
+  if (Array.isArray(colorMap)) {
+    return { name: "custom", stops: colorMap };
+  }
+  return void 0;
+}
+function metricWarnings(result, targetDeltaE) {
+  if (targetDeltaE <= 0) return [];
+  const minDeltaE = result.minDeltaE;
+  if (minDeltaE === 0 || minDeltaE >= targetDeltaE) return [];
+  return [
+    `Minimum adjacent perceptual distance ${minDeltaE.toFixed(2)} is below target ${targetDeltaE}.`
+  ];
+}
+function analyzePerceptualColor(color) {
+  const normalized = normalizeHexColor(color);
+  const rgb = hexToSrgb(normalized);
+  return {
+    color: normalized,
+    lightness: lightness(rgb),
+    chroma: chroma(rgb),
+    hue: hue(rgb),
+    nearestNeutral: srgbToHex(nearestNeutral(rgb))
+  };
+}
+function applyPerceptualColorPass(input) {
+  const warnings = [];
+  const targetDeltaE = finiteNumber(input.targetDeltaE, 8);
+  const options = {
+    steps: input.steps,
+    dampening: input.dampening ?? DEFAULT_DAMPENING,
+    arcSteps: input.arcSteps,
+    neutralAxis: input.neutralAxis
+  };
+  const resolvedMap = resolveColorMap(input.colorMap, warnings);
+  if (resolvedMap) {
+    const gradient2 = buildPerceptualGradient(resolvedMap.stops, options);
+    const colorMap = { name: resolvedMap.name, ...gradient2 };
+    warnings.push(...metricWarnings(gradient2, targetDeltaE));
+    return {
+      algorithm: "perceptual_lerp_delta_e2000",
+      source: "color_map",
+      scientific: input.scientific ?? true,
+      targetDeltaE,
+      dampening: options.dampening ?? DEFAULT_DAMPENING,
+      gradient: gradient2,
+      colorMap,
+      warnings
+    };
+  }
+  if (input.gradient) {
+    const gradient2 = buildPerceptualGradient(input.gradient, options);
+    warnings.push(...metricWarnings(gradient2, targetDeltaE));
+    return {
+      algorithm: "perceptual_lerp_delta_e2000",
+      source: "gradient",
+      scientific: input.scientific ?? false,
+      targetDeltaE,
+      dampening: options.dampening ?? DEFAULT_DAMPENING,
+      gradient: gradient2,
+      warnings
+    };
+  }
+  const palette = buildPerceptualPalette(input.palette ?? SCIENTIFIC_COLOR_MAPS.viridis, options);
+  const shouldSamplePalette = input.steps !== void 0 && input.steps > palette.colors.length;
+  const gradient = shouldSamplePalette ? buildPerceptualGradient(palette.colors, options) : void 0;
+  warnings.push(...metricWarnings(gradient ?? palette, targetDeltaE));
+  return {
+    algorithm: "perceptual_lerp_delta_e2000",
+    source: "palette",
+    scientific: input.scientific ?? false,
+    targetDeltaE,
+    dampening: options.dampening ?? DEFAULT_DAMPENING,
+    palette,
+    gradient,
+    warnings
+  };
+}
+var SCIENTIFIC_COLOR_MAPS;
+var init_PerceptualColorPass = __esm({
+  "src/compiler/PerceptualColorPass.ts"() {
+    init_color();
+    SCIENTIFIC_COLOR_MAPS = {
+      viridis: ["#440154", "#3b528b", "#21918c", "#5ec962", "#fde725"],
+      plasma: ["#0d0887", "#7e03a8", "#cc4778", "#f89540", "#f0f921"],
+      magma: ["#000004", "#3b0f70", "#8c2981", "#de4968", "#fcfdbf"],
+      inferno: ["#000004", "#420a68", "#932667", "#dd513a", "#fcffa4"],
+      cividis: ["#00204c", "#31456b", "#666970", "#a69c75", "#ffe945"],
+      turbo: ["#30123b", "#466be3", "#1bcfd4", "#a4fc3c", "#faba39", "#7a0403"],
+      thermal: ["#102040", "#1f77b4", "#31a354", "#ffbf00", "#d62728"]
+    };
+  }
+});
+
+export { DAMPENING_OFF, DEFAULT_DAMPENING, DEFAULT_LANL_GRAY_NOISE, LANL_GRAY_ACHROMATIC_AGGREGATES, LANL_GRAY_ACHROMATIC_SOURCE, SCIENTIFIC_COLOR_MAPS, analyzePerceptualColor, applyPerceptualColorPass, arcLengthDeltaE2000, buildPerceptualGradient, buildPerceptualPalette, chroma, dampen, deltaE2000, fitLanlGrayAchromaticModel, hexToSrgb, hue, init_PerceptualColorPass, init_color, labMetricQuadraticForm, labToSrgb, labToXyz, lanlGrayChoiceProbability, lanlGrayMeanAccuracy, lanlGrayNegativeLogLikelihood, lightness, linearRgbToXyz, linearToSrgb, linearToSrgbChannel, metricTensorArcLengthDeltaE2000, metricTensorDeltaE2000, nearestNeutral, normalizeHexColor, perceptualDistance, perceptualLerp, solveDeltaE2000Geodesic, srgbToHex, srgbToLab, srgbToLinear, srgbToLinearChannel, xyzToLab, xyzToLinearRgb };
+//# sourceMappingURL=chunk-UCVZXQ63.js.map
+//# sourceMappingURL=chunk-UCVZXQ63.js.map