@pixerate/editor 0.103.0 → 0.105.0

package/dist/{chunk-NQLQ2JOI.js → chunk-4X5MIVCE.js}

@@ -16,6 +16,7 @@ import {
   effectsFingerprint,
   effectsMargin,
   effectsScale,
+  encodePng,
   findLayer,
   flattenLayers,
   gaussianBlur,
@@ -60,8 +61,10 @@ import {
   translateSurface
 } from "./chunk-HEW6KDNI.js";
 import {
+  WARP_STYLES,
   applyMatrix,
   evalWarpMesh,
+  fitWarpMesh,
   identityWarpMesh,
   invertMatrix,
   isValidWarpMesh,
@@ -855,21 +858,21 @@ function toBase64(bytes, length) {
   parts.push(chunk);
   return parts.join("");
 }
-function fromBase64(text2) {
-  if (text2.length % 4 !== 0) throw new Error("Invalid base64 length");
+function fromBase64(text3) {
+  if (text3.length % 4 !== 0) throw new Error("Invalid base64 length");
   let pad = 0;
-  if (text2.endsWith("==")) pad = 2;
-  else if (text2.endsWith("=")) pad = 1;
-  const out = new Uint8Array(text2.length / 4 * 3 - pad);
+  if (text3.endsWith("==")) pad = 2;
+  else if (text3.endsWith("=")) pad = 1;
+  const out = new Uint8Array(text3.length / 4 * 3 - pad);
   let o = 0;
   const digit = (i, k) => {
-    const ch = text2.charCodeAt(i + k);
-    if (ch === 61 && i + 4 === text2.length && k >= 4 - pad) return 0;
+    const ch = text3.charCodeAt(i + k);
+    if (ch === 61 && i + 4 === text3.length && k >= 4 - pad) return 0;
     const idx = ch < 128 ? B64_INDEX[ch] : -1;
     if (idx < 0) throw new Error("Invalid base64 character");
     return idx;
   };
-  for (let i = 0; i < text2.length; i += 4) {
+  for (let i = 0; i < text3.length; i += 4) {
     const n = digit(i, 0) << 18 | digit(i, 1) << 12 | digit(i, 2) << 6 | digit(i, 3);
     if (o < out.length) out[o++] = n >> 16 & 255;
     if (o < out.length) out[o++] = n >> 8 & 255;
@@ -4030,8 +4033,8 @@ var PsdReader = class _PsdReader {
     return v;
   }
   /** A length field: 8 bytes in PSB where the format says so, else 4. */
-  len(long3) {
-    return long3 ? this.u64() : this.u32();
+  len(long4) {
+    return long4 ? this.u64() : this.u32();
   }
   bytes(n) {
     this.need(n, `${n} bytes`);
@@ -4138,11 +4141,11 @@ var PsdWriter = class {
     this.length += n;
   }
   /** Reserves a length field; `endLen` fills it with the bytes written since. */
-  beginLen(long3) {
+  beginLen(long4) {
     const at = this.length;
-    if (long3) this.u64(0);
+    if (long4) this.u64(0);
     else this.u32(0);
-    return { at, long: long3 };
+    return { at, long: long4 };
   }
   endLen(mark) {
     const n = this.length - mark.at - (mark.long ? 8 : 4);
@@ -4187,6 +4190,162 @@ function encodeLegacyName(s) {
   return Uint8Array.from(out);
 }
 
+// src/image-editor/psd/compression.ts
+var MAX_DECODED_BYTES = 2 ** 31;
+function rowBytes(width, depth) {
+  return depth === 1 ? Math.ceil(width / 8) : width * Math.max(1, depth >> 3);
+}
+function decodedLength(l) {
+  const total = l.planes * l.height * rowBytes(l.width, l.depth);
+  if (total > MAX_DECODED_BYTES) throw new PsdError(`Decoded channel data of ${total} bytes is larger than the ${MAX_DECODED_BYTES}-byte limit.`);
+  return total;
+}
+function packbitsBound(n) {
+  return n + Math.ceil(n / 128);
+}
+function packbitsEncode(src, out, at) {
+  const n = src.length;
+  let i = 0;
+  while (i < n) {
+    let run = 1;
+    while (i + run < n && run < 128 && src[i + run] === src[i]) run++;
+    if (run >= 2) {
+      out[at++] = 257 - run & 255;
+      out[at++] = src[i];
+      i += run;
+      continue;
+    }
+    const start = i;
+    let len = 0;
+    while (i < n && len < 128) {
+      if (i + 2 < n && src[i] === src[i + 1] && src[i] === src[i + 2]) break;
+      i++;
+      len++;
+    }
+    out[at++] = len - 1;
+    out.set(src.subarray(start, start + len), at);
+    at += len;
+  }
+  return at;
+}
+function packbitsDecodeInto(src, expected, out, at) {
+  const target = at + expected;
+  let i = 0;
+  while (at < target) {
+    if (i >= src.length) throw new PsdError("PackBits row ended early.");
+    const h = src[i++];
+    if (h < 128) {
+      const len = h + 1;
+      if (i + len > src.length) throw new PsdError("PackBits literal is truncated.");
+      if (at + len > target) throw new PsdError("PackBits literal overflows its row.");
+      out.set(src.subarray(i, i + len), at);
+      at += len;
+      i += len;
+    } else if (h !== 128) {
+      const len = 257 - h;
+      if (i >= src.length) throw new PsdError("PackBits run is truncated.");
+      const b = src[i++];
+      if (at + len > target) throw new PsdError("PackBits run overflows its row.");
+      out.fill(b, at, at + len);
+      at += len;
+    }
+  }
+  return at;
+}
+function inflateChecked(data, expected) {
+  let out;
+  try {
+    out = inflate(data, { maxOutput: expected + (1 << 20), sizeHint: expected, verify: false });
+  } catch (e) {
+    throw new PsdError(`ZIP channel data: ${e instanceof ZlibError || e instanceof Error ? e.message : String(e)}`);
+  }
+  if (out.length < expected) throw new PsdError(`ZIP stream produced ${out.length} of ${expected} bytes.`);
+  return out.length === expected ? out : out.subarray(0, expected);
+}
+function unpredict(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 = 1; i < rb; i++) buf[o + i] = buf[o + i] + buf[o + i - 1] & 255;
+    } else if (l.depth === 16) {
+      for (let i = 1; i < w; 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) {
+      for (let i = 1; i < rb; i++) buf[o + i] = buf[o + i] + buf[o + i - 1] & 255;
+      scratch.set(buf.subarray(o, o + rb));
+      for (let i = 0; i < w; i++) for (let k = 0; k < 4; k++) buf[o + 4 * i + k] = scratch[k * w + i];
+    } else {
+      throw new PsdError(`ZIP prediction is not defined for depth ${l.depth}.`);
+    }
+  }
+}
+function decodeRle(r, l, total) {
+  const rows = l.planes * l.height;
+  const rb = rowBytes(l.width, l.depth);
+  r.checkCount(rows, l.psb ? 4 : 2, "RLE row counts");
+  const counts = new Array(rows);
+  for (let i = 0; i < rows; i++) counts[i] = l.psb ? r.u32() : r.u16();
+  if (total > r.remaining * 130) throw new PsdError("RLE data is too short for its declared size.");
+  const out = new Uint8Array(total);
+  let at = 0;
+  for (const c of counts) at = packbitsDecodeInto(r.bytes(c), rb, out, at);
+  return out;
+}
+function decodePlanes(compression, data, l) {
+  const total = decodedLength(l);
+  switch (compression) {
+    case 0:
+      if (data.length < total) throw new PsdError(`Raw channel data has ${data.length} of ${total} bytes.`);
+      return data.slice(0, total);
+    case 1:
+      return decodeRle(new PsdReader(data), l, total);
+    case 2:
+      return inflateChecked(data, total).slice();
+    case 3: {
+      const v = inflateChecked(data, total).slice();
+      unpredict(v, l);
+      return v;
+    }
+    default:
+      throw new PsdError(`Unsupported compression method ${compression}.`);
+  }
+}
+function encodeRle(decoded2, l) {
+  const rows = l.planes * l.height;
+  const rb = rowBytes(l.width, l.depth);
+  const cs = l.psb ? 4 : 2;
+  const packed = new Uint8Array(rows * packbitsBound(rb));
+  let at = 0;
+  const counts = new Uint8Array(rows * cs);
+  for (let row = 0; row < rows; row++) {
+    const start = at;
+    at = packbitsEncode(decoded2.subarray(row * rb, (row + 1) * rb), packed, at);
+    const n = at - start;
+    if (cs === 2) {
+      if (n > 65535) throw new PsdError("An RLE row is longer than 65535 bytes; write a PSB instead.");
+      counts[row * 2] = n >> 8;
+      counts[row * 2 + 1] = n & 255;
+    } else {
+      counts[row * 4] = n >>> 24;
+      counts[row * 4 + 1] = n >>> 16 & 255;
+      counts[row * 4 + 2] = n >>> 8 & 255;
+      counts[row * 4 + 3] = n & 255;
+    }
+  }
+  const out = new Uint8Array(counts.length + at);
+  out.set(counts);
+  out.set(packed.subarray(0, at), counts.length);
+  return out;
+}
+
 // src/image-editor/psd/descriptor.ts
 var MAX_DEPTH = 64;
 var STRING_IDS = /* @__PURE__ */ new Set(["warp", "list", "time"]);
@@ -4302,12 +4461,12 @@ function readValue(r, depth) {
     case "UntF":
       return { type, unit: r.ascii(4), value: r.f64() };
     case "UnFl": {
-      const unit2 = r.ascii(4);
+      const unit3 = r.ascii(4);
       const n = r.u32();
       r.checkCount(n, 8, "Unit float list");
       const values = [];
       for (let i = 0; i < n; i++) values.push(r.f64());
-      return { type, unit: unit2, values };
+      return { type, unit: unit3, values };
     }
     case "TEXT":
       return { type, value: r.unicode() };
@@ -4760,11 +4919,11 @@ function writeAdjustmentBlock(kind, params) {
     case "blackWhite": {
       const p = params;
       const tint = p.tint ? hexToRgb(p.tint) : BW_TINT;
-      const dbl2 = (v) => ({ type: "doub", value: clamp2(v, 0, 1) * 255 });
+      const dbl3 = (v) => ({ type: "doub", value: clamp2(v, 0, 1) * 255 });
       const items = BW_KEYS.map(([field, key]) => [key, long(clamp2(p[field], -200, 300))]);
       items.push(
         ["useTint", { type: "bool", value: p.tint !== null }],
-        ["tintColor", { type: "Objc", value: descriptor("RGBC", [["Rd  ", dbl2(tint[0])], ["Grn ", dbl2(tint[1])], ["Bl  ", dbl2(tint[2])]]) }],
+        ["tintColor", { type: "Objc", value: descriptor("RGBC", [["Rd  ", dbl3(tint[0])], ["Grn ", dbl3(tint[1])], ["Bl  ", dbl3(tint[2])]]) }],
         ["bwPresetKind", { type: "long", value: 1 }],
         ["blackAndWhitePresetFileName", { type: "TEXT", value: "" }]
       );
@@ -4786,161 +4945,562 @@ function writeAdjustmentBlock(kind, params) {
   throw new Error(`Unknown adjustment kind "${kind}".`);
 }
 
-// src/image-editor/psd/compression.ts
-var MAX_DECODED_BYTES = 2 ** 31;
-function rowBytes(width, depth) {
-  return depth === 1 ? Math.ceil(width / 8) : width * Math.max(1, depth >> 3);
-}
-function decodedLength(l) {
-  const total = l.planes * l.height * rowBytes(l.width, l.depth);
-  if (total > MAX_DECODED_BYTES) throw new PsdError(`Decoded channel data of ${total} bytes is larger than the ${MAX_DECODED_BYTES}-byte limit.`);
-  return total;
-}
-function packbitsBound(n) {
-  return n + Math.ceil(n / 128);
-}
-function packbitsEncode(src, out, at) {
-  const n = src.length;
-  let i = 0;
-  while (i < n) {
-    let run = 1;
-    while (i + run < n && run < 128 && src[i + run] === src[i]) run++;
-    if (run >= 2) {
-      out[at++] = 257 - run & 255;
-      out[at++] = src[i];
-      i += run;
-      continue;
-    }
-    const start = i;
-    let len = 0;
-    while (i < n && len < 128) {
-      if (i + 2 < n && src[i] === src[i + 1] && src[i] === src[i + 2]) break;
-      i++;
-      len++;
+// src/image-editor/psd/smart.ts
+var dbl = (value) => ({ type: "doub", value });
+var unit = (u, value) => ({ type: "UntF", unit: u, value });
+var long2 = (value) => ({ type: "long", value: Math.round(value) });
+var boolV = (value) => ({ type: "bool", value });
+var enumV = (typeId, value) => ({ type: "enum", typeId, value });
+var textV = (value) => ({ type: "TEXT", value });
+var obj = (d) => ({ type: "Objc", value: d });
+var text = (d, key) => {
+  const v = descGet(d, key);
+  return v?.type === "TEXT" ? v.value : void 0;
+};
+var enumOf = (d, key) => {
+  const v = descGet(d, key);
+  return v?.type === "enum" ? v.value : void 0;
+};
+var numbers = (d, key) => {
+  const v = descGet(d, key);
+  if (v?.type !== "VlLs") return null;
+  const out = [];
+  for (const it of v.items) {
+    if (it.type === "doub" || it.type === "UntF" || it.type === "long") out.push(it.value);
+    else return null;
+  }
+  return out;
+};
+function setItem(d, key, v) {
+  const i = d.items.findIndex(([k]) => k === key);
+  if (i >= 0) d.items[i] = [key, v];
+  else d.items.push([key, v]);
+}
+function cloneDescriptor(d) {
+  return parseVersionedDescriptor(versionedDescriptorBytes(d));
+}
+function psdUuid(seed) {
+  if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(seed)) return seed;
+  let hex = "";
+  for (let k = 0; k < 4; k++) {
+    let h = (2166136261 ^ k * 2654435769) >>> 0;
+    for (let i = 0; i < seed.length; i++) h = Math.imul(h ^ seed.charCodeAt(i), 16777619) >>> 0;
+    hex += h.toString(16).padStart(8, "0");
+  }
+  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}
+var LINKED_FILE_KEYS = ["lnk2", "lnk3", "lnkD", "lnkE"];
+function readLinkedItem(item) {
+  const r = new PsdReader(item);
+  const kind = r.ascii(4);
+  const version = r.u32();
+  const n = r.u8();
+  const uuid = new TextDecoder().decode(r.bytes(n));
+  const name = r.unicode();
+  const fileType = r.ascii(4);
+  r.skip(4);
+  const len = r.u64();
+  if (r.u8() !== 0) readVersionedDescriptor(r);
+  if (kind === "liFD") return { kind, uuid, name, fileType, bytes: r.bytes(Math.min(len, r.remaining)) };
+  let path;
+  if (kind === "liFE") {
+    try {
+      const d = readVersionedDescriptor(r);
+      path = text(d, "fullPath") ?? text(d, "originalPath") ?? text(d, "relPath");
+    } catch {
+      path = void 0;
     }
-    out[at++] = len - 1;
-    out.set(src.subarray(start, start + len), at);
-    at += len;
+    void version;
   }
-  return at;
+  return { kind, uuid, name, fileType, bytes: new Uint8Array(0), path: path ?? name };
 }
-function packbitsDecodeInto(src, expected, out, at) {
-  const target = at + expected;
-  let i = 0;
-  while (at < target) {
-    if (i >= src.length) throw new PsdError("PackBits row ended early.");
-    const h = src[i++];
-    if (h < 128) {
-      const len = h + 1;
-      if (i + len > src.length) throw new PsdError("PackBits literal is truncated.");
-      if (at + len > target) throw new PsdError("PackBits literal overflows its row.");
-      out.set(src.subarray(i, i + len), at);
-      at += len;
-      i += len;
-    } else if (h !== 128) {
-      const len = 257 - h;
-      if (i >= src.length) throw new PsdError("PackBits run is truncated.");
-      const b = src[i++];
-      if (at + len > target) throw new PsdError("PackBits run overflows its row.");
-      out.fill(b, at, at + len);
-      at += len;
+function parseLinkedFiles(data) {
+  const out = [];
+  let at = 0;
+  while (at + 8 <= data.length) {
+    const r = new PsdReader(data, at);
+    const len = r.u64();
+    if (!(len > 0) || at + 8 + len > data.length) break;
+    try {
+      const item = readLinkedItem(data.subarray(at + 8, at + 8 + len));
+      if (item) out.push(item);
+    } catch {
     }
+    at = at + 8 + len + 3 & ~3;
   }
-  return at;
+  return out;
 }
-function inflateChecked(data, expected) {
-  let out;
-  try {
-    out = inflate(data, { maxOutput: expected + (1 << 20), sizeHint: expected, verify: false });
-  } catch (e) {
-    throw new PsdError(`ZIP channel data: ${e instanceof ZlibError || e instanceof Error ? e.message : String(e)}`);
-  }
-  if (out.length < expected) throw new PsdError(`ZIP stream produced ${out.length} of ${expected} bytes.`);
-  return out.length === expected ? out : out.subarray(0, expected);
+function fileTypeOf(bytes) {
+  const b = bytes;
+  if (b[0] === 56 && b[1] === 66 && b[2] === 80 && b[3] === 83) return b[5] === 2 ? { code: "8BPB", ext: "psb" } : { code: "8BPS", ext: "psd" };
+  if (b[0] === 137 && b[1] === 80 && b[2] === 78 && b[3] === 71) return { code: "PNGf", ext: "png" };
+  if (b[0] === 255 && b[1] === 216) return { code: "JPEG", ext: "jpg" };
+  if (b[0] === 73 && b[1] === 73 || b[0] === 77 && b[1] === 77) return { code: "TIFF", ext: "tif" };
+  if (b[0] === 71 && b[1] === 73 && b[2] === 70) return { code: "GIFf", ext: "gif" };
+  if (b[0] === 37 && b[1] === 80 && b[2] === 68 && b[3] === 70) return { code: "PDF ", ext: "pdf" };
+  const head = new TextDecoder().decode(b.subarray(0, 256)).trimStart();
+  if (head.startsWith("<?xml") || head.startsWith("<svg")) return { code: "SVG ", ext: "svg" };
+  return { code: "    ", ext: "bin" };
+}
+function encodeLinkedFile(f) {
+  const w = new PsdWriter();
+  w.ascii("liFD");
+  w.u32(7);
+  const id = new TextEncoder().encode(f.uuid).subarray(0, 255);
+  w.u8(id.length);
+  w.bytes(id);
+  w.unicode(f.name, true);
+  w.ascii(fileTypeOf(f.bytes).code);
+  w.ascii("8BIM");
+  w.u64(f.bytes.length);
+  w.u8(0);
+  w.bytes(f.bytes);
+  w.u32(0);
+  w.f64(0);
+  w.u8(0);
+  const item = w.result();
+  const out = new PsdWriter();
+  out.u64(item.length);
+  out.bytes(item);
+  out.zeros((4 - out.length % 4) % 4);
+  return out.result();
 }
-function unpredict(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 = 1; i < rb; i++) buf[o + i] = buf[o + i] + buf[o + i - 1] & 255;
-    } else if (l.depth === 16) {
-      for (let i = 1; i < w; 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;
+var FILTER_EFFECTS_KEYS = ["FEid", "FXid"];
+var readRect = (r) => ({ top: r.i32(), left: r.i32(), bottom: r.i32(), right: r.i32() });
+function readPlane(r) {
+  const len = r.u64();
+  if (len < 2) throw new PsdError("Filter effects: a plane is shorter than its compression field.");
+  const s = r.sub(len);
+  return { compression: s.u16(), data: s.rest() };
+}
+function parseFilterEffects(data) {
+  const r = new PsdReader(data);
+  const version = r.u32();
+  if (version < 1 || version > 3) throw new PsdError(`Filter effects version ${version}.`);
+  const items = [];
+  while (r.remaining >= 8) {
+    const len = r.u64();
+    const body = r.sub(len);
+    while (body.remaining > 0) {
+      const id = new TextDecoder().decode(body.pascal(1));
+      const itemVersion = body.u32();
+      const it = body.sub(body.u64());
+      const rect = readRect(it);
+      const depth = it.u32();
+      const maxChannels = it.u32();
+      if (maxChannels > 64) throw new PsdError("Filter effects: too many channels.");
+      const slots = [];
+      for (let i = 0; i < maxChannels + 2; i++) slots.push(it.u32() !== 0 ? readPlane(it) : null);
+      let mask = null;
+      if (body.remaining > 0 && body.u8() !== 0) mask = { rect: readRect(body), plane: readPlane(body) };
+      items.push({ id, version: itemVersion, rect, depth, maxChannels, slots, mask });
+    }
+    const pad = (4 - len % 4) % 4;
+    r.skip(Math.min(pad, r.remaining));
+    if (r.remaining < 8) break;
+  }
+  return { version, items };
+}
+function writeFilterEffects(items, version = 3) {
+  const w = new PsdWriter();
+  w.u32(version);
+  const plane = (b, p) => {
+    b.u64(p.data.length + 2);
+    b.u16(p.compression);
+    b.bytes(p.data);
+  };
+  const rect = (b, r) => {
+    b.i32(r.top);
+    b.i32(r.left);
+    b.i32(r.bottom);
+    b.i32(r.right);
+  };
+  for (const it of items) {
+    const b = new PsdWriter();
+    b.pascal(new TextEncoder().encode(it.id), 1);
+    b.u32(it.version);
+    const mark = b.beginLen(true);
+    rect(b, it.rect);
+    b.u32(it.depth);
+    b.u32(it.maxChannels);
+    for (let i = 0; i < it.maxChannels + 2; i++) {
+      const p = it.slots[i];
+      if (p) {
+        b.u32(1);
+        plane(b, p);
+      } else b.u32(0);
+    }
+    b.endLen(mark);
+    if (it.mask) {
+      b.u8(1);
+      rect(b, it.mask.rect);
+      plane(b, it.mask.plane);
+    } else b.u8(0);
+    const body = b.result();
+    w.u64(body.length);
+    w.bytes(body);
+    w.zeros((4 - w.length % 4) % 4);
+  }
+  if (!items.length) w.u64(0);
+  return w.result();
+}
+function filterMaskFromItem(item) {
+  if (!item.mask || item.depth !== 8) return null;
+  const { rect, plane } = item.mask;
+  const width = rect.right - rect.left;
+  const height = rect.bottom - rect.top;
+  if (!(width > 0 && height > 0) || width * height > 1 << 28) return null;
+  const bytes = decodePlanes(plane.compression, plane.data, { planes: 1, width, height, depth: 8, psb: true });
+  const surface = surfaceFromPixels({ width, height, data: bytes }, 1, rect.left, rect.top, 255);
+  return { surface, defaultValue: 255 };
+}
+function filterMaskItem(placed, mask, area) {
+  const painted = contentBounds(mask.surface);
+  let b = painted ?? { x: 0, y: 0, width: 1, height: 1 };
+  if (mask.defaultValue !== 255 && area) {
+    const x0 = Math.min(area.x, painted?.x ?? area.x);
+    const y0 = Math.min(area.y, painted?.y ?? area.y);
+    const x1 = Math.max(area.x + area.width, painted ? painted.x + painted.width : 0);
+    const y1 = Math.max(area.y + area.height, painted ? painted.y + painted.height : 0);
+    b = { x: x0, y: y0, width: x1 - x0, height: y1 - y0 };
+  }
+  const rect = { top: b.y, left: b.x, bottom: b.y + b.height, right: b.x + b.width };
+  const values = readRegion(mask.surface, b);
+  const plane = new Uint8Array(values.buffer, values.byteOffset, values.length);
+  return {
+    id: placed,
+    version: 1,
+    rect,
+    depth: 8,
+    maxChannels: 24,
+    slots: Array.from({ length: 26 }, () => null),
+    mask: { rect, plane: { compression: 1, data: encodeRle(plane, { planes: 1, width: b.width, height: b.height, depth: 8, psb: true }) } }
+  };
+}
+var warpStyleOf = (name) => {
+  if (!name.startsWith("warp")) return null;
+  const s = name[4]?.toLowerCase() + name.slice(5);
+  return WARP_STYLES.includes(s) ? s : null;
+};
+function warpFromDescriptor(w, contents) {
+  const full = { x: 0, y: 0, width: contents.width, height: contents.height };
+  const styleName = enumOf(w, "warpStyle");
+  if (!styleName) return void 0;
+  if (styleName === "warpNone") return { mesh: null, frame: full };
+  const bd = descObject(w, "bounds");
+  if (!bd) return void 0;
+  const left = descNumber(bd, "Left") ?? 0;
+  const top = descNumber(bd, "Top ") ?? 0;
+  const bounds = { x: left, y: top, width: (descNumber(bd, "Rght") ?? 0) - left, height: (descNumber(bd, "Btom") ?? 0) - top };
+  if (!(bounds.width > 0 && bounds.height > 0)) return void 0;
+  let mesh;
+  let frame = full;
+  if (styleName === "warpCustom") {
+    const env = descObject(w, "customEnvelopeWarp");
+    const arr = env ? descGet(env, "meshPoints") : void 0;
+    if (!arr || arr.type !== "ObAr") return void 0;
+    const xs = descGet(arr.body, "Hrzn");
+    const ys = descGet(arr.body, "Vrtc");
+    if (xs?.type !== "UnFl" || ys?.type !== "UnFl" || xs.values.length !== 16 || ys.values.length !== 16) return void 0;
+    mesh = { us: [0, 1], vs: [0, 1], points: xs.values.map((x, i) => ({ x, y: ys.values[i] })) };
+    const px = mesh.points.map((p) => p.x);
+    const py = mesh.points.map((p) => p.y);
+    const f = { x: Math.min(...px), y: Math.min(...py), width: Math.max(...px) - Math.min(...px), height: Math.max(...py) - Math.min(...py) };
+    if (f.width > 1e-9 && f.height > 1e-9 && [f.x, f.y, f.width, f.height].every(Number.isFinite)) frame = f;
+  } else {
+    const style = warpStyleOf(styleName);
+    if (!style) return void 0;
+    mesh = warpPresetMesh(
+      {
+        style,
+        bend: descNumber(w, "warpValue") ?? 0,
+        horizontal: descNumber(w, "warpPerspective") ?? 0,
+        vertical: descNumber(w, "warpPerspectiveOther") ?? 0,
+        orientation: enumOf(w, "warpRotate") === "Vrtc" ? "vertical" : "horizontal"
+      },
+      bounds
+    );
+    if (!mesh) return { mesh: null, frame: full };
+  }
+  const same = Math.abs(bounds.x) < 1e-6 && Math.abs(bounds.y) < 1e-6 && Math.abs(bounds.width - contents.width) < 1e-6 && Math.abs(bounds.height - contents.height) < 1e-6;
+  if (!same) {
+    const m = mesh;
+    mesh = fitWarpMesh((s, t) => evalWarpMesh(m, (s * contents.width - bounds.x) / bounds.width, (t * contents.height - bounds.y) / bounds.height), [0, 1], [0, 1]);
+  }
+  return { mesh, frame };
+}
+function warpDescriptor(mesh, contents) {
+  const full = { x: 0, y: 0, width: contents.width, height: contents.height };
+  const single = mesh && mesh.us.length === 2 && mesh.vs.length === 2 && mesh.points.length === 16;
+  const bounds = descriptor("classFloatRect", [
+    ["Top ", dbl(0)],
+    ["Left", dbl(0)],
+    ["Btom", dbl(contents.height)],
+    ["Rght", dbl(contents.width)]
+  ]);
+  const items = [
+    ["warpStyle", enumV("warpStyle", single ? "warpCustom" : "warpNone")],
+    ["warpValue", dbl(0)],
+    ["warpPerspective", dbl(0)],
+    ["warpPerspectiveOther", dbl(0)],
+    ["warpRotate", enumV("Ornt", "Hrzn")],
+    ["bounds", obj(bounds)],
+    ["uOrder", long2(4)],
+    ["vOrder", long2(4)]
+  ];
+  let frame = full;
+  if (single) {
+    const body = descriptor("rationalPoint", [
+      ["Hrzn", { type: "UnFl", unit: "#Pxl", values: mesh.points.map((p) => p.x) }],
+      ["Vrtc", { type: "UnFl", unit: "#Pxl", values: mesh.points.map((p) => p.y) }]
+    ]);
+    items.push(["customEnvelopeWarp", obj(descriptor("customEnvelopeWarp", [["meshPoints", { type: "ObAr", prefix: 16, body }]]))]);
+    const px = mesh.points.map((p) => p.x);
+    const py = mesh.points.map((p) => p.y);
+    frame = { x: Math.min(...px), y: Math.min(...py), width: Math.max(...px) - Math.min(...px), height: Math.max(...py) - Math.min(...py) };
+  }
+  return { warp: descriptor("warp", items), frame, dropped: Boolean(mesh && !single) };
+}
+var isParallelogram = (q2) => {
+  const tol = 1e-6 * (1 + Math.max(...q2.flatMap((p) => [Math.abs(p.x), Math.abs(p.y)])));
+  return Math.abs(q2[0].x + q2[2].x - q2[1].x - q2[3].x) <= tol && Math.abs(q2[0].y + q2[2].y - q2[1].y - q2[3].y) <= tol;
+};
+var toQuad = (p) => [
+  { x: p[0], y: p[1] },
+  { x: p[2], y: p[3] },
+  { x: p[4], y: p[5] },
+  { x: p[6], y: p[7] }
+];
+function cornersFromQuad(quad, frame, contents) {
+  if (quad.length !== 8 || !quad.every(Number.isFinite)) return null;
+  const q2 = toQuad(quad);
+  const h = rectToQuad(frame, q2);
+  if (!h) return null;
+  const out = boxQuad({ x: 0, y: 0, width: contents.width, height: contents.height }).map((p) => applyHomography(h, p));
+  return out.every(Boolean) ? out : null;
+}
+function quadFromCorners(corners, frame, contents) {
+  const h = rectToQuad({ x: 0, y: 0, width: contents.width, height: contents.height }, corners);
+  const pts = boxQuad(frame).map((p) => (h ? applyHomography(h, p) : p) ?? p);
+  return pts.flatMap((p) => [p.x, p.y]);
+}
+var PLACED_KEYS = ["SoLd", "SoLE", "PlLd"];
+function parsePlaced(key, data) {
+  try {
+    if (key === "SoLd" || key === "SoLE") {
+      const r = new PsdReader(data);
+      if (r.ascii(4) !== "soLD") return null;
+      r.u32();
+      const d = readVersionedDescriptor(r);
+      const quad = numbers(d, "nonAffineTransform") ?? numbers(d, "Trnf") ?? [];
+      const affine = numbers(d, "Trnf");
+      const sz = descObject(d, "Sz  ");
+      const size = sz ? { width: descNumber(sz, "Wdth") ?? 0, height: descNumber(sz, "Hght") ?? 0 } : void 0;
+      const use = affine && affine.length === 8 && isParallelogram(toQuad(affine)) && quad.length === 8 && !isParallelogram(toQuad(quad)) ? quad : affine ?? quad;
+      return {
+        key,
+        descriptor: d,
+        idnt: text(d, "Idnt") ?? "",
+        placed: text(d, "placed") ?? "",
+        quad: use,
+        size: size && size.width > 0 && size.height > 0 ? size : void 0,
+        warp: descObject(d, "warp"),
+        filterFX: descObject(d, "filterFX")
+      };
+    }
+    if (key === "PlLd") {
+      const r = new PsdReader(data);
+      if (r.ascii(4) !== "plcL") return null;
+      r.u32();
+      const n = r.u8();
+      const idnt = new TextDecoder().decode(r.bytes(n));
+      r.skip(16);
+      const quad = [];
+      for (let i = 0; i < 8; i++) quad.push(r.f64());
+      let warp;
+      if (r.remaining > 8 && r.peek(r.remaining).some((b) => b !== 0)) {
+        r.u32();
+        try {
+          warp = readVersionedDescriptor(r);
+        } catch {
+          warp = void 0;
+        }
       }
-    } else if (l.depth === 32) {
-      for (let i = 1; i < rb; i++) buf[o + i] = buf[o + i] + buf[o + i - 1] & 255;
-      scratch.set(buf.subarray(o, o + rb));
-      for (let i = 0; i < w; i++) for (let k = 0; k < 4; k++) buf[o + 4 * i + k] = scratch[k * w + i];
-    } else {
-      throw new PsdError(`ZIP prediction is not defined for depth ${l.depth}.`);
+      return { key, idnt, placed: idnt, quad, warp };
     }
+  } catch {
+    return null;
   }
+  return null;
 }
-function decodeRle(r, l, total) {
-  const rows = l.planes * l.height;
-  const rb = rowBytes(l.width, l.depth);
-  r.checkCount(rows, l.psb ? 4 : 2, "RLE row counts");
-  const counts = new Array(rows);
-  for (let i = 0; i < rows; i++) counts[i] = l.psb ? r.u32() : r.u16();
-  if (total > r.remaining * 130) throw new PsdError("RLE data is too short for its declared size.");
-  const out = new Uint8Array(total);
-  let at = 0;
-  for (const c of counts) at = packbitsDecodeInto(r.bytes(c), rb, out, at);
+function placementFromPlaced(p, size, notes) {
+  let mesh = null;
+  let frame = { x: 0, y: 0, width: size.width, height: size.height };
+  if (p.warp) {
+    const w = warpFromDescriptor(p.warp, size);
+    if (!w) notes.push("its warp could not be read and was left out");
+    else {
+      mesh = w.mesh;
+      if (p.quad.length === 8 && isParallelogram(toQuad(p.quad))) frame = w.frame;
+    }
+  }
+  const corners = cornersFromQuad(p.quad, frame, size);
+  if (!corners) return null;
+  const out = { corners };
+  if (mesh) out.warp = mesh;
   return out;
 }
-function decodePlanes(compression, data, l) {
-  const total = decodedLength(l);
-  switch (compression) {
-    case 0:
-      if (data.length < total) throw new PsdError(`Raw channel data has ${data.length} of ${total} bytes.`);
-      return data.slice(0, total);
-    case 1:
-      return decodeRle(new PsdReader(data), l, total);
-    case 2:
-      return inflateChecked(data, total).slice();
-    case 3: {
-      const v = inflateChecked(data, total).slice();
-      unpredict(v, l);
-      return v;
+var BOX_BLUR = { classId: "boxblur", id: 840, name: "Box Blur..." };
+function blendOptionsOf(item) {
+  const o = descObject(item, "blendOptions");
+  const opacity = o ? Math.min(1, Math.max(0, (descNumber(o, "Opct") ?? 100) / 100)) : 1;
+  const id = o ? enumOf(o, "Md  ") : void 0;
+  return { blend: id && blendFromPsdId(id) || "normal", opacity };
+}
+function blendOptions(f) {
+  return obj(
+    descriptor("blendOptions", [
+      ["Opct", unit("#Prc", Math.min(1, Math.max(0, f.opacity)) * 100)],
+      ["Md  ", enumV("BlnM", psdBlendId(f.blend))]
+    ])
+  );
+}
+function smartFiltersFromPsd(fx, newId, notes) {
+  const filters = [];
+  const list2 = descGet(fx, "filterFXList");
+  for (const v of list2?.type === "VlLs" ? list2.items : []) {
+    if (v.type !== "Objc" && v.type !== "GlbO") continue;
+    const item = v.value;
+    const { blend, opacity } = blendOptionsOf(item);
+    const enabled = descBool(item, "enab") !== false;
+    const fltr = descObject(item, "Fltr");
+    const radius = fltr?.classId === BOX_BLUR.classId ? descNumber(fltr, "Rds ") : void 0;
+    if (radius !== void 0 && radius >= 0 && radius <= 50) {
+      filters.push({ id: newId(), kind: "blur", enabled, radius, blend, opacity });
+      continue;
     }
-    default:
-      throw new PsdError(`Unsupported compression method ${compression}.`);
+    const name = (text(item, "Nm  ") ?? "Filter").replace(/&/g, "");
+    const neutral = cloneDescriptor(item);
+    setItem(neutral, "blendOptions", blendOptions({ blend: "normal", opacity: 1 }));
+    setItem(neutral, "enab", boolV(true));
+    filters.push({ id: newId(), kind: "psd", enabled, name, data: versionedDescriptorBytes(neutral), blend, opacity });
+    notes.push(`the ${name.replace(/\.\.\.$/, "")} smart filter is kept but not drawn`);
   }
+  return { enabled: descBool(fx, "enab") !== false, filters };
 }
-function encodeRle(decoded2, l) {
-  const rows = l.planes * l.height;
-  const rb = rowBytes(l.width, l.depth);
-  const cs = l.psb ? 4 : 2;
-  const packed = new Uint8Array(rows * packbitsBound(rb));
-  let at = 0;
-  const counts = new Uint8Array(rows * cs);
-  for (let row = 0; row < rows; row++) {
-    const start = at;
-    at = packbitsEncode(decoded2.subarray(row * rb, (row + 1) * rb), packed, at);
-    const n = at - start;
-    if (cs === 2) {
-      if (n > 65535) throw new PsdError("An RLE row is longer than 65535 bytes; write a PSB instead.");
-      counts[row * 2] = n >> 8;
-      counts[row * 2 + 1] = n & 255;
-    } else {
-      counts[row * 4] = n >>> 24;
-      counts[row * 4 + 1] = n >>> 16 & 255;
-      counts[row * 4 + 2] = n >>> 8 & 255;
-      counts[row * 4 + 3] = n & 255;
-    }
+function filterFXDescriptor(stack, dropped) {
+  const list2 = [];
+  for (const f of stack.filters) {
+    if (f.kind === "psd") {
+      const d = parseVersionedDescriptor(f.data);
+      setItem(d, "blendOptions", blendOptions(f));
+      setItem(d, "enab", boolV(f.enabled));
+      list2.push(obj(d));
+    } else if (f.kind === "blur") {
+      const rgb = (v) => obj(descriptor("RGBC", [["Rd  ", dbl(v)], ["Grn ", dbl(v)], ["Bl  ", dbl(v)]]));
+      list2.push(
+        obj(
+          descriptor("filterFX", [
+            ["Nm  ", textV(BOX_BLUR.name)],
+            ["blendOptions", blendOptions(f)],
+            ["enab", boolV(f.enabled)],
+            ["hasoptions", boolV(true)],
+            ["FrgC", rgb(0)],
+            ["BckC", rgb(255)],
+            ["Fltr", obj(descriptor(BOX_BLUR.classId, [["Rds ", unit("#Pxl", f.radius)]]))],
+            ["filterID", long2(BOX_BLUR.id)]
+          ])
+        )
+      );
+    } else dropped.push(f.kind);
+  }
+  return descriptor("filterFXStyle", [
+    ["enab", boolV(stack.enabled)],
+    ["validAtPosition", boolV(true)],
+    ["filterMaskEnable", boolV(stack.mask ? stack.mask.enabled !== false : true)],
+    ["filterMaskLinked", boolV(stack.mask ? stack.mask.linked !== false : false)],
+    ["filterMaskExtendWithWhite", boolV(true)],
+    ["filterFXList", { type: "VlLs", items: list2 }]
+  ]);
+}
+function filterStackKey(stack) {
+  if (!stack) return "";
+  return JSON.stringify([
+    stack.enabled,
+    stack.filters.map((f) => f.kind === "psd" ? ["psd", f.enabled, f.blend, f.opacity, Array.from(f.data)] : { ...f, id: void 0 }),
+    stack.mask ? [stack.mask.enabled !== false, stack.mask.linked !== false] : null
+  ]);
+}
+function soldBytes(s, notes) {
+  const { warp, frame, dropped } = warpDescriptor(s.placement.warp, s.size);
+  if (dropped) notes.push("a warp of several patches was written without its warp (the layer\u2019s pixels still show it)");
+  const quad = { type: "VlLs", items: quadFromCorners(s.placement.corners, frame, s.size).map(dbl) };
+  let d;
+  if (s.template) {
+    d = cloneDescriptor(s.template);
+    setItem(d, "Idnt", textV(s.idnt));
+    setItem(d, "placed", textV(s.placed));
+    setItem(d, "Trnf", quad);
+    setItem(d, "nonAffineTransform", quad);
+    setItem(d, "warp", obj(warp));
+    setItem(d, "Sz  ", obj(descriptor("Pnt ", [["Wdth", dbl(s.size.width)], ["Hght", dbl(s.size.height)]])));
+    if (s.filterFX) setItem(d, "filterFX", obj(s.filterFX));
+    else d.items = d.items.filter(([k]) => k !== "filterFX");
+  } else {
+    const ratio = (n, den) => obj(descriptor("null", [["numerator", long2(n)], ["denominator", long2(den)]]));
+    const items = [
+      ["Idnt", textV(s.idnt)],
+      ["placed", textV(s.placed)],
+      ["PgNm", long2(1)],
+      ["totalPages", long2(1)],
+      ["Crop", long2(1)],
+      ["frameStep", ratio(0, 600)],
+      ["duration", ratio(0, 600)],
+      ["frameCount", long2(1)],
+      ["Annt", long2(16)],
+      ["Type", long2(2)],
+      ["Trnf", quad],
+      ["nonAffineTransform", quad],
+      ["warp", obj(warp)],
+      ["Sz  ", obj(descriptor("Pnt ", [["Wdth", dbl(s.size.width)], ["Hght", dbl(s.size.height)]]))],
+      ["Rslt", unit("#Rsl", 72)]
+    ];
+    if (s.filterFX) items.push(["filterFX", obj(s.filterFX)]);
+    items.push(["comp", long2(-1)], ["compInfo", obj(descriptor("null", [["compID", long2(-1)], ["originalCompID", long2(-1)]]))]);
+    d = descriptor("null", items);
   }
-  const out = new Uint8Array(counts.length + at);
-  out.set(counts);
-  out.set(packed.subarray(0, at), counts.length);
-  return out;
+  const w = new PsdWriter();
+  w.ascii("soLD");
+  w.u32(4);
+  writeVersionedDescriptor(w, d);
+  w.zeros((4 - w.length % 4) % 4);
+  return w.result();
+}
+function plldBytes(s) {
+  const { warp, frame } = warpDescriptor(s.placement.warp, s.size);
+  const w = new PsdWriter();
+  w.ascii("plcL");
+  w.u32(3);
+  const id = new TextEncoder().encode(s.idnt).subarray(0, 255);
+  w.u8(id.length);
+  w.bytes(id);
+  for (const v of [1, 1, 16, 2]) w.u32(v);
+  for (const v of quadFromCorners(s.placement.corners, frame, s.size)) w.f64(v);
+  w.u32(0);
+  writeVersionedDescriptor(w, warp);
+  w.zeros((4 - w.length % 4) % 4);
+  return w.result();
 }
+var BROWSER_IMAGE_TYPES = {
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  tif: "image/tiff",
+  tiff: "image/tiff",
+  svg: "image/svg+xml",
+  png: "image/png",
+  webp: "image/webp"
+};
 
 // src/image-editor/psd/file.ts
 var PSD_MAX_DIMENSION = 3e4;
@@ -4992,7 +5552,7 @@ var SECTION_OTHER = 0;
 var SECTION_OPEN = 1;
 var SECTION_CLOSED = 2;
 var SECTION_DIVIDER = 3;
-function readRect(r) {
+function readRect2(r) {
   return { top: r.i32(), left: r.i32(), bottom: r.i32(), right: r.i32() };
 }
 function rectSize(rect) {
@@ -5079,8 +5639,8 @@ function realBeforeParameters(d) {
 function parseMask(d) {
   try {
     const r = new PsdReader(d);
-    const m = { rect: readRect(r), defaultColor: r.u8(), flags: r.u8() };
-    const readReal = () => r.remaining >= 18 ? { flags: r.u8(), background: r.u8(), rect: readRect(r) } : void 0;
+    const m = { rect: readRect2(r), defaultColor: r.u8(), flags: r.u8() };
+    const readReal = () => r.remaining >= 18 ? { flags: r.u8(), background: r.u8(), rect: readRect2(r) } : void 0;
     const params = (m.flags & MASK_FLAG_PARAMETERS) !== 0;
     const realFirst = params && realBeforeParameters(d);
     if (realFirst) m.real = readReal();
@@ -5098,7 +5658,7 @@ function parseMask(d) {
   }
 }
 function readLayerRecord(r, psb) {
-  const rect = readRect(r);
+  const rect = readRect2(r);
   const n = r.u16();
   if (n > MAX_LAYER_CHANNELS) throw new PsdError(`A layer has ${n} channels (at most ${MAX_LAYER_CHANNELS}).`);
   const channels = [];
@@ -5249,11 +5809,11 @@ function writeRect(w, r) {
 }
 function writeBlocks(w, blocks, psb, alignment) {
   for (const b of blocks) {
-    const long3 = psb && PSB_LONG_KEYS.has(b.key);
-    w.ascii(long3 ? "8B64" : "8BIM");
+    const long4 = psb && PSB_LONG_KEYS.has(b.key);
+    w.ascii(long4 ? "8B64" : "8BIM");
     w.ascii(b.key);
     const pad = (alignment - b.data.length % alignment) % alignment;
-    if (long3) w.u64(b.data.length + pad);
+    if (long4) w.u64(b.data.length + pad);
     else w.u32(b.data.length + pad);
     w.bytes(b.data);
     w.zeros(pad);
@@ -5678,6 +6238,7 @@ var FILL_KEYS = ["SoCo", "GdFl", "PtFl"];
 var TYPE_KEYS = ["TySh", "tySh"];
 var SMART_KEYS = ["SoLd", "SoLE", "PlLd"];
 var VECTOR_KEYS = ["vmsk", "vsms"];
+var MAX_CONTENTS_DEPTH = 6;
 var percent = (v) => Math.round(v / 255 * 100) / 100;
 var Warnings = class {
   groups = /* @__PURE__ */ new Map();
@@ -5896,6 +6457,26 @@ function importNode(ctx, node, depth) {
     return layer2;
   }
   const props = baseProps(ctx, rec, name, notes);
+  if (kind === "smart-object" && ctx.skipPixels) {
+    const block = PLACED_KEYS.map((k) => rec.blocks.find((b) => b.key === k)).find(Boolean);
+    const placed = block ? parsePlaced(block.key, block.data) : null;
+    if (placed) {
+      const file = ctx.linked.get(placed.idnt);
+      if (!file || file.kind !== "liFD") notes.push("linked contents come in as the stored pixels");
+      entry.type = "smart";
+      entry.status = notes.length ? "approximated" : "mapped";
+      return { type: "pixel", id: ctx.newId(name), ...props, surface: emptySurface(4), offset: { x: 0, y: 0 } };
+    }
+  }
+  if (kind === "smart-object" && !ctx.skipPixels) {
+    const smart = importSmart(ctx, rec, name, notes, props);
+    if (smart) {
+      entry.type = "smart";
+      entry.id = smart.id;
+      entry.status = notes.length ? "approximated" : "mapped";
+      return smart;
+    }
+  }
   if (kind !== "pixel") {
     const what = kind === "smart-object" ? "Smart objects" : kind === "type" ? "Type layers" : kind === "shape" ? "Shape layers" : "Fill layers";
     ctx.warn.add(`${what} came in as pixel layers (their stored pixels)`, name);
@@ -5913,6 +6494,126 @@ function importNode(ctx, node, depth) {
   entry.status = notes.length ? "approximated" : "mapped";
   return layer;
 }
+function contentsFor(ctx, placed, name, notes) {
+  const memo = ctx.contents.get(placed.idnt);
+  if (memo !== void 0) return memo;
+  const file = ctx.linked.get(placed.idnt);
+  let out = null;
+  if (file && file.kind === "liFD" && file.bytes.length) {
+    const t = fileTypeOf(file.bytes);
+    const base = { id: placed.idnt, name: file.name || `${name}.${t.ext}`, file: { bytes: file.bytes.slice(), type: t.ext } };
+    try {
+      if (t.ext === "psd" || t.ext === "psb") {
+        if (ctx.depth + 1 > MAX_CONTENTS_DEPTH) throw new PsdError("the contents nest too deep");
+        const nested = psdToLayers(readPsd(file.bytes), { newId: ctx.newId, depth: ctx.depth + 1 });
+        for (const w of nested.warnings) ctx.warn.add(`In its contents: ${w.replace(/\.$/, "")}`, name);
+        out = {
+          ...base,
+          kind: "document",
+          width: nested.width,
+          height: nested.height,
+          document: { layers: nested.layers, globalLight: nested.globalLight, patterns: nested.patterns.length ? nested.patterns : void 0 }
+        };
+      } else if (t.ext === "png") {
+        const png = decodePng(file.bytes);
+        out = { ...base, kind: "raster", width: png.width, height: png.height, raster: surfaceFromPixels(png, 4, 0, 0) };
+      } else {
+        const size = placed.size ?? { width: 0, height: 0 };
+        if (!(size.width > 0 && size.height > 0)) throw new PsdError("the contents have no stored size");
+        out = { ...base, kind: "raster", width: Math.round(size.width), height: Math.round(size.height) };
+        if (BROWSER_IMAGE_TYPES[t.ext]) {
+          ctx.warn.add(`Smart object contents in ${t.ext.toUpperCase()} format are decoded only in a browser (prepareSmartObjects); until then the layer shows its stored pixels and cannot be re-rendered`, name);
+        } else {
+          ctx.warn.add(`Smart object contents of an unsupported type (${t.ext === "bin" ? "unknown" : t.ext.toUpperCase()}) are kept for export, but the layer shows its stored pixels and cannot be re-rendered`, name);
+        }
+        notes.push(`${t.ext} contents not decoded here`);
+      }
+    } catch (e) {
+      ctx.warn.add(`Smart object contents could not be read (${e instanceof Error ? e.message : String(e)}); the layer came in as its stored pixels`, name);
+      notes.push("contents could not be read");
+      out = null;
+    }
+  }
+  ctx.contents.set(placed.idnt, out);
+  return out;
+}
+function importSmart(ctx, rec, name, notes, props) {
+  const block = PLACED_KEYS.map((k) => rec.blocks.find((b) => b.key === k)).find(Boolean);
+  if (!block) return null;
+  const placed = parsePlaced(block.key, block.data);
+  if (!placed) return null;
+  const surface = recordPixels(ctx, rec, name);
+  let contents = placed.idnt ? contentsFor(ctx, placed, name, notes) : null;
+  let placement = null;
+  let preview = false;
+  if (contents) {
+    const size = placed.size ?? { width: contents.width, height: contents.height };
+    const pnotes = [];
+    placement = placementFromPlaced(placed, size, pnotes);
+    for (const n of pnotes) {
+      ctx.warn.add(`A smart object's placement was approximated: ${n}`, name);
+      notes.push(n);
+    }
+    if (placement && (size.width !== contents.width || size.height !== contents.height)) {
+      const kx = contents.width / size.width;
+      const ky = contents.height / size.height;
+      if (placement.warp) placement = { ...placement, warp: mapWarpMeshPoints(placement.warp, (p) => ({ x: p.x * kx, y: p.y * ky })) };
+    }
+  }
+  if (!contents || !placement) {
+    const b = surface.bounds;
+    const { width, height } = rectSize(rec.rect);
+    if (!b || !(width > 0 && height > 0)) return null;
+    const file = ctx.linked.get(placed.idnt);
+    contents = {
+      id: placed.idnt || ctx.newId(`${name}-contents`),
+      name: file?.name || `${name}.png`,
+      width,
+      height,
+      kind: "raster",
+      raster: translateSurface(surface, -rec.rect.left, -rec.rect.top)
+    };
+    if (file && file.kind !== "liFD") {
+      contents.linked = { path: file.path ?? file.name };
+      ctx.warn.add(`Linked smart objects came in as their embedded preview; the linked file is not read`, name);
+      notes.push(`linked to "${file.path ?? file.name}"`);
+    } else if (!notes.includes("contents could not be read")) {
+      ctx.warn.add("A smart object without readable contents came in with its stored pixels as contents", name);
+      notes.push("contents missing");
+    }
+    placement = { corners: boxQuad({ x: rec.rect.left, y: rec.rect.top, width, height }) };
+    preview = true;
+  }
+  const layer = { type: "smart", id: ctx.newId(name), ...props, contents, placement, surface, offset: { x: 0, y: 0 } };
+  const fill = u8Block(rec, "iOpa");
+  if (fill !== void 0 && fill < 255) layer.fillOpacity = percent(fill);
+  const effects = recordEffects(ctx, rec, name, notes, false);
+  if (effects) layer.effects = effects;
+  const mask = recordMask(ctx, rec, name);
+  if (mask) layer.mask = mask;
+  if (placed.filterFX) {
+    const fnotes = [];
+    let n = 0;
+    const stack = smartFiltersFromPsd(placed.filterFX, () => `${layer.id}-flt-${++n}`, fnotes);
+    if (preview) {
+      stack.filters = stack.filters.map((f) => f.kind === "psd" ? f : { ...f, enabled: false });
+    }
+    for (const note of fnotes) {
+      ctx.warn.add(`Smart filters were approximated: ${note}`, name);
+      notes.push(note);
+    }
+    const item = ctx.filterItems.get(placed.placed);
+    const fm = item ? filterMaskFromItem(item) : null;
+    if (fm) {
+      if (descBool(placed.filterFX, "filterMaskEnable") === false) fm.enabled = false;
+      if (descBool(placed.filterFX, "filterMaskLinked") === false) fm.linked = false;
+      stack.mask = fm;
+    }
+    if (stack.filters.length || stack.mask || !stack.enabled) layer.smartFilters = stack;
+  }
+  layer.psd = { key: block.key, data: block.data.slice(), placed: placed.placed || void 0 };
+  return layer;
+}
 function mergedLayer(ctx) {
   const { header } = ctx.file;
   const { width, height } = header;
@@ -5960,8 +6661,24 @@ function psdToLayers(file, options = {}) {
     summary: [],
     colorCount: colorChannelCount(header.colorMode, header.channels),
     palette: header.colorMode === MODE_INDEXED ? file.colorModeData : void 0,
-    patterns: /* @__PURE__ */ new Map()
+    patterns: /* @__PURE__ */ new Map(),
+    linked: /* @__PURE__ */ new Map(),
+    filterItems: /* @__PURE__ */ new Map(),
+    contents: /* @__PURE__ */ new Map(),
+    depth: options.depth ?? 0
   };
+  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);
+    }
+    if (FILTER_EFFECTS_KEYS.includes(block.key)) {
+      try {
+        for (const it of parseFilterEffects(block.data).items) ctx.filterItems.set(it.id, it);
+      } catch (e) {
+        warn.extra.push(`The smart filter masks could not be read (${e instanceof Error ? e.message : String(e)}); they reveal everything.`);
+      }
+    }
+  }
   for (const block of file.globalBlocks) {
     if (!PATTERN_BLOCK_KEYS.includes(block.key)) continue;
     try {
@@ -6064,14 +6781,20 @@ var BLEND_LONG = [
 ];
 var BLEND_OF = new Map([...BLEND_CODES, ...BLEND_LONG].map(([m, id]) => [id, m]));
 var BLEND_ID = new Map(BLEND_CODES);
+function blendFromPsdId(id) {
+  return BLEND_OF.get(id);
+}
+function psdBlendId(mode) {
+  return BLEND_ID.get(mode) ?? "Nrml";
+}
 var num2 = (d, key, fallback) => descNumber(d, key) ?? fallback;
 var pct = (d, key, fallback) => num2(d, key, fallback * 100) / 100;
 var bool = (d, key) => descBool(d, key) === true;
-var enumOf = (d, key) => {
+var enumOf2 = (d, key) => {
   const v = descGet(d, key);
   return v?.type === "enum" ? v.value : void 0;
 };
-var text = (d, key) => {
+var text2 = (d, key) => {
   const v = d ? descGet(d, key) : void 0;
   return v?.type === "TEXT" ? v.value : "";
 };
@@ -6081,15 +6804,15 @@ var list = (d, key) => {
   return v.items.flatMap((it) => it.type === "Objc" || it.type === "GlbO" ? [it.value] : []);
 };
 var clamp3 = (v, lo, hi) => Number.isFinite(v) ? Math.min(hi, Math.max(lo, v)) : lo;
-var unit = (u, value) => ({ type: "UntF", unit: u, value });
-var dbl = (value) => ({ type: "doub", value });
-var long2 = (value) => ({ type: "long", value: Math.round(value) });
-var boolV = (value) => ({ type: "bool", value });
-var enumV = (typeId, value) => ({ type: "enum", typeId, value });
-var textV = (value) => ({ type: "TEXT", value });
-var obj = (d) => ({ type: "Objc", value: d });
+var unit2 = (u, value) => ({ type: "UntF", unit: u, value });
+var dbl2 = (value) => ({ type: "doub", value });
+var long3 = (value) => ({ type: "long", value: Math.round(value) });
+var boolV2 = (value) => ({ type: "bool", value });
+var enumV2 = (typeId, value) => ({ type: "enum", typeId, value });
+var textV2 = (value) => ({ type: "TEXT", value });
+var obj2 = (d) => ({ type: "Objc", value: d });
 function blendOf(d, key, fallback, notes) {
-  const id = enumOf(d, key);
+  const id = enumOf2(d, key);
   if (id === void 0) return fallback;
   const m = BLEND_OF.get(id);
   if (m) return m;
@@ -6128,15 +6851,15 @@ function colorOf(d, fallback = "#000000") {
 function colorDesc(hex) {
   const [r, g, b] = parseEffectColor(hex) ?? [0, 0, 0];
   return descriptor("RGBC", [
-    ["Rd  ", dbl(r * 255)],
-    ["Grn ", dbl(g * 255)],
-    ["Bl  ", dbl(b * 255)]
+    ["Rd  ", dbl2(r * 255)],
+    ["Grn ", dbl2(g * 255)],
+    ["Bl  ", dbl2(b * 255)]
   ]);
 }
 function contourOf(d, key) {
   const c = descObject(d, key);
   if (!c) return void 0;
-  const name = text(c, "Nm  ");
+  const name = text2(c, "Nm  ");
   const points = list(c, "Crv ").map((p) => {
     const out = { input: clamp3(num2(p, "Hrzn", 0) / 255, 0, 1), output: clamp3(num2(p, "Vrtc", 0) / 255, 0, 1) };
     if (descBool(p, "Cnty") === false) out.corner = true;
@@ -6156,16 +6879,16 @@ function contourDesc(c) {
     type: "VlLs",
     items: points.map((p) => {
       const items = [
-        ["Hrzn", dbl(p.input * 255)],
-        ["Vrtc", dbl(p.output * 255)]
+        ["Hrzn", dbl2(p.input * 255)],
+        ["Vrtc", dbl2(p.output * 255)]
       ];
-      if (p.corner) items.push(["Cnty", boolV(false)]);
-      return obj(descriptor("CrPt", items));
+      if (p.corner) items.push(["Cnty", boolV2(false)]);
+      return obj2(descriptor("CrPt", items));
     })
   };
-  return obj(
+  return obj2(
     descriptor("ShpC", [
-      ["Nm  ", textV(name)],
+      ["Nm  ", textV2(name)],
       ["Crv ", pts]
     ])
   );
@@ -6183,7 +6906,7 @@ function gradientOf(d, notes) {
       { position: 0, color: "#000000" },
       { position: 1, color: "#ffffff" }
     ],
-    style: GRADIENT_STYLES.find(([, id]) => id === enumOf(d, "Type"))?.[0] ?? "linear",
+    style: GRADIENT_STYLES.find(([, id]) => id === enumOf2(d, "Type"))?.[0] ?? "linear",
     angle: clamp3(num2(d, "Angl", 90), -360, 360),
     scale: clamp3(pct(d, "Scl ", 1), 0.1, 1.5),
     reverse: bool(d, "Rvrs"),
@@ -6194,12 +6917,12 @@ function gradientOf(d, notes) {
   if (off) g.offset = { x: clamp3(pct(off, "Hrzn", 0), -1, 1), y: clamp3(pct(off, "Vrtc", 0), -1, 1) };
   const grad = descObject(d, "Grad");
   if (!grad) return g;
-  if (enumOf(grad, "GrdF") === "ClNs") {
+  if (enumOf2(grad, "GrdF") === "ClNs") {
     notes.add("noise gradients became black to white");
     return g;
   }
   const raw = list(grad, "Clrs").map((s) => {
-    const type = enumOf(s, "Type");
+    const type = enumOf2(s, "Type");
     if (type === "FrgC" || type === "BckC") notes.add("foreground / background gradient stops became black / white");
     const color = type === "BckC" ? "#ffffff" : colorOf(descObject(s, "Clr "));
     return { position: clamp3(num2(s, "Lctn", 0) / 4096, 0, 1), color, mid: clamp3(num2(s, "Mdpn", 50) / 100, 0.05, 0.95) };
@@ -6227,12 +6950,12 @@ function gradientItems(g) {
   const clrs = {
     type: "VlLs",
     items: g.stops.map(
-      (s) => obj(
+      (s) => obj2(
         descriptor("Clrt", [
-          ["Clr ", obj(colorDesc(s.color))],
-          ["Type", enumV("Clry", "UsrS")],
-          ["Lctn", long2(s.position * 4096)],
-          ["Mdpn", long2(50)]
+          ["Clr ", obj2(colorDesc(s.color))],
+          ["Type", enumV2("Clry", "UsrS")],
+          ["Lctn", long3(s.position * 4096)],
+          ["Mdpn", long3(50)]
         ])
       )
     )
@@ -6241,35 +6964,35 @@ function gradientItems(g) {
   const trns = {
     type: "VlLs",
     items: op.map(
-      (s) => obj(
+      (s) => obj2(
         descriptor("TrnS", [
-          ["Opct", unit("#Prc", s.opacity * 100)],
-          ["Lctn", long2(s.position * 4096)],
-          ["Mdpn", long2(50)]
+          ["Opct", unit2("#Prc", s.opacity * 100)],
+          ["Lctn", long3(s.position * 4096)],
+          ["Mdpn", long3(50)]
         ])
       )
     )
   };
   const grad = descriptor("Grdn", [
-    ["Nm  ", textV("Custom")],
-    ["GrdF", enumV("GrdF", "CstS")],
-    ["Intr", dbl(0)],
+    ["Nm  ", textV2("Custom")],
+    ["GrdF", enumV2("GrdF", "CstS")],
+    ["Intr", dbl2(0)],
     ["Clrs", clrs],
     ["Trns", trns]
   ]);
   return [
-    ["Grad", obj(grad)],
-    ["Angl", unit("#Ang", g.angle)],
-    ["Type", enumV("GrdT", GRADIENT_STYLES.find(([s]) => s === g.style)[1])],
-    ["Rvrs", boolV(g.reverse)],
-    ["Algn", boolV(g.align)],
-    ["Scl ", unit("#Prc", g.scale * 100)],
+    ["Grad", obj2(grad)],
+    ["Angl", unit2("#Ang", g.angle)],
+    ["Type", enumV2("GrdT", GRADIENT_STYLES.find(([s]) => s === g.style)[1])],
+    ["Rvrs", boolV2(g.reverse)],
+    ["Algn", boolV2(g.align)],
+    ["Scl ", unit2("#Prc", g.scale * 100)],
     [
       "Ofst",
-      obj(
+      obj2(
         descriptor("Pnt ", [
-          ["Hrzn", unit("#Prc", g.offset.x * 100)],
-          ["Vrtc", unit("#Prc", g.offset.y * 100)]
+          ["Hrzn", unit2("#Prc", g.offset.x * 100)],
+          ["Vrtc", unit2("#Prc", g.offset.y * 100)]
         ])
       )
     ]
@@ -6277,13 +7000,13 @@ function gradientItems(g) {
 }
 function patternRefOf(d) {
   const p = descObject(d, "Ptrn");
-  return { patternId: text(p, "Idnt") || text(p, "Nm  "), name: text(p, "Nm  ") };
+  return { patternId: text2(p, "Idnt") || text2(p, "Nm  "), name: text2(p, "Nm  ") };
 }
 function patternRefDesc(patternId, name) {
-  return obj(
+  return obj2(
     descriptor("Ptrn", [
-      ["Nm  ", textV(name ?? patternId)],
-      ["Idnt", textV(patternId)]
+      ["Nm  ", textV2(name ?? patternId)],
+      ["Idnt", textV2(patternId)]
     ])
   );
 }
@@ -6297,14 +7020,14 @@ function placementOf(d) {
 }
 function placementItems(angle, link, phase) {
   const out = [];
-  if (angle) out.push(["Angl", unit("#Ang", angle)]);
-  out.push(["Algn", boolV(link)]);
+  if (angle) out.push(["Angl", unit2("#Ang", angle)]);
+  out.push(["Algn", boolV2(link)]);
   out.push([
     "phase",
-    obj(
+    obj2(
       descriptor("Pnt ", [
-        ["Hrzn", dbl(phase.x)],
-        ["Vrtc", dbl(phase.y)]
+        ["Hrzn", dbl2(phase.x)],
+        ["Vrtc", dbl2(phase.y)]
       ])
     )
   ]);
@@ -6353,7 +7076,7 @@ function readOne(kind, d, notes) {
       const base = {
         ...common(d, kind, notes),
         fill,
-        technique: enumOf(d, "GlwT") === "PrBL" ? "precise" : "softer",
+        technique: enumOf2(d, "GlwT") === "PrBL" ? "precise" : "softer",
         size: size("blur", 5),
         contour: contourOf(d, "TrnS"),
         antiAlias: bool(d, "AntA"),
@@ -6362,7 +7085,7 @@ function readOne(kind, d, notes) {
         noise: clamp3(pct(d, "Nose", 0), 0, 1)
       };
       const spread = clamp3(pct(d, "Ckmt", 0), 0, 1);
-      return kind === "outer-glow" ? { ...base, kind, spread } : { ...base, kind, choke: spread, source: enumOf(d, "glwS") === "SrcC" ? "center" : "edge" };
+      return kind === "outer-glow" ? { ...base, kind, spread } : { ...base, kind, choke: spread, source: enumOf2(d, "glwS") === "SrcC" ? "center" : "edge" };
     }
     case "bevel-emboss": {
       const styles = { OtrB: "outer-bevel", InrB: "inner-bevel", Embs: "emboss", PlEb: "pillow-emboss", strokeEmboss: "stroke-emboss" };
@@ -6370,10 +7093,10 @@ function readOne(kind, d, notes) {
         id: newEffectId(),
         enabled: descBool(d, "enab") !== false,
         kind,
-        style: styles[enumOf(d, "bvlS") ?? ""] ?? "inner-bevel",
-        technique: enumOf(d, "bvlT") === "PrBL" ? "chisel-hard" : enumOf(d, "bvlT") === "Slmt" ? "chisel-soft" : "smooth",
+        style: styles[enumOf2(d, "bvlS") ?? ""] ?? "inner-bevel",
+        technique: enumOf2(d, "bvlT") === "PrBL" ? "chisel-hard" : enumOf2(d, "bvlT") === "Slmt" ? "chisel-soft" : "smooth",
         depth: clamp3(pct(d, "srgR", 1), 0, 10),
-        direction: enumOf(d, "bvlD") === "Out " ? "down" : "up",
+        direction: enumOf2(d, "bvlD") === "Out " ? "down" : "up",
         size: size("blur", 5),
         soften: clamp3(num2(d, "Sftn", 0), 0, 16),
         angle: clamp3(num2(d, "lagl", 120), -360, 360),
@@ -6417,14 +7140,14 @@ function readOne(kind, d, notes) {
       return { ...common(d, kind, notes), kind, patternId: ref.patternId, name: ref.name, scale: clamp3(pct(d, "Scl ", 1), 0.01, 10), angle: place.angle, link: place.link, phase: place.phase };
     }
     case "stroke": {
-      const paint = enumOf(d, "PntT");
+      const paint = enumOf2(d, "PntT");
       let fill;
       if (paint === "GrFl") fill = { type: "gradient", gradient: gradientOf(d, notes) };
       else if (paint === "Ptrn") {
         const ref = patternRefOf(d);
         fill = { type: "pattern", patternId: ref.patternId, name: ref.name, scale: clamp3(pct(d, "Scl ", 1), 0.01, 10) };
       } else fill = { type: "color", color: colorOf(descObject(d, "Clr ")) };
-      const pos = enumOf(d, "Styl");
+      const pos = enumOf2(d, "Styl");
       return { ...common(d, kind, notes), kind, size: size("Sz  ", 3), position: pos === "InsF" ? "inside" : pos === "CtrF" ? "center" : "outside", fill };
     }
   }
@@ -6451,11 +7174,11 @@ function parseLfx2(data) {
 }
 function commonItems(e) {
   return [
-    ["enab", boolV(e.enabled)],
-    ["present", boolV(true)],
-    ["showInDialog", boolV(true)],
-    ["Md  ", enumV("BlnM", BLEND_ID.get(e.blend) ?? "Nrml")],
-    ["Opct", unit("#Prc", e.opacity * 100)]
+    ["enab", boolV2(e.enabled)],
+    ["present", boolV2(true)],
+    ["showInDialog", boolV2(true)],
+    ["Md  ", enumV2("BlnM", BLEND_ID.get(e.blend) ?? "Nrml")],
+    ["Opct", unit2("#Prc", e.opacity * 100)]
   ];
 }
 function writeOne(e) {
@@ -6465,17 +7188,17 @@ function writeOne(e) {
       const inner = e.kind === "inner-shadow";
       const items = [
         ...commonItems(e),
-        ["Clr ", obj(colorDesc(e.color))],
-        ["uglg", boolV(e.useGlobalLight)],
-        ["lagl", unit("#Ang", e.angle)],
-        ["Dstn", unit("#Pxl", e.distance)],
-        ["Ckmt", unit("#Pxl", (inner ? e.choke : e.spread) * 100)],
-        ["blur", unit("#Pxl", e.size)],
-        ["Nose", unit("#Prc", e.noise * 100)],
-        ["AntA", boolV(e.antiAlias)],
+        ["Clr ", obj2(colorDesc(e.color))],
+        ["uglg", boolV2(e.useGlobalLight)],
+        ["lagl", unit2("#Ang", e.angle)],
+        ["Dstn", unit2("#Pxl", e.distance)],
+        ["Ckmt", unit2("#Pxl", (inner ? e.choke : e.spread) * 100)],
+        ["blur", unit2("#Pxl", e.size)],
+        ["Nose", unit2("#Prc", e.noise * 100)],
+        ["AntA", boolV2(e.antiAlias)],
         ["TrnS", contourDesc(e.contour)]
       ];
-      if (e.kind === "drop-shadow") items.push(["layerConceals", boolV(e.knocksOut)]);
+      if (e.kind === "drop-shadow") items.push(["layerConceals", boolV2(e.knocksOut)]);
       return descriptor(inner ? "IrSh" : "DrSh", items);
     }
     case "outer-glow":
@@ -6483,110 +7206,110 @@ function writeOne(e) {
       const inner = e.kind === "inner-glow";
       const items = [...commonItems(e)];
       if (e.fill.type === "gradient") items.push(...gradientItems(e.fill.gradient));
-      else items.push(["Clr ", obj(colorDesc(e.fill.color))]);
+      else items.push(["Clr ", obj2(colorDesc(e.fill.color))]);
       items.push(
-        ["GlwT", enumV("BETE", e.technique === "precise" ? "PrBL" : "SfBL")],
-        ["Ckmt", unit("#Pxl", (inner ? e.choke : e.spread) * 100)],
-        ["blur", unit("#Pxl", e.size)],
-        ["Nose", unit("#Prc", e.noise * 100)],
-        ["ShdN", unit("#Prc", e.jitter * 100)],
-        ["AntA", boolV(e.antiAlias)],
+        ["GlwT", enumV2("BETE", e.technique === "precise" ? "PrBL" : "SfBL")],
+        ["Ckmt", unit2("#Pxl", (inner ? e.choke : e.spread) * 100)],
+        ["blur", unit2("#Pxl", e.size)],
+        ["Nose", unit2("#Prc", e.noise * 100)],
+        ["ShdN", unit2("#Prc", e.jitter * 100)],
+        ["AntA", boolV2(e.antiAlias)],
         ["TrnS", contourDesc(e.contour)],
-        ["Inpr", unit("#Prc", e.range * 100)]
+        ["Inpr", unit2("#Prc", e.range * 100)]
       );
-      if (e.kind === "inner-glow") items.push(["glwS", enumV("IGSr", e.source === "center" ? "SrcC" : "SrcE")]);
+      if (e.kind === "inner-glow") items.push(["glwS", enumV2("IGSr", e.source === "center" ? "SrcC" : "SrcE")]);
       return descriptor(inner ? "IrGl" : "OrGl", items);
     }
     case "bevel-emboss": {
       const style = { "outer-bevel": "OtrB", "inner-bevel": "InrB", emboss: "Embs", "pillow-emboss": "PlEb", "stroke-emboss": "strokeEmboss" }[e.style];
       const tech = { smooth: "SfBL", "chisel-hard": "PrBL", "chisel-soft": "Slmt" }[e.technique];
       const items = [
-        ["enab", boolV(e.enabled)],
-        ["present", boolV(true)],
-        ["showInDialog", boolV(true)],
-        ["hglM", enumV("BlnM", BLEND_ID.get(e.highlightBlend) ?? "Scrn")],
-        ["hglC", obj(colorDesc(e.highlightColor))],
-        ["hglO", unit("#Prc", e.highlightOpacity * 100)],
-        ["sdwM", enumV("BlnM", BLEND_ID.get(e.shadowBlend) ?? "Mltp")],
-        ["sdwC", obj(colorDesc(e.shadowColor))],
-        ["sdwO", unit("#Prc", e.shadowOpacity * 100)],
-        ["bvlT", enumV("bvlT", tech)],
-        ["bvlS", enumV("BESl", style)],
-        ["uglg", boolV(e.useGlobalLight)],
-        ["lagl", unit("#Ang", e.angle)],
-        ["Lald", unit("#Ang", e.altitude)],
-        ["srgR", unit("#Prc", e.depth * 100)],
-        ["blur", unit("#Pxl", e.size)],
-        ["bvlD", enumV("BESs", e.direction === "up" ? "In  " : "Out ")],
+        ["enab", boolV2(e.enabled)],
+        ["present", boolV2(true)],
+        ["showInDialog", boolV2(true)],
+        ["hglM", enumV2("BlnM", BLEND_ID.get(e.highlightBlend) ?? "Scrn")],
+        ["hglC", obj2(colorDesc(e.highlightColor))],
+        ["hglO", unit2("#Prc", e.highlightOpacity * 100)],
+        ["sdwM", enumV2("BlnM", BLEND_ID.get(e.shadowBlend) ?? "Mltp")],
+        ["sdwC", obj2(colorDesc(e.shadowColor))],
+        ["sdwO", unit2("#Prc", e.shadowOpacity * 100)],
+        ["bvlT", enumV2("bvlT", tech)],
+        ["bvlS", enumV2("BESl", style)],
+        ["uglg", boolV2(e.useGlobalLight)],
+        ["lagl", unit2("#Ang", e.angle)],
+        ["Lald", unit2("#Ang", e.altitude)],
+        ["srgR", unit2("#Prc", e.depth * 100)],
+        ["blur", unit2("#Pxl", e.size)],
+        ["bvlD", enumV2("BESs", e.direction === "up" ? "In  " : "Out ")],
         ["TrnS", contourDesc(e.glossContour)],
-        ["Sftn", unit("#Pxl", e.soften)]
+        ["Sftn", unit2("#Pxl", e.soften)]
       ];
       if (e.contourElement) {
-        items.push(["useShape", boolV(true)], ["MpgS", contourDesc(e.contourElement.contour)], ["AntA", boolV(e.contourElement.antiAlias)], ["Inpr", unit("#Prc", e.contourElement.range * 100)]);
-      } else items.push(["useShape", boolV(false)]);
+        items.push(["useShape", boolV2(true)], ["MpgS", contourDesc(e.contourElement.contour)], ["AntA", boolV2(e.contourElement.antiAlias)], ["Inpr", unit2("#Prc", e.contourElement.range * 100)]);
+      } else items.push(["useShape", boolV2(false)]);
       if (e.texture) {
         const t = e.texture;
         items.push(
-          ["useTexture", boolV(true)],
-          ["InvT", boolV(t.invert)],
-          ["Scl ", unit("#Prc", t.scale * 100)],
-          ["textureDepth", unit("#Prc", t.depth * 100)],
+          ["useTexture", boolV2(true)],
+          ["InvT", boolV2(t.invert)],
+          ["Scl ", unit2("#Prc", t.scale * 100)],
+          ["textureDepth", unit2("#Prc", t.depth * 100)],
           ["Ptrn", patternRefDesc(t.patternId, t.name)],
           ...placementItems(0, t.link ?? true, t.phase ?? { x: 0, y: 0 })
         );
-      } else items.push(["useTexture", boolV(false)]);
+      } else items.push(["useTexture", boolV2(false)]);
       return descriptor("ebbl", items);
     }
     case "satin":
       return descriptor("ChFX", [
         ...commonItems(e),
-        ["Clr ", obj(colorDesc(e.color))],
-        ["AntA", boolV(e.antiAlias)],
-        ["Invr", boolV(e.invert)],
-        ["lagl", unit("#Ang", e.angle)],
-        ["Dstn", unit("#Pxl", e.distance)],
-        ["blur", unit("#Pxl", e.size)],
+        ["Clr ", obj2(colorDesc(e.color))],
+        ["AntA", boolV2(e.antiAlias)],
+        ["Invr", boolV2(e.invert)],
+        ["lagl", unit2("#Ang", e.angle)],
+        ["Dstn", unit2("#Pxl", e.distance)],
+        ["blur", unit2("#Pxl", e.size)],
         ["MpgS", contourDesc(e.contour)]
       ]);
     case "color-overlay":
-      return descriptor("SoFi", [...commonItems(e), ["Clr ", obj(colorDesc(e.color))]]);
+      return descriptor("SoFi", [...commonItems(e), ["Clr ", obj2(colorDesc(e.color))]]);
     case "gradient-overlay":
-      return descriptor("GrFl", [...commonItems(e), ...gradientItems(e.gradient), ["Dthr", boolV(e.dither)]]);
+      return descriptor("GrFl", [...commonItems(e), ...gradientItems(e.gradient), ["Dthr", boolV2(e.dither)]]);
     case "pattern-overlay":
       return descriptor("patternFill", [
         ...commonItems(e),
         ["Ptrn", patternRefDesc(e.patternId, e.name)],
-        ["Scl ", unit("#Prc", e.scale * 100)],
+        ["Scl ", unit2("#Prc", e.scale * 100)],
         ...placementItems(e.angle ?? 0, e.link ?? true, e.phase ?? { x: 0, y: 0 })
       ]);
     case "stroke": {
       const items = [
         ...commonItems(e),
-        ["Styl", enumV("FStl", e.position === "inside" ? "InsF" : e.position === "center" ? "CtrF" : "OutF")],
-        ["Sz  ", unit("#Pxl", e.size)]
+        ["Styl", enumV2("FStl", e.position === "inside" ? "InsF" : e.position === "center" ? "CtrF" : "OutF")],
+        ["Sz  ", unit2("#Pxl", e.size)]
       ];
       const f = e.fill;
-      if (f.type === "color") items.push(["PntT", enumV("FrFl", "SClr")], ["Clr ", obj(colorDesc(f.color))]);
-      else if (f.type === "gradient") items.push(["PntT", enumV("FrFl", "GrFl")], ...gradientItems(f.gradient));
-      else items.push(["PntT", enumV("FrFl", "Ptrn")], ["Ptrn", patternRefDesc(f.patternId, f.name)], ["Scl ", unit("#Prc", f.scale * 100)]);
+      if (f.type === "color") items.push(["PntT", enumV2("FrFl", "SClr")], ["Clr ", obj2(colorDesc(f.color))]);
+      else if (f.type === "gradient") items.push(["PntT", enumV2("FrFl", "GrFl")], ...gradientItems(f.gradient));
+      else items.push(["PntT", enumV2("FrFl", "Ptrn")], ["Ptrn", patternRefDesc(f.patternId, f.name)], ["Scl ", unit2("#Prc", f.scale * 100)]);
       return descriptor("FrFX", items);
     }
   }
 }
 function writeLfx2(effects) {
   const items = [
-    ["Scl ", unit("#Prc", 100)],
-    ["masterFXSwitch", boolV(effects.enabled)]
+    ["Scl ", unit2("#Prc", 100)],
+    ["masterFXSwitch", boolV2(effects.enabled)]
   ];
   const scale = effectsScale(effects);
   let dropped = 0;
   for (const [single, multi, kind] of KINDS) {
     const of = effects.items.filter((e) => e.kind === kind).map((e) => writeOne(scaleLayerEffect(e, scale)));
     if (!of.length) continue;
-    if (of.length === 1) items.push([single, obj(of[0])]);
-    else if (multi) items.push([multi, { type: "VlLs", items: of.map(obj) }]);
+    if (of.length === 1) items.push([single, obj2(of[0])]);
+    else if (multi) items.push([multi, { type: "VlLs", items: of.map(obj2) }]);
     else {
-      items.push([single, obj(of[0])]);
+      items.push([single, obj2(of[0])]);
       dropped += of.length - 1;
     }
   }
@@ -6716,6 +7439,76 @@ function lockBits(layer) {
   if (!l) return 0;
   return (l.all ? 2147483648 : 0) | (l.transparency ? 1 : 0) | (l.pixels ? 2 : 0) | (l.position ? 4 : 0);
 }
+function prepareNestedLayers(layers) {
+  const out = [];
+  for (const l of layers) {
+    if (l.type === "annotation") continue;
+    let next = l;
+    if (l.type === "group") next = { ...l, children: prepareNestedLayers(l.children) };
+    else if (l.type === "pixel" && (l.filters?.length || l.source === "document")) {
+      const p = { ...l };
+      if (l.filters?.some(isActiveFilter)) {
+        const b = l.surface.bounds;
+        if (b) {
+          const r = { x: b.x + l.offset.x - 64, y: b.y + l.offset.y - 64, width: b.width + 128, height: b.height + 128 };
+          const plain = { ...l, visible: true, opacity: 1, blend: "normal" };
+          delete plain.mask;
+          delete plain.clipped;
+          delete plain.effects;
+          delete plain.fillOpacity;
+          const data = new LayerCompositor().composite([plain], r, { width: r.x + r.width, height: r.y + r.height });
+          p.surface = surfaceFromPixels({ width: r.width, height: r.height, data }, 4, r.x - l.offset.x, r.y - l.offset.y);
+        }
+      }
+      delete p.filters;
+      delete p.source;
+      next = p;
+    }
+    if (next.mask?.source) {
+      next = { ...next };
+      delete next.mask;
+    }
+    out.push(next);
+  }
+  return out;
+}
+function smartContentsFile(c) {
+  const base = c.name.replace(/\.\w+$/, "") || "Contents";
+  if (c.file) return { name: c.name, bytes: c.file.bytes };
+  if (c.kind === "raster") {
+    const data = readRegion(contentsSurface(c), { x: 0, y: 0, width: c.width, height: c.height });
+    return { name: `${base}.png`, bytes: encodePng(c.width, c.height, data) };
+  }
+  const doc = c.document;
+  const merged = readRegion(contentsSurface(c), { x: 0, y: 0, width: c.width, height: c.height });
+  const res = exportPsd({ width: c.width, height: c.height, layers: prepareNestedLayers(doc.layers), merged, patterns: doc.patterns, globalLight: doc.globalLight });
+  return { name: `${base}.${res.psb ? "psb" : "psd"}`, bytes: res.bytes };
+}
+var near = (a, b) => Math.abs(a - b) <= 1e-6 * (1 + Math.abs(a));
+function placedUnchanged(layer, idnt, placedId) {
+  const raw = layer.psd;
+  if (!raw || raw.key === "PlLd") return false;
+  const p = parsePlaced(raw.key, raw.data);
+  if (!p || p.idnt !== idnt || p.placed !== placedId) return false;
+  const size = p.size ?? { width: layer.contents.width, height: layer.contents.height };
+  if (size.width !== layer.contents.width || size.height !== layer.contents.height) return false;
+  const was = placementFromPlaced(p, size, []);
+  if (!was) return false;
+  const now = placementGeometry(layer);
+  if (!was.corners.every((c, i) => near(c.x, now.corners[i].x) && near(c.y, now.corners[i].y))) return false;
+  const meshKey = (m) => m ? m.points.map((q2) => `${q2.x.toFixed(5)},${q2.y.toFixed(5)}`).join(";") + `|${m.us.length}x${m.vs.length}` : "";
+  if (meshKey(was.warp) !== meshKey(now.warp)) return false;
+  if ((layer.placement.interpolation ?? "bicubic") !== "bicubic") return false;
+  const stored = p.filterFX ? smartFiltersFromPsd(p.filterFX, () => "", []) : void 0;
+  if (stored && p.filterFX) {
+    if (descBool(p.filterFX, "filterMaskEnable") === false || descBool(p.filterFX, "filterMaskLinked") === false) {
+      stored.mask = { surface: layer.surface, defaultValue: 255, enabled: descBool(p.filterFX, "filterMaskEnable") !== false, linked: descBool(p.filterFX, "filterMaskLinked") !== false };
+    }
+  }
+  const current = layer.smartFilters;
+  const norm = (st) => st && (st.filters.length || !st.enabled) ? filterStackKey({ ...st, mask: st.mask && (st.mask.enabled === false || st.mask.linked === false) ? st.mask : void 0 }) : "";
+  return norm(stored) === norm(current);
+}
 function exportPsd(input) {
   const { width, height } = input;
   if (width < 1 || height < 1) throw new PsdError("The document is empty.");
@@ -6725,6 +7518,9 @@ function exportPsd(input) {
   const notes = /* @__PURE__ */ new Map();
   const note = (msg, name) => notes.set(msg, [...notes.get(msg) ?? [], name]);
   const patternIds2 = /* @__PURE__ */ new Set();
+  const linkedFiles = /* @__PURE__ */ new Map();
+  const filterItems = [];
+  const placedIds = /* @__PURE__ */ new Set();
   const effectsBlock = (layer) => {
     const fx = layer.effects;
     if (!fx) return null;
@@ -6834,6 +7630,57 @@ function exportPsd(input) {
         records.push(rec);
         return;
       }
+      case "smart": {
+        const extra = [];
+        if (layer.fillOpacity !== void 0 && layer.fillOpacity < 1) {
+          extra.push({ key: "iOpa", data: Uint8Array.from([Math.round(Math.max(0, layer.fillOpacity) * 255), 0, 0, 0]) });
+        }
+        const c = layer.contents;
+        const idnt = psdUuid(c.id);
+        if (!linkedFiles.has(idnt)) {
+          if (c.linked) note("Linked smart objects were embedded (their preview is written as the contents)", layer.name);
+          linkedFiles.set(idnt, smartContentsFile(c));
+        }
+        let placedId = layer.psd?.placed ?? psdUuid(`${layer.id}:placed`);
+        if (placedIds.has(placedId)) placedId = psdUuid(`${layer.id}:placed:${placedIds.size}`);
+        placedIds.add(placedId);
+        if (placedUnchanged(layer, idnt, placedId)) {
+          extra.push({ key: layer.psd.key, data: padEven(layer.psd.data) });
+        } else {
+          const dropped = [];
+          const filterFX = layer.smartFilters ? filterFXDescriptor(layer.smartFilters, dropped) : void 0;
+          if (dropped.length) note("Develop smart filters have no Photoshop filter and were left out of the filter list (the layer\u2019s pixels still show them)", layer.name);
+          const raw = layer.psd && layer.psd.key !== "PlLd" ? parsePlaced(layer.psd.key, layer.psd.data) : null;
+          const spec = { idnt, placed: placedId, placement: layer.placement, size: { width: c.width, height: c.height }, filterFX, template: raw?.descriptor };
+          const wnotes = [];
+          extra.push({ key: "PlLd", data: plldBytes(spec) }, { key: "SoLd", data: soldBytes(spec, wnotes) });
+          for (const n2 of wnotes) note(`A smart object: ${n2}`, layer.name);
+        }
+        const fm = layer.smartFilters?.mask;
+        if (fm && !fm.source) filterItems.push(filterMaskItem(placedId, fm, { x: 0, y: 0, width, height }));
+        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)
+          ];
+        } else {
+          rec.channels = [CHANNEL_ALPHA, 0, 1, 2].map(emptyChannel);
+        }
+        if (layer.mask) {
+          const m = maskChannel(layer.mask, 0, 0, psb);
+          rec.channels.push(m.channel);
+          rec.mask = m.mask;
+        }
+        records.push(rec);
+        return;
+      }
       case "annotation":
         throw new PsdError(`Annotation layer "${layer.name}" must be rasterized before export.`);
     }
@@ -6883,6 +7730,17 @@ function exportPsd(input) {
     }
     if (embed.length) globalBlocks.push({ key: "Patt", data: writePatternBlock(embed) });
   }
+  if (linkedFiles.size) {
+    const parts = [...linkedFiles].map(([uuid, f]) => encodeLinkedFile({ uuid, name: f.name, bytes: f.bytes }));
+    const data = new Uint8Array(parts.reduce((n2, p) => n2 + p.length, 0));
+    let at = 0;
+    for (const p of parts) {
+      data.set(p, at);
+      at += p.length;
+    }
+    globalBlocks.push({ key: "lnk2", data });
+  }
+  if (filterItems.length) globalBlocks.push({ key: "FEid", data: writeFilterEffects(filterItems) });
   const bytes = writePsd(
     {
       header: { psb, channels: planes.length, width, height, depth: 8, colorMode: 3 },
@@ -7147,23 +8005,24 @@ export {
   deserializeLayer,
   deserializeLayers,
   PsdError,
+  decodePlanes,
+  encodeRle,
   parseVersionedDescriptor,
   versionedDescriptorBytes,
   ADJUSTMENT_KEYS,
   SUPPORTED_ADJUSTMENT_KEYS,
   parseAdjustmentBlock,
   writeAdjustmentBlock,
-  decodePlanes,
-  encodeRle,
+  parseLfx2,
+  writeLfx2,
+  parseLrfx,
+  BROWSER_IMAGE_TYPES,
   readPsd,
   layerName,
   layerTree,
   decodeLayerChannel,
   decodeMergedImage,
   writePsd,
-  parseLfx2,
-  writeLfx2,
-  parseLrfx,
   PATTERN_BLOCK_KEYS,
   parsePatternBlock,
   psdPatternToEffectPattern,
@@ -7171,6 +8030,7 @@ export {
   PSD_BLEND_KEYS,
   psdToLayers,
   importPsd,
+  smartContentsFile,
   exportPsd
 };
-//# sourceMappingURL=chunk-NQLQ2JOI.js.map
+//# sourceMappingURL=chunk-4X5MIVCE.js.map