@pixerate/editor 0.22.0 → 0.24.0

package/dist/image-editor/index.cjs

@@ -1,9 +1,1140 @@
-"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 _class; var _class2; var _class3;// src/image-editor/filters.ts
+"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 _class; var _class2; var _class3;
+
+var _chunkD6FH2YAXcjs = require('../chunk-D6FH2YAX.cjs');
+
+// src/image-editor/color.ts
+var LEGACY_PROCESS_VERSION = 1;
+var LATEST_PROCESS_VERSION = 2;
+function normalizeProcessVersion(value) {
+  if (typeof value !== "number" || !Number.isInteger(value)) return LEGACY_PROCESS_VERSION;
+  return value >= LATEST_PROCESS_VERSION ? LATEST_PROCESS_VERSION : LEGACY_PROCESS_VERSION;
+}
+function srgbToLinear(v) {
+  return v <= 0.04045 ? v / 12.92 : Math.pow((v + 0.055) / 1.055, 2.4);
+}
+function linearToSrgb(v) {
+  return v <= 31308e-7 ? v * 12.92 : 1.055 * Math.pow(v, 1 / 2.4) - 0.055;
+}
+var LUMA_709 = [0.2126, 0.7152, 0.0722];
+var IDENTITY_MATRIX3 = [1, 0, 0, 0, 1, 0, 0, 0, 1];
+function mulMatrix3(a, b) {
+  const out = new Array(9).fill(0);
+  for (let r = 0; r < 3; r++) {
+    for (let c = 0; c < 3; c++) {
+      out[r * 3 + c] = a[r * 3] * b[c] + a[r * 3 + 1] * b[3 + c] + a[r * 3 + 2] * b[6 + c];
+    }
+  }
+  return out;
+}
+function applyMatrix3(m, v) {
+  return [
+    m[0] * v[0] + m[1] * v[1] + m[2] * v[2],
+    m[3] * v[0] + m[4] * v[1] + m[5] * v[2],
+    m[6] * v[0] + m[7] * v[1] + m[8] * v[2]
+  ];
+}
+function invertMatrix3(m) {
+  const [a, b, c, d, e, f, g, h, i] = m;
+  const A = e * i - f * h;
+  const B = -(d * i - f * g);
+  const C = d * h - e * g;
+  const det = a * A + b * B + c * C;
+  if (!Number.isFinite(det) || Math.abs(det) < 1e-12) return null;
+  const k = 1 / det;
+  return [
+    A * k,
+    -(b * i - c * h) * k,
+    (b * f - c * e) * k,
+    B * k,
+    (a * i - c * g) * k,
+    -(a * f - c * d) * k,
+    C * k,
+    -(a * h - b * g) * k,
+    (a * e - b * d) * k
+  ];
+}
+function diag3(x, y, z) {
+  return [x, 0, 0, 0, y, 0, 0, 0, z];
+}
+var D65 = { x: 0.3127, y: 0.329 };
+function xyToXyz(p) {
+  return [p.x / p.y, 1, (1 - p.x - p.y) / p.y];
+}
+function xyzToXy(v) {
+  const s = v[0] + v[1] + v[2];
+  return s <= 0 ? { ...D65 } : { x: v[0] / s, y: v[1] / s };
+}
+var SRGB_TO_XYZ = (() => {
+  const p = [{ x: 0.64, y: 0.33 }, { x: 0.3, y: 0.6 }, { x: 0.15, y: 0.06 }].map(xyToXyz);
+  const m = [p[0][0], p[1][0], p[2][0], p[0][1], p[1][1], p[2][1], p[0][2], p[1][2], p[2][2]];
+  const inv = invertMatrix3(m);
+  const s = inv ? applyMatrix3(inv, xyToXyz(D65)) : [1, 1, 1];
+  return mulMatrix3(m, diag3(s[0], s[1], s[2]));
+})();
+var XYZ_TO_SRGB = _nullishCoalesce(invertMatrix3(SRGB_TO_XYZ), () => ( IDENTITY_MATRIX3));
+var BRADFORD = [0.8951, 0.2664, -0.1614, -0.7502, 1.7135, 0.0367, 0.0389, -0.0685, 1.0296];
+var BRADFORD_INV = _nullishCoalesce(invertMatrix3(BRADFORD), () => ( IDENTITY_MATRIX3));
+function bradfordAdaptation(src, dst) {
+  if (src.x === dst.x && src.y === dst.y) return [...IDENTITY_MATRIX3];
+  const s = applyMatrix3(BRADFORD, xyToXyz(src));
+  const d = applyMatrix3(BRADFORD, xyToXyz(dst));
+  return mulMatrix3(BRADFORD_INV, mulMatrix3(diag3(d[0] / s[0], d[1] / s[1], d[2] / s[2]), BRADFORD));
+}
+function wbMatrix(src) {
+  return mulMatrix3(XYZ_TO_SRGB, mulMatrix3(bradfordAdaptation(src, D65), SRGB_TO_XYZ));
+}
+function linearSrgbToXy(rgb) {
+  return xyzToXy(applyMatrix3(SRGB_TO_XYZ, rgb));
+}
+var TINT_SCALE = 3e3;
+var MIN_KELVIN = 1667;
+var MAX_KELVIN = 25e3;
+function kimXy(tIn) {
+  const t = Math.min(MAX_KELVIN, Math.max(MIN_KELVIN, tIn));
+  const t2 = t * t;
+  const t3 = t2 * t;
+  const x = t <= 4e3 ? -266123900 / t3 - 234358.9 / t2 + 877.6956 / t + 0.17991 : -3025846900 / t3 + 21070379e-1 / t2 + 222.6347 / t + 0.24039;
+  const x2 = x * x;
+  const x3 = x2 * x;
+  const y = t <= 2222 ? -1.1063814 * x3 - 1.3481102 * x2 + 2.18555832 * x - 0.20219683 : t <= 4e3 ? -0.9549476 * x3 - 1.37418593 * x2 + 2.09137015 * x - 0.16748867 : 3.081758 * x3 - 5.8733867 * x2 + 3.75112997 * x - 0.37001483;
+  return { x, y };
+}
+function xyToUv(p) {
+  const d = -2 * p.x + 12 * p.y + 3;
+  return [4 * p.x / d, 6 * p.y / d];
+}
+function uvToXy(u, v) {
+  const d = 2 * u - 8 * v + 4;
+  return { x: 3 * u / d, y: 2 * v / d };
+}
+function locusUv(tIn) {
+  const t = Math.max(1e3, tIn);
+  if (t >= MIN_KELVIN && t <= MAX_KELVIN) return xyToUv(kimXy(t));
+  const [a, b] = t < MIN_KELVIN ? [MIN_KELVIN, MIN_KELVIN + 50] : [MAX_KELVIN - 500, MAX_KELVIN];
+  const [ua, va] = xyToUv(kimXy(a));
+  const [ub, vb] = xyToUv(kimXy(b));
+  const ma = 1e6 / a;
+  const mb = 1e6 / b;
+  const s = (1e6 / t - ma) / (mb - ma);
+  return [ua + (ub - ua) * s, va + (vb - va) * s];
+}
+function locusNormal(t) {
+  const m = 1e6 / t;
+  const [u0, v0] = locusUv(1e6 / (m + 1));
+  const [u1, v1] = locusUv(1e6 / Math.max(m - 1, 1));
+  const du = u1 - u0;
+  const dv = v1 - v0;
+  const l = Math.max(Math.hypot(du, dv), 1e-12);
+  const nx = -dv / l;
+  const ny = du / l;
+  return ny < 0 ? [-nx, -ny] : [nx, ny];
+}
+function tempTintToXy(kelvin, tint) {
+  const [u, v] = locusUv(kelvin);
+  const [nu, nv] = locusNormal(kelvin);
+  const duv = tint / TINT_SCALE;
+  return uvToXy(u + nu * duv, v + nv * duv);
+}
+function xyToTempTint(p) {
+  const [u, v] = xyToUv(p);
+  const dist = (m) => {
+    const [lu2, lv2] = locusUv(1e6 / m);
+    return (u - lu2) ** 2 + (v - lv2) ** 2;
+  };
+  let best = 20;
+  let bd = Infinity;
+  for (let m = 20; m <= 1e3; m += 5) {
+    const d = dist(m);
+    if (d < bd) {
+      bd = d;
+      best = m;
+    }
+  }
+  let a = Math.max(best - 5, 20);
+  let b = Math.min(best + 5, 1e3);
+  const g = 0.61803398875;
+  for (let i = 0; i < 60; i++) {
+    const c = b - g * (b - a);
+    const d = a + g * (b - a);
+    if (dist(c) < dist(d)) b = d;
+    else a = c;
+  }
+  const kelvin = 1e6 / ((a + b) / 2);
+  const [lu, lv] = locusUv(kelvin);
+  const [nu, nv] = locusNormal(kelvin);
+  const duv = (u - lu) * nu + (v - lv) * nv;
+  return { kelvin, tint: duv * TINT_SCALE };
+}
+var AS_SHOT_KELVIN = 6500;
+var MIRED_PER_TEMPERATURE_UNIT = 1;
+var AS_SHOT_MIRED = 1e6 / AS_SHOT_KELVIN;
+function temperatureToKelvin(temperature) {
+  return 1e6 / (AS_SHOT_MIRED - temperature * MIRED_PER_TEMPERATURE_UNIT);
+}
+function kelvinToTemperature(kelvin) {
+  return (AS_SHOT_MIRED - 1e6 / kelvin) / MIRED_PER_TEMPERATURE_UNIT;
+}
+var AS_SHOT_WB_INV = _nullishCoalesce(invertMatrix3(wbMatrix(tempTintToXy(AS_SHOT_KELVIN, 0))), () => ( IDENTITY_MATRIX3));
+function whiteBalanceMatrix(temperature, tint = 0) {
+  if (!temperature && !tint) return [...IDENTITY_MATRIX3];
+  const set = wbMatrix(tempTintToXy(temperatureToKelvin(temperature), tint));
+  const m = mulMatrix3(set, AS_SHOT_WB_INV);
+  const g = applyMatrix3(m, [1, 1, 1]);
+  const y = g[0] * LUMA_709[0] + g[1] * LUMA_709[1] + g[2] * LUMA_709[2];
+  return mulMatrix3(m, diag3(1 / y, 1 / y, 1 / y));
+}
+function whiteBalanceFromSample(rgb) {
+  const [r, g, b] = Array.isArray(rgb) ? rgb : [rgb.r, rgb.g, rgb.b];
+  const lin = [r, g, b].map((c) => srgbToLinear(Math.min(255, Math.max(0, c)) / 255));
+  if (lin[0] + lin[1] + lin[2] <= 1e-6) return { temperature: 0, tint: 0 };
+  const src = linearSrgbToXy(applyMatrix3(AS_SHOT_WB_INV, lin));
+  const { kelvin, tint } = xyToTempTint(src);
+  const clamp2 = (v) => Math.max(-100, Math.min(100, v));
+  return { temperature: clamp2(kelvinToTemperature(kelvin)), tint: clamp2(tint) };
+}
+var TONE_LUT_SIZE = 4096;
+var GREY = 0.18;
+var GREY_P = Math.pow(GREY, 1 / 2.2);
+var SHOULDER_KNEE = 0.6;
+function toneCurve(y, contrast, brightness, headroom = 1) {
+  if (!(y > 0)) return 0;
+  const h = Math.max(1, headroom);
+  let o = Math.min(y, h);
+  if (h > 1 && o > SHOULDER_KNEE) {
+    const span = 1 - SHOULDER_KNEE;
+    const x = (o - SHOULDER_KNEE) / span;
+    const X = (h - SHOULDER_KNEE) / span;
+    o = SHOULDER_KNEE + span * (x * (1 + x / (X * X)) / (1 + x));
+  }
+  if (contrast === 0 && brightness === 0) return Math.min(1, o);
+  let p = Math.pow(Math.min(1, o), 1 / 2.2);
+  const c = contrast / 100;
+  if (c !== 0) {
+    p += c * 0.4 * (p - GREY_P) * (1 - (2 * p - 1) ** 2);
+  }
+  const b = brightness / 100;
+  if (b !== 0) {
+    p += b * 0.8 * p * (1 - p);
+  }
+  return Math.pow(Math.min(1, Math.max(0, p)), 2.2);
+}
+function buildToneLut(contrast, brightness, headroom = 1) {
+  const h = Math.max(1, headroom);
+  const lut = new Float32Array(TONE_LUT_SIZE + 1);
+  for (let i = 0; i <= TONE_LUT_SIZE; i++) {
+    lut[i] = toneCurve(h * i / TONE_LUT_SIZE, contrast, brightness, h);
+  }
+  return lut;
+}
+function sampleToneLut(lut, headroom, y) {
+  if (!(y > 0)) return lut[0];
+  const n = lut.length - 1;
+  const f = y * n / Math.max(1, headroom);
+  if (f >= n) return lut[n];
+  const i = f | 0;
+  return lut[i] + (lut[i + 1] - lut[i]) * (f - i);
+}
+
+// src/image-editor/blend.ts
+var BLEND_MODES = [
+  { id: "normal", label: "Normal", canvas: "source-over" },
+  { id: "darken", label: "Darken", canvas: "darken" },
+  { id: "multiply", label: "Multiply", canvas: "multiply" },
+  { id: "color-burn", label: "Color Burn", canvas: "color-burn" },
+  { id: "linear-burn", label: "Linear Burn", canvas: null },
+  { id: "darker-color", label: "Darker Color", canvas: null },
+  { id: "lighten", label: "Lighten", canvas: "lighten" },
+  { id: "screen", label: "Screen", canvas: "screen" },
+  { id: "color-dodge", label: "Color Dodge", canvas: "color-dodge" },
+  { id: "linear-dodge", label: "Linear Dodge (Add)", canvas: null },
+  { id: "lighter-color", label: "Lighter Color", canvas: null },
+  { id: "overlay", label: "Overlay", canvas: "overlay" },
+  // Canvas soft-light is the W3C formula, not Photoshop's: use the scalar path.
+  { id: "soft-light", label: "Soft Light", canvas: null },
+  { id: "hard-light", label: "Hard Light", canvas: "hard-light" },
+  { id: "vivid-light", label: "Vivid Light", canvas: null },
+  { id: "linear-light", label: "Linear Light", canvas: null },
+  { id: "pin-light", label: "Pin Light", canvas: null },
+  { id: "hard-mix", label: "Hard Mix", canvas: null },
+  { id: "difference", label: "Difference", canvas: "difference" },
+  { id: "exclusion", label: "Exclusion", canvas: "exclusion" },
+  { id: "subtract", label: "Subtract", canvas: null },
+  { id: "divide", label: "Divide", canvas: null },
+  { id: "hue", label: "Hue", canvas: "hue" },
+  { id: "saturation", label: "Saturation", canvas: "saturation" },
+  { id: "color", label: "Color", canvas: "color" },
+  { id: "luminosity", label: "Luminosity", canvas: "luminosity" }
+];
+var BLEND_INFO = new Map(BLEND_MODES.map((m) => [m.id, m]));
+function isBlendMode(value) {
+  return typeof value === "string" && BLEND_INFO.has(value);
+}
+function normalizeBlendMode(value) {
+  return isBlendMode(value) ? value : "normal";
+}
+function canvasCompositeOperation(mode) {
+  return _nullishCoalesce(_optionalChain([BLEND_INFO, 'access', _2 => _2.get, 'call', _3 => _3(_nullishCoalesce(mode, () => ( "normal"))), 'optionalAccess', _4 => _4.canvas]), () => ( null));
+}
+function isSeparableBlendMode(mode) {
+  return !(mode === "hue" || mode === "saturation" || mode === "color" || mode === "luminosity" || mode === "darker-color" || mode === "lighter-color");
+}
+function colorBurn(cb, cs) {
+  if (cb >= 1) return 1;
+  if (cs <= 0) return 0;
+  return 1 - Math.min(1, (1 - cb) / cs);
+}
+function colorDodge(cb, cs) {
+  if (cb <= 0) return 0;
+  if (cs >= 1) return 1;
+  return Math.min(1, cb / (1 - cs));
+}
+function hardLight(cb, cs) {
+  if (cs <= 0.5) return cb * 2 * cs;
+  const s = 2 * cs - 1;
+  return cb + s - cb * s;
+}
+function softLight(cb, cs) {
+  return cs <= 0.5 ? 2 * cb * cs + cb * cb * (1 - 2 * cs) : 2 * cb * (1 - cs) + Math.sqrt(Math.max(0, cb)) * (2 * cs - 1);
+}
+function vividLightHardMix(cb, cs) {
+  const EDGE = 1e-4;
+  if (cs <= 0.5) {
+    if (cb >= 1 - EDGE) return 1;
+    if (cs <= 0) return 0;
+    return 1 - Math.min(1, (1 - cb) / (2 * cs));
+  }
+  if (cb <= EDGE) return 0;
+  if (cs >= 1) return 1;
+  return Math.min(1, cb / (2 * (1 - cs)));
+}
+function blendChannel(mode, cb, cs) {
+  switch (mode) {
+    case "normal":
+      return cs;
+    case "darken":
+      return Math.min(cb, cs);
+    case "multiply":
+      return cb * cs;
+    case "color-burn":
+      return colorBurn(cb, cs);
+    case "linear-burn":
+      return Math.max(0, cb + cs - 1);
+    case "lighten":
+      return Math.max(cb, cs);
+    case "screen":
+      return cb + cs - cb * cs;
+    case "color-dodge":
+      return colorDodge(cb, cs);
+    case "linear-dodge":
+      return Math.min(1, cb + cs);
+    case "overlay":
+      return hardLight(cs, cb);
+    case "soft-light":
+      return softLight(cb, cs);
+    case "hard-light":
+      return hardLight(cb, cs);
+    case "vivid-light":
+      if (cs <= 0) return 0;
+      if (cs >= 1) return 1;
+      return cs <= 0.5 ? colorBurn(cb, 2 * cs) : colorDodge(cb, 2 * (cs - 0.5));
+    case "linear-light":
+      return Math.min(1, Math.max(0, cb + 2 * cs - 1));
+    case "pin-light":
+      return cs <= 0.5 ? Math.min(cb, 2 * cs) : Math.max(cb, 2 * cs - 1);
+    case "hard-mix":
+      return vividLightHardMix(cb, cs) >= 0.5 - 1e-6 ? 1 : 0;
+    case "difference":
+      return Math.abs(cb - cs);
+    case "exclusion":
+      return cb + cs - 2 * cb * cs;
+    case "subtract":
+      return Math.max(0, cb - cs);
+    case "divide":
+      if (cs <= 0) return cb <= 0 ? 0 : 1;
+      return Math.min(1, cb / cs);
+    default:
+      return cs;
+  }
+}
+function blendLum(c) {
+  return 0.3 * c[0] + 0.59 * c[1] + 0.11 * c[2];
+}
+function clipColor(c) {
+  const l = blendLum(c);
+  const n = Math.min(c[0], c[1], c[2]);
+  const x = Math.max(c[0], c[1], c[2]);
+  let out = [c[0], c[1], c[2]];
+  if (n < 0) {
+    const d = l - n;
+    out = out.map((v) => l > 0 && d > 0 ? l + (v - l) * l / d : l);
+  }
+  if (x > 1) {
+    const d = x - l;
+    out = out.map((v) => l < 1 && d > 0 ? l + (v - l) * (1 - l) / d : l);
+  }
+  return out;
+}
+function setLum(c, l) {
+  const d = l - blendLum(c);
+  return clipColor([c[0] + d, c[1] + d, c[2] + d]);
+}
+function sat(c) {
+  return Math.max(c[0], c[1], c[2]) - Math.min(c[0], c[1], c[2]);
+}
+function setSat(c, s) {
+  const idx = [0, 1, 2].sort((a, b) => c[a] - c[b]);
+  const [imin, imid, imax] = idx;
+  const out = [0, 0, 0];
+  if (c[imax] > c[imin]) {
+    out[imid] = (c[imid] - c[imin]) * s / (c[imax] - c[imin]);
+    out[imax] = s;
+  }
+  out[imin] = 0;
+  return out;
+}
+function blendRgb(mode, cb, cs) {
+  switch (mode) {
+    case "hue":
+      return setLum(setSat(cs, sat(cb)), blendLum(cb));
+    case "saturation":
+      return setLum(setSat(cb, sat(cs)), blendLum(cb));
+    case "color":
+      return setLum(cs, blendLum(cb));
+    case "luminosity":
+      return setLum(cb, blendLum(cs));
+    case "darker-color":
+      return blendLum(cs) < blendLum(cb) ? [cs[0], cs[1], cs[2]] : [cb[0], cb[1], cb[2]];
+    case "lighter-color":
+      return blendLum(cs) > blendLum(cb) ? [cs[0], cs[1], cs[2]] : [cb[0], cb[1], cb[2]];
+    default:
+      return [blendChannel(mode, cb[0], cs[0]), blendChannel(mode, cb[1], cs[1]), blendChannel(mode, cb[2], cs[2])];
+  }
+}
+function blendPixel(mode, backdrop, source, alpha = 1) {
+  const ab = _nullishCoalesce(backdrop[3], () => ( 1));
+  const as = (_nullishCoalesce(source[3], () => ( 1))) * alpha;
+  if (!(as > 0)) return [backdrop[0], backdrop[1], backdrop[2], ab];
+  const b = blendRgb(mode, backdrop, source);
+  const ao = as + ab * (1 - as);
+  if (ao <= 0) return [0, 0, 0, 0];
+  const out = [0, 0, 0, ao];
+  for (let i = 0; i < 3; i++) {
+    out[i] = ((1 - as) * ab * backdrop[i] + (1 - ab) * as * source[i] + as * ab * b[i]) / ao;
+  }
+  return out;
+}
+function blendImageData(backdrop, source, mode, alpha = 1) {
+  const d = backdrop.data;
+  const s = source.data;
+  const len = Math.min(d.length, s.length);
+  const cb = [0, 0, 0, 0];
+  const cs = [0, 0, 0, 0];
+  for (let i = 0; i < len; i += 4) {
+    if (s[i + 3] === 0) continue;
+    for (let k = 0; k < 4; k++) {
+      cb[k] = d[i + k] / 255;
+      cs[k] = s[i + k] / 255;
+    }
+    const o = blendPixel(mode, cb, cs, alpha);
+    d[i] = Math.round(o[0] * 255);
+    d[i + 1] = Math.round(o[1] * 255);
+    d[i + 2] = Math.round(o[2] * 255);
+    d[i + 3] = Math.round(o[3] * 255);
+  }
+}
+
+// src/image-editor/adjustment-layers.ts
+var ADJUSTMENT_LUT_SIZE = 4096;
+var clamp01 = (v) => v <= 0 ? 0 : v >= 1 ? 1 : v;
+var finite = (v, fallback) => typeof v === "number" && Number.isFinite(v) ? v : fallback;
+var clampTo = (v, lo, hi, fallback) => Math.min(hi, Math.max(lo, finite(v, fallback)));
+var remEuclid = (a, b) => (a % b + b) % b;
+function sampleLut(table, v) {
+  const n = table.length - 1;
+  const x = clamp01(v) * n;
+  const i = Math.floor(x);
+  const j = Math.min(i + 1, n);
+  const f = x - i;
+  return table[i] * (1 - f) + table[j] * f;
+}
+var ADJUSTMENT_KINDS = [
+  { kind: "curves", label: "Curves" },
+  { kind: "levels", label: "Levels" },
+  { kind: "hueSaturation", label: "Hue/Saturation" },
+  { kind: "vibrance", label: "Vibrance" },
+  { kind: "colorBalance", label: "Color Balance" },
+  { kind: "blackWhite", label: "Black & White" },
+  { kind: "photoFilter", label: "Photo Filter" },
+  { kind: "invert", label: "Invert" },
+  { kind: "posterize", label: "Posterize" },
+  { kind: "threshold", label: "Threshold" }
+];
+var KIND_LABELS = new Map(ADJUSTMENT_KINDS.map((k) => [k.kind, k.label]));
+function isAdjustmentKind(value) {
+  return typeof value === "string" && KIND_LABELS.has(value);
+}
+function adjustmentKindLabel(kind) {
+  return _nullishCoalesce(KIND_LABELS.get(kind), () => ( kind));
+}
+var HUE_RANGE_LABELS = ["Reds", "Yellows", "Greens", "Cyans", "Blues", "Magentas"];
+function neutralHueRange(i) {
+  const c = 60 * i;
+  return { hue: 0, saturation: 0, lightness: 0, bounds: [c - 45, c - 15, c + 15, c + 45] };
+}
+var identityCurve = () => [
+  { input: 0, output: 0 },
+  { input: 255, output: 255 }
+];
+var identityLevels = () => ({ inBlack: 0, inWhite: 255, gamma: 1, outBlack: 0, outWhite: 255 });
+function defaultAdjustmentParams(kind) {
+  const defaults = {
+    curves: () => ({ master: identityCurve(), red: identityCurve(), green: identityCurve(), blue: identityCurve() }),
+    levels: () => ({ master: identityLevels(), red: identityLevels(), green: identityLevels(), blue: identityLevels() }),
+    hueSaturation: () => ({
+      hue: 0,
+      saturation: 0,
+      lightness: 0,
+      colorize: false,
+      ranges: [0, 1, 2, 3, 4, 5].map(neutralHueRange)
+    }),
+    vibrance: () => ({ vibrance: 0, saturation: 0 }),
+    colorBalance: () => ({ shadows: [0, 0, 0], midtones: [0, 0, 0], highlights: [0, 0, 0], preserveLuminosity: true }),
+    blackWhite: () => ({ reds: 40, yellows: 60, greens: 40, cyans: 60, blues: 20, magentas: 80, tint: null }),
+    invert: () => ({}),
+    posterize: () => ({ levels: 4 }),
+    threshold: () => ({ level: 128 }),
+    photoFilter: () => ({ color: "#ec8a00", density: 25, preserveLuminosity: true })
+  };
+  return defaults[kind]();
+}
+var layerCounter = 0;
+function createAdjustmentLayer(kind, options = {}) {
+  const raw = {
+    id: _nullishCoalesce(options.id, () => ( `adj_${Date.now().toString(36)}_${(++layerCounter).toString(36)}`)),
+    kind,
+    name: options.name,
+    params: { ...defaultAdjustmentParams(kind), ..._nullishCoalesce(options.params, () => ( {})) },
+    enabled: _nullishCoalesce(options.enabled, () => ( true)),
+    opacity: _nullishCoalesce(options.opacity, () => ( 1)),
+    blend: _nullishCoalesce(options.blend, () => ( "normal"))
+  };
+  return normalizeAdjustmentLayer(raw);
+}
+var HEX = /^#[0-9a-f]{6}$/i;
+function normCurve(points) {
+  if (!Array.isArray(points)) return identityCurve();
+  const out = points.filter((p) => p && typeof p === "object").map((p) => ({ input: clampTo(p.input, 0, 255, 0), output: clampTo(p.output, 0, 255, 0) })).sort((a, b) => a.input - b.input);
+  return out.length >= 2 ? out : identityCurve();
+}
+function normLevels(ch) {
+  const c = ch && typeof ch === "object" ? ch : {};
+  return {
+    inBlack: clampTo(c.inBlack, 0, 254, 0),
+    inWhite: clampTo(c.inWhite, 1, 255, 255),
+    gamma: clampTo(c.gamma, 0.1, 9.99, 1),
+    outBlack: clampTo(c.outBlack, 0, 255, 0),
+    outWhite: clampTo(c.outWhite, 0, 255, 255)
+  };
+}
+function normTone(t) {
+  const a = Array.isArray(t) ? t : [];
+  return [clampTo(a[0], -100, 100, 0), clampTo(a[1], -100, 100, 0), clampTo(a[2], -100, 100, 0)];
+}
+function normParams(kind, raw) {
+  const p = raw && typeof raw === "object" ? raw : {};
+  const d = defaultAdjustmentParams(kind);
+  switch (kind) {
+    case "curves":
+      return { master: normCurve(p.master), red: normCurve(p.red), green: normCurve(p.green), blue: normCurve(p.blue) };
+    case "levels":
+      return { master: normLevels(p.master), red: normLevels(p.red), green: normLevels(p.green), blue: normLevels(p.blue) };
+    case "hueSaturation": {
+      const ranges = [0, 1, 2, 3, 4, 5].map((i) => {
+        const r = Array.isArray(p.ranges) && p.ranges[i] && typeof p.ranges[i] === "object" ? p.ranges[i] : {};
+        const n = neutralHueRange(i);
+        const b = Array.isArray(r.bounds) && r.bounds.length === 4 && r.bounds.every((v) => Number.isFinite(v)) ? r.bounds : n.bounds;
+        return {
+          hue: clampTo(r.hue, -180, 180, 0),
+          saturation: clampTo(r.saturation, -100, 100, 0),
+          lightness: clampTo(r.lightness, -100, 100, 0),
+          bounds: [b[0], b[1], b[2], b[3]]
+        };
+      });
+      const colorize = p.colorize === true;
+      return {
+        hue: colorize ? clampTo(p.hue, 0, 360, 0) : clampTo(p.hue, -180, 180, 0),
+        saturation: clampTo(p.saturation, -100, 100, 0),
+        lightness: clampTo(p.lightness, -100, 100, 0),
+        colorize,
+        ranges
+      };
+    }
+    case "vibrance":
+      return { vibrance: clampTo(p.vibrance, -100, 100, 0), saturation: clampTo(p.saturation, -100, 100, 0) };
+    case "colorBalance":
+      return {
+        shadows: normTone(p.shadows),
+        midtones: normTone(p.midtones),
+        highlights: normTone(p.highlights),
+        preserveLuminosity: p.preserveLuminosity !== false
+      };
+    case "blackWhite": {
+      const out = {};
+      for (const k of ["reds", "yellows", "greens", "cyans", "blues", "magentas"]) out[k] = clampTo(p[k], -200, 300, d[k]);
+      out.tint = typeof p.tint === "string" && HEX.test(p.tint) ? p.tint.toLowerCase() : null;
+      return out;
+    }
+    case "photoFilter":
+      return {
+        color: typeof p.color === "string" && HEX.test(p.color) ? p.color.toLowerCase() : d.color,
+        density: clampTo(p.density, 0, 100, d.density),
+        preserveLuminosity: p.preserveLuminosity !== false
+      };
+    case "posterize":
+      return { levels: Math.round(clampTo(p.levels, 2, 255, 4)) };
+    case "threshold":
+      return { level: Math.round(clampTo(p.level, 1, 255, 128)) };
+    case "invert":
+      return {};
+  }
+}
+function normalizeAdjustmentLayer(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const r = raw;
+  if (!isAdjustmentKind(r.kind)) return null;
+  const layer = {
+    id: typeof r.id === "string" && r.id ? r.id : `adj_${Date.now().toString(36)}_${(++layerCounter).toString(36)}`,
+    kind: r.kind,
+    enabled: r.enabled !== false,
+    opacity: clampTo(r.opacity, 0, 1, 1),
+    blend: normalizeBlendMode(r.blend),
+    params: normParams(r.kind, r.params)
+  };
+  if (typeof r.name === "string" && r.name) layer.name = r.name;
+  return layer;
+}
+function normalizeAdjustmentLayers(raw) {
+  if (!Array.isArray(raw)) return [];
+  const seen = /* @__PURE__ */ new Set();
+  const out = [];
+  for (const item of raw) {
+    const layer = normalizeAdjustmentLayer(item);
+    if (!layer) continue;
+    while (seen.has(layer.id)) layer.id = `${layer.id}_${(++layerCounter).toString(36)}`;
+    seen.add(layer.id);
+    out.push(layer);
+  }
+  return out;
+}
+function curveLut(points, size = ADJUSTMENT_LUT_SIZE) {
+  const pts = points.filter((p) => Number.isFinite(p.input) && Number.isFinite(p.output)).map((p) => [p.input, p.output]).sort((a, b) => a[0] - b[0]);
+  const dedup = [];
+  for (const p of pts) {
+    if (dedup.length && Math.abs(dedup[dedup.length - 1][0] - p[0]) < 1e-6) continue;
+    dedup.push(p);
+  }
+  const out = new Float32Array(size);
+  const n = dedup.length;
+  if (n < 2) {
+    for (let k = 0; k < size; k++) out[k] = k / (size - 1);
+    return out;
+  }
+  const x = dedup.map((p) => p[0]);
+  const y = dedup.map((p) => p[1]);
+  const m2 = new Float64Array(n);
+  if (n > 2) {
+    const c = new Float64Array(n);
+    const d = new Float64Array(n);
+    for (let i = 1; i < n - 1; i++) {
+      const h0 = x[i] - x[i - 1];
+      const h1 = x[i + 1] - x[i];
+      const a = h0 / 6;
+      const b = (h0 + h1) / 3;
+      const cc = h1 / 6;
+      const r = (y[i + 1] - y[i]) / h1 - (y[i] - y[i - 1]) / h0;
+      const denom = b - a * c[i - 1];
+      c[i] = cc / denom;
+      d[i] = (r - a * d[i - 1]) / denom;
+    }
+    for (let i = n - 2; i >= 1; i--) m2[i] = d[i] - c[i] * m2[i + 1];
+  }
+  let seg = 0;
+  for (let k = 0; k < size; k++) {
+    const xv = k / (size - 1);
+    if (xv <= x[0]) {
+      out[k] = clamp01(y[0]);
+      continue;
+    }
+    if (xv >= x[n - 1]) {
+      out[k] = clamp01(y[n - 1]);
+      continue;
+    }
+    while (seg < n - 2 && xv > x[seg + 1]) seg++;
+    const x0 = x[seg], x1 = x[seg + 1];
+    const h = x1 - x0;
+    const a = (x1 - xv) / h;
+    const b = (xv - x0) / h;
+    const v = a * y[seg] + b * y[seg + 1] + ((a * a * a - a) * m2[seg] + (b * b * b - b) * m2[seg + 1]) * (h * h) / 6;
+    out[k] = clamp01(v);
+  }
+  return out;
+}
+function curveLutFromLevels(points) {
+  return curveLut(points.map((p) => ({ input: p.input / 255, output: p.output / 255 })));
+}
+var toUnitLevels = (c) => ({
+  inBlack: c.inBlack / 255,
+  inWhite: c.inWhite / 255,
+  gamma: c.gamma,
+  outBlack: c.outBlack / 255,
+  outWhite: c.outWhite / 255
+});
+function levelsValue(ch, v, quantum) {
+  const range = Math.max(1e-6, ch.inWhite - ch.inBlack);
+  let u;
+  if (quantum !== void 0 && Number.isFinite(quantum) && quantum >= 1) {
+    const q = quantum;
+    const vq = Math.round(v * q) / q;
+    u = Math.floor(clamp01((vq - ch.inBlack) / range) * q + 0.5 + 1e-3) / q;
+  } else {
+    u = clamp01((v - ch.inBlack) / range);
+  }
+  const g = Math.max(0.01, ch.gamma);
+  let t;
+  if (g > 1) {
+    const power = Math.pow(u, 1 / g);
+    const line = 0.93 * Math.pow(2, g) * u;
+    if (power <= 1e-6 || line <= 1e-6) t = Math.min(power, line);
+    else {
+      const p = 10;
+      t = Math.pow(Math.pow(power, -p) + Math.pow(line, -p), -1 / p);
+    }
+  } else {
+    t = Math.pow(u, 1 / g);
+  }
+  return ch.outBlack + t * (ch.outWhite - ch.outBlack);
+}
+function rgbToHsl(c) {
+  const max = Math.max(c[0], c[1], c[2]);
+  const min = Math.min(c[0], c[1], c[2]);
+  const l = (max + min) / 2;
+  if (Math.abs(max - min) < 1e-7) return [0, 0, l];
+  const d = max - min;
+  const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+  let h;
+  if (max === c[0]) h = remEuclid((c[1] - c[2]) / d, 6);
+  else if (max === c[1]) h = (c[2] - c[0]) / d + 2;
+  else h = (c[0] - c[1]) / d + 4;
+  return [h / 6, s, l];
+}
+function hslToRgb(h, s, l) {
+  if (s <= 0) return [l, l, l];
+  const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+  const p = 2 * l - q;
+  const f = (t) => {
+    t = remEuclid(t, 1);
+    if (t < 1 / 6) return p + (q - p) * 6 * t;
+    if (t < 0.5) return q;
+    if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;
+    return p;
+  };
+  return [f(h + 1 / 3), f(h), f(h - 1 / 3)];
+}
+function hueRangeWeight(range, deg) {
+  const [a, b0, c0, d0] = range.bounds;
+  const rel = (x) => Number.isFinite(x) && Number.isFinite(a) ? remEuclid(x - a, 360) : 0;
+  const b = rel(b0);
+  const c = Math.max(rel(c0), b);
+  const d = Math.max(rel(d0), c);
+  const h = rel(deg);
+  if (h <= b) return b <= 0 ? 1 : h / b;
+  if (h <= c) return 1;
+  if (h <= d) return d <= c ? 1 : (d - h) / (d - c);
+  return 0;
+}
+var isNeutralRange = (r) => r.hue === 0 && r.saturation === 0 && r.lightness === 0;
+function hueRangeTables(ranges) {
+  const n = ADJUSTMENT_LUT_SIZE;
+  const t = [new Float32Array(n), new Float32Array(n), new Float32Array(n)];
+  const active = ranges.filter((r) => !isNeutralRange(r));
+  for (let k = 0; k < n; k++) {
+    const deg = k / (n - 1) * 360;
+    for (const r of active) {
+      const w = hueRangeWeight(r, deg);
+      t[0][k] += w * r.hue;
+      t[1][k] += w * r.saturation / 100;
+      t[2][k] += w * r.lightness / 100;
+    }
+  }
+  return t;
+}
+function hueSaturation(c, hue, s, l, colorize) {
+  const lighten = (v) => l > 0 ? v + (1 - v) * l : v * (1 + l);
+  if (colorize) {
+    const ll2 = rgbToHsl(c)[2];
+    return hslToRgb(remEuclid(hue, 360) / 360, Math.min(1, Math.abs(s)), lighten(ll2));
+  }
+  const [hh0, ss0, ll] = rgbToHsl([lighten(c[0]), lighten(c[1]), lighten(c[2])]);
+  const hh = remEuclid(hh0 + hue / 360, 1);
+  const ss = Math.min(1, Math.max(0, s > 0 ? ss0 / Math.max(1 / 512, 1 - s) : ss0 * (1 + s)));
+  return hslToRgb(hh, ss, ll);
+}
+function rangeLightness(c, l) {
+  const k = Math.min(1, Math.max(-1, l));
+  const target = k > 0 ? Math.max(c[0], c[1], c[2]) : Math.min(c[0], c[1], c[2]);
+  const a = Math.abs(k);
+  return [c[0] + (target - c[0]) * a, c[1] + (target - c[1]) * a, c[2] + (target - c[2]) * a];
+}
+var VIBRANCE_GREY = [0.288, 0.712];
+var VIBRANCE_BOOST = [0.5001, 0.0887, 0.4374, 0.7573, -0.8113, 0.5154, 2.8026];
+function vibranceSkin(h) {
+  if (h <= 30) return 1;
+  if (h < 45) return (45 - h) / 15;
+  if (h < 300) return 0;
+  return (h - 300) / 60;
+}
+function hsvHue(c, mx, mn) {
+  const d = mx - mn;
+  let h;
+  if (mx === c[0]) h = remEuclid((c[1] - c[2]) / d, 6);
+  else if (mx === c[1]) h = (c[2] - c[0]) / d + 2;
+  else h = (c[0] - c[1]) / d + 4;
+  return h * 60;
+}
+function vibranceLinear(c, v) {
+  const mx = Math.max(c[0], c[1], c[2]);
+  const mn = Math.min(c[0], c[1], c[2]);
+  if (mx <= 0 || mx - mn <= 1e-9) return c;
+  const t = 1 - mn / mx;
+  const shape = t * (1 - t) * (2 - t + t * t) * mx * Math.max(0, 1 - mx);
+  let t2, v2;
+  if (v < 0) {
+    const a = -v;
+    t2 = t * (1 - a / 4) * (1 - a + a * t * (1 + t) / 2);
+    v2 = mx - a * shape;
+  } else {
+    const [c0, c1, p, q, r0, ra, rt] = VIBRANCE_BOOST;
+    const w = vibranceSkin(hsvHue(c, mx, mn));
+    const a = v * (1 - w) + 0.64 * Math.pow(v, 1.6) * w;
+    const boost = (c0 * a + c1 * a * a) * Math.pow(t, p) * Math.pow(1 - t, q) * Math.exp((r0 + ra * a + rt * (1 - t)) * Math.max(0, 1 - mx));
+    t2 = Math.min(1, t * (1 + boost));
+    v2 = mx + v / 4 * shape;
+  }
+  const m2 = v2 * (1 - t2);
+  const k = (v2 - m2) / (mx - mn);
+  return [m2 + (c[0] - mn) * k, m2 + (c[1] - mn) * k, m2 + (c[2] - mn) * k];
+}
+function vibrancePixel(c, v, s) {
+  let l = [srgbToLinear(Math.max(0, c[0])), srgbToLinear(Math.max(0, c[1])), srgbToLinear(Math.max(0, c[2]))];
+  if (v !== 0) l = vibranceLinear(l, v);
+  if (s !== 0) {
+    const g = VIBRANCE_GREY[0] * l[0] + VIBRANCE_GREY[1] * l[1];
+    l = l.map((x) => Math.min(1, Math.max(0, g + (1 + s) * (x - g))));
+  }
+  return l.map((x) => linearToSrgb(clamp01(x)));
+}
+var BALANCE_LEVELS = 0.39;
+function colorBalanceChannel(tones, preserveLuminosity, ch, v) {
+  const [shadows, midtones, highlights] = tones;
+  const black = (x, b) => Math.max(0, (x - b) / (1 - b));
+  const white = (x, w) => Math.min(1, x / w);
+  let out = clamp01(v);
+  for (const [tone2, sliders] of [
+    [2, highlights],
+    [0, shadows],
+    [1, midtones]
+  ]) {
+    const a = [0, 1, 2].map((i) => Math.min(1, Math.max(-1, sliders[i] / 100)));
+    if (preserveLuminosity) {
+      const own = _nullishCoalesce(a[ch], () => ( 0));
+      const lo = Math.min(a[0], a[1], a[2]);
+      const hi = Math.max(a[0], a[1], a[2]);
+      if (tone2 === 0) out = black(out, BALANCE_LEVELS * (hi - own));
+      else if (tone2 === 1) out = Math.pow(out, Math.pow(2, (hi + lo) / 2 - own));
+      else out = white(out, 1 - BALANCE_LEVELS * (own - lo));
+      continue;
+    }
+    const s = a[ch];
+    if (s === 0) continue;
+    if (tone2 === 1) out = Math.pow(out, Math.pow(2, -s));
+    else if (tone2 === 0 && s < 0) out = Math.pow(black(out, BALANCE_LEVELS * -s), Math.pow(2, -s / 2));
+    else if (tone2 === 2 && s > 0) out = Math.pow(white(out, 1 - BALANCE_LEVELS * s), Math.pow(2, -s / 2));
+    else out = Math.pow(out, Math.pow(2, -s / 2));
+  }
+  return out;
+}
+function blackWhiteGray(c, weights) {
+  const [r, g, b] = c;
+  const max = Math.max(r, g, b);
+  const min = Math.min(r, g, b);
+  const mid = r + g + b - max - min;
+  const primary = r >= g && r >= b ? 0 : g >= b ? 2 : 4;
+  const secondary = b <= r && b <= g ? 1 : r <= g ? 3 : 5;
+  return clamp01(min + (mid - min) * weights[secondary] / 100 + (max - mid) * weights[primary] / 100);
+}
+var D50 = [0.96422, 1, 0.82521];
+var SRGB_TO_XYZ_D50 = [
+  [0.436074, 0.385064, 0.14308],
+  [0.222504, 0.716878, 0.060618],
+  [0.013932, 0.097104, 0.714173]
+];
+var XYZ_D50_TO_SRGB = [
+  [3.133856, -1.616867, -0.490615],
+  [-0.978768, 1.916142, 0.033454],
+  [0.071945, -0.228991, 1.405243]
+];
+function photoFilterMatrix(color, density, normalizeY = false) {
+  const d = Number.isFinite(density) ? clamp01(density) : 0;
+  const lin = [0, 1, 2].map((i) => srgbToLinear(clamp01(color[i])));
+  const xyz = SRGB_TO_XYZ_D50.map((r) => r[0] * lin[0] + r[1] * lin[1] + r[2] * lin[2]);
+  let s = [0, 1, 2].map((i) => 1 - d + d * xyz[i] / D50[i]);
+  if (normalizeY && s[1] > 1e-6) {
+    const y = s[1];
+    s = s.map((v) => v / y);
+  }
+  return [0, 1, 2].map(
+    (r) => [0, 1, 2].map((c) => XYZ_D50_TO_SRGB[r][0] * s[0] * SRGB_TO_XYZ_D50[0][c] + XYZ_D50_TO_SRGB[r][1] * s[1] * SRGB_TO_XYZ_D50[1][c] + XYZ_D50_TO_SRGB[r][2] * s[2] * SRGB_TO_XYZ_D50[2][c])
+  );
+}
+function posterizeValue(v, levels) {
+  const n = Math.min(255, Math.max(2, Math.round(levels)));
+  const x = Math.round(clamp01(v) * 255);
+  const bin = Math.min(n - 1, Math.floor(x * n / 256));
+  return Math.floor(bin * 255 / (n - 1)) / 255;
+}
+var rgbToGray = (c) => 0.299 * c[0] + 0.587 * c[1] + 0.114 * c[2];
+function hexToRgb(hex) {
+  if (!HEX.test(hex)) return [0, 0, 0];
+  const n = parseInt(hex.slice(1), 16);
+  return [(n >> 16 & 255) / 255, (n >> 8 & 255) / 255, (n & 255) / 255];
+}
+function lutOp(luts) {
+  const [lr, lg, lb] = luts;
+  return (c) => {
+    c[0] = sampleLut(lr, c[0]);
+    c[1] = sampleLut(lg, c[1]);
+    c[2] = sampleLut(lb, c[2]);
+  };
+}
+var isIdentityCurve = (pts) => pts.length === 2 && pts[0].input === 0 && pts[0].output === 0 && pts[1].input === 255 && pts[1].output === 255;
+var isIdentityLevels = (c) => c.inBlack === 0 && c.inWhite === 255 && c.gamma === 1 && c.outBlack === 0 && c.outWhite === 255;
+var LEVELS_QUANTUM = 255;
+function toneLuts(layer) {
+  const n = ADJUSTMENT_LUT_SIZE;
+  if (layer.kind === "curves") {
+    const m = curveLutFromLevels(layer.params.master);
+    return [layer.params.red, layer.params.green, layer.params.blue].map((pts) => {
+      const ch = curveLutFromLevels(pts);
+      for (let k = 0; k < n; k++) ch[k] = sampleLut(m, ch[k]);
+      return ch;
+    });
+  }
+  if (layer.kind === "levels") {
+    const m = toUnitLevels(layer.params.master);
+    return [layer.params.red, layer.params.green, layer.params.blue].map((rec) => {
+      const c = toUnitLevels(rec);
+      const out = new Float32Array(n);
+      for (let k = 0; k < n; k++) out[k] = levelsValue(m, levelsValue(c, k / (n - 1), LEVELS_QUANTUM), LEVELS_QUANTUM);
+      return out;
+    });
+  }
+  return null;
+}
+function compileAdjustmentLayer(layer) {
+  switch (layer.kind) {
+    case "curves": {
+      const p = layer.params;
+      if ([p.master, p.red, p.green, p.blue].every(isIdentityCurve)) return null;
+      return lutOp(toneLuts(layer));
+    }
+    case "levels": {
+      const p = layer.params;
+      if ([p.master, p.red, p.green, p.blue].every(isIdentityLevels)) return null;
+      return lutOp(toneLuts(layer));
+    }
+    case "hueSaturation": {
+      const p = layer.params;
+      const rangesActive = !p.colorize && p.ranges.some((r) => !isNeutralRange(r));
+      if (!p.colorize && !rangesActive && p.hue === 0 && p.saturation === 0 && p.lightness === 0) return null;
+      const tables = rangesActive ? hueRangeTables(p.ranges) : null;
+      const sat2 = p.saturation / 100;
+      const light = Math.min(1, Math.max(-1, p.lightness / 100));
+      return (c) => {
+        let dh = 0, ds = 0, dl = 0;
+        if (tables) {
+          const h0 = rgbToHsl(c)[0];
+          dh = sampleLut(tables[0], h0);
+          ds = sampleLut(tables[1], h0);
+          dl = sampleLut(tables[2], h0);
+        }
+        const out = rangeLightness(hueSaturation(c, p.hue + dh, Math.min(1, Math.max(-1, sat2 + ds)), light, p.colorize), dl);
+        c[0] = out[0];
+        c[1] = out[1];
+        c[2] = out[2];
+      };
+    }
+    case "vibrance": {
+      const v = layer.params.vibrance / 100;
+      const s = layer.params.saturation / 100;
+      if (v === 0 && s === 0) return null;
+      return (c) => {
+        const out = vibrancePixel(c, v, s);
+        c[0] = out[0];
+        c[1] = out[1];
+        c[2] = out[2];
+      };
+    }
+    case "colorBalance": {
+      const p = layer.params;
+      const tones = [p.shadows, p.midtones, p.highlights];
+      if (tones.every((t) => t[0] === 0 && t[1] === 0 && t[2] === 0)) return null;
+      const n = ADJUSTMENT_LUT_SIZE;
+      const luts = [0, 1, 2].map((ch) => {
+        const out = new Float32Array(n);
+        for (let k = 0; k < n; k++) out[k] = colorBalanceChannel(tones, p.preserveLuminosity, ch, k / (n - 1));
+        return out;
+      });
+      return lutOp(luts);
+    }
+    case "blackWhite": {
+      const p = layer.params;
+      const weights = [p.reds, p.yellows, p.greens, p.cyans, p.blues, p.magentas];
+      const tint = p.tint ? hexToRgb(p.tint) : null;
+      return (c) => {
+        const g = blackWhiteGray(c, weights);
+        if (tint) {
+          const t = setLum(tint, g);
+          c[0] = clamp01(t[0]);
+          c[1] = clamp01(t[1]);
+          c[2] = clamp01(t[2]);
+        } else {
+          c[0] = c[1] = c[2] = g;
+        }
+      };
+    }
+    case "photoFilter": {
+      const p = layer.params;
+      if (p.density <= 0) return null;
+      const m = photoFilterMatrix(hexToRgb(p.color), p.density / 100, false);
+      const preserve = p.preserveLuminosity;
+      return (c) => {
+        const l = [srgbToLinear(Math.max(0, c[0])), srgbToLinear(Math.max(0, c[1])), srgbToLinear(Math.max(0, c[2]))];
+        let f = [0, 1, 2].map((r) => linearToSrgb(Math.max(0, m[r][0] * l[0] + m[r][1] * l[1] + m[r][2] * l[2])));
+        if (preserve) {
+          const target = 0.3 * c[0] + 0.59 * c[1] + 0.11 * c[2];
+          f = setLum(f, target);
+        }
+        c[0] = clamp01(f[0]);
+        c[1] = clamp01(f[1]);
+        c[2] = clamp01(f[2]);
+      };
+    }
+    case "invert":
+      return (c) => {
+        c[0] = 1 - c[0];
+        c[1] = 1 - c[1];
+        c[2] = 1 - c[2];
+      };
+    case "posterize": {
+      const levels = layer.params.levels;
+      return (c) => {
+        c[0] = posterizeValue(c[0], levels);
+        c[1] = posterizeValue(c[1], levels);
+        c[2] = posterizeValue(c[2], levels);
+      };
+    }
+    case "threshold": {
+      const t = Math.round(layer.params.level);
+      return (c) => {
+        const v = Math.round(rgbToGray(c) * 255) >= t ? 1 : 0;
+        c[0] = c[1] = c[2] = v;
+      };
+    }
+  }
+  return null;
+}
+var COMPILE_CACHE_LIMIT = 64;
+var compileCache = /* @__PURE__ */ new Map();
+function compiledFor(layer) {
+  const key = `${layer.kind}:${JSON.stringify(layer.params)}`;
+  if (compileCache.has(key)) {
+    const op2 = compileCache.get(key);
+    compileCache.delete(key);
+    compileCache.set(key, op2);
+    return op2;
+  }
+  const op = compileAdjustmentLayer(layer);
+  compileCache.set(key, op);
+  if (compileCache.size > COMPILE_CACHE_LIMIT) compileCache.delete(compileCache.keys().next().value);
+  return op;
+}
+function activeAdjustmentLayers(layers) {
+  if (!_optionalChain([layers, 'optionalAccess', _5 => _5.length])) return [];
+  return layers.filter((l) => l.enabled !== false && (_nullishCoalesce(l.opacity, () => ( 1))) > 0 && compiledFor(l) !== null);
+}
+function evaluateAdjustmentLayers(color, layers) {
+  const c = [color[0], color[1], color[2]];
+  for (const layer of layers) applyLayer(c, layer, compiledFor(layer));
+  return c;
+}
+function applyLayer(c, layer, op) {
+  if (!op || layer.enabled === false) return;
+  const alpha = Math.min(1, Math.max(0, _nullishCoalesce(layer.opacity, () => ( 1))));
+  if (alpha <= 0) return;
+  const blend = _nullishCoalesce(layer.blend, () => ( "normal"));
+  if (blend === "normal" && alpha >= 1) {
+    op(c);
+    return;
+  }
+  const cb0 = c[0], cb1 = c[1], cb2 = c[2];
+  op(c);
+  const b = blend === "normal" ? c : blendRgb(blend, [cb0, cb1, cb2], c);
+  c[0] = (1 - alpha) * cb0 + alpha * b[0];
+  c[1] = (1 - alpha) * cb1 + alpha * b[1];
+  c[2] = (1 - alpha) * cb2 + alpha * b[2];
+}
+function applyAdjustmentLayers(imageData, layers) {
+  const active = activeAdjustmentLayers(layers);
+  if (!active.length) return;
+  const ops = active.map((l) => compiledFor(l));
+  const data = imageData.data;
+  const len = data.length;
+  const c = [0, 0, 0];
+  for (let i = 0; i < len; i += 4) {
+    if (data[i + 3] === 0) continue;
+    c[0] = data[i] / 255;
+    c[1] = data[i + 1] / 255;
+    c[2] = data[i + 2] / 255;
+    for (let k = 0; k < active.length; k++) applyLayer(c, active[k], ops[k]);
+    data[i] = Math.round(clamp01(c[0]) * 255);
+    data[i + 1] = Math.round(clamp01(c[1]) * 255);
+    data[i + 2] = Math.round(clamp01(c[2]) * 255);
+  }
+}
+function adjustmentLayersKey(layers) {
+  if (!_optionalChain([layers, 'optionalAccess', _6 => _6.length])) return "";
+  return JSON.stringify(
+    layers.map((l) => [l.kind, l.enabled !== false, _nullishCoalesce(l.opacity, () => ( 1)), _nullishCoalesce(l.blend, () => ( "normal")), l.params])
+  );
+}
+
+// src/image-editor/filters.ts
 function clamp(value, min = 0, max = 255) {
   return Math.max(min, Math.min(max, value));
 }
 function applyAdjustments(imageData, adjustments) {
-  const { brightness, contrast, saturation, exposure, temperature, opacity, blur } = adjustments;
+  if (normalizeProcessVersion(adjustments.process) === LATEST_PROCESS_VERSION) {
+    applyProcess2Adjustments(imageData, adjustments);
+  } else {
+    applyLegacyAdjustments(imageData, adjustments);
+  }
+  applyAdjustmentLayers(imageData, adjustments.layers);
+  if (adjustments.blur > 0) {
+    applyFastBoxBlur(imageData, Math.min(Math.round(adjustments.blur), 40));
+  }
+}
+function applyLegacyAdjustments(imageData, adjustments) {
+  const { brightness, contrast, saturation, exposure, temperature, opacity } = adjustments;
   const data = imageData.data;
   const len = data.length;
   const hasBrightness = brightness !== 0;
@@ -57,8 +1188,108 @@ function applyAdjustments(imageData, adjustments) {
       data[i + 3] = a;
     }
   }
