@pixerate/editor 0.113.0 → 0.114.0

package/dist/chunk-BRLYOPLT.js

@@ -0,0 +1,2574 @@
+import {
+  deflate,
+  inflate
+} from "./chunk-6FCKOS2B.js";
+
+// src/cms/math.ts
+var D50 = [0.9642, 1, 0.8249];
+var D65_XY = [0.3127, 0.329];
+var IDENTITY = [
+  [1, 0, 0],
+  [0, 1, 0],
+  [0, 0, 1]
+];
+function mul(a, b) {
+  const o = [
+    [0, 0, 0],
+    [0, 0, 0],
+    [0, 0, 0]
+  ];
+  for (let i = 0; i < 3; i++) for (let j = 0; j < 3; j++) o[i][j] = a[i][0] * b[0][j] + a[i][1] * b[1][j] + a[i][2] * b[2][j];
+  return o;
+}
+function apply(m, v) {
+  return [m[0][0] * v[0] + m[0][1] * v[1] + m[0][2] * v[2], m[1][0] * v[0] + m[1][1] * v[1] + m[1][2] * v[2], m[2][0] * v[0] + m[2][1] * v[1] + m[2][2] * v[2]];
+}
+function det(m) {
+  return m[0][0] * (m[1][1] * m[2][2] - m[1][2] * m[2][1]) - m[0][1] * (m[1][0] * m[2][2] - m[1][2] * m[2][0]) + m[0][2] * (m[1][0] * m[2][1] - m[1][1] * m[2][0]);
+}
+function invert(m) {
+  const d = det(m);
+  if (!Number.isFinite(d) || Math.abs(d) < 1e-12) return null;
+  const k = 1 / d;
+  return [
+    [(m[1][1] * m[2][2] - m[1][2] * m[2][1]) * k, (m[0][2] * m[2][1] - m[0][1] * m[2][2]) * k, (m[0][1] * m[1][2] - m[0][2] * m[1][1]) * k],
+    [(m[1][2] * m[2][0] - m[1][0] * m[2][2]) * k, (m[0][0] * m[2][2] - m[0][2] * m[2][0]) * k, (m[0][2] * m[1][0] - m[0][0] * m[1][2]) * k],
+    [(m[1][0] * m[2][1] - m[1][1] * m[2][0]) * k, (m[0][1] * m[2][0] - m[0][0] * m[2][1]) * k, (m[0][0] * m[1][1] - m[0][1] * m[1][0]) * k]
+  ];
+}
+function xyToXyz(xy) {
+  const [x, y] = xy;
+  return [x / y, 1, (1 - x - y) / y];
+}
+var BRADFORD = [
+  [0.8951, 0.2664, -0.1614],
+  [-0.7502, 1.7135, 0.0367],
+  [0.0389, -0.0685, 1.0296]
+];
+function bradford(src, dst) {
+  const inv = invert(BRADFORD);
+  const s = apply(BRADFORD, src);
+  const d = apply(BRADFORD, dst);
+  const scale = [
+    [d[0] / s[0], 0, 0],
+    [0, d[1] / s[1], 0],
+    [0, 0, d[2] / s[2]]
+  ];
+  return mul(inv, mul(scale, BRADFORD));
+}
+function rgbToXyzMatrix(r, g, b, white) {
+  const xr = xyToXyz(r);
+  const xg = xyToXyz(g);
+  const xb = xyToXyz(b);
+  const m = [
+    [xr[0], xg[0], xb[0]],
+    [xr[1], xg[1], xb[1]],
+    [xr[2], xg[2], xb[2]]
+  ];
+  const inv = invert(m);
+  if (!inv) return null;
+  const s = apply(inv, white);
+  return [
+    [m[0][0] * s[0], m[0][1] * s[1], m[0][2] * s[2]],
+    [m[1][0] * s[0], m[1][1] * s[1], m[1][2] * s[2]],
+    [m[2][0] * s[0], m[2][1] * s[1], m[2][2] * s[2]]
+  ];
+}
+var EPS = 216 / 24389;
+var KAPPA = 24389 / 27;
+var labF = (t) => t > EPS ? Math.cbrt(t) : (KAPPA * t + 16) / 116;
+var labFinv = (f) => {
+  const f3 = f * f * f;
+  return f3 > EPS ? f3 : (116 * f - 16) / KAPPA;
+};
+function xyzToLab(xyz, white = D50) {
+  const fx = labF(xyz[0] / white[0]);
+  const fy = labF(xyz[1] / white[1]);
+  const fz = labF(xyz[2] / white[2]);
+  return [116 * fy - 16, 500 * (fx - fy), 200 * (fy - fz)];
+}
+function labToXyz(lab, white = D50) {
+  const fy = (lab[0] + 16) / 116;
+  const fx = fy + lab[1] / 500;
+  const fz = fy - lab[2] / 200;
+  return [labFinv(fx) * white[0], labFinv(fy) * white[1], labFinv(fz) * white[2]];
+}
+function deltaE76(a, b) {
+  return Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
+}
+var s15f16Round = (v) => Math.round(v * 65536) / 65536;
+var d50Quantized = () => [s15f16Round(D50[0]), s15f16Round(D50[1]), s15f16Round(D50[2])];
+
+// src/cms/curve.ts
+var IDENTITY_CURVE = { type: "identity" };
+function srgbTrc() {
+  return { type: "parametric", kind: 3, p: [2.4, 1 / 1.055, 0.055 / 1.055, 1 / 12.92, 0.04045, 0, 0] };
+}
+var gammaCurve = (g) => ({ type: "gamma", gamma: g });
+function paramCount(kind) {
+  return kind === 0 ? 1 : kind === 1 ? 3 : kind === 2 ? 4 : kind === 3 ? 5 : 7;
+}
+function isIdentityCurve(c) {
+  switch (c.type) {
+    case "identity":
+      return true;
+    case "gamma":
+      return Math.abs(c.gamma - 1) < 1e-9;
+    case "parametric":
+      return c.kind === 0 && Math.abs(c.p[0] - 1) < 1e-9;
+    case "table": {
+      const n = c.table.length;
+      if (n < 2) return true;
+      for (let i = 0; i < n; i++) if (Math.abs(c.table[i] - i / (n - 1)) >= 1 / 65535) return false;
+      return true;
+    }
+  }
+}
+var mirror = (x, f) => x < 0 ? -f(-x) : f(x);
+var pw = (base, g) => base <= 0 ? 0 : Math.pow(base, g);
+function para(kind, p, x) {
+  const [g, a, b, c, d, e, f] = p;
+  switch (kind) {
+    case 0:
+      return mirror(x, (v) => Math.pow(v, g));
+    case 1:
+      return a !== 0 && x >= -b / a ? pw(a * x + b, g) : 0;
+    case 2:
+      return a !== 0 && x >= -b / a ? pw(a * x + b, g) + c : c;
+    case 3:
+      if (x < 0 && b === 0 && d === 0) return -para(kind, p, -x);
+      return x >= d ? pw(a * x + b, g) : c * x;
+    default:
+      return x >= d ? pw(a * x + b, g) + e : c * x + f;
+  }
+}
+function paraInverse(kind, p, y) {
+  const [g, a, b, c, d, e, f] = p;
+  if (Math.abs(g) < 1e-12) return null;
+  const root = (v) => v <= 0 ? 0 : Math.pow(v, 1 / g);
+  switch (kind) {
+    case 0:
+      return mirror(y, (v) => Math.pow(v, 1 / g));
+    case 1:
+      if (a === 0) return null;
+      return y <= 0 ? -b / a : (root(y) - b) / a;
+    case 2:
+      if (a === 0) return null;
+      return y <= c ? -b / a : (root(y - c) - b) / a;
+    case 3: {
+      if (a === 0) return null;
+      if (y < 0 && b === 0 && d === 0) {
+        const v = paraInverse(kind, p, -y);
+        return v === null ? null : -v;
+      }
+      const yd = pw(a * d + b, g);
+      if (y >= yd) return (root(y) - b) / a;
+      return c !== 0 ? y / c : 0;
+    }
+    default: {
+      if (a === 0) return null;
+      const yd = pw(a * d + b, g) + e;
+      if (y >= yd) return (root(y - e) - b) / a;
+      return c !== 0 ? (y - f) / c : 0;
+    }
+  }
+}
+function numericInverse(f, y) {
+  const increasing = f(1) >= f(0);
+  let lo = 0;
+  let hi = 1;
+  for (let k = 0; k < 60; k++) {
+    const mid = 0.5 * (lo + hi);
+    if (f(mid) < y === increasing) lo = mid;
+    else hi = mid;
+  }
+  return 0.5 * (lo + hi);
+}
+function table(t, x) {
+  const n = t.length;
+  if (n === 0) return x;
+  if (n === 1) return t[0];
+  const pos = Math.min(1, Math.max(0, x)) * (n - 1);
+  const i = Math.min(n - 2, Math.floor(pos));
+  const f = pos - i;
+  return t[i] + (t[i + 1] - t[i]) * f;
+}
+function edgeIndex(t, start) {
+  const n = t.length;
+  if (start) {
+    const v2 = t[0];
+    let i2 = n - 1;
+    for (let k = 0; k < n; k++) {
+      if (Math.abs(t[k] - v2) > 1e-7) {
+        i2 = k - 1;
+        break;
+      }
+    }
+    return i2 / (n - 1);
+  }
+  const v = t[n - 1];
+  let i = 0;
+  for (let k = n - 1; k >= 0; k--) {
+    if (Math.abs(t[k] - v) > 1e-7) {
+      i = k + 1;
+      break;
+    }
+  }
+  return i / (n - 1);
+}
+function tableInverse(t, y) {
+  const n = t.length;
+  if (n < 2) return y;
+  const increasing = t[n - 1] >= t[0];
+  const loV = increasing ? t[0] : t[n - 1];
+  const hiV = increasing ? t[n - 1] : t[0];
+  if (y <= loV) return edgeIndex(t, increasing);
+  if (y >= hiV) return edgeIndex(t, !increasing);
+  let lo = 0;
+  let hi = n - 1;
+  while (hi - lo > 1) {
+    const mid = lo + hi >> 1;
+    if (t[mid] < y === increasing) lo = mid;
+    else hi = mid;
+  }
+  const a = t[lo];
+  const b = t[hi];
+  const f = Math.abs(b - a) > 1e-12 ? (y - a) / (b - a) : 0.5;
+  return (lo + f) / (n - 1);
+}
+function evalCurve(c, x) {
+  switch (c.type) {
+    case "identity":
+      return x;
+    case "gamma":
+      return mirror(x, (v) => Math.pow(v, c.gamma));
+    case "parametric":
+      return para(c.kind, c.p, x);
+    case "table":
+      return table(c.table, x);
+  }
+}
+function evalCurveInverse(c, y) {
+  switch (c.type) {
+    case "identity":
+      return y;
+    case "gamma":
+      return Math.abs(c.gamma) < 1e-12 ? y : mirror(y, (v) => Math.pow(v, 1 / c.gamma));
+    case "parametric":
+      return paraInverse(c.kind, c.p, y) ?? numericInverse((x) => para(c.kind, c.p, x), y);
+    case "table":
+      return tableInverse(c.table, y);
+  }
+}
+function sampleCurve(c, n) {
+  const out = new Float32Array(n);
+  for (let i = 0; i < n; i++) out[i] = evalCurve(c, i / (n - 1));
+  return out;
+}
+
+// src/cms/clut.ts
+var MAX_CHANNELS = 15;
+var Clut = class _Clut {
+  constructor(grid, outputs, data) {
+    this.grid = grid;
+    this.outputs = outputs;
+    this.data = data;
+    const inputs = grid.length;
+    if (inputs < 1 || inputs > MAX_CHANNELS || outputs < 1 || outputs > MAX_CHANNELS) throw new RangeError("bad CLUT dimensions");
+    this.inputs = inputs;
+    this.strides = new Array(inputs).fill(0);
+    let s = outputs;
+    for (let i = inputs - 1; i >= 0; i--) {
+      this.strides[i] = s;
+      s *= Math.max(1, grid[i]);
+    }
+    if (data.length !== s) throw new RangeError(`CLUT data length ${data.length}, expected ${s}`);
+  }
+  grid;
+  outputs;
+  data;
+  inputs;
+  strides;
+  get nodes() {
+    return this.data.length / this.outputs;
+  }
+  /** A table sampled from `f` at every node. */
+  static sample(grid, outputs, f) {
+    const inputs = grid.length;
+    const total = grid.reduce((a, b) => a * b, 1);
+    const data = new Float32Array(total * outputs);
+    const idx = new Array(inputs).fill(0);
+    const inp = new Float32Array(inputs);
+    for (let node = 0; node < total; node++) {
+      let rem = node;
+      for (let d = inputs - 1; d >= 0; d--) {
+        idx[d] = rem % grid[d];
+        rem = Math.floor(rem / grid[d]);
+      }
+      for (let d = 0; d < inputs; d++) inp[d] = grid[d] > 1 ? idx[d] / (grid[d] - 1) : 0;
+      f(inp, data.subarray(node * outputs, (node + 1) * outputs));
+    }
+    return new _Clut(grid, outputs, data);
+  }
+  /** Base offset, fraction and stride along input `d` at `v`. */
+  locate(d, v, out, k) {
+    const n = this.grid[d];
+    if (n < 2) {
+      out[k] = 0;
+      out[k + 1] = 0;
+      out[k + 2] = 0;
+      return;
+    }
+    const p = Math.min(1, Math.max(0, v)) * (n - 1);
+    const i = Math.min(n - 2, Math.floor(p));
+    out[k] = i * this.strides[d];
+    out[k + 1] = p - i;
+    out[k + 2] = this.strides[d];
+  }
+  loc = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+  lo = new Float32Array(MAX_CHANNELS);
+  hi = new Float32Array(MAX_CHANNELS);
+  eval(input, out) {
+    const L = this.loc;
+    switch (this.inputs) {
+      case 1: {
+        this.locate(0, input[0], L, 0);
+        const [b, r, s] = L;
+        for (let k = 0; k < this.outputs; k++) {
+          const a = this.data[b + k];
+          const c = s > 0 ? this.data[b + s + k] : a;
+          out[k] = a + (c - a) * r;
+        }
+        return;
+      }
+      case 3:
+        this.locate(0, input[0], L, 0);
+        this.locate(1, input[1], L, 3);
+        this.locate(2, input[2], L, 6);
+        this.tetra(L[0] + L[3] + L[6], L[2], L[5], L[8], L[1], L[4], L[7], out);
+        return;
+      case 4: {
+        this.locate(0, input[0], L, 0);
+        this.locate(1, input[1], L, 3);
+        this.locate(2, input[2], L, 6);
+        this.locate(3, input[3], L, 9);
+        const base = L[0] + L[3] + L[6] + L[9];
+        const r0 = L[1];
+        const s0 = L[2];
+        this.tetra(base, L[5], L[8], L[11], L[4], L[7], L[10], this.lo);
+        if (r0 > 0 && s0 > 0) {
+          this.tetra(base + s0, L[5], L[8], L[11], L[4], L[7], L[10], this.hi);
+          for (let k = 0; k < this.outputs; k++) out[k] = this.lo[k] + (this.hi[k] - this.lo[k]) * r0;
+        } else for (let k = 0; k < this.outputs; k++) out[k] = this.lo[k];
+        return;
+      }
+      default:
+        this.evalMultilinear(input, out);
+    }
+  }
+  /** Tetrahedral interpolation in one cube at `base` with strides `sx, sy, sz` and fractions `rx, ry, rz`. */
+  tetra(base, sx, sy, sz, rx, ry, rz, out) {
+    const d = this.data;
+    let p1, p2, p3, w1, w2, w3;
+    const sxy = sx + sy;
+    const sall = sxy + sz;
+    if (rx >= ry) {
+      if (ry >= rz) {
+        p1 = sx;
+        p2 = sxy;
+        p3 = sall;
+        w1 = rx;
+        w2 = ry;
+        w3 = rz;
+      } else if (rx >= rz) {
+        p1 = sx;
+        p2 = sx + sz;
+        p3 = sall;
+        w1 = rx;
+        w2 = rz;
+        w3 = ry;
+      } else {
+        p1 = sz;
+        p2 = sx + sz;
+        p3 = sall;
+        w1 = rz;
+        w2 = rx;
+        w3 = ry;
+      }
+    } else if (rx >= rz) {
+      p1 = sy;
+      p2 = sxy;
+      p3 = sall;
+      w1 = ry;
+      w2 = rx;
+      w3 = rz;
+    } else if (ry >= rz) {
+      p1 = sy;
+      p2 = sy + sz;
+      p3 = sall;
+      w1 = ry;
+      w2 = rz;
+      w3 = rx;
+    } else {
+      p1 = sz;
+      p2 = sy + sz;
+      p3 = sall;
+      w1 = rz;
+      w2 = ry;
+      w3 = rx;
+    }
+    for (let k = 0; k < this.outputs; k++) {
+      const v0 = d[base + k];
+      const v1 = d[base + p1 + k];
+      const v2 = d[base + p2 + k];
+      const v3 = d[base + p3 + k];
+      out[k] = v0 + (v1 - v0) * w1 + (v2 - v1) * w2 + (v3 - v2) * w3;
+    }
+  }
+  evalMultilinear(input, out) {
+    const n = this.inputs;
+    let base = 0;
+    const r = new Array(n);
+    const s = new Array(n);
+    const L = [0, 0, 0];
+    for (let d = 0; d < n; d++) {
+      this.locate(d, input[d], L, 0);
+      base += L[0];
+      r[d] = L[1];
+      s[d] = L[2];
+    }
+    const o = this.outputs;
+    for (let k = 0; k < o; k++) out[k] = 0;
+    for (let corner = 0; corner < 1 << n; corner++) {
+      let w = 1;
+      let off = base;
+      for (let d = 0; d < n; d++) {
+        if (corner & 1 << d) {
+          w *= r[d];
+          off += s[d];
+        } else w *= 1 - r[d];
+      }
+      if (w === 0) continue;
+      for (let k = 0; k < o; k++) out[k] += w * this.data[off + k];
+    }
+  }
+};
+
+// src/cms/pipeline.ts
+var MAX_PIPE = 16;
+var XYZ_SCALE = 65535 / 32768;
+var V2_L = 100 * 65535 / 65280;
+var V2_AB = 255 * 65535 / 65280;
+var clamp01 = (v) => v < 0 ? 0 : v > 1 ? 1 : v;
+function matrix3(m) {
+  return { kind: "matrix", rows: 3, cols: 3, m: [...m[0], ...m[1], ...m[2]], offset: [0, 0, 0] };
+}
+function stageOutputs(s, n) {
+  return s.kind === "matrix" ? s.rows : s.kind === "clut" ? s.clut.outputs : n;
+}
+var EPS2 = 216 / 24389;
+var KAPPA2 = 24389 / 27;
+function runStage(s, v, n, tmp, tmpIn, tmpOut) {
+  switch (s.kind) {
+    case "curves":
+      for (let k = 0; k < s.curves.length; k++) v[k] = evalCurve(s.curves[k], v[k]);
+      return n;
+    case "inv-curves":
+      for (let k = 0; k < s.curves.length; k++) v[k] = evalCurveInverse(s.curves[k], v[k]);
+      return n;
+    case "matrix": {
+      for (let r = 0; r < s.rows; r++) {
+        let acc = s.offset[r];
+        for (let c = 0; c < s.cols; c++) acc += s.m[r * s.cols + c] * v[c];
+        tmp[r] = acc;
+      }
+      for (let r = 0; r < s.rows; r++) v[r] = tmp[r];
+      return s.rows;
+    }
+    case "clut": {
+      const c = s.clut;
+      for (let k = 0; k < c.inputs; k++) tmpIn[k] = v[k];
+      c.eval(tmpIn, tmpOut);
+      for (let k = 0; k < c.outputs; k++) v[k] = tmpOut[k];
+      return c.outputs;
+    }
+    case "lab-to-xyz": {
+      const fy = (v[0] + 16) / 116;
+      const fx = fy + v[1] / 500;
+      const fz = fy - v[2] / 200;
+      const finv = (f) => {
+        const f3 = f * f * f;
+        return f3 > EPS2 ? f3 : (116 * f - 16) / KAPPA2;
+      };
+      v[0] = finv(fx) * D50[0];
+      v[1] = finv(fy) * D50[1];
+      v[2] = finv(fz) * D50[2];
+      return 3;
+    }
+    case "xyz-to-lab": {
+      const f = (t) => t > EPS2 ? Math.cbrt(t) : (KAPPA2 * t + 16) / 116;
+      const fx = f(Math.max(0, v[0]) / D50[0]);
+      const fy = f(Math.max(0, v[1]) / D50[1]);
+      const fz = f(Math.max(0, v[2]) / D50[2]);
+      v[0] = 116 * fy - 16;
+      v[1] = 500 * (fx - fy);
+      v[2] = 200 * (fy - fz);
+      return 3;
+    }
+    case "decode-lab-v4":
+      v[0] *= 100;
+      v[1] = v[1] * 255 - 128;
+      v[2] = v[2] * 255 - 128;
+      return 3;
+    case "encode-lab-v4":
+      v[0] = clamp01(v[0] / 100);
+      v[1] = clamp01((v[1] + 128) / 255);
+      v[2] = clamp01((v[2] + 128) / 255);
+      return 3;
+    case "decode-lab-v2":
+      v[0] *= V2_L;
+      v[1] = v[1] * V2_AB - 128;
+      v[2] = v[2] * V2_AB - 128;
+      return 3;
+    case "encode-lab-v2":
+      v[0] = clamp01(v[0] / V2_L);
+      v[1] = clamp01((v[1] + 128) / V2_AB);
+      v[2] = clamp01((v[2] + 128) / V2_AB);
+      return 3;
+    case "decode-xyz":
+      for (let k = 0; k < 3; k++) v[k] *= XYZ_SCALE;
+      return 3;
+    case "encode-xyz":
+      for (let k = 0; k < 3; k++) v[k] = clamp01(v[k] / XYZ_SCALE);
+      return 3;
+    case "clamp01":
+      for (let k = 0; k < n; k++) v[k] = clamp01(v[k]);
+      return n;
+  }
+}
+var Pipeline = class {
+  constructor(inputs, stages) {
+    this.inputs = inputs;
+    this.stages = stages;
+    this.outputs = stages.reduce((n, s) => stageOutputs(s, n), inputs);
+  }
+  inputs;
+  stages;
+  outputs;
+  v = new Float64Array(MAX_PIPE);
+  tmp = new Float64Array(MAX_PIPE);
+  tmpIn = new Float32Array(MAX_PIPE);
+  tmpOut = new Float32Array(MAX_PIPE);
+  extend(stages) {
+    for (const s of stages) {
+      this.outputs = stageOutputs(s, this.outputs);
+      this.stages.push(s);
+    }
+  }
+  /** Evaluates one colour: `input` has `inputs` values, `out` receives `outputs`. */
+  eval(input, out) {
+    const v = this.v;
+    for (let k = 0; k < this.inputs; k++) v[k] = input[k];
+    let n = this.inputs;
+    for (const s of this.stages) n = runStage(s, v, n, this.tmp, this.tmpIn, this.tmpOut);
+    for (let k = 0; k < this.outputs; k++) out[k] = v[k];
+  }
+  /** Removes no-op stages, cancels adjacent inverse pairs and merges consecutive 3×3 matrices. */
+  optimize() {
+    const out = [];
+    for (const s of this.stages) {
+      const noop = (s.kind === "curves" || s.kind === "inv-curves") && s.curves.every(isIdentityCurve) || s.kind === "matrix" && s.rows === 3 && s.cols === 3 && s.offset.every((o) => Math.abs(o) < 1e-12) && s.m.every((v, i) => Math.abs(v - (i % 4 === 0 ? 1 : 0)) < 1e-12);
+      if (noop) continue;
+      const last = out[out.length - 1];
+      const pair = last ? `${last.kind}>${s.kind}` : "";
+      const cancels = [
+        "lab-to-xyz>xyz-to-lab",
+        "xyz-to-lab>lab-to-xyz",
+        "encode-lab-v4>decode-lab-v4",
+        "encode-lab-v2>decode-lab-v2",
+        "encode-xyz>decode-xyz",
+        "decode-lab-v4>encode-lab-v4",
+        "decode-lab-v2>encode-lab-v2",
+        "decode-xyz>encode-xyz"
+      ].includes(pair);
+      if (cancels) {
+        out.pop();
+        continue;
+      }
+      if (last && last.kind === "matrix" && s.kind === "matrix" && last.rows === 3 && last.cols === 3 && s.rows === 3 && s.cols === 3) {
+        const a = last.m;
+        const b = s.m;
+        const m = new Array(9).fill(0);
+        const off = [0, 0, 0];
+        for (let r = 0; r < 3; r++) {
+          for (let c = 0; c < 3; c++) for (let k = 0; k < 3; k++) m[r * 3 + c] += b[r * 3 + k] * a[k * 3 + c];
+          off[r] = b[r * 3] * last.offset[0] + b[r * 3 + 1] * last.offset[1] + b[r * 3 + 2] * last.offset[2] + s.offset[r];
+        }
+        out.pop();
+        out.push({ kind: "matrix", rows: 3, cols: 3, m, offset: off });
+        continue;
+      }
+      out.push(s);
+    }
+    this.stages = out;
+    this.outputs = out.reduce((n, s) => stageOutputs(s, n), this.inputs);
+  }
+};
+
+// src/cms/profile.ts
+var INTENTS = ["perceptual", "relative", "saturation", "absolute"];
+var INTENT_CODES = { perceptual: 0, relative: 1, saturation: 2, absolute: 3 };
+var intentCode = (i) => INTENT_CODES[i];
+var intentFromCode = (n) => INTENTS[n] ?? null;
+var CmsError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CmsError";
+  }
+};
+var CLASS_SIGS = { scnr: "input", mntr: "display", prtr: "output", link: "link", spac: "colorspace", abst: "abstract", nmcl: "named" };
+var classSig = (c) => Object.entries(CLASS_SIGS).find(([, v]) => v === c)?.[0] ?? "mntr";
+var SPACE_SIGS = {
+  "XYZ ": "xyz",
+  "Lab ": "lab",
+  "Luv ": "luv",
+  YCbr: "ycbcr",
+  "Yxy ": "yxy",
+  "RGB ": "rgb",
+  GRAY: "gray",
+  "HSV ": "hsv",
+  "HLS ": "hls",
+  CMYK: "cmyk",
+  "CMY ": "cmy"
+};
+function spaceFromSig(s) {
+  if (SPACE_SIGS[s]) return SPACE_SIGS[s];
+  const m = /^([2-9A-F])CLR$/.exec(s);
+  if (m) return `${parseInt(m[1], 16)}clr`;
+  return "unknown";
+}
+function spaceSig(c) {
+  const hit = Object.entries(SPACE_SIGS).find(([, v]) => v === c);
+  if (hit) return hit[0];
+  const m = /^(\d+)clr$/.exec(c);
+  if (m) return `${Number(m[1]).toString(16).toUpperCase()}CLR`;
+  return "RGB ";
+}
+function spaceChannels(c) {
+  if (c === "gray") return 1;
+  if (c === "cmyk") return 4;
+  if (c === "unknown") return 0;
+  const m = /^(\d+)clr$/.exec(c);
+  return m ? Number(m[1]) : 3;
+}
+function profileChannels(p) {
+  return spaceChannels(p.colorSpace);
+}
+var SAME_COLORS_MAX_DELTA_E = 0.5;
+function mediaWhite(p) {
+  if (p.version[0] < 4 && p.profileClass === "display") return [D50[0], D50[1], D50[2]];
+  return p.whitePoint;
+}
+function isMatrixShaper(p) {
+  return p.a2b.every((l) => !l) && (p.matrix !== null && p.trc !== null || p.grayTrc !== null);
+}
+var lutIndex = (intent) => intent === "perceptual" ? 0 : intent === "saturation" ? 2 : 1;
+function lutFor(luts, intent) {
+  return luts[lutIndex(intent)] ?? luts[0];
+}
+function supportsIntent(p, intent, input) {
+  const luts = input ? p.a2b : p.b2a;
+  return Boolean(luts[lutIndex(intent)]) || luts.every((l) => !l);
+}
+function decodePcs(pcs, kind) {
+  if (pcs === "xyz") return { kind: "decode-xyz" };
+  return kind === "lut16" ? { kind: "decode-lab-v2" } : { kind: "decode-lab-v4" };
+}
+function encodePcs(pcs, kind) {
+  if (pcs === "xyz") return { kind: "encode-xyz" };
+  return kind === "lut16" ? { kind: "encode-lab-v2" } : { kind: "encode-lab-v4" };
+}
+function deviceToPcs(p, intent) {
+  const l = lutFor(p.a2b, intent);
+  if (l) return { stages: [...l.stages, decodePcs(p.pcs, l.kind)], pcs: p.pcs };
+  switch (p.colorSpace) {
+    case "rgb":
+      if (!p.matrix || !p.trc) throw new CmsError("RGB profile without matrix/TRC or AToB tags");
+      return { stages: [{ kind: "curves", curves: [...p.trc] }, matrix3(p.matrix)], pcs: "xyz" };
+    case "gray": {
+      if (!p.grayTrc) throw new CmsError("gray profile without kTRC");
+      if (p.pcs === "lab") return { stages: [{ kind: "curves", curves: [p.grayTrc] }, { kind: "matrix", rows: 3, cols: 1, m: [100, 0, 0], offset: [0, 0, 0] }], pcs: "lab" };
+      return { stages: [{ kind: "curves", curves: [p.grayTrc] }, { kind: "matrix", rows: 3, cols: 1, m: [D50[0], D50[1], D50[2]], offset: [0, 0, 0] }], pcs: "xyz" };
+    }
+    case "lab":
+      return { stages: [{ kind: "decode-lab-v4" }], pcs: "lab" };
+    case "xyz":
+      return { stages: [{ kind: "decode-xyz" }], pcs: "xyz" };
+    default:
+      throw new CmsError(`${p.colorSpace} profile without AToB tags`);
+  }
+}
+function pcsToDevice(p, intent) {
+  const l = lutFor(p.b2a, intent);
+  if (l) return { stages: [encodePcs(p.pcs, l.kind), ...l.stages], pcs: p.pcs };
+  switch (p.colorSpace) {
+    case "rgb": {
+      if (!p.matrix || !p.trc) throw new CmsError("RGB profile without matrix/TRC or BToA tags");
+      const inv = invert(p.matrix);
+      if (!inv) throw new CmsError("singular colorant matrix");
+      return { stages: [matrix3(inv), { kind: "inv-curves", curves: [...p.trc] }], pcs: "xyz" };
+    }
+    case "gray": {
+      if (!p.grayTrc) throw new CmsError("gray profile without kTRC");
+      if (p.pcs === "lab") return { stages: [{ kind: "matrix", rows: 1, cols: 3, m: [0.01, 0, 0], offset: [0] }, { kind: "inv-curves", curves: [p.grayTrc] }], pcs: "lab" };
+      return { stages: [{ kind: "matrix", rows: 1, cols: 3, m: [0, 1, 0], offset: [0] }, { kind: "inv-curves", curves: [p.grayTrc] }], pcs: "xyz" };
+    }
+    case "lab":
+      return { stages: [{ kind: "encode-lab-v4" }], pcs: "lab" };
+    case "xyz":
+      return { stages: [{ kind: "encode-xyz" }], pcs: "xyz" };
+    default:
+      throw new CmsError(`${p.colorSpace} profile without BToA tags`);
+  }
+}
+function canBeDestination(p) {
+  try {
+    for (const i of ["perceptual", "relative", "saturation"]) pcsToDevice(p, i);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function grayAsRgb(p) {
+  if (!p.grayTrc || p.pcs !== "xyz") return null;
+  const w = D50;
+  const c = p.grayTrc;
+  return {
+    ...p,
+    colorSpace: "rgb",
+    description: `${p.description} (as RGB)`,
+    matrix: [
+      [w[0] / 3, w[0] / 3, w[0] / 3],
+      [w[1] / 3, w[1] / 3, w[1] / 3],
+      [w[2] / 3, w[2] / 3, w[2] / 3]
+    ],
+    trc: [c, c, c],
+    grayTrc: null,
+    a2b: [null, null, null],
+    b2a: [null, null, null],
+    bytes: null
+  };
+}
+var Reader = class {
+  constructor(b) {
+    this.b = b;
+  }
+  b;
+  check(off, len) {
+    if (off < 0 || len < 0 || off + len > this.b.length) throw new CmsError("ICC profile is truncated");
+  }
+  slice(off, len) {
+    this.check(off, len);
+    return this.b.subarray(off, off + len);
+  }
+  u8(off) {
+    this.check(off, 1);
+    return this.b[off];
+  }
+  u16(off) {
+    this.check(off, 2);
+    return this.b[off] << 8 | this.b[off + 1];
+  }
+  u32(off) {
+    this.check(off, 4);
+    return (this.b[off] << 24 | this.b[off + 1] << 16 | this.b[off + 2] << 8 | this.b[off + 3]) >>> 0;
+  }
+  s15f16(off) {
+    return (this.u32(off) | 0) / 65536;
+  }
+  xyz(off) {
+    return [this.s15f16(off), this.s15f16(off + 4), this.s15f16(off + 8)];
+  }
+  ascii(off, len) {
+    return String.fromCharCode(...this.slice(off, len));
+  }
+};
+var MAX_CLUT_VALUES = 16 * 1024 * 1024;
+function parseProfile(bytes) {
+  if (bytes.length < 132) throw new CmsError("ICC profile is truncated");
+  const head = new Reader(bytes);
+  if (head.ascii(36, 4) !== "acsp") throw new CmsError("not an ICC profile (missing 'acsp' signature)");
+  const declared = head.u32(0);
+  const end = declared >= 132 && declared <= bytes.length ? declared : bytes.length;
+  const r = new Reader(bytes.subarray(0, end));
+  const version = [r.u8(8), r.u8(9)];
+  const profileClass = CLASS_SIGS[r.ascii(12, 4)] ?? "unknown";
+  const colorSpace = spaceFromSig(r.ascii(16, 4));
+  const pcsSig = r.ascii(20, 4);
+  const pcs = pcsSig === "Lab " ? "lab" : "xyz";
+  const renderingIntent = intentFromCode(r.u32(64) & 65535) ?? "perceptual";
+  const count = r.u32(128);
+  if (count > 1024) throw new CmsError(`invalid ICC profile: ${count} tags`);
+  const tags = /* @__PURE__ */ new Map();
+  for (let i = 0; i < count; i++) {
+    const o = 132 + i * 12;
+    const sig = r.ascii(o, 4);
+    if (!tags.has(sig)) tags.set(sig, [r.u32(o + 4), r.u32(o + 8)]);
+  }
+  const tagData = (sig) => {
+    const t = tags.get(sig);
+    return t ? r.slice(t[0], t[1]) : null;
+  };
+  const xyzTag = (sig) => {
+    const d = tagData(sig);
+    if (!d) return null;
+    const dr = new Reader(d);
+    if (d.length < 20 || dr.ascii(0, 4) !== "XYZ ") throw new CmsError(`invalid ICC profile: tag ${sig} is not XYZType`);
+    return dr.xyz(8);
+  };
+  const curveTag = (sig) => {
+    const d = tagData(sig);
+    return d ? parseCurve(d)[0] : null;
+  };
+  const whitePoint = xyzTag("wtpt") ?? [D50[0], D50[1], D50[2]];
+  let blackPoint2 = null;
+  try {
+    blackPoint2 = xyzTag("bkpt");
+  } catch {
+    blackPoint2 = null;
+  }
+  let chad = null;
+  const cd = tagData("chad");
+  if (cd && cd.length >= 44 && new Reader(cd).ascii(0, 4) === "sf32") {
+    const rd = new Reader(cd);
+    chad = [
+      [rd.s15f16(8), rd.s15f16(12), rd.s15f16(16)],
+      [rd.s15f16(20), rd.s15f16(24), rd.s15f16(28)],
+      [rd.s15f16(32), rd.s15f16(36), rd.s15f16(40)]
+    ];
+  }
+  const rr = xyzTag("rXYZ");
+  const gg = xyzTag("gXYZ");
+  const bb = xyzTag("bXYZ");
+  const matrix = rr && gg && bb ? [
+    [rr[0], gg[0], bb[0]],
+    [rr[1], gg[1], bb[1]],
+    [rr[2], gg[2], bb[2]]
+  ] : null;
+  const tr = curveTag("rTRC");
+  const tg = curveTag("gTRC");
+  const tb = curveTag("bTRC");
+  const trc = tr && tg && tb ? [tr, tg, tb] : null;
+  const grayTrc = curveTag("kTRC");
+  const lut = (sig, a2b2) => {
+    const d = tagData(sig);
+    return d ? parseLut(d, a2b2) : null;
+  };
+  const a2b = [lut("A2B0", true), lut("A2B1", true), lut("A2B2", true)];
+  const b2a = [lut("B2A0", false), lut("B2A1", false), lut("B2A2", false)];
+  const desc = tagData("desc");
+  const cprt = tagData("cprt");
+  const p = {
+    version,
+    profileClass,
+    colorSpace,
+    pcs,
+    renderingIntent,
+    description: desc ? parseText(desc) : "",
+    copyright: cprt ? parseText(cprt) : "",
+    whitePoint,
+    blackPoint: blackPoint2,
+    chad,
+    matrix,
+    trc,
+    grayTrc,
+    a2b,
+    b2a,
+    bytes: bytes.slice()
+  };
+  const dev = spaceChannels(colorSpace);
+  const conn = profileClass === "link" ? spaceChannels(spaceFromSig(pcsSig)) : 3;
+  for (const l of a2b) if (l && (dev !== 0 && l.inputs !== dev || conn !== 0 && l.outputs !== conn)) throw new CmsError(`invalid ICC profile: AToB tag has ${l.inputs}\u2192${l.outputs} channels for a ${colorSpace} profile`);
+  for (const l of b2a) if (l && (conn !== 0 && l.inputs !== conn || dev !== 0 && l.outputs !== dev)) throw new CmsError(`invalid ICC profile: BToA tag has ${l.inputs}\u2192${l.outputs} channels for a ${colorSpace} profile`);
+  return p;
+}
+function parseCurve(d) {
+  const r = new Reader(d);
+  const type = r.ascii(0, 4);
+  if (type === "curv") {
+    const n = r.u32(8);
+    const len = 12 + n * 2;
+    if (n === 0) return [IDENTITY_CURVE, len];
+    if (n === 1) return [gammaCurve(r.u16(12) / 256), len];
+    if (n > 1 << 20) throw new CmsError("invalid ICC profile: curve too long");
+    r.check(12, n * 2);
+    const t = new Float32Array(n);
+    for (let i = 0; i < n; i++) t[i] = r.u16(12 + i * 2) / 65535;
+    return [{ type: "table", table: t }, len];
+  }
+  if (type === "para") {
+    const kind = r.u16(8);
+    if (kind > 4) throw new CmsError(`unsupported ICC feature: parametric curve type ${kind}`);
+    const n = paramCount(kind);
+    const p = [0, 0, 0, 0, 0, 0, 0];
+    for (let i = 0; i < n; i++) p[i] = r.s15f16(12 + i * 4);
+    return [kind === 0 ? gammaCurve(p[0]) : { type: "parametric", kind, p }, 12 + n * 4];
+  }
+  throw new CmsError(`unsupported ICC feature: curve type "${type}"`);
+}
+function parseCurvesAt(d, off, n) {
+  const out = [];
+  let o = off;
+  for (let k = 0; k < n; k++) {
+    if (o >= d.length) throw new CmsError("ICC profile is truncated");
+    const [c, len] = parseCurve(d.subarray(o));
+    out.push(c);
+    o += len + 3 & ~3;
+  }
+  return out;
+}
+function parseLut(d, a2b) {
+  const r = new Reader(d);
+  const ty = r.ascii(0, 4);
+  if (ty === "mft1" || ty === "mft2") {
+    const wide = ty === "mft2";
+    const i = r.u8(8);
+    const o = r.u8(9);
+    const g = r.u8(10);
+    if (i < 1 || i > 15 || o < 1 || o > 15 || g === 0) throw new CmsError("invalid ICC profile: bad lut dimensions");
+    const m = [
+      [r.s15f16(12), r.s15f16(16), r.s15f16(20)],
+      [r.s15f16(24), r.s15f16(28), r.s15f16(32)],
+      [r.s15f16(36), r.s15f16(40), r.s15f16(44)]
+    ];
+    const nIn = wide ? r.u16(48) : 256;
+    const nOut = wide ? r.u16(50) : 256;
+    let off = wide ? 52 : 48;
+    if (wide && (nIn < 2 || nIn > 4096 || nOut < 2 || nOut > 4096)) throw new CmsError("invalid ICC profile: bad lut16 table size");
+    const bps = wide ? 2 : 1;
+    const values = (at, count) => {
+      r.check(at, count * bps);
+      const out = new Float32Array(count);
+      if (wide) for (let k = 0; k < count; k++) out[k] = r.u16(at + 2 * k) / 65535;
+      else for (let k = 0; k < count; k++) out[k] = d[at + k] / 255;
+      return out;
+    };
+    const tables = (count, len) => {
+      const v = [];
+      for (let k = 0; k < count; k++) {
+        v.push({ type: "table", table: values(off, len) });
+        off += len * bps;
+      }
+      return v;
+    };
+    const inCurves = tables(i, nIn);
+    const nodes = Math.pow(g, i);
+    if (nodes * o > MAX_CLUT_VALUES) throw new CmsError("invalid ICC profile: CLUT too large");
+    const data = values(off, nodes * o);
+    off += nodes * o * bps;
+    const outCurves = tables(o, nOut);
+    const stages = [];
+    const ident = m.every((row, a) => row.every((v, b) => Math.abs(v - (a === b ? 1 : 0)) < 1e-6));
+    if (!a2b && i === 3 && !ident) stages.push(matrix3(m));
+    stages.push({ kind: "curves", curves: inCurves });
+    stages.push({ kind: "clut", clut: new Clut(new Array(i).fill(g), o, data) });
+    stages.push({ kind: "curves", curves: outCurves });
+    return { kind: wide ? "lut16" : "lut8", inputs: i, outputs: o, stages };
+  }
+  if (ty === "mAB " || ty === "mBA ") {
+    const i = r.u8(8);
+    const o = r.u8(9);
+    if (i < 1 || i > 15 || o < 1 || o > 15) throw new CmsError("invalid ICC profile: bad lutAB dimensions");
+    const ob = r.u32(12);
+    const om = r.u32(16);
+    const omc = r.u32(20);
+    const oc = r.u32(24);
+    const oa = r.u32(28);
+    const matrix = (at) => {
+      const m = [];
+      for (let k = 0; k < 9; k++) m.push(r.s15f16(at + k * 4));
+      return { kind: "matrix", rows: 3, cols: 3, m, offset: [r.s15f16(at + 36), r.s15f16(at + 40), r.s15f16(at + 44)] };
+    };
+    const clut = (at, cin, cout) => {
+      const grid = [];
+      for (let k = 0; k < cin; k++) {
+        const gp = r.u8(at + k);
+        if (gp < 1) throw new CmsError("invalid ICC profile: zero grid points");
+        grid.push(gp);
+      }
+      const prec = r.u8(at + 16);
+      const nodes = grid.reduce((a, b) => a * b, 1);
+      if (nodes * cout > MAX_CLUT_VALUES) throw new CmsError("invalid ICC profile: CLUT too large");
+      const total = nodes * cout;
+      const data = new Float32Array(total);
+      if (prec === 1) {
+        r.check(at + 20, total);
+        for (let k = 0; k < total; k++) data[k] = d[at + 20 + k] / 255;
+      } else if (prec === 2) {
+        r.check(at + 20, total * 2);
+        for (let k = 0; k < total; k++) data[k] = r.u16(at + 20 + 2 * k) / 65535;
+      } else throw new CmsError(`invalid ICC profile: CLUT precision ${prec}`);
+      return { kind: "clut", clut: new Clut(grid, cout, data) };
+    };
+    const stages = [];
+    if (ty === "mAB ") {
+      if (oc !== 0) {
+        if (oa === 0) throw new CmsError("invalid ICC profile: lutAtoB with CLUT but no A curves");
+        stages.push({ kind: "curves", curves: parseCurvesAt(d, oa, i) });
+        stages.push(clut(oc, i, o));
+      } else if (i !== o) throw new CmsError("invalid ICC profile: lutAtoB without CLUT changes channel count");
+      if (om !== 0) {
+        stages.push({ kind: "curves", curves: parseCurvesAt(d, omc, o) });
+        stages.push(matrix(om));
+      }
+      if (ob === 0) throw new CmsError("invalid ICC profile: lutAtoB without B curves");
+      stages.push({ kind: "curves", curves: parseCurvesAt(d, ob, o) });
+    } else {
+      if (ob === 0) throw new CmsError("invalid ICC profile: lutBtoA without B curves");
+      stages.push({ kind: "curves", curves: parseCurvesAt(d, ob, i) });
+      if (om !== 0) {
+        stages.push(matrix(om));
+        stages.push({ kind: "curves", curves: parseCurvesAt(d, omc, i) });
+      }
+      if (oc !== 0) {
+        if (oa === 0) throw new CmsError("invalid ICC profile: lutBtoA with CLUT but no A curves");
+        stages.push(clut(oc, i, o));
+        stages.push({ kind: "curves", curves: parseCurvesAt(d, oa, o) });
+      } else if (i !== o) throw new CmsError("invalid ICC profile: lutBtoA without CLUT changes channel count");
+    }
+    return { kind: "ab", inputs: i, outputs: o, stages };
+  }
+  throw new CmsError(`unsupported ICC feature: LUT type "${ty}"`);
+}
+function parseText(d) {
+  try {
+    const r = new Reader(d);
+    const ty = r.ascii(0, 4);
+    const ascii = (s) => {
+      const z = s.indexOf(0);
+      return String.fromCharCode(...z >= 0 ? s.subarray(0, z) : s).trim();
+    };
+    if (ty === "desc") return ascii(r.slice(12, Math.min(r.u32(8), d.length - 12)));
+    if (ty === "text") return ascii(d.subarray(8));
+    if (ty === "mluc") {
+      const n = r.u32(8);
+      const size = r.u32(12);
+      let best = null;
+      for (let k = 0; k < Math.min(n, 256); k++) {
+        const o = 16 + k * size;
+        const lang = r.ascii(o, 2);
+        const len = r.u32(o + 4);
+        const off = r.u32(o + 8);
+        if (!best || lang === "en") {
+          best = [off, len];
+          if (lang === "en") break;
+        }
+      }
+      if (!best) return "";
+      const s = r.slice(best[0], best[1]);
+      let out = "";
+      for (let k = 0; k + 1 < s.length; k += 2) out += String.fromCharCode(s[k] << 8 | s[k + 1]);
+      return out.replace(/\0+$/, "").trim();
+    }
+  } catch {
+    return "";
+  }
+  return "";
+}
+
+// src/cms/write.ts
+var Bytes = class {
+  buf = new Uint8Array(1024);
+  length = 0;
+  grow(n) {
+    if (this.length + n <= this.buf.length) return;
+    let cap = this.buf.length * 2;
+    while (cap < this.length + n) cap *= 2;
+    const next = new Uint8Array(cap);
+    next.set(this.buf.subarray(0, this.length));
+    this.buf = next;
+  }
+  u8(...v) {
+    this.grow(v.length);
+    for (const x of v) this.buf[this.length++] = x & 255;
+  }
+  u16(v) {
+    this.u8(v >> 8, v);
+  }
+  u32(v) {
+    this.u8(v >>> 24, v >>> 16, v >>> 8, v);
+  }
+  ascii(s) {
+    for (let i = 0; i < s.length; i++) this.u8(s.charCodeAt(i));
+  }
+  s15(v) {
+    this.u32(Math.round(v * 65536) | 0);
+  }
+  bytes(b) {
+    this.grow(b.length);
+    this.buf.set(b, this.length);
+    this.length += b.length;
+  }
+  pad4() {
+    while (this.length % 4) this.u8(0);
+  }
+  set32(at, v) {
+    this.buf[at] = v >>> 24;
+    this.buf[at + 1] = v >>> 16 & 255;
+    this.buf[at + 2] = v >>> 8 & 255;
+    this.buf[at + 3] = v & 255;
+  }
+  result() {
+    return this.buf.slice(0, this.length);
+  }
+};
+var u16q = (v) => Math.round(Math.min(1, Math.max(0, v)) * 65535);
+function xyzType(v) {
+  const o = new Bytes();
+  o.ascii("XYZ ");
+  o.u32(0);
+  for (const c of v) o.s15(c);
+  return o.result();
+}
+function mluc(text) {
+  const o = new Bytes();
+  o.ascii("mluc");
+  o.u32(0);
+  o.u32(1);
+  o.u32(12);
+  o.ascii("enUS");
+  o.u32(text.length * 2);
+  o.u32(28);
+  for (let i = 0; i < text.length; i++) o.u16(text.charCodeAt(i));
+  return o.result();
+}
+function curveElem(c) {
+  const o = new Bytes();
+  switch (c.type) {
+    case "identity":
+      o.ascii("curv");
+      o.u32(0);
+      o.u32(0);
+      break;
+    case "gamma":
+      o.ascii("para");
+      o.u32(0);
+      o.u32(0);
+      o.s15(c.gamma);
+      break;
+    case "parametric":
+      o.ascii("para");
+      o.u32(0);
+      o.u16(c.kind);
+      o.u16(0);
+      for (let i = 0; i < paramCount(c.kind); i++) o.s15(c.p[i]);
+      break;
+    case "table":
+      o.ascii("curv");
+      o.u32(0);
+      o.u32(c.table.length);
+      for (const v of c.table) o.u16(u16q(v));
+      break;
+  }
+  return o.result();
+}
+function curveTable(c, n) {
+  return c.type === "table" && c.table.length === n ? c.table : sampleCurve(c, n);
+}
+function tableLen(cs) {
+  let n = 2;
+  for (const c of cs) n = Math.max(n, c.type === "table" ? c.table.length : c.type === "identity" ? 2 : 1024);
+  return Math.min(4096, Math.max(2, n));
+}
+function lutParts(stages) {
+  let i = 0;
+  let mat = null;
+  const first = stages[0];
+  if (first?.kind === "matrix" && first.rows === 3 && first.cols === 3) {
+    mat = first.m;
+    i = 1;
+  }
+  const [a, c, b] = stages.slice(i);
+  if (stages.length - i !== 3 || a?.kind !== "curves" || c?.kind !== "clut" || b?.kind !== "curves") return null;
+  return { mat, a: a.curves, clut: c.clut, b: b.curves };
+}
+function encodeMft(stages, wide) {
+  const parts = lutParts(stages);
+  if (!parts) return null;
+  const { mat, a, clut, b } = parts;
+  const g = clut.grid[0];
+  if (!clut.grid.every((x) => x === g)) return null;
+  const o = new Bytes();
+  o.ascii(wide ? "mft2" : "mft1");
+  o.u32(0);
+  o.u8(clut.inputs, clut.outputs, g, 0);
+  for (const v of mat ?? [1, 0, 0, 0, 1, 0, 0, 0, 1]) o.s15(v);
+  const nIn = wide ? tableLen(a) : 256;
+  const nOut = wide ? tableLen(b) : 256;
+  if (wide) {
+    o.u16(nIn);
+    o.u16(nOut);
+  }
+  const put = (v) => wide ? o.u16(u16q(v)) : o.u8(Math.round(Math.min(1, Math.max(0, v)) * 255));
+  for (const c of a) for (const v of curveTable(c, nIn)) put(v);
+  for (const v of clut.data) put(v);
+  for (const c of b) for (const v of curveTable(c, nOut)) put(v);
+  return o.result();
+}
+function encodeAb(stages, a2b, inputs, outputs) {
+  let aCurves = null;
+  let clut = null;
+  let mCurves = null;
+  let matrix = null;
+  let bCurves = null;
+  const v = stages;
+  if (a2b) {
+    let k = 0;
+    if (v[0]?.kind === "curves" && v[1]?.kind === "clut") {
+      aCurves = v[0].curves;
+      clut = v[1].clut;
+      k = 2;
+    }
+    const rest = v.slice(k);
+    if (rest.length === 3 && rest[0].kind === "curves" && rest[1].kind === "matrix" && rest[2].kind === "curves") {
+      mCurves = rest[0].curves;
+      matrix = { m: rest[1].m, offset: rest[1].offset };
+      bCurves = rest[2].curves;
+    } else if (rest.length === 1 && rest[0].kind === "curves") bCurves = rest[0].curves;
+    else return null;
+  } else {
+    let k = 0;
+    if (v[0]?.kind === "curves") {
+      bCurves = v[0].curves;
+      k = 1;
+    }
+    const m0 = v[k];
+    const m1 = v[k + 1];
+    if (m0?.kind === "matrix" && m1?.kind === "curves") {
+      matrix = { m: m0.m, offset: m0.offset };
+      mCurves = m1.curves;
+      k += 2;
+    }
+    const c0 = v[k];
+    const c1 = v[k + 1];
+    if (c0?.kind === "clut" && c1?.kind === "curves") {
+      clut = c0.clut;
+      aCurves = c1.curves;
+      k += 2;
+    }
+    if (k !== v.length) return null;
+  }
+  if (!bCurves) return null;
+  const o = new Bytes();
+  o.ascii(a2b ? "mAB " : "mBA ");
+  o.u32(0);
+  o.u8(inputs, outputs, 0, 0);
+  for (let k = 0; k < 5; k++) o.u32(0);
+  const offs = [0, 0, 0, 0, 0];
+  const curves = (cs) => {
+    for (const c of cs) {
+      o.bytes(curveElem(c));
+      o.pad4();
+    }
+  };
+  offs[0] = o.length;
+  curves(bCurves);
+  if (matrix) {
+    offs[1] = o.length;
+    for (const x of matrix.m) o.s15(x);
+    for (const x of matrix.offset) o.s15(x);
+    offs[2] = o.length;
+    if (!mCurves) return null;
+    curves(mCurves);
+  }
+  if (clut) {
+    offs[3] = o.length;
+    const g = new Array(16).fill(0);
+    clut.grid.forEach((n, k) => g[k] = n);
+    o.u8(...g);
+    o.u8(2, 0, 0, 0);
+    for (const x of clut.data) o.u16(u16q(x));
+    o.pad4();
+    offs[4] = o.length;
+    if (!aCurves) return null;
+    curves(aCurves);
+  }
+  offs.forEach((x, k) => o.set32(12 + k * 4, x));
+  return o.result();
+}
+var sameBytes = (a, b) => a.length === b.length && a.every((v, i) => v === b[i]);
+function encodeProfile(p) {
+  const tags = [];
+  tags.push(["desc", mluc(p.description)]);
+  tags.push(["cprt", mluc(p.copyright)]);
+  tags.push(["wtpt", xyzType(p.whitePoint)]);
+  if (p.blackPoint) tags.push(["bkpt", xyzType(p.blackPoint)]);
+  if (p.chad) {
+    const o2 = new Bytes();
+    o2.ascii("sf32");
+    o2.u32(0);
+    for (const row of p.chad) for (const v of row) o2.s15(v);
+    tags.push(["chad", o2.result()]);
+  }
+  if (p.matrix) {
+    const m = p.matrix;
+    tags.push(["rXYZ", xyzType([m[0][0], m[1][0], m[2][0]])]);
+    tags.push(["gXYZ", xyzType([m[0][1], m[1][1], m[2][1]])]);
+    tags.push(["bXYZ", xyzType([m[0][2], m[1][2], m[2][2]])]);
+  }
+  if (p.trc) {
+    tags.push(["rTRC", curveElem(p.trc[0])]);
+    tags.push(["gTRC", curveElem(p.trc[1])]);
+    tags.push(["bTRC", curveElem(p.trc[2])]);
+  }
+  if (p.grayTrc) tags.push(["kTRC", curveElem(p.grayTrc)]);
+  for (const [luts, names, a2b] of [
+    [p.a2b, ["A2B0", "A2B1", "A2B2"], true],
+    [p.b2a, ["B2A0", "B2A1", "B2A2"], false]
+  ]) {
+    luts.forEach((l, k) => {
+      if (!l) return;
+      const data2 = l.kind === "lut16" ? encodeMft(l.stages, true) : l.kind === "lut8" ? encodeMft(l.stages, false) : encodeAb(l.stages, a2b, l.inputs, l.outputs);
+      if (data2) tags.push([names[k], data2]);
+    });
+  }
+  const tableLength = 4 + tags.length * 12;
+  const data = new Bytes();
+  const entries = [];
+  const placed = [];
+  for (const [sig, d] of tags) {
+    const same = placed.find(([b]) => sameBytes(b, d));
+    if (same) {
+      entries.push([sig, same[1], same[2]]);
+      continue;
+    }
+    const off = 128 + tableLength + data.length;
+    data.bytes(d);
+    data.pad4();
+    entries.push([sig, off, d.length]);
+    placed.push([d, off, d.length]);
+  }
+  const size = 128 + tableLength + data.length;
+  const o = new Bytes();
+  o.u32(size);
+  o.u32(0);
+  o.u8(4, 48, 0, 0);
+  o.ascii(classSig(p.profileClass));
+  o.ascii(spaceSig(p.colorSpace));
+  o.ascii(p.pcs === "lab" ? "Lab " : "XYZ ");
+  for (const v of [2026, 1, 1, 0, 0, 0]) o.u16(v);
+  o.ascii("acsp");
+  for (let k = 0; k < 6; k++) o.u32(0);
+  o.u32(intentCode(p.renderingIntent));
+  for (const v of D50) o.s15(v);
+  o.u32(0);
+  while (o.length < 128) o.u8(0);
+  o.u32(entries.length);
+  for (const [sig, off, len] of entries) {
+    o.ascii(sig);
+    o.u32(off);
+    o.u32(len);
+  }
+  o.bytes(data.result());
+  return o.result();
+}
+
+// src/cms/transform.ts
+var DEFAULT_TRANSFORM_OPTIONS = { intent: "relative", bpc: true, preciseFloat: true };
+var GRID_3D = 33;
+var GRID_4D = 17;
+var TABLE_1D = 4096;
+var OUT_TABLE = 4096;
+var PERCEPTUAL_BLACK_Y = 34731e-7;
+function shaper(cs, m) {
+  const curves8 = cs.map((c) => {
+    const t = new Float32Array(256);
+    for (let i = 0; i < 256; i++) t[i] = evalCurve(c, i / 255);
+    return t;
+  });
+  const curves = cs.map((c) => {
+    const t = new Float32Array(TABLE_1D + 1);
+    for (let i = 0; i <= TABLE_1D; i++) t[i] = evalCurve(c, i / TABLE_1D);
+    return t;
+  });
+  return { kind: "shaper", curves8, curves, matrix: m ? { rows: m.rows, cols: m.cols, m: Float32Array.from(m.m), offset: Float32Array.from(m.offset) } : null };
+}
+function table2(t, x) {
+  const n = t.length - 1;
+  const p = x * n;
+  const i = Math.min(n - 1, Math.max(0, Math.floor(p)));
+  const f = p - i;
+  return t[i] + (t[i + 1] - t[i]) * f;
+}
+function deviceWhite(cs) {
+  switch (cs) {
+    case "rgb":
+      return [1, 1, 1];
+    case "gray":
+      return [1];
+    case "cmyk":
+      return [0, 0, 0, 0];
+    case "cmy":
+      return [0, 0, 0];
+    case "lab":
+      return [1, 0.5, 0.5];
+    default:
+      return null;
+  }
+}
+var Transform = class _Transform {
+  constructor(pipeline, options) {
+    this.pipeline = pipeline;
+    this.options = options;
+    pipeline.optimize();
+    this.inputs = pipeline.inputs;
+    this.outputs = pipeline.outputs;
+    const head = pipeline.stages.slice();
+    const last = head[head.length - 1];
+    if (last?.kind === "inv-curves" && last.curves.length === this.outputs) {
+      this.post = last.curves.map((c) => {
+        const t = new Float32Array(OUT_TABLE);
+        for (let i = 0; i < OUT_TABLE; i++) {
+          const u = i / (OUT_TABLE - 1);
+          t[i] = Math.min(1, Math.max(0, evalCurveInverse(c, u * u * u * u)));
+        }
+        return t;
+      });
+      head.pop();
+      if (head[head.length - 1]?.kind === "clamp01") head.pop();
+    }
+    const headPipe = new Pipeline(this.inputs, head);
+    const mid = headPipe.outputs;
+    const hasClut = head.some((s) => s.kind === "clut");
+    const [h0, h1] = head;
+    if (head.length === 0) this.core = shaper([], null);
+    else if (head.length === 1 && h0.kind === "curves" && h0.curves.length === this.inputs) this.core = shaper(h0.curves, null);
+    else if (head.length === 1 && h0.kind === "matrix") this.core = shaper([], h0);
+    else if (head.length === 2 && h0.kind === "curves" && h0.curves.length === this.inputs && h1.kind === "matrix") this.core = shaper(h0.curves, h1);
+    else if (!hasClut) this.core = { kind: "exact" };
+    else {
+      const sample = (grid) => Clut.sample(grid, mid, (i, o) => headPipe.eval(i, o));
+      switch (this.inputs) {
+        case 1:
+          this.core = { kind: "grid", clut: sample([TABLE_1D]) };
+          break;
+        case 2:
+          this.core = { kind: "grid", clut: sample([GRID_3D, GRID_3D]) };
+          break;
+        case 3:
+          this.core = { kind: "grid", clut: sample([GRID_3D, GRID_3D, GRID_3D]) };
+          break;
+        case 4:
+          this.core = { kind: "grid", clut: sample([GRID_4D, GRID_4D, GRID_4D, GRID_4D]) };
+          break;
+        default:
+          this.core = { kind: "exact" };
+      }
+    }
+  }
+  pipeline;
+  options;
+  inputs;
+  outputs;
+  core;
+  post = null;
+  mid = new Float32Array(16);
+  tmp = new Float32Array(16);
+  inp = new Float32Array(16);
+  /** From `src` to `dst` with `intent` (and black point compensation). */
+  static create(src, dst, options = {}) {
+    const opts = { ...DEFAULT_TRANSFORM_OPTIONS, ...options };
+    const t = new _Transform(new Pipeline(profileChannels(src), linkStages(src, dst, opts.intent, opts.bpc)), opts);
+    if (opts.intent !== "absolute") t.fixWhite(src.colorSpace, dst.colorSpace);
+    return t;
+  }
+  /**
+   * Soft proof `src → proof → dst` (View › Proof Setup): `intent` / `bpc` apply to the
+   * document → proof step; proof → display is relative colorimetric with BPC, or absolute
+   * colorimetric without it when `simulatePaper` (paper colour and black ink simulated).
+   */
+  static proof(src, proof, dst, intent, bpc, simulatePaper) {
+    const stages = linkStages(src, proof, intent, bpc);
+    stages.push({ kind: "clamp01" });
+    stages.push(...simulatePaper ? linkStages(proof, dst, "absolute", false) : linkStages(proof, dst, "relative", true));
+    return new _Transform(new Pipeline(profileChannels(src), stages), { intent, bpc, preciseFloat: true });
+  }
+  /** The device-link node at the source's device white gets exactly the destination's white. */
+  fixWhite(src, dst) {
+    const sw = deviceWhite(src);
+    let dw = deviceWhite(dst);
+    if (!sw || !dw) return;
+    if (this.post) {
+      if (dst !== "rgb" && dst !== "gray") return;
+      dw = dw.map(() => 1);
+    }
+    if (this.core.kind !== "grid") return;
+    const c = this.core.clut;
+    if (c.inputs !== sw.length || c.outputs !== dw.length) return;
+    let off = 0;
+    let stride = c.outputs;
+    for (let d = c.inputs - 1; d >= 0; d--) {
+      const n = c.grid[d];
+      const pos = sw[d] * (n - 1);
+      if (Math.abs(pos - Math.round(pos)) > 1e-6) return;
+      off += Math.round(pos) * stride;
+      stride *= n;
+    }
+    for (let k = 0; k < c.outputs; k++) c.data[off + k] = dw[k];
+  }
+  /** Exact evaluation of one colour. */
+  eval(input, out) {
+    this.pipeline.eval(input, out);
+  }
+  /** Table evaluation of one colour (what integer buffers use). */
+  evalFast(input, out) {
+    const mid = this.mid;
+    const core = this.core;
+    if (core.kind === "exact") {
+      this.pipeline.eval(input, out);
+      return;
+    }
+    if (core.kind === "grid") {
+      for (let d = 0; d < this.inputs; d++) this.inp[d] = Math.min(1, Math.max(0, input[d]));
+      core.clut.eval(this.inp, mid);
+    } else {
+      const v = this.tmp;
+      for (let k = 0; k < this.inputs; k++) v[k] = core.curves.length ? table2(core.curves[k], input[k]) : input[k];
+      applyMatrix(core.matrix, v, mid, this.inputs);
+    }
+    this.finish(mid, out);
+  }
+  finish(mid, out) {
+    const post = this.post;
+    if (!post) {
+      for (let k = 0; k < this.outputs; k++) out[k] = mid[k];
+      return;
+    }
+    for (let k = 0; k < this.outputs; k++) {
+      const t = post[k];
+      const x = mid[k];
+      const u = Math.sqrt(Math.sqrt(x < 0 ? 0 : x > 1 ? 1 : x)) * (OUT_TABLE - 1);
+      const i = Math.min(OUT_TABLE - 2, Math.floor(u));
+      out[k] = t[i] + (t[i + 1] - t[i]) * (u - i);
+    }
+  }
+  /**
+   * Converts 8-bit interleaved pixels: `src` has `srcStride` samples per pixel (colour first),
+   * `dst` `dstStride`. With `copyExtra`, trailing channels (alpha) are copied.
+   */
+  convert8(src, srcStride, dst, dstStride, copyExtra = true) {
+    this.check(srcStride, dstStride);
+    const extra = copyExtra ? Math.min(srcStride - this.inputs, dstStride - this.outputs) : 0;
+    const n = Math.min(Math.floor(src.length / srcStride), Math.floor(dst.length / dstStride));
+    const out = new Float32Array(16);
+    const mid = this.mid;
+    const core = this.core;
+    const q = (v) => v <= 0 ? 0 : v >= 1 ? 255 : v * 255 + 0.5 | 0;
+    for (let p = 0; p < n; p++) {
+      const s = p * srcStride;
+      const d = p * dstStride;
+      if (core.kind === "shaper") {
+        const v = this.tmp;
+        for (let k = 0; k < this.inputs; k++) v[k] = core.curves8.length ? core.curves8[k][src[s + k]] : src[s + k] / 255;
+        applyMatrix(core.matrix, v, mid, this.inputs);
+        this.finish(mid, out);
+      } else {
+        for (let k = 0; k < this.inputs; k++) this.inp[k] = src[s + k] / 255;
+        this.evalFast(this.inp, out);
+      }
+      for (let k = 0; k < this.outputs; k++) dst[d + k] = q(out[k]);
+      for (let e = 0; e < extra; e++) dst[d + this.outputs + e] = src[s + this.inputs + e];
+    }
+  }
+  /** Converts 16-bit interleaved pixels (see `convert8`). */
+  convert16(src, srcStride, dst, dstStride, copyExtra = true) {
+    this.check(srcStride, dstStride);
+    const extra = copyExtra ? Math.min(srcStride - this.inputs, dstStride - this.outputs) : 0;
+    const n = Math.min(Math.floor(src.length / srcStride), Math.floor(dst.length / dstStride));
+    const out = new Float32Array(16);
+    for (let p = 0; p < n; p++) {
+      const s = p * srcStride;
+      const d = p * dstStride;
+      for (let k = 0; k < this.inputs; k++) this.inp[k] = src[s + k] / 65535;
+      this.evalFast(this.inp, out);
+      for (let k = 0; k < this.outputs; k++) dst[d + k] = Math.round(Math.min(1, Math.max(0, out[k])) * 65535);
+      for (let e = 0; e < extra; e++) dst[d + this.outputs + e] = src[s + this.inputs + e];
+    }
+  }
+  /** Converts float interleaved pixels (exact unless `preciseFloat` is off). */
+  convertFloat(src, srcStride, dst, dstStride, copyExtra = true) {
+    this.check(srcStride, dstStride);
+    const extra = copyExtra ? Math.min(srcStride - this.inputs, dstStride - this.outputs) : 0;
+    const n = Math.min(Math.floor(src.length / srcStride), Math.floor(dst.length / dstStride));
+    const precise = this.options.preciseFloat || this.core.kind === "exact";
+    const out = new Float32Array(16);
+    for (let p = 0; p < n; p++) {
+      const s = p * srcStride;
+      const d = p * dstStride;
+      for (let k = 0; k < this.inputs; k++) this.inp[k] = src[s + k];
+      if (precise) this.pipeline.eval(this.inp, out);
+      else this.evalFast(this.inp, out);
+      for (let k = 0; k < this.outputs; k++) dst[d + k] = out[k];
+      for (let e = 0; e < extra; e++) dst[d + this.outputs + e] = src[s + this.inputs + e];
+    }
+  }
+  check(ss, ds) {
+    if (ss < this.inputs || ds < this.outputs) throw new RangeError(`pixel stride smaller than the channel count (${this.inputs} \u2192 ${this.outputs})`);
+  }
+};
+function applyMatrix(m, v, out, n) {
+  if (!m) {
+    for (let k = 0; k < n; k++) out[k] = v[k];
+    return;
+  }
+  for (let r = 0; r < m.rows; r++) {
+    let s = m.offset[r];
+    for (let c = 0; c < m.cols; c++) s += m.m[r * m.cols + c] * v[c];
+    out[r] = s;
+  }
+}
+function linkStages(src, dst, intent, bpc) {
+  for (const p of [src, dst]) {
+    const labToLab = p.colorSpace === "lab" && p.a2b.every((l) => !l || l.outputs === 3) && p.b2a.every((l) => !l || l.inputs === 3);
+    if ((p.profileClass === "link" || p.profileClass === "named" || p.profileClass === "abstract") && !labToLab) {
+      throw new CmsError(`${p.profileClass} profiles cannot be used as a source or destination`);
+    }
+  }
+  const s = deviceToPcs(src, intent);
+  const d = pcsToDevice(dst, intent);
+  const stages = s.stages.slice();
+  const adjust = connection(src, dst, intent, bpc);
+  if (adjust) {
+    if (s.pcs === "lab") stages.push({ kind: "lab-to-xyz" });
+    stages.push({ kind: "matrix", rows: 3, cols: 3, m: [adjust.scale[0], 0, 0, 0, adjust.scale[1], 0, 0, 0, adjust.scale[2]], offset: adjust.offset });
+    if (d.pcs === "lab") stages.push({ kind: "xyz-to-lab" });
+  } else if (s.pcs === "lab" && d.pcs === "xyz") stages.push({ kind: "lab-to-xyz" });
+  else if (s.pcs === "xyz" && d.pcs === "lab") stages.push({ kind: "xyz-to-lab" });
+  stages.push(...d.stages);
+  return stages;
+}
+function connection(src, dst, intent, bpc) {
+  if (intent === "absolute") {
+    const ws = mediaWhite(src);
+    const wd = mediaWhite(dst);
+    const usable = (w) => w.every((v) => Number.isFinite(v) && v > 0);
+    if (!usable(ws) || !usable(wd)) throw new CmsError("absolute colorimetric needs a positive media white point in both profiles");
+    const s = [ws[0] / wd[0], ws[1] / wd[1], ws[2] / wd[2]];
+    if (s.every((v) => Math.abs(v - 1) < 1e-6)) return null;
+    return { scale: s, offset: [0, 0, 0] };
+  }
+  if (!bpc) return null;
+  const bs = blackPoint(src, intent);
+  const bd = blackPoint(dst, intent);
+  if (Math.abs(bs - bd) < 1e-6) return null;
+  const scale = [1, 1, 1];
+  const offset = [0, 0, 0];
+  for (let i = 0; i < 3; i++) {
+    const s = bs * D50[i];
+    const d = bd * D50[i];
+    const a = (D50[i] - d) / (D50[i] - s);
+    scale[i] = a;
+    offset[i] = D50[i] * (1 - a);
+  }
+  return { scale, offset };
+}
+function blackPoint(p, intent) {
+  if (p.colorSpace === "lab" || p.colorSpace === "xyz") return 0;
+  const lutBased = p.a2b.some(Boolean);
+  if (lutBased && p.version[0] >= 4 && (intent === "perceptual" || intent === "saturation")) return PERCEPTUAL_BLACK_Y;
+  const n = profileChannels(p);
+  const pcsY = (st, pcs, dev) => {
+    const out = new Float32Array(16);
+    new Pipeline(n, st.slice()).eval(dev, out);
+    const y = pcs === "xyz" ? out[1] : labToXyz([out[0], 0, 0])[1];
+    return Math.min(0.5, Math.max(0, y));
+  };
+  const to = deviceToPcs(p, intent);
+  const additive = p.colorSpace === "rgb" || p.colorSpace === "gray";
+  if (additive || !lutBased) return pcsY(to.stages, to.pcs, new Array(n).fill(0));
+  const colorimetric = intent === "saturation" ? "saturation" : "relative";
+  try {
+    const from = pcsToDevice(p, colorimetric);
+    const st = from.pcs === "xyz" ? [{ kind: "lab-to-xyz" }, ...from.stages] : from.stages.slice();
+    const dev = new Float32Array(16);
+    new Pipeline(3, st).eval([0, 0, 0], dev);
+    return pcsY(to.stages, to.pcs, dev.subarray(0, n));
+  } catch {
+    return pcsY(to.stages, to.pcs, new Array(n).fill(1));
+  }
+}
+var ids = /* @__PURE__ */ new WeakMap();
+var nextId = 1;
+var idOf = (p) => {
+  let id = ids.get(p);
+  if (!id) {
+    id = nextId++;
+    ids.set(p, id);
+  }
+  return id;
+};
+var cache = /* @__PURE__ */ new Map();
+function cachedTransform(src, dst, options = {}) {
+  const opts = { ...DEFAULT_TRANSFORM_OPTIONS, ...options };
+  const key = `${idOf(src)}:${idOf(dst)}:${opts.intent}:${opts.bpc}:${opts.preciseFloat}`;
+  let t = cache.get(key);
+  if (!t) {
+    if (cache.size > 64) cache.clear();
+    t = Transform.create(src, dst, opts);
+    cache.set(key, t);
+  }
+  return t;
+}
+function sameColors(a, b, lab) {
+  if (a === b) return true;
+  if (a.bytes && b.bytes && a.bytes.length === b.bytes.length && a.bytes.every((v, i) => v === b.bytes[i])) return true;
+  const n = profileChannels(a);
+  if (a.colorSpace !== b.colorSpace || n === 0 || n > 4) return false;
+  let ta;
+  let tb;
+  try {
+    ta = Transform.create(a, lab, { intent: "relative", bpc: false });
+    tb = Transform.create(b, lab, { intent: "relative", bpc: false });
+  } catch {
+    return false;
+  }
+  const steps = n <= 3 ? 17 : 9;
+  const decode = (o) => [o[0] * 100, o[1] * 255 - 128, o[2] * 255 - 128];
+  const input = new Float32Array(4);
+  const la = new Float32Array(16);
+  const lb = new Float32Array(16);
+  const total = Math.pow(steps, n);
+  for (let i = 0; i < total; i++) {
+    let k = i;
+    for (let c = 0; c < n; c++) {
+      input[c] = k % steps / (steps - 1);
+      k = Math.floor(k / steps);
+    }
+    ta.eval(input, la);
+    tb.eval(input, lb);
+    if (deltaE76(decode(la), decode(lb)) > 0.5) return false;
+  }
+  return true;
+}
+var GamutCheck = class {
+  constructor(src, proof, lab, threshold = 4) {
+    this.threshold = threshold;
+    const n = profileChannels(src);
+    this.direct = new Pipeline(n, linkStages(src, lab, "relative", false));
+    const via = linkStages(src, proof, "relative", false);
+    via.push({ kind: "clamp01" });
+    via.push(...linkStages(proof, lab, "relative", false));
+    this.via = new Pipeline(n, via);
+    const a = new Float32Array(16);
+    const b = new Float32Array(16);
+    const de = (p, o) => {
+      this.direct.eval(p, a);
+      this.via.eval(p, b);
+      o[0] = Math.hypot((a[0] - b[0]) * 100, (a[1] - b[1]) * 255, (a[2] - b[2]) * 255);
+    };
+    this.grid = n === 1 ? Clut.sample([256], 1, de) : n === 3 ? Clut.sample([33, 33, 33], 1, de) : n === 4 ? Clut.sample([17, 17, 17, 17], 1, de) : null;
+  }
+  threshold;
+  grid;
+  direct;
+  via;
+  /** ΔE*ab of a colour (normalised device values). */
+  deltaE(px) {
+    const o = new Float32Array(16);
+    if (this.grid) this.grid.eval(px, o);
+    else {
+      const a = new Float32Array(16);
+      const b = new Float32Array(16);
+      this.direct.eval(px, a);
+      this.via.eval(px, b);
+      o[0] = Math.hypot((a[0] - b[0]) * 100, (a[1] - b[1]) * 255, (a[2] - b[2]) * 255);
+    }
+    return o[0];
+  }
+  outOfGamut(px) {
+    return this.deltaE(px) > this.threshold;
+  }
+};
+var Lut3d = class {
+  constructor(t, size = 33) {
+    this.size = size;
+    if (t.inputs !== 3 || t.outputs !== 3 && t.outputs !== 1) throw new RangeError("display LUTs need a 3 \u2192 3 or 3 \u2192 1 transform");
+    const n = size;
+    this.data = new Float32Array(n * n * n * 3);
+    const out = new Float32Array(16);
+    const s = n - 1;
+    for (let b = 0; b < n; b++) {
+      for (let g = 0; g < n; g++) {
+        for (let r = 0; r < n; r++) {
+          t.eval([r / s, g / s, b / s], out);
+          const i = (r + g * n + b * n * n) * 3;
+          this.data[i] = out[0];
+          this.data[i + 1] = t.outputs === 1 ? out[0] : out[1];
+          this.data[i + 2] = t.outputs === 1 ? out[0] : out[2];
+        }
+      }
+    }
+  }
+  size;
+  data;
+  /** Trilinear sample of 0..1 RGB into `out`. */
+  sample(r, g, b, out) {
+    const n = this.size;
+    const loc = (v) => {
+      const p = Math.min(1, Math.max(0, v)) * (n - 1);
+      const i = Math.min(n - 2, Math.floor(p));
+      return [i, p - i];
+    };
+    const [r0, fr] = loc(r);
+    const [g0, fg] = loc(g);
+    const [b0, fb] = loc(b);
+    const d = this.data;
+    const at = (rr, gg, bb, k) => d[(rr + gg * n + bb * n * n) * 3 + k];
+    for (let k = 0; k < 3; k++) {
+      const x00 = at(r0, g0, b0, k) + (at(r0 + 1, g0, b0, k) - at(r0, g0, b0, k)) * fr;
+      const x10 = at(r0, g0 + 1, b0, k) + (at(r0 + 1, g0 + 1, b0, k) - at(r0, g0 + 1, b0, k)) * fr;
+      const x01 = at(r0, g0, b0 + 1, k) + (at(r0 + 1, g0, b0 + 1, k) - at(r0, g0, b0 + 1, k)) * fr;
+      const x11 = at(r0, g0 + 1, b0 + 1, k) + (at(r0 + 1, g0 + 1, b0 + 1, k) - at(r0, g0 + 1, b0 + 1, k)) * fr;
+      const y0 = x00 + (x10 - x00) * fg;
+      const y1 = x01 + (x11 - x01) * fg;
+      out[k] = y0 + (y1 - y0) * fb;
+    }
+  }
+  /** Applies the table to 8-bit RGBA in place (alpha kept), through a per-code 8-bit cache of the lattice. */
+  apply8(data) {
+    const o = [0, 0, 0];
+    for (let i = 0; i < data.length; i += 4) {
+      this.sample(data[i] / 255, data[i + 1] / 255, data[i + 2] / 255, o);
+      data[i] = Math.round(Math.min(1, Math.max(0, o[0])) * 255);
+      data[i + 1] = Math.round(Math.min(1, Math.max(0, o[1])) * 255);
+      data[i + 2] = Math.round(Math.min(1, Math.max(0, o[2])) * 255);
+    }
+  }
+};
+
+// src/cms/synth.ts
+var COATED_CMYK_DESCRIPTION = "Pixerate Coated CMYK (synthetic, 300% TAC, medium GCR)";
+var DEFAULT_CMYK_PARAMS = {
+  description: COATED_CMYK_DESCRIPTION,
+  tac: 3,
+  gcrStart: 0.2,
+  kMax: 0.95,
+  gcrGamma: 1.1,
+  tvi: [0.14, 0.14, 0.14, 0.17],
+  gridA2b: 11,
+  gridB2a: 17
+};
+var YN = 2;
+var CmykModel = class {
+  constructor(tvi) {
+    this.tvi = tvi;
+    const lab = (l, a, b) => labToXyz([l, a, b]);
+    const w = lab(95, 0, -2);
+    const base = [
+      w,
+      // paper
+      lab(55, -37, -50),
+      // C
+      lab(48, 74, -3),
+      // M
+      lab(24, 22, -46),
+      // C+M
+      lab(89, -5, 93),
+      // Y
+      lab(50, -65, 27),
+      // C+Y
+      lab(47, 68, 48),
+      // M+Y
+      lab(23, 0, 0)
+      // C+M+Y
+    ];
+    const k = lab(16, 0, 0);
+    const floor = 6e-3;
+    for (let m = 0; m < 16; m++) {
+      const p = base[m & 7];
+      const prim = m & 8 ? [0, 1, 2].map((i) => {
+        const s = floor * w[i];
+        return s + (p[i] - s) * (k[i] - s) / (w[i] - s);
+      }) : p;
+      this.primN.push(prim.map((v) => Math.pow(Math.max(0, v), 1 / YN)));
+    }
+    this.paper = w;
+  }
+  tvi;
+  primN = [];
+  paper;
+  xyz(cmyk) {
+    const a = [0, 1, 2, 3].map((i) => {
+      const v = Math.min(1, Math.max(0, cmyk[i]));
+      return Math.min(1, Math.max(0, v + 4 * this.tvi[i] * v * (1 - v)));
+    });
+    const s = [0, 0, 0];
+    for (let m = 0; m < 16; m++) {
+      let w = 1;
+      for (let i = 0; i < 4; i++) w *= m & 1 << i ? a[i] : 1 - a[i];
+      if (w === 0) continue;
+      const p = this.primN[m];
+      s[0] += w * p[0];
+      s[1] += w * p[1];
+      s[2] += w * p[2];
+    }
+    return [Math.pow(s[0], YN), Math.pow(s[1], YN), Math.pow(s[2], YN)];
+  }
+  lab(cmyk) {
+    const x = this.xyz(cmyk);
+    return xyzToLab([x[0] * D50[0] / this.paper[0], x[1] * D50[1] / this.paper[1], x[2] * D50[2] / this.paper[2]]);
+  }
+};
+function solveCmy(model, target, k, limit, seeds) {
+  const project = (x) => {
+    const v = [x[0], x[1], x[2]];
+    for (let it = 0; it < 4; it++) {
+      for (let i = 0; i < 3; i++) v[i] = Math.min(1, Math.max(0, v[i]));
+      const s = v[0] + v[1] + v[2];
+      if (s <= limit + 1e-12) break;
+      const active = Math.max(1, v.filter((x2) => x2 > 0).length);
+      const d = (s - limit) / active;
+      for (let i = 0; i < 3; i++) if (v[i] > 0) v[i] -= d;
+    }
+    return v;
+  };
+  const err = (x) => {
+    const l = model.lab([x[0], x[1], x[2], k]);
+    return [l[0] - target[0], l[1] - target[1], l[2] - target[2]];
+  };
+  const norm2 = (e) => e[0] * e[0] + e[1] * e[1] + e[2] * e[2];
+  let best = [[0, 0, 0], Infinity];
+  for (const seed of seeds) {
+    let x = project(seed);
+    let e = err(x);
+    let f = norm2(e);
+    let lambda = 1e-3;
+    for (let iter = 0; iter < 60; iter++) {
+      const h = 1e-5;
+      const j = [
+        [0, 0, 0],
+        [0, 0, 0],
+        [0, 0, 0]
+      ];
+      for (let c = 0; c < 3; c++) {
+        const xp = [x[0], x[1], x[2]];
+        xp[c] += h;
+        const ep = err(xp);
+        for (let r = 0; r < 3; r++) j[r][c] = (ep[r] - e[r]) / h;
+      }
+      const a = [
+        [0, 0, 0],
+        [0, 0, 0],
+        [0, 0, 0]
+      ];
+      const g = [0, 0, 0];
+      for (let r = 0; r < 3; r++) {
+        for (let c = 0; c < 3; c++) a[r][c] = j[0][r] * j[0][c] + j[1][r] * j[1][c] + j[2][r] * j[2][c];
+        g[r] = -(j[0][r] * e[0] + j[1][r] * e[1] + j[2][r] * e[2]);
+      }
+      let improved = false;
+      for (let t = 0; t < 8; t++) {
+        const al = [
+          [a[0][0], a[0][1], a[0][2]],
+          [a[1][0], a[1][1], a[1][2]],
+          [a[2][0], a[2][1], a[2][2]]
+        ];
+        for (let d = 0; d < 3; d++) al[d][d] += lambda * (1 + a[d][d]);
+        const inv = invert(al);
+        if (!inv) {
+          lambda *= 10;
+          continue;
+        }
+        const step = apply(inv, g);
+        const xn = project([x[0] + step[0], x[1] + step[1], x[2] + step[2]]);
+        const en = err(xn);
+        const fnew = norm2(en);
+        if (fnew < f) {
+          const moved = Math.max(Math.abs(xn[0] - x[0]), Math.abs(xn[1] - x[1]), Math.abs(xn[2] - x[2]));
+          x = xn;
+          e = en;
+          f = fnew;
+          lambda = Math.max(1e-9, lambda * 0.3);
+          improved = moved > 1e-9;
+          break;
+        }
+        lambda *= 10;
+      }
+      if (!improved || f < 1e-10) break;
+    }
+    if (f < best[1]) best = [x, f];
+    if (best[1] < 1e-6) break;
+  }
+  return [best[0], Math.sqrt(best[1])];
+}
+var SEEDS = [
+  [0.3, 0.3, 0.3],
+  [0.05, 0.05, 0.05],
+  [0.8, 0.8, 0.8],
+  [0.9, 0.2, 0.2],
+  [0.2, 0.9, 0.9]
+];
+function separate(model, p, target, warm) {
+  const seeds = warm ? [[warm[0], warm[1], warm[2]], ...SEEDS] : SEEDS;
+  const [cmy0] = solveCmy(model, target, 0, 3, seeds);
+  const g = Math.min(cmy0[0], cmy0[1], cmy0[2]);
+  const k = g <= p.gcrStart ? 0 : p.kMax * Math.pow((g - p.gcrStart) / (1 - p.gcrStart), p.gcrGamma);
+  const seeds2 = [[Math.max(0, cmy0[0] - k), Math.max(0, cmy0[1] - k), Math.max(0, cmy0[2] - k)], cmy0, ...seeds];
+  const [cmy, de] = solveCmy(model, target, k, Math.max(0, p.tac - k), seeds2);
+  return [[cmy[0], cmy[1], cmy[2], k], de];
+}
+var Gbd = class {
+  lBins = 41;
+  hBins = 72;
+  cmax;
+  blackL;
+  constructor(model, p) {
+    const { lBins, hBins } = this;
+    const cmax = new Float64Array(lBins * hBins);
+    const n = 13;
+    let blackL = 100;
+    for (let ci = 0; ci < n; ci++) {
+      for (let mi = 0; mi < n; mi++) {
+        for (let yi = 0; yi < n; yi++) {
+          for (let ki = 0; ki < 7; ki++) {
+            const v = [ci / (n - 1), mi / (n - 1), yi / (n - 1), ki / 6];
+            if (v[0] + v[1] + v[2] + v[3] > p.tac + 1e-9) continue;
+            const lab = model.lab(v);
+            blackL = Math.min(blackL, lab[0]);
+            const c = Math.hypot(lab[1], lab[2]);
+            const h = (Math.atan2(lab[2], lab[1]) + 2 * Math.PI) % (2 * Math.PI);
+            const li = Math.min(lBins - 1, Math.max(0, Math.round(lab[0] / 100 * (lBins - 1))));
+            const hi = Math.round(h / (2 * Math.PI) * hBins) % hBins;
+            cmax[li * hBins + hi] = Math.max(cmax[li * hBins + hi], c);
+          }
+        }
+      }
+    }
+    const get = (v, l, h) => v[Math.min(lBins - 1, Math.max(0, l)) * hBins + (h % hBins + hBins) % hBins];
+    const filled = new Float64Array(cmax.length);
+    for (let l = 0; l < lBins; l++) {
+      for (let h = 0; h < hBins; h++) {
+        let m = 0;
+        for (let dl = -1; dl <= 1; dl++) for (let dh = -1; dh <= 1; dh++) m = Math.max(m, get(cmax, l + dl, h + dh));
+        filled[l * hBins + h] = m;
+      }
+    }
+    this.cmax = new Float64Array(cmax.length);
+    for (let l = 0; l < lBins; l++) {
+      for (let h = 0; h < hBins; h++) {
+        let s = 0;
+        for (let dl = -1; dl <= 1; dl++) for (let dh = -1; dh <= 1; dh++) s += get(filled, l + dl, h + dh);
+        this.cmax[l * hBins + h] = s / 9;
+      }
+    }
+    this.blackL = blackL;
+  }
+  maxChroma(l, h) {
+    const { lBins, hBins } = this;
+    const lp = Math.min(1, Math.max(0, l / 100)) * (lBins - 1);
+    const hp = (h % (2 * Math.PI) + 2 * Math.PI) % (2 * Math.PI) / (2 * Math.PI) * hBins;
+    const l0 = Math.floor(lp);
+    const h0 = Math.floor(hp);
+    const fl = lp - l0;
+    const fh = hp - h0;
+    const l1 = Math.min(lBins - 1, l0 + 1);
+    const h0m = h0 % hBins;
+    const h1m = (h0 + 1) % hBins;
+    const v = (ll, hh) => this.cmax[ll * hBins + hh];
+    const a = v(l0, h0m) + (v(l0, h1m) - v(l0, h0m)) * fh;
+    const b = v(l1, h0m) + (v(l1, h1m) - v(l1, h0m)) * fh;
+    return a + (b - a) * fl;
+  }
+  /** Lightness mapped onto the printable range, chroma softly compressed above 80 % of the boundary. */
+  compress(lab) {
+    const l = this.blackL + Math.min(100, Math.max(0, lab[0])) * (100 - this.blackL) / 100;
+    const c = Math.hypot(lab[1], lab[2]);
+    if (c < 1e-9) return [l, 0, 0];
+    const h = Math.atan2(lab[2], lab[1]);
+    const cm = Math.max(1e-3, this.maxChroma(l, h));
+    const knee = 0.8 * cm;
+    const c2 = c <= knee ? c : knee + (cm - knee) * Math.tanh((c - knee) / (cm - knee));
+    return [l, c2 * Math.cos(h), c2 * Math.sin(h)];
+  }
+};
+var decodeV2 = (v) => [v[0] * 100 * 65535 / 65280, v[1] * 65535 / 256 - 128, v[2] * 65535 / 256 - 128];
+var encodeV2 = (lab) => [
+  Math.min(1, Math.max(0, lab[0] / (100 * 65535 / 65280))),
+  Math.min(1, Math.max(0, (lab[1] + 128) * 256 / 65535)),
+  Math.min(1, Math.max(0, (lab[2] + 128) * 256 / 65535))
+];
+function b2aTable(model, p, gbd) {
+  const n = p.gridB2a;
+  const data = new Float32Array(n * n * n * 4);
+  for (let li = 0; li < n; li++) {
+    for (let ai = 0; ai < n; ai++) {
+      let warm = null;
+      for (let bi = 0; bi < n; bi++) {
+        const lab = decodeV2([li / (n - 1), ai / (n - 1), bi / (n - 1)]);
+        const target = gbd ? gbd.compress(lab) : lab;
+        const [cmyk] = separate(model, p, target, warm);
+        warm = cmyk;
+        data.set(cmyk, ((li * n + ai) * n + bi) * 4);
+      }
+    }
+  }
+  return new Clut([n, n, n], 4, data);
+}
+var ramp = () => ({ type: "table", table: Float32Array.from([0, 1]) });
+function lut16(clut) {
+  return {
+    kind: "lut16",
+    inputs: clut.inputs,
+    outputs: clut.outputs,
+    stages: [
+      { kind: "curves", curves: Array.from({ length: clut.inputs }, ramp) },
+      { kind: "clut", clut },
+      { kind: "curves", curves: Array.from({ length: clut.outputs }, ramp) }
+    ]
+  };
+}
+function cmykProfile(p = DEFAULT_CMYK_PARAMS, copyright = "") {
+  const model = new CmykModel(p.tvi);
+  const g = p.gridA2b;
+  const a2bClut = Clut.sample([g, g, g, g], 3, (inp, out) => out.set(encodeV2(model.lab(inp))));
+  const gbd = new Gbd(model, p);
+  const a2b = lut16(a2bClut);
+  const perceptual = lut16(b2aTable(model, p, gbd));
+  const colorimetric = lut16(b2aTable(model, p, null));
+  return {
+    version: [4, 48],
+    profileClass: "output",
+    colorSpace: "cmyk",
+    pcs: "lab",
+    renderingIntent: "perceptual",
+    description: p.description,
+    copyright,
+    whitePoint: model.paper.map(s15f16Round),
+    blackPoint: null,
+    chad: null,
+    matrix: null,
+    trc: null,
+    grayTrc: null,
+    a2b: [a2b, a2b, a2b],
+    b2a: [perceptual, colorimetric, perceptual],
+    bytes: null
+  };
+}
+
+// src/cms/builtin.ts
+var BUILTIN_COPYRIGHT = "No copyright: CC0-1.0 public domain dedication. Generated by Pixerate.";
+var BUILTIN_PROFILES = [
+  { id: "srgb", description: "sRGB IEC61966-2.1", colorSpace: "rgb" },
+  { id: "display-p3", description: "Display P3", colorSpace: "rgb" },
+  { id: "adobe-rgb-compat", description: "Adobe RGB (1998)-compatible (Pixerate)", colorSpace: "rgb" },
+  { id: "prophoto-compat", description: "ProPhoto RGB-compatible (ROMM primaries, Pixerate)", colorSpace: "rgb" },
+  { id: "linear-srgb", description: "Linear sRGB (Pixerate)", colorSpace: "rgb" },
+  { id: "rec2020", description: "Rec. ITU-R BT.2020 (Pixerate)", colorSpace: "rgb" },
+  { id: "gray-gamma-2.2", description: "Gray Gamma 2.2 (Pixerate)", colorSpace: "gray" },
+  { id: "sgray", description: "sGray (sRGB tone curve, Pixerate)", colorSpace: "gray" },
+  { id: "dot-gain-20-compat", description: "Dot Gain 20%-compatible (gamma 1.732, Pixerate)", colorSpace: "gray" },
+  { id: "lab-d50", description: "Lab D50 identity (Pixerate)", colorSpace: "lab" },
+  { id: "coated-cmyk", description: "Pixerate Coated CMYK (synthetic, 300% TAC, medium GCR)", colorSpace: "cmyk" }
+];
+function builtinProfileId(s) {
+  const n = s.toLowerCase().replace(/[^a-z0-9]/g, "");
+  const aliases = {
+    srgb: "srgb",
+    srgbiec6196621: "srgb",
+    p3: "display-p3",
+    displayp3: "display-p3",
+    adobergb: "adobe-rgb-compat",
+    adobergb1998: "adobe-rgb-compat",
+    adobergbcompat: "adobe-rgb-compat",
+    prophoto: "prophoto-compat",
+    prophotorgb: "prophoto-compat",
+    prophotocompat: "prophoto-compat",
+    linearsrgb: "linear-srgb",
+    rec2020: "rec2020",
+    bt2020: "rec2020",
+    gray: "gray-gamma-2.2",
+    graygamma22: "gray-gamma-2.2",
+    sgray: "sgray",
+    dotgain20: "dot-gain-20-compat",
+    dotgain20compat: "dot-gain-20-compat",
+    lab: "lab-d50",
+    labd50: "lab-d50",
+    cmyk: "coated-cmyk",
+    coatedcmyk: "coated-cmyk"
+  };
+  return aliases[n] ?? BUILTIN_PROFILES.find((b) => b.description.toLowerCase() === s.toLowerCase())?.id ?? null;
+}
+function colorants(r, g, b, white) {
+  const m = rgbToXyzMatrix(r, g, b, white);
+  const d50 = d50Quantized();
+  const nearD50 = Math.abs(white[0] - D50[0]) < 1e-3 && Math.abs(white[2] - D50[2]) < 1e-3;
+  const adapt = nearD50 ? null : bradford(white, D50);
+  let m50;
+  if (adapt) m50 = mul(adapt, m);
+  else {
+    const s = apply(m, [1, 1, 1]);
+    m50 = m.map((row, i) => row.map((v) => v * D50[i] / s[i]));
+  }
+  const q = m50.map((row) => row.map(s15f16Round));
+  for (let i = 0; i < 3; i++) {
+    const row = q[i];
+    const err = d50[i] - (row[0] + row[1] + row[2]);
+    let k = 0;
+    for (let j = 1; j < 3; j++) if (Math.abs(row[j]) > Math.abs(row[k])) k = j;
+    row[k] = s15f16Round(row[k] + err);
+  }
+  return { m: q, chad: adapt ? adapt.map((row) => row.map(s15f16Round)) : null };
+}
+var withBytes = (p) => ({ ...p, bytes: encodeProfile(p) });
+function rgbProfile(desc, prim, white, trc) {
+  const { m, chad } = colorants(prim[0], prim[1], prim[2], white);
+  return withBytes({
+    version: [4, 48],
+    profileClass: "display",
+    colorSpace: "rgb",
+    pcs: "xyz",
+    renderingIntent: "perceptual",
+    description: desc,
+    copyright: BUILTIN_COPYRIGHT,
+    whitePoint: d50Quantized(),
+    blackPoint: null,
+    chad,
+    matrix: m,
+    trc: [trc, trc, trc],
+    grayTrc: null,
+    a2b: [null, null, null],
+    b2a: [null, null, null],
+    bytes: null
+  });
+}
+function grayProfile(desc, trc) {
+  return withBytes({
+    version: [4, 48],
+    profileClass: "display",
+    colorSpace: "gray",
+    pcs: "xyz",
+    renderingIntent: "perceptual",
+    description: desc,
+    copyright: BUILTIN_COPYRIGHT,
+    whitePoint: d50Quantized(),
+    blackPoint: null,
+    chad: null,
+    matrix: null,
+    trc: null,
+    grayTrc: trc,
+    a2b: [null, null, null],
+    b2a: [null, null, null],
+    bytes: null
+  });
+}
+function labProfile(desc) {
+  const ident = () => ({ kind: "ab", inputs: 3, outputs: 3, stages: [{ kind: "curves", curves: [IDENTITY_CURVE, IDENTITY_CURVE, IDENTITY_CURVE] }] });
+  return withBytes({
+    version: [4, 48],
+    profileClass: "colorspace",
+    colorSpace: "lab",
+    pcs: "lab",
+    renderingIntent: "perceptual",
+    description: desc,
+    copyright: BUILTIN_COPYRIGHT,
+    whitePoint: d50Quantized(),
+    blackPoint: null,
+    chad: null,
+    matrix: null,
+    trc: null,
+    grayTrc: null,
+    a2b: [ident(), null, null],
+    b2a: [ident(), null, null],
+    bytes: null
+  });
+}
+function build(id) {
+  const desc = BUILTIN_PROFILES.find((b) => b.id === id).description;
+  const d65 = xyToXyz(D65_XY);
+  const srgbP = [
+    [0.64, 0.33],
+    [0.3, 0.6],
+    [0.15, 0.06]
+  ];
+  switch (id) {
+    case "srgb":
+      return rgbProfile(desc, srgbP, d65, srgbTrc());
+    case "display-p3":
+      return rgbProfile(desc, [[0.68, 0.32], [0.265, 0.69], [0.15, 0.06]], d65, srgbTrc());
+    case "adobe-rgb-compat":
+      return rgbProfile(desc, [[0.64, 0.33], [0.21, 0.71], [0.15, 0.06]], d65, gammaCurve(563 / 256));
+    case "prophoto-compat":
+      return rgbProfile(desc, [[0.7347, 0.2653], [0.1596, 0.8404], [0.0366, 1e-4]], [D50[0], D50[1], D50[2]], gammaCurve(1.8));
+    case "linear-srgb":
+      return rgbProfile(desc, srgbP, d65, gammaCurve(1));
+    case "rec2020": {
+      const a = 1.099;
+      return rgbProfile(desc, [[0.708, 0.292], [0.17, 0.797], [0.131, 0.046]], d65, { type: "parametric", kind: 3, p: [1 / 0.45, 1 / a, (a - 1) / a, 1 / 4.5, 0.081, 0, 0] });
+    }
+    case "gray-gamma-2.2":
+      return grayProfile(desc, gammaCurve(2.2));
+    case "sgray":
+      return grayProfile(desc, srgbTrc());
+    case "dot-gain-20-compat":
+      return grayProfile(desc, gammaCurve(1.732));
+    case "lab-d50":
+      return labProfile(desc);
+    case "coated-cmyk": {
+      const p = cmykProfile(void 0, BUILTIN_COPYRIGHT);
+      const bytes = encodeProfile(p);
+      return { ...parseProfile(bytes), bytes };
+    }
+  }
+}
+var built = /* @__PURE__ */ new Map();
+function builtinProfile(id) {
+  let p = built.get(id);
+  if (!p) {
+    p = build(id);
+    built.set(id, p);
+  }
+  return p;
+}
+var srgbProfile = () => builtinProfile("srgb");
+function defaultProfileFor(cs) {
+  switch (cs) {
+    case "rgb":
+      return builtinProfile("srgb");
+    case "gray":
+      return builtinProfile("dot-gain-20-compat");
+    case "cmyk":
+      return builtinProfile("coated-cmyk");
+    case "lab":
+      return builtinProfile("lab-d50");
+    default:
+      return null;
+  }
+}
+
+// src/cms/embed.ts
+var crcTable = null;
+function crc32(bytes) {
+  if (!crcTable) {
+    crcTable = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+      let c2 = n;
+      for (let k = 0; k < 8; k++) c2 = c2 & 1 ? 3988292384 ^ c2 >>> 1 : c2 >>> 1;
+      crcTable[n] = c2 >>> 0;
+    }
+  }
+  let c = 4294967295;
+  for (let i = 0; i < bytes.length; i++) c = crcTable[(c ^ bytes[i]) & 255] ^ c >>> 8;
+  return (c ^ 4294967295) >>> 0;
+}
+var u32 = (b, o) => (b[o] << 24 | b[o + 1] << 16 | b[o + 2] << 8 | b[o + 3]) >>> 0;
+var PNG_SIG = [137, 80, 78, 71, 13, 10, 26, 10];
+var isPngBytes = (b) => b.length >= 8 && PNG_SIG.every((v, i) => b[i] === v);
+function readPngIcc(png) {
+  if (!isPngBytes(png)) return null;
+  let o = 8;
+  while (o + 12 <= png.length) {
+    const len = u32(png, o);
+    const type = String.fromCharCode(png[o + 4], png[o + 5], png[o + 6], png[o + 7]);
+    if (type === "iCCP") {
+      const d = png.subarray(o + 8, o + 8 + len);
+      const z = d.indexOf(0);
+      if (z < 1 || z > 79 || d[z + 1] !== 0) return null;
+      try {
+        return inflate(d.subarray(z + 2), { maxOutput: 64 * 1024 * 1024 });
+      } catch {
+        return null;
+      }
+    }
+    if (type === "IDAT" || type === "IEND") return null;
+    o += 12 + len;
+  }
+  return null;
+}
+function writePngIcc(png, icc, name = "ICC profile") {
+  if (!isPngBytes(png)) throw new Error("Not a PNG file.");
+  const chunks = [png.subarray(0, 8)];
+  let o = 8;
+  let inserted = false;
+  const label = Array.from(name.slice(0, 79), (c) => c.charCodeAt(0) & 127);
+  const body = new Uint8Array([...label, 0, 0, ...deflate(icc)]);
+  const chunk = new Uint8Array(12 + body.length);
+  chunk.set([body.length >>> 24, body.length >>> 16 & 255, body.length >>> 8 & 255, body.length & 255]);
+  chunk.set([105, 67, 67, 80], 4);
+  chunk.set(body, 8);
+  const crc = crc32(chunk.subarray(4, 8 + body.length));
+  chunk.set([crc >>> 24, crc >>> 16 & 255, crc >>> 8 & 255, crc & 255], 8 + body.length);
+  while (o + 12 <= png.length) {
+    const len = u32(png, o);
+    const type = String.fromCharCode(png[o + 4], png[o + 5], png[o + 6], png[o + 7]);
+    const whole = png.subarray(o, o + 12 + len);
+    if (type !== "iCCP" && type !== "sRGB" && type !== "gAMA") chunks.push(whole);
+    if (type === "IHDR" && !inserted) {
+      chunks.push(chunk);
+      inserted = true;
+    }
+    o += 12 + len;
+  }
+  const out = new Uint8Array(chunks.reduce((n, c) => n + c.length, 0));
+  let at = 0;
+  for (const c of chunks) {
+    out.set(c, at);
+    at += c.length;
+  }
+  return out;
+}
+var ICC_TAG = "ICC_PROFILE\0";
+function readJpegIcc(jpeg) {
+  if (jpeg.length < 4 || jpeg[0] !== 255 || jpeg[1] !== 216) return null;
+  const parts = /* @__PURE__ */ new Map();
+  let count = 0;
+  let o = 2;
+  while (o + 4 <= jpeg.length) {
+    if (jpeg[o] !== 255) break;
+    const marker = jpeg[o + 1];
+    if (marker === 216 || marker >= 208 && marker <= 215 || marker === 1) {
+      o += 2;
+      continue;
+    }
+    if (marker === 218 || marker === 217) break;
+    const len = jpeg[o + 2] << 8 | jpeg[o + 3];
+    if (marker === 226 && len >= 16) {
+      const d = jpeg.subarray(o + 4, o + 2 + len);
+      if (String.fromCharCode(...d.subarray(0, 12)) === ICC_TAG) {
+        parts.set(d[12], d.subarray(14));
+        count = d[13];
+      }
+    }
+    o += 2 + len;
+  }
+  if (!parts.size || !count) return null;
+  const ordered = [];
+  for (let i = 1; i <= count; i++) {
+    const p = parts.get(i);
+    if (!p) return null;
+    ordered.push(p);
+  }
+  const out = new Uint8Array(ordered.reduce((n, p) => n + p.length, 0));
+  let at = 0;
+  for (const p of ordered) {
+    out.set(p, at);
+    at += p.length;
+  }
+  return out;
+}
+function writeJpegIcc(jpeg, icc) {
+  if (jpeg.length < 4 || jpeg[0] !== 255 || jpeg[1] !== 216) throw new Error("Not a JPEG file.");
+  const MAX = 65519;
+  const count = Math.max(1, Math.ceil(icc.length / MAX));
+  if (count > 255) throw new Error("The ICC profile is too large for a JPEG.");
+  const segments = [];
+  for (let i = 0; i < count; i++) {
+    const part = icc.subarray(i * MAX, Math.min(icc.length, (i + 1) * MAX));
+    const len = 2 + 14 + part.length;
+    const s = new Uint8Array(2 + len);
+    s.set([255, 226, len >> 8, len & 255]);
+    for (let k = 0; k < 12; k++) s[4 + k] = ICC_TAG.charCodeAt(k);
+    s[16] = i + 1;
+    s[17] = count;
+    s.set(part, 18);
+    segments.push(s);
+  }
+  const keep = [jpeg.subarray(0, 2)];
+  let o = 2;
+  let inserted = false;
+  while (o + 4 <= jpeg.length && jpeg[o] === 255) {
+    const marker = jpeg[o + 1];
+    if (marker === 218 || marker === 217) break;
+    const len = jpeg[o + 2] << 8 | jpeg[o + 3];
+    const seg = jpeg.subarray(o, o + 2 + len);
+    const isIcc = marker === 226 && String.fromCharCode(...seg.subarray(4, 16)) === ICC_TAG;
+    if (!inserted && marker !== 224 && marker !== 225) {
+      keep.push(...segments);
+      inserted = true;
+    }
+    if (!isIcc) keep.push(seg);
+    o += 2 + len;
+  }
+  if (!inserted) keep.push(...segments);
+  keep.push(jpeg.subarray(o));
+  const out = new Uint8Array(keep.reduce((n, p) => n + p.length, 0));
+  let at = 0;
+  for (const p of keep) {
+    out.set(p, at);
+    at += p.length;
+  }
+  return out;
+}
+
+export {
+  D50,
+  D65_XY,
+  IDENTITY,
+  mul,
+  apply,
+  det,
+  invert,
+  xyToXyz,
+  bradford,
+  rgbToXyzMatrix,
+  xyzToLab,
+  labToXyz,
+  deltaE76,
+  s15f16Round,
+  d50Quantized,
+  IDENTITY_CURVE,
+  srgbTrc,
+  gammaCurve,
+  paramCount,
+  isIdentityCurve,
+  evalCurve,
+  evalCurveInverse,
+  sampleCurve,
+  MAX_CHANNELS,
+  Clut,
+  MAX_PIPE,
+  matrix3,
+  stageOutputs,
+  Pipeline,
+  INTENTS,
+  intentCode,
+  intentFromCode,
+  CmsError,
+  classSig,
+  spaceSig,
+  spaceChannels,
+  profileChannels,
+  SAME_COLORS_MAX_DELTA_E,
+  mediaWhite,
+  isMatrixShaper,
+  supportsIntent,
+  deviceToPcs,
+  pcsToDevice,
+  canBeDestination,
+  grayAsRgb,
+  parseProfile,
+  encodeProfile,
+  DEFAULT_TRANSFORM_OPTIONS,
+  Transform,
+  linkStages,
+  blackPoint,
+  cachedTransform,
+  sameColors,
+  GamutCheck,
+  Lut3d,
+  COATED_CMYK_DESCRIPTION,
+  DEFAULT_CMYK_PARAMS,
+  CmykModel,
+  separate,
+  cmykProfile,
+  BUILTIN_COPYRIGHT,
+  BUILTIN_PROFILES,
+  builtinProfileId,
+  builtinProfile,
+  srgbProfile,
+  defaultProfileFor,
+  readPngIcc,
+  writePngIcc,
+  readJpegIcc,
+  writeJpegIcc
+};
+//# sourceMappingURL=chunk-BRLYOPLT.js.map