@pixerate/editor 0.189.0 → 0.191.0

package/dist/{chunk-5UEFNX24.cjs → chunk-ZQGZWFPU.cjs}

@@ -1,4 +1,332 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }// src/text/opentype.ts
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; }
+
+
+var _chunkNM3G4VQTcjs = require('./chunk-NM3G4VQT.cjs');
+
+// src/vector/trace.ts
+var VECTOR_TRACE_MAX_PIXELS = 4e6;
+function signedArea(p) {
+  let a = 0;
+  for (let i = 0; i < p.length; i++) {
+    const [x0, y0] = p[i];
+    const [x1, y1] = p[(i + 1) % p.length];
+    a += x0 * y1 - x1 * y0;
+  }
+  return a / 2;
+}
+function pointInPoly(p, poly) {
+  let inside = false;
+  for (let i = 0, j = poly.length - 1; i < poly.length; j = i++) {
+    const [xi, yi] = poly[i];
+    const [xj, yj] = poly[j];
+    if (yi > p[1] !== yj > p[1] && p[0] < (xj - xi) * (p[1] - yi) / (yj - yi) + xi) inside = !inside;
+  }
+  return inside;
+}
+function vectorTraceContours(field, w, h, threshold) {
+  const gw = w + 2;
+  const gh = h + 2;
+  const val = (i, j) => i === 0 || j === 0 || i > w || j > h ? -Infinity : field[(j - 1) * w + (i - 1)];
+  const inside = (i, j) => val(i, j) >= threshold;
+  const pos = (i, j) => [i - 0.5, j - 0.5];
+  const cross = (a, b) => {
+    const va = val(a[0], a[1]);
+    const vb = val(b[0], b[1]);
+    let t;
+    if (Number.isFinite(va) && Number.isFinite(vb) && Math.abs(vb - va) > 1e-12) t = Math.min(1, Math.max(0, (threshold - va) / (vb - va)));
+    else if (Number.isFinite(va)) t = va >= threshold ? 0.5 : 0;
+    else t = vb >= threshold ? 0.5 : 1;
+    const pa = pos(a[0], a[1]);
+    const pb = pos(b[0], b[1]);
+    return [pa[0] + (pb[0] - pa[0]) * t, pa[1] + (pb[1] - pa[1]) * t];
+  };
+  const hid = (i, j) => 2 * (j * gw + i);
+  const vid = (i, j) => 2 * (j * gw + i) + 1;
+  const next = /* @__PURE__ */ new Map();
+  const point = /* @__PURE__ */ new Map();
+  for (let j = 0; j < gh - 1; j++) {
+    for (let i = 0; i < gw - 1; i++) {
+      const tl = inside(i, j);
+      const tr = inside(i + 1, j);
+      const br = inside(i + 1, j + 1);
+      const bl = inside(i, j + 1);
+      const code = +tl << 3 | +tr << 2 | +br << 1 | +bl;
+      if (code === 0 || code === 15) continue;
+      const top = hid(i, j);
+      const bottom = hid(i, j + 1);
+      const left = vid(i, j);
+      const right = vid(i + 1, j);
+      const seg = (a, b) => next.set(a, b);
+      const mean = () => (val(i, j) + val(i + 1, j) + val(i + 1, j + 1) + val(i, j + 1)) / 4;
+      switch (code) {
+        case 1:
+          seg(left, bottom);
+          break;
+        case 2:
+          seg(bottom, right);
+          break;
+        case 3:
+          seg(left, right);
+          break;
+        case 4:
+          seg(right, top);
+          break;
+        case 5:
+          if (mean() >= threshold) {
+            seg(left, top);
+            seg(right, bottom);
+          } else {
+            seg(left, bottom);
+            seg(right, top);
+          }
+          break;
+        case 6:
+          seg(bottom, top);
+          break;
+        case 7:
+          seg(left, top);
+          break;
+        case 8:
+          seg(top, left);
+          break;
+        case 9:
+          seg(top, bottom);
+          break;
+        case 10:
+          if (mean() >= threshold) {
+            seg(top, right);
+            seg(bottom, left);
+          } else {
+            seg(top, left);
+            seg(bottom, right);
+          }
+          break;
+        case 11:
+          seg(top, right);
+          break;
+        case 12:
+          seg(right, left);
+          break;
+        case 13:
+          seg(right, bottom);
+          break;
+        case 14:
+          seg(bottom, left);
+          break;
+      }
+      const edges = [
+        [top, [i, j], [i + 1, j]],
+        [bottom, [i, j + 1], [i + 1, j + 1]],
+        [left, [i, j], [i, j + 1]],
+        [right, [i + 1, j], [i + 1, j + 1]]
+      ];
+      for (const [e, a, b] of edges) if (inside(a[0], a[1]) !== inside(b[0], b[1]) && !point.has(e)) point.set(e, cross(a, b));
+    }
+  }
+  const out = [];
+  for (const start of [...next.keys()].sort((a, b) => a - b)) {
+    if (!next.has(start)) continue;
+    const poly = [];
+    let e = start;
+    for (; ; ) {
+      const n = next.get(e);
+      if (n === void 0) break;
+      next.delete(e);
+      const p = point.get(e);
+      if (p) poly.push(p);
+      e = n;
+      if (e === start) break;
+    }
+    if (poly.length >= 3) out.push(poly);
+  }
+  return out;
+}
+function squareContourCorners(ring) {
+  const n = ring.length;
+  if (n < 4) return ring;
+  const eq = (u, v) => Math.abs(u - v) < 1e-9;
+  const out = [];
+  for (let i = 0; i < n; i++) {
+    const a = ring[i];
+    const b = ring[(i + 1) % n];
+    const p = ring[(i - 1 + n) % n];
+    const q = ring[(i + 2) % n];
+    const diagonal = Math.abs(Math.abs(b[0] - a[0]) - 0.5) < 0.02 && Math.abs(Math.abs(b[1] - a[1]) - 0.5) < 0.02;
+    const wraps = i === n - 1;
+    let corner = null;
+    if (diagonal && (!wraps || out[0] === ring[0])) {
+      if (eq(p[1], a[1]) && !eq(p[0], a[0]) && eq(q[0], b[0]) && !eq(q[1], b[1])) corner = [b[0], a[1]];
+      else if (eq(p[0], a[0]) && !eq(p[1], a[1]) && eq(q[1], b[1]) && !eq(q[0], b[0])) corner = [a[0], b[1]];
+    }
+    if (!corner) {
+      out.push(a);
+      continue;
+    }
+    out.push(corner);
+    if (wraps) out.shift();
+    else i++;
+  }
+  if (out.length < 3) return ring;
+  const m = out.length;
+  for (let k = 0; k < m; k++) {
+    const p = out[(k - 1 + m) % m];
+    const a = out[k];
+    const q = out[(k + 1) % m];
+    if (Math.abs((a[0] - p[0]) * (q[1] - a[1]) - (a[1] - p[1]) * (q[0] - a[0])) > 1e-6) return k ? [...out.slice(k), ...out.slice(0, k)] : out;
+  }
+  return out;
+}
+function loopsOf(field, w, h, threshold, tolerance, minArea, square = false) {
+  const loops = [];
+  for (const contour of vectorTraceContours(field, w, h, threshold)) {
+    const raw = square ? squareContourCorners(contour) : contour;
+    const area = signedArea(raw);
+    if (Math.abs(area) < Math.max(0, minArea)) continue;
+    const simple = _chunkNM3G4VQTcjs.simplifyRing.call(void 0, raw, Math.max(0.01, tolerance));
+    if (simple.length < 3) continue;
+    loops.push({ raw, simple, area, depth: 0 });
+  }
+  for (const l of loops) l.depth = loops.filter((o) => o !== l && Math.abs(o.area) > Math.abs(l.area) && pointInPoly(l.simple[0], o.simple)).length;
+  return loops.sort((a, b) => a.depth - b.depth || Math.abs(b.area) - Math.abs(a.area));
+}
+function loopSubpath(l, tolerance, roundness) {
+  if (roundness <= 0) return { closed: true, anchors: l.simple.map(([x, y]) => ({ x, y })) };
+  const cornerAngleDeg = 25 + roundness * 125;
+  const cubics = _chunkNM3G4VQTcjs.fitCubics.call(void 0, l.raw, Math.max(0.05, tolerance), {
+    closed: true,
+    cornerAngleDeg
+  });
+  if (!cubics.length) return { closed: true, anchors: l.simple.map(([x, y]) => ({ x, y })) };
+  const anchors = cubics.map((c, k) => {
+    const prev = cubics[(k - 1 + cubics.length) % cubics.length];
+    return {
+      x: c.p0[0],
+      y: c.p0[1],
+      in: { x: prev.p2[0], y: prev.p2[1] },
+      out: { x: c.p1[0], y: c.p1[1] }
+    };
+  });
+  return { closed: true, anchors };
+}
+function traceField(field, w, h, threshold, o) {
+  const tolerance = _nullishCoalesce(o.tolerance, () => ( 1));
+  const roundness = Math.min(1, Math.max(0, _nullishCoalesce(o.cornerRoundness, () => ( 0.5))));
+  return loopsOf(field, w, h, threshold, tolerance, _nullishCoalesce(o.minArea, () => ( 10)), o.squareCorners === true).map((l) => loopSubpath(l, tolerance, roundness));
+}
+function quantizeVectorTraceColors(pixels, count) {
+  const n = pixels.width * pixels.height;
+  const d = pixels.data;
+  const opaque = [];
+  for (let i = 0; i < n; i++) if (d[i * 4 + 3] >= 128) opaque.push(i);
+  const boxes = opaque.length ? [opaque] : [];
+  const range = (box, c) => {
+    let lo = 255;
+    let hi = 0;
+    for (const i of box) {
+      const v = d[i * 4 + c];
+      if (v < lo) lo = v;
+      if (v > hi) hi = v;
+    }
+    return hi - lo;
+  };
+  while (boxes.length < count) {
+    let best = -1;
+    let bestRange = 0;
+    let bestC = 0;
+    boxes.forEach((b, k) => {
+      if (b.length < 2) return;
+      for (let c = 0; c < 3; c++) {
+        const r = range(b, c);
+        if (r > bestRange) {
+          bestRange = r;
+          best = k;
+          bestC = c;
+        }
+      }
+    });
+    if (best < 0) break;
+    const box = boxes[best].slice().sort((a, b) => d[a * 4 + bestC] - d[b * 4 + bestC]);
+    const key = (k) => d[box[k] * 4 + bestC];
+    const v = key(box.length >> 1);
+    let mid = box.findIndex((_, k) => key(k) >= v);
+    if (mid <= 0) mid = box.findIndex((_, k) => key(k) > v);
+    boxes.splice(best, 1, box.slice(0, mid), box.slice(mid));
+  }
+  const palette = boxes.map((b) => {
+    const s = [0, 0, 0];
+    for (const i of b) for (let c = 0; c < 3; c++) s[c] += d[i * 4 + c];
+    return [Math.round(s[0] / b.length), Math.round(s[1] / b.length), Math.round(s[2] / b.length)];
+  });
+  const index = new Int16Array(n).fill(-1);
+  const counts = palette.map(() => 0);
+  for (const i of opaque) {
+    let best = 0;
+    let bestD = Infinity;
+    palette.forEach((p, k) => {
+      const dd = (d[i * 4] - p[0]) ** 2 + (d[i * 4 + 1] - p[1]) ** 2 + (d[i * 4 + 2] - p[2]) ** 2;
+      if (dd < bestD) {
+        bestD = dd;
+        best = k;
+      }
+    });
+    index[i] = best;
+    counts[best]++;
+  }
+  return { palette, index, counts };
+}
+var hex = (c) => `#${c.map((v) => Math.round(v).toString(16).padStart(2, "0")).join("")}`;
+function traceVectorImage(pixels, options = {}) {
+  const { width: w, height: h, data } = pixels;
+  if (!(w > 0 && h > 0) || data.length < w * h * 4) throw new Error("The image has no pixels (or fewer than width \xD7 height \xD7 4 values).");
+  if (w * h > VECTOR_TRACE_MAX_PIXELS) throw new Error(`The image has ${w * h} pixels; scale it down to at most ${VECTOR_TRACE_MAX_PIXELS} to trace it.`);
+  const n = w * h;
+  if ((_nullishCoalesce(options.mode, () => ( "threshold"))) === "threshold") {
+    const field = new Float32Array(n);
+    const byAlpha = options.channel === "alpha";
+    for (let i = 0; i < n; i++) {
+      const a = data[i * 4 + 3] / 255;
+      field[i] = byAlpha ? a : a * (1 - (0.2126 * data[i * 4] + 0.7152 * data[i * 4 + 1] + 0.0722 * data[i * 4 + 2]) / 255);
+    }
+    const subpaths = traceField(field, w, h, Math.min(1, Math.max(0, _nullishCoalesce(options.threshold, () => ( 0.5)))), options);
+    return subpaths.length ? [
+      {
+        id: "trace-1",
+        type: "path",
+        name: "Trace",
+        fill: _nullishCoalesce(options.color, () => ( "#000000")),
+        stroke: null,
+        fillRule: "evenodd",
+        subpaths
+      }
+    ] : [];
+  }
+  const count = Math.min(32, Math.max(2, Math.round(_nullishCoalesce(options.colors, () => ( 6)))));
+  const q = quantizeVectorTraceColors(pixels, count);
+  const order = q.palette.map((_, k) => k).filter((k) => q.counts[k] > 0).sort((a, b) => q.counts[b] - q.counts[a]);
+  const rank = new Map(order.map((k, r) => [k, r]));
+  const out = [];
+  order.forEach((k, r) => {
+    const field = new Uint8Array(n);
+    for (let i = 0; i < n; i++) {
+      const ix = q.index[i];
+      field[i] = ix >= 0 && rank.get(ix) >= r ? 1 : 0;
+    }
+    const subpaths = traceField(field, w, h, 0.5, options);
+    if (subpaths.length)
+      out.push({
+        id: `trace-${out.length + 1}`,
+        type: "path",
+        name: hex(q.palette[k]),
+        fill: hex(q.palette[k]),
+        stroke: null,
+        fillRule: "evenodd",
+        subpaths
+      });
+  });
+  return out;
+}
+
+// src/text/opentype.ts
 var fail = (message) => {
   throw new Error(message);
 };
