@pixerate/editor 0.209.0 → 0.211.0

package/dist/chunk-MQDIP4CF.cjs

@@ -0,0 +1,462 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }// src/paint/heal.ts
+var TOL = 2e-3;
+var FINE_ITERS = 30;
+var FINE_OMEGA = 1.7;
+function solveMembrane(w, h, unknown, v) {
+  if (unknown.length !== w * h || v.length !== w * h) throw new RangeError(`solveMembrane: expected ${w * h} cells, got ${unknown.length} and ${v.length}.`);
+  const u = new Uint8Array(w * h);
+  for (let i = 0; i < u.length; i++) u[i] = unknown[i] ? 1 : 0;
+  solveLevel(w, h, u, v, 0);
+}
+function solveLevel(w, h, unknown, v, depth) {
+  let nUnknown = 0;
+  let knownSum = 0;
+  let nKnown = 0;
+  for (let i = 0; i < unknown.length; i++) {
+    if (unknown[i]) nUnknown++;
+    else {
+      knownSum += v[i];
+      nKnown++;
+    }
+  }
+  if (nUnknown === 0 || nKnown === 0) return;
+  if (w >= 8 && h >= 8 && nUnknown > 64 && depth < 16) {
+    const cw = Math.ceil(w / 2);
+    const chh = Math.ceil(h / 2);
+    const cu = new Uint8Array(cw * chh).fill(1);
+    const cv = new Float32Array(cw * chh);
+    for (let cy = 0; cy < chh; cy++) {
+      for (let cx = 0; cx < cw; cx++) {
+        let s = 0;
+        let n = 0;
+        for (let k = 0; k < 4; k++) {
+          const x = cx * 2 + (k & 1);
+          const y = cy * 2 + (k >> 1);
+          if (x < w && y < h && !unknown[y * w + x]) {
+            s += v[y * w + x];
+            n++;
+          }
+        }
+        if (n > 0) {
+          cu[cy * cw + cx] = 0;
+          cv[cy * cw + cx] = s / n;
+        }
+      }
+    }
+    solveLevel(cw, chh, cu, cv, depth + 1);
+    for (let y = 0; y < h; y++) {
+      const fy = Math.min(chh - 1, Math.max(0, (y + 0.5) / 2 - 0.5));
+      const y0 = Math.floor(fy);
+      const y1 = Math.min(chh - 1, y0 + 1);
+      const ty = fy - y0;
+      for (let x = 0; x < w; x++) {
+        if (!unknown[y * w + x]) continue;
+        const fx = Math.min(cw - 1, Math.max(0, (x + 0.5) / 2 - 0.5));
+        const x0 = Math.floor(fx);
+        const x1 = Math.min(cw - 1, x0 + 1);
+        const tx = fx - x0;
+        const a = cv[y0 * cw + x0] + (cv[y0 * cw + x1] - cv[y0 * cw + x0]) * tx;
+        const b = cv[y1 * cw + x0] + (cv[y1 * cw + x1] - cv[y1 * cw + x0]) * tx;
+        v[y * w + x] = a + (b - a) * ty;
+      }
+    }
+    sor(w, h, unknown, v, FINE_ITERS, FINE_OMEGA);
+  } else {
+    const mean = knownSum / nKnown;
+    for (let i = 0; i < v.length; i++) if (unknown[i]) v[i] = mean;
+    sor(w, h, unknown, v, 2e3, 1.85);
+  }
+}
+function sor(w, h, unknown, v, maxIter, omega) {
+  let n = 0;
+  for (let i = 0; i < unknown.length; i++) if (unknown[i]) n++;
+  const cells = new Uint32Array(n);
+  const masks = new Uint8Array(n);
+  for (let i = 0, k = 0; i < unknown.length; i++) {
+    if (!unknown[i]) continue;
+    const x = i % w;
+    const y = (i - x) / w;
+    cells[k] = i;
+    masks[k++] = (x > 0 ? 1 : 0) | (x + 1 < w ? 2 : 0) | (y > 0 ? 4 : 0) | (y + 1 < h ? 8 : 0);
+  }
+  for (let it = 0; it < maxIter; it++) {
+    let maxD = 0;
+    for (let k = 0; k < n; k++) {
+      const i = cells[k];
+      const m = masks[k];
+      let s;
+      let c;
+      if (m === 15) {
+        s = v[i - 1] + v[i + 1] + v[i - w] + v[i + w];
+        c = 4;
+      } else {
+        s = 0;
+        c = 0;
+        if (m & 1) s += v[i - 1], c++;
+        if (m & 2) s += v[i + 1], c++;
+        if (m & 4) s += v[i - w], c++;
+        if (m & 8) s += v[i + w], c++;
+        if (c === 0) continue;
+      }
+      const d = omega * (s / c - v[i]);
+      v[i] += d;
+      const ad = d < 0 ? -d : d;
+      if (ad > maxD) maxD = ad;
+    }
+    if (maxD < TOL) break;
+  }
+}
+function seamlessClone(w, h, ch, src, dst, mask) {
+  const n = w * h;
+  if (src.length !== n * ch || dst.length !== n * ch || mask.length !== n) throw new RangeError("seamlessClone: src, dst and mask must cover w \xD7 h pixels.");
+  const out = new Float32Array(n * ch);
+  const hv = new Float32Array(n);
+  for (let c = 0; c < ch; c++) {
+    for (let i = 0; i < n; i++) hv[i] = mask[i] ? 0 : dst[i * ch + c] - src[i * ch + c];
+    solveMembrane(w, h, mask, hv);
+    for (let i = 0; i < n; i++) out[i * ch + c] = mask[i] ? src[i * ch + c] + hv[i] : dst[i * ch + c];
+  }
+  return out;
+}
+function membraneFill(w, h, ch, img, hole) {
+  const n = w * h;
+  const out = new Float32Array(n * ch);
+  const v = new Float32Array(n);
+  for (let c = 0; c < ch; c++) {
+    for (let i = 0; i < n; i++) v[i] = hole[i] ? 0 : img[i * ch + c];
+    solveMembrane(w, h, hole, v);
+    for (let i = 0; i < n; i++) out[i * ch + c] = v[i];
+  }
+  return out;
+}
+function dilateMask(w, h, mask, r) {
+  const tmp = new Uint8Array(w * h);
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      if (!mask[y * w + x]) continue;
+      for (let xx = Math.max(0, x - r); xx <= Math.min(w - 1, x + r); xx++) tmp[y * w + xx] = 1;
+    }
+  }
+  const out = new Uint8Array(w * h);
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      if (!tmp[y * w + x]) continue;
+      for (let yy = Math.max(0, y - r); yy <= Math.min(h - 1, y + r); yy++) out[yy * w + x] = 1;
+    }
+  }
+  return out;
+}
+var MaskIntegral = class {
+  constructor(w, h, mask) {
+    this.w = w;
+    this.h = h;
+    const W = w + 1;
+    this.s = new Uint32Array(W * (h + 1));
+    for (let y = 0; y < h; y++) {
+      let row = 0;
+      for (let x = 0; x < w; x++) {
+        row += mask[y * w + x] ? 1 : 0;
+        this.s[(y + 1) * W + x + 1] = this.s[y * W + x + 1] + row;
+      }
+    }
+  }
+  
+  
+  
+  /** Masked cells in [x0, x1) × [y0, y1) (clipped to the grid). */
+  count(x0, y0, x1, y1) {
+    const W = this.w + 1;
+    const a = Math.max(0, Math.min(this.w, x0));
+    const b = Math.max(0, Math.min(this.h, y0));
+    const c = Math.max(0, Math.min(this.w, x1));
+    const d = Math.max(0, Math.min(this.h, y1));
+    if (c <= a || d <= b) return 0;
+    return this.s[d * W + c] - this.s[b * W + c] - this.s[d * W + a] + this.s[b * W + a];
+  }
+};
+function maskBounds(w, h, mask) {
+  let x0 = w;
+  let y0 = h;
+  let x1 = -1;
+  let y1 = -1;
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      if (!mask[y * w + x]) continue;
+      if (x < x0) x0 = x;
+      if (x > x1) x1 = x;
+      if (y < y0) y0 = y;
+      if (y > y1) y1 = y;
+    }
+  }
+  return x1 < 0 ? null : [x0, y0, x1 + 1, y1 + 1];
+}
+function bestOffset(w, h, ch, img, hole, ring, maxRadius) {
+  const bb = maskBounds(w, h, hole);
+  if (!bb) return null;
+  const extent = Math.max(w, h);
+  const R = Math.max(0, Math.min(extent, Math.floor(maxRadius)));
+  if (R === 0) return null;
+  const rg = Math.max(1, Math.min(extent, Math.floor(ring)));
+  const hs = new MaskIntegral(w, h, hole);
+  const x0 = bb[0] - rg;
+  const y0 = bb[1] - rg;
+  const x1 = bb[2] + rg;
+  const y1 = bb[3] + rg;
+  const pts = [];
+  for (let y = Math.max(0, y0); y < Math.min(h, y1); y++) {
+    for (let x = Math.max(0, x0); x < Math.min(w, x1); x++) {
+      if (hole[y * w + x]) continue;
+      if (hs.count(x - rg, y - rg, x + rg + 1, y + rg + 1) > 0) pts.push(x, y);
+    }
+  }
+  const stride = Math.max(1, Math.floor(pts.length / 2 / 2e3));
+  const sx = [];
+  const sy = [];
+  for (let i = 0; i < pts.length; i += 2 * stride) {
+    sx.push(pts[i]);
+    sy.push(pts[i + 1]);
+  }
+  const n = Math.max(1, sx.length);
+  const evalAt = (dx, dy, cutoff) => {
+    if (dx === 0 && dy === 0) return null;
+    const hx0 = x0 + dx;
+    const hy0 = y0 + dy;
+    const hx1 = x1 + dx;
+    const hy1 = y1 + dy;
+    if (hx0 < 0 || hy0 < 0 || hx1 > w || hy1 > h) return null;
+    if (hs.count(hx0, hy0, hx1, hy1) !== 0) return null;
+    const penalty = 1 + 1e-3 * (Math.hypot(dx, dy) / R);
+    let e = 0;
+    for (let i = 0; i < sx.length; i++) {
+      const a = (sy[i] * w + sx[i]) * ch;
+      const b = ((sy[i] + dy) * w + sx[i] + dx) * ch;
+      for (let c = 0; c < ch; c++) {
+        const d = img[a + c] - img[b + c];
+        e += d * d;
+      }
+      if ((i & 31) === 31 && e / n * penalty >= cutoff) return null;
+    }
+    return e / n * penalty;
+  };
+  const found = { best: null, e: Infinity };
+  const consider = (dx, dy) => {
+    const e = evalAt(dx, dy, found.e);
+    if (e !== null && e < found.e) {
+      found.e = e;
+      found.best = [dx, dy];
+    }
+  };
+  const step = Math.max(1, Math.floor(R / 24));
+  for (let dy = -R; dy <= R; dy += step) for (let dx = -R; dx <= R; dx += step) consider(dx, dy);
+  if (step > 1 && found.best) {
+    const [bx, by] = found.best;
+    for (let dy = by - step; dy <= by + step; dy++) for (let dx = bx - step; dx <= bx + step; dx++) consider(dx, dy);
+  }
+  return found.best;
+}
+var PATCH_R = 3;
+function rng(seed) {
+  let a = seed >>> 0;
+  return () => {
+    a = a + 1831565813 >>> 0;
+    let t = a;
+    t = Math.imul(t ^ t >>> 15, t | 1);
+    t ^= t + Math.imul(t ^ t >>> 7, t | 61);
+    return ((t ^ t >>> 14) >>> 0) / 4294967296;
+  };
+}
+function downsample(l, ch) {
+  const w = Math.max(1, l.w >> 1);
+  const h = Math.max(1, l.h >> 1);
+  const img = new Float32Array(w * h * ch);
+  const hole = new Uint8Array(w * h);
+  const exclude = l.exclude ? new Uint8Array(w * h) : null;
+  for (let y = 0; y < h; y++) {
+    for (let x = 0; x < w; x++) {
+      let n = 0;
+      const o = (y * w + x) * ch;
+      for (let dy = 0; dy < 2; dy++) {
+        for (let dx = 0; dx < 2; dx++) {
+          const sx = Math.min(l.w - 1, 2 * x + dx);
+          const sy = Math.min(l.h - 1, 2 * y + dy);
+          const i = sy * l.w + sx;
+          if (exclude && l.exclude[i]) exclude[y * w + x] = 1;
+          if (l.hole[i]) {
+            hole[y * w + x] = 1;
+            continue;
+          }
+          for (let c = 0; c < ch; c++) img[o + c] += l.img[i * ch + c];
+          n++;
+        }
+      }
+      if (n) for (let c = 0; c < ch; c++) img[o + c] /= n;
+    }
+  }
+  return { w, h, img, hole, exclude };
+}
+function contentAwareFill(w, h, ch, img, hole, options = {}) {
+  const iters = _nullishCoalesce(options.iterations, () => ( 4));
+  const base = {
+    w,
+    h,
+    img: Float32Array.from(img),
+    hole: Uint8Array.from(hole, (v) => v ? 1 : 0),
+    exclude: options.exclude ? Uint8Array.from(options.exclude, (v) => v ? 1 : 0) : null
+  };
+  const levels = [base];
+  while (levels.length < 4) {
+    const top = levels[levels.length - 1];
+    const b = maskBounds(top.w, top.h, top.hole);
+    if (!b || Math.max(b[2] - b[0], b[3] - b[1]) < 4 * PATCH_R || top.w < 8 * PATCH_R || top.h < 8 * PATCH_R) break;
+    levels.push(downsample(top, ch));
+  }
+  const random = rng(_nullishCoalesce(options.seed, () => ( w * 73856093 + h * 19349663)));
+  let prevFill = null;
+  let prevNnf = null;
+  let prevW = 0;
+  for (let li = levels.length - 1; li >= 0; li--) {
+    const { w: W, h: H, hole: holeL, exclude: excludeL } = levels[li];
+    const cur = new Float32Array(levels[li].img);
+    if (prevFill) {
+      for (let i = 0; i < W * H; i++) {
+        if (!holeL[i]) continue;
+        const x = Math.min(prevW - 1, i % W >> 1);
+        const y = Math.min(Math.floor(prevFill.length / ch / prevW) - 1, Math.floor(i / W) >> 1);
+        for (let c = 0; c < ch; c++) cur[i * ch + c] = prevFill[(y * prevW + x) * ch + c];
+      }
+    } else cur.set(membraneFill(W, H, ch, cur, holeL));
+    const holeBlocked = dilateMask(W, H, holeL, PATCH_R);
+    let blocked = holeBlocked;
+    if (excludeL) {
+      const off = dilateMask(W, H, excludeL, PATCH_R);
+      const sourceBlocked = new Uint8Array(W * H);
+      for (let i = 0; i < W * H; i++) sourceBlocked[i] = holeBlocked[i] || off[i] ? 1 : 0;
+      blocked = sourceBlocked;
+    }
+    const valid = [];
+    for (let y = PATCH_R; y < H - PATCH_R; y++) for (let x = PATCH_R; x < W - PATCH_R; x++) if (!blocked[y * W + x]) valid.push(y * W + x);
+    if (!valid.length) {
+      prevFill = cur;
+      prevNnf = null;
+      prevW = W;
+      continue;
+    }
+    const targets = [];
+    for (let y = 0; y < H; y++) for (let x = 0; x < W; x++) if (holeBlocked[y * W + x]) targets.push(y * W + x);
+    const nnf = new Int32Array(W * H).fill(-1);
+    const cost = new Float64Array(W * H);
+    const clampC = (v, n) => Math.min(n - 1 - PATCH_R, Math.max(PATCH_R, v));
+    const dist = (t, s, limit) => {
+      const tx = clampC(t % W, W);
+      const ty = clampC(Math.floor(t / W), H);
+      const sx = s % W;
+      const sy = Math.floor(s / W);
+      let d = 0;
+      for (let dy = -PATCH_R; dy <= PATCH_R; dy++) {
+        const tr = (ty + dy) * W;
+        const sr = (sy + dy) * W;
+        for (let dx = -PATCH_R; dx <= PATCH_R; dx++) {
+          const a = (tr + tx + dx) * ch;
+          const b = (sr + sx + dx) * ch;
+          for (let c = 0; c < ch; c++) {
+            const e = cur[a + c] - cur[b + c];
+            d += e * e;
+          }
+        }
+        if (d >= limit) return d;
+      }
+      return d;
+    };
+    const isValid = (s) => {
+      const x = s % W;
+      const y = Math.floor(s / W);
+      return s >= 0 && x >= PATCH_R && y >= PATCH_R && x < W - PATCH_R && y < H - PATCH_R && !blocked[s];
+    };
+    for (const t of targets) {
+      let s = -1;
+      if (prevNnf) {
+        const px = Math.min(prevW - 1, t % W >> 1);
+        const py = Math.floor(t / W) >> 1;
+        const ps = prevNnf[py * prevW + px];
+        if (ps >= 0) {
+          const cand = (Math.floor(ps / prevW) * 2 + (Math.floor(t / W) & 1)) * W + ps % prevW * 2 + (t % W & 1);
+          if (isValid(cand)) s = cand;
+        }
+      }
+      if (s < 0) s = valid[Math.floor(random() * valid.length)];
+      nnf[t] = s;
+    }
+    for (let em = 0; em < iters; em++) {
+      for (const t of targets) cost[t] = dist(t, nnf[t], Infinity);
+      for (let pass = 0; pass < 4; pass++) {
+        const fwd = pass % 2 === 0;
+        const step = fwd ? 1 : -1;
+        for (let k = 0; k < targets.length; k++) {
+          const t = targets[fwd ? k : targets.length - 1 - k];
+          const tx = t % W;
+          const ty = Math.floor(t / W);
+          for (const [nx, ny] of [[tx - step, ty], [tx, ty - step]]) {
+            if (nx < 0 || ny < 0 || nx >= W || ny >= H) continue;
+            const ns = nnf[ny * W + nx];
+            if (ns < 0) continue;
+            const cand = ns + step * (nx === tx ? W : 1);
+            if (!isValid(cand) || cand === nnf[t]) continue;
+            const d = dist(t, cand, cost[t]);
+            if (d < cost[t]) {
+              cost[t] = d;
+              nnf[t] = cand;
+            }
+          }
+          const bx = nnf[t] % W;
+          const by = Math.floor(nnf[t] / W);
+          for (let r = Math.max(W, H); r >= 1; r >>= 1) {
+            const cx = Math.round(bx + (random() * 2 - 1) * r);
+            const cy = Math.round(by + (random() * 2 - 1) * r);
+            const cand = cy * W + cx;
+            if (cx < 0 || cy < 0 || cx >= W || cy >= H || !isValid(cand)) continue;
+            const d = dist(t, cand, cost[t]);
+            if (d < cost[t]) {
+              cost[t] = d;
+              nnf[t] = cand;
+            }
+          }
+        }
+      }
+      const acc = new Float64Array(W * H * ch);
+      const wsum = new Float64Array(W * H);
+      for (const t of targets) {
+        const tx = clampC(t % W, W);
+        const ty = clampC(Math.floor(t / W), H);
+        const s = nnf[t];
+        const sx = s % W;
+        const sy = Math.floor(s / W);
+        for (let dy = -PATCH_R; dy <= PATCH_R; dy++) {
+          for (let dx = -PATCH_R; dx <= PATCH_R; dx++) {
+            const q = (ty + dy) * W + tx + dx;
+            if (!holeL[q]) continue;
+            const src = ((sy + dy) * W + sx + dx) * ch;
+            for (let c = 0; c < ch; c++) acc[q * ch + c] += cur[src + c];
+            wsum[q] += 1;
+          }
+        }
+      }
+      for (let q = 0; q < W * H; q++) if (holeL[q] && wsum[q] > 0) for (let c = 0; c < ch; c++) cur[q * ch + c] = acc[q * ch + c] / wsum[q];
+    }
+    prevFill = cur;
+    prevNnf = nnf;
+    prevW = W;
+  }
+  const out = Float32Array.from(img);
+  for (let i = 0; i < w * h; i++) if (base.hole[i]) for (let c = 0; c < ch; c++) out[i * ch + c] = prevFill[i * ch + c];
+  return out;
+}
+
+
+
+
+
+
+
+
+
+exports.solveMembrane = solveMembrane; exports.seamlessClone = seamlessClone; exports.membraneFill = membraneFill; exports.dilateMask = dilateMask; exports.maskBounds = maskBounds; exports.bestOffset = bestOffset; exports.contentAwareFill = contentAwareFill;

