@pixerate/editor 0.110.0 → 0.112.0

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

@@ -98,7 +98,8 @@ import {
   bezierPathBounds,
   outlineStroke,
   pathBoolean,
-  strokeOutlineRings
+  strokeOutlineRings,
+  transformBezierPath
 } from "./chunk-YCSFS3GK.js";
 
 // src/image-editor/color.ts
@@ -521,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;
@@ -2145,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];
@@ -2224,6 +2225,7 @@ function removeAlpha(imageData) {
 // src/image-editor/layers/model.ts
 var SHAPE_OPERATIONS = ["combine", "subtract", "intersect", "exclude"];
 var LIVE_SHAPE_KINDS = ["rect", "ellipse", "polygon", "star", "line"];
+var TEXT_ALIGNS = ["left", "center", "right", "justify"];
 var idCounter = 0;
 function newLayerId(prefix = "layer") {
   return `${prefix}_${Date.now().toString(36)}_${(++idCounter).toString(36)}`;
@@ -2251,13 +2253,13 @@ function pixelLayerBounds(layer, surface = layer.surface) {
   return { x: b.x + layer.offset.x, y: b.y + layer.offset.y, width: b.width, height: b.height };
 }
 function layerTypeLabel(type) {
-  return type === "pixel" ? "Pixel layer" : type === "adjustment" ? "Adjustment layer" : type === "group" ? "Group" : type === "smart" ? "Smart object" : type === "shape" ? "Shape layer" : "Annotation";
+  return type === "pixel" ? "Pixel layer" : type === "adjustment" ? "Adjustment layer" : type === "group" ? "Group" : type === "smart" ? "Smart object" : type === "shape" ? "Shape layer" : type === "type" ? "Type layer" : "Annotation";
 }
 function hasSurface(layer) {
-  return layer.type === "pixel" || layer.type === "smart" || layer.type === "shape";
+  return layer.type === "pixel" || layer.type === "smart" || layer.type === "shape" || layer.type === "type";
 }
 function isRenderedLayer(layer) {
-  return layer.type === "smart" || layer.type === "shape";
+  return layer.type === "smart" || layer.type === "shape" || layer.type === "type";
 }
 function shapeLayers(layers) {
   return flattenLayers(layers).filter((l) => l.type === "shape");
@@ -2359,7 +2361,7 @@ var PHOTO_PROFILE = {
    * A smart object draws its rendered pixels (contents → placement → smart filters) like a pixel
    * layer, and a shape layer the pixels rendered from its paths.
    */
-  isPixelLike: (l) => l.type === "smart" || l.type === "shape",
+  isPixelLike: (l) => l.type === "smart" || l.type === "shape" || l.type === "type",
   maskSourcePlane: (source, W, H, sources) => {
     const opts = source;
     const depth = sources.depthMap?.(opts) ?? null;
@@ -2888,14 +2890,14 @@ function parseCssColor(value) {
     if (h.length <= 4) h = h.replace(/./g, (c) => c + c);
     return { hex: `#${h.slice(0, 6)}`, alpha: h.length === 8 ? parseInt(h.slice(6, 8), 16) / 255 : 1 };
   }
-  const num3 = "([+-]?[\\d.]+%?)";
-  m = new RegExp(`^rgba?\\(\\s*${num3}[\\s,]+${num3}[\\s,]+${num3}(?:\\s*[,/]\\s*${num3})?\\s*\\)$`).exec(text3);
+  const num4 = "([+-]?[\\d.]+%?)";
+  m = new RegExp(`^rgba?\\(\\s*${num4}[\\s,]+${num4}[\\s,]+${num4}(?:\\s*[,/]\\s*${num4})?\\s*\\)$`).exec(text3);
   if (m) {
     const rgb = [m[1], m[2], m[3]].map(channel);
     if (!rgb.every(Number.isFinite)) return null;
     return { hex: `#${rgb.map(hex2).join("")}`, alpha: alphaOf(m[4]) };
   }
-  m = new RegExp(`^hsla?\\(\\s*([+-]?[\\d.]+)(?:deg)?[\\s,]+${num3}[\\s,]+${num3}(?:\\s*[,/]\\s*${num3})?\\s*\\)$`).exec(text3);
+  m = new RegExp(`^hsla?\\(\\s*([+-]?[\\d.]+)(?:deg)?[\\s,]+${num4}[\\s,]+${num4}(?:\\s*[,/]\\s*${num4})?\\s*\\)$`).exec(text3);
   if (m) {
     const rgb = hslToRgb2(parseFloat(m[1]), parseFloat(m[2]) / 100, parseFloat(m[3]) / 100);
     if (!rgb.every(Number.isFinite)) return null;
@@ -2962,7 +2964,7 @@ function withNewIds(layer) {
   const next = { ...layer, id: newLayerId(layer.type === "adjustment" ? "adj" : layer.type) };
   if (next.type === "group") next.children = next.children.map(withNewIds);
   if (next.type === "annotation") next.annotation = { ...next.annotation, id: next.id };
-  if (next.type === "shape") delete next.annotation;
+  if (next.type === "shape" || next.type === "type") delete next.annotation;
   if (next.type === "smart" && next.psd?.placed) {
     next.psd = { ...next.psd };
     delete next.psd.placed;
@@ -2992,7 +2994,7 @@ function setLayerProperties(layers, id, props) {
     next.opacity = props.opacity;
   }
   if (props.fillOpacity !== void 0) {
-    if (layer.type !== "pixel" && layer.type !== "smart" && layer.type !== "shape") fail(`fillOpacity applies to pixel, shape and smart object layers; "${id}" is a ${layer.type} layer.`);
+    if (layer.type !== "pixel" && layer.type !== "smart" && layer.type !== "shape" && layer.type !== "type") fail(`fillOpacity applies to pixel, shape, type and smart object layers; "${id}" is a ${layer.type} layer.`);
     if (!(typeof props.fillOpacity === "number" && props.fillOpacity >= 0 && props.fillOpacity <= 1)) fail("fillOpacity must be a number from 0 to 1.");
     const p = next;
     if (props.fillOpacity === 1) delete p.fillOpacity;
@@ -3127,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) {
@@ -3416,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)) };
@@ -3424,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);
@@ -3463,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);
@@ -3520,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);
@@ -3753,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) {
@@ -3805,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) {
@@ -3887,6 +3897,671 @@ function annotationOfShape(layer) {
   return out;
 }
 
+// src/image-editor/layers/text.ts
+var fail3 = (message) => {
+  throw new LayerOperationError(message);
+};
+var DEFAULT_TEXT_STYLE = { fontFamily: "sans-serif", fontWeight: 400, fontSize: 24, color: "#000000" };
+var DEFAULT_AUTO_LEADING = 1.2;
+var sameStyle = (a, b) => JSON.stringify(a) === JSON.stringify(b);
+function compact(runs) {
+  const out = [];
+  for (const r of runs) {
+    if (r.length <= 0) continue;
+    const last = out[out.length - 1];
+    if (last && sameStyle(last.style, r.style)) out[out.length - 1] = { ...last, length: last.length + r.length };
+    else out.push({ ...r });
+  }
+  return out;
+}
+function fitRuns(runs, length, fallback) {
+  const out = [];
+  let left = length;
+  for (const r of runs) {
+    if (left <= 0) break;
+    const n = Math.min(Math.max(0, Math.floor(r.length)), left);
+    if (n > 0) out.push({ ...r, length: n });
+    left -= n;
+  }
+  if (left > 0) {
+    if (out.length) out[out.length - 1] = { ...out[out.length - 1], length: out[out.length - 1].length + left };
+    else out.push({ length: left, style: runs[runs.length - 1]?.style ?? fallback });
+  }
+  return compact(out);
+}
+function styleAt(runs, index, fallback) {
+  let at = 0;
+  for (const r of runs) {
+    if (index < at + r.length) return r.style;
+    at += r.length;
+  }
+  return runs[runs.length - 1]?.style ?? fallback;
+}
+function restyleRange(runs, start, end, patch) {
+  const out = [];
+  let at = 0;
+  for (const r of runs) {
+    const a = at;
+    const b = at + r.length;
+    at = b;
+    const lo = Math.max(a, start);
+    const hi = Math.min(b, end);
+    if (hi <= lo) {
+      out.push({ ...r });
+      continue;
+    }
+    if (lo > a) out.push({ length: lo - a, style: r.style });
+    out.push({ length: hi - lo, style: patch(r.style) });
+    if (b > hi) out.push({ length: b - hi, style: r.style });
+  }
+  return compact(out);
+}
+function spliceRuns(runs, start, end, inserted, style) {
+  const out = [];
+  let at = 0;
+  let placed = false;
+  for (const r of runs) {
+    const a = at;
+    const b = at + r.length;
+    at = b;
+    if (b <= start) {
+      out.push({ ...r });
+      continue;
+    }
+    if (a < start) out.push({ length: start - a, style: r.style });
+    if (!placed) {
+      out.push({ length: inserted, style });
+      placed = true;
+    }
+    if (b > end) out.push({ length: b - Math.max(end, a), style: r.style });
+  }
+  if (!placed) out.push({ length: inserted, style });
+  return compact(out);
+}
+function paragraphRanges(text3) {
+  const out = [];
+  let start = 0;
+  for (let i = 0; i < text3.length; i++) {
+    if (text3[i] === "\n") {
+      out.push({ start, end: i + 1, content: i });
+      start = i + 1;
+    }
+  }
+  out.push({ start, end: text3.length, content: text3.length });
+  return out;
+}
+function fitParagraphRuns(runs, text3) {
+  const fallback = runs[0]?.style ?? {};
+  const out = compact(paragraphRanges(text3).map((p) => ({ length: p.end - p.start, style: styleAt(runs, p.start, fallback) })));
+  return out.length ? out : [{ length: 0, style: fallback }];
+}
+function fontOf(style) {
+  const f = { family: style.fontFamily, weight: style.fontWeight, italic: Boolean(style.italic), size: style.fontSize };
+  if (style.postScriptName) f.postScriptName = style.postScriptName;
+  return f;
+}
+var isBreakAfter = (c) => c === " " || c === "	" || c === "-" || c === "\u2010" || c === "\u200B";
+var isSpace = (c) => c === " " || c === "	";
+var isWide = (code) => code >= 11904 && code <= 40959 || code >= 44032 && code <= 55215 || code >= 63744 && code <= 64255 || code >= 65280 && code <= 65519;
+var layoutCache = /* @__PURE__ */ new WeakMap();
+function layoutText(layer, shaper) {
+  let byShaper = layoutCache.get(layer);
+  const hit = byShaper?.get(shaper.id);
+  if (hit) return hit;
+  const out = computeLayout(layer, shaper);
+  if (!byShaper) {
+    byShaper = /* @__PURE__ */ new Map();
+    layoutCache.set(layer, byShaper);
+  }
+  byShaper.set(shaper.id, out);
+  return out;
+}
+function computeLayout(layer, shaper) {
+  const { text: text3, frame } = layer;
+  const runs = fitRuns(layer.runs, text3.length, DEFAULT_TEXT_STYLE);
+  const missing = /* @__PURE__ */ new Set();
+  const resolved = /* @__PURE__ */ new Map();
+  const familyOf = (font) => {
+    const key = `${font.family}|${font.weight}|${font.italic}|${font.postScriptName ?? ""}`;
+    let fam = resolved.get(key);
+    if (fam === void 0) {
+      const r = shaper.resolve(font);
+      fam = r.family;
+      if (!r.available) missing.add(font.family);
+      resolved.set(key, fam);
+    }
+    return fam;
+  };
+  const resolvedFont = (style) => ({ ...fontOf(style), family: familyOf(fontOf(style)) });
+  const box2 = frame.kind === "box" ? frame : null;
+  const lines = [];
+  let y = 0;
+  let first = true;
+  const paragraphs = paragraphRanges(text3);
+  paragraphs.forEach((para, pi) => {
+    const pstyle = styleAt(layer.paragraphs, para.start, {});
+    const autoLeading = pstyle.autoLeading ?? DEFAULT_AUTO_LEADING;
+    if (pi > 0) y += pstyle.spaceBefore ?? 0;
+    const chars = [];
+    let i = para.start;
+    while (i < para.content) {
+      const style = styleAt(runs, i, DEFAULT_TEXT_STYLE);
+      let j = i + 1;
+      while (j < para.content && styleAt(runs, j, DEFAULT_TEXT_STYLE) === style) j++;
+      const seg = text3.slice(i, j);
+      const carets = shaper.measure(seg, resolvedFont(style));
+      const track = (style.tracking ?? 0) / 1e3 * style.fontSize;
+      for (let k = 0; k < seg.length; k++) chars.push({ index: i + k, ch: seg[k], advance: (carets[k + 1] ?? 0) - (carets[k] ?? 0) + track, style });
+      i = j;
+    }
+    const startIndent = pstyle.startIndent ?? 0;
+    const endIndent = pstyle.endIndent ?? 0;
+    const firstIndent = pstyle.firstLineIndent ?? 0;
+    const breaks = [];
+    if (!box2 || !chars.length) breaks.push([0, chars.length]);
+    else {
+      let s = 0;
+      while (s < chars.length) {
+        const avail = box2.width - startIndent - endIndent - (breaks.length === 0 ? firstIndent : 0);
+        let w = 0;
+        let e = s;
+        let lastBreak = -1;
+        while (e < chars.length) {
+          const c = chars[e];
+          if (!isSpace(c.ch) && w + c.advance > avail && e > s) break;
+          w += c.advance;
+          if (isBreakAfter(c.ch) || isWide(c.ch.charCodeAt(0)) || e + 1 < chars.length && isWide(chars[e + 1].ch.charCodeAt(0))) lastBreak = e + 1;
+          e++;
+        }
+        if (e < chars.length && lastBreak > s) e = lastBreak;
+        while (e < chars.length && isSpace(chars[e].ch)) e++;
+        breaks.push([s, e]);
+        s = e;
+      }
+    }
+    const align = pstyle.align ?? "left";
+    breaks.forEach(([s, e], li) => {
+      const lineChars = chars.slice(s, e);
+      let visibleEnd = lineChars.length;
+      while (visibleEnd > 0 && isSpace(lineChars[visibleEnd - 1].ch)) visibleEnd--;
+      const styles = lineChars.length ? [...new Set(lineChars.map((c) => c.style))] : [styleAt(runs, Math.min(para.start, Math.max(0, text3.length - 1)), DEFAULT_TEXT_STYLE)];
+      let ascent = 0;
+      let descent = 0;
+      let leading = 0;
+      for (const st of styles) {
+        const m = shaper.metrics(resolvedFont(st));
+        ascent = Math.max(ascent, m.ascent);
+        descent = Math.max(descent, m.descent);
+        leading = Math.max(leading, st.leading ?? autoLeading * st.fontSize);
+      }
+      if (first) {
+        y = frame.kind === "box" || frame.kind === "point" && frame.origin === "top" ? ascent : 0;
+        first = false;
+      } else y += leading;
+      const indent = startIndent + (li === 0 ? firstIndent : 0);
+      let width = 0;
+      for (let k2 = 0; k2 < visibleEnd; k2++) width += lineChars[k2].advance;
+      const lastLine = li === breaks.length - 1;
+      let extraPerSpace = 0;
+      if (box2 && align === "justify" && !lastLine) {
+        const spaces = lineChars.slice(0, visibleEnd).filter((c) => isSpace(c.ch)).length;
+        const avail = box2.width - startIndent - endIndent - (li === 0 ? firstIndent : 0);
+        if (spaces > 0 && avail > width) extraPerSpace = (avail - width) / spaces;
+      }
+      let x0;
+      const fullWidth = width + extraPerSpace * lineChars.slice(0, visibleEnd).filter((c) => isSpace(c.ch)).length;
+      if (box2) {
+        const avail = box2.width - startIndent - endIndent - (li === 0 ? firstIndent : 0);
+        x0 = indent + (align === "center" ? (avail - fullWidth) / 2 : align === "right" ? avail - fullWidth : 0);
+      } else x0 = indent + (align === "center" ? -fullWidth / 2 : align === "right" ? -fullWidth : 0);
+      const laid = [];
+      let x = x0;
+      for (const c of lineChars) {
+        const adv = c.advance + (isSpace(c.ch) ? extraPerSpace : 0);
+        laid.push({ index: c.index, x, advance: adv });
+        x += adv;
+      }
+      const fragments = [];
+      let k = 0;
+      while (k < lineChars.length) {
+        const st = lineChars[k].style;
+        let m = k + 1;
+        while (m < lineChars.length && lineChars[m].style === st) m++;
+        const font = resolvedFont(st);
+        const fx = laid[k].x;
+        const carets = [0];
+        for (let q2 = k; q2 < m; q2++) carets.push(laid[q2].x + laid[q2].advance - fx);
+        fragments.push({
+          start: lineChars[k].index,
+          end: lineChars[m - 1].index + 1,
+          style: st,
+          font,
+          family: font.family,
+          x: fx,
+          y: y - (st.baselineShift ?? 0),
+          carets,
+          spaced: Boolean(st.tracking) || extraPerSpace > 0
+        });
+        k = m;
+      }
+      const lineStart = lineChars.length ? lineChars[0].index : para.start;
+      lines.push({ start: lineStart, end: lineChars.length ? lineChars[lineChars.length - 1].index + 1 : para.start, baseline: y, ascent, descent, x: x0, width, chars: laid, fragments });
+    });
+    y += pstyle.spaceAfter ?? 0;
+  });
+  let bounds;
+  if (box2) bounds = { x: 0, y: 0, width: box2.width, height: box2.height };
+  else {
+    let x0 = Infinity;
+    let x1 = -Infinity;
+    for (const l of lines) {
+      x0 = Math.min(x0, l.x);
+      x1 = Math.max(x1, l.x + l.width);
+    }
+    if (!Number.isFinite(x0)) x0 = x1 = 0;
+    const top = lines.length ? lines[0].baseline - lines[0].ascent : 0;
+    const last = lines[lines.length - 1];
+    const bottom = last ? last.baseline + last.descent : 0;
+    bounds = { x: x0, y: top, width: Math.max(0, x1 - x0), height: Math.max(0, bottom - top) };
+  }
+  return { lines, bounds, missingFonts: [...missing] };
+}
+function textIndexAt(layout, p) {
+  if (!layout.lines.length) return 0;
+  let line = layout.lines[layout.lines.length - 1];
+  for (const l of layout.lines) {
+    if (p.y <= l.baseline + l.descent) {
+      line = l;
+      break;
+    }
+  }
+  if (!line.chars.length) return line.start;
+  for (const c of line.chars) if (p.x < c.x + c.advance / 2) return c.index;
+  const lastChar = line.chars[line.chars.length - 1];
+  return lastChar.index + 1;
+}
+function caretAt(layout, index) {
+  const lines = layout.lines;
+  if (!lines.length) return { x: 0, top: 0, bottom: 0, line: 0 };
+  for (let li = 0; li < lines.length; li++) {
+    const l2 = lines[li];
+    const next = lines[li + 1];
+    if (next && index >= next.start && (next.chars.length || index > l2.end || next.start > l2.end)) continue;
+    const c = l2.chars.find((ch) => ch.index === index);
+    const prev = l2.chars.find((ch) => ch.index === index - 1);
+    const x = c ? c.x : prev ? prev.x + prev.advance : l2.x;
+    return { x, top: l2.baseline - l2.ascent, bottom: l2.baseline + l2.descent, line: li };
+  }
+  const l = lines[lines.length - 1];
+  return { x: l.x + l.width, top: l.baseline - l.ascent, bottom: l.baseline + l.descent, line: lines.length - 1 };
+}
+var TEXT_RENDER_MARGIN = MAX_EFFECT_REACH;
+function textMatrix(layer) {
+  return layer.transform ?? IDENTITY_MATRIX;
+}
+function rectCorners(r) {
+  return [
+    { x: r.x, y: r.y },
+    { x: r.x + r.width, y: r.y },
+    { x: r.x + r.width, y: r.y + r.height },
+    { x: r.x, y: r.y + r.height }
+  ];
+}
+function docRect(r, m) {
+  const pts = rectCorners(r).map((p) => applyMatrix(m, p));
+  const x0 = Math.floor(Math.min(...pts.map((p) => p.x)));
+  const y0 = Math.floor(Math.min(...pts.map((p) => p.y)));
+  const x1 = Math.ceil(Math.max(...pts.map((p) => p.x)));
+  const y1 = Math.ceil(Math.max(...pts.map((p) => p.y)));
+  return { x: x0, y: y0, width: x1 - x0, height: y1 - y0 };
+}
+function intersect2(a, b) {
+  const x0 = Math.max(a.x, b.x);
+  const y0 = Math.max(a.y, b.y);
+  const x1 = Math.min(a.x + a.width, b.x + b.width);
+  const y1 = Math.min(a.y + a.height, b.y + b.height);
+  return x1 > x0 && y1 > y0 ? { x: x0, y: y0, width: x1 - x0, height: y1 - y0 } : null;
+}
+function inkBounds(layout) {
+  let b = null;
+  for (const l of layout.lines) {
+    for (const f of l.fragments) {
+      const pad = f.style.fontSize * 0.5;
+      const w = f.carets[f.carets.length - 1];
+      const r = { x: f.x - pad, y: f.y - l.ascent - pad, width: w + 2 * pad, height: l.ascent + l.descent + 2 * pad };
+      if (!b) b = r;
+      else {
+        const x0 = Math.min(b.x, r.x);
+        const y0 = Math.min(b.y, r.y);
+        b = { x: x0, y: y0, width: Math.max(b.x + b.width, r.x + r.width) - x0, height: Math.max(b.y + b.height, r.y + r.height) - y0 };
+      }
+    }
+  }
+  return b;
+}
+function decorations(f, l) {
+  const out = [];
+  const t = Math.max(1, f.style.fontSize / 15);
+  const w = f.carets[f.carets.length - 1];
+  if (f.style.underline) out.push({ x: f.x, y: f.y + Math.max(t, l.descent * 0.35), width: w, height: t });
+  if (f.style.strikethrough) out.push({ x: f.x, y: f.y - l.ascent * 0.3 - t / 2, width: w, height: t });
+  return out;
+}
+var rectPath = (r) => [
+  { type: "M", x: r.x, y: r.y },
+  { type: "L", x: r.x + r.width, y: r.y },
+  { type: "L", x: r.x + r.width, y: r.y + r.height },
+  { type: "L", x: r.x, y: r.y + r.height },
+  { type: "Z" }
+];
+function fragmentOutline(shaper, text3, f) {
+  const s = text3.slice(f.start, f.end);
+  if (!f.spaced) return shaper.outline(s, f.font, f.x, f.y);
+  const out = [];
+  for (let k = 0; k < s.length; k++) {
+    if (isSpace(s[k])) continue;
+    out.push(...shaper.outline(s[k], f.font, f.x + f.carets[k], f.y));
+  }
+  return out;
+}
+function textOutlines(layer, shaper) {
+  if (!shaper.outline) fail3(`The text shaper "${shaper.id}" cannot give glyph outlines; plug in an outline shaper (createOutlineTextShaper) to convert text to shapes.`);
+  const layout = layoutText(layer, shaper);
+  const m = textMatrix(layer);
+  const out = [];
+  for (const l of layout.lines) {
+    for (const f of l.fragments) {
+      let path = fragmentOutline(shaper, layer.text, f);
+      for (const r of decorations(f, l)) path = [...path, ...rectPath(r)];
+      out.push({ fragment: f, path: isIdentityMatrix(m) ? path : transformBezierPath(path, m) });
+    }
+  }
+  return out;
+}
+var rgbOf = (hex) => {
+  const c = parseCssColor(hex);
+  const h = (c?.hex ?? "#000000").slice(1);
+  return [parseInt(h.slice(0, 2), 16), parseInt(h.slice(2, 4), 16), parseInt(h.slice(4, 6), 16)];
+};
+function renderOutlines(layer, shaper, region) {
+  const parts = textOutlines(layer, shaper).map(({ fragment, path }) => ({ style: fragment.style, flat: flattenPath(path) }));
+  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 n = TILE * TILE;
+    const acc = new Float32Array(n * 4);
+    let any = false;
+    for (const p of parts) {
+      const cov = rasterizeCoverageSampled(p.flat, rect, "nonzero");
+      if (!cov) continue;
+      const [r, g, b] = rgbOf(p.style.color);
+      const op = p.style.opacity ?? 1;
+      for (let i = 0; i < n; i++) {
+        const sa = layer.antiAlias === false ? cov[i] >= 0.5 ? op : 0 : cov[i] * op;
+        if (!(sa > 0)) continue;
+        const k = i * 4;
+        const da = acc[k + 3];
+        const ao = sa + da * (1 - sa);
+        acc[k] = (r * sa + acc[k] * da * (1 - sa)) / ao;
+        acc[k + 1] = (g * sa + acc[k + 1] * da * (1 - sa)) / ao;
+        acc[k + 2] = (b * sa + acc[k + 2] * da * (1 - sa)) / ao;
+        acc[k + 3] = ao;
+        any = true;
+      }
+    }
+    if (!any) continue;
+    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;
+      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(px2, 4, 0);
+    if (tile) tiles.set(tileKey(tx, ty), tile);
+  }
+  return new TiledSurface(4, tiles, 0);
+}
+function renderOnCanvas(layer, shaper, region, env) {
+  if (!env.createCanvas) return null;
+  const canvas = env.createCanvas(region.width, region.height);
+  const ctx = canvas.getContext("2d");
+  if (!ctx || typeof ctx.getImageData !== "function") return null;
+  const layout = layoutText(layer, shaper);
+  const m = textMatrix(layer);
+  ctx.setTransform(1, 0, 0, 1, 0, 0);
+  ctx.clearRect(0, 0, region.width, region.height);
+  ctx.setTransform(m[0], m[1], m[2], m[3], m[4] - region.x, m[5] - region.y);
+  for (const l of layout.lines) {
+    for (const f of l.fragments) {
+      const [r, g, b] = rgbOf(f.style.color);
+      ctx.fillStyle = `rgb(${r}, ${g}, ${b})`;
+      ctx.globalAlpha = f.style.opacity ?? 1;
+      const s = layer.text.slice(f.start, f.end);
+      if (!f.spaced) shaper.draw(ctx, s, f.font, f.x, f.y);
+      else for (let k = 0; k < s.length; k++) if (!isSpace(s[k])) shaper.draw(ctx, s[k], f.font, f.x + f.carets[k], f.y);
+      for (const d of decorations(f, l)) ctx.fillRect(d.x, d.y, d.width, d.height);
+    }
+  }
+  ctx.globalAlpha = 1;
+  ctx.setTransform(1, 0, 0, 1, 0, 0);
+  const data = ctx.getImageData(0, 0, region.width, region.height).data;
+  return surfaceFromPixels({ width: region.width, height: region.height, data: new Uint8ClampedArray(data) }, 4, region.x, region.y);
+}
+function renderText(layer, env) {
+  const shaper = env.shaper;
+  if (!shaper || !shaper.outline && !shaper.draw) return null;
+  const layout = layoutText(layer, shaper);
+  const ink = inkBounds(layout);
+  const clip = { x: -TEXT_RENDER_MARGIN, y: -TEXT_RENDER_MARGIN, width: env.width + 2 * TEXT_RENDER_MARGIN, height: env.height + 2 * TEXT_RENDER_MARGIN };
+  const region = ink ? intersect2(docRect(ink, textMatrix(layer)), clip) : null;
+  if (!region) return { surface: emptySurface(4), missingFonts: layout.missingFonts };
+  if (shaper.outline) return { surface: renderOutlines(layer, shaper, region), missingFonts: layout.missingFonts };
+  const surface = renderOnCanvas(layer, shaper, region, env);
+  return surface ? { surface, missingFonts: layout.missingFonts } : null;
+}
+function rerenderText(layer, env) {
+  const r = renderText(layer, env);
+  if (!r) return fail3("Type layers need a text shaper to draw them, and none is set here (no 2D canvas). Pass textShaper in the editor options (for example createOutlineTextShaper with your fonts), or edit in a browser.");
+  const next = { ...layer, surface: r.surface };
+  delete next.rendering;
+  if (r.missingFonts.length) next.missingFonts = r.missingFonts;
+  else delete next.missingFonts;
+  return next;
+}
+var isNum2 = (v) => typeof v === "number" && Number.isFinite(v);
+function num(v, path, min, max) {
+  if (!isNum2(v) || v < min || v > max) fail3(`${path} must be a number from ${min} to ${max}, got ${JSON.stringify(v)}.`);
+  return v;
+}
+var TEXT_STYLE_FIELDS = ["fontFamily", "fontWeight", "italic", "fontSize", "color", "opacity", "tracking", "leading", "baselineShift", "underline", "strikethrough"];
+function patchTextStyle(base, patch, path = "style") {
+  const out = { ...base };
+  const o = out;
+  for (const [k, v] of Object.entries(patch)) {
+    if (v === void 0) continue;
+    switch (k) {
+      case "fontFamily":
+        if (typeof v !== "string" || !v.trim()) fail3(`${path}.fontFamily must be a font family name.`);
+        out.fontFamily = v.trim();
+        if (out.postScriptName) delete out.postScriptName;
+        break;
+      case "fontWeight": {
+        const w = v === "normal" ? 400 : v === "bold" ? 700 : v;
+        out.fontWeight = Math.round(num(w, `${path}.fontWeight`, 1, 1e3));
+        if (out.postScriptName) delete out.postScriptName;
+        break;
+      }
+      case "italic":
+      case "underline":
+      case "strikethrough":
+        if (typeof v !== "boolean" && v !== null) fail3(`${path}.${k} must be true or false.`);
+        if (v) o[k] = true;
+        else delete o[k];
+        if (k === "italic" && out.postScriptName) delete out.postScriptName;
+        break;
+      case "fontSize":
+        out.fontSize = num(v, `${path}.fontSize`, 0.5, 5e3);
+        break;
+      case "color": {
+        const c = parseCssColor(v);
+        if (!c) fail3(`${path}.color must be a colour such as #rrggbb.`);
+        out.color = c.hex;
+        if (c.alpha < 1) out.opacity = c.alpha;
+        break;
+      }
+      case "opacity":
+      case "tracking":
+      case "leading":
+      case "baselineShift": {
+        if (v === null) {
+          delete o[k];
+          break;
+        }
+        const [min, max] = k === "opacity" ? [0, 1] : k === "tracking" ? [-1e3, 1e4] : k === "leading" ? [0, 1e4] : [-5e3, 5e3];
+        const value = num(v, `${path}.${k}`, min, max);
+        if (k === "opacity" && value === 1 || (k === "tracking" || k === "baselineShift") && value === 0) delete o[k];
+        else o[k] = value;
+        break;
+      }
+      default:
+        fail3(`${path}.${k} is not a character style field; use ${TEXT_STYLE_FIELDS.join(", ")}.`);
+    }
+  }
+  return out;
+}
+var PARAGRAPH_STYLE_FIELDS = ["align", "autoLeading", "firstLineIndent", "startIndent", "endIndent", "spaceBefore", "spaceAfter"];
+function patchParagraphStyle(base, patch, path = "paragraph") {
+  const out = { ...base };
+  const o = out;
+  for (const [k, v] of Object.entries(patch)) {
+    if (v === void 0) continue;
+    if (k === "align") {
+      if (!TEXT_ALIGNS.includes(v)) fail3(`${path}.align must be one of ${TEXT_ALIGNS.join(", ")}.`);
+      if (v === "left") delete out.align;
+      else out.align = v;
+    } else if (PARAGRAPH_STYLE_FIELDS.includes(k)) {
+      if (v === null) {
+        delete o[k];
+        continue;
+      }
+      const value = k === "autoLeading" ? num(v, `${path}.${k}`, 0.1, 10) : num(v, `${path}.${k}`, -1e4, 1e4);
+      if (k === "autoLeading" && value === DEFAULT_AUTO_LEADING || k !== "autoLeading" && value === 0) delete o[k];
+      else o[k] = value;
+    } else fail3(`${path}.${k} is not a paragraph style field; use ${PARAGRAPH_STYLE_FIELDS.join(", ")}.`);
+  }
+  return out;
+}
+function textRange(text3, start, end) {
+  const s = start === void 0 ? 0 : start;
+  const e = end === void 0 ? text3.length : end;
+  if (!Number.isInteger(s) || !Number.isInteger(e) || s < 0 || e > text3.length || s > e) {
+    fail3(`start and end must be whole numbers with 0 \u2264 start \u2264 end \u2264 ${text3.length} (the text's length in UTF-16 code units), got ${String(start)} and ${String(end)}.`);
+  }
+  return [s, e];
+}
+function requireTypeLayer(layers, id) {
+  const layer = requireLayer(layers, id).layer;
+  if (layer.type !== "type") fail3(`Layer "${layer.name || id}" is a ${layer.type} layer, not a type layer; list_layers shows each layer's type.`);
+  return layer;
+}
+function normalizeText(text3, path = "text") {
+  if (typeof text3 !== "string") return fail3(`${path} must be a string.`);
+  return text3.replace(/\r\n?/g, "\n");
+}
+function typeLayerName(text3) {
+  const line = text3.split("\n").find((l) => l.trim()) ?? "";
+  return line.trim().slice(0, 32) || "Text";
+}
+function createTypeLayer(init, env, id = newLayerId(), lenient = false) {
+  const text3 = normalizeText(init.text);
+  const layer = {
+    type: "type",
+    id,
+    name: init.name ?? typeLayerName(text3),
+    visible: true,
+    opacity: 1,
+    blend: "normal",
+    text: text3,
+    runs: fitRuns(init.runs, text3.length, DEFAULT_TEXT_STYLE),
+    paragraphs: fitParagraphRuns(init.paragraphs ?? [{ length: text3.length, style: {} }], text3),
+    frame: init.frame,
+    surface: emptySurface(4),
+    offset: { x: 0, y: 0 }
+  };
+  if (!layer.runs.length) layer.runs = [{ length: 0, style: init.runs[0]?.style ?? DEFAULT_TEXT_STYLE }];
+  if (init.transform && !isIdentityMatrix(init.transform)) layer.transform = init.transform;
+  if (lenient && !renderText(layer, env)) return { ...layer, rendering: "stored" };
+  return rerenderText(layer, env);
+}
+function updateTypeLayer(layers, id, change, env, action = "edit it") {
+  const current = requireTypeLayer(layers, id);
+  requireUnlocked(current, "pixels", action);
+  const patch = change(current);
+  const next = { ...current, ...patch };
+  if (!("annotation" in patch)) delete next.annotation;
+  if ("text" in patch || "runs" in patch) next.runs = fitRuns(next.runs, next.text.length, current.runs[0]?.style ?? DEFAULT_TEXT_STYLE);
+  if (!next.runs.length) next.runs = [{ length: 0, style: styleAt(current.runs, 0, DEFAULT_TEXT_STYLE) }];
+  if ("text" in patch || "paragraphs" in patch) next.paragraphs = fitParagraphRuns(next.paragraphs, next.text);
+  const rendered = rerenderText(next, env);
+  return { layers: mapLayer(layers, id, () => rendered), layer: rendered };
+}
+function replaceTextRange(layer, start, end, insert) {
+  const text3 = layer.text.slice(0, start) + insert + layer.text.slice(end);
+  const style = styleAt(layer.runs, start > 0 && start === layer.text.length ? start - 1 : start, DEFAULT_TEXT_STYLE);
+  const runs = spliceRuns(layer.runs, start, end, insert.length, style);
+  const pstyle = styleAt(layer.paragraphs, start, {});
+  const paragraphs = spliceRuns(layer.paragraphs, start, end, insert.length, pstyle);
+  return { text: text3, runs, paragraphs: fitParagraphRuns(paragraphs, text3) };
+}
+function transformTypeLayer(layer, m) {
+  const t = multiplyMatrices(textMatrix(layer), m);
+  const next = { ...layer };
+  if (isIdentityMatrix(t)) delete next.transform;
+  else next.transform = t;
+  delete next.annotation;
+  return next;
+}
+function typeFrame(layer, shaper) {
+  if (layer.frame.kind === "box") return { x: 0, y: 0, width: layer.frame.width, height: layer.frame.height };
+  if (!shaper) return fail3("Type layers need a text shaper to be measured; none is set here.");
+  const b = layoutText(layer, shaper).bounds;
+  return { x: b.x, y: b.y, width: Math.max(b.width, 1), height: Math.max(b.height, 1) };
+}
+function typeAsPixelLayer(layer) {
+  const { text: _t, runs: _r, paragraphs: _p, frame: _f, transform: _m, antiAlias: _a, rendering: _g, missingFonts: _mf, annotation: _an, psd: _psd, type: _ty, ...rest } = layer;
+  return { ...rest, type: "pixel", surface: layer.surface, offset: { x: 0, y: 0 } };
+}
+function toTextSpace(layer, p) {
+  return applyMatrix(invertMatrix(textMatrix(layer)), p);
+}
+function typeFromAnnotation(a) {
+  if (a.type !== "text") return null;
+  const t = a;
+  const c = parseCssColor(t.color);
+  if (!c) return null;
+  const weight = t.fontWeight === void 0 || t.fontWeight === "normal" ? 400 : t.fontWeight === "bold" ? 700 : Number(t.fontWeight);
+  if (!Number.isFinite(weight)) return null;
+  const style = { fontFamily: t.fontFamily || "sans-serif", fontWeight: weight, fontSize: t.fontSize, color: c.hex };
+  const op = c.alpha * (t.opacity ?? 1);
+  if (op !== 1) style.opacity = op;
+  const text3 = t.text.replace(/\r?\n|\r/g, " ");
+  const translate = [1, 0, 0, 1, t.x, t.y];
+  const transform = t.rotation ? multiplyMatrices(translate, rotateMatrix(t.rotation, { x: t.x, y: t.y })) : translate;
+  return { text: text3, runs: [{ length: text3.length, style }], frame: { kind: "point", origin: "top" }, transform };
+}
+function annotationOfType(layer) {
+  const a = layer.annotation;
+  if (!a) return null;
+  if ((a.blend ?? "normal") === layer.blend) return a;
+  const out = { ...a };
+  if (layer.blend === "normal") delete out.blend;
+  else out.blend = layer.blend;
+  return out;
+}
+
 // src/image-editor/layers/defaults.ts
 var DEFAULT_ADJUSTMENTS_VALUES = {
   brightness: 0,
@@ -3988,6 +4663,12 @@ function annotationLayerName(annotation) {
   }
 }
 function annotationLayerFor(annotation, canvas) {
+  const blend = annotation.blend && annotation.blend !== "normal" ? annotation.blend : "normal";
+  const type = canvas ? typeFromAnnotation(annotation) : null;
+  if (type) {
+    const layer = createTypeLayer({ ...type, name: annotationLayerName(annotation) }, { shaper: null, ...canvas }, annotation.id, true);
+    return { ...layer, blend, annotation };
+  }
   const shape = canvas ? shapeFromAnnotation(annotation) : null;
   if (shape) {
     const layer = createShapeLayer(
@@ -4010,6 +4691,7 @@ function annotationLayerFor(annotation, canvas) {
 function annotationOfLayer(layer) {
   if (layer.type === "annotation") return layer.annotation;
   if (layer.type === "shape") return annotationOfShape(layer);
+  if (layer.type === "type") return annotationOfType(layer);
   return null;
 }
 function adjustmentNodeFromLegacy(layer, width, height) {
@@ -4166,7 +4848,7 @@ function isLegacyShape(stack) {
   }
   for (; i < layers.length; i++) {
     const l = layers[i];
-    if (l.type === "shape") {
+    if (l.type === "shape" || l.type === "type") {
       const a = l.annotation;
       if (!a || (a.blend ?? "normal") !== l.blend || !isPlain({ ...l, blend: "normal" }) || l.fillOpacity !== void 0) return false;
       if (l.id !== a.id || l.name !== annotationLayerName(a)) return false;
@@ -4338,7 +5020,7 @@ function geometryHomography(geometry) {
 }
 
 // src/image-editor/layers/smart.ts
-var fail3 = (message) => {
+var fail4 = (message) => {
   throw new LayerOperationError(message);
 };
 var SMART_RENDER_MARGIN = MAX_EFFECT_REACH;
@@ -4360,13 +5042,13 @@ function isContentsDecoded(contents) {
 function requireDecoded(layer, action) {
   if (isContentsDecoded(layer.contents)) return;
   const what = layer.contents.file?.type ? `a ${layer.contents.file.type.toUpperCase()} file` : "a file";
-  fail3(
+  fail4(
     `The contents of smart object "${layer.name || layer.id}" are ${what} that could not be decoded here, so it cannot ${action}. Run prepareSmartObjects() in a browser first, or rasterize it.`
   );
 }
 function requireSmartObject(layers, id) {
   const layer = requireLayer(layers, id).layer;
-  if (layer.type !== "smart") fail3(`Layer "${layer.name || id}" is a ${layer.type} layer, not a smart object; convert it with convert_to_smart_object.`);
+  if (layer.type !== "smart") fail4(`Layer "${layer.name || id}" is a ${layer.type} layer, not a smart object; convert it with convert_to_smart_object.`);
   return layer;
 }
 var contentsPixels = /* @__PURE__ */ new WeakMap();
@@ -4392,11 +5074,11 @@ function contentsSurface(contents) {
   return s;
 }
 function rasterContents(pixels, name, id = newContentsId()) {
-  if (!(pixels.width > 0 && pixels.height > 0) || pixels.data.length < pixels.width * pixels.height * 4) fail3("Contents pixels must be RGBA with width \xD7 height \xD7 4 bytes.");
+  if (!(pixels.width > 0 && pixels.height > 0) || pixels.data.length < pixels.width * pixels.height * 4) fail4("Contents pixels must be RGBA with width \xD7 height \xD7 4 bytes.");
   return { id, name, width: pixels.width, height: pixels.height, kind: "raster", raster: surfaceFromPixels(pixels, 4, 0, 0) };
 }
 function documentContents(document, width, height, name, id = newContentsId()) {
-  if (!(Number.isInteger(width) && Number.isInteger(height) && width > 0 && height > 0)) fail3("Contents width and height must be positive whole numbers.");
+  if (!(Number.isInteger(width) && Number.isInteger(height) && width > 0 && height > 0)) fail4("Contents width and height must be positive whole numbers.");
   return { id, name, width, height, kind: "document", document };
 }
 var placedCache = /* @__PURE__ */ new WeakMap();
@@ -4457,16 +5139,16 @@ function placeContents(layer, canvas, options = {}) {
     try {
       if (hasWarp(g)) {
         const f = transformMap(g);
-        if (!f) fail3("The placement folds the contents over itself or through the horizon; keep the corners a convex quad.");
+        if (!f) fail4("The placement folds the contents over itself or through the horizon; keep the corners a convex quad.");
         out = warpSurface(source, (p) => f({ x: p.x * k, y: p.y * k }), { interpolation, source: box2, clip, step: step > 1 ? step : void 0 });
       } else {
         const h = transformHomography(g);
-        if (!h) fail3("The placement folds the contents over itself or through the horizon; keep the corners a convex quad.");
+        if (!h) fail4("The placement folds the contents over itself or through the horizon; keep the corners a convex quad.");
         const hk = multiplyHomographies([k, 0, 0, 0, k, 0, 0, 0, 1], h);
         out = transformSurface(source, hk, { interpolation, source: box2, clip, step: step > 1 ? step : void 0 });
       }
     } catch (e) {
-      if (e instanceof TransformTooLargeError) fail3(e.message);
+      if (e instanceof TransformTooLargeError) fail4(e.message);
       throw e;
     }
   }
@@ -4559,19 +5241,19 @@ function rerender(layer, canvas, action = "change") {
 function normalizePlacement(raw, contents) {
   const c = raw?.corners;
   if (!Array.isArray(c) || c.length !== 4 || !c.every((p) => p && Number.isFinite(p.x) && Number.isFinite(p.y))) {
-    fail3("corners must be four finite points [top-left, top-right, bottom-right, bottom-left] in document pixels.");
+    fail4("corners must be four finite points [top-left, top-right, bottom-right, bottom-left] in document pixels.");
   }
   const out = { corners: c.map((p) => ({ x: p.x, y: p.y })) };
   if (raw.warp) {
-    if (!isValidWarpMesh(raw.warp)) fail3("warp must be a mesh with us and vs (knots from 0 to 1, increasing) and (3\xB7columns + 1) \xD7 (3\xB7rows + 1) finite points in contents pixels.");
+    if (!isValidWarpMesh(raw.warp)) fail4("warp must be a mesh with us and vs (knots from 0 to 1, increasing) and (3\xB7columns + 1) \xD7 (3\xB7rows + 1) finite points in contents pixels.");
     out.warp = { us: [...raw.warp.us], vs: [...raw.warp.vs], points: raw.warp.points.map((p) => ({ x: p.x, y: p.y })) };
   }
   if (raw.interpolation !== void 0) {
-    if (!isInterpolation(raw.interpolation)) fail3(`Unknown interpolation "${String(raw.interpolation)}"; use nearest, bilinear or bicubic.`);
+    if (!isInterpolation(raw.interpolation)) fail4(`Unknown interpolation "${String(raw.interpolation)}"; use nearest, bilinear or bicubic.`);
     if (raw.interpolation !== "bicubic") out.interpolation = raw.interpolation;
   }
   const g = { box: { x: 0, y: 0, width: contents.width, height: contents.height }, corners: out.corners, warp: out.warp ?? null };
-  if (!transformHomography(g)) fail3("These corners fold the contents over themselves or through the horizon; keep the quad convex.");
+  if (!transformHomography(g)) fail4("These corners fold the contents over themselves or through the horizon; keep the quad convex.");
   if (out.warp && !hasWarp(g)) delete out.warp;
   return out;
 }
@@ -4636,7 +5318,7 @@ function translateLayer(layer, dx, dy) {
   if (!dx && !dy) return layer;
   const moveMask = (m) => {
     if (!m) return m;
-    if (m.source) fail3(`Layer "${layer.name || layer.id}" has a depth mask, which cannot move into a smart object; bake or remove it first.`);
+    if (m.source) fail4(`Layer "${layer.name || layer.id}" has a depth mask, which cannot move into a smart object; bake or remove it first.`);
     return { ...m, surface: translateSurface(m.surface, dx, dy) };
   };
   switch (layer.type) {
@@ -4674,14 +5356,19 @@ function translateLayer(layer, dx, dy) {
       delete next.annotation;
       return next;
     }
+    case "type": {
+      const next = { ...transformTypeLayer(layer, translateMatrix(dx, dy)), surface: translateSurface(layer.surface, dx, dy), mask: moveMask(layer.mask) };
+      if (!next.mask) delete next.mask;
+      return next;
+    }
     case "annotation":
-      return fail3(`Annotation layer "${layer.name || layer.id}" cannot go into a smart object; rasterize it first.`);
+      return fail4(`Annotation layer "${layer.name || layer.id}" cannot go into a smart object; rasterize it first.`);
   }
 }
 function layerExtent(layer, surfaceOf, canvas) {
   const full = { x: 0, y: 0, width: canvas.width, height: canvas.height };
   let b = null;
-  if (layer.type === "pixel" || layer.type === "smart" || layer.type === "shape") {
+  if (layer.type === "pixel" || layer.type === "smart" || layer.type === "shape" || layer.type === "type") {
     const s = layer.type === "pixel" ? surfaceOf(layer) : layer.surface;
     if (s.defaultValue !== 0) b = full;
     else {
@@ -4709,10 +5396,10 @@ function asSmartFilters(filters) {
   return { enabled: true, filters: filters.map((f) => ({ ...f, blend: "normal", opacity: 1 })) };
 }
 function convertToSmartObject(layers, ids, canvas, options) {
-  if (!ids.length) fail3("Give at least one layer id to convert.");
+  if (!ids.length) fail4("Give at least one layer id to convert.");
   const locs = [...new Set(ids)].map((id) => requireLayer(layers, id));
   const parent = locs[0].parent?.id ?? null;
-  if (locs.some((l) => (l.parent?.id ?? null) !== parent)) fail3("Layers to convert must share one parent; move them next to each other first.");
+  if (locs.some((l) => (l.parent?.id ?? null) !== parent)) fail4("Layers to convert must share one parent; move them next to each other first.");
   for (const l of locs) requireUnlocked(l.layer, "all", "convert it");
   const ordered = locs.sort((a, b) => a.index - b.index);
   const top = ordered[ordered.length - 1];
@@ -4720,9 +5407,9 @@ function convertToSmartObject(layers, ids, canvas, options) {
   const single = ordered.length === 1 ? ordered[0].layer : null;
   if (single && single.type === "pixel") {
     const surface = options.surfaceOf(single);
-    if (surface.defaultValue !== 0) fail3(`Layer "${single.name || single.id}" has no transparent area to crop to; it cannot be converted.`);
+    if (surface.defaultValue !== 0) fail4(`Layer "${single.name || single.id}" has no transparent area to crop to; it cannot be converted.`);
     const b = contentBounds(surface);
-    if (!b) fail3(`Layer "${single.name || single.id}" has no pixels to convert; paint something first.`);
+    if (!b) fail4(`Layer "${single.name || single.id}" has no pixels to convert; paint something first.`);
     const contents = {
       id: newContentsId(),
       name: `${single.name || "Layer"}.png`,
@@ -4754,7 +5441,7 @@ function convertToSmartObject(layers, ids, canvas, options) {
   } else {
     let b = null;
     for (const l of ordered) b = union(b, layerExtent(l.layer, options.surfaceOf, canvas));
-    if (!b || !(b.width > 0 && b.height > 0)) fail3("The layers have no pixels to convert; paint something first.");
+    if (!b || !(b.width > 0 && b.height > 0)) fail4("The layers have no pixels to convert; paint something first.");
     const nested = ordered.map((l) => {
       let layer = l.layer;
       if (layer.type === "pixel" && layer.source === "document") {
@@ -4762,7 +5449,7 @@ function convertToSmartObject(layers, ids, canvas, options) {
         delete resolved.source;
         layer = resolved;
       }
-      if (flattenLayers([layer]).some((x) => x.type === "pixel" && x.source === "document")) fail3(`Layer "${layer.name || layer.id}" holds the document image inside a group; convert the Background on its own.`);
+      if (flattenLayers([layer]).some((x) => x.type === "pixel" && x.source === "document")) fail4(`Layer "${layer.name || layer.id}" holds the document image inside a group; convert the Background on its own.`);
       return translateLayer(layer, -b.x, -b.y);
     });
     if (nested[0].clipped) {
@@ -4827,7 +5514,7 @@ function instancesOf(layers, contentsId) {
 }
 function replaceContents(layers, contentsId, contents, canvas) {
   const ids = instancesOf(layers, contentsId);
-  if (!ids.length) fail3(`No smart object uses contents "${contentsId}".`);
+  if (!ids.length) fail4(`No smart object uses contents "${contentsId}".`);
   for (const id of ids) requireUnlocked(findLayer(layers, id).layer, "all", "replace its contents");
   const next = { ...contents, id: contentsId };
   let out = layers;
@@ -4860,12 +5547,12 @@ function refitPlacement(layer, contents) {
   return out;
 }
 function normalizeSmartFilter(raw, id = newLayerId("flt")) {
-  if (raw.kind === "psd") fail3("Photoshop filters can only come from a PSD; add develop or blur.");
+  if (raw.kind === "psd") fail4("Photoshop filters can only come from a PSD; add develop or blur.");
   const base = normalizeFilter(raw, id);
   const blend = raw.blend ?? "normal";
-  if (!isBlendMode(blend) || blend === "pigment") fail3(`Unknown blend mode "${String(blend)}" for a smart filter.`);
+  if (!isBlendMode(blend) || blend === "pigment") fail4(`Unknown blend mode "${String(blend)}" for a smart filter.`);
   const opacity = raw.opacity ?? 1;
-  if (!(typeof opacity === "number" && opacity >= 0 && opacity <= 1)) fail3("opacity must be a number from 0 to 1.");
+  if (!(typeof opacity === "number" && opacity >= 0 && opacity <= 1)) fail4("opacity must be a number from 0 to 1.");
   return { ...base, blend, opacity };
 }
 function withStack(layer, stack, canvas) {
@@ -4880,7 +5567,7 @@ function stackOf(layer) {
 function requireFilter(layer, filterId) {
   const list2 = layer.smartFilters?.filters ?? [];
   const i = list2.findIndex((f) => f.id === filterId);
-  if (i === -1) fail3(`Smart object "${layer.name || layer.id}" has no smart filter "${filterId}". Filters: ${list2.map((f) => `${f.id} (${f.kind})`).join(", ") || "none"}; call get_smart_object.`);
+  if (i === -1) fail4(`Smart object "${layer.name || layer.id}" has no smart filter "${filterId}". Filters: ${list2.map((f) => `${f.id} (${f.kind})`).join(", ") || "none"}; call get_smart_object.`);
   return i;
 }
 function editableSmart(layers, id) {
@@ -4901,23 +5588,23 @@ function updateSmartFilter(layers, id, filterId, changes, canvas) {
   const layer = editableSmart(layers, id);
   const i = requireFilter(layer, filterId);
   const current = layer.smartFilters.filters[i];
-  if ("kind" in changes && changes.kind !== current.kind) fail3("A smart filter kind cannot change; remove it and add another.");
-  let merged;
+  if ("kind" in changes && changes.kind !== current.kind) fail4("A smart filter kind cannot change; remove it and add another.");
+  let merged2;
   if (current.kind === "psd") {
     const extra = Object.keys(changes).filter((k) => !["enabled", "blend", "opacity", "kind"].includes(k));
-    if (extra.length) fail3(`"${current.name}" is a Photoshop filter we keep but do not model; only enabled, blend and opacity change. Unknown: ${extra.join(", ")}.`);
+    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(", ")}.`);
     const blend = changes.blend ?? current.blend;
-    if (!isBlendMode(blend) || blend === "pigment") fail3(`Unknown blend mode "${String(blend)}" for a smart filter.`);
+    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)) fail3("opacity must be a number from 0 to 1.");
-    merged = { ...current, enabled: changes.enabled === void 0 ? current.enabled : Boolean(changes.enabled), blend, opacity };
+    if (!(typeof opacity === "number" && opacity >= 0 && opacity <= 1)) fail4("opacity must be a number from 0 to 1.");
+    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);
@@ -4931,7 +5618,7 @@ function moveSmartFilter(layers, id, filterId, index, canvas) {
   const layer = editableSmart(layers, id);
   const i = requireFilter(layer, filterId);
   const list2 = layer.smartFilters.filters;
-  if (!Number.isInteger(index) || index < 0 || index >= list2.length) fail3(`index must be a whole number from 0 to ${list2.length - 1}.`);
+  if (!Number.isInteger(index) || index < 0 || index >= list2.length) fail4(`index must be a whole number from 0 to ${list2.length - 1}.`);
   const filters = [...list2];
   const [f] = filters.splice(i, 1);
   filters.splice(index, 0, f);
@@ -4945,7 +5632,7 @@ function setSmartFiltersEnabled(layers, id, enabled, canvas) {
 }
 function setSmartFilterMask(layers, id, mask, canvas) {
   const layer = editableSmart(layers, id);
-  if (mask?.source) fail3("A smart filter mask is painted, not generated; use a raster mask.");
+  if (mask?.source) fail4("A smart filter mask is painted, not generated; use a raster mask.");
   const stack = { ...stackOf(layer) };
   if (mask) stack.mask = mask;
   else delete stack.mask;
@@ -4954,7 +5641,7 @@ function setSmartFilterMask(layers, id, mask, canvas) {
 }
 function withFilterMaskSurface(layer, surface, canvas) {
   const stack = stackOf(layer);
-  if (!stack.mask) fail3(`Smart object "${layer.name || layer.id}" has no filter mask; add one with set_smart_filter_mask.`);
+  if (!stack.mask) fail4(`Smart object "${layer.name || layer.id}" has no filter mask; add one with set_smart_filter_mask.`);
   return withStack(layer, { ...stack, mask: { ...stack.mask, surface } }, canvas);
 }
 function placementBounds(layer) {
@@ -5075,6 +5762,86 @@ function serializeLayer(layer, ctx) {
       return serializeSmartObject(layer, base, ctx);
     case "shape":
       return serializeShape(layer, base);
+    case "type":
+      return serializeType(layer, base, ctx);
+  }
+}
+function serializeType(layer, base, ctx) {
+  const out = {
+    ...base,
+    type: "type",
+    text: layer.text,
+    runs: JSON.parse(JSON.stringify(layer.runs)),
+    paragraphs: JSON.parse(JSON.stringify(layer.paragraphs)),
+    frame: { ...layer.frame }
+  };
+  if (layer.transform) out.transform = [...layer.transform];
+  if (layer.antiAlias === false) out.antiAlias = false;
+  if (layer.fillOpacity !== void 0 && layer.fillOpacity !== 1) out.fillOpacity = layer.fillOpacity;
+  const enc = encodeSurface(layer.surface);
+  if (enc) {
+    out.asset = ctx.addAsset(enc.url, layer.id);
+    out.x = enc.x;
+    out.y = enc.y;
+  }
+  if (layer.missingFonts?.length) out.missingFonts = [...layer.missingFonts];
+  if (layer.annotation) out.annotation = JSON.parse(JSON.stringify(layer.annotation));
+  if (layer.psd?.tySh || layer.psd?.blocks?.length) {
+    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;
+}
+function readType(r, base, ctx) {
+  const label = `Layer "${base.name || base.id}"`;
+  try {
+    const text3 = normalizeText(r.text ?? "");
+    const runs = (Array.isArray(r.runs) ? r.runs : []).map((run, i) => ({
+      length: Math.max(0, Math.floor(num2(run?.length, 0, 1e9, 0))),
+      style: patchTextStyle(DEFAULT_TEXT_STYLE, run?.style && typeof run.style === "object" ? run.style : {}, `runs[${i}].style`)
+    }));
+    const paragraphs = (Array.isArray(r.paragraphs) ? r.paragraphs : []).map((p, i) => ({
+      length: Math.max(0, Math.floor(num2(p?.length, 0, 1e9, 0))),
+      style: patchParagraphStyle({}, p?.style && typeof p.style === "object" ? p.style : {}, `paragraphs[${i}].style`)
+    }));
+    const f = r.frame;
+    const frame = f?.kind === "box" ? { kind: "box", width: num2(f.width, 1, 1e6, 100), height: num2(f.height, 1, 1e6, 100) } : f?.origin === "top" ? { kind: "point", origin: "top" } : { kind: "point" };
+    const m = Array.isArray(r.transform) && r.transform.length === 6 && r.transform.every((v) => typeof v === "number" && Number.isFinite(v)) ? r.transform : void 0;
+    const layer = {
+      ...base,
+      type: "type",
+      text: text3,
+      runs: fitRuns(runs, text3.length, DEFAULT_TEXT_STYLE),
+      paragraphs: fitParagraphRuns(paragraphs.length ? paragraphs : [{ length: text3.length, style: {} }], text3),
+      frame,
+      surface: emptySurface(4),
+      offset: { x: 0, y: 0 }
+    };
+    if (!layer.runs.length) layer.runs = [{ length: 0, style: runs[0]?.style ?? DEFAULT_TEXT_STYLE }];
+    if (m) layer.transform = m;
+    if (r.antiAlias === false) layer.antiAlias = false;
+    if (typeof r.fillOpacity === "number" && r.fillOpacity !== 1) layer.fillOpacity = num2(r.fillOpacity, 0, 1, 1);
+    if (Array.isArray(r.missingFonts)) layer.missingFonts = r.missingFonts.filter((x) => typeof x === "string");
+    if (r.annotation && typeof r.annotation === "object" && r.annotation.type === "text") layer.annotation = JSON.parse(JSON.stringify({ ...r.annotation, id: r.annotation.id ?? base.id }));
+    if (r.psd && typeof r.psd === "object") {
+      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" };
+    const env = { ...ctx.canvas ?? { width: 1, height: 1 }, shaper: ctx.text?.shaper ?? null, createCanvas: ctx.text?.createCanvas };
+    try {
+      return rerenderText(layer, env);
+    } catch {
+      return { ...layer, rendering: "stored" };
+    }
+  } catch (e) {
+    ctx.problems.push(`${label}: the text could not be read (${e instanceof Error ? e.message : String(e)})`);
+    return null;
   }
 }
 function serializeShape(layer, base) {
@@ -5086,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) {
@@ -5115,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 = num(r.fillOpacity, 0, 1, 1);
+    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) {
@@ -5269,7 +6038,7 @@ function decodePngDataUrl(url, channels) {
   }
   return { width: png.width, height: png.height, data: out };
 }
-var num = (v, lo, hi, fallback) => typeof v === "number" && Number.isFinite(v) ? Math.min(hi, Math.max(lo, v)) : fallback;
+var num2 = (v, lo, hi, fallback) => typeof v === "number" && Number.isFinite(v) ? Math.min(hi, Math.max(lo, v)) : fallback;
 function readSurface(ref, x, y, channels, defaultValue, ctx, what) {
   if (typeof ref !== "string" || !ref) return emptySurface(channels, defaultValue);
   const url = ctx.assets[ref];
@@ -5278,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(num(x, -1e7, 1e7, 0)), Math.round(num(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);
@@ -5293,8 +6062,8 @@ function readMask(raw, ctx, what) {
     surface: r.source ? emptySurface(1, 255) : readSurface(r.asset, r.x, r.y, 1, defaultValue, ctx, `${what} mask`),
     defaultValue: r.source ? 255 : defaultValue
   };
-  if (typeof r.density === "number" && r.density !== 1) mask.density = num(r.density, 0, 1, 1);
-  if (typeof r.feather === "number" && r.feather > 0) mask.feather = num(r.feather, 0, 1e3, 0);
+  if (typeof r.density === "number" && r.density !== 1) mask.density = num2(r.density, 0, 1, 1);
+  if (typeof r.feather === "number" && r.feather > 0) mask.feather = num2(r.feather, 0, 1e3, 0);
   if (r.enabled === false) mask.enabled = false;
   if (r.linked === false) mask.linked = false;
   if (r.source && typeof r.source === "object") {
@@ -5311,18 +6080,18 @@ function readFilters(raw) {
     const r = f;
     const id = typeof r.id === "string" && r.id ? r.id : newLayerId("flt");
     const enabled = r.enabled !== false;
-    if (r.kind === "blur") out.push({ id, kind: "blur", enabled, radius: num(r.radius, 0, 50, 0) });
+    if (r.kind === "blur") out.push({ id, kind: "blur", enabled, radius: num2(r.radius, 0, 50, 0) });
     else if (r.kind === "develop") {
       out.push({
         id,
         kind: "develop",
         enabled,
-        brightness: num(r.brightness, -100, 100, 0),
-        contrast: num(r.contrast, -100, 100, 0),
-        saturation: num(r.saturation, -100, 100, 0),
-        exposure: num(r.exposure, -100, 100, 0),
-        temperature: num(r.temperature, -100, 100, 0),
-        tint: num(r.tint, -100, 100, 0),
+        brightness: num2(r.brightness, -100, 100, 0),
+        contrast: num2(r.contrast, -100, 100, 0),
+        saturation: num2(r.saturation, -100, 100, 0),
+        exposure: num2(r.exposure, -100, 100, 0),
+        temperature: num2(r.temperature, -100, 100, 0),
+        tint: num2(r.tint, -100, 100, 0),
         process: normalizeProcessVersion(r.process)
       });
     }
@@ -5337,7 +6106,7 @@ function deserializeLayer(raw, ctx) {
     id,
     name: typeof r.name === "string" ? r.name : "",
     visible: r.visible !== false,
-    opacity: num(r.opacity, 0, 1, 1),
+    opacity: num2(r.opacity, 0, 1, 1),
     blend: normalizeBlendMode(r.blend)
   };
   if (r.clipped === true) base.clipped = true;
@@ -5356,10 +6125,10 @@ function deserializeLayer(raw, ctx) {
         ...base,
         type: "pixel",
         surface: r.source === "document" ? emptySurface(4) : readSurface(r.asset, r.x, r.y, 4, 0, ctx, `Layer "${base.name || id}"`),
-        offset: { x: Math.round(num(r.offset?.x, -1e7, 1e7, 0)), y: Math.round(num(r.offset?.y, -1e7, 1e7, 0)) }
+        offset: { x: Math.round(num2(r.offset?.x, -1e7, 1e7, 0)), y: Math.round(num2(r.offset?.y, -1e7, 1e7, 0)) }
       };
       if (r.source === "document") layer.source = "document";
-      if (typeof r.fillOpacity === "number" && r.fillOpacity !== 1) layer.fillOpacity = num(r.fillOpacity, 0, 1, 1);
+      if (typeof r.fillOpacity === "number" && r.fillOpacity !== 1) layer.fillOpacity = num2(r.fillOpacity, 0, 1, 1);
       const filters = readFilters(r.filters);
       if (filters) layer.filters = filters;
       return layer;
@@ -5386,15 +6155,17 @@ function deserializeLayer(raw, ctx) {
         return null;
       }
       const annotation = JSON.parse(JSON.stringify({ ...a, id: typeof a.id === "string" ? a.id : id }));
-      const migrated = annotationLayerFor(annotation, ctx.canvas ?? { width: 1, height: 1 });
-      if (migrated.type === "shape") {
+      const migrated = annotationLayerFor(annotation, { ...ctx.canvas ?? { width: 1, height: 1 }, shaper: ctx.text?.shaper ?? null, createCanvas: ctx.text?.createCanvas });
+      if (migrated.type === "shape" || migrated.type === "type") {
         const blend = base.blend === "normal" ? migrated.blend : base.blend;
-        return { ...migrated, ...base, blend, type: "shape", id, name: base.name };
+        return { ...migrated, ...base, blend, id, name: base.name };
       }
       return { ...base, type: "annotation", annotation };
     }
     case "shape":
       return readShape(r, base, ctx);
+    case "type":
+      return readType(r, base, ctx);
     case "smart":
       return readSmartObject(r, base, ctx);
     default:
@@ -5414,8 +6185,8 @@ function readContents(id, ctx) {
     ctx.problems.push(`Smart object contents "${id}" are missing`);
     return null;
   }
-  const width = Math.round(num(raw.width, 0, 3e5, 0));
-  const height = Math.round(num(raw.height, 0, 3e5, 0));
+  const width = Math.round(num2(raw.width, 0, 3e5, 0));
+  const height = Math.round(num2(raw.height, 0, 3e5, 0));
   if (!(width > 0 && height > 0)) {
     ctx.problems.push(`Smart object contents "${id}" have no size`);
     return null;
@@ -5439,7 +6210,7 @@ function readContents(id, ctx) {
     const layers = deserializeLayers(raw.layers, ctx);
     ctx.canvas = outer;
     c.document = { layers };
-    if (raw.globalLight && typeof raw.globalLight === "object") c.document.globalLight = { angle: num(raw.globalLight.angle, -360, 360, 120), altitude: num(raw.globalLight.altitude, 0, 90, 30) };
+    if (raw.globalLight && typeof raw.globalLight === "object") c.document.globalLight = { angle: num2(raw.globalLight.angle, -360, 360, 120), altitude: num2(raw.globalLight.altitude, 0, 90, 30) };
     const patterns = deserializePatterns(raw.patterns, ctx.problems);
     if (patterns.length) c.document.patterns = patterns;
   }
@@ -5456,7 +6227,7 @@ function readSmartFilters(raw, ctx, what) {
   for (const f of list2) {
     if (!f || typeof f !== "object") continue;
     const blend = isBlendMode(f.blend) && f.blend !== "pigment" ? f.blend : "normal";
-    const opacity = num(f.opacity, 0, 1, 1);
+    const opacity = num2(f.opacity, 0, 1, 1);
     if (f.kind === "psd") {
       try {
         filters.push({ id: typeof f.id === "string" ? f.id : newLayerId("flt"), kind: "psd", enabled: f.enabled !== false, name: typeof f.name === "string" ? f.name : "Filter", data: base64ToBytes(String(f.data ?? "")), blend, opacity });
@@ -5494,7 +6265,7 @@ function readSmartObject(r, base, ctx) {
   const layer = { ...base, type: "smart", contents, placement, surface: emptySurface(4), offset: { x: 0, y: 0 } };
   const filters = readSmartFilters(r.smartFilters, ctx, what);
   if (filters) layer.smartFilters = filters;
-  if (typeof r.fillOpacity === "number" && r.fillOpacity !== 1) layer.fillOpacity = num(r.fillOpacity, 0, 1, 1);
+  if (typeof r.fillOpacity === "number" && r.fillOpacity !== 1) layer.fillOpacity = num2(r.fillOpacity, 0, 1, 1);
   if (r.psd && typeof r.psd.key === "string" && typeof r.psd.data === "string") {
     try {
       layer.psd = { key: r.psd.key, data: base64ToBytes(r.psd.data) };
@@ -5599,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`);
@@ -5707,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);
@@ -5756,180 +6527,24 @@ 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);
+// src/image-editor/psd/descriptor.ts
+var MAX_DEPTH = 64;
+var STRING_IDS = /* @__PURE__ */ new Set(["warp", "list", "time"]);
+function descriptor(classId, items = []) {
+  return { name: "", classId, items };
 }
-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 descGet(d, key) {
+  return d.items.find(([k]) => k === key)?.[1];
 }
-function packbitsBound(n) {
-  return n + Math.ceil(n / 128);
+function descNumber(d, key) {
+  const v = descGet(d, key);
+  if (!v) return void 0;
+  if (v.type === "long" || v.type === "doub" || v.type === "UntF" || v.type === "comp") return v.value;
+  return void 0;
 }
-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"]);
-function descriptor(classId, items = []) {
-  return { name: "", classId, items };
-}
-function descGet(d, key) {
-  return d.items.find(([k]) => k === key)?.[1];
-}
-function descNumber(d, key) {
-  const v = descGet(d, key);
-  if (!v) return void 0;
-  if (v.type === "long" || v.type === "doub" || v.type === "UntF" || v.type === "comp") return v.value;
-  return void 0;
-}
-function descBool(d, key) {
-  const v = descGet(d, key);
-  return v?.type === "bool" ? v.value : void 0;
+function descBool(d, key) {
+  const v = descGet(d, key);
+  return v?.type === "bool" ? v.value : void 0;
 }
 function descObject(d, key) {
   const v = descGet(d, key);
@@ -6027,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() };
@@ -6393,137 +7008,1477 @@ function parseAdjustmentBlock(key, data) {
         const highlights = tone();
         return { kind: "colorBalance", params: { shadows, midtones, highlights, preserveLuminosity: r.u8() !== 0 } };
       }
-      case "blwh":
-        return parseBlackWhite(data);
-      case "phfl":
-        return parsePhotoFilter(data);
-      default:
-        return null;
+      case "blwh":
+        return parseBlackWhite(data);
+      case "phfl":
+        return parsePhotoFilter(data);
+      default:
+        return null;
+    }
+  } catch {
+    return null;
+  }
+}
+var q = (v) => Math.round(clamp2(v, 0, 255));
+var i16 = (v) => Math.round(clamp2(v, -32768, 32767));
+function writeLevels(w, c) {
+  w.u16(q(c.inBlack));
+  w.u16(q(c.inWhite));
+  w.u16(q(c.outBlack));
+  w.u16(q(c.outWhite));
+  w.u16(Math.round(clamp2(c.gamma * 100, 1, 999)));
+}
+var long = (value) => ({ type: "long", value: i16(value) });
+function writeAdjustmentBlock(kind, params) {
+  const w = new PsdWriter();
+  switch (kind) {
+    case "invert":
+      return { key: "nvrt", data: new Uint8Array(0) };
+    case "threshold": {
+      const p = params;
+      w.u16(Math.max(1, q(p.level)));
+      w.u16(0);
+      return { key: "thrs", data: w.result() };
+    }
+    case "posterize": {
+      const p = params;
+      w.u16(Math.round(clamp2(p.levels, 2, 255)));
+      w.u16(0);
+      return { key: "post", data: w.result() };
+    }
+    case "levels": {
+      const p = params;
+      w.u16(2);
+      for (const c of [p.master, p.red, p.green, p.blue]) writeLevels(w, c);
+      const ident = { inBlack: 0, inWhite: 255, gamma: 1, outBlack: 0, outWhite: 255 };
+      for (let i = 4; i < 29; i++) writeLevels(w, ident);
+      return { key: "levl", data: w.result() };
+    }
+    case "curves": {
+      const p = params;
+      w.u8(0);
+      w.u16(1);
+      w.u32(15);
+      for (const c of [p.master, p.red, p.green, p.blue]) {
+        const pts = c.slice(0, 19);
+        w.u16(pts.length);
+        for (const pt of pts) {
+          w.u16(q(pt.output));
+          w.u16(q(pt.input));
+        }
+      }
+      return { key: "curv", data: w.result() };
+    }
+    case "hueSaturation": {
+      const p = params;
+      w.u16(2);
+      w.u8(p.colorize ? 1 : 0);
+      w.u8(0);
+      for (let k = 0; k < 2; k++) for (const x of [p.hue, p.saturation, p.lightness]) w.i16(i16(x));
+      for (let i = 0; i < 6; i++) {
+        const r = p.ranges[i] ?? neutralHueRange(i);
+        for (const b of r.bounds) w.u16(Math.round((b % 360 + 360) % 360) % 360);
+        for (const x of [r.hue, r.saturation, r.lightness]) w.i16(i16(x));
+      }
+      return { key: "hue2", data: w.result() };
+    }
+    case "vibrance": {
+      const p = params;
+      const d = descriptor("null", [
+        ["vibrance", long(clamp2(p.vibrance, -100, 100))],
+        ["Strt", long(clamp2(p.saturation, -100, 100))]
+      ]);
+      return { key: "vibA", data: versionedDescriptorBytes(d) };
+    }
+    case "colorBalance": {
+      const p = params;
+      for (const x of [...p.shadows, ...p.midtones, ...p.highlights]) w.i16(i16(clamp2(x, -100, 100)));
+      w.u8(p.preserveLuminosity ? 1 : 0);
+      w.u8(0);
+      return { key: "blnc", data: w.result() };
+    }
+    case "blackWhite": {
+      const p = params;
+      const tint = p.tint ? hexToRgb(p.tint) : BW_TINT;
+      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  ", dbl4(tint[0])], ["Grn ", dbl4(tint[1])], ["Bl  ", dbl4(tint[2])]]) }],
+        ["bwPresetKind", { type: "long", value: 1 }],
+        ["blackAndWhitePresetFileName", { type: "TEXT", value: "" }]
+      );
+      return { key: "blwh", data: versionedDescriptorBytes(descriptor("null", items)) };
+    }
+    case "photoFilter": {
+      const p = params;
+      const rgb = hexToRgb(p.color);
+      w.u16(2);
+      w.u16(0);
+      for (const x of rgb) w.u16(Math.round(clamp2(x, 0, 1) * 65535));
+      w.u16(0);
+      w.u32(Math.round(clamp2(p.density, 0, 100)));
+      w.u8(p.preserveLuminosity ? 1 : 0);
+      w.zeros(3);
+      return { key: "phfl", data: w.result() };
+    }
+  }
+  throw new Error(`Unknown adjustment kind "${kind}".`);
+}
+
+// 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 obj = (d) => ({ type: "Objc", value: d });
+var enumOf = (d, key) => {
+  const v = descGet(d, key);
+  return v?.type === "enum" ? v.value : void 0;
+};
+function read(data) {
+  try {
+    return parseVersionedDescriptor(data);
+  } catch {
+    return null;
+  }
+}
+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;
+  }
+  if (v.type === "doub" || v.type === "long") return v.value;
+  return void 0;
+}
+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 null;
+}
+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}.`);
     }
-  } catch {
-    return null;
   }
 }
-var q = (v) => Math.round(clamp2(v, 0, 255));
-var i16 = (v) => Math.round(clamp2(v, -32768, 32767));
-function writeLevels(w, c) {
-  w.u16(q(c.inBlack));
-  w.u16(q(c.inWhite));
-  w.u16(q(c.outBlack));
-  w.u16(q(c.outWhite));
-  w.u16(Math.round(clamp2(c.gamma * 100, 1, 999)));
+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;
 }
-var long = (value) => ({ type: "long", value: i16(value) });
-function writeAdjustmentBlock(kind, params) {
-  const w = new PsdWriter();
-  switch (kind) {
-    case "invert":
-      return { key: "nvrt", data: new Uint8Array(0) };
-    case "threshold": {
-      const p = params;
-      w.u16(Math.max(1, q(p.level)));
-      w.u16(0);
-      return { key: "thrs", data: w.result() };
-    }
-    case "posterize": {
-      const p = params;
-      w.u16(Math.round(clamp2(p.levels, 2, 255)));
-      w.u16(0);
-      return { key: "post", data: w.result() };
-    }
-    case "levels": {
-      const p = params;
-      w.u16(2);
-      for (const c of [p.master, p.red, p.green, p.blue]) writeLevels(w, c);
-      const ident = { inBlack: 0, inWhite: 255, gamma: 1, outBlack: 0, outWhite: 255 };
-      for (let i = 4; i < 29; i++) writeLevels(w, ident);
-      return { key: "levl", data: w.result() };
-    }
-    case "curves": {
-      const p = params;
-      w.u8(0);
-      w.u16(1);
-      w.u32(15);
-      for (const c of [p.master, p.red, p.green, p.blue]) {
-        const pts = c.slice(0, 19);
-        w.u16(pts.length);
-        for (const pt of pts) {
-          w.u16(q(pt.output));
-          w.u16(q(pt.input));
-        }
-      }
-      return { key: "curv", data: w.result() };
-    }
-    case "hueSaturation": {
-      const p = params;
-      w.u16(2);
-      w.u8(p.colorize ? 1 : 0);
-      w.u8(0);
-      for (let k = 0; k < 2; k++) for (const x of [p.hue, p.saturation, p.lightness]) w.i16(i16(x));
-      for (let i = 0; i < 6; i++) {
-        const r = p.ranges[i] ?? neutralHueRange(i);
-        for (const b of r.bounds) w.u16(Math.round((b % 360 + 360) % 360) % 360);
-        for (const x of [r.hue, r.saturation, r.lightness]) w.i16(i16(x));
-      }
-      return { key: "hue2", data: w.result() };
-    }
-    case "vibrance": {
-      const p = params;
-      const d = descriptor("null", [
-        ["vibrance", long(clamp2(p.vibrance, -100, 100))],
-        ["Strt", long(clamp2(p.saturation, -100, 100))]
-      ]);
-      return { key: "vibA", data: versionedDescriptorBytes(d) };
-    }
-    case "colorBalance": {
-      const p = params;
-      for (const x of [...p.shadows, ...p.midtones, ...p.highlights]) w.i16(i16(clamp2(x, -100, 100)));
-      w.u8(p.preserveLuminosity ? 1 : 0);
-      w.u8(0);
-      return { key: "blnc", data: w.result() };
-    }
-    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 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])]]) }],
-        ["bwPresetKind", { type: "long", value: 1 }],
-        ["blackAndWhitePresetFileName", { type: "TEXT", value: "" }]
-      );
-      return { key: "blwh", data: versionedDescriptorBytes(descriptor("null", items)) };
+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;
     }
-    case "photoFilter": {
-      const p = params;
-      const rgb = hexToRgb(p.color);
-      w.u16(2);
-      w.u16(0);
-      for (const x of rgb) w.u16(Math.round(clamp2(x, 0, 1) * 65535));
-      w.u16(0);
-      w.u32(Math.round(clamp2(p.density, 0, 100)));
-      w.u8(p.preserveLuminosity ? 1 : 0);
-      w.zeros(3);
-      return { key: "phfl", data: w.result() };
+    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;
     }
   }
-  throw new Error(`Unknown adjustment kind "${kind}".`);
+  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 dbl = (value) => ({ type: "doub", value });
-var unit = (u, value) => ({ type: "UntF", unit: u, value });
-var long2 = (value) => ({ type: "long", value: Math.round(value) });
-var boolV = (value) => ({ type: "bool", value });
-var enumV = (typeId, value) => ({ type: "enum", typeId, value });
+var 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 obj = (d) => ({ type: "Objc", value: d });
+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 enumOf = (d, key) => {
+var enumOf2 = (d, key) => {
   const v = descGet(d, key);
   return v?.type === "enum" ? v.value : void 0;
 };
@@ -6750,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");
@@ -6769,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);
@@ -6782,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
     );
@@ -6799,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) {
@@ -6820,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) };
 }
@@ -6920,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))]
     ])
   );
 }
@@ -6948,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`);
   }
@@ -6960,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 }]
   ]);
 }
@@ -7000,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);
@@ -7008,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();
@@ -7252,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;
@@ -7263,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);
@@ -7375,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);
@@ -7800,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"];
@@ -8043,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);
@@ -8060,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;
@@ -8231,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)) {
@@ -8353,10 +10390,10 @@ function blendFromPsdId(id) {
 function psdBlendId(mode) {
   return BLEND_ID.get(mode) ?? "Nrml";
 }
-var num2 = (d, key, fallback) => descNumber(d, key) ?? fallback;
-var pct = (d, key, fallback) => num2(d, key, fallback * 100) / 100;
+var 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;
 };
@@ -8370,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;
@@ -8417,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) {
@@ -8427,7 +10464,7 @@ function contourOf(d, key) {
   if (!c) return void 0;
   const name = text2(c, "Nm  ");
   const points = list(c, "Crv ").map((p) => {
-    const out = { input: clamp3(num2(p, "Hrzn", 0) / 255, 0, 1), output: clamp3(num2(p, "Vrtc", 0) / 255, 0, 1) };
+    const out = { input: clamp3(num3(p, "Hrzn", 0) / 255, 0, 1), output: clamp3(num3(p, "Vrtc", 0) / 255, 0, 1) };
     if (descBool(p, "Cnty") === false) out.corner = true;
     return out;
   });
@@ -8445,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]
@@ -8472,8 +10509,8 @@ function gradientOf(d, notes) {
       { position: 0, color: "#000000" },
       { position: 1, color: "#ffffff" }
     ],
-    style: GRADIENT_STYLES.find(([, id]) => id === enumOf2(d, "Type"))?.[0] ?? "linear",
-    angle: clamp3(num2(d, "Angl", 90), -360, 360),
+    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"),
     align: descBool(d, "Algn") !== false,
@@ -8483,15 +10520,15 @@ 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(num2(s, "Lctn", 0) / 4096, 0, 1), color, mid: clamp3(num2(s, "Mdpn", 50) / 100, 0.05, 0.95) };
+    return { position: clamp3(num3(s, "Lctn", 0) / 4096, 0, 1), color, mid: clamp3(num3(s, "Mdpn", 50) / 100, 0.05, 0.95) };
   }).sort((a, b) => a.position - b.position);
   if (raw.length) {
     const stops = [];
@@ -8507,21 +10544,21 @@ function gradientOf(d, notes) {
     });
     g.stops = stops;
   }
-  const opacity = list(grad, "Trns").map((s) => ({ position: clamp3(num2(s, "Lctn", 0) / 4096, 0, 1), opacity: clamp3(num2(s, "Opct", 100) / 100, 0, 1) })).sort((a, b) => a.position - b.position);
+  const opacity = list(grad, "Trns").map((s) => ({ position: clamp3(num3(s, "Lctn", 0) / 4096, 0, 1), opacity: clamp3(num3(s, "Opct", 100) / 100, 0, 1) })).sort((a, b) => a.position - b.position);
   if (opacity.some((o) => o.opacity < 1)) g.opacityStops = opacity;
-  if (num2(grad, "Intr", 0) > 0) notes.add("gradient smoothness is drawn as straight segments");
+  if (num3(grad, "Intr", 0) > 0) notes.add("gradient smoothness is drawn as straight segments");
   return g;
 }
 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)]
         ])
       )
     )