-  if (blur > 0) {
-    applyFastBoxBlur(imageData, Math.min(Math.round(blur), 40));
+}
+var DECODE_LUT = (() => {
+  const lut = new Float32Array(256);
+  for (let i = 0; i < 256; i++) lut[i] = srgbToLinear(i / 255);
+  return lut;
+})();
+var ENCODE_LUT_SIZE = 65535;
+var encodeLut = null;
+function getEncodeLut() {
+  if (!encodeLut) {
+    encodeLut = new Uint8Array(ENCODE_LUT_SIZE + 1);
+    for (let i = 0; i <= ENCODE_LUT_SIZE; i++) {
+      encodeLut[i] = Math.round(linearToSrgb(i / ENCODE_LUT_SIZE) * 255);
+    }
+  }
+  return encodeLut;
+}
+var cachedPlan = null;
+function getProcess2Plan(adjustments) {
+  const exposure = adjustments.exposure || 0;
+  const temperature = adjustments.temperature || 0;
+  const tint = adjustments.tint || 0;
+  const contrast = adjustments.contrast || 0;
+  const brightness = adjustments.brightness || 0;
+  const saturation = 1 + (adjustments.saturation || 0) / 100;
+  const key = `${exposure},${temperature},${tint},${contrast},${brightness},${saturation}`;
+  if (cachedPlan && cachedPlan.key === key) return cachedPlan;
+  const gain = Math.pow(2, exposure / 50);
+  const wb = whiteBalanceMatrix(temperature, tint);
+  const m = new Float64Array(9);
+  for (let i = 0; i < 9; i++) m[i] = wb[i] * gain;
+  const luts = [];
+  const scale = [0, 0, 0];
+  for (let c = 0; c < 3; c++) {
+    let reach = 0;
+    for (let k = 0; k < 3; k++) reach += Math.max(0, m[c * 3 + k]);
+    const headroom = Math.max(1, reach);
+    luts[c] = buildToneLut(contrast, brightness, headroom);
+    scale[c] = TONE_LUT_SIZE / headroom;
+  }
+  cachedPlan = { key, m, luts, scale, saturation };
+  return cachedPlan;
+}
+function applyProcess2Adjustments(imageData, adjustments) {
+  const data = imageData.data;
+  const len = data.length;
+  const opacity = _nullishCoalesce(adjustments.opacity, () => ( 1));
+  const hasOpacity = opacity < 1;
+  const hasColor = !!adjustments.brightness || !!adjustments.contrast || !!adjustments.saturation || !!adjustments.exposure || !!adjustments.temperature || !!adjustments.tint;
+  if (!hasColor) {
+    if (hasOpacity) {
+      for (let i = 3; i < len; i += 4) data[i] = clamp(data[i] * opacity);
+    }
+    return;
+  }
+  const plan = getProcess2Plan(adjustments);
+  const dec = DECODE_LUT;
+  const enc = getEncodeLut();
+  const { m, luts, scale, saturation } = plan;
+  const m0 = m[0], m1 = m[1], m2 = m[2], m3 = m[3], m4 = m[4], m5 = m[5], m6 = m[6], m7 = m[7], m8 = m[8];
+  const lutR = luts[0], lutG = luts[1], lutB = luts[2];
+  const sR = scale[0], sG = scale[1], sB = scale[2];
+  const N = TONE_LUT_SIZE;
+  const hasSaturation = saturation !== 1;
+  const wr = LUMA_709[0], wg = LUMA_709[1], wb = LUMA_709[2];
+  for (let i = 0; i < len; i += 4) {
+    const r0 = dec[data[i]];
+    const g0 = dec[data[i + 1]];
+    const b0 = dec[data[i + 2]];
+    let r = m0 * r0 + m1 * g0 + m2 * b0;
+    let g = m3 * r0 + m4 * g0 + m5 * b0;
+    let b = m6 * r0 + m7 * g0 + m8 * b0;
+    let f;
+    let k;
+    if (r <= 0) r = lutR[0];
+    else if ((f = r * sR) >= N) r = lutR[N];
+    else {
+      k = f | 0;
+      r = lutR[k] + (lutR[k + 1] - lutR[k]) * (f - k);
+    }
+    if (g <= 0) g = lutG[0];
+    else if ((f = g * sG) >= N) g = lutG[N];
+    else {
+      k = f | 0;
+      g = lutG[k] + (lutG[k + 1] - lutG[k]) * (f - k);
+    }
+    if (b <= 0) b = lutB[0];
+    else if ((f = b * sB) >= N) b = lutB[N];
+    else {
+      k = f | 0;
+      b = lutB[k] + (lutB[k + 1] - lutB[k]) * (f - k);
+    }
+    if (hasSaturation) {
+      const y = wr * r + wg * g + wb * b;
+      r = y + (r - y) * saturation;
+      g = y + (g - y) * saturation;
+      b = y + (b - y) * saturation;
+    }
+    data[i] = enc[r <= 0 ? 0 : r >= 1 ? ENCODE_LUT_SIZE : r * ENCODE_LUT_SIZE + 0.5 | 0];
+    data[i + 1] = enc[g <= 0 ? 0 : g >= 1 ? ENCODE_LUT_SIZE : g * ENCODE_LUT_SIZE + 0.5 | 0];
+    data[i + 2] = enc[b <= 0 ? 0 : b >= 1 ? ENCODE_LUT_SIZE : b * ENCODE_LUT_SIZE + 0.5 | 0];
+    if (hasOpacity) data[i + 3] = clamp(data[i + 3] * opacity);
   }
 }
 function applyFastBoxBlur(imageData, radius) {
@@ -148,6 +1379,63 @@ function removeAlpha(imageData) {
   }
 }
 