@@ -310,22 +638,22 @@ function cffOutlines(view, t, numGlyphs) {
   const gsubrs = cffIndex(view, strings.end).items;
   if (!tops.items.length) fail("The font's CFF table has no Top DICT.");
   const top = cffDict(view, tops.items[0][0], tops.items[0][1]);
-  const charStrings = cffIndex(view, base + (_nullishCoalesce(_optionalChain([top, 'access', _ => _.get, 'call', _2 => _2(17), 'optionalAccess', _3 => _3[0]]), () => ( fail("The font's CFF table has no CharStrings."))))).items;
+  const charStrings = cffIndex(view, base + (_nullishCoalesce(_optionalChain([top, 'access', _2 => _2.get, 'call', _3 => _3(17), 'optionalAccess', _4 => _4[0]]), () => ( fail("The font's CFF table has no CharStrings."))))).items;
   const privateOf = (dict) => {
     const pv = dict.get(18);
     if (!pv || pv.length < 2) return { subrs: [], defaultWidth: 0, nominalWidth: 0 };
     const [size, off] = pv;
     const priv = cffDict(view, base + off, base + off + size);
-    const subrsOff = _optionalChain([priv, 'access', _4 => _4.get, 'call', _5 => _5(19), 'optionalAccess', _6 => _6[0]]);
+    const subrsOff = _optionalChain([priv, 'access', _5 => _5.get, 'call', _6 => _6(19), 'optionalAccess', _7 => _7[0]]);
     return {
       subrs: subrsOff !== void 0 ? cffIndex(view, base + off + subrsOff).items : [],
-      defaultWidth: _nullishCoalesce(_optionalChain([priv, 'access', _7 => _7.get, 'call', _8 => _8(20), 'optionalAccess', _9 => _9[0]]), () => ( 0)),
-      nominalWidth: _nullishCoalesce(_optionalChain([priv, 'access', _10 => _10.get, 'call', _11 => _11(21), 'optionalAccess', _12 => _12[0]]), () => ( 0))
+      defaultWidth: _nullishCoalesce(_optionalChain([priv, 'access', _8 => _8.get, 'call', _9 => _9(20), 'optionalAccess', _10 => _10[0]]), () => ( 0)),
+      nominalWidth: _nullishCoalesce(_optionalChain([priv, 'access', _11 => _11.get, 'call', _12 => _12(21), 'optionalAccess', _13 => _13[0]]), () => ( 0))
     };
   };
   let fdFor;
-  const fdArrayOff = _optionalChain([top, 'access', _13 => _13.get, 'call', _14 => _14(1236), 'optionalAccess', _15 => _15[0]]);
-  const fdSelectOff = _optionalChain([top, 'access', _16 => _16.get, 'call', _17 => _17(1237), 'optionalAccess', _18 => _18[0]]);
+  const fdArrayOff = _optionalChain([top, 'access', _14 => _14.get, 'call', _15 => _15(1236), 'optionalAccess', _16 => _16[0]]);
+  const fdSelectOff = _optionalChain([top, 'access', _17 => _17.get, 'call', _18 => _18(1237), 'optionalAccess', _19 => _19[0]]);
   if (fdArrayOff !== void 0 && fdSelectOff !== void 0) {
     const fds = cffIndex(view, base + fdArrayOff).items.map(([a, b]) => privateOf(cffDict(view, a, b)));
     const sel = base + fdSelectOff;
@@ -795,7 +1123,7 @@ function parseOpenTypeFont(data, options = {}) {
     if (g < 0 || g >= numGlyphs) return 0;
     const i = Math.min(g, numHMetrics - 1);
     if (i >= 0 && hmtx.offset + i * 4 + 2 <= hmtx.offset + hmtx.length) return view.getUint16(hmtx.offset + i * 4);
-    return _nullishCoalesce(_optionalChain([cffWidth, 'optionalCall', _19 => _19(g)]), () => ( 0));
+    return _nullishCoalesce(_optionalChain([cffWidth, 'optionalCall', _20 => _20(g)]), () => ( 0));
   };
   const kernPairs = readKern(view, tables.get("kern"));
   const gpos = gposKerning(view, tables.get("GPOS"));
@@ -849,11 +1177,11 @@ function parseOpenTypeFont(data, options = {}) {
     kerning,
     glyphPath,
     getAdvanceWidth(text, fontSize, opts) {
-      return layout(text, _optionalChain([opts, 'optionalAccess', _20 => _20.kerning]) !== false).width * fontSize / unitsPerEm;
+      return layout(text, _optionalChain([opts, 'optionalAccess', _21 => _21.kerning]) !== false).width * fontSize / unitsPerEm;
     },
     getPath(text, x, y, fontSize, opts) {
       const k = fontSize / unitsPerEm;
-      const { gs, xs } = layout(text, _optionalChain([opts, 'optionalAccess', _21 => _21.kerning]) !== false);
+      const { gs, xs } = layout(text, _optionalChain([opts, 'optionalAccess', _22 => _22.kerning]) !== false);
       const commands = [];
       gs.forEach((g, i) => {
         const ox = x + xs[i] * k;
@@ -925,4 +1253,9 @@ async function unwoff(view) {
 
 
 
-exports.parseOpenTypeFont = parseOpenTypeFont; exports.loadOpenTypeFont = loadOpenTypeFont;
+
+
+
+
+
+exports.VECTOR_TRACE_MAX_PIXELS = VECTOR_TRACE_MAX_PIXELS; exports.vectorTraceContours = vectorTraceContours; exports.traceField = traceField; exports.quantizeVectorTraceColors = quantizeVectorTraceColors; exports.traceVectorImage = traceVectorImage; exports.parseOpenTypeFont = parseOpenTypeFont; exports.loadOpenTypeFont = loadOpenTypeFont;

package/dist/image-editor/controller.d.cts

@@ -1,4 +1,5 @@
 import { AdjustmentKind, AdjustmentLayer, AdjustmentParamsMap, Annotation, CreateAnnotationPayload, AspectRatio, CropBox, DepthMaskOptions, ExportOptions, ImageAdjustments, ImageDimensions, ImageEditorFit, ImageEditorOptions, ImageEditorState, ImageEditorTool, ImageTransform, ImagePoint, SerializedImageEditorState } from './types.cjs';
+import { type PathToSelectionOptions, type SelectionToPathOptions } from './selection/path.cjs';
 import { RenderOptions } from './renderer.cjs';
 import { type BlendMode } from './blend.cjs';
 import type { ImageHistogram } from './histogram.cjs';
@@ -11,7 +12,7 @@ import { type RefineEdgeParams } from './selection/refine.cjs';
 import { type LayerMaskProps } from './selection/layer-mask.cjs';
 import { type AlphaChannel } from './selection/channels.cjs';
 import type { AdjustmentLayerMask } from './types.cjs';
-import { type LayerBlendMode, type ImageLayer, type LayerFilter, type LayerTarget, type PixelLayer, type RasterMask, type SmartContents, type SmartFilter, type SmartPlacement, type LiveShape, type ShapeFillRule, type ShapeOperation, type ShapePaint, type ShapeStroke, type ParagraphStyle, type TextStyle, type TypeLayer, type ImageEffectAnimation } from './layers/model.cjs';
+import { type LayerBlendMode, type ImageLayer, type LayerFilter, type LayerTarget, type PixelLayer, type RasterMask, type SmartContents, type SmartFilter, type SmartPlacement, type LiveShape, type ShapeFillRule, type VectorMask, type ShapeOperation, type ShapePaint, type ShapeStroke, type ParagraphStyle, type TextStyle, type TypeLayer, type ImageEffectAnimation } from './layers/model.cjs';
 import { type TextLayout, type TextShaper } from './layers/text.cjs';
 import type { VectorSubpath } from '../vector/types.cjs';
 import { EffectsSlot } from '../effects/helpers.cjs';
@@ -209,6 +210,29 @@ export interface CloneSource {
  * 'star' | 'line', … }`, see `LiveShape`) or subpaths (`[{ anchors: [{ x, y, in?, out? }],
  * closed }]` or SVG path data), and how it combines with the components below it.
  */
+/** A vector mask's path: several `components`, or one `shape` / `subpaths` (with `op`). */
+export interface VectorMaskPathInput extends ShapeGeometryInput {
+    components?: ShapeGeometryInput[];
+    fillRule?: ShapeFillRule;
+}
+/** A vector mask as `getVectorMask` describes it. */
+export interface VectorMaskInfo {
+    layerId: string;
+    enabled: boolean;
+    linked: boolean;
+    inverted: boolean;
+    fillRule: ShapeFillRule;
+    density: number;
+    feather: number;
+    /** Bounds of the path's anchors and handles (document px), or `null` for an empty path. */
+    bounds: CropBox | null;
+    components: Array<{
+        index: number;
+        op: ShapeOperation;
+        live: LiveShape | null;
+        subpaths: VectorSubpath[];
+    }>;
+}
 export interface ShapeGeometryInput {
     shape?: LiveShape | Record<string, unknown>;
     subpaths?: VectorSubpath[] | string;
@@ -888,6 +912,54 @@ export declare class ImageEditorController {
     addLayerMask(id: string, from?: 'reveal-all' | 'hide-all' | 'selection' | 'hide-selection' | 'transparency', props?: LayerMaskProps): RasterMask;
     /** Removes a layer's mask (one undo step). */
     removeLayerMask(id: string): void;
+    /** The layer for a vector mask command: not a shape layer (its path is its vector mask), not a depth-masked one. */
+    private vectorMaskLayer;
+    private requireVectorMask;
+    /** Components from a path spec: `components`, or one `shape` / `subpaths`. */
+    private vectorMaskComponents;
+    /**
+     * Layer › Vector Mask: `reveal-all` (an empty path showing everything), `hide-all` (an empty path
+     * hiding everything) or `path` (reveals inside the path given). Replaces an existing vector mask;
+     * the raster mask is kept and both apply. One undo step. Returns the vector mask.
+     */
+    addVectorMask(id: string, from?: 'reveal-all' | 'hide-all' | 'path' | 'selection', path?: VectorMaskPathInput, trace?: SelectionToPathOptions): VectorMask;
+    /** The selection's outline as subpaths; throws when nothing is selected or nothing is left to trace. */
+    private traceSelection;
+    /**
+     * Make Work Path: the selection's outline as closed Bézier subpaths in document pixels, holes
+     * included (fill them even-odd), within `tolerance` px. Changes nothing. Throws without a selection.
+     */
+    selectionToPath(options?: SelectionToPathOptions): {
+        subpaths: VectorSubpath[];
+        svg: string;
+        fillRule: 'evenodd';
+        bounds: CropBox | null;
+        anchors: number;
+    };
+    /**
+     * Make Selection: fills a path (`shape`, `subpaths` or `components`, document pixels) into a
+     * selection combined with the current one by `mode`, with `feather` px and `antiAlias`. One
+     * undo step. Returns whether anything is selected.
+     */
+    pathToSelection(path: VectorMaskPathInput, options?: PathToSelectionOptions & {
+        mode?: SelectionMode;
+    }): boolean;
+    /** Replaces a vector mask's path (its properties are kept). One undo step. Returns the vector mask. */
+    setVectorMaskPath(id: string, path: VectorMaskPathInput): VectorMask;
+    /** Changes a vector mask's enabled, linked, inverted, density or feather (the path is kept). One undo step. */
+    setVectorMaskProps(id: string, props: Partial<Pick<VectorMask, 'enabled' | 'linked' | 'inverted' | 'density' | 'feather'>>): VectorMask;
+    /** Deletes a layer's vector mask (one undo step). */
+    removeVectorMask(id: string): void;
+    /**
+     * Layer › Rasterize › Vector Mask: multiplies the path (with its density and feather) into the
+     * layer's raster mask, adding one when there is none, and removes the vector mask. The raster
+     * mask keeps its own properties. One undo step. Returns the raster mask.
+     */
+    rasterizeVectorMask(id: string): RasterMask;
+    /** Load Selection from a vector mask's path (density and feather are not applied), inverted with `invert`. */
+    selectionFromVectorMask(id: string, mode?: SelectionMode, invert?: boolean): boolean;
+    /** A layer's vector mask with its paths (rounded), or `null` without one. */
+    getVectorMask(id: string): VectorMaskInfo | null;
     /** Changes any layer mask's density, feather, enabled or linked flag (pixels kept). Returns the mask. */
     setLayerMaskProps(id: string, props: LayerMaskProps, commitToHistory?: boolean): RasterMask;
     /**

package/dist/image-editor/controller.d.ts

@@ -1,4 +1,5 @@
 import { AdjustmentKind, AdjustmentLayer, AdjustmentParamsMap, Annotation, CreateAnnotationPayload, AspectRatio, CropBox, DepthMaskOptions, ExportOptions, ImageAdjustments, ImageDimensions, ImageEditorFit, ImageEditorOptions, ImageEditorState, ImageEditorTool, ImageTransform, ImagePoint, SerializedImageEditorState } from './types.js';
+import { type PathToSelectionOptions, type SelectionToPathOptions } from './selection/path.js';
 import { RenderOptions } from './renderer.js';
 import { type BlendMode } from './blend.js';
 import type { ImageHistogram } from './histogram.js';
@@ -11,7 +12,7 @@ import { type RefineEdgeParams } from './selection/refine.js';
 import { type LayerMaskProps } from './selection/layer-mask.js';
 import { type AlphaChannel } from './selection/channels.js';
 import type { AdjustmentLayerMask } from './types.js';
-import { type LayerBlendMode, type ImageLayer, type LayerFilter, type LayerTarget, type PixelLayer, type RasterMask, type SmartContents, type SmartFilter, type SmartPlacement, type LiveShape, type ShapeFillRule, type ShapeOperation, type ShapePaint, type ShapeStroke, type ParagraphStyle, type TextStyle, type TypeLayer, type ImageEffectAnimation } from './layers/model.js';
+import { type LayerBlendMode, type ImageLayer, type LayerFilter, type LayerTarget, type PixelLayer, type RasterMask, type SmartContents, type SmartFilter, type SmartPlacement, type LiveShape, type ShapeFillRule, type VectorMask, type ShapeOperation, type ShapePaint, type ShapeStroke, type ParagraphStyle, type TextStyle, type TypeLayer, type ImageEffectAnimation } from './layers/model.js';
 import { type TextLayout, type TextShaper } from './layers/text.js';
 import type { VectorSubpath } from '../vector/types.js';
 import { EffectsSlot } from '../effects/helpers.js';
@@ -209,6 +210,29 @@ export interface CloneSource {
  * 'star' | 'line', … }`, see `LiveShape`) or subpaths (`[{ anchors: [{ x, y, in?, out? }],
  * closed }]` or SVG path data), and how it combines with the components below it.
  */
+/** A vector mask's path: several `components`, or one `shape` / `subpaths` (with `op`). */
+export interface VectorMaskPathInput extends ShapeGeometryInput {
+    components?: ShapeGeometryInput[];
+    fillRule?: ShapeFillRule;
+}
+/** A vector mask as `getVectorMask` describes it. */
+export interface VectorMaskInfo {
+    layerId: string;
+    enabled: boolean;
+    linked: boolean;
+    inverted: boolean;
+    fillRule: ShapeFillRule;
+    density: number;
+    feather: number;
+    /** Bounds of the path's anchors and handles (document px), or `null` for an empty path. */
+    bounds: CropBox | null;
+    components: Array<{
+        index: number;
+        op: ShapeOperation;
+        live: LiveShape | null;
+        subpaths: VectorSubpath[];
+    }>;
+}
 export interface ShapeGeometryInput {
     shape?: LiveShape | Record<string, unknown>;
     subpaths?: VectorSubpath[] | string;
@@ -888,6 +912,54 @@ export declare class ImageEditorController {
     addLayerMask(id: string, from?: 'reveal-all' | 'hide-all' | 'selection' | 'hide-selection' | 'transparency', props?: LayerMaskProps): RasterMask;
     /** Removes a layer's mask (one undo step). */
     removeLayerMask(id: string): void;
+    /** The layer for a vector mask command: not a shape layer (its path is its vector mask), not a depth-masked one. */
+    private vectorMaskLayer;
+    private requireVectorMask;
+    /** Components from a path spec: `components`, or one `shape` / `subpaths`. */
+    private vectorMaskComponents;
+    /**
+     * Layer › Vector Mask: `reveal-all` (an empty path showing everything), `hide-all` (an empty path
+     * hiding everything) or `path` (reveals inside the path given). Replaces an existing vector mask;
+     * the raster mask is kept and both apply. One undo step. Returns the vector mask.
+     */
+    addVectorMask(id: string, from?: 'reveal-all' | 'hide-all' | 'path' | 'selection', path?: VectorMaskPathInput, trace?: SelectionToPathOptions): VectorMask;
+    /** The selection's outline as subpaths; throws when nothing is selected or nothing is left to trace. */
+    private traceSelection;
+    /**
+     * Make Work Path: the selection's outline as closed Bézier subpaths in document pixels, holes
+     * included (fill them even-odd), within `tolerance` px. Changes nothing. Throws without a selection.
+     */
+    selectionToPath(options?: SelectionToPathOptions): {
+        subpaths: VectorSubpath[];
+        svg: string;
+        fillRule: 'evenodd';
+        bounds: CropBox | null;
+        anchors: number;
+    };
+    /**
+     * Make Selection: fills a path (`shape`, `subpaths` or `components`, document pixels) into a
+     * selection combined with the current one by `mode`, with `feather` px and `antiAlias`. One
+     * undo step. Returns whether anything is selected.
+     */
+    pathToSelection(path: VectorMaskPathInput, options?: PathToSelectionOptions & {
+        mode?: SelectionMode;
+    }): boolean;
+    /** Replaces a vector mask's path (its properties are kept). One undo step. Returns the vector mask. */
+    setVectorMaskPath(id: string, path: VectorMaskPathInput): VectorMask;
+    /** Changes a vector mask's enabled, linked, inverted, density or feather (the path is kept). One undo step. */
+    setVectorMaskProps(id: string, props: Partial<Pick<VectorMask, 'enabled' | 'linked' | 'inverted' | 'density' | 'feather'>>): VectorMask;
+    /** Deletes a layer's vector mask (one undo step). */
+    removeVectorMask(id: string): void;
+    /**
+     * Layer › Rasterize › Vector Mask: multiplies the path (with its density and feather) into the
+     * layer's raster mask, adding one when there is none, and removes the vector mask. The raster
+     * mask keeps its own properties. One undo step. Returns the raster mask.
+     */
+    rasterizeVectorMask(id: string): RasterMask;
+    /** Load Selection from a vector mask's path (density and feather are not applied), inverted with `invert`. */
+    selectionFromVectorMask(id: string, mode?: SelectionMode, invert?: boolean): boolean;
+    /** A layer's vector mask with its paths (rounded), or `null` without one. */
+    getVectorMask(id: string): VectorMaskInfo | null;
     /** Changes any layer mask's density, feather, enabled or linked flag (pixels kept). Returns the mask. */
     setLayerMaskProps(id: string, props: LayerMaskProps, commitToHistory?: boolean): RasterMask;
     /**

package/dist/image-editor/free-transform.d.cts

@@ -1,9 +1,3 @@
-/**
- * Free Transform sessions: what a transform moves (a layer's pixels with its linked mask, a lone
- * unlinked mask, the selected pixels as a floating piece, a copy of them on a new layer, or just
- * the selection outline), a live preview while the geometry changes, and one undo step when it is
- * committed with full-quality resampling.
- */
 import { TiledSurface } from '../raster/surface.cjs';
 import { type Interpolation } from '../raster/transform.cjs';
 import { type ImageLayer, type LayerTarget, type PixelLayer, type SmartObjectLayer } from './layers/model.cjs';
@@ -147,6 +141,9 @@ export declare class FreeTransformSession {
     }, preview?: FreeTransformPreview | false): FreeTransformGeometry;
     /** Resamples every part for the current geometry and shows it (or returns it, for commit). */
     private resample;
+    /** A linked vector mask follows the layer's content through the same document-space map. */
+    private moveVectorMask;
+    private resampleContent;
     /**
      * A shape with its paths mapped through the current geometry and rendered again (live shapes
      * stay live under an affine map; perspective and warps turn them into plain paths). Previews

package/dist/image-editor/free-transform.d.ts

@@ -1,9 +1,3 @@
-/**
- * Free Transform sessions: what a transform moves (a layer's pixels with its linked mask, a lone
- * unlinked mask, the selected pixels as a floating piece, a copy of them on a new layer, or just
- * the selection outline), a live preview while the geometry changes, and one undo step when it is
- * committed with full-quality resampling.
- */
 import { TiledSurface } from '../raster/surface.js';
 import { type Interpolation } from '../raster/transform.js';
 import { type ImageLayer, type LayerTarget, type PixelLayer, type SmartObjectLayer } from './layers/model.js';
@@ -147,6 +141,9 @@ export declare class FreeTransformSession {
     }, preview?: FreeTransformPreview | false): FreeTransformGeometry;
     /** Resamples every part for the current geometry and shows it (or returns it, for commit). */
     private resample;
+    /** A linked vector mask follows the layer's content through the same document-space map. */
+    private moveVectorMask;
+    private resampleContent;
     /**
      * A shape with its paths mapped through the current geometry and rendered again (live shapes
      * stay live under an affine map; perspective and warps turn them into plain paths). Previews