@pixerate/editor 0.113.0 → 0.115.0

package/dist/{chunk-CZOXTEMN.js → chunk-XICA4PVO.js}

@@ -1,12 +1,12 @@
 import {
   DEFAULT_GLOBAL_LIGHT,
+  DeepCompositor,
   LAYER_EFFECT_KINDS,
   LayerEffectError,
   MAX_EFFECT_REACH,
   PatternTile,
   RasterCompositor,
   TransformTooLargeError,
-  ZlibError,
   base64ToBytes,
   blendTile,
   builtinPattern,
@@ -23,7 +23,6 @@ import {
   findLayer,
   flattenLayers,
   gaussianBlur,
-  inflate,
   insertLayer,
   isInterpolation,
   isLayerEffectKind,
@@ -35,13 +34,17 @@ import {
   parseDataUrl,
   parseEffectColor,
   pngDataUrl,
+  readDeepRegion,
   reduceSurface,
   scaleLayerEffect,
+  surfaceDepth,
+  surfaceFromDeepPixels,
   transformSurface,
   validateEffectGradient,
   validateLayerEffects,
-  warpSurface
-} from "./chunk-LQEEDHOP.js";
+  warpSurface,
+  writeDeepRegion
+} from "./chunk-C6C5PDKU.js";
 import {
   affineFromHomography,
   applyHomography,
@@ -68,8 +71,21 @@ import {
   tileKey,
   tilesInRect,
   translateSurface
-} from "./chunk-HNS7UHCM.js";
+} from "./chunk-XK5LZKBD.js";
+import {
+  Transform,
+  builtinProfile,
+  parseProfile,
+  srgbProfile
+} from "./chunk-BRLYOPLT.js";
+import {
+  ZlibError,
+  deflate,
+  inflate
+} from "./chunk-6FCKOS2B.js";
 import {
+  DEFAULT_AUTO_LEADING,
+  DEFAULT_TEXT_STYLE,
   IDENTITY_MATRIX,
   WARP_STYLES,
   applyMatrix,
@@ -77,11 +93,15 @@ import {
   ellipseSubpath,
   evalWarpMesh,
   expandVectorCorners,
+  fitParagraphRuns,
+  fitRuns,
   fitWarpMesh,
   identityWarpMesh,
   invertMatrix,
   isIdentityMatrix,
+  isTextSpace,
   isValidWarpMesh,
+  layoutText,
   mapWarpMeshPoints,
   matrixAbout,
   multiplyMatrices,
@@ -89,11 +109,16 @@ import {
   rectSubpath,
   rotateMatrix,
   setAnchorCorner,
+  spliceRuns,
   starSubpath,
+  styleAt,
   subpathsToBezier,
+  textDecorations,
+  textFragmentOutline,
+  textRectPath,
   translateMatrix,
   warpPresetMesh
-} from "./chunk-BLWCAQCW.js";
+} from "./chunk-VXR7XWMF.js";
 import {
   bezierPathBounds,
   outlineStroke,
@@ -1742,7 +1767,7 @@ function lutOp(luts) {
 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) {
+function toneLuts(layer, quantum = LEVELS_QUANTUM) {
   const n = ADJUSTMENT_LUT_SIZE;
   if (layer.kind === "curves") {
     const m = curveLutFromLevels(layer.params.master);
@@ -1757,13 +1782,14 @@ function toneLuts(layer) {
     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);
+      const q2 = quantum ?? void 0;
+      for (let k = 0; k < n; k++) out[k] = levelsValue(m, levelsValue(c, k / (n - 1), q2), q2);
       return out;
     });
   }
   return null;
 }
-function compileAdjustmentLayer(layer) {
+function compileAdjustmentLayer(layer, options = {}) {
   switch (layer.kind) {
     case "curves": {
       const p = layer.params;
@@ -1773,7 +1799,7 @@ function compileAdjustmentLayer(layer) {
     case "levels": {
       const p = layer.params;
       if ([p.master, p.red, p.green, p.blue].every(isIdentityLevels)) return null;
-      return lutOp(toneLuts(layer));
+      return lutOp(toneLuts(layer, options.deep ? null : LEVELS_QUANTUM));
     }
     case "hueSaturation": {
       const p = layer.params;
@@ -1878,15 +1904,15 @@ function compileAdjustmentLayer(layer) {
 }
 var COMPILE_CACHE_LIMIT = 64;
 var compileCache = /* @__PURE__ */ new Map();
-function compiledFor(layer) {
-  const key = `${layer.kind}:${JSON.stringify(layer.params)}`;
+function compiledFor(layer, deep = false) {
+  const key = `${deep ? "deep:" : ""}${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);
+  const op = compileAdjustmentLayer(layer, { deep });
   compileCache.set(key, op);
   if (compileCache.size > COMPILE_CACHE_LIMIT) compileCache.delete(compileCache.keys().next().value);
   return op;
@@ -1947,6 +1973,29 @@ function applyAdjustmentLayers(imageData, layers, masks) {
     data[i + 2] = Math.round(clamp01(c[2]) * 255);
   }
 }
+function applyAdjustmentLayersFloat(data, layers, masks) {
+  const active = activeAdjustmentLayers(layers);
+  if (!active.length) return;
+  const ops = active.map((l) => compiledFor(l, true));
+  const planes = active.map((l) => masks?.get(l.id));
+  const c = [0, 0, 0];
+  for (let i = 0; i < data.length; i += 4) {
+    if (!(data[i + 3] > 0)) continue;
+    c[0] = data[i];
+    c[1] = data[i + 1];
+    c[2] = data[i + 2];
+    for (let k = 0; k < active.length; k++) {
+      const plane = planes[k];
+      if (plane) {
+        const cov = plane[i >> 2];
+        if (cov > 0) applyLayer(c, active[k], ops[k], cov >= 1 ? 1 : cov);
+      } else applyLayer(c, active[k], ops[k]);
+    }
+    data[i] = c[0];
+    data[i + 1] = c[1];
+    data[i + 2] = c[2];
+  }
+}
 function adjustmentLayersKey(layers) {
   if (!layers?.length) return "";
   return JSON.stringify(
@@ -2222,10 +2271,12 @@ function removeAlpha(imageData) {
   }
 }
 
+// src/text/types.ts
+var TEXT_ALIGNS = ["left", "center", "right", "justify"];
+
 // src/image-editor/layers/model.ts
 var SHAPE_OPERATIONS = ["combine", "subtract", "intersect", "exclude"];
 var LIVE_SHAPE_KINDS = ["rect", "ellipse", "polygon", "star", "line"];
-var TEXT_ALIGNS = ["left", "center", "right", "justify"];
 var idCounter = 0;
 function newLayerId(prefix = "layer") {
   return `${prefix}_${Date.now().toString(36)}_${(++idCounter).toString(36)}`;
@@ -2376,6 +2427,12 @@ var LayerCompositor = class extends RasterCompositor {
     super(PHOTO_PROFILE, options);
   }
 };
+function compositeDeep(layers, rect, sources, depth) {
+  const deep = new DeepCompositor(new LayerCompositor(), PHOTO_PROFILE, {
+    applyFilterRunDeep: (run, acc, _r, masks) => applyAdjustmentLayersFloat(acc, run.map(adjustmentNodeAsLayer), masks)
+  }, depth);
+  return deep.composite(layers, rect, sources);
+}
 
 // src/image-editor/layers/vector-raster.ts
 var FLATNESS = 0.01;
@@ -3901,300 +3958,6 @@ function annotationOfShape(layer) {
 var fail3 = (message) => {
   throw new LayerOperationError(message);
 };
-var DEFAULT_TEXT_STYLE = { fontFamily: "sans-serif", fontWeight: 400, fontSize: 24, color: "#000000" };
-var DEFAULT_AUTO_LEADING = 1.2;
-var sameStyle = (a, b) => JSON.stringify(a) === JSON.stringify(b);
-function compact(runs) {
-  const out = [];
-  for (const r of runs) {
-    if (r.length <= 0) continue;
-    const last = out[out.length - 1];
-    if (last && sameStyle(last.style, r.style)) out[out.length - 1] = { ...last, length: last.length + r.length };
-    else out.push({ ...r });
-  }
-  return out;
-}
-function fitRuns(runs, length, fallback) {
-  const out = [];
-  let left = length;
-  for (const r of runs) {
-    if (left <= 0) break;
-    const n = Math.min(Math.max(0, Math.floor(r.length)), left);
-    if (n > 0) out.push({ ...r, length: n });
-    left -= n;
-  }
-  if (left > 0) {
-    if (out.length) out[out.length - 1] = { ...out[out.length - 1], length: out[out.length - 1].length + left };
-    else out.push({ length: left, style: runs[runs.length - 1]?.style ?? fallback });
-  }
-  return compact(out);
-}
-function styleAt(runs, index, fallback) {
-  let at = 0;
-  for (const r of runs) {
-    if (index < at + r.length) return r.style;
-    at += r.length;
-  }
-  return runs[runs.length - 1]?.style ?? fallback;
-}
-function restyleRange(runs, start, end, patch) {
-  const out = [];
-  let at = 0;
-  for (const r of runs) {
-    const a = at;
-    const b = at + r.length;
-    at = b;
-    const lo = Math.max(a, start);
-    const hi = Math.min(b, end);
-    if (hi <= lo) {
-      out.push({ ...r });
-      continue;
-    }
-    if (lo > a) out.push({ length: lo - a, style: r.style });
-    out.push({ length: hi - lo, style: patch(r.style) });
-    if (b > hi) out.push({ length: b - hi, style: r.style });
-  }
-  return compact(out);
-}
-function spliceRuns(runs, start, end, inserted, style) {
-  const out = [];
-  let at = 0;
-  let placed = false;
-  for (const r of runs) {
-    const a = at;
-    const b = at + r.length;
-    at = b;
-    if (b <= start) {
-      out.push({ ...r });
-      continue;
-    }
-    if (a < start) out.push({ length: start - a, style: r.style });
-    if (!placed) {
-      out.push({ length: inserted, style });
-      placed = true;
-    }
-    if (b > end) out.push({ length: b - Math.max(end, a), style: r.style });
-  }
-  if (!placed) out.push({ length: inserted, style });
-  return compact(out);
-}
-function paragraphRanges(text3) {
-  const out = [];
-  let start = 0;
-  for (let i = 0; i < text3.length; i++) {
-    if (text3[i] === "\n") {
-      out.push({ start, end: i + 1, content: i });
-      start = i + 1;
-    }
-  }
-  out.push({ start, end: text3.length, content: text3.length });
-  return out;
-}
-function fitParagraphRuns(runs, text3) {
-  const fallback = runs[0]?.style ?? {};
-  const out = compact(paragraphRanges(text3).map((p) => ({ length: p.end - p.start, style: styleAt(runs, p.start, fallback) })));
-  return out.length ? out : [{ length: 0, style: fallback }];
-}
-function fontOf(style) {
-  const f = { family: style.fontFamily, weight: style.fontWeight, italic: Boolean(style.italic), size: style.fontSize };
-  if (style.postScriptName) f.postScriptName = style.postScriptName;
-  return f;
-}
-var isBreakAfter = (c) => c === " " || c === "	" || c === "-" || c === "\u2010" || c === "\u200B";
-var isSpace = (c) => c === " " || c === "	";
-var isWide = (code) => code >= 11904 && code <= 40959 || code >= 44032 && code <= 55215 || code >= 63744 && code <= 64255 || code >= 65280 && code <= 65519;
-var layoutCache = /* @__PURE__ */ new WeakMap();
-function layoutText(layer, shaper) {
-  let byShaper = layoutCache.get(layer);
-  const hit = byShaper?.get(shaper.id);
-  if (hit) return hit;
-  const out = computeLayout(layer, shaper);
-  if (!byShaper) {
-    byShaper = /* @__PURE__ */ new Map();
-    layoutCache.set(layer, byShaper);
-  }
-  byShaper.set(shaper.id, out);
-  return out;
-}
-function computeLayout(layer, shaper) {
-  const { text: text3, frame } = layer;
-  const runs = fitRuns(layer.runs, text3.length, DEFAULT_TEXT_STYLE);
-  const missing = /* @__PURE__ */ new Set();
-  const resolved = /* @__PURE__ */ new Map();
-  const familyOf = (font) => {
-    const key = `${font.family}|${font.weight}|${font.italic}|${font.postScriptName ?? ""}`;
-    let fam = resolved.get(key);
-    if (fam === void 0) {
-      const r = shaper.resolve(font);
-      fam = r.family;
-      if (!r.available) missing.add(font.family);
-      resolved.set(key, fam);
-    }
-    return fam;
-  };
-  const resolvedFont = (style) => ({ ...fontOf(style), family: familyOf(fontOf(style)) });
-  const box2 = frame.kind === "box" ? frame : null;
-  const lines = [];
-  let y = 0;
-  let first = true;
-  const paragraphs = paragraphRanges(text3);
-  paragraphs.forEach((para, pi) => {
-    const pstyle = styleAt(layer.paragraphs, para.start, {});
-    const autoLeading = pstyle.autoLeading ?? DEFAULT_AUTO_LEADING;
-    if (pi > 0) y += pstyle.spaceBefore ?? 0;
-    const chars = [];
-    let i = para.start;
-    while (i < para.content) {
-      const style = styleAt(runs, i, DEFAULT_TEXT_STYLE);
-      let j = i + 1;
-      while (j < para.content && styleAt(runs, j, DEFAULT_TEXT_STYLE) === style) j++;
-      const seg = text3.slice(i, j);
-      const carets = shaper.measure(seg, resolvedFont(style));
-      const track = (style.tracking ?? 0) / 1e3 * style.fontSize;
-      for (let k = 0; k < seg.length; k++) chars.push({ index: i + k, ch: seg[k], advance: (carets[k + 1] ?? 0) - (carets[k] ?? 0) + track, style });
-      i = j;
-    }
-    const startIndent = pstyle.startIndent ?? 0;
-    const endIndent = pstyle.endIndent ?? 0;
-    const firstIndent = pstyle.firstLineIndent ?? 0;
-    const breaks = [];
-    if (!box2 || !chars.length) breaks.push([0, chars.length]);
-    else {
-      let s = 0;
-      while (s < chars.length) {
-        const avail = box2.width - startIndent - endIndent - (breaks.length === 0 ? firstIndent : 0);
-        let w = 0;
-        let e = s;
-        let lastBreak = -1;
-        while (e < chars.length) {
-          const c = chars[e];
-          if (!isSpace(c.ch) && w + c.advance > avail && e > s) break;
-          w += c.advance;
-          if (isBreakAfter(c.ch) || isWide(c.ch.charCodeAt(0)) || e + 1 < chars.length && isWide(chars[e + 1].ch.charCodeAt(0))) lastBreak = e + 1;
-          e++;
-        }
-        if (e < chars.length && lastBreak > s) e = lastBreak;
-        while (e < chars.length && isSpace(chars[e].ch)) e++;
-        breaks.push([s, e]);
-        s = e;
-      }
-    }
-    const align = pstyle.align ?? "left";
-    breaks.forEach(([s, e], li) => {
-      const lineChars = chars.slice(s, e);
-      let visibleEnd = lineChars.length;
-      while (visibleEnd > 0 && isSpace(lineChars[visibleEnd - 1].ch)) visibleEnd--;
-      const styles = lineChars.length ? [...new Set(lineChars.map((c) => c.style))] : [styleAt(runs, Math.min(para.start, Math.max(0, text3.length - 1)), DEFAULT_TEXT_STYLE)];
-      let ascent = 0;
-      let descent = 0;
-      let leading = 0;
-      for (const st of styles) {
-        const m = shaper.metrics(resolvedFont(st));
-        ascent = Math.max(ascent, m.ascent);
-        descent = Math.max(descent, m.descent);
-        leading = Math.max(leading, st.leading ?? autoLeading * st.fontSize);
-      }
-      if (first) {
-        y = frame.kind === "box" || frame.kind === "point" && frame.origin === "top" ? ascent : 0;
-        first = false;
-      } else y += leading;
-      const indent = startIndent + (li === 0 ? firstIndent : 0);
-      let width = 0;
-      for (let k2 = 0; k2 < visibleEnd; k2++) width += lineChars[k2].advance;
-      const lastLine = li === breaks.length - 1;
-      let extraPerSpace = 0;
-      if (box2 && align === "justify" && !lastLine) {
-        const spaces = lineChars.slice(0, visibleEnd).filter((c) => isSpace(c.ch)).length;
-        const avail = box2.width - startIndent - endIndent - (li === 0 ? firstIndent : 0);
-        if (spaces > 0 && avail > width) extraPerSpace = (avail - width) / spaces;
-      }
-      let x0;
-      const fullWidth = width + extraPerSpace * lineChars.slice(0, visibleEnd).filter((c) => isSpace(c.ch)).length;
-      if (box2) {
-        const avail = box2.width - startIndent - endIndent - (li === 0 ? firstIndent : 0);
-        x0 = indent + (align === "center" ? (avail - fullWidth) / 2 : align === "right" ? avail - fullWidth : 0);
-      } else x0 = indent + (align === "center" ? -fullWidth / 2 : align === "right" ? -fullWidth : 0);
-      const laid = [];
-      let x = x0;
-      for (const c of lineChars) {
-        const adv = c.advance + (isSpace(c.ch) ? extraPerSpace : 0);
-        laid.push({ index: c.index, x, advance: adv });
-        x += adv;
-      }
-      const fragments = [];
-      let k = 0;
-      while (k < lineChars.length) {
-        const st = lineChars[k].style;
-        let m = k + 1;
-        while (m < lineChars.length && lineChars[m].style === st) m++;
-        const font = resolvedFont(st);
-        const fx = laid[k].x;
-        const carets = [0];
-        for (let q2 = k; q2 < m; q2++) carets.push(laid[q2].x + laid[q2].advance - fx);
-        fragments.push({
-          start: lineChars[k].index,
-          end: lineChars[m - 1].index + 1,
-          style: st,
-          font,
-          family: font.family,
-          x: fx,
-          y: y - (st.baselineShift ?? 0),
-          carets,
-          spaced: Boolean(st.tracking) || extraPerSpace > 0
-        });
-        k = m;
-      }
-      const lineStart = lineChars.length ? lineChars[0].index : para.start;
-      lines.push({ start: lineStart, end: lineChars.length ? lineChars[lineChars.length - 1].index + 1 : para.start, baseline: y, ascent, descent, x: x0, width, chars: laid, fragments });
-    });
-    y += pstyle.spaceAfter ?? 0;
-  });
-  let bounds;
-  if (box2) bounds = { x: 0, y: 0, width: box2.width, height: box2.height };
-  else {
-    let x0 = Infinity;
-    let x1 = -Infinity;
-    for (const l of lines) {
-      x0 = Math.min(x0, l.x);
-      x1 = Math.max(x1, l.x + l.width);
-    }
-    if (!Number.isFinite(x0)) x0 = x1 = 0;
-    const top = lines.length ? lines[0].baseline - lines[0].ascent : 0;
-    const last = lines[lines.length - 1];
-    const bottom = last ? last.baseline + last.descent : 0;
-    bounds = { x: x0, y: top, width: Math.max(0, x1 - x0), height: Math.max(0, bottom - top) };
-  }
-  return { lines, bounds, missingFonts: [...missing] };
-}
-function textIndexAt(layout, p) {
-  if (!layout.lines.length) return 0;
-  let line = layout.lines[layout.lines.length - 1];
-  for (const l of layout.lines) {
-    if (p.y <= l.baseline + l.descent) {
-      line = l;
-      break;
-    }
-  }
-  if (!line.chars.length) return line.start;
-  for (const c of line.chars) if (p.x < c.x + c.advance / 2) return c.index;
-  const lastChar = line.chars[line.chars.length - 1];
-  return lastChar.index + 1;
-}
-function caretAt(layout, index) {
-  const lines = layout.lines;
-  if (!lines.length) return { x: 0, top: 0, bottom: 0, line: 0 };
-  for (let li = 0; li < lines.length; li++) {
-    const l2 = lines[li];
-    const next = lines[li + 1];
-    if (next && index >= next.start && (next.chars.length || index > l2.end || next.start > l2.end)) continue;
-    const c = l2.chars.find((ch) => ch.index === index);
-    const prev = l2.chars.find((ch) => ch.index === index - 1);
-    const x = c ? c.x : prev ? prev.x + prev.advance : l2.x;
-    return { x, top: l2.baseline - l2.ascent, bottom: l2.baseline + l2.descent, line: li };
-  }
-  const l = lines[lines.length - 1];
-  return { x: l.x + l.width, top: l.baseline - l.ascent, bottom: l.baseline + l.descent, line: lines.length - 1 };
-}
 var TEXT_RENDER_MARGIN = MAX_EFFECT_REACH;
 function textMatrix(layer) {
   return layer.transform ?? IDENTITY_MATRIX;
@@ -4239,31 +4002,6 @@ function inkBounds(layout) {
   }
   return b;
 }
-function decorations(f, l) {
-  const out = [];
-  const t = Math.max(1, f.style.fontSize / 15);
-  const w = f.carets[f.carets.length - 1];
-  if (f.style.underline) out.push({ x: f.x, y: f.y + Math.max(t, l.descent * 0.35), width: w, height: t });
-  if (f.style.strikethrough) out.push({ x: f.x, y: f.y - l.ascent * 0.3 - t / 2, width: w, height: t });
-  return out;
-}
-var rectPath = (r) => [
-  { type: "M", x: r.x, y: r.y },
-  { type: "L", x: r.x + r.width, y: r.y },
-  { type: "L", x: r.x + r.width, y: r.y + r.height },
-  { type: "L", x: r.x, y: r.y + r.height },
-  { type: "Z" }
-];
-function fragmentOutline(shaper, text3, f) {
-  const s = text3.slice(f.start, f.end);
-  if (!f.spaced) return shaper.outline(s, f.font, f.x, f.y);
-  const out = [];
-  for (let k = 0; k < s.length; k++) {
-    if (isSpace(s[k])) continue;
-    out.push(...shaper.outline(s[k], f.font, f.x + f.carets[k], f.y));
-  }
-  return out;
-}
 function textOutlines(layer, shaper) {
   if (!shaper.outline) fail3(`The text shaper "${shaper.id}" cannot give glyph outlines; plug in an outline shaper (createOutlineTextShaper) to convert text to shapes.`);
   const layout = layoutText(layer, shaper);
@@ -4271,8 +4009,8 @@ function textOutlines(layer, shaper) {
   const out = [];
   for (const l of layout.lines) {
     for (const f of l.fragments) {
-      let path = fragmentOutline(shaper, layer.text, f);
-      for (const r of decorations(f, l)) path = [...path, ...rectPath(r)];
+      let path = textFragmentOutline(shaper, layer.text, f);
+      for (const r of textDecorations(f, l)) path = [...path, ...textRectPath(r)];
       out.push({ fragment: f, path: isIdentityMatrix(m) ? path : transformBezierPath(path, m) });
     }
   }
@@ -4341,8 +4079,8 @@ function renderOnCanvas(layer, shaper, region, env) {
       ctx.globalAlpha = f.style.opacity ?? 1;
       const s = layer.text.slice(f.start, f.end);
       if (!f.spaced) shaper.draw(ctx, s, f.font, f.x, f.y);
-      else for (let k = 0; k < s.length; k++) if (!isSpace(s[k])) shaper.draw(ctx, s[k], f.font, f.x + f.carets[k], f.y);
-      for (const d of decorations(f, l)) ctx.fillRect(d.x, d.y, d.width, d.height);
+      else for (let k = 0; k < s.length; k++) if (!isTextSpace(s[k])) shaper.draw(ctx, s[k], f.font, f.x + f.carets[k], f.y);
+      for (const d of textDecorations(f, l)) ctx.fillRect(d.x, d.y, d.width, d.height);
     }
   }
   ctx.globalAlpha = 1;
@@ -5679,6 +5417,42 @@ function encodeSurface(surface) {
   encodedCache.set(surface, out);
   return out;
 }
+var deepCache = /* @__PURE__ */ new WeakMap();
+function encodeDeepSurface(surface) {
+  if (deepCache.has(surface)) return deepCache.get(surface);
+  let out = null;
+  const depth = surfaceDepth(surface);
+  const b = depth === 8 ? null : contentBounds(surface);
+  if (depth !== 8 && b) {
+    const samples = readDeepRegion(surface, b, depth);
+    const bytes = new Uint8Array(samples.byteLength);
+    const view = new DataView(bytes.buffer);
+    if (samples instanceof Uint16Array) for (let i = 0; i < samples.length; i++) view.setUint16(2 * i, samples[i], true);
+    else for (let i = 0; i < samples.length; i++) view.setFloat32(4 * i, samples[i], true);
+    out = { depth, x: b.x, y: b.y, width: b.width, height: b.height, data: bytesToBase64(deflate(bytes)) };
+  }
+  deepCache.set(surface, out);
+  return out;
+}
+function decodeDeepSurface(surface, raw, problems, label) {
+  const d = raw;
+  if (!d || typeof d !== "object") return surface;
+  try {
+    if (d.depth !== 16 && d.depth !== 32 || !(d.width > 0 && d.height > 0) || !Number.isInteger(d.x) || !Number.isInteger(d.y) || typeof d.data !== "string") throw new Error("malformed");
+    const n = d.width * d.height * 4;
+    const size = d.depth === 16 ? 2 : 4;
+    const bytes = inflate(base64ToBytes(d.data), { maxOutput: n * size });
+    if (bytes.length !== n * size) throw new Error("wrong length");
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const samples = d.depth === 16 ? new Uint16Array(n) : new Float32Array(n);
+    if (samples instanceof Uint16Array) for (let i = 0; i < n; i++) samples[i] = view.getUint16(2 * i, true);
+    else for (let i = 0; i < n; i++) samples[i] = view.getFloat32(4 * i, true);
+    return writeDeepRegion(surface, { x: d.x, y: d.y, width: d.width, height: d.height }, samples);
+  } catch {
+    problems.push(`${label}: its ${d.depth}-bit samples could not be read, so it was opened at 8 bits`);
+    return surface;
+  }
+}
 function baseFields(layer, ctx) {
   const out = {
     id: layer.id,
@@ -5747,6 +5521,10 @@ function serializeLayer(layer, ctx) {
       }
       if (layer.fillOpacity !== void 0 && layer.fillOpacity !== 1) out.fillOpacity = layer.fillOpacity;
       if (layer.filters?.length) out.filters = JSON.parse(JSON.stringify(layer.filters));
+      if (layer.source !== "document") {
+        const deep = encodeDeepSurface(layer.surface);
+        if (deep) out.deep = deep;
+      }
       return out;
     }
     case "adjustment":
@@ -6128,6 +5906,7 @@ function deserializeLayer(raw, ctx) {
         offset: { x: Math.round(num2(r.offset?.x, -1e7, 1e7, 0)), y: Math.round(num2(r.offset?.y, -1e7, 1e7, 0)) }
       };
       if (r.source === "document") layer.source = "document";
+      else if (r.deep) layer.surface = decodeDeepSurface(layer.surface, r.deep, ctx.problems, `Layer "${base.name || id}"`);
       if (typeof r.fillOpacity === "number" && r.fillOpacity !== 1) layer.fillOpacity = num2(r.fillOpacity, 0, 1, 1);
       const filters = readFilters(r.filters);
       if (filters) layer.filters = filters;
@@ -8465,6 +8244,36 @@ function encodeRle(decoded2, l) {
   out.set(packed.subarray(0, at), counts.length);
   return out;
 }
+function predict(buf, l) {
+  const rb = rowBytes(l.width, l.depth);
+  if (rb === 0) return;
+  const w = l.width;
+  const scratch = l.depth === 32 ? new Uint8Array(rb) : null;
+  for (let o = 0; o + rb <= buf.length; o += rb) {
+    if (l.depth === 1 || l.depth === 8) {
+      for (let i = rb - 1; i > 0; i--) buf[o + i] = buf[o + i] - buf[o + i - 1] & 255;
+    } else if (l.depth === 16) {
+      for (let i = w - 1; i > 0; i--) {
+        const a = buf[o + 2 * i] << 8 | buf[o + 2 * i + 1];
+        const b = buf[o + 2 * i - 2] << 8 | buf[o + 2 * i - 1];
+        const v = a - b & 65535;
+        buf[o + 2 * i] = v >> 8;
+        buf[o + 2 * i + 1] = v & 255;
+      }
+    } else if (l.depth === 32) {
+      scratch.set(buf.subarray(o, o + rb));
+      for (let i = 0; i < w; i++) for (let k = 0; k < 4; k++) buf[o + k * w + i] = scratch[4 * i + k];
+      for (let i = rb - 1; i > 0; i--) buf[o + i] = buf[o + i] - buf[o + i - 1] & 255;
+    } else {
+      throw new PsdError(`ZIP prediction is not defined for depth ${l.depth}.`);
+    }
+  }
+}
+function encodeZipPredicted(decoded2, l) {
+  const buf = decoded2.slice();
+  predict(buf, l);
+  return deflate(buf);
+}
 
 // src/image-editor/psd/smart.ts
 var dbl2 = (value) => ({ type: "doub", value });
@@ -9405,23 +9214,31 @@ function writePsd(file, encodeName) {
   w.endLen(res);
   const lm = w.beginLen(psb);
   if (file.layers.length || file.globalBlocks.length) {
-    const li = w.beginLen(psb);
-    if (file.layers.length) {
-      const start = w.length;
-      w.i16(file.mergedAlpha ? -file.layers.length : file.layers.length);
-      for (const rec of file.layers) writeLayerRecord(w, rec, psb, encodeName(rec.legacyName));
+    const writeLayerInfo = (out) => {
+      const start = out.length;
+      out.i16(file.mergedAlpha ? -file.layers.length : file.layers.length);
+      for (const rec of file.layers) writeLayerRecord(out, rec, psb, encodeName(rec.legacyName));
       for (const rec of file.layers) {
         for (const c of rec.channels) {
           if (c.compression === null) continue;
-          w.u16(c.compression);
-          w.bytes(c.data);
+          out.u16(c.compression);
+          out.bytes(c.data);
         }
       }
-      if ((w.length - start) % 2) w.u8(0);
-    }
+      if ((out.length - start) % 2) out.u8(0);
+    };
+    const deepKey = header.depth === 16 ? "Lr16" : header.depth === 32 ? "Lr32" : null;
+    let blocks = file.globalBlocks;
+    const li = w.beginLen(psb);
+    if (file.layers.length && !deepKey) writeLayerInfo(w);
     w.endLen(li);
+    if (file.layers.length && deepKey) {
+      const lw = new PsdWriter();
+      writeLayerInfo(lw);
+      blocks = [{ key: deepKey, data: lw.result() }, ...blocks];
+    }
     w.u32(0);
-    writeBlocks(w, file.globalBlocks, psb, 4);
+    writeBlocks(w, blocks, psb, 4);
   }
   w.endLen(lm);
   w.u16(file.imageCompression);
@@ -9430,6 +9247,7 @@ function writePsd(file, encodeName) {
 }
 
 // src/image-editor/psd/pixels.ts
+var MODE_BITMAP = 0;
 var MODE_INDEXED = 2;
 var MODE_RGB = 3;
 var MODE_CMYK = 4;
@@ -9509,6 +9327,15 @@ function toRgba8(set) {
     }
     return out;
   }
+  if (mode === MODE_CMYK && set.cmykToRgb) {
+    const ink = new Uint8Array(n * 4);
+    for (let i = 0, o = 0; i < n; i++, o += 4) {
+      for (let c = 0; c < 4; c++) ink[o + c] = Math.round((1 - (planes[c] ? planes[c](i) : 1)) * 255);
+      out[o + 3] = Math.round(alpha(i) * 255);
+    }
+    set.cmykToRgb(ink, out);
+    return out;
+  }
   const palette = set.palette;
   for (let i = 0, o = 0; i < n; i++, o += 4) {
     let r;
@@ -9553,6 +9380,99 @@ function toRgba8(set) {
   }
   return out;
 }
+function toRgbaDeep(set) {
+  const { width, height, depth, mode } = set;
+  if (depth !== 16 && depth !== 32 || mode === MODE_INDEXED || mode === MODE_BITMAP) return null;
+  const n = width * height;
+  const isLab = mode === MODE_LAB;
+  const cmyk = mode === MODE_CMYK;
+  const raw = (plane, fill) => {
+    if (!plane) return () => fill;
+    if (depth === 16) return (i) => (plane[2 * i] << 8 | plane[2 * i + 1]) / 65535;
+    const view = new DataView(plane.buffer, plane.byteOffset, plane.byteLength);
+    return (i) => view.getFloat32(4 * i, false) || 0;
+  };
+  const planes = set.color.map((p) => raw(p, cmyk ? 1 : 0));
+  const alpha = raw(set.alpha, 1);
+  if (depth === 16) {
+    const out2 = new Uint16Array(n * 4);
+    const q2 = (v) => Math.round(clamp012(v) * 65535);
+    for (let i = 0, o = 0; i < n; i++, o += 4) {
+      let r;
+      let g;
+      let b;
+      if (mode === MODE_CMYK) {
+        const k = planes[3] ? planes[3](i) : 1;
+        r = planes[0](i) * k;
+        g = planes[1](i) * k;
+        b = planes[2](i) * k;
+      } else if (isLab) {
+        [r, g, b] = labToSrgb(planes[0](i) * 100, planes[1](i) * 255 - 128, planes[2](i) * 255 - 128);
+      } else if (mode === MODE_RGB || mode === MODE_MULTICHANNEL) {
+        r = planes[0](i);
+        g = planes[1] ? planes[1](i) : r;
+        b = planes[2] ? planes[2](i) : r;
+      } else r = g = b = planes[0](i);
+      out2[o] = q2(r);
+      out2[o + 1] = q2(g);
+      out2[o + 2] = q2(b);
+      out2[o + 3] = q2(alpha(i));
+    }
+    return out2;
+  }
+  const out = new Float32Array(n * 4);
+  for (let i = 0, o = 0; i < n; i++, o += 4) {
+    let r;
+    let g;
+    let b;
+    if (isLab) {
+      [r, g, b] = labToSrgb(planes[0](i) * 100, planes[1](i) * 255 - 128, planes[2](i) * 255 - 128).map(srgbToLinear);
+    } else if (cmyk) {
+      const k = planes[3] ? planes[3](i) : 1;
+      r = planes[0](i) * k;
+      g = planes[1](i) * k;
+      b = planes[2](i) * k;
+    } else if (mode === MODE_RGB || mode === MODE_MULTICHANNEL) {
+      r = planes[0](i);
+      g = planes[1] ? planes[1](i) : r;
+      b = planes[2] ? planes[2](i) : r;
+    } else r = g = b = planes[0](i);
+    out[o] = r;
+    out[o + 1] = g;
+    out[o + 2] = b;
+    out[o + 3] = clamp012(alpha(i));
+  }
+  return out;
+}
+function deepToPlanes(data, n) {
+  const bytes = data instanceof Uint16Array ? 2 : 4;
+  const planes = [0, 1, 2, 3].map(() => new Uint8Array(n * bytes));
+  if (data instanceof Uint16Array) {
+    for (let i = 0; i < n; i++) {
+      for (let c = 0; c < 4; c++) {
+        const v = data[i * 4 + c];
+        planes[c][2 * i] = v >> 8;
+        planes[c][2 * i + 1] = v & 255;
+      }
+    }
+  } else {
+    const views = planes.map((p) => new DataView(p.buffer));
+    for (let i = 0; i < n; i++) for (let c = 0; c < 4; c++) views[c].setFloat32(4 * i, data[i * 4 + c], false);
+  }
+  return planes;
+}
+function planeAtDepth(plane, depth) {
+  if (depth === 8) return plane;
+  if (depth === 16) {
+    const out2 = new Uint8Array(plane.length * 2);
+    for (let i = 0; i < plane.length; i++) out2[2 * i] = out2[2 * i + 1] = plane[i];
+    return out2;
+  }
+  const out = new Uint8Array(plane.length * 4);
+  const view = new DataView(out.buffer);
+  for (let i = 0; i < plane.length; i++) view.setFloat32(4 * i, plane[i] / 255, false);
+  return out;
+}
 function toMask8(plane, width, height, depth) {
   if (depth === 8) return new Uint8ClampedArray(plane.buffer, plane.byteOffset, width * height);
   const s = sampler(plane, depth, width, false, 0);
@@ -9587,6 +9507,16 @@ function matteWhite(data) {
   }
   return out;
 }
+function matteWhiteDeep(data) {
+  const out = data.slice();
+  const one = out instanceof Uint16Array ? 65535 : 1;
+  for (let i = 0; i < out.length; i += 4) {
+    const a = Math.min(1, Math.max(0, out[i + 3] / one));
+    if (a >= 1) continue;
+    for (let c = 0; c < 3; c++) out[i + c] = out instanceof Uint16Array ? Math.round(out[i + c] * a + one * (1 - a)) : out[i + c] * a + one * (1 - a);
+  }
+  return out;
+}
 
 // src/image-editor/psd/patterns.ts
 var MAX_EDGE = 3e4;
@@ -9823,16 +9753,19 @@ function recordPixels(ctx, rec, name) {
   const planes = ids.map((id) => rec.channels.some((c) => c.id === id) ? decodeOr(ctx, rec, id, name) ?? null : void 0);
   if (planes.some((p) => p === null)) return emptySurface(4);
   if (planes.every((p) => p === void 0)) return emptySurface(4);
-  const data = toRgba8({
+  const set = {
     width,
     height,
     depth: ctx.file.header.depth,
     mode: ctx.file.header.colorMode,
     color: planes.slice(0, ctx.colorCount),
     alpha: planes[ctx.colorCount],
-    palette: ctx.palette
-  });
-  return surfaceFromPixels({ width, height, data }, 4, rec.rect.left, rec.rect.top);
+    palette: ctx.palette,
+    cmykToRgb: ctx.cmykToRgb
+  };
+  const deep = set.cmykToRgb ? null : toRgbaDeep(set);
+  if (deep) return surfaceFromDeepPixels({ width, height, data: deep }, 4, rec.rect.left, rec.rect.top);
+  return surfaceFromPixels({ width, height, data: toRgba8(set) }, 4, rec.rect.left, rec.rect.top);
 }
 function recordMask(ctx, rec, name) {
   const m = rec.mask;
@@ -10230,16 +10163,24 @@ function mergedLayer(ctx) {
   const plane = (i) => i < header.channels ? planes.subarray(i * size, (i + 1) * size) : void 0;
   const cc = ctx.colorCount;
   const hasAlpha = header.channels > cc && (ctx.file.layers.length === 0 || ctx.file.mergedAlpha);
-  const data = toRgba8({
+  const set = {
     width,
     height,
     depth: header.depth,
     mode: header.colorMode,
     color: Array.from({ length: cc }, (_, i) => plane(i)),
     alpha: hasAlpha ? plane(cc) : void 0,
-    palette: ctx.palette
-  });
-  if (hasAlpha) unmatteWhite(data);
+    palette: ctx.palette,
+    cmykToRgb: ctx.cmykToRgb
+  };
+  const deep = hasAlpha || set.cmykToRgb ? null : toRgbaDeep(set);
+  let surface;
+  if (deep) surface = surfaceFromDeepPixels({ width, height, data: deep }, 4);
+  else {
+    const data = toRgba8(set);
+    if (hasAlpha) unmatteWhite(data);
+    surface = surfaceFromPixels({ width, height, data }, 4);
+  }
   return {
     type: "pixel",
     id: ctx.newId("Background"),
@@ -10247,7 +10188,7 @@ function mergedLayer(ctx) {
     visible: true,
     opacity: 1,
     blend: "normal",
-    surface: surfaceFromPixels({ width, height, data }, 4),
+    surface,
     offset: { x: 0, y: 0 }
   };
 }
@@ -10270,6 +10211,28 @@ function psdToLayers(file, options = {}) {
     depth: options.depth ?? 0,
     dpi: resolution(file) ?? 72
   };
+  let cmykProfile = null;
+  if (header.colorMode === MODE_CMYK && !ctx.skipPixels) {
+    const icc = resource(file, 1039);
+    let src = null;
+    if (icc) {
+      try {
+        const p = parseProfile(icc);
+        if (p.colorSpace === "cmyk") {
+          src = p;
+          cmykProfile = { name: p.description || "Embedded CMYK profile", icc: icc.slice() };
+        } else warn.extra.push(`The CMYK file embeds a ${p.colorSpace.toUpperCase()} profile; the default coated CMYK profile was used.`);
+      } catch (e) {
+        warn.extra.push(`The CMYK profile could not be read (${e instanceof Error ? e.message : String(e)}); the default coated CMYK profile was used.`);
+      }
+    }
+    if (!src) {
+      src = builtinProfile("coated-cmyk");
+      cmykProfile = { builtin: "coated-cmyk", name: src.description };
+    }
+    const t = Transform.create(src, srgbProfile(), { intent: "relative", bpc: true });
+    ctx.cmykToRgb = (ink, out) => t.convert8(ink, 4, out, 4, false);
+  }
   for (const block of file.globalBlocks) {
     if (LINKED_FILE_KEYS.includes(block.key)) {
       for (const f of parseLinkedFiles(block.data)) if (!ctx.linked.has(f.uuid)) ctx.linked.set(f.uuid, f);
@@ -10291,10 +10254,12 @@ function psdToLayers(file, options = {}) {
     }
   }
   const mode = COLOR_MODES[header.colorMode] ?? `mode ${header.colorMode}`;
-  if (mode !== "rgb" || header.depth !== 8) {
-    warn.extra.push(`The file is ${header.depth}-bit ${mode}; it was converted to 8-bit RGB.`);
+  if (mode !== "rgb" && header.depth > 8 && header.colorMode !== MODE_INDEXED && header.colorMode !== MODE_BITMAP) {
+    warn.extra.push(`The file is ${header.depth}-bit ${mode}; it was converted to ${header.depth}-bit RGB.`);
+  } else if (mode !== "rgb" || header.depth !== 8 && header.depth !== 16 && header.depth !== 32) {
+    const how = header.colorMode === MODE_CMYK ? ` through ${cmykProfile?.name ?? "its profile"}` : "";
+    warn.extra.push(`The file is ${header.depth}-bit ${mode}; it was converted to 8-bit RGB${how}.`);
   }
-  if (resource(file, 1039)) warn.extra.push("The embedded ICC profile is ignored; colours are read as sRGB.");
   let layers = [];
   if (file.layers.length) {
     const tree = layerTree(file);
@@ -10327,7 +10292,10 @@ function psdToLayers(file, options = {}) {
     resolution: resolution(file),
     patterns: [...ctx.patterns.values()],
     ...angle !== void 0 || altitude !== void 0 ? { globalLight: { angle: Math.max(-360, Math.min(360, angle ?? 120)), altitude: Math.max(0, Math.min(90, altitude ?? 30)) } } : {},
-    info: { psb: header.psb, depth: header.depth, colorMode: mode, channels: header.channels }
+    info: { psb: header.psb, depth: header.depth, colorMode: mode, channels: header.channels },
+    ...cmykProfile ? { sourceMode: { mode: "cmyk", profile: cmykProfile } } : header.colorMode === MODE_LAB ? { sourceMode: { mode: "lab" } } : {},
+    ...resource(file, 1039) ? { iccProfile: resource(file, 1039).slice() } : {},
+    bitDepth: (header.depth === 16 || header.depth === 32) && header.colorMode !== MODE_INDEXED && header.colorMode !== MODE_BITMAP ? header.depth : 8
   };
 }
 function importPsd(bytes, options = {}) {
@@ -11020,11 +10988,18 @@ function sectionBlock(kind, blendKey) {
   return w.result();
 }
 var toRect = (r) => ({ top: r.y, left: r.x, bottom: r.y + r.height, right: r.x + r.width });
-function rleChannel(id, plane, width, height, psb) {
-  return { id, compression: 1, data: encodeRle(plane, { planes: 1, width, height, depth: 8, psb }) };
+function rleChannel(id, plane, width, height, psb, depth = 8) {
+  const layout = { planes: 1, width, height, depth, psb };
+  if (depth === 32) return { id, compression: 3, data: encodeZipPredicted(plane, layout) };
+  return { id, compression: 1, data: encodeRle(plane, layout) };
+}
+function surfacePlanes(surface, bounds, depth) {
+  const n = bounds.width * bounds.height;
+  if (depth === 8) return rgbaToPlanes(readRegion(surface, bounds), n);
+  return deepToPlanes(readDeepRegion(surface, bounds, depth), n);
 }
 var emptyChannel = (id) => ({ id, compression: 0, data: new Uint8Array(0) });
-function maskChannel(mask, ox, oy, psb) {
+function maskChannel(mask, ox, oy, psb, depth = 8) {
   if (mask.source) throw new PsdError("A parametric mask must be baked before export.");
   const bounds = contentBounds(mask.surface);
   const def = mask.defaultValue;
@@ -11035,7 +11010,8 @@ function maskChannel(mask, ox, oy, psb) {
   if (!bounds) return { channel: emptyChannel(CHANNEL_USER_MASK), mask: m };
   const plane = readRegion(mask.surface, bounds);
   m.rect = toRect({ ...bounds, x: bounds.x + ox, y: bounds.y + oy });
-  return { channel: rleChannel(CHANNEL_USER_MASK, new Uint8Array(plane.buffer, plane.byteOffset, plane.length), bounds.width, bounds.height, psb), mask: m };
+  const bytes = planeAtDepth(new Uint8Array(plane.buffer, plane.byteOffset, plane.length), depth);
+  return { channel: rleChannel(CHANNEL_USER_MASK, bytes, bounds.width, bounds.height, psb, depth), mask: m };
 }
 function lockBits(layer) {
   const l = layer.locks;
@@ -11114,7 +11090,23 @@ function placedUnchanged(layer, idnt, placedId) {
 }
 function exportPsd(input) {
   const { width, height } = input;
+  const depth = input.depth ?? 8;
   if (width < 1 || height < 1) throw new PsdError("The document is empty.");
+  const mode = input.colorMode ?? "rgb";
+  if (mode !== "rgb" && !input.colorPlanes) throw new PsdError(`A ${mode.toUpperCase()} file needs colorPlanes to convert the pixels.`);
+  if (mode !== "rgb" && depth !== 8) throw new PsdError(`${mode.toUpperCase()} files are written at 8 bits per channel.`);
+  const colorIds = mode === "cmyk" ? [0, 1, 2, 3] : [0, 1, 2];
+  const colorPlanes = (rgba, n2) => mode === "rgb" ? rgbaToPlanes(rgba, n2).slice(0, 3) : input.colorPlanes(rgba, n2);
+  const pixelChannels = (rgba, w, h) => {
+    const n2 = w * h;
+    const alpha = rgbaToPlanes(rgba, n2)[3];
+    return [rleChannel(CHANNEL_ALPHA, alpha, w, h, psb), ...colorPlanes(rgba, n2).map((p, i) => rleChannel(i, p, w, h, psb))];
+  };
+  const surfaceChannels = (surface, bounds) => {
+    if (mode !== "rgb") return pixelChannels(readRegion(surface, bounds), bounds.width, bounds.height);
+    const [r, g, b, a2] = surfacePlanes(surface, bounds, depth);
+    return [CHANNEL_ALPHA, 0, 1, 2].map((id, i) => rleChannel(id, [a2, r, g, b][i], bounds.width, bounds.height, psb, depth));
+  };
   const psb = width > PSD_MAX_DIMENSION || height > PSD_MAX_DIMENSION;
   const records = [];
   let nextId = 0;
@@ -11158,7 +11150,7 @@ function exportPsd(input) {
       case "group": {
         records.push({
           rect: EMPTY_RECT,
-          channels: [CHANNEL_ALPHA, 0, 1, 2].map(emptyChannel),
+          channels: [CHANNEL_ALPHA, ...colorIds].map(emptyChannel),
           blendKey: "norm",
           opacity: 255,
           clipping: 0,
@@ -11175,12 +11167,12 @@ function exportPsd(input) {
         const rec = {
           ...base,
           rect: EMPTY_RECT,
-          channels: [CHANNEL_ALPHA, 0, 1, 2].map(emptyChannel),
+          channels: [CHANNEL_ALPHA, ...colorIds].map(emptyChannel),
           blendKey,
           flags: base.flags | FLAG_PIXELS_IRRELEVANT
         };
         if (layer.mask) {
-          const m = maskChannel(layer.mask, 0, 0, psb);
+          const m = maskChannel(layer.mask, 0, 0, psb, depth);
           rec.channels.push(m.channel);
           rec.mask = m.mask;
         }
@@ -11192,11 +11184,11 @@ function exportPsd(input) {
         const rec = {
           ...common2(layer, [{ key: block.key, data: block.data }]),
           rect: EMPTY_RECT,
-          channels: [CHANNEL_ALPHA, 0, 1, 2].map(emptyChannel),
+          channels: [CHANNEL_ALPHA, ...colorIds].map(emptyChannel),
           blendKey: BLEND_TO_PSD[layer.blend] ?? "norm"
         };
         if (layer.mask) {
-          const m = maskChannel(layer.mask, 0, 0, psb);
+          const m = maskChannel(layer.mask, 0, 0, psb, depth);
           rec.channels.push(m.channel);
           rec.mask = m.mask;
         }
@@ -11213,20 +11205,13 @@ function exportPsd(input) {
         const rec = { ...common2(layer, extra), rect: EMPTY_RECT, channels: [], blendKey: BLEND_TO_PSD[layer.blend] ?? "norm" };
         const bounds = contentBounds(layer.surface);
         if (bounds) {
-          const n2 = bounds.width * bounds.height;
-          const [r2, g2, b2, a2] = rgbaToPlanes(readRegion(layer.surface, bounds), n2);
           rec.rect = toRect({ ...bounds, x: bounds.x + layer.offset.x, y: bounds.y + layer.offset.y });
-          rec.channels = [
-            rleChannel(CHANNEL_ALPHA, a2, bounds.width, bounds.height, psb),
-            rleChannel(0, r2, bounds.width, bounds.height, psb),
-            rleChannel(1, g2, bounds.width, bounds.height, psb),
-            rleChannel(2, b2, bounds.width, bounds.height, psb)
-          ];
+          rec.channels = surfaceChannels(layer.surface, bounds);
         } else {
-          rec.channels = [CHANNEL_ALPHA, 0, 1, 2].map(emptyChannel);
+          rec.channels = [CHANNEL_ALPHA, ...colorIds].map(emptyChannel);
         }
         if (layer.mask) {
-          const m = maskChannel(layer.mask, layer.offset.x, layer.offset.y, psb);
+          const m = maskChannel(layer.mask, layer.offset.x, layer.offset.y, psb, depth);
           rec.channels.push(m.channel);
           rec.mask = m.mask;
         }
@@ -11264,20 +11249,13 @@ function exportPsd(input) {
         const rec = { ...common2(layer, extra), rect: EMPTY_RECT, channels: [], blendKey: BLEND_TO_PSD[layer.blend] ?? "norm" };
         const bounds = contentBounds(layer.surface);
         if (bounds) {
-          const n2 = bounds.width * bounds.height;
-          const [r2, g2, b2, a2] = rgbaToPlanes(readRegion(layer.surface, bounds), n2);
           rec.rect = toRect(bounds);
-          rec.channels = [
-            rleChannel(CHANNEL_ALPHA, a2, bounds.width, bounds.height, psb),
-            rleChannel(0, r2, bounds.width, bounds.height, psb),
-            rleChannel(1, g2, bounds.width, bounds.height, psb),
-            rleChannel(2, b2, bounds.width, bounds.height, psb)
-          ];
+          rec.channels = surfaceChannels(layer.surface, bounds);
         } else {
-          rec.channels = [CHANNEL_ALPHA, 0, 1, 2].map(emptyChannel);
+          rec.channels = [CHANNEL_ALPHA, ...colorIds].map(emptyChannel);
         }
         if (layer.mask) {
-          const m = maskChannel(layer.mask, 0, 0, psb);
+          const m = maskChannel(layer.mask, 0, 0, psb, depth);
           rec.channels.push(m.channel);
           rec.mask = m.mask;
         }
@@ -11292,7 +11270,7 @@ function exportPsd(input) {
         }
         if (layer.type === "shape") {
           const losses = /* @__PURE__ */ new Set();
-          for (const b2 of shapeBlocks(layer, width, height, input.resolution ?? 72, losses)) extra.push({ key: b2.key, data: padEven(b2.data) });
+          for (const b of shapeBlocks(layer, width, height, input.resolution ?? 72, losses)) extra.push({ key: b.key, data: padEven(b.data) });
           for (const n2 of losses) note(n2, layer.name);
           if (layer.fill?.type === "pattern") patternIds2.add(layer.fill.patternId);
           if (layer.stroke?.paint.type === "pattern") patternIds2.add(layer.stroke.paint.patternId);
@@ -11302,20 +11280,13 @@ function exportPsd(input) {
         const rec = { ...common2(layer, extra), rect: EMPTY_RECT, channels: [], blendKey: BLEND_TO_PSD[layer.blend] ?? "norm" };
         const bounds = contentBounds(layer.surface);
         if (bounds) {
-          const n2 = bounds.width * bounds.height;
-          const [r2, g2, b2, a2] = rgbaToPlanes(readRegion(layer.surface, bounds), n2);
           rec.rect = toRect(bounds);
-          rec.channels = [
-            rleChannel(CHANNEL_ALPHA, a2, bounds.width, bounds.height, psb),
-            rleChannel(0, r2, bounds.width, bounds.height, psb),
-            rleChannel(1, g2, bounds.width, bounds.height, psb),
-            rleChannel(2, b2, bounds.width, bounds.height, psb)
-          ];
+          rec.channels = surfaceChannels(layer.surface, bounds);
         } else {
-          rec.channels = [CHANNEL_ALPHA, 0, 1, 2].map(emptyChannel);
+          rec.channels = [CHANNEL_ALPHA, ...colorIds].map(emptyChannel);
         }
         if (layer.mask) {
-          const m = maskChannel(layer.mask, 0, 0, psb);
+          const m = maskChannel(layer.mask, 0, 0, psb, depth);
           rec.channels.push(m.channel);
           rec.mask = m.mask;
         }
@@ -11330,11 +11301,18 @@ function exportPsd(input) {
   if (records.length > 32767) throw new PsdError("A PSD holds at most 32767 layer records.");
   const n = width * height;
   if (input.merged.length < n * 4) throw new PsdError(`The merged image has ${input.merged.length} bytes, expected ${n * 4}.`);
-  const [r, g, b, a] = rgbaToPlanes(matteWhite(input.merged), n);
+  const matted = matteWhite(input.merged);
+  const a = rgbaToPlanes(matted, n)[3];
   const transparent = a.some((v) => v !== 255);
-  const planes = transparent ? [r, g, b, a] : [r, g, b];
-  const merged2 = new Uint8Array(n * planes.length);
-  planes.forEach((p, i) => merged2.set(p, i * n));
+  let planes = [...colorPlanes(matted, n), ...transparent ? [a] : []].map((p) => planeAtDepth(p, depth));
+  const deep = input.mergedDeep;
+  if (deep && depth !== 8 && deep.length >= n * 4 && (deep instanceof Uint16Array ? depth === 16 : depth === 32)) {
+    const dp = deepToPlanes(matteWhiteDeep(deep), n);
+    planes = transparent ? dp : dp.slice(0, 3);
+  }
+  const planeBytes = n * (depth >> 3);
+  const merged2 = new Uint8Array(planeBytes * planes.length);
+  planes.forEach((p, i) => merged2.set(p, i * planeBytes));
   const res = Math.max(1, input.resolution ?? 72);
   const rw = new PsdWriter();
   for (let k = 0; k < 2; k++) {
@@ -11352,6 +11330,7 @@ function exportPsd(input) {
     { id: 1005, name: "", data: rw.result() },
     { id: 1057, name: "", data: version.result() }
   ];
+  if (input.iccProfile?.length) resources.push({ id: 1039, name: "", data: input.iccProfile });
   if (input.globalLight) {
     const i32 = (v) => {
       const w = new PsdWriter();
@@ -11384,14 +11363,14 @@ function exportPsd(input) {
   if (filterItems.length) globalBlocks.push({ key: "FEid", data: writeFilterEffects(filterItems) });
   const bytes = writePsd(
     {
-      header: { psb, channels: planes.length, width, height, depth: 8, colorMode: 3 },
+      header: { psb, channels: planes.length, width, height, depth, colorMode: mode === "cmyk" ? 4 : mode === "lab" ? 9 : 3 },
       colorModeData: new Uint8Array(0),
       resources,
       layers: records,
       mergedAlpha: transparent && records.length > 0,
       globalBlocks,
-      imageCompression: 1,
-      imageData: encodeRle(merged2, { planes: planes.length, width, height, depth: 8, psb })
+      imageCompression: depth === 32 ? 0 : 1,
+      imageData: depth === 32 ? merged2 : encodeRle(merged2, { planes: planes.length, width, height, depth, psb })
     },
     encodeLegacyName
   );
@@ -11527,6 +11506,7 @@ export {
   activeAdjustmentLayers,
   evaluateAdjustmentLayers,
   applyAdjustmentLayers,
+  applyAdjustmentLayersFloat,
   adjustmentLayersKey,
   applyAdjustments,
   applyLegacyAdjustments,
@@ -11534,9 +11514,9 @@ export {
   applyBoxBlur,
   applyDepthMask,
   removeAlpha,
+  TEXT_ALIGNS,
   SHAPE_OPERATIONS,
   LIVE_SHAPE_KINDS,
-  TEXT_ALIGNS,
   newLayerId,
   pixelLayers,
   developFilter,
@@ -11553,6 +11533,7 @@ export {
   depthMaskAlpha,
   runLayerFilters,
   LayerCompositor,
+  compositeDeep,
   DEFAULT_ADJUSTMENTS_VALUES,
   DEFAULT_TRANSFORM_VALUES,
   DEFAULT_DEPTH_MASK_VALUES,
@@ -11612,18 +11593,6 @@ export {
   shapeFromAnnotation,
   annotationBlend,
   annotationOfShape,
-  DEFAULT_TEXT_STYLE,
-  DEFAULT_AUTO_LEADING,
-  fitRuns,
-  styleAt,
-  restyleRange,
-  spliceRuns,
-  paragraphRanges,
-  fitParagraphRuns,
-  fontOf,
-  layoutText,
-  textIndexAt,
-  caretAt,
   TEXT_RENDER_MARGIN,
   textMatrix,
   textOutlines,
@@ -11725,6 +11694,8 @@ export {
   serializePatterns,
   deserializePatterns,
   encodeSurface,
+  encodeDeepSurface,
+  decodeDeepSurface,
   serializeEffects,
   deserializeEffects,
   serializeLayer,
@@ -11764,4 +11735,4 @@ export {
   smartContentsFile,
   exportPsd
 };
-//# sourceMappingURL=chunk-CZOXTEMN.js.map
+//# sourceMappingURL=chunk-XICA4PVO.js.map