@@ -8530,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)]
         ])
       )
     ]
@@ -8569,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)]
@@ -8579,21 +10616,21 @@ function patternRefDesc(patternId, name) {
 function placementOf(d) {
   const phase = descObject(d, "phase");
   return {
-    angle: clamp3(num2(d, "Angl", 0), -360, 360),
+    angle: clamp3(num3(d, "Angl", 0), -360, 360),
     link: descBool(d, "Algn") !== false,
-    phase: phase ? { x: num2(phase, "Hrzn", 0), y: num2(phase, "Vrtc", 0) } : { x: 0, y: 0 }
+    phase: phase ? { x: num3(phase, "Hrzn", 0), y: num3(phase, "Vrtc", 0) } : { x: 0, y: 0 }
   };
 }
 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)]
       ])
     )
   ]);
@@ -8616,16 +10653,16 @@ function common(d, kind, notes) {
   return { id: newEffectId(), enabled: descBool(d, "enab") !== false, blend: blendOf(d, "Md  ", def.blend, notes), opacity: clamp3(pct(d, "Opct", def.opacity), 0, 1) };
 }
 function readOne(kind, d, notes) {
-  const size = (key, fallback) => clamp3(num2(d, key, fallback), 0, 250);
+  const size = (key, fallback) => clamp3(num3(d, key, fallback), 0, 250);
   switch (kind) {
     case "drop-shadow":
     case "inner-shadow": {
       const base = {
         ...common(d, kind, notes),
         color: colorOf(descObject(d, "Clr ")),
-        angle: clamp3(num2(d, "lagl", 120), -360, 360),
+        angle: clamp3(num3(d, "lagl", 120), -360, 360),
         useGlobalLight: descBool(d, "uglg") !== false,
-        distance: clamp3(num2(d, "Dstn", 5), 0, 3e4),
+        distance: clamp3(num3(d, "Dstn", 5), 0, 3e4),
         size: size("blur", 5),
         contour: contourOf(d, "TrnS"),
         antiAlias: bool(d, "AntA"),
@@ -8642,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"),
@@ -8651,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" };
@@ -8659,14 +10696,14 @@ 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(num2(d, "Sftn", 0), 0, 16),
-        angle: clamp3(num2(d, "lagl", 120), -360, 360),
-        altitude: clamp3(num2(d, "Lald", 30), 0, 90),
+        soften: clamp3(num3(d, "Sftn", 0), 0, 16),
+        angle: clamp3(num3(d, "lagl", 120), -360, 360),
+        altitude: clamp3(num3(d, "Lald", 30), 0, 90),
         useGlobalLight: descBool(d, "uglg") !== false,
         glossContour: contourOf(d, "TrnS"),
         highlightColor: colorOf(descObject(d, "hglC"), "#ffffff"),
@@ -8689,7 +10726,7 @@ function readOne(kind, d, notes) {
         ...common(d, kind, notes),
         kind,
         color: colorOf(descObject(d, "Clr ")),
-        angle: clamp3(num2(d, "lagl", 19), -360, 360),
+        angle: clamp3(num3(d, "lagl", 19), -360, 360),
         distance: size("Dstn", 11),
         size: size("blur", 14),
         contour: contourOf(d, "MpgS"),
@@ -8706,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 };
     }
   }
@@ -8740,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) {
@@ -8754,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":
@@ -8772,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;
     }
   }
