@pixerate/editor 0.190.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';
@@ -921,7 +922,28 @@ export declare class ImageEditorController {
      * 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', path?: VectorMaskPathInput): VectorMask;
+    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. */

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';
@@ -921,7 +922,28 @@ export declare class ImageEditorController {
      * 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', path?: VectorMaskPathInput): VectorMask;
+    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. */