package/dist/{chunk-KFIOEOCQ.js → chunk-W3TOZTL7.js}

@@ -5168,9 +5168,9 @@ function serializeVectorMask(vm) {
   if (vm.feather) out.feather = vm.feather;
   return out;
 }
-function readVectorMask(r) {
-  if (!Array.isArray(r.components)) throw new Error("its components are missing");
-  const components = r.components.map((raw, i) => {
+function readShapeComponents(stored) {
+  if (!Array.isArray(stored)) throw new Error("its components are missing");
+  return stored.map((raw, i) => {
     const c = raw;
     const op = requireOperation(c?.op, `components[${i}].op`);
     if (c?.live) {
@@ -5179,7 +5179,9 @@ function readVectorMask(r) {
     }
     return { op, subpaths: Array.isArray(c?.subpaths) && !c.subpaths.length ? [] : normalizeSubpaths(c?.subpaths, `components[${i}].subpaths`) };
   });
-  const vm = { components };
+}
+function readVectorMask(r) {
+  const vm = { components: readShapeComponents(r.components) };
   if (r.fillRule === "evenodd") vm.fillRule = "evenodd";
   if (r.inverted === true) vm.inverted = true;
   if (r.enabled === false) vm.enabled = false;
@@ -6957,6 +6959,19 @@ function vectorBlockForComponents(components, inverted, width, height, flags = 0
   });
   return writeVectorBlock({ subpaths, initialFill: subpaths.length === 0 && inverted }, flags & ~VMSK_INVERT | (inverted && subpaths.length ? VMSK_INVERT : 0));
 }
+var RESOURCE_WORK_PATH = 1025;
+var RESOURCE_PATH_FIRST = 2e3;
+var RESOURCE_PATH_LAST = 2997;
+function componentsFromPathResource(data, width, height) {
+  const block = new Uint8Array(8 + data.length);
+  new DataView(block.buffer).setUint32(0, 3);
+  block.set(data, 8);
+  const read2 = componentsFromVectorBlock(block, width, height);
+  return read2 ? { components: read2.components, inverted: read2.inverted } : null;
+}
+function pathResourceForComponents(components, width, height) {
+  return vectorBlockForComponents(components, false, width, height).slice(8);
+}
 
 // src/image-editor/psd/channels.ts
 var hexToRgb2 = (hex) => {
@@ -8986,12 +9001,14 @@ function writeBlocks(w, blocks, psb, alignment) {
 function writeMask(w, m) {
   writeRect(w, m.rect);
   w.u8(m.defaultColor);
-  const pf = (m.userDensity !== void 0 ? 1 : 0) | (m.userFeather !== void 0 ? 2 : 0);
+  const pf = (m.userDensity !== void 0 ? 1 : 0) | (m.userFeather !== void 0 ? 2 : 0) | (m.vectorDensity !== void 0 ? 4 : 0) | (m.vectorFeather !== void 0 ? 8 : 0);
   w.u8(pf ? m.flags | MASK_FLAG_PARAMETERS : m.flags & ~MASK_FLAG_PARAMETERS);
   if (pf) {
     w.u8(pf);
     if (m.userDensity !== void 0) w.u8(m.userDensity);
     if (m.userFeather !== void 0) w.f64(m.userFeather);
+    if (m.vectorDensity !== void 0) w.u8(m.vectorDensity);
+    if (m.vectorFeather !== void 0) w.f64(m.vectorFeather);
   }
   const len = 18 + (pf ? 1 + maskParameterBytes(pf) : 0);
   w.zeros(Math.max(0, 20 - len) + (4 - Math.max(20, len) % 4) % 4);
@@ -10179,6 +10196,16 @@ function psdToLayers(file, options = {}) {
       warn.extra.push(`The alpha channels could not be read (${e instanceof Error ? e.message : String(e)}).`);
     }
   }
+  const paths = [];
+  for (const r of file.resources) {
+    const saved = r.id >= RESOURCE_PATH_FIRST && r.id <= RESOURCE_PATH_LAST;
+    if (!saved && r.id !== RESOURCE_WORK_PATH) continue;
+    const read2 = componentsFromPathResource(r.data, header.width, header.height);
+    if (!read2?.components.length) continue;
+    if (read2.inverted) warn.extra.push(`The path "${r.name || "Work Path"}" starts by subtracting, which Pixerate's paths do not keep; it came in without that.`);
+    paths.push(saved ? { name: r.name || `Path ${paths.length + 1}`, components: read2.components } : { name: "Work Path", components: read2.components, work: true });
+  }
+  paths.sort((a, b) => Number(Boolean(a.work)) - Number(Boolean(b.work)));
   const i32 = (b) => b && b.length >= 4 ? new DataView(b.buffer, b.byteOffset, 4).getInt32(0) : void 0;
   const angle = i32(resource(file, 1037));
   const altitude = i32(resource(file, 1049));
@@ -10193,6 +10220,7 @@ function psdToLayers(file, options = {}) {
     ...angle !== void 0 || altitude !== void 0 ? { globalLight: { angle: Math.max(-360, Math.min(360, angle ?? 120)), altitude: Math.max(0, Math.min(90, altitude ?? 30)) } } : {},
     info: { psb: header.psb, depth: header.depth, colorMode: mode, channels: header.channels },
     ...alphaChannels.length ? { alphaChannels } : {},
+    ...paths.length ? { paths } : {},
     ...cmykProfile ? { sourceMode: { mode: "cmyk", profile: cmykProfile } } : header.colorMode === MODE_LAB ? { sourceMode: { mode: "lab" } } : {},
     ...resource(file, 1039) ? { iccProfile: resource(file, 1039).slice() } : {},
     bitDepth: (header.depth === 16 || header.depth === 32) && header.colorMode !== MODE_INDEXED && header.colorMode !== MODE_BITMAP ? header.depth : 8
@@ -11022,6 +11050,7 @@ function exportPsd(input) {
   };
   const psb = width > PSD_MAX_DIMENSION || height > PSD_MAX_DIMENSION;
   const records = [];
+  const vectorParams = /* @__PURE__ */ new WeakMap();
   let nextId = 0;
   const notes = /* @__PURE__ */ new Map();
   const note = (msg, name) => notes.set(msg, [...notes.get(msg) ?? [], name]);
@@ -11054,7 +11083,10 @@ function exportPsd(input) {
     if (vm) {
       const flags = (vm.linked === false ? VMSK_NOT_LINKED : 0) | (vm.enabled === false ? VMSK_DISABLED : 0);
       blocks.push({ key: "vmsk", data: vectorBlockForComponents(vm.components, vm.inverted === true, width, height, flags) });
-      if ((vm.density ?? 1) !== 1 || (vm.feather ?? 0) > 0) note("Vector mask density and feather are not written; the paths are", layer.name);
+      const params = {};
+      if ((vm.density ?? 1) < 1) params.density = Math.round(Math.max(0, vm.density ?? 1) * 255);
+      if ((vm.feather ?? 0) > 0) params.feather = vm.feather;
+      if (params.density !== void 0 || params.feather !== void 0) vectorParams.set(blocks, params);
       if (vm.fillRule === "evenodd") note("Vector masks are written with the nonzero fill rule (Photoshop has no even-odd paths)", layer.name);
     }
     return {
@@ -11263,6 +11295,15 @@ function exportPsd(input) {
   ];
   if (input.iccProfile?.length) resources.push({ id: 1039, name: "", data: input.iccProfile });
   resources.push(...alphaChannelResources(input.alphaChannels ?? []));
+  let savedPathId = RESOURCE_PATH_FIRST;
+  for (const p of input.paths ?? []) {
+    if (!p.work && savedPathId > RESOURCE_PATH_LAST) {
+      note("Only 998 saved paths fit in a PSD file; the rest are not written", p.name);
+      continue;
+    }
+    if (p.fillRule === "evenodd") note("Paths are written with the nonzero fill rule (Photoshop has no even-odd paths)", p.name);
+    resources.push({ id: p.work ? RESOURCE_WORK_PATH : savedPathId++, name: p.work ? "" : p.name, data: pathResourceForComponents(p.components, width, height) });
+  }
   if (input.globalLight) {
     const i32 = (v) => {
       const w = new PsdWriter();
@@ -11293,6 +11334,13 @@ function exportPsd(input) {
     globalBlocks.push({ key: "lnk2", data });
   }
   if (filterItems.length) globalBlocks.push({ key: "FEid", data: writeFilterEffects(filterItems) });
+  for (const rec of records) {
+    const params = vectorParams.get(rec.blocks);
+    if (!params) continue;
+    rec.mask ??= { rect: EMPTY_RECT, defaultColor: 255, flags: 0 };
+    if (params.density !== void 0) rec.mask.vectorDensity = params.density;
+    if (params.feather !== void 0) rec.mask.vectorFeather = params.feather;
+  }
   const bytes = writePsd(
     {
       header: { psb, channels: planes.length, width, height, depth, colorMode: mode === "cmyk" ? 4 : mode === "lab" ? 9 : 3 },
@@ -11622,6 +11670,7 @@ export {
   decodeDeepSurface,
   serializeEffects,
   deserializeEffects,
+  readShapeComponents,
   serializeLayer,
   serializeContents,
   serializeLayers,