@pixerate/editor 0.111.0 → 0.113.0

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

@@ -522,20 +522,20 @@ function hitTestCrop(canvasPt, state, vpWidth, vpHeight, handleThreshold = 14, c
 }
 function hitTestCropRect(canvasPt, rect, handleThreshold) {
   const { x, y, width: w, height: h } = rect;
-  const px = canvasPt.x;
+  const px2 = canvasPt.x;
   const py = canvasPt.y;
   const dist = (x1, y1, x2, y2) => Math.hypot(x1 - x2, y1 - y2);
-  if (dist(px, py, x, y) <= handleThreshold) return "nw";
-  if (dist(px, py, x + w, y) <= handleThreshold) return "ne";
-  if (dist(px, py, x + w, y + h) <= handleThreshold) return "se";
-  if (dist(px, py, x, y + h) <= handleThreshold) return "sw";
-  const nearX = px >= x - handleThreshold && px <= x + w + handleThreshold;
+  if (dist(px2, py, x, y) <= handleThreshold) return "nw";
+  if (dist(px2, py, x + w, y) <= handleThreshold) return "ne";
+  if (dist(px2, py, x + w, y + h) <= handleThreshold) return "se";
+  if (dist(px2, py, x, y + h) <= handleThreshold) return "sw";
+  const nearX = px2 >= x - handleThreshold && px2 <= x + w + handleThreshold;
   const nearY = py >= y - handleThreshold && py <= y + h + handleThreshold;
   if (nearX && Math.abs(py - y) <= handleThreshold) return "n";
   if (nearX && Math.abs(py - (y + h)) <= handleThreshold) return "s";
-  if (nearY && Math.abs(px - x) <= handleThreshold) return "w";
-  if (nearY && Math.abs(px - (x + w)) <= handleThreshold) return "e";
-  if (px >= x && px <= x + w && py >= y && py <= y + h) {
+  if (nearY && Math.abs(px2 - x) <= handleThreshold) return "w";
+  if (nearY && Math.abs(px2 - (x + w)) <= handleThreshold) return "e";
+  if (px2 >= x && px2 <= x + w && py >= y && py <= y + h) {
     return "inside";
   }
   return null;
@@ -2146,8 +2146,8 @@ function applyFastBoxBlur(imageData, radius) {
       let r = 0, g = 0, b = 0, a = 0;
       let count = 0;
       for (let k = -radius; k <= radius; k++) {
-        const px = Math.min(w - 1, Math.max(0, x + k));
-        const idx = (y * w + px) * 4;
+        const px2 = Math.min(w - 1, Math.max(0, x + k));
+        const idx = (y * w + px2) * 4;
         r += src[idx];
         g += src[idx + 1];
         b += src[idx + 2];
@@ -3129,9 +3129,9 @@ function updateLayerFilter(layers, id, filterId, changes) {
   if (i === -1) fail(`Layer "${id}" has no filter "${filterId}". Filters: ${(layer.filters ?? []).map((f) => f.id).join(", ") || "none"}.`);
   const current = layer.filters[i];
   if ("kind" in changes && changes.kind !== current.kind) fail("A filter kind cannot change; remove it and add another.");
-  const merged = normalizeFilter({ ...current, ...changes, kind: current.kind }, current.id);
+  const merged2 = normalizeFilter({ ...current, ...changes, kind: current.kind }, current.id);
   const filters = [...layer.filters];
-  filters[i] = merged;
+  filters[i] = merged2;
   return mapLayer(layers, id, () => ({ ...layer, filters }));
 }
 function removeLayerFilter(layers, id, filterId) {
@@ -3418,7 +3418,8 @@ function shapeGeometry(layer) {
       bounds = { x: x0, y: y0, width: Math.max(bounds.x + bounds.width, b.x + b.width) - x0, height: Math.max(bounds.y + bounds.height, b.y + b.height) - y0 };
     }
   };
-  if (layer.fill) for (const f of fills) add(flatBounds(f.flat));
+  if (layer.fill && layer.inverted) add({ x: -1e7, y: -1e7, width: 2e7, height: 2e7 });
+  else if (layer.fill) for (const f of fills) add(flatBounds(f.flat));
   if (stroke) add(flatBounds(stroke));
   const g = shapeGeometryBounds(layer) ?? { x: 0, y: 0, width: 0, height: 0 };
   const frame = { x: Math.floor(g.x), y: Math.floor(g.y), width: Math.max(1, Math.ceil(g.x + g.width) - Math.floor(g.x)), height: Math.max(1, Math.ceil(g.y + g.height) - Math.floor(g.y)) };
@@ -3426,8 +3427,14 @@ function shapeGeometry(layer) {
   geometryCache.set(layer, geo);
   return geo;
 }
-function fillCoverage(geo, rect, rule) {
+function fillCoverage(geo, rect, rule, inverted = false) {
   const n = rect.width * rect.height;
+  if (inverted) {
+    const area = fillCoverage(geo, rect, rule);
+    const out = new Float32Array(n);
+    for (let i = 0; i < n; i++) out[i] = 1 - (area ? area[i] : 0);
+    return out;
+  }
   let acc = null;
   geo.fills.forEach((f, i) => {
     const cov = f.flat.length > 1 ? rasterizeCoverageSampled(f.flat, rect, rule) : rasterizeCoverage(f.flat, rect, rule);
@@ -3465,7 +3472,7 @@ function renderShapeRect(layer, rect, env, ctx = paintContext(env)) {
   const n = rect.width * rect.height;
   const rule = layer.fillRule ?? "nonzero";
   const needArea = Boolean(layer.fill) || geo.stroke !== null && geo.align !== "center";
-  const area = needArea ? fillCoverage(geo, rect, rule) : null;
+  const area = needArea ? fillCoverage(geo, rect, rule, Boolean(layer.inverted && layer.fill)) : null;
   let sCov = geo.stroke ? rasterizeCoverageSampled(geo.stroke, rect, "nonzero") : null;
   if (sCov && geo.align === "inside") sCov = area ? combineCoverage(sCov, area, "intersect", n) : null;
   else if (sCov && geo.align === "outside" && area) sCov = combineCoverage(sCov, area, "subtract", n);
@@ -3522,9 +3529,9 @@ function renderShape(layer, env, options = {}) {
   const tiles = /* @__PURE__ */ new Map();
   for (const { tx, ty } of tilesInRect(region)) {
     const rect = { x: tx * TILE, y: ty * TILE, width: TILE, height: TILE };
-    const px = renderShapeRect(layer, rect, env, ctx);
-    if (!px) continue;
-    const tile = finishTile(px, 4, 0);
+    const px2 = renderShapeRect(layer, rect, env, ctx);
+    if (!px2) continue;
+    const tile = finishTile(px2, 4, 0);
     if (tile) tiles.set(tileKey(tx, ty), tile);
   }
   return new TiledSurface(4, tiles, 0);
@@ -3755,6 +3762,7 @@ function createShapeLayer(init, env, id = newLayerId()) {
     offset: { x: 0, y: 0 }
   };
   if (init.fillRule && init.fillRule !== "nonzero") layer.fillRule = init.fillRule;
+  if (init.inverted) layer.inverted = true;
   return rerenderShape(layer, env);
 }
 function defaultShapeName(c) {
@@ -3807,7 +3815,7 @@ function mergeShapeComponents(components, fillRule = "nonzero") {
   return [{ op: "combine", subpaths }];
 }
 function shapeAsPixelLayer(layer) {
-  const { components: _c, fillRule: _r, fill: _f, stroke: _s, annotation: _a, psd: _p, type: _t, ...rest } = layer;
+  const { components: _c, fillRule: _r, inverted: _i, fill: _f, stroke: _s, annotation: _a, psd: _p, type: _t, ...rest } = layer;
   return { ...rest, type: "pixel", surface: layer.surface, offset: { x: 0, y: 0 } };
 }
 function annotationPaint(color, opacity) {
@@ -4302,16 +4310,16 @@ function renderOutlines(layer, shaper, region) {
       }
     }
     if (!any) continue;
-    const px = new Uint8ClampedArray(n * 4);
+    const px2 = new Uint8ClampedArray(n * 4);
     for (let i = 0; i < n * 4; i += 4) {
       const a = Math.round(acc[i + 3] * 255);
       if (!a) continue;
-      px[i] = Math.round(acc[i]);
-      px[i + 1] = Math.round(acc[i + 1]);
-      px[i + 2] = Math.round(acc[i + 2]);
-      px[i + 3] = a;
+      px2[i] = Math.round(acc[i]);
+      px2[i + 1] = Math.round(acc[i + 1]);
+      px2[i + 2] = Math.round(acc[i + 2]);
+      px2[i + 3] = a;
     }
-    const tile = finishTile(px, 4, 0);
+    const tile = finishTile(px2, 4, 0);
     if (tile) tiles.set(tileKey(tx, ty), tile);
   }
   return new TiledSurface(4, tiles, 0);
@@ -5581,7 +5589,7 @@ function updateSmartFilter(layers, id, filterId, changes, canvas) {
   const i = requireFilter(layer, filterId);
   const current = layer.smartFilters.filters[i];
   if ("kind" in changes && changes.kind !== current.kind) fail4("A smart filter kind cannot change; remove it and add another.");
-  let merged;
+  let merged2;
   if (current.kind === "psd") {
     const extra = Object.keys(changes).filter((k) => !["enabled", "blend", "opacity", "kind"].includes(k));
     if (extra.length) fail4(`"${current.name}" is a Photoshop filter we keep but do not model; only enabled, blend and opacity change. Unknown: ${extra.join(", ")}.`);
@@ -5589,14 +5597,14 @@ function updateSmartFilter(layers, id, filterId, changes, canvas) {
     if (!isBlendMode(blend) || blend === "pigment") fail4(`Unknown blend mode "${String(blend)}" for a smart filter.`);
     const opacity = changes.opacity ?? current.opacity;
     if (!(typeof opacity === "number" && opacity >= 0 && opacity <= 1)) fail4("opacity must be a number from 0 to 1.");
-    merged = { ...current, enabled: changes.enabled === void 0 ? current.enabled : Boolean(changes.enabled), blend, opacity };
+    merged2 = { ...current, enabled: changes.enabled === void 0 ? current.enabled : Boolean(changes.enabled), blend, opacity };
   } else {
-    merged = normalizeSmartFilter({ ...current, ...changes, kind: current.kind }, current.id);
+    merged2 = normalizeSmartFilter({ ...current, ...changes, kind: current.kind }, current.id);
   }
   const filters = [...layer.smartFilters.filters];
-  filters[i] = merged;
+  filters[i] = merged2;
   const next = withStack(layer, { ...layer.smartFilters, filters }, canvas);
-  return { layers: mapLayer(layers, id, () => next), layer: next, filter: merged };
+  return { layers: mapLayer(layers, id, () => next), layer: next, filter: merged2 };
 }
 function removeSmartFilter(layers, id, filterId, canvas) {
   const layer = editableSmart(layers, id);
@@ -5782,6 +5790,7 @@ function serializeType(layer, base, ctx) {
     out.psd = {};
     if (layer.psd.tySh) out.psd.tySh = bytesToBase64(layer.psd.tySh);
     if (layer.psd.blocks?.length) out.psd.blocks = layer.psd.blocks.map((b) => ({ key: b.key, data: bytesToBase64(b.data) }));
+    if (layer.psd.signature) out.psd.signature = layer.psd.signature;
   }
   return out;
 }
@@ -5820,6 +5829,7 @@ function readType(r, base, ctx) {
       const psd = {};
       if (typeof r.psd.tySh === "string") psd.tySh = base64ToBytes(r.psd.tySh);
       if (Array.isArray(r.psd.blocks)) psd.blocks = r.psd.blocks.filter((b) => b && typeof b.key === "string" && typeof b.data === "string").map((b) => ({ key: b.key, data: base64ToBytes(b.data) }));
+      if (typeof r.psd.signature === "string") psd.signature = r.psd.signature;
       if (psd.tySh || psd.blocks?.length) layer.psd = psd;
     }
     if (typeof r.asset === "string") return { ...layer, surface: readSurface(r.asset, r.x, r.y, 4, 0, ctx, label), rendering: "stored" };
@@ -5843,9 +5853,10 @@ function serializeShape(layer, base) {
     stroke: layer.stroke ? JSON.parse(JSON.stringify(layer.stroke)) : null
   };
   if (layer.fillRule === "evenodd") out.fillRule = "evenodd";
+  if (layer.inverted) out.inverted = true;
   if (layer.fillOpacity !== void 0 && layer.fillOpacity !== 1) out.fillOpacity = layer.fillOpacity;
   if (layer.annotation) out.annotation = JSON.parse(JSON.stringify(layer.annotation));
-  if (layer.psd?.blocks?.length) out.psd = { blocks: layer.psd.blocks.map((b) => ({ key: b.key, data: bytesToBase64(b.data) })) };
+  if (layer.psd?.blocks?.length) out.psd = { blocks: layer.psd.blocks.map((b) => ({ key: b.key, data: bytesToBase64(b.data) })), ...layer.psd.signature ? { signature: layer.psd.signature } : {} };
   return out;
 }
 function readShape(r, base, ctx) {
@@ -5872,13 +5883,14 @@ function readShape(r, base, ctx) {
         stroke: r.stroke === null || r.stroke === void 0 ? null : normalizeShapeStroke(r.stroke, "stroke")
       };
     }
-    const layer = createShapeLayer({ ...data, fillRule: r.fillRule === "evenodd" ? "evenodd" : "nonzero" }, env, base.id);
+    const layer = createShapeLayer({ ...data, fillRule: r.fillRule === "evenodd" ? "evenodd" : "nonzero", inverted: r.inverted === true && !a }, env, base.id);
     const out = { ...layer, ...base, type: "shape", components: layer.components, fill: layer.fill, stroke: layer.stroke, surface: layer.surface, offset: { x: 0, y: 0 } };
     if (typeof r.fillOpacity === "number" && r.fillOpacity !== 1) out.fillOpacity = num2(r.fillOpacity, 0, 1, 1);
     if (a && shapeFromAnnotation(a)) out.annotation = a;
     if (r.psd && Array.isArray(r.psd.blocks)) {
       const blocks = r.psd.blocks.filter((b) => b && typeof b.key === "string" && typeof b.data === "string").map((b) => ({ key: b.key, data: base64ToBytes(b.data) }));
       if (blocks.length) out.psd = { blocks };
+      if (out.psd && typeof r.psd.signature === "string") out.psd.signature = r.psd.signature;
     }
     return out;
   } catch (e) {
@@ -6035,8 +6047,8 @@ function readSurface(ref, x, y, channels, defaultValue, ctx, what) {
     return emptySurface(channels, defaultValue);
   }
   try {
-    const px = (ctx.decodeAsset ?? decodePngDataUrl)(url, channels);
-    return surfaceFromPixels(px, channels, Math.round(num2(x, -1e7, 1e7, 0)), Math.round(num2(y, -1e7, 1e7, 0)), defaultValue);
+    const px2 = (ctx.decodeAsset ?? decodePngDataUrl)(url, channels);
+    return surfaceFromPixels(px2, channels, Math.round(num2(x, -1e7, 1e7, 0)), Math.round(num2(y, -1e7, 1e7, 0)), defaultValue);
   } catch (err) {
     ctx.problems.push(`${what}: asset "${ref}" could not be decoded (${err.message})`);
     return emptySurface(channels, defaultValue);
@@ -6358,8 +6370,8 @@ var PsdReader = class _PsdReader {
     return v;
   }
   /** A length field: 8 bytes in PSB where the format says so, else 4. */
-  len(long4) {
-    return long4 ? this.u64() : this.u32();
+  len(long5) {
+    return long5 ? this.u64() : this.u32();
   }
   bytes(n) {
     this.need(n, `${n} bytes`);
@@ -6466,11 +6478,11 @@ var PsdWriter = class {
     this.length += n;
   }
   /** Reserves a length field; `endLen` fills it with the bytes written since. */
-  beginLen(long4) {
+  beginLen(long5) {
     const at = this.length;
-    if (long4) this.u64(0);
+    if (long5) this.u64(0);
     else this.u32(0);
-    return { at, long: long4 };
+    return { at, long: long5 };
   }
   endLen(mark) {
     const n = this.length - mark.at - (mark.long ? 8 : 4);
@@ -6515,162 +6527,6 @@ 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"]);
@@ -6786,12 +6642,12 @@ function readValue(r, depth) {
     case "UntF":
       return { type, unit: r.ascii(4), value: r.f64() };
     case "UnFl": {
-      const unit3 = r.ascii(4);
+      const unit4 = 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: unit3, values };
+      return { type, unit: unit4, values };
     }
     case "TEXT":
       return { type, value: r.unicode() };
@@ -7244,11 +7100,11 @@ function writeAdjustmentBlock(kind, params) {
     case "blackWhite": {
       const p = params;
       const tint = p.tint ? hexToRgb(p.tint) : BW_TINT;
-      const dbl3 = (v) => ({ type: "doub", value: clamp2(v, 0, 1) * 255 });
+      const dbl4 = (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  ", dbl3(tint[0])], ["Grn ", dbl3(tint[1])], ["Bl  ", dbl3(tint[2])]]) }],
+        ["tintColor", { type: "Objc", value: descriptor("RGBC", [["Rd  ", dbl4(tint[0])], ["Grn ", dbl4(tint[1])], ["Bl  ", dbl4(tint[2])]]) }],
         ["bwPresetKind", { type: "long", value: 1 }],
         ["blackAndWhitePresetFileName", { type: "TEXT", value: "" }]
       );
@@ -7270,83 +7126,1423 @@ function writeAdjustmentBlock(kind, params) {
   throw new Error(`Unknown adjustment kind "${kind}".`);
 }
 
-// src/image-editor/psd/smart.ts
-var dbl = (value) => ({ type: "doub", value });
+// src/image-editor/psd/paths.ts
+var RECORD = 26;
+var fixed = (v) => v / 16777216;
+var toFixed = (v) => Math.max(-2147483648, Math.min(2147483647, Math.round(v * 16777216)));
+function readPathRecords(data) {
+  const r = new PsdReader(data);
+  const subpaths = [];
+  let initialFill = false;
+  let remaining = 0;
+  while (r.remaining >= RECORD) {
+    const selector = r.u16();
+    const body = r.sub(24);
+    if (selector === 0 || selector === 3) {
+      remaining = body.u16();
+      subpaths.push({ closed: selector === 0, operation: body.i16(), knots: [] });
+    } else if (selector === 1 || selector === 2 || selector === 4 || selector === 5) {
+      const closed = selector <= 2;
+      const last = subpaths[subpaths.length - 1];
+      if (remaining === 0 && (!last || last.closed !== closed)) subpaths.push({ closed, operation: -1, knots: [] });
+      remaining = Math.max(0, remaining - 1);
+      const pt = () => {
+        const y = fixed(body.i32());
+        const x = fixed(body.i32());
+        return { x, y };
+      };
+      const pre = pt();
+      const anchor = pt();
+      const post = pt();
+      subpaths[subpaths.length - 1].knots.push({ linked: selector === 1 || selector === 4, pre, anchor, post });
+    } else if (selector === 8) {
+      initialFill = body.u16() !== 0;
+    }
+  }
+  return { subpaths, initialFill };
+}
+function writePathRecords(path) {
+  const w = new PsdWriter();
+  w.u16(6);
+  w.zeros(24);
+  w.u16(8);
+  w.u16(path.initialFill ? 1 : 0);
+  w.zeros(22);
+  for (const s of path.subpaths) {
+    w.u16(s.closed ? 0 : 3);
+    w.u16(Math.min(s.knots.length, 65535));
+    w.i16(s.operation);
+    w.u16(1);
+    w.zeros(18);
+    for (const k of s.knots.slice(0, 65535)) {
+      w.u16(s.closed ? k.linked ? 1 : 2 : k.linked ? 4 : 5);
+      for (const p of [k.pre, k.anchor, k.post]) {
+        w.i32(toFixed(p.y));
+        w.i32(toFixed(p.x));
+      }
+    }
+  }
+  return w.result();
+}
+var VMSK_INVERT = 1;
+function readVectorBlock(data) {
+  if (data.length < 8) return null;
+  const r = new PsdReader(data);
+  const version = r.u32();
+  const flags = r.u32();
+  return { version, flags, path: readPathRecords(data.subarray(8)) };
+}
+function writeVectorBlock(path, flags = 0) {
+  const body = writePathRecords(path);
+  const w = new PsdWriter();
+  w.u32(3);
+  w.u32(flags);
+  w.bytes(body);
+  return w.result();
+}
+var OP_TO_PSD = { combine: 1, subtract: 2, intersect: 3, exclude: 0 };
+var OP_FROM_PSD = (v) => v === 0 ? "exclude" : v === 2 ? "subtract" : v === 3 ? "intersect" : "combine";
+function componentsFromVectorBlock(data, width, height) {
+  const block = readVectorBlock(data);
+  if (!block) return null;
+  const pt = (p) => ({ x: p.x * width, y: p.y * height });
+  const comps = [];
+  for (const s of block.path.subpaths) {
+    if (!s.knots.length) continue;
+    const anchors = s.knots.map((k) => {
+      const a = pt(k.anchor);
+      const pre = pt(k.pre);
+      const post = pt(k.post);
+      const out = { x: a.x, y: a.y };
+      if (pre.x !== a.x || pre.y !== a.y) out.in = pre;
+      if (post.x !== a.x || post.y !== a.y) out.out = post;
+      if (k.linked && (out.in || out.out)) out.type = "smooth";
+      return out;
+    });
+    const sp = { closed: s.closed, anchors };
+    if (s.operation === -1 && comps.length) comps[comps.length - 1].subpaths.push(sp);
+    else comps.push({ op: s.operation, subpaths: [sp] });
+  }
+  let inverted = comps.length ? comps[0].op === 2 : block.path.initialFill;
+  const components = comps.map((c, i) => {
+    let op = i === 0 ? "combine" : OP_FROM_PSD(c.op);
+    if (inverted && i > 0) op = op === "combine" ? "subtract" : op === "subtract" ? "combine" : op;
+    return { op, subpaths: c.subpaths };
+  });
+  if (block.flags & VMSK_INVERT) inverted = !inverted;
+  return { components, inverted, flags: block.flags };
+}
+function vectorBlockForComponents(components, inverted, width, height, flags = 0) {
+  const w = Math.max(1, width);
+  const h = Math.max(1, height);
+  const fr = (p) => ({ x: p.x / w, y: p.y / h });
+  const subpaths = [];
+  components.forEach((c, ci) => {
+    expandVectorCorners(c.subpaths).forEach((sp, si) => {
+      if (!sp.anchors.length) return;
+      subpaths.push({
+        closed: sp.closed,
+        operation: si > 0 ? -1 : ci === 0 ? 1 : OP_TO_PSD[c.op],
+        knots: sp.anchors.map((a) => ({
+          linked: a.type === "smooth" || a.type === "symmetric",
+          pre: fr(a.in ?? a),
+          anchor: fr(a),
+          post: fr(a.out ?? a)
+        }))
+      });
+    });
+  });
+  return writeVectorBlock({ subpaths, initialFill: subpaths.length === 0 && inverted }, flags & ~VMSK_INVERT | (inverted && subpaths.length ? VMSK_INVERT : 0));
+}
+
+// src/image-editor/psd/shapes.ts
+var SHAPE_PSD_KEYS = ["vsms", "vmsk", "vscg", "vstk", "vogk", "SoCo", "GdFl", "PtFl"];
 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 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;
+function read(data) {
+  try {
+    return parseVersionedDescriptor(data);
+  } catch {
+    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");
+function px(v, dpi) {
+  if (!v) return void 0;
+  if (v.type === "UntF") {
+    if (v.unit === "#Pnt") return v.value * dpi / 72;
+    if (v.unit === "#Mlm") return v.value * dpi / 25.4;
+    return v.value;
   }
-  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+  if (v.type === "doub" || v.type === "long") return v.value;
+  return void 0;
 }
-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;
-    }
-    void version;
+function paintFromContent(key, d, notes) {
+  if (key === "SoCo") return { type: "color", color: colorOf(descObject(d, "Clr ")) };
+  if (key === "GdFl") return { type: "gradient", gradient: gradientOf(d, notes) };
+  if (key === "PtFl") {
+    const ref = patternRefOf(d);
+    const place = placementOf(d);
+    const scale = (descNumber(d, "Scl ") ?? 100) / 100;
+    const p = { type: "pattern", patternId: ref.patternId, name: ref.name, scale: Math.max(0.01, Math.min(10, scale)) };
+    if (place.angle) p.angle = place.angle;
+    if (!place.link) p.link = false;
+    if (place.phase.x || place.phase.y) p.phase = place.phase;
+    return p;
   }
-  return { kind, uuid, name, fileType, bytes: new Uint8Array(0), path: path ?? name };
+  return null;
 }
-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 {
+function contentOfPaint(p) {
+  if (p.type === "color") return { key: "SoCo", desc: descriptor("null", [["Clr ", obj(colorDesc(p.color))]]) };
+  if (p.type === "gradient") return { key: "GdFl", desc: descriptor("null", gradientItems(p.gradient)) };
+  return {
+    key: "PtFl",
+    desc: descriptor("null", [["Ptrn", patternRefDesc(p.patternId, p.name)], ["Scl ", unit("#Prc", p.scale * 100)], ...placementItems(p.angle ?? 0, p.link ?? true, p.phase ?? { x: 0, y: 0 })])
+  };
+}
+function paintFromVscg(data, notes) {
+  if (data.length < 8) return null;
+  const key = String.fromCharCode(...data.subarray(0, 4));
+  const d = read(data.subarray(4));
+  return d ? paintFromContent(key, d, notes) : null;
+}
+function vscgBytes(p) {
+  const { key, desc } = contentOfPaint(p);
+  const body = versionedDescriptorBytes(desc);
+  const out = new Uint8Array(4 + body.length);
+  for (let i = 0; i < 4; i++) out[i] = key.charCodeAt(i);
+  out.set(body, 4);
+  return out;
+}
+function classOfContent(d) {
+  if (d.classId === "solidColorLayer" || descGet(d, "Clr ")) return "SoCo";
+  if (d.classId === "gradientLayer" || descGet(d, "Grad")) return "GdFl";
+  return "PtFl";
+}
+function strokeFromVstk(data, dpi, notes) {
+  const d = read(data);
+  if (!d) return null;
+  const fillEnabled = descBool(d, "fillEnabled") !== false;
+  if (descBool(d, "strokeEnabled") !== true) return { stroke: null, fillEnabled };
+  const content = descObject(d, "strokeStyleContent");
+  const paint = (content ? paintFromContent(classOfContent(content), content, notes) : null) ?? { type: "color", color: "#000000" };
+  const opacity = (descNumber(d, "strokeStyleOpacity") ?? 100) / 100;
+  const stroke = { width: px(descGet(d, "strokeStyleLineWidth"), dpi) ?? 1, paint: opacity < 1 ? { ...paint, opacity } : paint };
+  const cap = enumOf(d, "strokeStyleLineCapType");
+  if (cap === "strokeStyleRoundCap") stroke.cap = "round";
+  else if (cap === "strokeStyleSquareCap") stroke.cap = "square";
+  const join = enumOf(d, "strokeStyleLineJoinType");
+  if (join === "strokeStyleRoundJoin") stroke.join = "round";
+  else if (join === "strokeStyleBevelJoin") stroke.join = "bevel";
+  const align = enumOf(d, "strokeStyleLineAlignment");
+  if (align === "strokeStyleAlignInside") stroke.align = "inside";
+  else if (align === "strokeStyleAlignOutside") stroke.align = "outside";
+  const miter = descNumber(d, "strokeStyleMiterLimit");
+  if (miter !== void 0 && miter !== 100) stroke.miterLimit = Math.max(1, Math.min(500, miter));
+  const dashes = descGet(d, "strokeStyleLineDashSet");
+  if (dashes?.type === "VlLs") {
+    const list2 = dashes.items.map((v) => v.type === "UntF" || v.type === "doub" || v.type === "long" ? v.value : NaN).filter((v) => Number.isFinite(v) && v >= 0);
+    if (list2.length && list2.some((v) => v > 0)) stroke.dashes = list2;
+  }
+  const offset = descNumber(d, "strokeStyleLineDashOffset");
+  if (offset) stroke.dashOffset = offset;
+  if (enumOf(d, "strokeStyleBlendMode") && enumOf(d, "strokeStyleBlendMode") !== "Nrml" && enumOf(d, "strokeStyleBlendMode") !== "normal") notes.add("a shape stroke blend mode other than Normal became Normal");
+  return { stroke, fillEnabled };
+}
+function vstkBytes(stroke, fillEnabled, dpi) {
+  const s = stroke ?? { width: 3, paint: { type: "color", color: "#000000" } };
+  const { key, desc } = contentOfPaint(s.paint);
+  const content = { ...desc, classId: key === "SoCo" ? "solidColorLayer" : key === "GdFl" ? "gradientLayer" : "patternLayer" };
+  const d = descriptor("strokeStyle", [
+    ["strokeStyleVersion", long2(2)],
+    ["strokeEnabled", boolV(Boolean(stroke))],
+    ["fillEnabled", boolV(fillEnabled)],
+    ["strokeStyleLineWidth", unit("#Pxl", s.width)],
+    ["strokeStyleLineDashOffset", unit("#Pnt", s.dashOffset ?? 0)],
+    ["strokeStyleMiterLimit", dbl(s.miterLimit ?? 100)],
+    ["strokeStyleLineCapType", enumV("strokeStyleLineCapType", s.cap === "round" ? "strokeStyleRoundCap" : s.cap === "square" ? "strokeStyleSquareCap" : "strokeStyleButtCap")],
+    ["strokeStyleLineJoinType", enumV("strokeStyleLineJoinType", s.join === "round" ? "strokeStyleRoundJoin" : s.join === "bevel" ? "strokeStyleBevelJoin" : "strokeStyleMiterJoin")],
+    ["strokeStyleLineAlignment", enumV("strokeStyleLineAlignment", s.align === "inside" ? "strokeStyleAlignInside" : s.align === "outside" ? "strokeStyleAlignOutside" : "strokeStyleAlignCenter")],
+    ["strokeStyleScaleLock", boolV(false)],
+    ["strokeStyleStrokeAdjust", boolV(false)],
+    ["strokeStyleLineDashSet", { type: "VlLs", items: (s.dashes ?? []).map((v) => unit("#Nne", v)) }],
+    ["strokeStyleBlendMode", enumV("BlnM", "Nrml")],
+    ["strokeStyleOpacity", unit("#Prc", (s.paint.opacity ?? 1) * 100)],
+    ["strokeStyleContent", obj(content)],
+    ["strokeStyleResolution", dbl(dpi)]
+  ]);
+  return versionedDescriptorBytes(d);
+}
+function rectOf(o) {
+  const b = descObject(o, "keyOriginShapeBBox");
+  if (!b) return null;
+  const t = descNumber(b, "Top ");
+  const l = descNumber(b, "Left");
+  const bt = descNumber(b, "Btom");
+  const r = descNumber(b, "Rght");
+  if ([t, l, bt, r].some((v) => v === void 0 || !Number.isFinite(v))) return null;
+  return { x: l, y: t, width: r - l, height: bt - t };
+}
+function pointOf(o, key) {
+  const p = descObject(o, key);
+  const x = p && descNumber(p, "Hrzn");
+  const y = p && descNumber(p, "Vrtc");
+  return x !== void 0 && y !== void 0 && Number.isFinite(x) && Number.isFinite(y) ? { x, y } : null;
+}
+function liveShapesFromVogk(data) {
+  const out = /* @__PURE__ */ new Map();
+  if (data.length < 8) return out;
+  const d = read(data.subarray(4));
+  const list2 = d && descGet(d, "keyDescriptorList");
+  if (!list2 || list2.type !== "VlLs") return out;
+  list2.items.forEach((item, i) => {
+    if (item.type !== "Objc") return;
+    const o = item.value;
+    if (descBool(o, "keyShapeInvalidated") === true) return;
+    const index = descNumber(o, "keyOriginIndex") ?? i;
+    let transform;
+    const t = descObject(o, "Trnf");
+    if (t) {
+      const g = (k, dv) => descNumber(t, k) ?? dv;
+      const m = [g("xx", 1), g("xy", 0), g("yx", 0), g("yy", 1), g("tx", 0), g("ty", 0)];
+      if (!(m[0] === 1 && m[1] === 0 && m[2] === 0 && m[3] === 1 && m[4] === 0 && m[5] === 0)) transform = m;
+    }
+    const tt = transform ? { transform } : {};
+    const type = descNumber(o, "keyOriginType");
+    let live = null;
+    const r = rectOf(o);
+    if ((type === 1 || type === 2) && r) {
+      const rr = type === 2 ? descObject(o, "keyOriginRRectRadii") : void 0;
+      const g = (k) => rr ? descNumber(rr, k) ?? 0 : 0;
+      const radii = [g("topLeft"), g("topRight"), g("bottomRight"), g("bottomLeft")];
+      live = { kind: "rect", ...r, ...radii.some((v) => v > 0) ? { radii } : {}, ...tt };
+    } else if (type === 5 && r) live = { kind: "ellipse", ...r, ...tt };
+    else if (type === 4) {
+      const a = pointOf(o, "keyOriginLineStart");
+      const b = pointOf(o, "keyOriginLineEnd");
+      if (a && b) {
+        const weight = descNumber(o, "keyOriginLineWeight") ?? 1;
+        const line = { kind: "line", x1: a.x, y1: a.y, x2: b.x, y2: b.y, weight, ...tt };
+        const head = () => {
+          const w = (descNumber(o, "keyOriginLineArrWdth") ?? 500) / 100 * weight;
+          const l = (descNumber(o, "keyOriginLineArrLngth") ?? 1e3) / 100 * weight;
+          const c = (descNumber(o, "keyOriginLineArrConc") ?? 0) / 100;
+          return c ? { width: w, length: l, concavity: Math.max(-0.5, Math.min(0.5, c)) } : { width: w, length: l };
+        };
+        if (descBool(o, "keyOriginLineArrowSt") === true) line.startArrow = head();
+        if (descBool(o, "keyOriginLineArrowEnd") === true) line.endArrow = head();
+        live = line;
+      }
+    }
+    if (live) out.set(index, live);
+  });
+  return out;
+}
+function vogkBytes(components, dpi) {
+  const bbox = (r) => obj(
+    descriptor("unitRect", [
+      ["unitValueQuadVersion", long2(1)],
+      ["Top ", unit("#Pxl", r.y)],
+      ["Left", unit("#Pxl", r.x)],
+      ["Btom", unit("#Pxl", r.y + r.height)],
+      ["Rght", unit("#Pxl", r.x + r.width)]
+    ])
+  );
+  const items = [];
+  components.forEach((c, index) => {
+    const live = c.live;
+    if (!live || live.kind === "polygon" || live.kind === "star") return;
+    const base = (type) => [
+      ["keyOriginType", long2(type)],
+      ["keyOriginResolution", dbl(dpi)]
+    ];
+    let o;
+    if (live.kind === "rect") {
+      const radii = live.radii ?? [0, 0, 0, 0];
+      if (radii.every((v) => v === 0)) o = [...base(1), ["keyOriginShapeBBox", bbox(live)]];
+      else
+        o = [
+          ...base(2),
+          [
+            "keyOriginRRectRadii",
+            obj(
+              descriptor("radii", [
+                ["unitValueQuadVersion", long2(1)],
+                ["topRight", unit("#Pxl", radii[1])],
+                ["topLeft", unit("#Pxl", radii[0])],
+                ["bottomLeft", unit("#Pxl", radii[3])],
+                ["bottomRight", unit("#Pxl", radii[2])]
+              ])
+            )
+          ],
+          ["keyOriginShapeBBox", bbox(live)]
+        ];
+    } else if (live.kind === "ellipse") o = [...base(5), ["keyOriginShapeBBox", bbox(live)]];
+    else {
+      const pnt = (x, y) => obj(descriptor("Pnt ", [["Hrzn", dbl(x)], ["Vrtc", dbl(y)]]));
+      const head = live.endArrow ?? live.startArrow;
+      const w = live.weight || 1;
+      o = [
+        ...base(4),
+        ["keyOriginShapeBBox", bbox({ x: Math.min(live.x1, live.x2), y: Math.min(live.y1, live.y2), width: Math.abs(live.x2 - live.x1), height: Math.abs(live.y2 - live.y1) })],
+        ["keyOriginLineEnd", pnt(live.x2, live.y2)],
+        ["keyOriginLineStart", pnt(live.x1, live.y1)],
+        ["keyOriginLineWeight", dbl(live.weight)],
+        ["keyOriginLineArrowSt", boolV(Boolean(live.startArrow))],
+        ["keyOriginLineArrowEnd", boolV(Boolean(live.endArrow))],
+        ["keyOriginLineArrWdth", dbl(head ? head.width / w * 100 : 0)],
+        ["keyOriginLineArrLngth", dbl(head ? head.length / w * 100 : 0)],
+        ["keyOriginLineArrConc", long2(head?.concavity ? head.concavity * 100 : 0)]
+      ];
+    }
+    const m = live.transform;
+    if (m) {
+      o.push([
+        "Trnf",
+        obj(
+          descriptor("Trnf", [
+            ["xx", dbl(m[0])],
+            ["xy", dbl(m[1])],
+            ["yx", dbl(m[2])],
+            ["yy", dbl(m[3])],
+            ["tx", dbl(m[4])],
+            ["ty", dbl(m[5])]
+          ])
+        )
+      ]);
+    }
+    o.push(["keyOriginIndex", long2(index)]);
+    items.push(obj(descriptor("null", o)));
+  });
+  if (!items.length) return null;
+  const body = versionedDescriptorBytes(descriptor("null", [["keyDescriptorList", { type: "VlLs", items }]]));
+  const out = new Uint8Array(4 + body.length);
+  new DataView(out.buffer).setUint32(0, 1);
+  out.set(body, 4);
+  return out;
+}
+function shapeSignature(layer) {
+  return JSON.stringify([layer.components, layer.fill, layer.stroke, layer.fillRule ?? "nonzero", Boolean(layer.inverted)]);
+}
+function shapeFromBlocks(blocks, width, height, dpi, notes) {
+  const block = (k) => blocks.find((b) => b.key === k)?.data;
+  const vector = block("vsms") ?? block("vmsk");
+  const path = vector ? componentsFromVectorBlock(vector, width, height) : null;
+  if (!path) return null;
+  let fill = null;
+  const vscg = block("vscg");
+  if (vscg) fill = paintFromVscg(vscg, notes);
+  for (const key of ["SoCo", "GdFl", "PtFl"]) {
+    if (fill) break;
+    const data = block(key);
+    const d = data && (() => {
+      try {
+        return parseVersionedDescriptor(data);
+      } catch {
+        return null;
+      }
+    })();
+    if (d) fill = paintFromContent(key, d, notes);
+  }
+  let stroke = null;
+  const vstk = block("vstk");
+  if (vstk) {
+    const s = strokeFromVstk(vstk, dpi, notes);
+    if (s) {
+      stroke = s.stroke;
+      if (!s.fillEnabled) fill = null;
+    }
+  }
+  const vogk = block("vogk");
+  const live = vogk ? liveShapesFromVogk(vogk) : /* @__PURE__ */ new Map();
+  const components = path.components.map((c, i) => {
+    const l = live.get(i);
+    return l && sameExtent(liveShapeSubpaths(l), c) ? { ...c, live: l } : c;
+  });
+  return { components, inverted: path.inverted, fill, stroke };
+}
+function sameExtent(sub, c) {
+  const ext = (list2) => {
+    let x0 = Infinity;
+    let y0 = Infinity;
+    let x1 = -Infinity;
+    let y1 = -Infinity;
+    for (const sp of list2) for (const a2 of sp.anchors) {
+      x0 = Math.min(x0, a2.x);
+      y0 = Math.min(y0, a2.y);
+      x1 = Math.max(x1, a2.x);
+      y1 = Math.max(y1, a2.y);
+    }
+    return [x0, y0, x1, y1];
+  };
+  const a = ext(sub);
+  const b = ext(c.subpaths);
+  return a.every((v, i) => Math.abs(v - b[i]) < 1);
+}
+function shapeBlocks(layer, width, height, dpi, notes) {
+  const kept = layer.psd?.blocks;
+  if (kept?.length && layer.psd?.signature === shapeSignature(layer)) return kept.map((b) => ({ key: b.key, data: b.data }));
+  const out = [];
+  out.push({ key: "vsms", data: vectorBlockForComponents(layer.components, Boolean(layer.inverted), width, height) });
+  if (layer.fillRule === "evenodd" && layer.components.some((c) => c.subpaths.length > 1)) notes.add("Even-odd fill rules were written as nonzero (Photoshop fills shapes nonzero)");
+  const fill = layer.fill ?? { type: "color", color: "#000000" };
+  if (layer.fill?.opacity !== void 0 && layer.fill.opacity < 1) notes.add("Shape fill opacity has no PSD equivalent and was written as 100 % (use the layer fill opacity)");
+  out.push({ key: "vscg", data: vscgBytes(fill) });
+  if (layer.stroke || !layer.fill) out.push({ key: "vstk", data: vstkBytes(layer.stroke, Boolean(layer.fill), dpi) });
+  const vogk = vogkBytes(layer.components, dpi);
+  if (vogk) out.push({ key: "vogk", data: vogk });
+  if (layer.components.some((c) => c.live?.kind === "line" && (c.live.startArrow && c.live.endArrow && JSON.stringify(c.live.startArrow) !== JSON.stringify(c.live.endArrow) || false))) {
+    notes.add("Lines with different start and end arrowheads were written with one arrowhead size (Photoshop has one)");
+  }
+  return out;
+}
+
+// src/image-editor/psd/engine-data.ts
+var EngineDataError = class extends Error {
+  constructor(message) {
+    super(`EngineData: ${message}`);
+    this.name = "EngineDataError";
+  }
+};
+var MAX_DEPTH2 = 64;
+var isWs = (c) => c === 32 || c === 9 || c === 13 || c === 10 || c === 0;
+var isDelim = (c) => isWs(c) || c === 91 || c === 93 || c === 60 || c === 62 || c === 40 || c === 47;
+function parseEngineData(b) {
+  let i = 0;
+  const ws = () => {
+    while (i < b.length && isWs(b[i])) i++;
+  };
+  const name = () => {
+    i++;
+    const start = i;
+    while (i < b.length && !isDelim(b[i])) i++;
+    let s = "";
+    for (let k = start; k < i; k++) s += String.fromCharCode(b[k]);
+    return s;
+  };
+  const value = (depth) => {
+    if (depth > MAX_DEPTH2) throw new EngineDataError("nesting too deep");
+    ws();
+    if (i >= b.length) throw new EngineDataError("unexpected end");
+    const c = b[i];
+    if (c === 60 && b[i + 1] === 60) {
+      i += 2;
+      const items = [];
+      for (; ; ) {
+        ws();
+        if (b[i] === 62 && b[i + 1] === 62) {
+          i += 2;
+          return { t: "dict", items };
+        }
+        if (b[i] !== 47) throw new EngineDataError(i >= b.length ? "unterminated dictionary" : `expected a key at byte ${i}`);
+        const k = name();
+        items.push([k, value(depth + 1)]);
+      }
+    }
+    if (c === 91) {
+      i++;
+      const items = [];
+      for (; ; ) {
+        ws();
+        if (i >= b.length) throw new EngineDataError("unterminated array");
+        if (b[i] === 93) {
+          i++;
+          return { t: "array", items };
+        }
+        items.push(value(depth + 1));
+      }
+    }
+    if (c === 40) {
+      i++;
+      const raw = [];
+      for (; ; ) {
+        if (i >= b.length) throw new EngineDataError("unterminated string");
+        const x = b[i];
+        if (x === 92) {
+          if (i + 1 < b.length) raw.push(b[i + 1]);
+          i += 2;
+        } else if (x === 41) {
+          i++;
+          break;
+        } else {
+          raw.push(x);
+          i++;
+        }
+      }
+      return { t: "string", value: decodeString(raw) };
+    }
+    if (c === 47) return { t: "name", value: name() };
+    const start = i;
+    while (i < b.length && !isDelim(b[i])) i++;
+    let tok = "";
+    for (let k = start; k < i; k++) tok += String.fromCharCode(b[k]);
+    if (tok === "true" || tok === "false") return { t: "bool", value: tok === "true" };
+    if (!tok) throw new EngineDataError(`unexpected byte at ${i}`);
+    const n = Number(tok);
+    if (!Number.isFinite(n)) throw new EngineDataError(`bad number "${tok}"`);
+    return /[.eE]/.test(tok) ? { t: "real", value: n } : { t: "int", value: n };
+  };
+  ws();
+  if (b[i] === 47) {
+    const items = [];
+    while (i < b.length) {
+      ws();
+      if (i >= b.length) break;
+      if (b[i] !== 47) throw new EngineDataError(`expected a key at byte ${i}`);
+      const k = name();
+      items.push([k, value(1)]);
+      ws();
+    }
+    return { t: "dict", items };
+  }
+  return value(0);
+}
+function decodeString(raw) {
+  if (raw.length >= 2 && raw[0] === 254 && raw[1] === 255) {
+    let s = "";
+    for (let k = 2; k + 1 < raw.length; k += 2) s += String.fromCharCode(raw[k] << 8 | raw[k + 1]);
+    return s;
+  }
+  return String.fromCharCode(...raw);
+}
+var isContainer = (v) => v.t === "dict" || v.t === "array" && v.items.some((x) => x.t === "dict" || x.t === "array");
+function formatReal(r) {
+  if (!Number.isFinite(r)) return "0.0";
+  if (Number.isInteger(r) && Math.abs(r) < 1e15) return r.toFixed(1);
+  let s = r.toFixed(5);
+  while (s.endsWith("0")) s = s.slice(0, -1);
+  if (s === "0." || s === "-0.") return "0.0";
+  if (s.endsWith(".")) s += "0";
+  return s.replace(/^(-?)0\./, "$1.");
+}
+function writeEngineData(v) {
+  const out = [10, 10];
+  const push = (s) => {
+    for (let k = 0; k < s.length; k++) out.push(s.charCodeAt(k) & 255);
+  };
+  const indent = (n) => {
+    for (let k = 0; k < n; k++) out.push(9);
+  };
+  const write = (x, depth) => {
+    switch (x.t) {
+      case "dict":
+        push("<<\n");
+        for (const [k, val] of x.items) {
+          indent(depth + 1);
+          push(`/${k}`);
+          if (isContainer(val)) {
+            push("\n");
+            indent(depth + 1);
+          } else push(" ");
+          write(val, depth + 1);
+          push("\n");
+        }
+        indent(depth);
+        push(">>");
+        break;
+      case "array":
+        if (isContainer(x)) {
+          push("[\n");
+          for (const item of x.items) {
+            indent(depth);
+            write(item, depth);
+            push("\n");
+          }
+          indent(depth);
+          push("]");
+        } else {
+          push("[");
+          for (const item of x.items) {
+            push(" ");
+            write(item, depth);
+          }
+          push(" ]");
+        }
+        break;
+      case "string": {
+        out.push(40);
+        const raw = [254, 255];
+        for (let k = 0; k < x.value.length; k++) {
+          const u = x.value.charCodeAt(k);
+          raw.push(u >> 8, u & 255);
+        }
+        for (const c of raw) {
+          if (c === 40 || c === 41 || c === 92) out.push(92);
+          out.push(c);
+        }
+        out.push(41);
+        break;
+      }
+      case "int":
+        push(String(Math.round(x.value)));
+        break;
+      case "real":
+        push(formatReal(x.value));
+        break;
+      case "bool":
+        push(x.value ? "true" : "false");
+        break;
+      case "name":
+        push(`/${x.value}`);
+        break;
+    }
+  };
+  write(v, 0);
+  out.push(10);
+  return Uint8Array.from(out);
+}
+var E = {
+  dict: (items = []) => ({ t: "dict", items }),
+  array: (items) => ({ t: "array", items }),
+  str: (value) => ({ t: "string", value }),
+  int: (value) => ({ t: "int", value }),
+  real: (value) => ({ t: "real", value }),
+  bool: (value) => ({ t: "bool", value })
+};
+function eGet(v, key) {
+  return v?.t === "dict" ? v.items.find(([k]) => k === key)?.[1] : void 0;
+}
+function ePath(v, keys) {
+  return keys.reduce((at, k) => eGet(at, k), v);
+}
+function eNum(v) {
+  return v && (v.t === "int" || v.t === "real") ? v.value : void 0;
+}
+function eBool(v) {
+  if (!v) return void 0;
+  if (v.t === "bool") return v.value;
+  if (v.t === "int") return v.value !== 0;
+  return void 0;
+}
+function eStr(v) {
+  return v && (v.t === "string" || v.t === "name") ? v.value : void 0;
+}
+function eArray(v) {
+  return v?.t === "array" ? v.items : [];
+}
+function eSet(d, key, value) {
+  if (d.t !== "dict") return;
+  const at = d.items.findIndex(([k]) => k === key);
+  if (at >= 0) d.items[at] = [key, value];
+  else d.items.push([key, value]);
+}
+function eClone(v) {
+  return JSON.parse(JSON.stringify(v));
+}
+
+// src/image-editor/psd/type.ts
+function parseTySh(data) {
+  try {
+    const r = new PsdReader(data);
+    r.u16();
+    const m = [];
+    for (let k = 0; k < 6; k++) m.push(r.f64());
+    r.u16();
+    const text3 = readVersionedDescriptor(r);
+    let warp = null;
+    if (r.remaining >= 6) {
+      const at = r.pos;
+      try {
+        r.u16();
+        warp = readVersionedDescriptor(r);
+      } catch {
+        r.pos = at;
+      }
+    }
+    return { transform: m, text: text3, warp, tail: r.rest() };
+  } catch {
+    return null;
+  }
+}
+function defaultWarp() {
+  return descriptor("warp", [
+    ["warpStyle", { type: "enum", typeId: "warpStyle", value: "warpNone" }],
+    ["warpValue", { type: "doub", value: 0 }],
+    ["warpPerspective", { type: "doub", value: 0 }],
+    ["warpPerspectiveOther", { type: "doub", value: 0 }],
+    ["warpRotate", { type: "enum", typeId: "Ornt", value: "Hrzn" }]
+  ]);
+}
+function writeTySh(t) {
+  const w = new PsdWriter();
+  w.u16(1);
+  for (const v of t.transform) w.f64(v);
+  w.u16(50);
+  writeVersionedDescriptor(w, t.text);
+  w.u16(1);
+  writeVersionedDescriptor(w, t.warp ?? defaultWarp());
+  if (t.tail.length >= 16) w.bytes(t.tail);
+  else w.zeros(16);
+  return w.result();
+}
+var WEIGHTS = [
+  [/thin|hairline/, 100],
+  [/extralight|ultralight/, 200],
+  [/semibold|demibold|demi/, 600],
+  [/extrabold|ultrabold/, 800],
+  [/black|heavy/, 900],
+  [/bold/, 700],
+  [/medium/, 500],
+  [/light/, 300]
+];
+function fontFromPostScript(ps) {
+  let pro = ps;
+  let style = "";
+  const dash = ps.lastIndexOf("-");
+  if (dash > 0) {
+    pro = ps.slice(0, dash);
+    style = ps.slice(dash + 1);
+    const prev = pro.lastIndexOf("-");
+    if (/^(it|italic|oblique)$/i.test(style) && prev > 0 && /^(thin|hairline|extralight|ultralight|light|regular|roman|book|medium|semibold|demibold|demi|bold|extrabold|ultrabold|heavy|black)$/i.test(pro.slice(prev + 1))) {
+      style = ps.slice(prev + 1);
+      pro = ps.slice(0, prev);
+    }
+  } else {
+    const m = /^(.*?)(Bold|Italic|Light|Medium|Black|Regular|Oblique)+$/.exec(ps);
+    if (m && m[1]) {
+      pro = m[1];
+      style = ps.slice(m[1].length);
+    }
+  }
+  let suffix = "";
+  if (pro.endsWith("Pro")) suffix = " Pro";
+  else if (pro.endsWith("Std")) suffix = " Std";
+  const fam = pro.replace(/(MT|PS|Std|Pro)+$/, "");
+  let family = "";
+  for (let i = 0; i < fam.length; i++) {
+    const c = fam[i];
+    const upper = c >= "A" && c <= "Z";
+    const prevLower = i > 0 && fam[i - 1] >= "a" && fam[i - 1] <= "z";
+    const prevUpper = i > 0 && fam[i - 1] >= "A" && fam[i - 1] <= "Z";
+    const nextLower = i + 1 < fam.length && fam[i + 1] >= "a" && fam[i + 1] <= "z";
+    if (i > 0 && upper && (prevLower || prevUpper && nextLower)) family += " ";
+    family += c;
+  }
+  family += suffix;
+  const s = style.toLowerCase();
+  const weight = WEIGHTS.find(([re]) => re.test(s))?.[1] ?? 400;
+  return { family: family || ps, weight, italic: /italic|oblique|it$/.test(s) };
+}
+var STYLE_NAMES = [
+  [100, "Thin"],
+  [200, "ExtraLight"],
+  [300, "Light"],
+  [400, "Regular"],
+  [500, "Medium"],
+  [600, "SemiBold"],
+  [700, "Bold"],
+  [800, "ExtraBold"],
+  [900, "Black"]
+];
+function postScriptFor(s) {
+  if (s.postScriptName) return s.postScriptName;
+  const base = s.fontFamily.replace(/["',]/g, "").replace(/\s+/g, "");
+  const weight = STYLE_NAMES.reduce((best, w) => Math.abs(w[0] - s.fontWeight) < Math.abs(best[0] - s.fontWeight) ? w : best)[1];
+  if (weight === "Regular" && !s.italic) return base;
+  return `${base}-${weight === "Regular" ? "" : weight}${s.italic ? "Italic" : ""}`;
+}
+var hex22 = (v) => Math.round(Math.max(0, Math.min(1, v)) * 255).toString(16).padStart(2, "0");
+function merged(levels) {
+  const items = [];
+  for (const l of levels) {
+    if (l?.t !== "dict") continue;
+    for (const [k, v] of l.items) if (!items.some(([o]) => o === k)) items.push([k, v]);
+  }
+  return E.dict(items);
+}
+function charStyle(d, fonts, notes) {
+  const n = (k) => eNum(eGet(d, k));
+  const flag = (k) => eBool(eGet(d, k));
+  const s = { ...DEFAULT_TEXT_STYLE };
+  const fi = n("Font");
+  const ps = fi !== void 0 ? fonts[fi] : void 0;
+  if (ps) {
+    const f = fontFromPostScript(ps);
+    s.fontFamily = f.family;
+    s.fontWeight = f.weight;
+    if (f.italic) s.italic = true;
+    s.postScriptName = ps;
+  }
+  const size = n("FontSize");
+  if (size !== void 0 && size > 0) s.fontSize = size;
+  if (flag("AutoLeading") === false) {
+    const lead = n("Leading");
+    if (lead !== void 0 && lead > 0) s.leading = lead;
+  }
+  const tracking = n("Tracking");
+  if (tracking) s.tracking = tracking;
+  const shift = n("BaselineShift");
+  if (shift) s.baselineShift = shift;
+  if (flag("Underline")) s.underline = true;
+  if (flag("Strikethrough")) s.strikethrough = true;
+  if (flag("FauxBold")) notes.add("faux bold is drawn as the regular weight");
+  if (flag("FauxItalic")) notes.add("faux italic is drawn upright");
+  if ((n("HorizontalScale") ?? 1) !== 1 || (n("VerticalScale") ?? 1) !== 1) notes.add("horizontal and vertical character scaling is drawn at 100 %");
+  if ((n("FontCaps") ?? 0) !== 0) notes.add("small caps and all caps are drawn as typed");
+  const color = eGet(d, "FillColor");
+  const values = eArray(eGet(color, "Values")).map((v) => eNum(v) ?? 0);
+  if (values.length === 4) {
+    s.color = `#${hex22(values[1])}${hex22(values[2])}${hex22(values[3])}`;
+    if (values[0] < 1) s.opacity = Math.max(0, values[0]);
+  } else if (values.length === 2) {
+    const g = hex22(values[1]);
+    s.color = `#${g}${g}${g}`;
+  } else if (values.length === 5) {
+    const [c, m, y, k] = values.slice(1);
+    s.color = `#${hex22((1 - c) * (1 - k))}${hex22((1 - m) * (1 - k))}${hex22((1 - y) * (1 - k))}`;
+    notes.add("CMYK text colours were converted to RGB");
+  }
+  return s;
+}
+function paraStyle(d) {
+  const n = (k) => eNum(eGet(d, k));
+  const out = {};
+  const j = n("Justification");
+  const align = j === 1 ? "right" : j === 2 ? "center" : j !== void 0 && j >= 3 ? "justify" : "left";
+  if (align !== "left") out.align = align;
+  const set = (k, v) => {
+    if (v) out[k] = v;
+  };
+  set("firstLineIndent", n("FirstLineIndent"));
+  set("startIndent", n("StartIndent"));
+  set("endIndent", n("EndIndent"));
+  set("spaceBefore", n("SpaceBefore"));
+  set("spaceAfter", n("SpaceAfter"));
+  const auto = n("AutoLeading");
+  if (auto !== void 0 && auto > 0 && Math.abs(auto - 1.2) > 1e-6) out.autoLeading = auto;
+  return out;
+}
+function typeFromTySh(data, notes) {
+  const t = parseTySh(data);
+  if (!t) return null;
+  const txtV = descGet(t.text, "Txt ");
+  const txt = txtV?.type === "TEXT" ? txtV.value.replace(/\0+$/, "") : void 0;
+  const ed = descGet(t.text, "EngineData");
+  let engine = null;
+  if (ed?.type === "tdta") {
+    try {
+      engine = parseEngineData(ed.data);
+    } catch {
+      notes.add("the text engine data could not be read; the text came in in one style");
+    }
+  }
+  const anti = descGet(t.text, "AntA");
+  const antiAlias = !(anti?.type === "enum" && (anti.value === "Anno" || anti.value === "antiAliasNone"));
+  const ornt = descGet(t.text, "Ornt");
+  if (ornt?.type === "enum" && ornt.value === "Vrtc") notes.add("vertical type is laid out horizontally");
+  if (t.warp) {
+    const style = descGet(t.warp, "warpStyle");
+    if (style?.type === "enum" && style.value !== "warpNone") notes.add("warped text is drawn without its warp when edited");
+  }
+  const edText = eStr(ePath(engine ?? void 0, ["EngineDict", "Editor", "Text"])) ?? "";
+  const text3 = (txt ?? edText.replace(/\r$/, "")).replace(/\r\n?/g, "\n");
+  let runs = [{ length: text3.length, style: { ...DEFAULT_TEXT_STYLE } }];
+  let paragraphs = [{ length: text3.length, style: {} }];
+  let frame = { kind: "point" };
+  let transform = t.transform;
+  const fonts = [];
+  if (engine) {
+    const res = eGet(engine, "ResourceDict") ?? eGet(engine, "DocumentResources");
+    for (const f of eArray(eGet(res, "FontSet"))) fonts.push(eStr(eGet(f, "Name")) ?? "");
+    const styleSet = eArray(eGet(res, "StyleSheetSet"));
+    const paraSet = eArray(eGet(res, "ParagraphSheetSet"));
+    const normalStyle = styleSet[eNum(eGet(res, "TheNormalStyleSheet")) ?? 0] ?? styleSet[0];
+    const normalPara = paraSet[eNum(eGet(res, "TheNormalParagraphSheet")) ?? 0] ?? paraSet[0];
+    const named = (set, sheet) => {
+      const parent = eNum(eGet(sheet, "Parent"));
+      if (parent !== void 0 && set[parent]) return set[parent];
+      const name = eStr(eGet(sheet, "Name"));
+      return name ? set.find((s) => eStr(eGet(s, "Name")) === name) : void 0;
+    };
+    const prun = ePath(engine, ["EngineDict", "ParagraphRun"]);
+    const psheets = eArray(eGet(prun, "RunArray")).map((x) => eGet(x, "ParagraphSheet"));
+    const plens = eArray(eGet(prun, "RunLengthArray")).map((v) => eNum(v) ?? 0);
+    const paraBases = psheets.map((sheet) => {
+      const own = named(paraSet, sheet);
+      const base = merged([eGet(own, "Properties"), eGet(normalPara, "Properties")]);
+      const di = eNum(eGet(sheet, "DefaultStyleSheet")) ?? eNum(eGet(own, "DefaultStyleSheet"));
+      return { base, charDefault: di !== void 0 ? styleSet[di] : void 0 };
+    });
+    if (psheets.length) {
+      paragraphs = psheets.map((sheet, i) => ({ length: plens[i] ?? 0, style: paraStyle(merged([eGet(sheet, "Properties"), paraBases[i].base])) }));
+    }
+    const srun = ePath(engine, ["EngineDict", "StyleRun"]);
+    const ssheets = eArray(eGet(srun, "RunArray")).map((x) => eGet(x, "StyleSheet"));
+    const slens = eArray(eGet(srun, "RunLengthArray")).map((v) => eNum(v) ?? 0);
+    const paraAt = (at) => {
+      let end = 0;
+      for (let i = 0; i < plens.length; i++) {
+        end += plens[i];
+        if (at < end) return i;
+      }
+      return plens.length - 1;
+    };
+    if (ssheets.length) {
+      let at = 0;
+      runs = ssheets.map((sheet, i) => {
+        const own = named(styleSet, sheet);
+        const paraDefault = paraBases[paraAt(at)]?.charDefault;
+        at += slens[i] ?? 0;
+        const d = merged([eGet(sheet, "StyleSheetData"), eGet(own, "StyleSheetData"), eGet(paraDefault, "StyleSheetData"), eGet(normalStyle, "StyleSheetData")]);
+        return { length: slens[i] ?? 0, style: charStyle(d, fonts, notes) };
+      });
+    }
+    const shape = eArray(ePath(engine, ["EngineDict", "Rendered", "Shapes", "Children"]))[0];
+    if (eNum(eGet(shape, "ShapeType")) === 1) {
+      const b = eArray(ePath(shape, ["Cookie", "Photoshop", "BoxBounds"])).map((v) => eNum(v) ?? 0);
+      if (b.length === 4 && b[2] > b[0] && b[3] > b[1]) {
+        frame = { kind: "box", width: b[2] - b[0], height: b[3] - b[1] };
+        transform = multiplyMatrices([1, 0, 0, 1, b[0], b[1]], t.transform);
+      }
+    }
+  }
+  return {
+    text: text3,
+    runs: fitRuns(runs, text3.length, DEFAULT_TEXT_STYLE),
+    paragraphs: fitParagraphRuns(paragraphs, text3),
+    frame,
+    transform,
+    antiAlias,
+    fonts: [...new Set(fonts.filter(Boolean))]
+  };
+}
+function typeSignature(layer) {
+  return JSON.stringify([layer.text, layer.runs, layer.paragraphs, layer.frame, layer.transform ?? null, layer.antiAlias ?? true]);
+}
+function styleSheetData(s, font) {
+  const [r, g, b] = [1, 3, 5].map((i) => parseInt(s.color.slice(i, i + 2), 16) / 255);
+  return E.dict([
+    ["Font", E.int(font)],
+    ["FontSize", E.real(s.fontSize)],
+    ["FauxBold", E.bool(false)],
+    ["FauxItalic", E.bool(false)],
+    ["AutoLeading", E.bool(s.leading === void 0)],
+    ["Leading", E.real(s.leading ?? 0)],
+    ["HorizontalScale", E.real(1)],
+    ["VerticalScale", E.real(1)],
+    ["Tracking", E.int(Math.round(s.tracking ?? 0))],
+    ["AutoKerning", E.bool(true)],
+    ["Kerning", E.int(0)],
+    ["BaselineShift", E.real(s.baselineShift ?? 0)],
+    ["FontCaps", E.int(0)],
+    ["Underline", E.bool(Boolean(s.underline))],
+    ["Strikethrough", E.bool(Boolean(s.strikethrough))],
+    ["Ligatures", E.bool(true)],
+    ["DLigatures", E.bool(false)],
+    ["FillFlag", E.bool(true)],
+    [
+      "FillColor",
+      E.dict([
+        ["Type", E.int(1)],
+        ["Values", E.array([E.real(s.opacity ?? 1), E.real(r), E.real(g), E.real(b)])]
+      ])
+    ]
+  ]);
+}
+function paragraphProperties(p) {
+  const j = p.align === "right" ? 1 : p.align === "center" ? 2 : p.align === "justify" ? 3 : 0;
+  return E.dict([
+    ["Justification", E.int(j)],
+    ["FirstLineIndent", E.real(p.firstLineIndent ?? 0)],
+    ["StartIndent", E.real(p.startIndent ?? 0)],
+    ["EndIndent", E.real(p.endIndent ?? 0)],
+    ["SpaceBefore", E.real(p.spaceBefore ?? 0)],
+    ["SpaceAfter", E.real(p.spaceAfter ?? 0)],
+    ["AutoHyphenate", E.bool(false)],
+    ["AutoLeading", E.real(p.autoLeading ?? 1.2)],
+    ["LeadingType", E.int(0)]
+  ]);
+}
+var fontEntry = (name) => E.dict([
+  ["Name", E.str(name)],
+  ["Script", E.int(0)],
+  ["FontType", E.int(1)],
+  ["Synthetic", E.int(0)]
+]);
+function buildEngineData(layer, template) {
+  const e = template?.t === "dict" ? eClone(template) : E.dict([["EngineDict", E.dict()], ["ResourceDict", E.dict()]]);
+  if (eGet(e, "EngineDict")?.t !== "dict") eSet(e, "EngineDict", E.dict());
+  const dict = eGet(e, "EngineDict");
+  const text3 = layer.text.replace(/\n/g, "\r");
+  const edText = `${text3}\r`;
+  const res0 = eGet(e, "ResourceDict") ?? eGet(e, "DocumentResources");
+  const fonts = eArray(eGet(res0, "FontSet")).map((f) => eStr(eGet(f, "Name")) ?? "");
+  const fontIndex = (ps) => {
+    const at = fonts.indexOf(ps);
+    if (at >= 0) return at;
+    fonts.push(ps);
+    return fonts.length - 1;
+  };
+  const runs = fitRuns(layer.runs, layer.text.length, DEFAULT_TEXT_STYLE);
+  const sruns = [];
+  const slens = [];
+  runs.forEach((r, i) => {
+    sruns.push(E.dict([["StyleSheet", E.dict([["StyleSheetData", styleSheetData(r.style, fontIndex(postScriptFor(r.style)))]])]]));
+    slens.push(E.int(r.length + (i === runs.length - 1 ? 1 : 0)));
+  });
+  if (!runs.length) {
+    sruns.push(E.dict([["StyleSheet", E.dict([["StyleSheetData", styleSheetData(DEFAULT_TEXT_STYLE, fontIndex(postScriptFor(DEFAULT_TEXT_STYLE)))]])]]));
+    slens.push(E.int(1));
+  }
+  const paras = fitParagraphRuns(layer.paragraphs, layer.text);
+  const pruns = [];
+  const plens = [];
+  paras.forEach((p, i) => {
+    pruns.push(E.dict([["ParagraphSheet", E.dict([["DefaultStyleSheet", E.int(0)], ["Properties", paragraphProperties(p.style)]])]]));
+    plens.push(E.int(p.length + (i === paras.length - 1 ? 1 : 0)));
+  });
+  const editor = eGet(dict, "Editor") ?? E.dict();
+  eSet(editor, "Text", E.str(edText));
+  eSet(dict, "Editor", editor);
+  const pr = eGet(dict, "ParagraphRun") ?? E.dict();
+  eSet(pr, "RunArray", E.array(pruns));
+  eSet(pr, "RunLengthArray", E.array(plens));
+  if (!eGet(pr, "IsJoinable")) eSet(pr, "IsJoinable", E.int(1));
+  eSet(dict, "ParagraphRun", pr);
+  const sr = eGet(dict, "StyleRun") ?? E.dict();
+  eSet(sr, "RunArray", E.array(sruns));
+  eSet(sr, "RunLengthArray", E.array(slens));
+  if (!eGet(sr, "IsJoinable")) eSet(sr, "IsJoinable", E.int(2));
+  eSet(dict, "StyleRun", sr);
+  eSet(dict, "AntiAlias", E.int(layer.antiAlias === false ? 0 : 3));
+  if (!eGet(dict, "UseFractionalGlyphWidths")) eSet(dict, "UseFractionalGlyphWidths", E.bool(true));
+  const box2 = layer.frame.kind === "box" ? layer.frame : null;
+  const shapeType = box2 ? 1 : 0;
+  const photoshop = E.dict([["ShapeType", E.int(shapeType)]]);
+  if (box2) eSet(photoshop, "BoxBounds", E.array([E.real(0), E.real(0), E.real(box2.width), E.real(box2.height)]));
+  else eSet(photoshop, "PointBase", E.array([E.real(0), E.real(0)]));
+  eSet(
+    photoshop,
+    "Base",
+    E.dict([
+      ["ShapeType", E.int(shapeType)],
+      ["TransformPoint0", E.array([E.real(1), E.real(0)])],
+      ["TransformPoint1", E.array([E.real(0), E.real(1)])],
+      ["TransformPoint2", E.array([E.real(0), E.real(0)])]
+    ])
+  );
+  const child = E.dict([
+    ["ShapeType", E.int(shapeType)],
+    ["Procession", E.int(0)],
+    ["Lines", E.dict([["WritingDirection", E.int(0)], ["Children", E.array([])]])],
+    ["Cookie", E.dict([["Photoshop", photoshop]])]
+  ]);
+  eSet(dict, "Rendered", E.dict([["Version", E.int(1)], ["Shapes", E.dict([["WritingDirection", E.int(0)], ["Children", E.array([child])]])]]));
+  const fontSet = E.array(fonts.map(fontEntry));
+  for (const key of ["ResourceDict", "DocumentResources"]) {
+    let rd = eGet(e, key);
+    if (!rd) {
+      if (key === "DocumentResources") {
+        eSet(e, key, eClone(eGet(e, "ResourceDict") ?? E.dict()));
+        continue;
+      }
+      rd = E.dict();
+      eSet(e, key, rd);
+    }
+    eSet(rd, "FontSet", fontSet);
+    if (!eGet(rd, "StyleSheetSet")) eSet(rd, "StyleSheetSet", E.array([E.dict([["Name", E.str("Normal RGB")], ["StyleSheetData", styleSheetData(runs[0]?.style ?? DEFAULT_TEXT_STYLE, 0)]])]));
+    if (!eGet(rd, "ParagraphSheetSet")) eSet(rd, "ParagraphSheetSet", E.array([E.dict([["Name", E.str("Normal RGB")], ["DefaultStyleSheet", E.int(0)], ["Properties", paragraphProperties({})]])]));
+    if (!eGet(rd, "TheNormalStyleSheet")) eSet(rd, "TheNormalStyleSheet", E.int(0));
+    if (!eGet(rd, "TheNormalParagraphSheet")) eSet(rd, "TheNormalParagraphSheet", E.int(0));
+  }
+  return e;
+}
+function inkBounds2(layer) {
+  if (layer.frame.kind === "box") return [0, 0, layer.frame.width, layer.frame.height];
+  const b = contentBounds(layer.surface);
+  if (!b) return [0, 0, 0, 0];
+  const inv = invertMatrix(textMatrix(layer));
+  const pts = [
+    { x: b.x, y: b.y },
+    { x: b.x + b.width, y: b.y },
+    { x: b.x + b.width, y: b.y + b.height },
+    { x: b.x, y: b.y + b.height }
+  ].map((p) => applyMatrix(inv, p));
+  return [Math.min(...pts.map((p) => p.x)), Math.min(...pts.map((p) => p.y)), Math.max(...pts.map((p) => p.x)), Math.max(...pts.map((p) => p.y))];
+}
+function tyShForLayer(layer) {
+  const raw = layer.psd?.tySh;
+  if (raw && layer.psd?.signature === typeSignature(layer)) return raw;
+  const old = raw ? parseTySh(raw) : null;
+  const oldEd = old ? descGet(old.text, "EngineData") : void 0;
+  let template = null;
+  if (oldEd?.type === "tdta") {
+    try {
+      template = parseEngineData(oldEd.data);
+    } catch {
+      template = null;
+    }
+  }
+  const engine = buildEngineData(layer, template);
+  const text3 = old ? { ...old.text, items: [...old.text.items] } : descriptor("TxLr");
+  const set = (key, v) => {
+    const at = text3.items.findIndex(([k]) => k === key);
+    if (at >= 0) text3.items[at] = [key, v];
+    else text3.items.push([key, v]);
+  };
+  set("Txt ", { type: "TEXT", value: layer.text.replace(/\n/g, "\r") });
+  if (!descGet(text3, "textGridding")) set("textGridding", { type: "enum", typeId: "textGridding", value: "None" });
+  set("Ornt", { type: "enum", typeId: "Ornt", value: "Hrzn" });
+  set("AntA", { type: "enum", typeId: "Annt", value: layer.antiAlias === false ? "Anno" : "AnSm" });
+  const [l, t, r, b] = inkBounds2(layer);
+  const rect = (cls) => ({
+    type: "Objc",
+    value: descriptor(cls, [
+      ["Left", { type: "UntF", unit: "#Pnt", value: l }],
+      ["Top ", { type: "UntF", unit: "#Pnt", value: t }],
+      ["Rght", { type: "UntF", unit: "#Pnt", value: r }],
+      ["Btom", { type: "UntF", unit: "#Pnt", value: b }]
+    ])
+  });
+  set("bounds", rect("bounds"));
+  set("boundingBox", rect("boundingBox"));
+  if (!descGet(text3, "TextIndex")) set("TextIndex", { type: "long", value: 0 });
+  set("EngineData", { type: "tdta", data: writeEngineData(engine) });
+  const warpStyle = old?.warp ? descGet(old.warp, "warpStyle") : void 0;
+  const warp = old?.warp && warpStyle?.type === "enum" && warpStyle.value === "warpNone" ? old.warp : null;
+  return writeTySh({ transform: textMatrix(layer), text: text3, warp, tail: new Uint8Array(16) });
+}
+
+// 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/smart.ts
+var dbl2 = (value) => ({ type: "doub", value });
+var unit2 = (u, value) => ({ type: "UntF", unit: u, 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 textV = (value) => ({ type: "TEXT", value });
+var obj2 = (d) => ({ type: "Objc", value: d });
+var text = (d, key) => {
+  const v = descGet(d, key);
+  return v?.type === "TEXT" ? v.value : void 0;
+};
+var enumOf2 = (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;
+    }
+    void version;
+  }
+  return { kind, uuid, name, fileType, bytes: new Uint8Array(0), path: path ?? name };
+}
+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 {
@@ -7509,7 +8705,7 @@ var warpStyleOf = (name) => {
 };
 function warpFromDescriptor(w, contents) {
   const full = { x: 0, y: 0, width: contents.width, height: contents.height };
-  const styleName = enumOf(w, "warpStyle");
+  const styleName = enumOf2(w, "warpStyle");
   if (!styleName) return void 0;
   if (styleName === "warpNone") return { mesh: null, frame: full };
   const bd = descObject(w, "bounds");
@@ -7528,9 +8724,9 @@ function warpFromDescriptor(w, contents) {
     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 px2 = 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) };
+    const f = { x: Math.min(...px2), y: Math.min(...py), width: Math.max(...px2) - Math.min(...px2), 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);
@@ -7541,7 +8737,7 @@ function warpFromDescriptor(w, contents) {
         bend: descNumber(w, "warpValue") ?? 0,
         horizontal: descNumber(w, "warpPerspective") ?? 0,
         vertical: descNumber(w, "warpPerspectiveOther") ?? 0,
-        orientation: enumOf(w, "warpRotate") === "Vrtc" ? "vertical" : "horizontal"
+        orientation: enumOf2(w, "warpRotate") === "Vrtc" ? "vertical" : "horizontal"
       },
       bounds
     );
@@ -7558,20 +8754,20 @@ 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)]
+    ["Top ", dbl2(0)],
+    ["Left", dbl2(0)],
+    ["Btom", dbl2(contents.height)],
+    ["Rght", dbl2(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)]
+    ["warpStyle", enumV2("warpStyle", single ? "warpCustom" : "warpNone")],
+    ["warpValue", dbl2(0)],
+    ["warpPerspective", dbl2(0)],
+    ["warpPerspectiveOther", dbl2(0)],
+    ["warpRotate", enumV2("Ornt", "Hrzn")],
+    ["bounds", obj2(bounds)],
+    ["uOrder", long3(4)],
+    ["vOrder", long3(4)]
   ];
   let frame = full;
   if (single) {
@@ -7579,10 +8775,10 @@ function warpDescriptor(mesh, contents) {
       ["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);
+    items.push(["customEnvelopeWarp", obj2(descriptor("customEnvelopeWarp", [["meshPoints", { type: "ObAr", prefix: 16, body }]]))]);
+    const px2 = 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) };
+    frame = { x: Math.min(...px2), y: Math.min(...py), width: Math.max(...px2) - Math.min(...px2), height: Math.max(...py) - Math.min(...py) };
   }
   return { warp: descriptor("warp", items), frame, dropped: Boolean(mesh && !single) };
 }
@@ -7679,14 +8875,14 @@ 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;
+  const id = o ? enumOf2(o, "Md  ") : void 0;
   return { blend: id && blendFromPsdId(id) || "normal", opacity };
 }
 function blendOptions(f) {
-  return obj(
+  return obj2(
     descriptor("blendOptions", [
-      ["Opct", unit("#Prc", Math.min(1, Math.max(0, f.opacity)) * 100)],
-      ["Md  ", enumV("BlnM", psdBlendId(f.blend))]
+      ["Opct", unit2("#Prc", Math.min(1, Math.max(0, f.opacity)) * 100)],
+      ["Md  ", enumV2("BlnM", psdBlendId(f.blend))]
     ])
   );
 }
@@ -7707,7 +8903,7 @@ function smartFiltersFromPsd(fx, newId, notes) {
     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));
+    setItem(neutral, "enab", boolV2(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`);
   }
@@ -7719,32 +8915,32 @@ function filterFXDescriptor(stack, dropped) {
     if (f.kind === "psd") {
       const d = parseVersionedDescriptor(f.data);
       setItem(d, "blendOptions", blendOptions(f));
-      setItem(d, "enab", boolV(f.enabled));
-      list2.push(obj(d));
+      setItem(d, "enab", boolV2(f.enabled));
+      list2.push(obj2(d));
     } else if (f.kind === "blur") {
-      const rgb = (v) => obj(descriptor("RGBC", [["Rd  ", dbl(v)], ["Grn ", dbl(v)], ["Bl  ", dbl(v)]]));
+      const rgb = (v) => obj2(descriptor("RGBC", [["Rd  ", dbl2(v)], ["Grn ", dbl2(v)], ["Bl  ", dbl2(v)]]));
       list2.push(
-        obj(
+        obj2(
           descriptor("filterFX", [
             ["Nm  ", textV(BOX_BLUR.name)],
             ["blendOptions", blendOptions(f)],
-            ["enab", boolV(f.enabled)],
-            ["hasoptions", boolV(true)],
+            ["enab", boolV2(f.enabled)],
+            ["hasoptions", boolV2(true)],
             ["FrgC", rgb(0)],
             ["BckC", rgb(255)],
-            ["Fltr", obj(descriptor(BOX_BLUR.classId, [["Rds ", unit("#Pxl", f.radius)]]))],
-            ["filterID", long2(BOX_BLUR.id)]
+            ["Fltr", obj2(descriptor(BOX_BLUR.classId, [["Rds ", unit2("#Pxl", f.radius)]]))],
+            ["filterID", long3(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)],
+    ["enab", boolV2(stack.enabled)],
+    ["validAtPosition", boolV2(true)],
+    ["filterMaskEnable", boolV2(stack.mask ? stack.mask.enabled !== false : true)],
+    ["filterMaskLinked", boolV2(stack.mask ? stack.mask.linked !== false : false)],
+    ["filterMaskExtendWithWhite", boolV2(true)],
     ["filterFXList", { type: "VlLs", items: list2 }]
   ]);
 }
@@ -7759,7 +8955,7 @@ function filterStackKey(stack) {
 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) };
+  const quad = { type: "VlLs", items: quadFromCorners(s.placement.corners, frame, s.size).map(dbl2) };
   let d;
   if (s.template) {
     d = cloneDescriptor(s.template);
@@ -7767,31 +8963,31 @@ function soldBytes(s, notes) {
     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));
+    setItem(d, "warp", obj2(warp));
+    setItem(d, "Sz  ", obj2(descriptor("Pnt ", [["Wdth", dbl2(s.size.width)], ["Hght", dbl2(s.size.height)]])));
+    if (s.filterFX) setItem(d, "filterFX", obj2(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 ratio = (n, den) => obj2(descriptor("null", [["numerator", long3(n)], ["denominator", long3(den)]]));
     const items = [
       ["Idnt", textV(s.idnt)],
       ["placed", textV(s.placed)],
-      ["PgNm", long2(1)],
-      ["totalPages", long2(1)],
-      ["Crop", long2(1)],
+      ["PgNm", long3(1)],
+      ["totalPages", long3(1)],
+      ["Crop", long3(1)],
       ["frameStep", ratio(0, 600)],
       ["duration", ratio(0, 600)],
-      ["frameCount", long2(1)],
-      ["Annt", long2(16)],
-      ["Type", long2(2)],
+      ["frameCount", long3(1)],
+      ["Annt", long3(16)],
+      ["Type", long3(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)]
+      ["warp", obj2(warp)],
+      ["Sz  ", obj2(descriptor("Pnt ", [["Wdth", dbl2(s.size.width)], ["Hght", dbl2(s.size.height)]]))],
+      ["Rslt", unit2("#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)]]))]);
+    if (s.filterFX) items.push(["filterFX", obj2(s.filterFX)]);
+    items.push(["comp", long3(-1)], ["compInfo", obj2(descriptor("null", [["compID", long3(-1)], ["originalCompID", long3(-1)]]))]);
     d = descriptor("null", items);
   }
   const w = new PsdWriter();
@@ -8011,9 +9207,9 @@ function readLayerInfo(data, psb) {
   const count = r.i16();
   const n = Math.abs(count);
   r.checkCount(n, 34, "Layer records");
-  const read = [];
-  for (let i = 0; i < n; i++) read.push(readLayerRecord(r, psb));
-  for (const { record, lengths } of read) {
+  const read2 = [];
+  for (let i = 0; i < n; i++) read2.push(readLayerRecord(r, psb));
+  for (const { record, lengths } of read2) {
     record.channels.forEach((ch, i) => {
       const len = lengths[i];
       if (len === 0) return;
@@ -8022,7 +9218,7 @@ function readLayerInfo(data, psb) {
       ch.data = r.bytes(len - 2);
     });
   }
-  return { layers: read.map((x) => x.record), mergedAlpha: count < 0 };
+  return { layers: read2.map((x) => x.record), mergedAlpha: count < 0 };
 }
 function readPsd(bytes) {
   const r = new PsdReader(bytes);
@@ -8134,11 +9330,11 @@ function writeRect(w, r) {
 }
 function writeBlocks(w, blocks, psb, alignment) {
   for (const b of blocks) {
-    const long4 = psb && PSB_LONG_KEYS.has(b.key);
-    w.ascii(long4 ? "8B64" : "8BIM");
+    const long5 = psb && PSB_LONG_KEYS.has(b.key);
+    w.ascii(long5 ? "8B64" : "8BIM");
     w.ascii(b.key);
     const pad = (alignment - b.data.length % alignment) % alignment;
-    if (long4) w.u64(b.data.length + pad);
+    if (long5) w.u64(b.data.length + pad);
     else w.u32(b.data.length + pad);
     w.bytes(b.data);
     w.zeros(pad);
@@ -8559,7 +9755,7 @@ var PSD_BLEND_KEYS = {
 var BLEND_TO_PSD = Object.fromEntries(
   Object.entries(PSD_BLEND_KEYS).map(([k, v]) => [v, k])
 );
-var FILL_KEYS = ["SoCo", "GdFl", "PtFl"];
+var FILL_KEYS = ["SoCo", "GdFl", "PtFl", "vscg"];
 var TYPE_KEYS = ["TySh", "tySh"];
 var SMART_KEYS = ["SoLd", "SoLE", "PlLd"];
 var VECTOR_KEYS = ["vmsk", "vsms"];
@@ -8802,6 +9998,24 @@ function importNode(ctx, node, depth) {
       return smart;
     }
   }
+  if (kind === "shape") {
+    const shape = importShape(ctx, rec, name, notes, props);
+    if (shape) {
+      entry.type = "shape";
+      entry.id = shape.id;
+      entry.status = notes.length ? "approximated" : "mapped";
+      return shape;
+    }
+  }
+  if (kind === "type") {
+    const type = importType(ctx, rec, name, notes, props);
+    if (type) {
+      entry.type = "type";
+      entry.id = type.id;
+      entry.status = notes.length ? "approximated" : "mapped";
+      return type;
+    }
+  }
   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);
@@ -8819,6 +10033,69 @@ function importNode(ctx, node, depth) {
   entry.status = notes.length ? "approximated" : "mapped";
   return layer;
 }
+function importShape(ctx, rec, name, notes, props) {
+  const approx = /* @__PURE__ */ new Set();
+  const { width, height } = ctx.file.header;
+  const data = shapeFromBlocks(rec.blocks, width, height, ctx.dpi, approx);
+  if (!data) return null;
+  for (const n of approx) {
+    ctx.warn.add(`A shape layer was approximated: ${n}`, name);
+    notes.push(n);
+  }
+  const layer = {
+    type: "shape",
+    id: ctx.newId(name),
+    ...props,
+    components: data.components,
+    fill: data.fill,
+    stroke: data.stroke,
+    surface: emptySurface(4),
+    offset: { x: 0, y: 0 }
+  };
+  if (data.inverted) layer.inverted = true;
+  if (!ctx.skipPixels) layer.surface = renderShape(layer, { width, height, pattern: (id) => ctx.patterns.get(id) ?? null });
+  layer.psd = { blocks: rec.blocks.filter((b) => SHAPE_PSD_KEYS.includes(b.key)).map((b) => ({ key: b.key, data: b.data.slice() })), signature: shapeSignature(layer) };
+  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;
+  return layer;
+}
+function importType(ctx, rec, name, notes, props) {
+  const block = rec.blocks.find((b) => b.key === "TySh" || b.key === "tySh");
+  if (!block || block.key !== "TySh") return null;
+  const approx = /* @__PURE__ */ new Set();
+  const data = typeFromTySh(block.data, approx);
+  if (!data) return null;
+  for (const n of approx) {
+    ctx.warn.add(`A type layer was approximated: ${n}`, name);
+    notes.push(n);
+  }
+  const layer = {
+    type: "type",
+    id: ctx.newId(name),
+    ...props,
+    text: data.text,
+    runs: data.runs,
+    paragraphs: data.paragraphs,
+    frame: data.frame,
+    transform: data.transform,
+    surface: recordPixels(ctx, rec, name),
+    offset: { x: 0, y: 0 },
+    rendering: "stored"
+  };
+  if (!data.antiAlias) layer.antiAlias = false;
+  layer.psd = { tySh: block.data.slice(), signature: typeSignature(layer) };
+  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;
+  return layer;
+}
 function contentsFor(ctx, placed, name, notes) {
   const memo = ctx.contents.get(placed.idnt);
   if (memo !== void 0) return memo;
@@ -8990,7 +10267,8 @@ function psdToLayers(file, options = {}) {
     linked: /* @__PURE__ */ new Map(),
     filterItems: /* @__PURE__ */ new Map(),
     contents: /* @__PURE__ */ new Map(),
-    depth: options.depth ?? 0
+    depth: options.depth ?? 0,
+    dpi: resolution(file) ?? 72
   };
   for (const block of file.globalBlocks) {
     if (LINKED_FILE_KEYS.includes(block.key)) {
@@ -9115,7 +10393,7 @@ function psdBlendId(mode) {
 var num3 = (d, key, fallback) => descNumber(d, key) ?? fallback;
 var pct = (d, key, fallback) => num3(d, key, fallback * 100) / 100;
 var bool = (d, key) => descBool(d, key) === true;
-var enumOf2 = (d, key) => {
+var enumOf3 = (d, key) => {
   const v = descGet(d, key);
   return v?.type === "enum" ? v.value : void 0;
 };
@@ -9129,15 +10407,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 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 unit3 = (u, value) => ({ type: "UntF", unit: u, value });
+var dbl3 = (value) => ({ type: "doub", value });
+var long4 = (value) => ({ type: "long", value: Math.round(value) });
+var boolV3 = (value) => ({ type: "bool", value });
+var enumV3 = (typeId, value) => ({ type: "enum", typeId, value });
 var textV2 = (value) => ({ type: "TEXT", value });
-var obj2 = (d) => ({ type: "Objc", value: d });
+var obj3 = (d) => ({ type: "Objc", value: d });
 function blendOf(d, key, fallback, notes) {
-  const id = enumOf2(d, key);
+  const id = enumOf3(d, key);
   if (id === void 0) return fallback;
   const m = BLEND_OF.get(id);
   if (m) return m;
@@ -9176,9 +10454,9 @@ function colorOf(d, fallback = "#000000") {
 function colorDesc(hex) {
   const [r, g, b] = parseEffectColor(hex) ?? [0, 0, 0];
   return descriptor("RGBC", [
-    ["Rd  ", dbl2(r * 255)],
-    ["Grn ", dbl2(g * 255)],
-    ["Bl  ", dbl2(b * 255)]
+    ["Rd  ", dbl3(r * 255)],
+    ["Grn ", dbl3(g * 255)],
+    ["Bl  ", dbl3(b * 255)]
   ]);
 }
 function contourOf(d, key) {
@@ -9204,14 +10482,14 @@ function contourDesc(c) {
     type: "VlLs",
     items: points.map((p) => {
       const items = [
-        ["Hrzn", dbl2(p.input * 255)],
-        ["Vrtc", dbl2(p.output * 255)]
+        ["Hrzn", dbl3(p.input * 255)],
+        ["Vrtc", dbl3(p.output * 255)]
       ];
-      if (p.corner) items.push(["Cnty", boolV2(false)]);
-      return obj2(descriptor("CrPt", items));
+      if (p.corner) items.push(["Cnty", boolV3(false)]);
+      return obj3(descriptor("CrPt", items));
     })
   };
-  return obj2(
+  return obj3(
     descriptor("ShpC", [
       ["Nm  ", textV2(name)],
       ["Crv ", pts]
@@ -9231,7 +10509,7 @@ function gradientOf(d, notes) {
       { position: 0, color: "#000000" },
       { position: 1, color: "#ffffff" }
     ],
-    style: GRADIENT_STYLES.find(([, id]) => id === enumOf2(d, "Type"))?.[0] ?? "linear",
+    style: GRADIENT_STYLES.find(([, id]) => id === enumOf3(d, "Type"))?.[0] ?? "linear",
     angle: clamp3(num3(d, "Angl", 90), -360, 360),
     scale: clamp3(pct(d, "Scl ", 1), 0.1, 1.5),
     reverse: bool(d, "Rvrs"),
@@ -9242,12 +10520,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 (enumOf2(grad, "GrdF") === "ClNs") {
+  if (enumOf3(grad, "GrdF") === "ClNs") {
     notes.add("noise gradients became black to white");
     return g;
   }
   const raw = list(grad, "Clrs").map((s) => {
-    const type = enumOf2(s, "Type");
+    const type = enumOf3(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(num3(s, "Lctn", 0) / 4096, 0, 1), color, mid: clamp3(num3(s, "Mdpn", 50) / 100, 0.05, 0.95) };
@@ -9275,12 +10553,12 @@ function gradientItems(g) {
   const clrs = {
     type: "VlLs",
     items: g.stops.map(
-      (s) => obj2(
+      (s) => obj3(
         descriptor("Clrt", [
-          ["Clr ", obj2(colorDesc(s.color))],
-          ["Type", enumV2("Clry", "UsrS")],
-          ["Lctn", long3(s.position * 4096)],
-          ["Mdpn", long3(50)]
+          ["Clr ", obj3(colorDesc(s.color))],
+          ["Type", enumV3("Clry", "UsrS")],
+          ["Lctn", long4(s.position * 4096)],
+          ["Mdpn", long4(50)]
         ])
       )
     )
@@ -9289,35 +10567,35 @@ function gradientItems(g) {
   const trns = {
     type: "VlLs",
     items: op.map(
-      (s) => obj2(
+      (s) => obj3(
         descriptor("TrnS", [
-          ["Opct", unit2("#Prc", s.opacity * 100)],
-          ["Lctn", long3(s.position * 4096)],
-          ["Mdpn", long3(50)]
+          ["Opct", unit3("#Prc", s.opacity * 100)],
+          ["Lctn", long4(s.position * 4096)],
+          ["Mdpn", long4(50)]
         ])
       )
     )
   };
   const grad = descriptor("Grdn", [
     ["Nm  ", textV2("Custom")],
-    ["GrdF", enumV2("GrdF", "CstS")],
-    ["Intr", dbl2(0)],
+    ["GrdF", enumV3("GrdF", "CstS")],
+    ["Intr", dbl3(0)],
     ["Clrs", clrs],
     ["Trns", trns]
   ]);
   return [
-    ["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)],
+    ["Grad", obj3(grad)],
+    ["Angl", unit3("#Ang", g.angle)],
+    ["Type", enumV3("GrdT", GRADIENT_STYLES.find(([s]) => s === g.style)[1])],
+    ["Rvrs", boolV3(g.reverse)],
+    ["Algn", boolV3(g.align)],
+    ["Scl ", unit3("#Prc", g.scale * 100)],
     [
       "Ofst",
-      obj2(
+      obj3(
         descriptor("Pnt ", [
-          ["Hrzn", unit2("#Prc", g.offset.x * 100)],
-          ["Vrtc", unit2("#Prc", g.offset.y * 100)]
+          ["Hrzn", unit3("#Prc", g.offset.x * 100)],
+          ["Vrtc", unit3("#Prc", g.offset.y * 100)]
         ])
       )
     ]
@@ -9328,7 +10606,7 @@ function patternRefOf(d) {
   return { patternId: text2(p, "Idnt") || text2(p, "Nm  "), name: text2(p, "Nm  ") };
 }
 function patternRefDesc(patternId, name) {
-  return obj2(
+  return obj3(
     descriptor("Ptrn", [
       ["Nm  ", textV2(name ?? patternId)],
       ["Idnt", textV2(patternId)]
@@ -9345,14 +10623,14 @@ function placementOf(d) {
 }
 function placementItems(angle, link, phase) {
   const out = [];
-  if (angle) out.push(["Angl", unit2("#Ang", angle)]);
-  out.push(["Algn", boolV2(link)]);
+  if (angle) out.push(["Angl", unit3("#Ang", angle)]);
+  out.push(["Algn", boolV3(link)]);
   out.push([
     "phase",
-    obj2(
+    obj3(
       descriptor("Pnt ", [
-        ["Hrzn", dbl2(phase.x)],
-        ["Vrtc", dbl2(phase.y)]
+        ["Hrzn", dbl3(phase.x)],
+        ["Vrtc", dbl3(phase.y)]
       ])
     )
   ]);
@@ -9401,7 +10679,7 @@ function readOne(kind, d, notes) {
       const base = {
         ...common(d, kind, notes),
         fill,
-        technique: enumOf2(d, "GlwT") === "PrBL" ? "precise" : "softer",
+        technique: enumOf3(d, "GlwT") === "PrBL" ? "precise" : "softer",
         size: size("blur", 5),
         contour: contourOf(d, "TrnS"),
         antiAlias: bool(d, "AntA"),
@@ -9410,7 +10688,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: enumOf2(d, "glwS") === "SrcC" ? "center" : "edge" };
+      return kind === "outer-glow" ? { ...base, kind, spread } : { ...base, kind, choke: spread, source: enumOf3(d, "glwS") === "SrcC" ? "center" : "edge" };
     }
     case "bevel-emboss": {
       const styles = { OtrB: "outer-bevel", InrB: "inner-bevel", Embs: "emboss", PlEb: "pillow-emboss", strokeEmboss: "stroke-emboss" };
@@ -9418,10 +10696,10 @@ function readOne(kind, d, notes) {
         id: newEffectId(),
         enabled: descBool(d, "enab") !== false,
         kind,
-        style: styles[enumOf2(d, "bvlS") ?? ""] ?? "inner-bevel",
-        technique: enumOf2(d, "bvlT") === "PrBL" ? "chisel-hard" : enumOf2(d, "bvlT") === "Slmt" ? "chisel-soft" : "smooth",
+        style: styles[enumOf3(d, "bvlS") ?? ""] ?? "inner-bevel",
+        technique: enumOf3(d, "bvlT") === "PrBL" ? "chisel-hard" : enumOf3(d, "bvlT") === "Slmt" ? "chisel-soft" : "smooth",
         depth: clamp3(pct(d, "srgR", 1), 0, 10),
-        direction: enumOf2(d, "bvlD") === "Out " ? "down" : "up",
+        direction: enumOf3(d, "bvlD") === "Out " ? "down" : "up",
         size: size("blur", 5),
         soften: clamp3(num3(d, "Sftn", 0), 0, 16),
         angle: clamp3(num3(d, "lagl", 120), -360, 360),
@@ -9465,14 +10743,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 = enumOf2(d, "PntT");
+      const paint = enumOf3(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 = enumOf2(d, "Styl");
+      const pos = enumOf3(d, "Styl");
       return { ...common(d, kind, notes), kind, size: size("Sz  ", 3), position: pos === "InsF" ? "inside" : pos === "CtrF" ? "center" : "outside", fill };
     }
   }
@@ -9499,11 +10777,11 @@ function parseLfx2(data) {
 }
 function commonItems(e) {
   return [
-    ["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)]
+    ["enab", boolV3(e.enabled)],
+    ["present", boolV3(true)],
+    ["showInDialog", boolV3(true)],
+    ["Md  ", enumV3("BlnM", BLEND_ID.get(e.blend) ?? "Nrml")],
+    ["Opct", unit3("#Prc", e.opacity * 100)]
   ];
 }
 function writeOne(e) {
@@ -9513,17 +10791,17 @@ function writeOne(e) {
       const inner = e.kind === "inner-shadow";
       const items = [
         ...commonItems(e),
-        ["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)],
+        ["Clr ", obj3(colorDesc(e.color))],
+        ["uglg", boolV3(e.useGlobalLight)],
+        ["lagl", unit3("#Ang", e.angle)],
+        ["Dstn", unit3("#Pxl", e.distance)],
+        ["Ckmt", unit3("#Pxl", (inner ? e.choke : e.spread) * 100)],
+        ["blur", unit3("#Pxl", e.size)],
+        ["Nose", unit3("#Prc", e.noise * 100)],
+        ["AntA", boolV3(e.antiAlias)],
         ["TrnS", contourDesc(e.contour)]
       ];
-      if (e.kind === "drop-shadow") items.push(["layerConceals", boolV2(e.knocksOut)]);
+      if (e.kind === "drop-shadow") items.push(["layerConceals", boolV3(e.knocksOut)]);
       return descriptor(inner ? "IrSh" : "DrSh", items);
     }
     case "outer-glow":
@@ -9531,110 +10809,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 ", obj2(colorDesc(e.fill.color))]);
+      else items.push(["Clr ", obj3(colorDesc(e.fill.color))]);
       items.push(
-        ["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)],
+        ["GlwT", enumV3("BETE", e.technique === "precise" ? "PrBL" : "SfBL")],
+        ["Ckmt", unit3("#Pxl", (inner ? e.choke : e.spread) * 100)],
+        ["blur", unit3("#Pxl", e.size)],
+        ["Nose", unit3("#Prc", e.noise * 100)],
+        ["ShdN", unit3("#Prc", e.jitter * 100)],
+        ["AntA", boolV3(e.antiAlias)],
         ["TrnS", contourDesc(e.contour)],
-        ["Inpr", unit2("#Prc", e.range * 100)]
+        ["Inpr", unit3("#Prc", e.range * 100)]
       );
-      if (e.kind === "inner-glow") items.push(["glwS", enumV2("IGSr", e.source === "center" ? "SrcC" : "SrcE")]);
+      if (e.kind === "inner-glow") items.push(["glwS", enumV3("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", 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 ")],
+        ["enab", boolV3(e.enabled)],
+        ["present", boolV3(true)],
+        ["showInDialog", boolV3(true)],
+        ["hglM", enumV3("BlnM", BLEND_ID.get(e.highlightBlend) ?? "Scrn")],
+        ["hglC", obj3(colorDesc(e.highlightColor))],
+        ["hglO", unit3("#Prc", e.highlightOpacity * 100)],
+        ["sdwM", enumV3("BlnM", BLEND_ID.get(e.shadowBlend) ?? "Mltp")],
+        ["sdwC", obj3(colorDesc(e.shadowColor))],
+        ["sdwO", unit3("#Prc", e.shadowOpacity * 100)],
+        ["bvlT", enumV3("bvlT", tech)],
+        ["bvlS", enumV3("BESl", style)],
+        ["uglg", boolV3(e.useGlobalLight)],
+        ["lagl", unit3("#Ang", e.angle)],
+        ["Lald", unit3("#Ang", e.altitude)],
+        ["srgR", unit3("#Prc", e.depth * 100)],
+        ["blur", unit3("#Pxl", e.size)],
+        ["bvlD", enumV3("BESs", e.direction === "up" ? "In  " : "Out ")],
         ["TrnS", contourDesc(e.glossContour)],
-        ["Sftn", unit2("#Pxl", e.soften)]
+        ["Sftn", unit3("#Pxl", e.soften)]
       ];
       if (e.contourElement) {
-        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)]);
+        items.push(["useShape", boolV3(true)], ["MpgS", contourDesc(e.contourElement.contour)], ["AntA", boolV3(e.contourElement.antiAlias)], ["Inpr", unit3("#Prc", e.contourElement.range * 100)]);
+      } else items.push(["useShape", boolV3(false)]);
       if (e.texture) {
         const t = e.texture;
         items.push(
-          ["useTexture", boolV2(true)],
-          ["InvT", boolV2(t.invert)],
-          ["Scl ", unit2("#Prc", t.scale * 100)],
-          ["textureDepth", unit2("#Prc", t.depth * 100)],
+          ["useTexture", boolV3(true)],
+          ["InvT", boolV3(t.invert)],
+          ["Scl ", unit3("#Prc", t.scale * 100)],
+          ["textureDepth", unit3("#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", boolV2(false)]);
+      } else items.push(["useTexture", boolV3(false)]);
       return descriptor("ebbl", items);
     }
     case "satin":
       return descriptor("ChFX", [
         ...commonItems(e),
-        ["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)],
+        ["Clr ", obj3(colorDesc(e.color))],
+        ["AntA", boolV3(e.antiAlias)],
+        ["Invr", boolV3(e.invert)],
+        ["lagl", unit3("#Ang", e.angle)],
+        ["Dstn", unit3("#Pxl", e.distance)],
+        ["blur", unit3("#Pxl", e.size)],
         ["MpgS", contourDesc(e.contour)]
       ]);
     case "color-overlay":
-      return descriptor("SoFi", [...commonItems(e), ["Clr ", obj2(colorDesc(e.color))]]);
+      return descriptor("SoFi", [...commonItems(e), ["Clr ", obj3(colorDesc(e.color))]]);
     case "gradient-overlay":
-      return descriptor("GrFl", [...commonItems(e), ...gradientItems(e.gradient), ["Dthr", boolV2(e.dither)]]);
+      return descriptor("GrFl", [...commonItems(e), ...gradientItems(e.gradient), ["Dthr", boolV3(e.dither)]]);
     case "pattern-overlay":
       return descriptor("patternFill", [
         ...commonItems(e),
         ["Ptrn", patternRefDesc(e.patternId, e.name)],
-        ["Scl ", unit2("#Prc", e.scale * 100)],
+        ["Scl ", unit3("#Prc", e.scale * 100)],
         ...placementItems(e.angle ?? 0, e.link ?? true, e.phase ?? { x: 0, y: 0 })
       ]);
     case "stroke": {
       const items = [
         ...commonItems(e),
-        ["Styl", enumV2("FStl", e.position === "inside" ? "InsF" : e.position === "center" ? "CtrF" : "OutF")],
-        ["Sz  ", unit2("#Pxl", e.size)]
+        ["Styl", enumV3("FStl", e.position === "inside" ? "InsF" : e.position === "center" ? "CtrF" : "OutF")],
+        ["Sz  ", unit3("#Pxl", e.size)]
       ];
       const f = e.fill;
-      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)]);
+      if (f.type === "color") items.push(["PntT", enumV3("FrFl", "SClr")], ["Clr ", obj3(colorDesc(f.color))]);
+      else if (f.type === "gradient") items.push(["PntT", enumV3("FrFl", "GrFl")], ...gradientItems(f.gradient));
+      else items.push(["PntT", enumV3("FrFl", "Ptrn")], ["Ptrn", patternRefDesc(f.patternId, f.name)], ["Scl ", unit3("#Prc", f.scale * 100)]);
       return descriptor("FrFX", items);
     }
   }
 }
 function writeLfx2(effects) {
   const items = [
-    ["Scl ", unit2("#Prc", 100)],
-    ["masterFXSwitch", boolV2(effects.enabled)]
+    ["Scl ", unit3("#Prc", 100)],
+    ["masterFXSwitch", boolV3(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, obj2(of[0])]);
-    else if (multi) items.push([multi, { type: "VlLs", items: of.map(obj2) }]);
+    if (of.length === 1) items.push([single, obj3(of[0])]);
+    else if (multi) items.push([multi, { type: "VlLs", items: of.map(obj3) }]);
     else {
-      items.push([single, obj2(of[0])]);
+      items.push([single, obj3(of[0])]);
       dropped += of.length - 1;
     }
   }
@@ -9652,7 +10930,7 @@ function parseLrfx(data) {
     const count = r.u16();
     const items = [];
     const notes = /* @__PURE__ */ new Set();
-    const fixed = (v) => (v | 0) / 65536;
+    const fixed2 = (v) => (v | 0) / 65536;
     for (let i = 0; i < count; i++) {
       if (new TextDecoder().decode(r.bytes(4)) !== "8BIM") return null;
       const key = new TextDecoder().decode(r.bytes(4));
@@ -9671,10 +10949,10 @@ function parseLrfx(data) {
       };
       if (key === "dsdw" || key === "isdw") {
         b.u32();
-        const blur = fixed(b.u32());
+        const blur = fixed2(b.u32());
         b.u32();
-        const angle = fixed(b.u32());
-        const distance = fixed(b.u32());
+        const angle = fixed2(b.u32());
+        const distance = fixed2(b.u32());
         const color = colorAt(b);
         const blend = blendAt(b);
         const enabled = b.u8() !== 0;
@@ -9684,7 +10962,7 @@ function parseLrfx(data) {
         items.push(key === "dsdw" ? { ...base, kind: "drop-shadow", spread: 0, knocksOut: true } : { ...base, kind: "inner-shadow", choke: 0 });
       } else if (key === "oglw" || key === "iglw") {
         b.u32();
-        const blur = fixed(b.u32());
+        const blur = fixed2(b.u32());
         b.u32();
         const color = colorAt(b);
         const blend = blendAt(b);
@@ -9805,8 +11083,8 @@ function smartContentsFile(c) {
     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 });
+  const merged2 = 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: merged2, 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));
@@ -10006,6 +11284,44 @@ function exportPsd(input) {
         records.push(rec);
         return;
       }
+      case "shape":
+      case "type": {
+        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]) });
+        }
+        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 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);
+        } else {
+          extra.push({ key: "TySh", data: padEven(tyShForLayer(layer)) });
+        }
+        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.`);
     }
@@ -10017,8 +11333,8 @@ function exportPsd(input) {
   const [r, g, b, a] = rgbaToPlanes(matteWhite(input.merged), n);
   const transparent = a.some((v) => v !== 255);
   const planes = transparent ? [r, g, b, a] : [r, g, b];
-  const merged = new Uint8Array(n * planes.length);
-  planes.forEach((p, i) => merged.set(p, i * n));
+  const merged2 = new Uint8Array(n * planes.length);
+  planes.forEach((p, i) => merged2.set(p, i * n));
   const res = Math.max(1, input.resolution ?? 72);
   const rw = new PsdWriter();
   for (let k = 0; k < 2; k++) {
@@ -10075,7 +11391,7 @@ function exportPsd(input) {
       mergedAlpha: transparent && records.length > 0,
       globalBlocks,
       imageCompression: 1,
-      imageData: encodeRle(merged, { planes: planes.length, width, height, depth: 8, psb })
+      imageData: encodeRle(merged2, { planes: planes.length, width, height, depth: 8, psb })
     },
     encodeLegacyName
   );
@@ -10420,8 +11736,6 @@ export {
   deserializeLayer,
   deserializeLayers,
   PsdError,
-  decodePlanes,
-  encodeRle,
   parseVersionedDescriptor,
   versionedDescriptorBytes,
   ADJUSTMENT_KEYS,
@@ -10431,6 +11745,8 @@ export {
   parseLfx2,
   writeLfx2,
   parseLrfx,
+  decodePlanes,
+  encodeRle,
   BROWSER_IMAGE_TYPES,
   readPsd,
   layerName,
@@ -10448,4 +11764,4 @@ export {
   smartContentsFile,
   exportPsd
 };
-//# sourceMappingURL=chunk-HHZ6ZJTW.js.map
+//# sourceMappingURL=chunk-CZOXTEMN.js.map