@@ -8893,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));
@@ -8912,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;
@@ -8925,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);
@@ -9046,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));
@@ -9247,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.`);
     }
@@ -9258,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++) {
@@ -9316,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
   );
@@ -9461,6 +11536,7 @@ export {
   removeAlpha,
   SHAPE_OPERATIONS,
   LIVE_SHAPE_KINDS,
+  TEXT_ALIGNS,
   newLayerId,
   pixelLayers,
   developFilter,
@@ -9536,6 +11612,40 @@ export {
   shapeFromAnnotation,
   annotationBlend,
   annotationOfShape,
+  DEFAULT_TEXT_STYLE,
+  DEFAULT_AUTO_LEADING,
+  fitRuns,
+  styleAt,
+  restyleRange,
+  spliceRuns,
+  paragraphRanges,
+  fitParagraphRuns,
+  fontOf,
+  layoutText,
+  textIndexAt,
+  caretAt,
+  TEXT_RENDER_MARGIN,
+  textMatrix,
+  textOutlines,
+  renderText,
+  rerenderText,
+  TEXT_STYLE_FIELDS,
+  patchTextStyle,
+  PARAGRAPH_STYLE_FIELDS,
+  patchParagraphStyle,
+  textRange,
+  requireTypeLayer,
+  normalizeText,
+  typeLayerName,
+  createTypeLayer,
+  updateTypeLayer,
+  replaceTextRange,
+  transformTypeLayer,
+  typeFrame,
+  typeAsPixelLayer,
+  toTextSpace,
+  typeFromAnnotation,
+  annotationOfType,
   BACKGROUND_LAYER_ID,
   BACKGROUND_LAYER_NAME,
   DEVELOP_FILTER_ID,
@@ -9626,8 +11736,6 @@ export {
   deserializeLayer,
   deserializeLayers,
   PsdError,
-  decodePlanes,
-  encodeRle,
   parseVersionedDescriptor,
   versionedDescriptorBytes,
   ADJUSTMENT_KEYS,
@@ -9637,6 +11745,8 @@ export {
   parseLfx2,
   writeLfx2,
   parseLrfx,
+  decodePlanes,
+  encodeRle,
   BROWSER_IMAGE_TYPES,
   readPsd,
   layerName,
@@ -9654,4 +11764,4 @@ export {
   smartContentsFile,
   exportPsd
 };
-//# sourceMappingURL=chunk-DMRSJBJF.js.map
+//# sourceMappingURL=chunk-CZOXTEMN.js.map