+// src/image-editor/histogram.ts
+var HISTOGRAM_BINS = 256;
+function computeHistogram(imageData) {
+  const red = new Uint32Array(HISTOGRAM_BINS);
+  const green = new Uint32Array(HISTOGRAM_BINS);
+  const blue = new Uint32Array(HISTOGRAM_BINS);
+  const luminance = new Uint32Array(HISTOGRAM_BINS);
+  const shadows = [0, 0, 0];
+  const highlights = [0, 0, 0];
+  let samples = 0;
+  let transparent = 0;
+  const data = imageData.data;
+  const len = data.length - data.length % 4;
+  for (let i = 0; i < len; i += 4) {
+    if (!(data[i + 3] > 0)) {
+      transparent++;
+      continue;
+    }
+    samples++;
+    const r = clampByte(data[i]);
+    const g = clampByte(data[i + 1]);
+    const b = clampByte(data[i + 2]);
+    red[r]++;
+    green[g]++;
+    blue[b]++;
+    luminance[Math.round(0.2126 * r + 0.7152 * g + 0.0722 * b)]++;
+    if (r === 0) shadows[0]++;
+    if (g === 0) shadows[1]++;
+    if (b === 0) shadows[2]++;
+    if (r === 255) highlights[0]++;
+    if (g === 255) highlights[1]++;
+    if (b === 255) highlights[2]++;
+  }
+  let max = 0;
+  for (const bins of [red, green, blue, luminance]) {
+    for (let k = 0; k < HISTOGRAM_BINS; k++) if (bins[k] > max) max = bins[k];
+  }
+  return { red, green, blue, luminance, samples, transparent, shadows, highlights, max };
+}
+function clampByte(v) {
+  return v <= 0 ? 0 : v >= 255 ? 255 : Math.round(v);
+}
+function histogramPath(histogram, channel, width, height, options = {}) {
+  const bins = histogram[channel];
+  const sqrt = (_nullishCoalesce(options.scale, () => ( "sqrt"))) === "sqrt";
+  const f = (v) => sqrt ? Math.sqrt(v) : v;
+  const top = f(_nullishCoalesce(options.max, () => ( histogram.max))) || 1;
+  const dx = width / (HISTOGRAM_BINS - 1);
+  let d = `M0 ${height}`;
+  for (let k = 0; k < HISTOGRAM_BINS; k++) {
+    const y = height - f(bins[k]) / top * height;
+    d += ` L${round2(k * dx)} ${round2(y)}`;
+  }
+  return `${d} L${round2(width)} ${height} Z`;
+}
+var round2 = (v) => Math.round(v * 100) / 100;
+
 // src/image-editor/geometry.ts
 function normalizeAngle(degrees) {
   const a = (degrees % 360 + 360) % 360;
@@ -534,12 +1822,19 @@ var ImageCache = (_class = class {constructor() { _class.prototype.__init.call(t
   }
 }, _class);
 var globalImageCache = new ImageCache();
-var ImageEditorRenderer = (_class2 = class {constructor() { _class2.prototype.__init2.call(this);_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this);_class2.prototype.__init6.call(this); }
+var ImageEditorRenderer = (_class2 = class {constructor() { _class2.prototype.__init2.call(this);_class2.prototype.__init3.call(this);_class2.prototype.__init4.call(this);_class2.prototype.__init5.call(this);_class2.prototype.__init6.call(this);_class2.prototype.__init7.call(this); }
   __init2() {this.imageCache = globalImageCache}
   __init3() {this.cachedBaseCanvas = null}
   __init4() {this.cachedBaseKey = ""}
-  __init5() {this.sourceIds = /* @__PURE__ */ new WeakMap()}
-  __init6() {this.nextSourceId = 0}
+  /**
+   * Histogram of the last viewport base render (after adjustments and layers, before
+   * annotations); `null` until a render with pixel access has happened.
+   */
+  __init5() {this.previewHistogram = null}
+  /** Called whenever the viewport base image is re-rendered with the new histogram. */
+  
+  __init6() {this.sourceIds = /* @__PURE__ */ new WeakMap()}
+  __init7() {this.nextSourceId = 0}
   /**
    * Helper to create a canvas element safely in browser/JSDOM.
    */
@@ -593,14 +1888,20 @@ var ImageEditorRenderer = (_class2 = class {constructor() { _class2.prototype.__
       `${naturalWidth}x${naturalHeight}`,
       `${region.x},${region.y},${region.width},${region.height}`,
       `${projection.angle},${transform.flipH},${transform.flipV}`,
-      `${adjustments.brightness},${adjustments.contrast},${adjustments.saturation},${adjustments.exposure},${adjustments.temperature},${adjustments.blur},${adjustments.opacity}`,
-      `${depthMask.enabled},${depthMask.maskSource},${_optionalChain([depthMask, 'access', _ => _.depthRange, 'optionalAccess', _2 => _2[0]])}-${_optionalChain([depthMask, 'access', _3 => _3.depthRange, 'optionalAccess', _4 => _4[1]])},${depthMask.softness},${depthMask.invert},${depthMask.mode}`
+      `${adjustments.brightness},${adjustments.contrast},${adjustments.saturation},${adjustments.exposure},${adjustments.temperature},${_nullishCoalesce(adjustments.tint, () => ( 0))},${adjustments.blur},${adjustments.opacity},p${normalizeProcessVersion(adjustments.process)}`,
+      adjustmentLayersKey(adjustments.layers),
+      `${depthMask.enabled},${depthMask.maskSource},${_optionalChain([depthMask, 'access', _7 => _7.depthRange, 'optionalAccess', _8 => _8[0]])}-${_optionalChain([depthMask, 'access', _9 => _9.depthRange, 'optionalAccess', _10 => _10[1]])},${depthMask.softness},${depthMask.invert},${depthMask.mode}`
     ].join("|");
     let baseCanvas = this.cachedBaseCanvas;
     if (!baseCanvas || this.cachedBaseKey !== baseKey) {
-      baseCanvas = await this.renderBaseImage(img, naturalWidth, naturalHeight, region, transform, state);
+      let histogram = null;
+      baseCanvas = await this.renderBaseImage(img, naturalWidth, naturalHeight, region, transform, state, (pixels) => {
+        histogram = computeHistogram(pixels);
+      });
       this.cachedBaseCanvas = baseCanvas;
       this.cachedBaseKey = baseKey;
+      this.previewHistogram = histogram;
+      _optionalChain([this, 'access', _11 => _11.onPreviewHistogram, 'optionalCall', _12 => _12(histogram)]);
     }
     const drawW = rotated.width * projection.scale;
     const drawH = rotated.height * projection.scale;
@@ -631,7 +1932,7 @@ var ImageEditorRenderer = (_class2 = class {constructor() { _class2.prototype.__
    * Draws `region` of the source image with rotation/flip applied, then pixel adjustments
    * and the depth mask (which receives the identical transform so it stays aligned).
    */
-  async renderBaseImage(img, naturalWidth, naturalHeight, region, transform, state) {
+  async renderBaseImage(img, naturalWidth, naturalHeight, region, transform, state, onPixels) {
     const { adjustments, depthMask } = state;
     const rotated = getRotatedSize(region.width, region.height, transform);
     const baseW = Math.max(1, Math.round(rotated.width));
@@ -688,6 +1989,7 @@ var ImageEditorRenderer = (_class2 = class {constructor() { _class2.prototype.__
         } catch (e3) {
         }
       }
+      _optionalChain([onPixels, 'optionalCall', _13 => _13(imageData)]);
       baseCtx.putImageData(imageData, 0, 0);
     }
     return baseCanvas;
@@ -705,6 +2007,59 @@ var ImageEditorRenderer = (_class2 = class {constructor() { _class2.prototype.__
    * Draws an individual annotation onto the canvas.
    */
   async drawAnnotation(ctx, ann) {
+    const blend = normalizeBlendMode(ann.blend);
+    if (blend === "normal") {
+      await this.drawAnnotationContent(ctx, ann);
+      return;
+    }
+    const op = canvasCompositeOperation(blend);
+    if (op) {
+      ctx.save();
+      ctx.globalCompositeOperation = op;
+      await this.drawAnnotationContent(ctx, ann);
+      ctx.restore();
+      return;
+    }
+    if (!await this.drawAnnotationBlended(ctx, ann)) {
+      await this.drawAnnotationContent(ctx, ann);
+    }
+  }
+  /**
+   * Scalar fallback for blend modes the canvas cannot composite (Photoshop soft light, linear /
+   * vivid / pin light, hard mix, subtract, divide, darker / lighter colour, linear burn / dodge):
+   * draws the annotation on a same-size layer with the same transform, blends it into a copy of
+   * the target's pixels with `blendImageData`, and copies the result back inside the current clip.
+   */
+  async drawAnnotationBlended(ctx, ann) {
+    const canvas = ctx.canvas;
+    if (!canvas || typeof ctx.getTransform !== "function" || typeof ctx.getImageData !== "function") return false;
+    const w = canvas.width;
+    const h = canvas.height;
+    const layer = this.createCanvas(w, h);
+    const lctx = layer.getContext("2d");
+    if (!lctx) return false;
+    try {
+      lctx.setTransform(ctx.getTransform());
+      lctx.globalAlpha = ctx.globalAlpha;
+      await this.drawAnnotationContent(lctx, ann);
+      const backdrop = ctx.getImageData(0, 0, w, h);
+      const source = lctx.getImageData(0, 0, w, h);
+      if (!backdrop || !source) return false;
+      blendImageData(backdrop, source, normalizeBlendMode(ann.blend));
+      lctx.setTransform(1, 0, 0, 1, 0, 0);
+      lctx.putImageData(backdrop, 0, 0);
+    } catch (e4) {
+      return false;
+    }
+    ctx.save();
+    ctx.setTransform(1, 0, 0, 1, 0, 0);
+    ctx.globalAlpha = 1;
+    ctx.globalCompositeOperation = "copy";
+    ctx.drawImage(layer, 0, 0);
+    ctx.restore();
+    return true;
+  }
+  async drawAnnotationContent(ctx, ann) {
     ctx.save();
     if (ann.opacity !== void 0) {
       ctx.globalAlpha = ann.opacity;
@@ -807,7 +2162,7 @@ var ImageEditorRenderer = (_class2 = class {constructor() { _class2.prototype.__
         try {
           const loadedImg = await this.imageCache.get(imgAnn.src);
           ctx.drawImage(loadedImg, imgAnn.x, imgAnn.y, imgAnn.width, imgAnn.height);
-        } catch (e4) {
+        } catch (e5) {
         }
         break;
       }
@@ -960,8 +2315,8 @@ var ImageEditorRenderer = (_class2 = class {constructor() { _class2.prototype.__
     if (!ctx) return maskCanvas;
     ctx.fillStyle = MASK_BLACK;
     ctx.fillRect(0, 0, naturalWidth, naturalHeight);
-    const useCrop = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _5 => _5.useCrop]), () => ( true));
-    const useAnnotations = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _6 => _6.useAnnotations]), () => ( true));
+    const useCrop = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _14 => _14.useCrop]), () => ( true));
+    const useAnnotations = _nullishCoalesce(_optionalChain([options, 'optionalAccess', _15 => _15.useAnnotations]), () => ( true));
     if (useCrop && state.crop) {
       ctx.fillStyle = MASK_WHITE;
       ctx.fillRect(state.crop.x, state.crop.y, state.crop.width, state.crop.height);
@@ -971,7 +2326,7 @@ var ImageEditorRenderer = (_class2 = class {constructor() { _class2.prototype.__
         this.drawAnnotationMask(ctx, ann);
       }
     }
-    const imageData = _optionalChain([ctx, 'access', _7 => _7.getImageData, 'optionalCall', _8 => _8(0, 0, naturalWidth, naturalHeight)]);
+    const imageData = _optionalChain([ctx, 'access', _16 => _16.getImageData, 'optionalCall', _17 => _17(0, 0, naturalWidth, naturalHeight)]);
     if (imageData) {
       const d = imageData.data;
       for (let i = 0; i < d.length; i += 4) {
@@ -1058,15 +2413,45 @@ function getBaseProjection(region, transform, baseW, baseH) {
 }
 
 // src/image-editor/controller.ts
+var IMAGE_EDITOR_SCHEMA_VERSION = 2;
 var DEFAULT_ADJUSTMENTS = {
   brightness: 0,
   contrast: 0,
   saturation: 0,
   exposure: 0,
   temperature: 0,
+  tint: 0,
   blur: 0,
-  opacity: 1
+  opacity: 1,
+  process: LATEST_PROCESS_VERSION
 };
+function normalizeStoredAdjustments(stored) {
+  if (!stored) return { ...DEFAULT_ADJUSTMENTS };
+  const out = {
+    ...DEFAULT_ADJUSTMENTS,
+    ...stored,
+    process: normalizeProcessVersion(stored.process)
+  };
+  const layers = normalizeAdjustmentLayers(stored.layers);
+  if (layers.length) out.layers = layers;
+  else delete out.layers;
+  return out;
+}
+function migrateSerializedImageEditorState(data) {
+  const adjustments = normalizeStoredAdjustments(data.adjustments);
+  return {
+    version: _optionalChain([adjustments, 'access', _18 => _18.layers, 'optionalAccess', _19 => _19.length]) ? IMAGE_EDITOR_SCHEMA_VERSION : 1,
+    crop: data.crop ? { ...data.crop } : null,
+    transform: { ...DEFAULT_TRANSFORM, ...data.transform },
+    adjustments: serializeAdjustments(adjustments),
+    depthMask: {
+      ...DEFAULT_DEPTH_MASK,
+      ...data.depthMask,
+      depthRange: [..._nullishCoalesce(_optionalChain([data, 'access', _20 => _20.depthMask, 'optionalAccess', _21 => _21.depthRange]), () => ( DEFAULT_DEPTH_MASK.depthRange))]
+    },
+    annotations: JSON.parse(JSON.stringify(_nullishCoalesce(data.annotations, () => ( []))))
+  };
+}
 var DEFAULT_TRANSFORM = {
   rotate: 0,
   flipH: false,
@@ -1083,39 +2468,40 @@ var DEFAULT_DEPTH_MASK = {
 var ImageEditorController = (_class3 = class {
   
   
-  __init7() {this.imageElement = null}
-  __init8() {this.listeners = /* @__PURE__ */ new Set()}
+  __init8() {this.imageElement = null}
+  __init9() {this.listeners = /* @__PURE__ */ new Set()}
+  __init10() {this.histogramListeners = /* @__PURE__ */ new Set()}
   
   // History stacks
-  __init9() {this.undoStack = []}
-  __init10() {this.redoStack = []}
+  __init11() {this.undoStack = []}
+  __init12() {this.redoStack = []}
   
-  __init11() {this.isApplyingHistory = false}
+  __init13() {this.isApplyingHistory = false}
   
-  constructor(options = {}) {;_class3.prototype.__init7.call(this);_class3.prototype.__init8.call(this);_class3.prototype.__init9.call(this);_class3.prototype.__init10.call(this);_class3.prototype.__init11.call(this);
+  constructor(options = {}) {;_class3.prototype.__init8.call(this);_class3.prototype.__init9.call(this);_class3.prototype.__init10.call(this);_class3.prototype.__init11.call(this);_class3.prototype.__init12.call(this);_class3.prototype.__init13.call(this);
     this.maxHistoryDepth = _nullishCoalesce(options.maxHistoryDepth, () => ( 50));
     this.onStateChange = options.onStateChange;
     this.renderer = new ImageEditorRenderer();
-    const initialAdjustments = {
-      ...DEFAULT_ADJUSTMENTS,
-      ..._optionalChain([options, 'access', _9 => _9.initialState, 'optionalAccess', _10 => _10.adjustments])
+    this.renderer.onPreviewHistogram = (histogram) => {
+      this.histogramListeners.forEach((l) => l(histogram));
     };
+    const initialAdjustments = normalizeStoredAdjustments(_optionalChain([options, 'access', _22 => _22.initialState, 'optionalAccess', _23 => _23.adjustments]));
     const initialTransform = {
       ...DEFAULT_TRANSFORM,
-      ..._optionalChain([options, 'access', _11 => _11.initialState, 'optionalAccess', _12 => _12.transform])
+      ..._optionalChain([options, 'access', _24 => _24.initialState, 'optionalAccess', _25 => _25.transform])
     };
     const initialDepthMask = {
       ...DEFAULT_DEPTH_MASK,
-      ..._optionalChain([options, 'access', _13 => _13.initialState, 'optionalAccess', _14 => _14.depthMask])
+      ..._optionalChain([options, 'access', _26 => _26.initialState, 'optionalAccess', _27 => _27.depthMask])
     };
     this.state = {
       sourceUrl: typeof options.image === "string" ? options.image : null,
       imageDimensions: { width: 800, height: 600 },
-      crop: _nullishCoalesce(_optionalChain([options, 'access', _15 => _15.initialState, 'optionalAccess', _16 => _16.crop]), () => ( null)),
+      crop: _nullishCoalesce(_optionalChain([options, 'access', _28 => _28.initialState, 'optionalAccess', _29 => _29.crop]), () => ( null)),
       transform: initialTransform,
       adjustments: initialAdjustments,
       depthMask: initialDepthMask,
-      annotations: _nullishCoalesce(_optionalChain([options, 'access', _17 => _17.initialState, 'optionalAccess', _18 => _18.annotations]), () => ( [])),
+      annotations: _nullishCoalesce(_optionalChain([options, 'access', _30 => _30.initialState, 'optionalAccess', _31 => _31.annotations]), () => ( [])),
       selectedAnnotationId: null,
       activeTool: "select",
       zoom: 1,
@@ -1162,7 +2548,7 @@ var ImageEditorController = (_class3 = class {
             height: img.naturalHeight || img.height || 600
           }
         };
-      } catch (e5) {
+      } catch (e6) {
         return { sourceUrl: src, element: null, dimensions: { ...this.state.imageDimensions } };
       }
     }
@@ -1191,7 +2577,7 @@ var ImageEditorController = (_class3 = class {
   }
   notify() {
     const currentState = { ...this.state };
-    _optionalChain([this, 'access', _19 => _19.onStateChange, 'optionalCall', _20 => _20(currentState)]);
+    _optionalChain([this, 'access', _32 => _32.onStateChange, 'optionalCall', _33 => _33(currentState)]);
     this.listeners.forEach((l) => l(currentState));
   }
   // --- History (Undo / Redo / Reset) ---
@@ -1340,16 +2726,154 @@ var ImageEditorController = (_class3 = class {
     if (commitToHistory) {
       this.recordHistory();
     }
-    this.state.adjustments = {
+    const next = {
       ...this.state.adjustments,
       ...partial
     };
+    if ("layers" in partial) {
+      const layers = normalizeAdjustmentLayers(partial.layers);
+      if (layers.length) next.layers = layers;
+      else delete next.layers;
+    }
+    this.state.adjustments = next;
     this.notify();
   }
+  /** True when the adjustments use an older rendering process than {@link LATEST_PROCESS_VERSION}. */
+  get isProcessOutdated() {
+    return normalizeProcessVersion(this.state.adjustments.process) < LATEST_PROCESS_VERSION;
+  }
+  /**
+   * Update to Current Process: re-interprets the current adjustment values with the latest
+   * rendering process (one undo step). Returns false when already current.
+   */
+  upgradeProcess() {
+    if (!this.isProcessOutdated) return false;
+    this.setAdjustments({ process: LATEST_PROCESS_VERSION });
+    return true;
+  }
+  /** Resets the base sliders (latest process). Adjustment layers are kept; see `clearAdjustmentLayers`. */
   resetAdjustments() {
     this.recordHistory();
+    const layers = this.state.adjustments.layers;
     this.state.adjustments = { ...DEFAULT_ADJUSTMENTS };
+    if (_optionalChain([layers, 'optionalAccess', _34 => _34.length])) this.state.adjustments.layers = layers;
+    this.notify();
+  }
+  // --- Adjustment layers ---
+  /** The adjustment layers, bottom (first) to top (last). */
+  getAdjustmentLayers() {
+    return _nullishCoalesce(this.state.adjustments.layers, () => ( []));
+  }
+  getAdjustmentLayer(id) {
+    return this.getAdjustmentLayers().find((l) => l.id === id);
+  }
+  setLayers(layers) {
+    const next = { ...this.state.adjustments };
+    if (layers.length) next.layers = layers;
+    else delete next.layers;
+    this.state.adjustments = next;
+  }
+  /**
+   * Adds an adjustment layer on top (or at `index`, 0 = bottom) as one undo step and returns
+   * its id. `kind` alone gives neutral parameters.
+   */
+  addAdjustmentLayer(init, index) {
+    const spec = typeof init === "string" ? { kind: init } : init;
+    const layers = [...this.getAdjustmentLayers()];
+    const layer = createAdjustmentLayer(spec.kind, {
+      id: spec.id && !layers.some((l) => l.id === spec.id) ? spec.id : void 0,
+      name: spec.name,
+      params: spec.params,
+      enabled: spec.enabled,
+      opacity: spec.opacity,
+      blend: spec.blend
+    });
+    this.recordHistory();
+    const at = index === void 0 ? layers.length : Math.max(0, Math.min(layers.length, Math.round(index)));
+    layers.splice(at, 0, layer);
+    this.setLayers(layers);
+    this.notify();
+    return layer.id;
+  }
+  /**
+   * Updates a layer (`params` merged into the current ones, then normalised). Pass
+   * `commitToHistory = false` for the moves of a drag after recording its start once.
+   * Returns false for an unknown id.
+   */
+  updateAdjustmentLayer(id, update, commitToHistory = true) {
+    const layers = this.getAdjustmentLayers();
+    const index = layers.findIndex((l) => l.id === id);
+    if (index === -1) return false;
+    const current = layers[index];
+    const merged = normalizeAdjustmentLayer({
+      ...current,
+      ...update.enabled !== void 0 ? { enabled: update.enabled } : {},
+      ...update.opacity !== void 0 ? { opacity: update.opacity } : {},
+      ...update.blend !== void 0 ? { blend: update.blend } : {},
+      ...update.name !== void 0 ? { name: update.name } : {},
+      params: { ...current.params, ..._nullishCoalesce(update.params, () => ( {})) }
+    });
+    if (!merged) return false;
+    if (commitToHistory) this.recordHistory();
+    const next = [...layers];
+    next[index] = merged;
+    this.setLayers(next);
+    this.notify();
+    return true;
+  }
+  /** Removes a layer as one undo step. Returns false for an unknown id. */
+  removeAdjustmentLayer(id) {
+    const layers = this.getAdjustmentLayers();
+    if (!layers.some((l) => l.id === id)) return false;
+    this.recordHistory();
+    this.setLayers(layers.filter((l) => l.id !== id));
+    this.notify();
+    return true;
+  }
+  /** Moves a layer to `toIndex` (0 = bottom) as one undo step. Returns false if nothing moved. */
+  moveAdjustmentLayer(id, toIndex) {
+    const layers = [...this.getAdjustmentLayers()];
+    const from = layers.findIndex((l) => l.id === id);
+    if (from === -1) return false;
+    const to = Math.max(0, Math.min(layers.length - 1, Math.round(toIndex)));
+    if (to === from) return false;
+    this.recordHistory();
+    const [layer] = layers.splice(from, 1);
+    layers.splice(to, 0, layer);
+    this.setLayers(layers);
     this.notify();
+    return true;
+  }
+  /** Shows or hides a layer (flips it without `enabled`) as one undo step. */
+  toggleAdjustmentLayer(id, enabled) {
+    const layer = this.getAdjustmentLayer(id);
+    if (!layer) return false;
+    const next = _nullishCoalesce(enabled, () => ( !layer.enabled));
+    if (next === layer.enabled) return false;
+    return this.updateAdjustmentLayer(id, { enabled: next });
+  }
+  /** Removes every adjustment layer as one undo step. */
+  clearAdjustmentLayers() {
+    if (!this.getAdjustmentLayers().length) return;
+    this.recordHistory();
+    this.setLayers([]);
+    this.notify();
+  }
+  // --- Histogram ---
+  /**
+   * Histogram of the last rendered preview (after adjustments and layers, before annotations),
+   * or `null` before the first render or without canvas pixel access.
+   */
+  getHistogram() {
+    return this.renderer.previewHistogram;
+  }
+  /** Calls `listener` now and whenever a render produces a new preview histogram. */
+  subscribeHistogram(listener) {
+    this.histogramListeners.add(listener);
+    listener(this.renderer.previewHistogram);
+    return () => {
+      this.histogramListeners.delete(listener);
+    };
   }
   // --- Depth Masking (Gleamforge) ---
   setDepthMask(partial) {
@@ -1436,7 +2960,7 @@ var ImageEditorController = (_class3 = class {
     if (!source) return;
     try {
       await this.renderer.renderToCanvas(targetCanvas, source, this.state, options);
-    } catch (e6) {
+    } catch (e7) {
     }
   }
   async renderExport(options) {
@@ -1556,15 +3080,16 @@ var ImageEditorController = (_class3 = class {
   }
   loadJSON(data) {
     this.recordHistory();
-    this.applySerializedState(data);
+    this.applySerializedState(migrateSerializedImageEditorState(data));
     this.notify();
   }
   serializeState() {
     return {
-      version: 1,
+      // States without adjustment layers keep schema 1, so they round-trip unchanged.
+      version: _optionalChain([this, 'access', _35 => _35.state, 'access', _36 => _36.adjustments, 'access', _37 => _37.layers, 'optionalAccess', _38 => _38.length]) ? IMAGE_EDITOR_SCHEMA_VERSION : 1,
       crop: this.state.crop ? { ...this.state.crop } : null,
       transform: { ...this.state.transform },
-      adjustments: { ...this.state.adjustments },
+      adjustments: serializeAdjustments(this.state.adjustments),
       depthMask: {
         ...this.state.depthMask,
         depthRange: [...this.state.depthMask.depthRange]
@@ -1575,7 +3100,7 @@ var ImageEditorController = (_class3 = class {
   applySerializedState(data) {
     this.state.crop = data.crop ? { ...data.crop } : null;
     this.state.transform = { ...data.transform };
-    this.state.adjustments = { ...data.adjustments };
+    this.state.adjustments = normalizeStoredAdjustments(data.adjustments);
     this.state.depthMask = {
       ...data.depthMask,
       depthRange: [...data.depthMask.depthRange]
@@ -1583,6 +3108,16 @@ var ImageEditorController = (_class3 = class {
     this.state.annotations = JSON.parse(JSON.stringify(data.annotations || []));
   }
 }, _class3);
+function serializeAdjustments(adjustments) {
+  const out = { ...adjustments };
+  if (_optionalChain([out, 'access', _39 => _39.layers, 'optionalAccess', _40 => _40.length])) out.layers = JSON.parse(JSON.stringify(out.layers));
+  else delete out.layers;
+  if (normalizeProcessVersion(out.process) === LEGACY_PROCESS_VERSION) {
+    delete out.process;
+    if (!out.tint) delete out.tint;
+  }
+  return out;
+}
 function scaleAnnotation(ann, sx, sy) {
   const k = Math.sqrt(Math.abs(sx * sy));
   const base = { ...ann, x: ann.x * sx, y: ann.y * sy };
@@ -1603,6 +3138,677 @@ function scaleAnnotation(ann, sx, sy) {
   }
 }
 
+// src/image-editor/document.ts
+var IMAGE_EDITOR_STATE_VERSION = 1;
+var imageEditorStateMigrations = {};
+var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var isNumber = (value) => typeof value === "number" && Number.isFinite(value);
+function expectObject(value, what) {
+  if (!isObject(value)) throw new Error(`${what} must be an object`);
+  return value;
+}
+function checkFields(value, types, what) {
+  for (const [field, ok] of Object.entries(types)) {
+    if (field in value && value[field] !== void 0 && !ok(value[field])) {
+      throw new Error(`${what}.${field} has an invalid value`);
+    }
+  }
+}
+var isBoolean = (v) => typeof v === "boolean";
+function parseCrop(value) {
+  if (value === null) return null;
+  const crop = expectObject(value, "crop");
+  for (const field of ["x", "y", "width", "height"]) {
+    if (!isNumber(crop[field])) throw new Error(`crop.${field} must be a number`);
+  }
+  return { ...crop };
+}
+function parseTransform(value) {
+  const transform = expectObject(value, "transform");
+  checkFields(transform, { rotate: isNumber, flipH: isBoolean, flipV: isBoolean }, "transform");
+  return { ...DEFAULT_TRANSFORM, ...transform };
+}
+var ADJUSTMENT_NUMBERS = [
+  "brightness",
+  "contrast",
+  "saturation",
+  "exposure",
+  "temperature",
+  "tint",
+  "blur",
+  "opacity"
+];
+function parseAdjustments(value) {
+  const adjustments = expectObject(value, "adjustments");
+  checkFields(
+    adjustments,
+    {
+      ...Object.fromEntries(ADJUSTMENT_NUMBERS.map((k) => [k, isNumber])),
+      process: (v) => v === 1 || v === 2
+    },
+    "adjustments"
+  );
+  return { ...adjustments };
+}
+function parseDepthMask(value) {
+  const mask = expectObject(value, "depthMask");
+  checkFields(
+    mask,
+    {
+      enabled: isBoolean,
+      maskSource: (v) => v === null || typeof v === "string",
+      mode: (v) => v === "threshold" || v === "brightness",
+      depthRange: (v) => Array.isArray(v) && v.length === 2 && v.every(isNumber),
+      softness: isNumber,
+      invert: isBoolean
+    },
+    "depthMask"
+  );
+  const merged = { ...DEFAULT_DEPTH_MASK, ...mask };
+  return { ...merged, depthRange: [...merged.depthRange] };
+}
+var ANNOTATION_TYPES = /* @__PURE__ */ new Set(["pen", "rect", "circle", "arrow", "line", "text", "image"]);
+var isAnnotation = (value) => isObject(value) && typeof value.id === "string" && typeof value.type === "string" && ANNOTATION_TYPES.has(value.type) && isNumber(value.x) && isNumber(value.y);
+function loadImageEditorDocument(input) {
+  let dropped = 0;
+  const result = _chunkD6FH2YAXcjs.loadDocument.call(void 0, 
+    input,
+    {
+      crop: { parse: parseCrop, defaults: null },
+      transform: { parse: parseTransform, defaults: () => ({ ...DEFAULT_TRANSFORM }) },
+      adjustments: {
+        parse: parseAdjustments,
+        // Same as what `loadJSON` derives from missing adjustments.
+        defaults: () => normalizeStoredAdjustments(void 0)
+      },
+      depthMask: {
+        parse: parseDepthMask,
+        defaults: () => ({ ...DEFAULT_DEPTH_MASK, depthRange: [...DEFAULT_DEPTH_MASK.depthRange] })
+      },
+      annotations: {
+        parse: (value) => {
+          if (!Array.isArray(value)) throw new Error("annotations must be an array");
+          const kept = value.filter(isAnnotation);
+          dropped = value.length - kept.length;
+          return JSON.parse(JSON.stringify(kept));
+        },
+        defaults: () => []
+      }
+    },
+    {
+      currentVersion: IMAGE_EDITOR_STATE_VERSION,
+      steps: imageEditorStateMigrations
+    }
+  );
+  if (dropped > 0) {
+    result.report.problems.push({
+      section: "annotations",
+      message: `${dropped} invalid annotation${dropped === 1 ? "" : "s"} dropped`
+    });
+  }
+  const state = { version: 1, ...result.value };
+  return { state, report: result.report, unknown: result.unknown };
+}
+
+// src/image-editor/controls.ts
+var plain = { kind: "plain" };
+var centered = { kind: "centered" };
+var IMAGE_ADJUSTMENT_CONTROLS = [
+  { id: "brightness", label: "Brightness", section: "light", min: -100, max: 100, step: 1, default: 0, decimals: 0, track: centered },
+  { id: "contrast", label: "Contrast", section: "light", min: -100, max: 100, step: 1, default: 0, decimals: 0, track: centered },
+  {
+    id: "saturation",
+    label: "Saturation",
+    section: "color",
+    min: -100,
+    max: 100,
+    step: 1,
+    default: 0,
+    decimals: 0,
+    track: { kind: "gradient", from: "#7a7a7a", to: "#e04a3a" }
+  },
+  { id: "exposure", label: "Exposure", section: "light", min: -100, max: 100, step: 1, default: 0, decimals: 0, track: centered },
+  { id: "temperature", label: "Warmth / Temperature", section: "color", min: -100, max: 100, step: 1, default: 0, decimals: 0, track: { kind: "temp" } },
+  { id: "tint", label: "Tint", section: "color", min: -100, max: 100, step: 1, default: 0, decimals: 0, track: { kind: "tint" }, requiresProcess: 2 },
+  { id: "blur", label: "Blur", section: "effects", min: 0, max: 30, step: 1, default: 0, decimals: 0, track: plain, unit: "px" },
+  { id: "opacity", label: "Opacity", section: "effects", min: 0, max: 1, step: 0.05, default: 1, decimals: 0, track: plain, displayScale: 100, unit: "%" }
+];
+var tone = (prefix, label) => [
+  ["0", "Cyan \u2013 Red", "#00b7c7", "#e0343a"],
+  ["1", "Magenta \u2013 Green", "#d23ad2", "#2fb34a"],
+  ["2", "Yellow \u2013 Blue", "#e0c63a", "#3a5be0"]
+].map(([i, l, from, to]) => ({
+  id: `${prefix}.${i}`,
+  label: `${label} ${l}`,
+  section: "layer",
+  min: -100,
+  max: 100,
+  step: 1,
+  default: 0,
+  decimals: 0,
+  track: { kind: "gradient", from, to }
+}));
+var levelsRecord = (ch, label) => [
+  { id: `${ch}.inBlack`, label: `${label} input black`, section: "layer", min: 0, max: 253, step: 1, default: 0, decimals: 0, track: plain },
+  { id: `${ch}.gamma`, label: `${label} gamma`, section: "layer", min: 0.1, max: 9.99, step: 0.01, default: 1, decimals: 2, track: plain },
+  { id: `${ch}.inWhite`, label: `${label} input white`, section: "layer", min: 2, max: 255, step: 1, default: 255, decimals: 0, track: plain },
+  { id: `${ch}.outBlack`, label: `${label} output black`, section: "layer", min: 0, max: 255, step: 1, default: 0, decimals: 0, track: plain },
+  { id: `${ch}.outWhite`, label: `${label} output white`, section: "layer", min: 0, max: 255, step: 1, default: 255, decimals: 0, track: plain }
+];
+var RANGE_NAMES = ["Reds", "Yellows", "Greens", "Cyans", "Blues", "Magentas"];
+var ADJUSTMENT_LAYER_CONTROLS = {
+  curves: [],
+  levels: [
+    ...levelsRecord("master", "RGB"),
+    ...levelsRecord("red", "Red"),
+    ...levelsRecord("green", "Green"),
+    ...levelsRecord("blue", "Blue")
+  ],
+  hueSaturation: [
+    { id: "hue", label: "Hue", section: "layer", min: -180, max: 180, step: 1, default: 0, decimals: 0, track: { kind: "rainbow" }, unit: "\xB0" },
+    { id: "saturation", label: "Saturation", section: "layer", min: -100, max: 100, step: 1, default: 0, decimals: 0, track: { kind: "gradient", from: "#7a7a7a", to: "#e04a3a" } },
+    { id: "lightness", label: "Lightness", section: "layer", min: -100, max: 100, step: 1, default: 0, decimals: 0, track: { kind: "gradient", from: "#000000", to: "#ffffff" } },
+    ...RANGE_NAMES.flatMap((name, i) => [
+      { id: `ranges.${i}.hue`, label: `${name} hue`, section: "layer", min: -180, max: 180, step: 1, default: 0, decimals: 0, track: { kind: "rainbow" }, unit: "\xB0" },
+      { id: `ranges.${i}.saturation`, label: `${name} saturation`, section: "layer", min: -100, max: 100, step: 1, default: 0, decimals: 0, track: centered },
+      { id: `ranges.${i}.lightness`, label: `${name} lightness`, section: "layer", min: -100, max: 100, step: 1, default: 0, decimals: 0, track: centered }
+    ])
+  ],
+  vibrance: [
+    { id: "vibrance", label: "Vibrance", section: "layer", min: -100, max: 100, step: 1, default: 0, decimals: 0, track: { kind: "gradient", from: "#7a7a7a", to: "#d8406a" } },
+    { id: "saturation", label: "Saturation", section: "layer", min: -100, max: 100, step: 1, default: 0, decimals: 0, track: { kind: "gradient", from: "#7a7a7a", to: "#e04a3a" } }
+  ],
+  colorBalance: [...tone("shadows", "Shadows"), ...tone("midtones", "Midtones"), ...tone("highlights", "Highlights")],
+  blackWhite: [
+    ["reds", "Reds", 40, "#e0343a"],
+    ["yellows", "Yellows", 60, "#e0c63a"],
+    ["greens", "Greens", 40, "#2fb34a"],
+    ["cyans", "Cyans", 60, "#00b7c7"],
+    ["blues", "Blues", 20, "#3a5be0"],
+    ["magentas", "Magentas", 80, "#d23ad2"]
+  ].map(([id, label, def, to]) => ({
+    id,
+    label,
+    section: "layer",
+    min: -200,
+    max: 300,
+    step: 1,
+    default: def,
+    decimals: 0,
+    track: { kind: "gradient", from: "#000000", to },
+    unit: "%"
+  })),
+  invert: [],
+  posterize: [{ id: "levels", label: "Levels", section: "layer", min: 2, max: 255, step: 1, default: 4, decimals: 0, track: plain }],
+  threshold: [{ id: "level", label: "Threshold level", section: "layer", min: 1, max: 255, step: 1, default: 128, decimals: 0, track: { kind: "gradient", from: "#000000", to: "#ffffff" } }],
+  photoFilter: [{ id: "density", label: "Density", section: "layer", min: 0, max: 100, step: 1, default: 25, decimals: 0, track: plain, unit: "%" }]
+};
+var ADJUSTMENT_LAYER_OPACITY_CONTROL = {
+  id: "opacity",
+  label: "Opacity",
+  section: "layer",
+  min: 0,
+  max: 1,
+  step: 0.01,
+  default: 1,
+  decimals: 0,
+  track: plain,
+  displayScale: 100,
+  unit: "%"
+};
+var BASE_BY_ID = new Map(IMAGE_ADJUSTMENT_CONTROLS.map((c) => [c.id, c]));
+function findAdjustmentControl(id) {
+  return BASE_BY_ID.get(id);
+}
+function findLayerControl(kind, id) {
+  if (id === "opacity") return ADJUSTMENT_LAYER_OPACITY_CONTROL;
+  return _optionalChain([ADJUSTMENT_LAYER_CONTROLS, 'access', _41 => _41[kind], 'optionalAccess', _42 => _42.find, 'call', _43 => _43((c) => c.id === id)]);
+}
+function clampControlValue(spec, v) {
+  if (typeof v !== "number" || !Number.isFinite(v)) return spec.default;
+  const clamped = Math.min(spec.max, Math.max(spec.min, v));
+  const steps = Math.round((clamped - spec.min) / spec.step);
+  const snapped = spec.min + steps * spec.step;
+  return Math.min(spec.max, Number(snapped.toFixed(6)));
+}
+function formatControlValue(spec, v) {
+  const shown = (Number.isFinite(v) ? v : spec.default) * (_nullishCoalesce(spec.displayScale, () => ( 1)));
+  const s = shown.toFixed(spec.decimals);
+  return `${s}${_nullishCoalesce(spec.unit, () => ( ""))}`;
+}
+function controlPosition(spec, v) {
+  const p = (clampControlValue(spec, v) - spec.min) / (spec.max - spec.min || 1);
+  return Math.min(1, Math.max(0, p));
+}
+function controlTrackBackground(spec) {
+  const t = spec.track;
+  switch (t.kind) {
+    case "temp":
+      return "linear-gradient(to right, #3a7bd5, #d8d8d8, #f2c94c)";
+    case "tint":
+      return "linear-gradient(to right, #3fbf4f, #d8d8d8, #d23ad2)";
+    case "gradient":
+      return `linear-gradient(to right, ${t.from}, ${t.to})`;
+    case "rainbow":
+      return "linear-gradient(to right, #00ffff, #0000ff, #ff00ff, #ff0000, #ffff00, #00ff00, #00ffff)";
+    default:
+      return void 0;
+  }
+}
+function getControlPath(obj, path) {
+  let cur = obj;
+  for (const part of path.split(".")) {
+    if (cur === null || cur === void 0) return void 0;
+    cur = cur[part];
+  }
+  return cur;
+}
+function setControlPath(obj, path, value) {
+  const parts = path.split(".");
+  const root = Array.isArray(obj) ? [...obj] : { ...obj };
+  let cur = root;
+  for (let i = 0; i < parts.length - 1; i++) {
+    const next = cur[parts[i]];
+    cur[parts[i]] = Array.isArray(next) ? [...next] : next && typeof next === "object" ? { ...next } : {};
+    cur = cur[parts[i]];
+  }
+  cur[parts[parts.length - 1]] = value;
+  return root;
+}
+function readAdjustmentControls(adjustments) {
+  const out = {};
+  for (const c of IMAGE_ADJUSTMENT_CONTROLS) {
+    const v = adjustments[c.id];
+    out[c.id] = typeof v === "number" && Number.isFinite(v) ? v : c.default;
+  }
+  return out;
+}
+
+// src/image-editor/tools.ts
+var LAYER_PATH = /^layers\.([^.]+)\.(.+)$/;
+function adjustmentsSummary(adjustments) {
+  return {
+    process: normalizeProcessVersion(adjustments.process),
+    values: readAdjustmentControls(adjustments),
+    layers: (_nullishCoalesce(adjustments.layers, () => ( []))).map((l) => JSON.parse(JSON.stringify(l)))
+  };
+}
+function createImageEditorToolProvider(controller, options = {}) {
+  const getAdjustments = {
+    name: "get_adjustments",
+    title: "Read image adjustments",
+    description: "Returns the image editor adjustment values by control id, the rendering process version and the adjustment layers (bottom to top).",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    annotations: {
+      title: "Read image adjustments",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    handler: () => adjustmentsSummary(controller.getState().adjustments)
+  };
+  const listControls = {
+    name: "list_controls",
+    title: "List adjustment controls",
+    description: "Lists every adjustment control (id, label, section, min, max, step, default), the parameters of each adjustment-layer kind, and the blend modes.",
+    inputSchema: { type: "object", properties: {}, additionalProperties: false },
+    annotations: {
+      title: "List adjustment controls",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    handler: () => ({
+      controls: IMAGE_ADJUSTMENT_CONTROLS.map(({ id, label, section, min, max, step, default: def, requiresProcess }) => ({
+        id,
+        label,
+        section,
+        min,
+        max,
+        step,
+        default: def,
+        ...requiresProcess ? { requiresProcess } : {}
+      })),
+      layerKinds: ADJUSTMENT_KINDS.map(({ kind, label }) => ({
+        kind,
+        label,
+        controls: [...ADJUSTMENT_LAYER_CONTROLS[kind], ADJUSTMENT_LAYER_OPACITY_CONTROL].map(({ id, label: l, min, max, step, default: def }) => ({
+          id,
+          label: l,
+          min,
+          max,
+          step,
+          default: def
+        }))
+      })),
+      blendModes: BLEND_MODES.map((m) => m.id),
+      layerPathFormat: "layers.<layerId>.<controlId>"
+    })
+  };
+  const setAdjustments = {
+    name: "set_adjustments",
+    title: "Set image adjustments",
+    description: 'Sets adjustment values by control id in one undoable step. Base controls use their id (e.g. "exposure"); layer parameters use "layers.<layerId>.<controlId>" (e.g. "layers.adj_1.vibrance"). Values are clamped to each control range; the applied values are returned.',
+    inputSchema: {
+      type: "object",
+      properties: {
+        values: {
+          type: "object",
+          description: "Map of control id to number. See list_controls for ids and ranges.",
+          additionalProperties: { type: "number" }
+        },
+        label: { type: "string", description: "Short description of the change (echoed back)." }
+      },
+      required: ["values"],
+      additionalProperties: false
+    },
+    annotations: {
+      title: "Set image adjustments",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    handler: ({ values, label }) => {
+      const entries = Object.entries(_nullishCoalesce(values, () => ( {})));
+      if (!entries.length) throw new Error('No values given. Pass {"values": {"<control id>": number}}.');
+      const state = controller.getState();
+      const base = {};
+      const layers = (_nullishCoalesce(state.adjustments.layers, () => ( []))).map((l) => ({ ...l }));
+      const applied = {};
+      const clamped = [];
+      const unknown = [];
+      for (const [id, raw] of entries) {
+        const m = LAYER_PATH.exec(id);
+        if (m) {
+          const layer = layers.find((l) => l.id === m[1]);
+          const spec2 = layer ? findLayerControl(layer.kind, m[2]) : void 0;
+          if (!layer || !spec2) {
+            unknown.push(id);
+            continue;
+          }
+          const v2 = clampControlValue(spec2, raw);
+          if (v2 !== raw) clamped.push(id);
+          if (spec2.id === "opacity") layer.opacity = v2;
+          else layer.params = setControlPath(layer.params, spec2.id, v2);
+          applied[id] = v2;
+          continue;
+        }
+        const spec = findAdjustmentControl(id);
+        if (!spec) {
+          unknown.push(id);
+          continue;
+        }
+        const v = clampControlValue(spec, raw);
+        if (v !== raw) clamped.push(id);
+        base[id] = v;
+        applied[id] = v;
+      }
+      if (unknown.length) {
+        const accepted = IMAGE_ADJUSTMENT_CONTROLS.map((c) => c.id).join(", ");
+        throw new Error(
+          `Unknown control id(s): ${unknown.join(", ")}. Accepted: ${accepted}, or layers.<layerId>.<controlId> for an existing layer.`
+        );
+      }
+      const changedLayers = Object.keys(applied).some((id) => id.startsWith("layers."));
+      controller.setAdjustments(changedLayers ? { ...base, layers } : base);
+      const result = { applied, clamped };
+      if (typeof label === "string" && label) result.label = label;
+      const notes = [];
+      if ("tint" in applied && normalizeProcessVersion(controller.getState().adjustments.process) < 2) {
+        notes.push("Tint has no effect on process 1 edits.");
+      }
+      if (notes.length) result.notes = notes;
+      return result;
+    }
+  };
+  const addLayer = {
+    name: "add_adjustment_layer",
+    title: "Add an adjustment layer",
+    description: "Adds a non-destructive adjustment layer on top of the stack (one undoable step) and returns it. Kinds: " + ADJUSTMENT_KINDS.map((k) => k.kind).join(", ") + ". Omitted params are neutral.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        kind: { type: "string", enum: ADJUSTMENT_KINDS.map((k) => k.kind) },
+        params: { type: "object", description: "Initial parameters (see list_controls); merged with neutral defaults." },
+        opacity: { type: "number", minimum: 0, maximum: 1 },
+        blend: { type: "string", enum: BLEND_MODES.map((m) => m.id) },
+        name: { type: "string" }
+      },
+      required: ["kind"],
+      additionalProperties: false
+    },
+    annotations: {
+      title: "Add an adjustment layer",
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: false,
+      openWorldHint: false
+    },
+    handler: ({ kind, params, opacity, blend, name }) => {
+      if (!isAdjustmentKind(kind)) throw new Error(`Unknown adjustment kind "${kind}".`);
+      if (blend !== void 0 && !isBlendMode(blend)) throw new Error(`Unknown blend mode "${blend}".`);
+      const id = controller.addAdjustmentLayer({ kind, params, opacity, blend, name });
+      const layer = controller.getAdjustmentLayer(id);
+      return { layer: JSON.parse(JSON.stringify(layer)), index: controller.getAdjustmentLayers().length - 1 };
+    }
+  };
+  const renderPreview = {
+    name: "render_preview",
+    title: "Render a preview",
+    description: "Renders the edited image (crop, adjustments, layers, annotations) as a PNG whose longest side is at most maxSide pixels.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        maxSide: { type: "integer", minimum: 16, maximum: 2048, description: "Longest side in pixels (default 512)." }
+      },
+      additionalProperties: false
+    },
+    annotations: {
+      title: "Render a preview",
+      readOnlyHint: true,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false
+    },
+    handler: async ({ maxSide }) => {
+      const side = Math.max(16, Math.min(2048, Math.round(typeof maxSide === "number" ? maxSide : 512)));
+      const state = controller.getState();
+      const crop = _nullishCoalesce(state.crop, () => ( { x: 0, y: 0, ...state.imageDimensions }));
+      const quarter = Math.abs(Math.round(state.transform.rotate % 180 / 90)) % 2 === 1;
+      const w = quarter ? crop.height : crop.width;
+      const h = quarter ? crop.width : crop.height;
+      const k = Math.min(1, side / Math.max(w, h, 1));
+      const dataUrl = await controller.toDataURL({
+        format: "image/png",
+        width: Math.max(1, Math.round(w * k)),
+        height: Math.max(1, Math.round(h * k))
+      });
+      const comma = dataUrl.indexOf(",");
+      if (!dataUrl.startsWith("data:image/png") || comma < 0 || comma === dataUrl.length - 1) {
+        throw new Error("Rendering is not available in this environment.");
+      }
+      return {
+        content: [
+          { type: "image", data: dataUrl.slice(comma + 1), mimeType: "image/png" },
+          { type: "text", text: `Preview ${Math.round(w * k)}\xD7${Math.round(h * k)}` }
+        ]
+      };
+    }
+  };
+  return {
+    id: _nullishCoalesce(options.id, () => ( "image-editor")),
+    namespace: options.namespace,
+    tools: [getAdjustments, listControls, setAdjustments, addLayer, renderPreview]
+  };
+}
+
+// src/image-editor/curve-editing.ts
+var clampLevel = (v) => Math.min(255, Math.max(0, Math.round(v)));
+function curvePointToBox(p, width, height) {
+  return { x: p.input / 255 * width, y: height - p.output / 255 * height };
+}
+function boxToCurvePoint(x, y, width, height) {
+  return { input: clampLevel(x / (width || 1) * 255), output: clampLevel((height - y) / (height || 1) * 255) };
+}
+function curveSvgPath(points, width, height, samples = 64) {
+  const lut = curveLutFromLevels(points);
+  const n = lut.length - 1;
+  let d = "";
+  for (let i = 0; i <= samples; i++) {
+    const t = i / samples;
+    const y = lut[Math.round(t * n)];
+    d += `${i === 0 ? "M" : " L"}${round22(t * width)} ${round22(height - y * height)}`;
+  }
+  return d;
+}
+function hitTestCurvePoint(points, x, y, width, height, radius = 8) {
+  let best = -1;
+  let bestD = radius * radius;
+  points.forEach((p, i) => {
+    const b = curvePointToBox(p, width, height);
+    const d = (b.x - x) ** 2 + (b.y - y) ** 2;
+    if (d <= bestD) {
+      best = i;
+      bestD = d;
+    }
+  });
+  return best;
+}
+function insertCurvePoint(points, p) {
+  const point = { input: clampLevel(p.input), output: clampLevel(p.output) };
+  const out = points.filter((q) => q.input !== point.input).map((q) => ({ ...q }));
+  let index = out.findIndex((q) => q.input > point.input);
+  if (index === -1) index = out.length;
+  out.splice(index, 0, point);
+  return { points: out, index };
+}
+function moveCurvePoint(points, index, p) {
+  const out = points.map((q) => ({ ...q }));
+  if (index < 0 || index >= out.length) return out;
+  const lo = index > 0 ? out[index - 1].input + 1 : 0;
+  const hi = index < out.length - 1 ? out[index + 1].input - 1 : 255;
+  out[index] = { input: Math.min(hi, Math.max(lo, clampLevel(p.input))), output: clampLevel(p.output) };
+  return out;
+}
+function removeCurvePoint(points, index) {
+  if (points.length <= 2 || index < 0 || index >= points.length) return points.map((q) => ({ ...q }));
+  return points.filter((_, i) => i !== index).map((q) => ({ ...q }));
+}
+var round22 = (v) => Math.round(v * 100) / 100;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -1630,5 +3836,5 @@ function scaleAnnotation(ann, sx, sy) {
 
 
 
-exports.DEFAULT_ADJUSTMENTS = DEFAULT_ADJUSTMENTS; exports.DEFAULT_DEPTH_MASK = DEFAULT_DEPTH_MASK; exports.DEFAULT_TRANSFORM = DEFAULT_TRANSFORM; exports.ImageEditorController = ImageEditorController; exports.ImageEditorRenderer = ImageEditorRenderer; exports.applyAdjustments = applyAdjustments; exports.applyDepthMask = applyDepthMask; exports.applyImageProjectionToContext = applyImageProjectionToContext; exports.calculateCropDrag = calculateCropDrag; exports.canvasToImagePoint = canvasToImagePoint; exports.clampCropToImage = clampCropToImage; exports.getAnnotationBounds = getAnnotationBounds; exports.getCropCursor = getCropCursor; exports.getRotatedSize = getRotatedSize; exports.getViewportMetrics = getViewportMetrics; exports.getViewportProjection = getViewportProjection; exports.globalImageCache = globalImageCache; exports.hitTestAnnotation = hitTestAnnotation; exports.hitTestCrop = hitTestCrop; exports.imageToCanvasPoint = imageToCanvasPoint; exports.isQuarterTurnSwapped = isQuarterTurnSwapped; exports.mapCropHandle = mapCropHandle; exports.normalizeAngle = normalizeAngle; exports.projectImagePoint = projectImagePoint; exports.projectImageRect = projectImageRect; exports.removeAlpha = removeAlpha; exports.unprojectCanvasPoint = unprojectCanvasPoint;
+exports.ADJUSTMENT_KINDS = ADJUSTMENT_KINDS; exports.ADJUSTMENT_LAYER_CONTROLS = ADJUSTMENT_LAYER_CONTROLS; exports.ADJUSTMENT_LAYER_OPACITY_CONTROL = ADJUSTMENT_LAYER_OPACITY_CONTROL; exports.ADJUSTMENT_LUT_SIZE = ADJUSTMENT_LUT_SIZE; exports.AS_SHOT_KELVIN = AS_SHOT_KELVIN; exports.BLEND_MODES = BLEND_MODES; exports.D65 = D65; exports.DEFAULT_ADJUSTMENTS = DEFAULT_ADJUSTMENTS; exports.DEFAULT_DEPTH_MASK = DEFAULT_DEPTH_MASK; exports.DEFAULT_TRANSFORM = DEFAULT_TRANSFORM; exports.HISTOGRAM_BINS = HISTOGRAM_BINS; exports.HUE_RANGE_LABELS = HUE_RANGE_LABELS; exports.IDENTITY_MATRIX3 = IDENTITY_MATRIX3; exports.IMAGE_ADJUSTMENT_CONTROLS = IMAGE_ADJUSTMENT_CONTROLS; exports.IMAGE_EDITOR_SCHEMA_VERSION = IMAGE_EDITOR_SCHEMA_VERSION; exports.IMAGE_EDITOR_STATE_VERSION = IMAGE_EDITOR_STATE_VERSION; exports.ImageEditorController = ImageEditorController; exports.ImageEditorRenderer = ImageEditorRenderer; exports.LATEST_PROCESS_VERSION = LATEST_PROCESS_VERSION; exports.LEGACY_PROCESS_VERSION = LEGACY_PROCESS_VERSION; exports.LUMA_709 = LUMA_709; exports.MAX_KELVIN = MAX_KELVIN; exports.MIN_KELVIN = MIN_KELVIN; exports.MIRED_PER_TEMPERATURE_UNIT = MIRED_PER_TEMPERATURE_UNIT; exports.TINT_SCALE = TINT_SCALE; exports.TONE_LUT_SIZE = TONE_LUT_SIZE; exports.VIBRANCE_GREY = VIBRANCE_GREY; exports.activeAdjustmentLayers = activeAdjustmentLayers; exports.adjustmentKindLabel = adjustmentKindLabel; exports.adjustmentLayersKey = adjustmentLayersKey; exports.applyAdjustmentLayers = applyAdjustmentLayers; exports.applyAdjustments = applyAdjustments; exports.applyDepthMask = applyDepthMask; exports.applyImageProjectionToContext = applyImageProjectionToContext; exports.applyLegacyAdjustments = applyLegacyAdjustments; exports.applyMatrix3 = applyMatrix3; exports.applyProcess2Adjustments = applyProcess2Adjustments; exports.blackWhiteGray = blackWhiteGray; exports.blendChannel = blendChannel; exports.blendImageData = blendImageData; exports.blendLum = blendLum; exports.blendPixel = blendPixel; exports.blendRgb = blendRgb; exports.boxToCurvePoint = boxToCurvePoint; exports.bradfordAdaptation = bradfordAdaptation; exports.buildToneLut = buildToneLut; exports.calculateCropDrag = calculateCropDrag; exports.canvasCompositeOperation = canvasCompositeOperation; exports.canvasToImagePoint = canvasToImagePoint; exports.clampControlValue = clampControlValue; exports.clampCropToImage = clampCropToImage; exports.colorBalanceChannel = colorBalanceChannel; exports.compileAdjustmentLayer = compileAdjustmentLayer; exports.computeHistogram = computeHistogram; exports.controlPosition = controlPosition; exports.controlTrackBackground = controlTrackBackground; exports.createAdjustmentLayer = createAdjustmentLayer; exports.createImageEditorToolProvider = createImageEditorToolProvider; exports.curveLut = curveLut; exports.curveLutFromLevels = curveLutFromLevels; exports.curvePointToBox = curvePointToBox; exports.curveSvgPath = curveSvgPath; exports.defaultAdjustmentParams = defaultAdjustmentParams; exports.evaluateAdjustmentLayers = evaluateAdjustmentLayers; exports.findAdjustmentControl = findAdjustmentControl; exports.findLayerControl = findLayerControl; exports.formatControlValue = formatControlValue; exports.getAnnotationBounds = getAnnotationBounds; exports.getControlPath = getControlPath; exports.getCropCursor = getCropCursor; exports.getRotatedSize = getRotatedSize; exports.getViewportMetrics = getViewportMetrics; exports.getViewportProjection = getViewportProjection; exports.globalImageCache = globalImageCache; exports.hexToRgb = hexToRgb; exports.histogramPath = histogramPath; exports.hitTestAnnotation = hitTestAnnotation; exports.hitTestCrop = hitTestCrop; exports.hitTestCurvePoint = hitTestCurvePoint; exports.hslToRgb = hslToRgb; exports.hueRangeTables = hueRangeTables; exports.hueRangeWeight = hueRangeWeight; exports.hueSaturation = hueSaturation; exports.identityCurve = identityCurve; exports.identityLevels = identityLevels; exports.imageEditorStateMigrations = imageEditorStateMigrations; exports.imageToCanvasPoint = imageToCanvasPoint; exports.insertCurvePoint = insertCurvePoint; exports.invertMatrix3 = invertMatrix3; exports.isAdjustmentKind = isAdjustmentKind; exports.isBlendMode = isBlendMode; exports.isQuarterTurnSwapped = isQuarterTurnSwapped; exports.isSeparableBlendMode = isSeparableBlendMode; exports.kelvinToTemperature = kelvinToTemperature; exports.levelsValue = levelsValue; exports.linearSrgbToXy = linearSrgbToXy; exports.linearToSrgb = linearToSrgb; exports.loadImageEditorDocument = loadImageEditorDocument; exports.mapCropHandle = mapCropHandle; exports.migrateSerializedImageEditorState = migrateSerializedImageEditorState; exports.moveCurvePoint = moveCurvePoint; exports.mulMatrix3 = mulMatrix3; exports.neutralHueRange = neutralHueRange; exports.normalizeAdjustmentLayer = normalizeAdjustmentLayer; exports.normalizeAdjustmentLayers = normalizeAdjustmentLayers; exports.normalizeAngle = normalizeAngle; exports.normalizeBlendMode = normalizeBlendMode; exports.normalizeProcessVersion = normalizeProcessVersion; exports.normalizeStoredAdjustments = normalizeStoredAdjustments; exports.photoFilterMatrix = photoFilterMatrix; exports.posterizeValue = posterizeValue; exports.projectImagePoint = projectImagePoint; exports.projectImageRect = projectImageRect; exports.rangeLightness = rangeLightness; exports.readAdjustmentControls = readAdjustmentControls; exports.removeAlpha = removeAlpha; exports.removeCurvePoint = removeCurvePoint; exports.rgbToGray = rgbToGray; exports.rgbToHsl = rgbToHsl; exports.sampleLut = sampleLut; exports.sampleToneLut = sampleToneLut; exports.setControlPath = setControlPath; exports.setLum = setLum; exports.srgbToLinear = srgbToLinear; exports.tempTintToXy = tempTintToXy; exports.temperatureToKelvin = temperatureToKelvin; exports.toneCurve = toneCurve; exports.toneLuts = toneLuts; exports.unprojectCanvasPoint = unprojectCanvasPoint; exports.uvToXy = uvToXy; exports.vibranceLinear = vibranceLinear; exports.vibrancePixel = vibrancePixel; exports.wbMatrix = wbMatrix; exports.whiteBalanceFromSample = whiteBalanceFromSample; exports.whiteBalanceMatrix = whiteBalanceMatrix; exports.xyToTempTint = xyToTempTint; exports.xyToUv = xyToUv;
 //# sourceMappingURL=index.cjs.map