@pixerate/editor 0.37.0 → 0.39.0

package/dist/vector/index.cjs

@@ -34,13 +34,34 @@ var _chunkQKLRAA4Tcjs = require('../chunk-QKLRAA4T.cjs');
 
 
 
-var _chunkGVB7ZPLZcjs = require('../chunk-GVB7ZPLZ.cjs');
+
+
+
+
+var _chunkVNYRI265cjs = require('../chunk-VNYRI265.cjs');
 
 // src/vector/types.ts
 var VECTOR_CORNER_KINDS = ["round", "inverted", "chamfer"];
 var VECTOR_ARROWHEADS = ["triangle", "arrow", "open", "circle", "square", "bar"];
-var VECTOR_TOOLS = ["select", "direct", "pen", "pencil", "rect", "ellipse", "polygon", "star", "line", "scissors", "knife", "eraser", "width"];
+var VECTOR_TOOLS = [
+  "select",
+  "direct",
+  "pen",
+  "pencil",
+  "rect",
+  "ellipse",
+  "polygon",
+  "star",
+  "line",
+  "scissors",
+  "knife",
+  "eraser",
+  "width",
+  "shapeBuilder",
+  "paintBucket"
+];
 var VECTOR_TRANSFORM_HANDLES = ["nw", "n", "ne", "e", "se", "s", "sw", "w", "rotate"];
+var VECTOR_PATHFINDER_OPERATIONS = ["divide", "trim", "merge", "crop", "outline", "minusBack"];
 
 // src/vector/corners.ts
 var EPS = 1e-9;
@@ -61,7 +82,7 @@ var Side = class {
   constructor(a, h1, h2, b) {
     this.straight = onAnchor(a, h1) && onAnchor(b, h2);
     this.curve = this.straight ? [pt(a), pt(b)] : [pt(a), pt(_nullishCoalesce(h1, () => ( a))), pt(_nullishCoalesce(h2, () => ( b))), pt(b)];
-    this.length = this.straight ? Math.hypot(b.x - a.x, b.y - a.y) : _chunkGVB7ZPLZcjs.segmentLength.call(void 0, this.curve);
+    this.length = this.straight ? Math.hypot(b.x - a.x, b.y - a.y) : _chunkVNYRI265cjs.segmentLength.call(void 0, this.curve);
   }
   /** Unit direction the side leaves the corner in (towards its first control point off the corner). */
   direction() {
@@ -79,10 +100,10 @@ var Side = class {
       const t2 = this.length > EPS ? Math.min(1, Math.max(0, s / this.length)) : 0;
       return { t: t2, p: add(vec(this.curve[0]), mul(u, s)), dir: u };
     }
-    const t = _chunkGVB7ZPLZcjs.segmentParamAtLength.call(void 0, this.curve, s, this.length);
-    const d = vec(_chunkGVB7ZPLZcjs.segmentDerivative.call(void 0, this.curve, t));
+    const t = _chunkVNYRI265cjs.segmentParamAtLength.call(void 0, this.curve, s, this.length);
+    const d = vec(_chunkVNYRI265cjs.segmentDerivative.call(void 0, this.curve, t));
     const l = len(d);
-    return { t, p: vec(_chunkGVB7ZPLZcjs.segmentPoint.call(void 0, this.curve, t)), dir: l > EPS ? mul(d, 1 / l) : u };
+    return { t, p: vec(_chunkVNYRI265cjs.segmentPoint.call(void 0, this.curve, t)), dir: l > EPS ? mul(d, 1 / l) : u };
   }
 };
 function cornerOf(sp, s, i) {
@@ -183,7 +204,7 @@ function expandVectorCornersOf(sp, subpath = 0) {
     const s0 = from ? from.tv : 0;
     const s1 = to ? 1 - to.tu : 1;
     const seg = [pt(a), pt(_nullishCoalesce(a.out, () => ( a))), pt(_nullishCoalesce(b.in, () => ( b))), pt(b)];
-    const part = _chunkGVB7ZPLZcjs.subSegment.call(void 0, seg, s0, Math.max(s0, s1));
+    const part = _chunkVNYRI265cjs.subSegment.call(void 0, seg, s0, Math.max(s0, s1));
     return { out: vec(part[1]), in: vec(part[2]) };
   });
   const anchors = [];
@@ -344,14 +365,14 @@ function mirrorWidthProfile(points) {
 function editable(points) {
   return _optionalChain([points, 'optionalAccess', _13 => _13.length]) ? points.map((p) => ({ ...p })) : [sym(0, 1), sym(1, 1)];
 }
-function insertWidthPoint(points, t, sides = {}, options = {}) {
+function insertWidthPoint(points, t, sides2 = {}, options = {}) {
   const pts = editable(points);
   const tt = Math.min(Math.max(Number.isFinite(t) ? t : 0, 0), 1);
   const here = widthProfileAt(_optionalChain([points, 'optionalAccess', _14 => _14.length]) ? points : null, tt);
   const p = {
     t: tt,
-    left: _nullishCoalesce(clean(sides.left, VECTOR_WIDTH_PROFILE_MAX_SCALE), () => ( here.left)),
-    right: _nullishCoalesce(clean(sides.right, VECTOR_WIDTH_PROFILE_MAX_SCALE), () => ( here.right))
+    left: _nullishCoalesce(clean(sides2.left, VECTOR_WIDTH_PROFILE_MAX_SCALE), () => ( here.left)),
+    right: _nullishCoalesce(clean(sides2.right, VECTOR_WIDTH_PROFILE_MAX_SCALE), () => ( here.right))
   };
   const same = pts.findIndex((q) => Math.abs(q.t - tt) <= VECTOR_WIDTH_SAME_T);
   if (same >= 0 && !options.step) {
@@ -486,7 +507,7 @@ function flatten(segments, closed, tol) {
     corner.push(isCorner);
   };
   for (const seg of segments) {
-    const flat = _chunkGVB7ZPLZcjs.flattenChain.call(void 0, [seg], tol);
+    const flat = _chunkVNYRI265cjs.flattenChain.call(void 0, [seg], tol);
     if (dist(seg[0], seg[seg.length - 1]) <= 1e-12 && flat.length > 1) flat.push(seg[seg.length - 1]);
     flat.forEach((p, i) => push(p, i === 0 || i === flat.length - 1));
   }
@@ -576,12 +597,12 @@ function variableStrokeRings(path, options) {
     const last = out[out.length - 1];
     if (!last || dist(last, p) > 1e-12) out.push(p);
   };
-  for (const contour of _chunkGVB7ZPLZcjs.pathToContours.call(void 0, path)) {
+  for (const contour of _chunkVNYRI265cjs.pathToContours.call(void 0, path)) {
     if (!contour.segments.length) continue;
     const poly = flatten(contour.segments, contour.closed, Math.min(tol, half) / 4);
     if (!poly) continue;
     const len2 = poly.s[poly.s.length - 1];
-    const sides = (s) => {
+    const sides2 = (s) => {
       const w = widthProfileAt(options.profile, s / len2);
       return [w.left * half, w.right * half];
     };
@@ -595,7 +616,7 @@ function variableStrokeRings(path, options) {
       pts.push({ p: pb, s: b, corner: false });
       const run = pts.filter((q, i) => i === 0 || dist(q.p, pts[i - 1].p) > 1e-9);
       if (run.length < 2) {
-        const [l, r] = sides(a);
+        const [l, r] = sides2(a);
         const w2 = (l + r) / 2;
         if (cap === "round" && w2 > 0) rings.push([[pa[0] + w2, pa[1]], ...arcPoints(pa, 0, 2 * Math.PI, w2, w2, tol)]);
         continue;
@@ -605,7 +626,7 @@ function variableStrokeRings(path, options) {
       const dirs = [];
       for (let i = 0; i < m; i++) dirs.push(unitOf(sub2(run[i + 1].p, run[i].p)));
       const normals = dirs.map(leftNormal);
-      const w = run.map((q) => sides(q.s));
+      const w = run.map((q) => sides2(q.s));
       const side = (sigma) => {
         const k = sigma > 0 ? 0 : 1;
         const S = (i) => along(run[i].p, normals[i], sigma * w[i][k]);
@@ -702,7 +723,7 @@ function variableStrokeOutline(path, options) {
   const tol = options.tolerance && options.tolerance > 0 ? options.tolerance : 0.05;
   let polygons;
   try {
-    polygons = _chunkGVB7ZPLZcjs.polygonBoolean.call(void 0, "union", [{ rings: pieces, fillRule: "nonzero" }]);
+    polygons = _chunkVNYRI265cjs.polygonBoolean.call(void 0, "union", [{ rings: pieces, fillRule: "nonzero" }]);
   } catch (e2) {
     return [];
   }
@@ -710,11 +731,11 @@ function variableStrokeOutline(path, options) {
   for (const polygon2 of polygons) {
     for (const ring of polygon2) {
       if (ring.length < 3) continue;
-      const cubics = _chunkGVB7ZPLZcjs.fitCubics.call(void 0, ring, tol, { closed: true, cornerAngleDeg: 25 });
+      const cubics = _chunkVNYRI265cjs.fitCubics.call(void 0, ring, tol, { closed: true, cornerAngleDeg: 25 });
       if (!cubics.length) continue;
       out.push({ type: "M", x: cubics[0].p0[0], y: cubics[0].p0[1] });
       cubics.forEach((c, i) => {
-        if (_chunkGVB7ZPLZcjs.isStraightCubic.call(void 0, c, tol * 0.02)) {
+        if (_chunkVNYRI265cjs.isStraightCubic.call(void 0, c, tol * 0.02)) {
           if (i < cubics.length - 1) out.push({ type: "L", x: c.p3[0], y: c.p3[1] });
         } else out.push({ type: "C", x1: c.p1[0], y1: c.p1[1], x2: c.p2[0], y2: c.p2[1], x: c.p3[0], y: c.p3[1] });
       });
@@ -725,17 +746,17 @@ function variableStrokeOutline(path, options) {
 }
 function nearestStrokePosition(path, p, only) {
   let best = null;
-  _chunkGVB7ZPLZcjs.pathToContours.call(void 0, path).forEach((c, ci) => {
+  _chunkVNYRI265cjs.pathToContours.call(void 0, path).forEach((c, ci) => {
     if (!c.segments.length || only !== void 0 && ci !== only) return;
-    const lengths = c.segments.map((s) => _chunkGVB7ZPLZcjs.segmentLength.call(void 0, s));
+    const lengths = c.segments.map((s) => _chunkVNYRI265cjs.segmentLength.call(void 0, s));
     const total = lengths.reduce((a, b) => a + b, 0);
     if (!(total > 0)) return;
     let acc = 0;
     c.segments.forEach((seg, si) => {
-      const near2 = _chunkGVB7ZPLZcjs.segmentNearest.call(void 0, seg, p);
+      const near2 = _chunkVNYRI265cjs.segmentNearest.call(void 0, seg, p);
       if (!best || near2.distance < best.distance) {
-        const s = acc + _chunkGVB7ZPLZcjs.segmentLength.call(void 0, seg, 0, near2.t);
-        const tan = _chunkGVB7ZPLZcjs.segmentTangent.call(void 0, seg, near2.t);
+        const s = acc + _chunkVNYRI265cjs.segmentLength.call(void 0, seg, 0, near2.t);
+        const tan = _chunkVNYRI265cjs.segmentTangent.call(void 0, seg, near2.t);
         const pt2 = seg.length === 2 ? lerp(seg[0], seg[1], near2.t) : evalSeg(seg, near2.t);
         const n = leftNormal([tan[0], tan[1]]);
         const side = (p[0] - pt2[0]) * n[0] + (p[1] - pt2[1]) * n[1] >= 0 ? "left" : "right";
@@ -752,9 +773,9 @@ function evalSeg(seg, t) {
   return pts[0];
 }
 function strokePositionPoint(path, index, t) {
-  const c = _chunkGVB7ZPLZcjs.pathToContours.call(void 0, path)[index];
+  const c = _chunkVNYRI265cjs.pathToContours.call(void 0, path)[index];
   if (!_optionalChain([c, 'optionalAccess', _22 => _22.segments, 'access', _23 => _23.length])) return null;
-  const lengths = c.segments.map((s) => _chunkGVB7ZPLZcjs.segmentLength.call(void 0, s));
+  const lengths = c.segments.map((s) => _chunkVNYRI265cjs.segmentLength.call(void 0, s));
   const total = lengths.reduce((a, b) => a + b, 0);
   let want = Math.min(Math.max(t, 0), 1) * total;
   for (let i = 0; i < c.segments.length; i++) {
@@ -765,11 +786,11 @@ function strokePositionPoint(path, index, t) {
       const target = Math.min(want, lengths[i]);
       for (let k = 0; k < 40; k++) {
         const mid = (lo + hi) / 2;
-        if (_chunkGVB7ZPLZcjs.segmentLength.call(void 0, seg, 0, mid) < target) lo = mid;
+        if (_chunkVNYRI265cjs.segmentLength.call(void 0, seg, 0, mid) < target) lo = mid;
         else hi = mid;
       }
       const u = (lo + hi) / 2;
-      const tan = _chunkGVB7ZPLZcjs.segmentTangent.call(void 0, seg, u);
+      const tan = _chunkVNYRI265cjs.segmentTangent.call(void 0, seg, u);
       return { point: evalSeg(seg, u), tangent: [tan[0], tan[1]] };
     }
     want -= lengths[i];
@@ -781,7 +802,7 @@ function strokePositionPoint(path, index, t) {
 var KAPPA = 0.5522847498307936;
 var NOTCH = 0.7;
 function isClosedBezierShape(path) {
-  const contours = _chunkGVB7ZPLZcjs.pathToContours.call(void 0, path).filter((c) => c.segments.length > 0);
+  const contours = _chunkVNYRI265cjs.pathToContours.call(void 0, path).filter((c) => c.segments.length > 0);
   return contours.length > 0 && contours.every((c) => c.closed);
 }
 function effectiveStrokeAlign(style, closedShape) {
@@ -802,7 +823,7 @@ function vectorStrokeLineArea(parts, style, tolerance) {
   const join = _nullishCoalesce(style.strokeLinejoin, () => ( "miter"));
   const cap = _nullishCoalesce(style.strokeLinecap, () => ( "butt"));
   if (profile) return variableStrokeOutline(parts.line, { width: parts.drawWidth, profile, join, cap, ...dash, ...tolerance ? { tolerance } : {} });
-  return _chunkGVB7ZPLZcjs.outlineStroke.call(void 0, parts.line, { width: parts.drawWidth, join, cap, ...dash, ...tolerance ? { tolerance } : {} });
+  return _chunkVNYRI265cjs.outlineStroke.call(void 0, parts.line, { width: parts.drawWidth, join, cap, ...dash, ...tolerance ? { tolerance } : {} });
 }
 var capExtent = (style, width) => style.strokeLinecap === "round" || style.strokeLinecap === "square" ? width / 2 : 0;
 function arrowheadWeight(style, end) {
@@ -879,16 +900,16 @@ function arrowheadPath(kind, tip, dir, hw) {
   }
 }
 var toVec = (p) => ({ x: p[0], y: p[1] });
-var segLen = (s) => _chunkGVB7ZPLZcjs.segmentLength.call(void 0, s);
+var segLen = (s) => _chunkVNYRI265cjs.segmentLength.call(void 0, s);
 function endOf(segs, atStart) {
   const long = (s2) => segLen(s2) > 1e-9;
   if (atStart) {
     const s2 = _nullishCoalesce(segs.find(long), () => ( segs[0]));
-    const t2 = _chunkGVB7ZPLZcjs.segmentTangent.call(void 0, s2, 0);
+    const t2 = _chunkVNYRI265cjs.segmentTangent.call(void 0, s2, 0);
     return { p: toVec(segs[0][0]), out: v(-t2[0], -t2[1]) };
   }
   const s = _nullishCoalesce([...segs].reverse().find(long), () => ( segs[segs.length - 1]));
-  const t = _chunkGVB7ZPLZcjs.segmentTangent.call(void 0, s, 1);
+  const t = _chunkVNYRI265cjs.segmentTangent.call(void 0, s, 1);
   const last = segs[segs.length - 1];
   return { p: toVec(last[last.length - 1]), out: v(t[0], t[1]) };
 }
@@ -899,7 +920,7 @@ function pointAlong(segs, fromStart, dist4) {
     const l = segLen(s);
     if (acc + l >= dist4) {
       const want = fromStart ? dist4 - acc : l - (dist4 - acc);
-      const pts = _chunkGVB7ZPLZcjs.trimSegments.call(void 0, [s], 0, want);
+      const pts = _chunkVNYRI265cjs.trimSegments.call(void 0, [s], 0, want);
       const p = pts.length ? pts[0][pts[0].length - 1] : s[0];
       return toVec(p);
     }
@@ -909,7 +930,7 @@ function pointAlong(segs, fromStart, dist4) {
 }
 function vectorStrokeParts(path, style) {
   const width = _nullishCoalesce(style.strokeWidth, () => ( 1));
-  const contours = _chunkGVB7ZPLZcjs.pathToContours.call(void 0, path).filter((c) => c.segments.length > 0);
+  const contours = _chunkVNYRI265cjs.pathToContours.call(void 0, path).filter((c) => c.segments.length > 0);
   const closedShape = contours.length > 0 && contours.every((c) => c.closed);
   const align = effectiveStrokeAlign(style, closedShape);
   const drawWidth = align === "center" ? width : width * 2;
@@ -949,26 +970,26 @@ function vectorStrokeParts(path, style) {
     if (!s0 && !s1) return c;
     const lengths = c.segments.map(segLen);
     const total = lengths.reduce((a, b) => a + b, 0);
-    return { closed: false, segments: total - s1 > s0 ? _chunkGVB7ZPLZcjs.trimSegments.call(void 0, c.segments, s0, total - s1, lengths) : [] };
+    return { closed: false, segments: total - s1 > s0 ? _chunkVNYRI265cjs.trimSegments.call(void 0, c.segments, s0, total - s1, lengths) : [] };
   });
-  return { align, line: _chunkGVB7ZPLZcjs.contoursToPath.call(void 0, trimmed), drawWidth, heads };
+  return { align, line: _chunkVNYRI265cjs.contoursToPath.call(void 0, trimmed), drawWidth, heads };
 }
 function vectorStrokeOutlinePath(path, style) {
   const parts = vectorStrokeParts(path, style);
   const stroke = vectorStrokeLineArea(parts, style);
   const fill = { path, fillRule: _nullishCoalesce(style.fillRule, () => ( "nonzero")) };
   let area = stroke;
-  if (parts.align === "inside") area = _chunkGVB7ZPLZcjs.pathBoolean.call(void 0, "intersection", [stroke, fill]).path;
-  else if (parts.align === "outside") area = _chunkGVB7ZPLZcjs.pathBoolean.call(void 0, "difference", [stroke, fill]).path;
+  if (parts.align === "inside") area = _chunkVNYRI265cjs.pathBoolean.call(void 0, "intersection", [stroke, fill]).path;
+  else if (parts.align === "outside") area = _chunkVNYRI265cjs.pathBoolean.call(void 0, "difference", [stroke, fill]).path;
   if (!parts.heads.length) return area;
-  return _chunkGVB7ZPLZcjs.pathBoolean.call(void 0, "union", [area, ...parts.heads.map((h) => h.path)]).path;
+  return _chunkVNYRI265cjs.pathBoolean.call(void 0, "union", [area, ...parts.heads.map((h) => h.path)]).path;
 }
 function hitTestVectorStroke(path, p, style, tolerance = 0) {
   const parts = vectorStrokeParts(path, style);
   const point = [p.x, p.y];
   const width = _nullishCoalesce(style.strokeWidth, () => ( 1));
   for (const h of parts.heads) {
-    if (_chunkGVB7ZPLZcjs.pointInBezierPath.call(void 0, h.path, point) || tolerance > 0 && _chunkGVB7ZPLZcjs.distanceToBezierPath.call(void 0, h.path, point) <= tolerance) return true;
+    if (_chunkVNYRI265cjs.pointInBezierPath.call(void 0, h.path, point) || tolerance > 0 && _chunkVNYRI265cjs.distanceToBezierPath.call(void 0, h.path, point) <= tolerance) return true;
   }
   if (!parts.line.length) return false;
   const profile = strokeWidthProfileOf(style);
@@ -986,13 +1007,13 @@ function hitTestVectorStroke(path, p, style, tolerance = 0) {
       reach = Math.max(reach, width / 2 * (w.left + w.right) / 2);
     }
   } else {
-    d = _chunkGVB7ZPLZcjs.distanceToBezierPath.call(void 0, parts.line, point);
+    d = _chunkVNYRI265cjs.distanceToBezierPath.call(void 0, parts.line, point);
     if (parts.align !== "center") reach = width;
   }
   if (parts.align === "center") return d <= reach + tolerance;
   if (d > reach + tolerance) return false;
   if (d <= tolerance) return true;
-  const inside = _chunkGVB7ZPLZcjs.pointInBezierPath.call(void 0, path, point, _nullishCoalesce(style.fillRule, () => ( "nonzero")));
+  const inside = _chunkVNYRI265cjs.pointInBezierPath.call(void 0, path, point, _nullishCoalesce(style.fillRule, () => ( "nonzero")));
   return parts.align === "inside" ? inside : !inside;
 }
 function vectorStrokeReach(style) {
@@ -1068,7 +1089,7 @@ function vectorNodeToBezier(node) {
 }
 function vectorPathData(input, precision = 3) {
   const subpaths = Array.isArray(input) ? input : input.subpaths;
-  return _chunkGVB7ZPLZcjs.bezierPathToSvg.call(void 0, subpathsToBezier(subpaths), { precision });
+  return _chunkVNYRI265cjs.bezierPathToSvg.call(void 0, subpathsToBezier(subpaths), { precision });
 }
 function inferAnchorType(a) {
   if (isOnAnchor(a, a.in) || isOnAnchor(a, a.out)) return "corner";
@@ -1084,7 +1105,7 @@ function inferAnchorType(a) {
   return Math.abs(li - lo) <= 1e-3 * Math.max(li, lo) ? "symmetric" : "smooth";
 }
 function bezierToSubpaths(input) {
-  const path = _chunkGVB7ZPLZcjs.toBezierPath.call(void 0, input);
+  const path = _chunkVNYRI265cjs.toBezierPath.call(void 0, input);
   const out = [];
   let current = null;
   const last = () => current.anchors[current.anchors.length - 1];
@@ -1181,14 +1202,14 @@ function nodeMatrix(node) {
 function vectorPathWorldBezier(node, parent = IDENTITY_MATRIX) {
   const m = multiplyMatrices(nodeMatrix(node), parent);
   const path = subpathsToBezier(node.subpaths);
-  return isIdentityMatrix(m) ? path : _chunkGVB7ZPLZcjs.transformBezierPath.call(void 0, path, m);
+  return isIdentityMatrix(m) ? path : _chunkVNYRI265cjs.transformBezierPath.call(void 0, path, m);
 }
 function vectorNodeBounds(node, parent = IDENTITY_MATRIX) {
   if (node.type === "group") {
     const m = multiplyMatrices(nodeMatrix(node), parent);
     return unionBounds(node.children.map((c) => vectorNodeBounds(c, m)));
   }
-  const b = _chunkGVB7ZPLZcjs.bezierPathBounds.call(void 0, vectorPathWorldBezier(node, parent));
+  const b = _chunkVNYRI265cjs.bezierPathBounds.call(void 0, vectorPathWorldBezier(node, parent));
   if (!b) return null;
   return { x: b.minX, y: b.minY, width: b.maxX - b.minX, height: b.maxY - b.minY };
 }
@@ -1222,9 +1243,9 @@ function hitTestVectorNode(node, p, tolerance = 0, parent = IDENTITY_MATRIX) {
   const path = vectorPathWorldBezier(node, parent);
   if (path.length === 0) return false;
   const point = [p.x, p.y];
-  if (hasPaint(node.fill) && _chunkGVB7ZPLZcjs.pointInBezierPath.call(void 0, path, point, _nullishCoalesce(node.fillRule, () => ( "nonzero")))) return true;
+  if (hasPaint(node.fill) && _chunkVNYRI265cjs.pointInBezierPath.call(void 0, path, point, _nullishCoalesce(node.fillRule, () => ( "nonzero")))) return true;
   if (hasPaint(node.stroke)) return hitTestVectorStroke(path, p, node, tolerance);
-  return _chunkGVB7ZPLZcjs.distanceToBezierPath.call(void 0, path, point) <= tolerance;
+  return _chunkVNYRI265cjs.distanceToBezierPath.call(void 0, path, point) <= tolerance;
 }
 function vectorStrokeOutline(node, parent = IDENTITY_MATRIX) {
   if (!hasPaint(node.stroke) || !((_nullishCoalesce(node.strokeWidth, () => ( 1))) > 0)) return [];
@@ -1244,9 +1265,9 @@ function nearestSegment(node, p) {
     const count = subpathSegmentCount(sp);
     for (let i = 0; i < count; i++) {
       const seg = subpathSegment(sp, i);
-      const hit = _chunkGVB7ZPLZcjs.segmentNearest.call(void 0, seg, [p.x, p.y]);
+      const hit = _chunkVNYRI265cjs.segmentNearest.call(void 0, seg, [p.x, p.y]);
       if (!best || hit.distance < best.distance) {
-        const pt2 = _chunkGVB7ZPLZcjs.segmentPoint.call(void 0, seg, hit.t);
+        const pt2 = _chunkVNYRI265cjs.segmentPoint.call(void 0, seg, hit.t);
         best = { subpath: s, segment: i, t: hit.t, point: { x: pt2[0], y: pt2[1] }, distance: hit.distance };
       }
     }
@@ -1420,7 +1441,7 @@ function insertAnchor(sp, segment, t) {
   const ia = segment;
   const ib = (segment + 1) % n;
   const seg = subpathSegment(sp, segment);
-  const [left, right] = _chunkGVB7ZPLZcjs.splitSegment.call(void 0, seg, t);
+  const [left, right] = _chunkVNYRI265cjs.splitSegment.call(void 0, seg, t);
   const mid = left[left.length - 1];
   const anchor = { x: mid[0], y: mid[1] };
   if (seg.length === 4) {
@@ -1474,8 +1495,8 @@ function ellipseSubpath(b) {
     ]
   };
 }
-function polygonSubpath(b, sides = 6) {
-  const n = Math.max(3, Math.round(sides));
+function polygonSubpath(b, sides2 = 6) {
+  const n = Math.max(3, Math.round(sides2));
   const cx = b.x + b.width / 2;
   const cy = b.y + b.height / 2;
   const anchors = [];
@@ -1516,7 +1537,7 @@ function vectorCornersAttribute(subpaths, precision = 3) {
   subpaths.forEach(
     (sp, s) => sp.anchors.forEach((a, i) => {
       if (!a.corner || !(a.corner.radius > 0)) return;
-      out.push(`${s}.${i}:${_chunkGVB7ZPLZcjs.formatNumber.call(void 0, a.corner.radius, precision)}${a.corner.kind && a.corner.kind !== "round" ? `:${a.corner.kind}` : ""}`);
+      out.push(`${s}.${i}:${_chunkVNYRI265cjs.formatNumber.call(void 0, a.corner.radius, precision)}${a.corner.kind && a.corner.kind !== "round" ? `:${a.corner.kind}` : ""}`);
     })
   );
   return out.join(" ");
@@ -1537,7 +1558,7 @@ var escapeAttr = (value) => value.replace(/&/g, "&amp;").replace(/"/g, "&quot;")
 function vectorPaintToSvg(paint, gradientId) {
   if (!hasPaint(paint)) return { value: "none", gradient: null };
   if (typeof paint === "string") return { value: paint, gradient: null };
-  return { value: `url(#${gradientId})`, gradient: _chunkGVB7ZPLZcjs.gradientToSvgDef.call(void 0, paint, gradientId) };
+  return { value: `url(#${gradientId})`, gradient: _chunkVNYRI265cjs.gradientToSvgDef.call(void 0, paint, gradientId) };
 }
 var partsCache = /* @__PURE__ */ new WeakMap();
 function vectorStrokeSvgParts(node, clipId, precision = 3) {
@@ -1555,22 +1576,22 @@ function computeStrokeSvgParts(node, clipId, precision) {
   if (parts.align === "center" && !parts.heads.length && !profiled) return void 0;
   let clip = null;
   if (parts.align !== "center") {
-    const b = _chunkGVB7ZPLZcjs.bezierPathBounds.call(void 0, path);
+    const b = _chunkVNYRI265cjs.bezierPathBounds.call(void 0, path);
     const pad = vectorStrokeReach(node) + 1;
     const bounds = b ? { x: round2(b.minX - pad), y: round2(b.minY - pad), width: round2(b.maxX - b.minX + 2 * pad), height: round2(b.maxY - b.minY + 2 * pad) } : { x: 0, y: 0, width: 0, height: 0 };
     clip = { kind: parts.align === "inside" ? "clip" : "mask", id: clipId, bounds };
   }
   return {
     align: parts.align,
-    d: _chunkGVB7ZPLZcjs.bezierPathToSvg.call(void 0, parts.line, { precision }),
+    d: _chunkVNYRI265cjs.bezierPathToSvg.call(void 0, parts.line, { precision }),
     width: parts.drawWidth,
-    ...profiled && (_nullishCoalesce(node.strokeWidth, () => ( 1))) > 0 ? { outline: _chunkGVB7ZPLZcjs.bezierPathToSvg.call(void 0, vectorStrokeLineArea(parts, node), { precision }) } : {},
+    ...profiled && (_nullishCoalesce(node.strokeWidth, () => ( 1))) > 0 ? { outline: _chunkVNYRI265cjs.bezierPathToSvg.call(void 0, vectorStrokeLineArea(parts, node), { precision }) } : {},
     clip,
-    heads: parts.heads.map((h) => _chunkGVB7ZPLZcjs.bezierPathToSvg.call(void 0, h.path, { precision }))
+    heads: parts.heads.map((h) => _chunkVNYRI265cjs.bezierPathToSvg.call(void 0, h.path, { precision }))
   };
 }
 function widthProfileToAttribute(points, precision = 4) {
-  return points.map((p) => [p.t, p.left, p.right].map((n) => _chunkGVB7ZPLZcjs.formatNumber.call(void 0, n, precision)).join(",")).join(";");
+  return points.map((p) => [p.t, p.left, p.right].map((n) => _chunkVNYRI265cjs.formatNumber.call(void 0, n, precision)).join(",")).join(";");
 }
 function widthProfileFromAttribute(value) {
   if (!value) return [];
@@ -1594,11 +1615,11 @@ function vectorDocumentToSvg(doc, options = {}) {
   const pretty = options.pretty !== false;
   const defs = [];
   const lines = [];
-  const num = (n) => _chunkGVB7ZPLZcjs.formatNumber.call(void 0, n, precision);
+  const num = (n) => _chunkVNYRI265cjs.formatNumber.call(void 0, n, precision);
   const indent = (depth) => pretty ? "  ".repeat(depth) : "";
   const common = (node) => {
     let out2 = ` id="${escapeAttr(node.id)}"`;
-    if (node.transform) out2 += ` transform="matrix(${node.transform.map((n) => _chunkGVB7ZPLZcjs.formatNumber.call(void 0, n, 6)).join(" ")})"`;
+    if (node.transform) out2 += ` transform="matrix(${node.transform.map((n) => _chunkVNYRI265cjs.formatNumber.call(void 0, n, 6)).join(" ")})"`;
     if (node.opacity !== void 0 && node.opacity < 1) out2 += ` opacity="${num(node.opacity)}"`;
     if (node.visible === false) out2 += ` display="none"`;
     return out2;
@@ -1617,7 +1638,7 @@ function vectorDocumentToSvg(doc, options = {}) {
     if (stroke.gradient) defs.push(gradientMarkup(stroke.gradient));
     const d = vectorPathData(node, precision);
     const corners2 = vectorCornersAttribute(node.subpaths, precision);
-    const live = corners2 ? ` data-vector-d="${_chunkGVB7ZPLZcjs.bezierPathToSvg.call(void 0, subpathsToBezier(node.subpaths, { corners: false }), { precision })}" data-vector-corners="${corners2}"` : "";
+    const live = corners2 ? ` data-vector-d="${_chunkVNYRI265cjs.bezierPathToSvg.call(void 0, subpathsToBezier(node.subpaths, { corners: false }), { precision })}" data-vector-corners="${corners2}"` : "";
     const fillAttrs = ` fill="${escapeAttr(fill.value)}"${node.fillRule === "evenodd" ? ` fill-rule="evenodd"` : ""}`;
     const lineAttrs = (width) => {
       let out2 = ` stroke="${escapeAttr(stroke.value)}" stroke-width="${num(width)}"`;
@@ -1648,7 +1669,7 @@ function vectorDocumentToSvg(doc, options = {}) {
     lines.push(`${indent(depth)}<g${common(node)}${data}>`);
     lines.push(`${indent(depth + 1)}<path data-vector-part="fill" d="${d}"${fillAttrs}${live}/>`);
     if (options.strokes === "outline") {
-      const area = _chunkGVB7ZPLZcjs.bezierPathToSvg.call(void 0, vectorStrokeOutlinePath(subpathsToBezier(node.subpaths), node), { precision });
+      const area = _chunkVNYRI265cjs.bezierPathToSvg.call(void 0, vectorStrokeOutlinePath(subpathsToBezier(node.subpaths), node), { precision });
       lines.push(`${indent(depth + 1)}<path data-vector-part="stroke-outline" d="${area}" fill="${escapeAttr(stroke.value)}"/>`);
     } else {
       let clip = "";
@@ -2373,13 +2394,13 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
     const pt2 = toPoint(p);
     for (const s of this.segments) {
       if (p.x < s.minX - tol || p.x > s.maxX + tol || p.y < s.minY - tol || p.y > s.maxY + tol) continue;
-      const hit = _chunkGVB7ZPLZcjs.segmentNearest.call(void 0, s.seg, pt2);
+      const hit = _chunkVNYRI265cjs.segmentNearest.call(void 0, s.seg, pt2);
       if (hit.distance <= tol) out.push({ seg: s.seg, t: hit.t, distance: hit.distance });
     }
     return out.sort((a, b) => a.distance - b.distance);
   }
   onSegment(near2) {
-    return near2.length ? toVec2(_chunkGVB7ZPLZcjs.segmentPoint.call(void 0, near2[0].seg, near2[0].t)) : null;
+    return near2.length ? toVec2(_chunkVNYRI265cjs.segmentPoint.call(void 0, near2[0].seg, near2[0].t)) : null;
   }
   /** Where two of the target segments near `p` cross, the crossing nearest `p` within `tol`. */
   crossing(near2, p, tol) {
@@ -2388,7 +2409,7 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
     let bestD = Infinity;
     for (let i = 0; i < list.length; i++) {
       for (let j = i + 1; j < list.length; j++) {
-        for (const hit of _chunkGVB7ZPLZcjs.segmentIntersections.call(void 0, list[i].seg, list[j].seg)) {
+        for (const hit of _chunkVNYRI265cjs.segmentIntersections.call(void 0, list[i].seg, list[j].seg)) {
           const q = toVec2(hit.point);
           const d = distance(q, p);
           if (d <= tol && d < bestD) {
@@ -2710,15 +2731,15 @@ var crossCondition = (r, d) => r[0] * d[1] - r[1] * d[0];
 function solveOnSegment(seg, base, cond) {
   const b = [base.x, base.y];
   const g = (t) => {
-    const p = _chunkGVB7ZPLZcjs.segmentPoint.call(void 0, seg, t);
-    return cond([p[0] - b[0], p[1] - b[1]], _chunkGVB7ZPLZcjs.segmentDerivative.call(void 0, seg, t));
+    const p = _chunkVNYRI265cjs.segmentPoint.call(void 0, seg, t);
+    return cond([p[0] - b[0], p[1] - b[1]], _chunkVNYRI265cjs.segmentDerivative.call(void 0, seg, t));
   };
   const vals = [];
   let scale = 0;
   for (let i = 0; i <= CURVE_SAMPLES; i++) {
     const t = i / CURVE_SAMPLES;
-    const p = _chunkGVB7ZPLZcjs.segmentPoint.call(void 0, seg, t);
-    const d = _chunkGVB7ZPLZcjs.segmentDerivative.call(void 0, seg, t);
+    const p = _chunkVNYRI265cjs.segmentPoint.call(void 0, seg, t);
+    const d = _chunkVNYRI265cjs.segmentDerivative.call(void 0, seg, t);
     const r = [p[0] - b[0], p[1] - b[1]];
     vals.push(cond(r, d));
     scale = Math.max(scale, Math.hypot(r[0], r[1]) * Math.hypot(d[0], d[1]));
@@ -2745,8 +2766,8 @@ function solveOnSegment(seg, base, cond) {
       } else hi = m;
     }
     const t = (lo + hi) / 2;
-    const p = _chunkGVB7ZPLZcjs.segmentPoint.call(void 0, seg, t);
-    const dv = _chunkGVB7ZPLZcjs.segmentDerivative.call(void 0, seg, t);
+    const p = _chunkVNYRI265cjs.segmentPoint.call(void 0, seg, t);
+    const dv = _chunkVNYRI265cjs.segmentDerivative.call(void 0, seg, t);
     const r = Math.hypot(p[0] - b[0], p[1] - b[1]);
     const dl = Math.hypot(dv[0], dv[1]);
     if (!(r > 1e-9 && dl > 0) || Math.abs(cond([p[0] - b[0], p[1] - b[1]], dv)) > 1e-6 * r * dl) continue;
@@ -2783,7 +2804,7 @@ function endTangent(c) {
   return [1, 0];
 }
 function sample(c, n, out, withStart) {
-  for (let i = withStart ? 0 : 1; i <= n; i++) out.push(_chunkGVB7ZPLZcjs.segmentPoint.call(void 0, c, i / n));
+  for (let i = withStart ? 0 : 1; i <= n; i++) out.push(_chunkVNYRI265cjs.segmentPoint.call(void 0, c, i / n));
 }
 var onAnchor2 = (a, h) => !h || Math.abs(h.x - a.x) < EPS3 && Math.abs(h.y - a.y) < EPS3;
 function tidy(a, keepType = true) {
@@ -2829,7 +2850,7 @@ function fitAcross(pts, N, t0, t1) {
     const u = [];
     for (let i = 0; i <= N; i++) u.push(k * i / N);
     for (let i = 1; i <= N; i++) u.push(k + (1 - k) * i / N);
-    return _chunkGVB7ZPLZcjs.fitCubicWithTangents.call(void 0, pts, u, t0, t1);
+    return _chunkVNYRI265cjs.fitCubicWithTangents.call(void 0, pts, u, t0, t1);
   };
   return goldenMin(fit, 0, 1);
 }
@@ -2889,7 +2910,7 @@ function bendSegment(sp, segment, t, p) {
   return { anchors, closed: sp.closed };
 }
 function subpathPointAt(sp, segment, t) {
-  const [x, y] = _chunkGVB7ZPLZcjs.segmentPoint.call(void 0, subpathSegment(sp, segment), t);
+  const [x, y] = _chunkVNYRI265cjs.segmentPoint.call(void 0, subpathSegment(sp, segment), t);
   return { x, y };
 }
 function curvatureMoveAnchor(sp, index, q) {
@@ -3150,20 +3171,20 @@ function removeRedundantPoints(sp, tolerance) {
 }
 
 // src/vector/pathCut.ts
-var loopArea = (l) => _chunkGVB7ZPLZcjs.contourSignedArea.call(void 0, l.segs);
+var loopArea = (l) => _chunkVNYRI265cjs.contourSignedArea.call(void 0, l.segs);
 function loopSample(l) {
   const k = l.chord.findIndex((c) => !c);
-  return _chunkGVB7ZPLZcjs.segmentPoint.call(void 0, l.segs[k >= 0 ? k : 0], 0.5);
+  return _chunkVNYRI265cjs.segmentPoint.call(void 0, l.segs[k >= 0 ? k : 0], 0.5);
 }
-var contains2 = (l, p) => _chunkGVB7ZPLZcjs.windingNumber.call(void 0, [l.segs], p) !== 0;
+var contains2 = (l, p) => _chunkVNYRI265cjs.windingNumber.call(void 0, [l.segs], p) !== 0;
 function groupFaces(loops) {
-  const usable = loops.filter((l) => l.segs.length && Math.abs(loopArea(l)) > 1e-12);
-  if (!usable.length) return [];
-  const largest = usable.reduce((a, b) => Math.abs(loopArea(b)) > Math.abs(loopArea(a)) ? b : a);
+  const usable2 = loops.filter((l) => l.segs.length && Math.abs(loopArea(l)) > 1e-12);
+  if (!usable2.length) return [];
+  const largest = usable2.reduce((a, b) => Math.abs(loopArea(b)) > Math.abs(loopArea(a)) ? b : a);
   const sign = Math.sign(loopArea(largest));
-  const outers = usable.filter((l) => Math.sign(loopArea(l)) === sign).sort((a, b) => Math.abs(loopArea(a)) - Math.abs(loopArea(b)));
+  const outers = usable2.filter((l) => Math.sign(loopArea(l)) === sign).sort((a, b) => Math.abs(loopArea(a)) - Math.abs(loopArea(b)));
   const faces = new Map(outers.map((o) => [o, { loops: [o] }]));
-  for (const hole of usable.filter((l) => Math.sign(loopArea(l)) !== sign)) {
+  for (const hole of usable2.filter((l) => Math.sign(loopArea(l)) !== sign)) {
     const p = loopSample(hole);
     const parent = outers.find((o) => Math.abs(loopArea(o)) > Math.abs(loopArea(hole)) && contains2(o, p));
     if (parent) faces.get(parent).loops.push(hole);
@@ -3171,12 +3192,12 @@ function groupFaces(loops) {
   return outers.reverse().map((o) => faces.get(o));
 }
 function faceToPath(face) {
-  return _chunkGVB7ZPLZcjs.contoursToPath.call(void 0, face.loops.map((l) => ({ segments: l.segs, closed: true })));
+  return _chunkVNYRI265cjs.contoursToPath.call(void 0, face.loops.map((l) => ({ segments: l.segs, closed: true })));
 }
 function facesOf(path, fillRule) {
-  const normalized = _chunkGVB7ZPLZcjs.normalizeBezierPath.call(void 0, path, fillRule);
-  const loops = _chunkGVB7ZPLZcjs.pathToContours.call(void 0, normalized).map((c) => {
-    const segs = _chunkGVB7ZPLZcjs.closeContour.call(void 0, c, true).map((s) => s.slice());
+  const normalized = _chunkVNYRI265cjs.normalizeBezierPath.call(void 0, path, fillRule);
+  const loops = _chunkVNYRI265cjs.pathToContours.call(void 0, normalized).map((c) => {
+    const segs = _chunkVNYRI265cjs.closeContour.call(void 0, c, true).map((s) => s.slice());
     return { segs, chord: segs.map(() => false) };
   });
   return groupFaces(loops);
@@ -3246,7 +3267,7 @@ function lineHits(p, q, seg) {
   const scale = Math.sqrt(len2) * Math.max(1, ...seg.map((pt2) => Math.abs(pt2[0]) + Math.abs(pt2[1])));
   const out = [];
   for (const t of rootsInUnit(...coeffs, scale)) {
-    const point = _chunkGVB7ZPLZcjs.segmentPoint.call(void 0, seg, t);
+    const point = _chunkVNYRI265cjs.segmentPoint.call(void 0, seg, t);
     const s = ((point[0] - p[0]) * dx + (point[1] - p[1]) * dy) / len2;
     if (s >= -1e-9 && s <= 1 + 1e-9) out.push({ s: Math.min(1, Math.max(0, s)), t, point });
   }
@@ -3259,7 +3280,7 @@ function arc(l, a, b, eps) {
   const segs = [];
   const chord = [];
   const push = (k, t0, t1) => {
-    const piece = t0 <= 0 && t1 >= 1 ? l.segs[k].slice() : _chunkGVB7ZPLZcjs.subSegment.call(void 0, l.segs[k], t0, t1);
+    const piece = t0 <= 0 && t1 >= 1 ? l.segs[k].slice() : _chunkVNYRI265cjs.subSegment.call(void 0, l.segs[k], t0, t1);
     if (!degenerate(piece, eps)) {
       segs.push(piece);
       chord.push(l.chord[k]);
@@ -3284,7 +3305,7 @@ function knifePath(path, fillRule, knife) {
   if (pts.length < 2) return null;
   let faces = facesOf(path, fillRule);
   if (!faces.length) return null;
-  const b = _chunkGVB7ZPLZcjs.bezierPathBounds.call(void 0, path);
+  const b = _chunkVNYRI265cjs.bezierPathBounds.call(void 0, path);
   const size = b ? Math.max(b.maxX - b.minX, b.maxY - b.minY, 1) : 1;
   const eps = size * 1e-9;
   let cursor = -Infinity;
@@ -3298,7 +3319,7 @@ function knifePath(path, fillRule, knife) {
         const kb = { minX: Math.min(pts[m][0], pts[m + 1][0]), maxX: Math.max(pts[m][0], pts[m + 1][0]), minY: Math.min(pts[m][1], pts[m + 1][1]), maxY: Math.max(pts[m][1], pts[m + 1][1]) };
         face2.loops.forEach(
           (l, li) => l.segs.forEach((seg, si) => {
-            const sb = _chunkGVB7ZPLZcjs.segmentBounds.call(void 0, seg);
+            const sb = _chunkVNYRI265cjs.segmentBounds.call(void 0, seg);
             if (sb.maxX < kb.minX - eps || sb.minX > kb.maxX + eps || sb.maxY < kb.minY - eps || sb.minY > kb.maxY + eps) return;
             for (const h of lineHits(pts[m], pts[m + 1], seg)) {
               const s = m + h.s;
@@ -3313,7 +3334,7 @@ function knifePath(path, fillRule, knife) {
         const m = Math.min(pts.length - 2, Math.floor(s));
         const u = s - m;
         const q = [pts[m][0] + (pts[m + 1][0] - pts[m][0]) * u, pts[m][1] + (pts[m + 1][1] - pts[m][1]) * u];
-        return _chunkGVB7ZPLZcjs.windingNumber.call(void 0, face2.loops.map((l) => l.segs), q) !== 0;
+        return _chunkVNYRI265cjs.windingNumber.call(void 0, face2.loops.map((l) => l.segs), q) !== 0;
       };
       for (let i = 0; i < unique.length - 1; i++) {
         const from2 = unique[i];
@@ -3373,33 +3394,33 @@ function eraserRegion(points, width) {
     ];
   }
   const line2 = [{ type: "M", x: pts[0][0], y: pts[0][1] }, ...pts.slice(1).map((p) => ({ type: "L", x: p[0], y: p[1] }))];
-  return _chunkGVB7ZPLZcjs.outlineStroke.call(void 0, line2, { width, cap: "round", join: "round" });
+  return _chunkVNYRI265cjs.outlineStroke.call(void 0, line2, { width, cap: "round", join: "round" });
 }
 function eraseFromFill(path, fillRule, region) {
-  const overlap = _chunkGVB7ZPLZcjs.pathBoolean.call(void 0, "intersection", [{ path, fillRule }, { path: region }]).path;
-  if (!_chunkGVB7ZPLZcjs.pathToContours.call(void 0, overlap).some((c) => Math.abs(_chunkGVB7ZPLZcjs.contourSignedArea.call(void 0, _chunkGVB7ZPLZcjs.closeContour.call(void 0, c, true))) > 1e-9)) return null;
-  const rest = _chunkGVB7ZPLZcjs.pathBoolean.call(void 0, "difference", [{ path, fillRule }, { path: region }]).path;
+  const overlap = _chunkVNYRI265cjs.pathBoolean.call(void 0, "intersection", [{ path, fillRule }, { path: region }]).path;
+  if (!_chunkVNYRI265cjs.pathToContours.call(void 0, overlap).some((c) => Math.abs(_chunkVNYRI265cjs.contourSignedArea.call(void 0, _chunkVNYRI265cjs.closeContour.call(void 0, c, true))) > 1e-9)) return null;
+  const rest = _chunkVNYRI265cjs.pathBoolean.call(void 0, "difference", [{ path, fillRule }, { path: region }]).path;
   return splitIntoFaces(rest);
 }
 function eraseFromOutline(sp, region) {
-  const regionSegs = _chunkGVB7ZPLZcjs.pathToContours.call(void 0, region).flatMap((c) => _chunkGVB7ZPLZcjs.closeContour.call(void 0, c, true));
+  const regionSegs = _chunkVNYRI265cjs.pathToContours.call(void 0, region).flatMap((c) => _chunkVNYRI265cjs.closeContour.call(void 0, c, true));
   if (!regionSegs.length) return null;
-  const rb = _chunkGVB7ZPLZcjs.bezierPathBounds.call(void 0, region);
+  const rb = _chunkVNYRI265cjs.bezierPathBounds.call(void 0, region);
   const count = subpathSegmentCount(sp);
   if (!rb || count === 0) return null;
-  const removed = (p) => _chunkGVB7ZPLZcjs.pointInBezierPath.call(void 0, region, p, "nonzero");
+  const removed = (p) => _chunkVNYRI265cjs.pointInBezierPath.call(void 0, region, p, "nonzero");
   const runs = [];
   let cur = [];
   let any = false;
   for (let i = 0; i < count; i++) {
     const seg = subpathSegment(sp, i);
-    const sb = _chunkGVB7ZPLZcjs.segmentBounds.call(void 0, seg);
+    const sb = _chunkVNYRI265cjs.segmentBounds.call(void 0, seg);
     const ts = [0, 1];
     if (!(sb.maxX < rb.minX || sb.minX > rb.maxX || sb.maxY < rb.minY || sb.minY > rb.maxY)) {
       for (const r of regionSegs) {
-        const b = _chunkGVB7ZPLZcjs.segmentBounds.call(void 0, r);
+        const b = _chunkVNYRI265cjs.segmentBounds.call(void 0, r);
         if (b.maxX < sb.minX || b.minX > sb.maxX || b.maxY < sb.minY || b.minY > sb.maxY) continue;
-        for (const hit of _chunkGVB7ZPLZcjs.segmentIntersections.call(void 0, seg, r)) if (hit.ta > 1e-9 && hit.ta < 1 - 1e-9) ts.push(hit.ta);
+        for (const hit of _chunkVNYRI265cjs.segmentIntersections.call(void 0, seg, r)) if (hit.ta > 1e-9 && hit.ta < 1 - 1e-9) ts.push(hit.ta);
       }
     }
     ts.sort((a, b) => a - b);
@@ -3407,7 +3428,7 @@ function eraseFromOutline(sp, region) {
       const t0 = ts[k];
       const t1 = ts[k + 1];
       if (t1 - t0 < 1e-9) continue;
-      if (removed(_chunkGVB7ZPLZcjs.segmentPoint.call(void 0, seg, (t0 + t1) / 2))) {
+      if (removed(_chunkVNYRI265cjs.segmentPoint.call(void 0, seg, (t0 + t1) / 2))) {
         any = true;
         if (cur.length) runs.push(cur);
         cur = [];
@@ -3426,7 +3447,7 @@ function eraseFromOutline(sp, region) {
   for (const run of runs) {
     const anchors = [];
     for (const { seg, t0, t1 } of run) {
-      const c = _chunkGVB7ZPLZcjs.subSegment.call(void 0, subpathSegment(sp, seg), t0, t1);
+      const c = _chunkVNYRI265cjs.subSegment.call(void 0, subpathSegment(sp, seg), t0, t1);
       const line2 = c.length === 2;
       const start = c[0];
       const end = c[c.length - 1];
@@ -3715,15 +3736,226 @@ function recognizeInkShape(points, options = {}) {
   return roundish && rms < 0.1 ? ellipse() : null;
 }
 
+// src/vector/builder.ts
+function vectorPathEntries(doc, roots, options = {}) {
+  const out = [];
+  const visit = (node, parent, inside) => {
+    if (node.visible === false || node.locked && !options.locked) return;
+    const picked = inside || roots === null || roots.includes(node.id);
+    if (node.type === "group") {
+      const m = multiplyMatrices(nodeMatrix(node), parent);
+      for (const c of node.children) visit(c, m, picked);
+    } else if (picked) out.push({ node, parent });
+  };
+  for (const n of doc.nodes) visit(n, IDENTITY_MATRIX, false);
+  return out;
+}
+var usable = (sp) => sp.anchors.length > 1;
+function worldOf(entry, subpaths) {
+  return vectorPathWorldBezier({ ...entry.node, subpaths }, entry.parent);
+}
+function subpathEnclosesArea(sp) {
+  const contour = _chunkVNYRI265cjs.pathToContours.call(void 0, subpathsToBezier([{ ...sp, closed: true }]))[0];
+  if (!contour) return false;
+  const segs = _chunkVNYRI265cjs.closeContour.call(void 0, contour, true);
+  const b = _chunkVNYRI265cjs.bezierPathBounds.call(void 0, _chunkVNYRI265cjs.contoursToPath.call(void 0, [{ segments: segs, closed: true }]));
+  if (!b) return false;
+  const w = b.maxX - b.minX;
+  const h = b.maxY - b.minY;
+  return Math.abs(_chunkVNYRI265cjs.contourSignedArea.call(void 0, segs)) > 1e-9 * (w * w + h * h);
+}
+var paintKey = (paint) => typeof paint === "string" ? paint.trim().toLowerCase() : JSON.stringify(_nullishCoalesce(paint, () => ( null)));
+function vectorPathfinderShape(entry, op) {
+  const { node } = entry;
+  const subpaths = node.subpaths.filter(usable);
+  const closed = subpaths.map((s) => ({ ...s, closed: true }));
+  const fillRule = _nullishCoalesce(node.fillRule, () => ( "nonzero"));
+  if (hasPaint(node.fill)) return { path: worldOf(entry, closed), fillRule, key: `fill:${paintKey(node.fill)}`, paint: "fill" };
+  const open = subpaths.length > 0 && subpaths.every((s) => !s.closed);
+  if (op === "divide" && open) return { path: worldOf(entry, subpaths), line: true, paint: "line" };
+  if (hasPaint(node.stroke) && (_nullishCoalesce(node.strokeWidth, () => ( 1))) > 0) {
+    const path = vectorStrokeOutline({ ...node, subpaths }, entry.parent);
+    return { path, fillRule: "nonzero", key: `fill:${paintKey(node.stroke)}`, paint: "stroke" };
+  }
+  return { path: worldOf(entry, closed), fillRule, key: "none", paint: "outline" };
+}
+var STROKE_KEYS = [
+  "stroke",
+  "strokeWidth",
+  "strokeLinecap",
+  "strokeLinejoin",
+  "strokeDasharray",
+  "strokeAlign",
+  "startArrow",
+  "endArrow",
+  "arrowAlign",
+  "startArrowScale",
+  "endArrowScale",
+  "strokeWidthProfile"
+];
+function vectorResultStyle(node, paint, edge = false) {
+  const { id: _id, subpaths: _s, transform: _t, ...rest } = node;
+  const base = { ...rest, fillRule: "nonzero" };
+  if (edge) {
+    for (const k of STROKE_KEYS) delete base[k];
+    const stroke = paint === "stroke" || !hasPaint(node.fill) ? node.stroke : node.fill;
+    return { ...base, fill: null, stroke: _nullishCoalesce(stroke, () => ( "#000000")), strokeWidth: _nullishCoalesce(node.strokeWidth, () => ( 1)) };
+  }
+  if (paint === "stroke") {
+    for (const k of STROKE_KEYS) delete base[k];
+    return { ...base, fill: _nullishCoalesce(node.stroke, () => ( null)), stroke: null };
+  }
+  return base;
+}
+function vectorShapeBuilderMap(entries) {
+  const lines = [];
+  const inputs = entries.map((entry) => {
+    const filled = hasPaint(entry.node.fill);
+    const subpaths = entry.node.subpaths.filter(usable).map((sp) => !sp.closed && filled && subpathEnclosesArea(sp) ? { ...sp, closed: true } : sp);
+    lines.push(!subpaths.some((s) => s.closed));
+    return { path: worldOf(entry, subpaths), fillRule: _nullishCoalesce(entry.node.fillRule, () => ( "nonzero")) };
+  });
+  const map = _chunkVNYRI265cjs.PlanarMap.build(inputs);
+  if (!map) return null;
+  let chains = null;
+  const runs = (line2) => (chains ??= map.chains()).filter((c) => lines[c.source] === line2 && !(line2 && c.closed)).map((c) => {
+    const path = _chunkVNYRI265cjs.contoursToPath.call(void 0, [{ segments: c.segments, closed: c.closed }]);
+    return { path, segments: c.segments, closed: c.closed, source: c.source, bounds: _chunkVNYRI265cjs.bezierPathBounds.call(void 0, path) };
+  });
+  const pieces = lines.some(Boolean) ? runs(true) : [];
+  let edges = null;
+  let size = 0;
+  for (const input of inputs) {
+    const b = _chunkVNYRI265cjs.bezierPathBounds.call(void 0, input.path);
+    if (b) size = Math.max(size, b.maxX - b.minX, b.maxY - b.minY);
+  }
+  return {
+    entries: [...entries],
+    map,
+    lines,
+    pieces,
+    get edges() {
+      return edges ??= runs(false);
+    },
+    tolerance: 0.2 * Math.max(size / 2e3, 0.25)
+  };
+}
+function pieceNear(pieces, p, tol) {
+  const point = [p.x, p.y];
+  let best = null;
+  pieces.forEach((piece, index) => {
+    const b = piece.bounds;
+    if (p.x < b.minX - tol || p.x > b.maxX + tol || p.y < b.minY - tol || p.y > b.maxY + tol) return;
+    const d = _chunkVNYRI265cjs.distanceToBezierPath.call(void 0, piece.path, point);
+    if (d <= tol && (!best || d < best.d)) best = { index, d };
+  });
+  return best;
+}
+function vectorShapeBuilderHit(m, p, lineTolerance = null) {
+  if (lineTolerance !== null && lineTolerance > 0) {
+    const line2 = pieceNear(m.pieces, p, lineTolerance);
+    const edge = pieceNear(m.edges, p, lineTolerance);
+    if (edge && (!line2 || edge.d < line2.d)) return { edge: edge.index };
+    if (line2) return { line: line2.index };
+  }
+  const face = m.map.faceAt([p.x, p.y]);
+  return face >= 0 ? { face } : null;
+}
+function samplePolyline(points, step) {
+  const out = [];
+  const s = Math.max(step, 1e-3);
+  points.forEach((p, i) => {
+    if (i > 0) {
+      const a = points[i - 1];
+      const n = Math.min(4e3, Math.ceil(Math.hypot(p.x - a.x, p.y - a.y) / s));
+      for (let k = 1; k < n; k++) out.push({ x: a.x + (p.x - a.x) * k / n, y: a.y + (p.y - a.y) * k / n });
+    }
+    out.push(p);
+  });
+  return out;
+}
+function addBuilderHit(touched, hit) {
+  if (!hit) return false;
+  const [list, i] = "face" in hit ? [touched.faces, hit.face] : "line" in hit ? [touched.lines, hit.line] : [touched.edges, hit.edge];
+  if (list.includes(i)) return false;
+  list.push(i);
+  return true;
+}
+function sides(m, piece) {
+  const seg = piece.segments[Math.floor(piece.segments.length / 2)];
+  const mid = _chunkVNYRI265cjs.segmentPoint.call(void 0, seg, 0.5);
+  const t = _chunkVNYRI265cjs.segmentTangent.call(void 0, seg, 0.5);
+  const chord = Math.hypot(seg[seg.length - 1][0] - seg[0][0], seg[seg.length - 1][1] - seg[0][1]);
+  const off = Math.max(1e-6, Math.min(0.05, 0.05 * chord));
+  return [m.map.faceAt([mid[0] - t[1] * off, mid[1] + t[0] * off]), m.map.faceAt([mid[0] + t[1] * off, mid[1] - t[0] * off])];
+}
+function vectorBuilderErasedEdges(m, touched) {
+  if (!touched.edges.length) return [];
+  const faces = new Set(touched.faces);
+  return touched.edges.filter((k) => m.edges[k] && !sides(m, m.edges[k]).some((f) => f >= 0 && faces.has(f)));
+}
+function planShapeBuilder(m, touched, erase) {
+  const replace = /* @__PURE__ */ new Map();
+  const picked = new Set(touched.faces);
+  const faces = m.map.faces;
+  const sourcesOf = faces.map((_, i) => m.map.faceSources(i));
+  const cuts = erase ? vectorBuilderErasedEdges(m, touched).map((k) => m.edges[k]) : [];
+  m.entries.forEach((entry, i) => {
+    if (m.lines[i]) {
+      const own = m.pieces.flatMap((piece, k) => piece.source === i ? [k] : []);
+      const keep = own.filter((k) => !touched.lines.includes(k) && !sides(m, m.pieces[k]).every((f) => f >= 0 && picked.has(f)));
+      if (keep.length === own.length) return;
+      replace.set(i, keep.length ? { kind: "pieces", paths: keep.map((k) => m.pieces[k].path) } : null);
+      return;
+    }
+    const inUnion = touched.faces.some((f) => sourcesOf[f].includes(i));
+    if (!inUnion && !cuts.length) return;
+    let rest;
+    if (inUnion) {
+      const kept = faces.flatMap((_, f) => sourcesOf[f].includes(i) && !picked.has(f) ? [f] : []);
+      rest = kept.length ? m.map.merge(kept) : [];
+    } else rest = worldOf(entry, entry.node.subpaths.filter(usable));
+    const fillCloses = hasPaint(entry.node.fill);
+    let cut = false;
+    for (const piece of cuts) {
+      const r = rest.length ? _chunkVNYRI265cjs.cutOutPiece.call(void 0, rest, piece, fillCloses, m.tolerance) : null;
+      if (r) {
+        rest = r;
+        cut = true;
+      }
+    }
+    if (!inUnion && !cut) return;
+    replace.set(i, rest.length ? { kind: inUnion ? "fill" : "outline", path: rest } : null);
+  });
+  let merged = null;
+  if (!erase && touched.faces.length) {
+    const path = m.map.merge(touched.faces);
+    const covered = touched.faces.map((f) => sourcesOf[f]).find((s) => s.length);
+    const lastShape = m.lines.lastIndexOf(false);
+    const style = covered ? covered[covered.length - 1] : lastShape >= 0 ? lastShape : m.entries.length - 1;
+    if (path.length) merged = { path, style, currentFill: !covered };
+  }
+  return { replace, merged };
+}
+function vectorFillMap(doc, gap = 0) {
+  const entries = vectorPathEntries(doc, null, { locked: true });
+  return _chunkVNYRI265cjs.PlanarMap.build(
+    entries.map((e) => ({ path: worldOf(e, e.node.subpaths.filter(usable)), fills: false })),
+    { gap, maxSegments: 2e4 }
+  );
+}
+
 // src/vector/controller.ts
 var DEFAULT_VECTOR_SNAP = { grid: 0, objects: true, guides: true, threshold: 5, angles: VECTOR_CONSTRUCTION_ANGLES };
+var VECTOR_FILL_GAP = 6;
 var DEFAULT_VECTOR_PATH_EDIT = {
   keepShapeOnDelete: true,
   curvatureMoves: false,
   pencilSmoothing: 0,
   recognizeShapes: false,
   eraserSize: 10,
-  pencilPressure: "pen"
+  pencilPressure: "pen",
+  fillGap: 0
 };
 var VECTOR_PENCIL_STRING_PX = 100;
 var VECTOR_STYLE_KEYS = [
@@ -3962,9 +4194,27 @@ var TOOL_LABELS = {
   scissors: "Scissors",
   knife: "Knife",
   eraser: "Eraser",
-  width: "Width"
+  width: "Width",
+  shapeBuilder: "Shape Builder",
+  paintBucket: "Paint Bucket"
+};
+var TOOL_KEYS = {
+  v: "select",
+  a: "direct",
+  p: "pen",
+  n: "pencil",
+  r: "rect",
+  o: "ellipse",
+  y: "polygon",
+  s: "star",
+  l: "line",
+  c: "scissors",
+  k: "knife",
+  e: "eraser",
+  w: "width",
+  m: "shapeBuilder",
+  b: "paintBucket"
 };
-var TOOL_KEYS = { v: "select", a: "direct", p: "pen", n: "pencil", r: "rect", o: "ellipse", y: "polygon", s: "star", l: "line", c: "scissors", k: "knife", e: "eraser", w: "width" };
 function vectorToolLabel(tool) {
   return TOOL_LABELS[tool];
 }
@@ -3981,7 +4231,9 @@ var VECTOR_TOOL_SHORTCUTS = {
   scissors: "C",
   knife: "K",
   eraser: "E",
-  width: "W"
+  width: "W",
+  shapeBuilder: "M",
+  paintBucket: "B"
 };
 var VECTOR_TOOL_GLYPHS = {
   select: "\u2196",
@@ -3996,7 +4248,9 @@ var VECTOR_TOOL_GLYPHS = {
   scissors: "\u2702",
   knife: "\u27CB",
   eraser: "\u232B",
-  width: "\u21F9"
+  width: "\u21F9",
+  shapeBuilder: "\u2295",
+  paintBucket: "\u25CD"
 };
 var SHAPE_TOOLS = /* @__PURE__ */ new Set(["rect", "ellipse", "polygon", "star", "line"]);
 var BOOLEAN_OPS = {
@@ -4006,6 +4260,14 @@ var BOOLEAN_OPS = {
   exclude: "xor"
 };
 var BOOLEAN_LABELS = { union: "Union", subtract: "Subtract", intersect: "Intersect", exclude: "Exclude" };
+var VECTOR_PATHFINDER_LABELS = {
+  divide: "Divide",
+  trim: "Trim",
+  merge: "Merge",
+  crop: "Crop",
+  outline: "Outline",
+  minusBack: "Minus Back"
+};
 function mapTree(nodes, fn) {
   let changed = false;
   const out = [];
@@ -4070,16 +4332,23 @@ var VectorEditorController = (_class3 = class {
   __init20() {this.hoverTargets = null}
   __init21() {this.spaceHeld = false}
   __init22() {this.clipboard = null}
+  /** Shape Builder map of the selection, kept while the document and the selection stay the same. */
+  __init23() {this.builderCache = null}
+  /** Paint bucket map of the visible outlines. */
+  __init24() {this.fillCache = null}
+  __init25() {this.builderPreview = null}
+  /** What the highlight shows, to skip notifying when the pointer stays over the same face. */
+  __init26() {this.builderHoverKey = null}
   
   
-  __init23() {this.listeners = /* @__PURE__ */ new Set()}
-  __init24() {this.cleanups = []}
-  __init25() {this.applying = false}
+  __init27() {this.listeners = /* @__PURE__ */ new Set()}
+  __init28() {this.cleanups = []}
+  __init29() {this.applying = false}
   /** Set while a commit records a change that was already applied, so `restore` still reports it. */
-  __init26() {this.committing = false}
-  __init27() {this.revision = 0}
+  __init30() {this.committing = false}
+  __init31() {this.revision = 0}
   
-  constructor(options = {}) {;_class3.prototype.__init9.call(this);_class3.prototype.__init10.call(this);_class3.prototype.__init11.call(this);_class3.prototype.__init12.call(this);_class3.prototype.__init13.call(this);_class3.prototype.__init14.call(this);_class3.prototype.__init15.call(this);_class3.prototype.__init16.call(this);_class3.prototype.__init17.call(this);_class3.prototype.__init18.call(this);_class3.prototype.__init19.call(this);_class3.prototype.__init20.call(this);_class3.prototype.__init21.call(this);_class3.prototype.__init22.call(this);_class3.prototype.__init23.call(this);_class3.prototype.__init24.call(this);_class3.prototype.__init25.call(this);_class3.prototype.__init26.call(this);_class3.prototype.__init27.call(this);_class3.prototype.__init28.call(this);_class3.prototype.__init29.call(this);
+  constructor(options = {}) {;_class3.prototype.__init9.call(this);_class3.prototype.__init10.call(this);_class3.prototype.__init11.call(this);_class3.prototype.__init12.call(this);_class3.prototype.__init13.call(this);_class3.prototype.__init14.call(this);_class3.prototype.__init15.call(this);_class3.prototype.__init16.call(this);_class3.prototype.__init17.call(this);_class3.prototype.__init18.call(this);_class3.prototype.__init19.call(this);_class3.prototype.__init20.call(this);_class3.prototype.__init21.call(this);_class3.prototype.__init22.call(this);_class3.prototype.__init23.call(this);_class3.prototype.__init24.call(this);_class3.prototype.__init25.call(this);_class3.prototype.__init26.call(this);_class3.prototype.__init27.call(this);_class3.prototype.__init28.call(this);_class3.prototype.__init29.call(this);_class3.prototype.__init30.call(this);_class3.prototype.__init31.call(this);_class3.prototype.__init32.call(this);_class3.prototype.__init33.call(this);
     this.history = _nullishCoalesce(options.history, () => ( new (0, _chunkQKLRAA4Tcjs.HistoryManager)()));
     this.doc = options.document ? cloneVectorDocument(options.document) : { width: 800, height: 600, nodes: [] };
     this.tool = _nullishCoalesce(options.tool, () => ( "select"));
@@ -4108,9 +4377,9 @@ var VectorEditorController = (_class3 = class {
   // State
   // -------------------------------------------------------------------------
   /** The current snapshot (stable until the next change). */
-  __init28() {this.getState = () => this.state}
+  __init32() {this.getState = () => this.state}
   /** Calls `listener` after every change. Returns an unsubscribe function. */
-  __init29() {this.subscribe = (listener) => {
+  __init33() {this.subscribe = (listener) => {
     this.listeners.add(listener);
     return () => {
       this.listeners.delete(listener);
@@ -4144,6 +4413,7 @@ var VectorEditorController = (_class3 = class {
       interaction: this.interaction,
       pen: this.pen,
       pointer: this.pointer,
+      builder: this.builderPreview,
       canUndo: h.canUndo,
       canRedo: h.canRedo,
       undoLabel: h.undoName,
@@ -4202,6 +4472,11 @@ var VectorEditorController = (_class3 = class {
         if (_optionalChain([this, 'access', _103 => _103.drag, 'optionalAccess', _104 => _104.kind]) === "width") return this.drag.mode === "move" ? "grabbing" : "ew-resize";
         if (_optionalChain([h, 'optionalAccess', _105 => _105.widthPoint])) return h.widthPoint.part === "center" ? "grab" : "ew-resize";
         return _optionalChain([h, 'optionalAccess', _106 => _106.strokeSpot]) ? "copy" : "default";
+      case "shapeBuilder":
+        if (!_optionalChain([this, 'access', _107 => _107.builderPreview, 'optionalAccess', _108 => _108.faces, 'access', _109 => _109.length]) && !_optionalChain([this, 'access', _110 => _110.builderPreview, 'optionalAccess', _111 => _111.lines, 'access', _112 => _112.length])) return "crosshair";
+        return this.builderPreview.mode === "erase" ? "not-allowed" : "cell";
+      case "paintBucket":
+        return this.builderPreview ? "cell" : "crosshair";
       default:
         return "crosshair";
     }
@@ -4221,7 +4496,7 @@ var VectorEditorController = (_class3 = class {
       this.selection = s.selection.filter((id) => this.getNode(id));
       this.anchors = s.anchors.filter((r) => getAnchor(this.doc, r));
       this.editingId = s.editingId && this.getNode(s.editingId) ? s.editingId : null;
-      this.pen = s.pen && _optionalChain([this, 'access', _107 => _107.getNode, 'call', _108 => _108(s.pen.nodeId), 'optionalAccess', _109 => _109.subpaths, 'optionalAccess', _110 => _110[s.pen.subpath]]) ? s.pen : null;
+      this.pen = s.pen && _optionalChain([this, 'access', _113 => _113.getNode, 'call', _114 => _114(s.pen.nodeId), 'optionalAccess', _115 => _115.subpaths, 'optionalAccess', _116 => _116[s.pen.subpath]]) ? s.pen : null;
     } finally {
       this.applying = false;
     }
@@ -4328,6 +4603,8 @@ var VectorEditorController = (_class3 = class {
     this.hover = null;
     this.guides = null;
     this.widthPoint = null;
+    this.builderPreview = null;
+    this.builderHoverKey = null;
     if (tool !== "direct") {
       this.anchors = [];
       this.editingId = null;
@@ -4386,7 +4663,7 @@ var VectorEditorController = (_class3 = class {
       if (res.kind) {
         this.snappedToObject = true;
         this.setGuides(res);
-        return _optionalChain([leave, 'optionalAccess', _111 => _111.constrain]) ? res.point : { x: res.x ? res.point.x : this.gridValue(res.point.x), y: res.y ? res.point.y : this.gridValue(res.point.y) };
+        return _optionalChain([leave, 'optionalAccess', _117 => _117.constrain]) ? res.point : { x: res.x ? res.point.x : this.gridValue(res.point.x), y: res.y ? res.point.y : this.gridValue(res.point.y) };
       }
     }
     this.setGuides(null);
@@ -4404,14 +4681,14 @@ var VectorEditorController = (_class3 = class {
   /** Where the pointer at `p` would place a point with the pen or a shape tool (and the guides showing why). */
   hoverSnap(p, input) {
     if (this.tool === "pen") {
-      const sp = this.pen ? _optionalChain([this, 'access', _112 => _112.getNode, 'call', _113 => _113(this.pen.nodeId), 'optionalAccess', _114 => _114.subpaths, 'access', _115 => _115[this.pen.subpath]]) : void 0;
-      if (this.pen && sp && _optionalChain([this, 'access', _116 => _116.hover, 'optionalAccess', _117 => _117.anchor])) {
+      const sp = this.pen ? _optionalChain([this, 'access', _118 => _118.getNode, 'call', _119 => _119(this.pen.nodeId), 'optionalAccess', _120 => _120.subpaths, 'access', _121 => _121[this.pen.subpath]]) : void 0;
+      if (this.pen && sp && _optionalChain([this, 'access', _122 => _122.hover, 'optionalAccess', _123 => _123.anchor])) {
         this.setGuides(null);
         return p;
       }
       const last = this.pen && sp ? getAnchorWorld(this.doc, { nodeId: this.pen.nodeId, subpath: this.pen.subpath, index: sp.anchors.length - 1 }) : void 0;
       const leave = last ? { at: { x: last.x, y: last.y }, constrain: input.shift ? "angle" : null } : null;
-      return this.snapDrawn(p, leave, input, () => this.drawingTargets(_nullishCoalesce(_optionalChain([this, 'access', _118 => _118.pen, 'optionalAccess', _119 => _119.nodeId]), () => ( null))));
+      return this.snapDrawn(p, leave, input, () => this.drawingTargets(_nullishCoalesce(_optionalChain([this, 'access', _124 => _124.pen, 'optionalAccess', _125 => _125.nodeId]), () => ( null))));
     }
     if (SHAPE_TOOLS.has(this.tool)) return this.snapDrawn(p, null, input, () => this.drawingTargets(null));
     this.setGuides(null);
@@ -4559,7 +4836,7 @@ var VectorEditorController = (_class3 = class {
     if (d.fillRule) out.fillRule = d.fillRule;
     if (d.strokeAlign && d.strokeAlign !== "center") out.strokeAlign = d.strokeAlign;
     for (const key of ["startArrow", "endArrow", "arrowAlign", "startArrowScale", "endArrowScale"]) if (d[key]) out[key] = d[key];
-    if (_optionalChain([d, 'access', _120 => _120.strokeWidthProfile, 'optionalAccess', _121 => _121.length])) out.strokeWidthProfile = d.strokeWidthProfile.map((p) => ({ ...p }));
+    if (_optionalChain([d, 'access', _126 => _126.strokeWidthProfile, 'optionalAccess', _127 => _127.length])) out.strokeWidthProfile = d.strokeWidthProfile.map((p) => ({ ...p }));
     return out;
   }
   /** Merges `patch` into a node (paths take style and geometry; groups name / visibility / opacity). */
@@ -4607,7 +4884,7 @@ var VectorEditorController = (_class3 = class {
   /** Removes one width point of a path's profile (the width tool's Delete). */
   removeWidthPoint(ref) {
     const node = this.getNode(ref.nodeId);
-    if (_optionalChain([node, 'optionalAccess', _122 => _122.type]) !== "path" || !_optionalChain([node, 'access', _123 => _123.strokeWidthProfile, 'optionalAccess', _124 => _124[ref.index]])) return { ok: false, message: "There is no such width point." };
+    if (_optionalChain([node, 'optionalAccess', _128 => _128.type]) !== "path" || !_optionalChain([node, 'access', _129 => _129.strokeWidthProfile, 'optionalAccess', _130 => _130[ref.index]])) return { ok: false, message: "There is no such width point." };
     const rest = removeWidthPoints(sanitizeWidthProfile(node.strokeWidthProfile), [ref.index]);
     this.widthPoint = null;
     this.change("Delete Width Point", () => this.replaceNode(node.id, withStyle(node, { strokeWidthProfile: rest.length ? rest : null })));
@@ -4632,7 +4909,7 @@ var VectorEditorController = (_class3 = class {
     const refs = this.cornerTargets(options);
     if (!refs.length) return { ok: false, message: "Nothing is selected." };
     this.change("Corner Kind", () => {
-      this.doc = this.updateAnchors(this.doc, refs, (a) => setAnchorCorner(a, _nullishCoalesce(_optionalChain([a, 'access', _125 => _125.corner, 'optionalAccess', _126 => _126.radius]), () => ( 0)), kind));
+      this.doc = this.updateAnchors(this.doc, refs, (a) => setAnchorCorner(a, _nullishCoalesce(_optionalChain([a, 'access', _131 => _131.corner, 'optionalAccess', _132 => _132.radius]), () => ( 0)), kind));
     });
     return { ok: true };
   }
@@ -4771,10 +5048,10 @@ var VectorEditorController = (_class3 = class {
     return this.selection.filter((id) => {
       let covered = false;
       const loc = locateVectorNode(this.doc.nodes, id);
-      let parent = _nullishCoalesce(_optionalChain([loc, 'optionalAccess', _127 => _127.parent]), () => ( null));
+      let parent = _nullishCoalesce(_optionalChain([loc, 'optionalAccess', _133 => _133.parent]), () => ( null));
       while (parent) {
         if (this.selection.includes(parent.id)) covered = true;
-        parent = _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _128 => _128(this.doc.nodes, parent.id), 'optionalAccess', _129 => _129.parent]), () => ( null));
+        parent = _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _134 => _134(this.doc.nodes, parent.id), 'optionalAccess', _135 => _135.parent]), () => ( null));
       }
       return !covered;
     });
@@ -4957,8 +5234,8 @@ var VectorEditorController = (_class3 = class {
     if (!ids.length) return null;
     const locs = ids.map((id2) => locateVectorNode(this.doc.nodes, id2));
     if (locs.some((l) => !l)) return null;
-    const parent = _nullishCoalesce(_optionalChain([locs, 'access', _130 => _130[0], 'access', _131 => _131.parent, 'optionalAccess', _132 => _132.id]), () => ( null));
-    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _133 => _133.parent, 'optionalAccess', _134 => _134.id]), () => ( null))) !== parent)) return null;
+    const parent = _nullishCoalesce(_optionalChain([locs, 'access', _136 => _136[0], 'access', _137 => _137.parent, 'optionalAccess', _138 => _138.id]), () => ( null));
+    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _139 => _139.parent, 'optionalAccess', _140 => _140.id]), () => ( null))) !== parent)) return null;
     const id = this.newId();
     this.change("Group", () => {
       const set = new Set(ids);
@@ -4981,7 +5258,7 @@ var VectorEditorController = (_class3 = class {
   }
   /** Replaces selected groups with their children. */
   ungroup(options = {}) {
-    const groups = (_nullishCoalesce(options.ids, () => ( this.selection))).map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _135 => _135.type]) === "group");
+    const groups = (_nullishCoalesce(options.ids, () => ( this.selection))).map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _141 => _141.type]) === "group");
     if (!groups.length) return { ok: false, message: "Select a group to ungroup." };
     const set = new Set(groups.map((g) => g.id));
     this.change("Ungroup", () => {
@@ -5041,7 +5318,7 @@ var VectorEditorController = (_class3 = class {
     });
     const paths = [...new Set(order)].map((id2) => this.getNode(id2));
     if (paths.length < 2) return null;
-    const result = _chunkGVB7ZPLZcjs.pathBoolean.call(void 0, 
+    const result = _chunkVNYRI265cjs.pathBoolean.call(void 0, 
       BOOLEAN_OPS[op],
       paths.map((p) => ({
         path: vectorPathWorldBezier(
@@ -5091,11 +5368,11 @@ var VectorEditorController = (_class3 = class {
   /** A document-space path mapped into the parent space of node `id`. */
   intoParentSpace(id, path) {
     const parent = _nullishCoalesce(vectorParentMatrix(this.doc.nodes, id), () => ( IDENTITY_MATRIX));
-    return isRoot(parent) ? path : _chunkGVB7ZPLZcjs.transformBezierPath.call(void 0, path, invertMatrix(parent));
+    return isRoot(parent) ? path : _chunkVNYRI265cjs.transformBezierPath.call(void 0, path, invertMatrix(parent));
   }
   /** Splits selected compound paths into one path per subpath. */
   breakApart(options = {}) {
-    const paths = (_nullishCoalesce(options.ids, () => ( this.selection))).map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _136 => _136.type]) === "path" && n.subpaths.length > 1);
+    const paths = (_nullishCoalesce(options.ids, () => ( this.selection))).map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _142 => _142.type]) === "path" && n.subpaths.length > 1);
     if (!paths.length) return { ok: false, message: "Select a compound path to break apart." };
     const created = [];
     const set = new Set(paths.map((p) => p.id));
@@ -5115,6 +5392,255 @@ var VectorEditorController = (_class3 = class {
     return { ok: true };
   }
   // -------------------------------------------------------------------------
+  // Pathfinder, Shape Builder and paint bucket
+  // -------------------------------------------------------------------------
+  /**
+   * Pathfinder: Divide, Trim, Merge, Crop, Outline or Minus Back over the selected (or given)
+   * paths, in document space (rotated nodes and groups included, live corners cut). Unfilled
+   * stroked paths take part as the area their stroke paints (Divide: open ones cut instead).
+   * The results replace the operands at the place of the top-most one, grouped when there are
+   * several; each keeps the style of the operand whose area it is. Returns the new path ids,
+   * or an empty list when nothing came out.
+   */
+  pathfinder(op, options = {}) {
+    const roots = _nullishCoalesce(options.ids, () => ( this.selectedRoots()));
+    const entries = vectorPathEntries(this.doc, roots);
+    if (entries.length < (op === "divide" || op === "outline" ? 1 : 2)) return [];
+    const shapes = entries.map((e) => vectorPathfinderShape(e, op));
+    const result = _chunkVNYRI265cjs.pathfinder.call(void 0, op, shapes);
+    if (result.error || !result.pieces.length) return [];
+    const last = entries[entries.length - 1].node.id;
+    const topRoot = _nullishCoalesce([...roots].reverse().find((r) => {
+      const n = this.getNode(r);
+      return !!n && !!findVectorNode([n], last);
+    }), () => ( last));
+    const nodes = [];
+    for (const piece of result.pieces) {
+      const subpaths = bezierToSubpaths(this.intoParentSpace(topRoot, piece.path)).map((sp) => piece.open ? { ...sp, closed: false } : sp);
+      if (!subpaths.length) continue;
+      const source = entries[piece.source].node;
+      const style = vectorResultStyle(source, shapes[piece.source].paint, op === "outline");
+      nodes.push({ ...style, type: "path", id: this.newId(), name: _nullishCoalesce(source.name, () => ( "Path")), subpaths });
+    }
+    if (!nodes.length) return [];
+    const label = VECTOR_PATHFINDER_LABELS[op];
+    const container = nodes.length > 1 ? { id: this.newId(), type: "group", name: label, children: nodes } : nodes[0];
+    const drop = /* @__PURE__ */ new Set([...entries.map((e) => e.node.id), ...roots]);
+    this.change(label, () => {
+      this.setDoc(mapTree(this.doc.nodes, (n) => n.id === topRoot ? container : drop.has(n.id) ? null : n));
+      this.selection = [container.id];
+      this.anchors = [];
+      this.editingId = null;
+    });
+    return nodes.map((n) => n.id);
+  }
+  /** The Shape Builder map of the selected (or given) paths, cached per document and selection. */
+  shapeBuilderMap(ids) {
+    const roots = _nullishCoalesce(ids, () => ( this.selectedRoots()));
+    const key = roots.join("\0");
+    if (_optionalChain([this, 'access', _143 => _143.builderCache, 'optionalAccess', _144 => _144.doc]) === this.doc && this.builderCache.key === key) return this.builderCache.map;
+    const entries = roots.length ? vectorPathEntries(this.doc, roots) : [];
+    const map = entries.length ? vectorShapeBuilderMap(entries) : null;
+    this.builderCache = { doc: this.doc, key, map };
+    return map;
+  }
+  /** The faces the Shape Builder offers for the selected (or given) paths (document units). */
+  getShapeBuilderFaces(options = {}) {
+    const m = this.shapeBuilderMap(options.ids);
+    if (!m) return [];
+    return m.map.faces.map((f, index) => {
+      const p = m.map.faceInterior(index);
+      return {
+        index,
+        d: _chunkVNYRI265cjs.bezierPathToSvg.call(void 0, f.path, { precision: 3 }),
+        area: f.area,
+        sources: m.map.faceSources(index).map((i) => m.entries[i].node.id),
+        point: p ? { x: p[0], y: p[1] } : null
+      };
+    });
+  }
+  /** Pick distance of the Shape Builder's erase for line pieces (document units). */
+  builderLineTolerance() {
+    return Math.max(this.hitRadius, 4) / this.viewport.zoom;
+  }
+  /**
+   * Shape Builder gesture along `points` (document units; one point is a click) over the faces
+   * the selected (or given) paths make. Merges the faces touched into one shape styled like the
+   * top-most shape over the first face (the current fill for a face only outlines enclose);
+   * with `erase` deletes them, the pieces of unfilled open paths and the edges of other outlines
+   * (cut where paths meet) within `tolerance`: a deleted edge opens a closed subpath there,
+   * splits an open one or takes a subpath it runs all the way round, and edges bounding a face
+   * deleted in the same gesture go with the face. Every shape covering a touched face loses
+   * that area; paths keep their own transforms. One undo step.
+   */
+  shapeBuilder(points, options = {}) {
+    const none = (message) => ({ ok: false, message, merged: null, faces: 0, lines: 0, edges: 0 });
+    if (!points.length || !points.every((p) => Number.isFinite(p.x) && Number.isFinite(p.y))) return none("Give the points of the gesture.");
+    const m = this.shapeBuilderMap(options.ids);
+    if (!m) return none("Select paths that make faces.");
+    const erase = !!options.erase;
+    const tol = erase ? _nullishCoalesce(options.tolerance, () => ( this.builderLineTolerance())) : null;
+    const touched = { faces: [], lines: [], edges: [] };
+    const size = m.map.faces.reduce((s, f) => Math.max(s, f.bounds.maxX - f.bounds.minX, f.bounds.maxY - f.bounds.minY), 1);
+    for (const p of samplePolyline(points, Math.max(size / 2e3, 0.25 / this.viewport.zoom))) addBuilderHit(touched, vectorShapeBuilderHit(m, p, tol));
+    if (!touched.faces.length && !touched.lines.length && !touched.edges.length) return none("There is no face under the pointer.");
+    return this.applyShapeBuilder(m, touched, erase);
+  }
+  applyShapeBuilder(m, touched, erase) {
+    const plan = planShapeBuilder(m, touched, erase);
+    let mergedId = null;
+    const created = /* @__PURE__ */ new Map();
+    this.change(erase ? "Shape Builder Delete" : "Shape Builder", () => {
+      let nodes = this.doc.nodes;
+      m.entries.forEach((entry, i) => {
+        const node = entry.node;
+        const toLocal = (path) => _chunkVNYRI265cjs.transformBezierPath.call(void 0, path, invertMatrix(multiplyMatrices(nodeMatrix(node), entry.parent)));
+        const list = [];
+        const r = plan.replace.get(i);
+        if (r === void 0) list.push(node);
+        else if (_optionalChain([r, 'optionalAccess', _145 => _145.kind]) === "fill") list.push({ ...node, fillRule: "nonzero", subpaths: bezierToSubpaths(toLocal(r.path)) });
+        else if (_optionalChain([r, 'optionalAccess', _146 => _146.kind]) === "outline") list.push({ ...node, subpaths: bezierToSubpaths(toLocal(r.path)) });
+        else if (_optionalChain([r, 'optionalAccess', _147 => _147.kind]) === "pieces") {
+          r.paths.forEach(
+            (path, k) => list.push({ ...node, id: k === 0 ? node.id : this.newId(), subpaths: bezierToSubpaths(toLocal(path)).map((sp) => ({ ...sp, closed: false })) })
+          );
+        }
+        if (plan.merged && plan.merged.style === i) {
+          mergedId = this.newId();
+          const merged = {
+            ...vectorResultStyle(node, "fill"),
+            type: "path",
+            id: mergedId,
+            name: "Shape",
+            ...node.transform ? { transform: node.transform } : {},
+            subpaths: bezierToSubpaths(toLocal(plan.merged.path))
+          };
+          if (plan.merged.currentFill || !hasPaint(merged.fill)) merged.fill = hasPaint(this.defaults.fill) ? this.defaults.fill : "#808080";
+          list.push(merged);
+        }
+        if (r === void 0 && list.length === 1) return;
+        created.set(node.id, list.map((n) => n.id));
+        nodes = spliceTree(nodes, node.id, list);
+      });
+      this.setDoc(nodes);
+      const selection = this.selection.flatMap((id) => _nullishCoalesce(created.get(id), () => ( [id])));
+      if (mergedId && !selection.includes(mergedId)) selection.push(mergedId);
+      this.selection = selection.filter((id, k) => !!this.getNode(id) && selection.indexOf(id) === k);
+      this.anchors = [];
+      this.editingId = null;
+    });
+    this.builderCache = null;
+    return { ok: true, merged: mergedId, faces: touched.faces.length, lines: touched.lines.length, edges: erase ? vectorBuilderErasedEdges(m, touched).length : 0 };
+  }
+  /** The paint bucket's map of the visible outlines, cached per document and gap. */
+  fillMap(gap) {
+    if (_optionalChain([this, 'access', _148 => _148.fillCache, 'optionalAccess', _149 => _149.doc]) === this.doc && this.fillCache.gap === gap) return this.fillCache.map;
+    const map = vectorFillMap(this.doc, gap);
+    this.fillCache = { doc: this.doc, gap, map };
+    return map;
+  }
+  /**
+   * Paint bucket: the region the visible outlines enclose around `point` (document units),
+   * crossings split and islands left as holes, becomes a new path filled with the current fill
+   * default, placed just below the selection (or on top when nothing is selected). `gap`
+   * (default `editing.fillGap`) closes gaps up to that size between loose ends. Returns the new
+   * path's id, or null when nothing encloses the point.
+   */
+  fillRegion(point, options = {}) {
+    if (!Number.isFinite(point.x) || !Number.isFinite(point.y)) return null;
+    const region = _optionalChain([this, 'access', _150 => _150.fillMap, 'call', _151 => _151(_nullishCoalesce(options.gap, () => ( this.editing.fillGap))), 'optionalAccess', _152 => _152.regionAt, 'call', _153 => _153([point.x, point.y])]);
+    if (!_optionalChain([region, 'optionalAccess', _154 => _154.length])) return null;
+    let below = null;
+    const roots = new Set(this.selectedRoots());
+    walkVectorNodes(this.doc.nodes, (n) => {
+      if (!below && roots.has(n.id)) below = n.id;
+    });
+    const subpaths = bezierToSubpaths(below ? this.intoParentSpace(below, region) : region);
+    if (!subpaths.length) return null;
+    const id = this.newId();
+    const node = { id, type: "path", name: "Fill", ...this.styleFor(false), stroke: null, fillRule: "nonzero", subpaths };
+    if (!hasPaint(node.fill)) node.fill = "#808080";
+    const target = below;
+    this.change("Fill Region", () => {
+      if (target) {
+        const current = this.getNode(target);
+        this.setDoc(spliceTree(this.doc.nodes, target, [node, current]));
+      } else this.setDoc([...this.doc.nodes, node]);
+      if (!target) this.selection = [id];
+      this.anchors = [];
+      this.editingId = null;
+    });
+    return id;
+  }
+  /** Updates the Shape Builder / paint bucket highlight for the pointer at `p`; true when it changed. */
+  hoverBuilder(p, alt) {
+    if (this.tool === "paintBucket") {
+      const region = _nullishCoalesce(_optionalChain([this, 'access', _155 => _155.fillMap, 'call', _156 => _156(this.editing.fillGap), 'optionalAccess', _157 => _157.regionAt, 'call', _158 => _158([p.x, p.y])]), () => ( null));
+      const key2 = region ? _chunkVNYRI265cjs.bezierPathToSvg.call(void 0, region, { precision: 2 }) : null;
+      if (key2 === this.builderHoverKey) return false;
+      this.builderHoverKey = key2;
+      this.builderPreview = region ? { mode: "fill", faces: [region], lines: [], trail: null } : null;
+      return true;
+    }
+    const m = this.selectedRoots().length ? this.shapeBuilderMap() : null;
+    const hit = m ? vectorShapeBuilderHit(m, p, alt ? this.builderLineTolerance() : null) : null;
+    const key = hit ? `${alt ? "erase" : "merge"}:${JSON.stringify(hit)}` : null;
+    if (key === this.builderHoverKey) return false;
+    this.builderHoverKey = key;
+    const touched = { faces: [], lines: [], edges: [] };
+    addBuilderHit(touched, hit);
+    this.builderPreview = hit && m ? this.builderPreviewOf(m, touched, alt, null) : null;
+    return true;
+  }
+  builderPreviewOf(m, touched, erase, trail) {
+    const faces = m.map.faces;
+    return {
+      mode: erase ? "erase" : "merge",
+      faces: touched.faces.map((f) => faces[f].path),
+      // Edges bounding a face touched too go with the face, so they are not shown apart.
+      lines: [...touched.lines.map((k) => m.pieces[k].path), ...erase ? vectorBuilderErasedEdges(m, touched).map((k) => m.edges[k].path) : []],
+      trail
+    };
+  }
+  downBuilder(p, input) {
+    this.builderHoverKey = null;
+    if (this.tool === "paintBucket") {
+      this.fillRegion(p);
+      this.builderPreview = null;
+      this.hoverBuilder(p, false);
+      this.notify();
+      return;
+    }
+    const m = this.selectedRoots().length ? this.shapeBuilderMap() : null;
+    if (!m) return;
+    const erase = !!input.alt;
+    const touched = { faces: [], lines: [], edges: [] };
+    addBuilderHit(touched, vectorShapeBuilderHit(m, p, erase ? this.builderLineTolerance() : null));
+    this.drag = { kind: "builder", erase, points: [p], touched, map: m };
+    this.interaction = { type: "builder", mode: erase ? "erase" : "merge", points: [p] };
+    this.builderPreview = this.builderPreviewOf(m, touched, erase, [p]);
+    this.notify();
+  }
+  moveBuilder(drag, p) {
+    const last = drag.points[drag.points.length - 1];
+    if (Math.hypot(p.x - last.x, p.y - last.y) * this.viewport.zoom < 1) return;
+    const tol = drag.erase ? this.builderLineTolerance() : null;
+    for (const q of samplePolyline([last, p], 2 / this.viewport.zoom)) addBuilderHit(drag.touched, vectorShapeBuilderHit(drag.map, q, tol));
+    drag.points.push(p);
+    this.interaction = { type: "builder", mode: drag.erase ? "erase" : "merge", points: drag.points.slice() };
+    this.builderPreview = this.builderPreviewOf(drag.map, drag.touched, drag.erase, drag.points.slice());
+    this.notify();
+  }
+  upBuilder(drag) {
+    this.builderPreview = null;
+    this.builderHoverKey = null;
+    if (!drag.touched.faces.length && !drag.touched.lines.length && !drag.touched.edges.length) {
+      this.notify();
+      return;
+    }
+    this.applyShapeBuilder(drag.map, drag.touched, drag.erase);
+  }
+  // -------------------------------------------------------------------------
   // Anchor editing
   // -------------------------------------------------------------------------
   updateAnchors(doc, refs, fn) {
@@ -5157,7 +5683,7 @@ var VectorEditorController = (_class3 = class {
   /** `doc` with anchor `ref` moved to document point `to` by a Curvature-tool move. */
   curvatureMoved(doc, ref, to) {
     const node = findVectorNode(doc.nodes, ref.nodeId);
-    if (_optionalChain([node, 'optionalAccess', _137 => _137.type]) !== "path" || node.locked || !node.subpaths[ref.subpath]) return doc;
+    if (_optionalChain([node, 'optionalAccess', _159 => _159.type]) !== "path" || node.locked || !node.subpaths[ref.subpath]) return doc;
     const q = this.toLocal(ref.nodeId, to, doc);
     const subpaths = node.subpaths.map((sp, i) => i === ref.subpath ? curvatureMoveAnchor(sp, ref.index, q) : sp);
     const nodes = mapTree(doc.nodes, (n) => n.id === ref.nodeId ? { ...node, subpaths } : n);
@@ -5166,7 +5692,7 @@ var VectorEditorController = (_class3 = class {
   /** `doc` with segment `ref` bent through document point `p` at parameter `t`. */
   bent(doc, ref, t, p) {
     const node = findVectorNode(doc.nodes, ref.nodeId);
-    if (_optionalChain([node, 'optionalAccess', _138 => _138.type]) !== "path" || node.locked || !node.subpaths[ref.subpath]) return doc;
+    if (_optionalChain([node, 'optionalAccess', _160 => _160.type]) !== "path" || node.locked || !node.subpaths[ref.subpath]) return doc;
     const q = this.toLocal(ref.nodeId, p, doc);
     const subpaths = node.subpaths.map((sp, i) => i === ref.subpath ? bendSegment(sp, ref.segment, t, q) : sp);
     return { ...doc, nodes: mapTree(doc.nodes, (n) => n.id === ref.nodeId ? { ...node, subpaths } : n) };
@@ -5177,7 +5703,7 @@ var VectorEditorController = (_class3 = class {
    */
   bendSegment(ref, to, t = 0.5) {
     const node = this.getNode(ref.nodeId);
-    const sp = _optionalChain([node, 'optionalAccess', _139 => _139.type]) === "path" ? node.subpaths[ref.subpath] : void 0;
+    const sp = _optionalChain([node, 'optionalAccess', _161 => _161.type]) === "path" ? node.subpaths[ref.subpath] : void 0;
     if (!sp || ref.segment < 0 || ref.segment >= (sp.closed ? sp.anchors.length : sp.anchors.length - 1) || sp.anchors.length < 2) return { ok: false, message: "There is no such segment." };
     if (node.locked) return { ok: false, message: "The path is locked." };
     this.change("Bend Segment", () => {
@@ -5212,7 +5738,7 @@ var VectorEditorController = (_class3 = class {
   /** Adds an anchor on the nearest segment of `nodeId` to document point `point` (shape unchanged). */
   insertAnchorAt(nodeId, point) {
     const node = this.getNode(nodeId);
-    if (_optionalChain([node, 'optionalAccess', _140 => _140.type]) !== "path") return null;
+    if (_optionalChain([node, 'optionalAccess', _162 => _162.type]) !== "path") return null;
     const hit = nearestSegment(node, this.toLocal(nodeId, point));
     if (!hit) return null;
     const { subpath, index } = insertAnchor(node.subpaths[hit.subpath], hit.segment, hit.t);
@@ -5256,7 +5782,7 @@ var VectorEditorController = (_class3 = class {
   setClosed(closed, nodeId) {
     const targets = nodeId ? (() => {
       const n = this.getNode(nodeId);
-      return _optionalChain([n, 'optionalAccess', _141 => _141.type]) === "path" ? n.subpaths.map((_, s) => ({ nodeId, subpath: s })) : [];
+      return _optionalChain([n, 'optionalAccess', _163 => _163.type]) === "path" ? n.subpaths.map((_, s) => ({ nodeId, subpath: s })) : [];
     })() : this.anchors.map((r) => ({ nodeId: r.nodeId, subpath: r.subpath }));
     if (!targets.length) return { ok: false, message: "Select a path or points." };
     this.change(closed ? "Close Path" : "Open Path", () => {
@@ -5277,7 +5803,7 @@ var VectorEditorController = (_class3 = class {
       this.setDoc(
         mapTree(
           this.doc.nodes,
-          (n) => n.type === "path" && set.has(n.id) ? { ...n, subpaths: n.subpaths.map(reverseSubpath), ..._optionalChain([n, 'access', _142 => _142.strokeWidthProfile, 'optionalAccess', _143 => _143.length]) ? { strokeWidthProfile: reverseWidthProfile(n.strokeWidthProfile) } : {} } : n
+          (n) => n.type === "path" && set.has(n.id) ? { ...n, subpaths: n.subpaths.map(reverseSubpath), ..._optionalChain([n, 'access', _164 => _164.strokeWidthProfile, 'optionalAccess', _165 => _165.length]) ? { strokeWidthProfile: reverseWidthProfile(n.strokeWidthProfile) } : {} } : n
         )
       );
       this.anchors = [];
@@ -5415,7 +5941,7 @@ var VectorEditorController = (_class3 = class {
    */
   cutPathAt(nodeId, point) {
     const node = this.getNode(nodeId);
-    if (_optionalChain([node, 'optionalAccess', _144 => _144.type]) !== "path" || node.locked) return null;
+    if (_optionalChain([node, 'optionalAccess', _166 => _166.type]) !== "path" || node.locked) return null;
     const local = this.toLocal(nodeId, point);
     const hit = nearestSegment(node, local);
     if (!hit) return null;
@@ -5465,7 +5991,7 @@ var VectorEditorController = (_class3 = class {
       if (n.visible === false || n.locked || parent && blocked.has(parent.id)) blocked.add(n.id);
     });
     const visible = (p) => !blocked.has(p.id);
-    if (_optionalChain([ids, 'optionalAccess', _145 => _145.length]) || this.selection.length) return this.pathTargets(_nullishCoalesce(ids, () => ( this.selection))).filter(visible);
+    if (_optionalChain([ids, 'optionalAccess', _167 => _167.length]) || this.selection.length) return this.pathTargets(_nullishCoalesce(ids, () => ( this.selection))).filter(visible);
     const box = polylineBounds(points.map(toPoint2), pad);
     if (!box) return [];
     const out = [];
@@ -5521,10 +6047,10 @@ var VectorEditorController = (_class3 = class {
     const region = eraserRegion(pts, width);
     if (!region.length) return [];
     const plan = [];
-    const rb = _chunkGVB7ZPLZcjs.bezierPathBounds.call(void 0, region);
+    const rb = _chunkVNYRI265cjs.bezierPathBounds.call(void 0, region);
     const reach = rb ? [{ x: rb.minX, y: rb.minY }, { x: rb.maxX, y: rb.maxY }] : points;
     for (const node of this.strokeTargets(reach, options.ids, 0)) {
-      const local = _chunkGVB7ZPLZcjs.transformBezierPath.call(void 0, region, invertMatrix(this.worldOf(node.id)));
+      const local = _chunkVNYRI265cjs.transformBezierPath.call(void 0, region, invertMatrix(this.worldOf(node.id)));
       const live = node.subpaths.filter((sp) => sp.anchors.length > 1);
       if (!live.length) continue;
       if (hasPaint(node.fill) && live.every((sp) => sp.closed)) {
@@ -5551,7 +6077,7 @@ var VectorEditorController = (_class3 = class {
   finishPath() {
     if (!this.pen) return;
     const node = this.getNode(this.pen.nodeId);
-    const sp = _optionalChain([node, 'optionalAccess', _146 => _146.subpaths, 'access', _147 => _147[this.pen.subpath]]);
+    const sp = _optionalChain([node, 'optionalAccess', _168 => _168.subpaths, 'access', _169 => _169[this.pen.subpath]]);
     const pen = this.pen;
     this.pen = null;
     this.pointer = null;
@@ -5595,7 +6121,7 @@ var VectorEditorController = (_class3 = class {
       if (trimmed.startsWith("{")) {
         try {
           const data = JSON.parse(trimmed);
-          if (_optionalChain([data, 'optionalAccess', _148 => _148.type]) === VECTOR_CLIPBOARD_TYPE && Array.isArray(data.nodes)) nodes = data.nodes;
+          if (_optionalChain([data, 'optionalAccess', _170 => _170.type]) === VECTOR_CLIPBOARD_TYPE && Array.isArray(data.nodes)) nodes = data.nodes;
         } catch (e3) {
           nodes = null;
         }
@@ -5607,7 +6133,7 @@ var VectorEditorController = (_class3 = class {
         }
       }
     } else nodes = this.clipboard;
-    if (!_optionalChain([nodes, 'optionalAccess', _149 => _149.length])) return [];
+    if (!_optionalChain([nodes, 'optionalAccess', _171 => _171.length])) return [];
     const offset = _nullishCoalesce(options.offset, () => ( (text && !text.trim().startsWith("{") ? { x: 0, y: 0 } : { x: 10, y: 10 })));
     const copies = nodes.map((n) => transformVectorNode(this.freshIds(n), translateMatrix(offset.x, offset.y)));
     this.change("Paste", () => {
@@ -5651,14 +6177,14 @@ var VectorEditorController = (_class3 = class {
     if (!frame) return null;
     const { box, handles } = getVectorSelectionBoxGeometry(frame, this.viewport);
     const r = this.hitRadius + 2;
-    const usable = box.width < 2 * r || box.height < 2 * r ? handles.filter((h) => h.handle.length === 2 || h.handle === "rotate") : handles;
-    for (const h of usable) if (Math.hypot(h.screen.x - screen.x, h.screen.y - screen.y) <= r * Math.SQRT2) return h.handle;
+    const usable2 = box.width < 2 * r || box.height < 2 * r ? handles.filter((h) => h.handle.length === 2 || h.handle === "rotate") : handles;
+    for (const h of usable2) if (Math.hypot(h.screen.x - screen.x, h.screen.y - screen.y) <= r * Math.SQRT2) return h.handle;
     return null;
   }
   hitHandle(screen) {
     for (const ref of getVisibleHandles(this.view()).reverse()) {
       const a = getAnchorWorld(this.doc, ref);
-      const h = _optionalChain([a, 'optionalAccess', _150 => _150[ref.handle]]);
+      const h = _optionalChain([a, 'optionalAccess', _172 => _172[ref.handle]]);
       if (!h) continue;
       const s = this.documentToScreen(h);
       if (Math.hypot(s.x - screen.x, s.y - screen.y) <= this.hitRadius) return ref;
@@ -5828,9 +6354,9 @@ var VectorEditorController = (_class3 = class {
   downWidth(screen, p, input) {
     const hit = this.hitWidthHandle(screen);
     const spot = hit ? null : this.strokeSpotAt(p);
-    const nodeId = _nullishCoalesce(_optionalChain([hit, 'optionalAccess', _151 => _151.ref, 'access', _152 => _152.nodeId]), () => ( _optionalChain([spot, 'optionalAccess', _153 => _153.nodeId])));
+    const nodeId = _nullishCoalesce(_optionalChain([hit, 'optionalAccess', _173 => _173.ref, 'access', _174 => _174.nodeId]), () => ( _optionalChain([spot, 'optionalAccess', _175 => _175.nodeId])));
     const node = nodeId ? this.getNode(nodeId) : void 0;
-    const g = _optionalChain([node, 'optionalAccess', _154 => _154.type]) === "path" ? vectorStrokeWidthGeometry(node) : null;
+    const g = _optionalChain([node, 'optionalAccess', _176 => _176.type]) === "path" ? vectorStrokeWidthGeometry(node) : null;
     if (!node || node.type !== "path" || !g) {
       if (this.widthPoint) {
         this.widthPoint = null;
@@ -5849,7 +6375,7 @@ var VectorEditorController = (_class3 = class {
     if (hit) {
       profile = sanitizeWidthProfile(node.strokeWidthProfile);
       ref = { nodeId: node.id, index: hit.ref.index, subpath: hit.ref.subpath };
-      t = _nullishCoalesce(_optionalChain([profile, 'access', _155 => _155[ref.index], 'optionalAccess', _156 => _156.t]), () => ( 0));
+      t = _nullishCoalesce(_optionalChain([profile, 'access', _177 => _177[ref.index], 'optionalAccess', _178 => _178.t]), () => ( 0));
       subpath = hit.ref.subpath;
       if (hit.ref.part === "center") mode = "move";
       else if (input.alt) side = hit.ref.part;
@@ -5936,6 +6462,9 @@ var VectorEditorController = (_class3 = class {
         return this.downPencil(p, input);
       case "width":
         return this.downWidth(screen, p, input);
+      case "shapeBuilder":
+      case "paintBucket":
+        return this.downBuilder(p, input);
       case "scissors": {
         const seg = this.nearestOutline(p);
         if (seg) this.cutPathAt(seg.nodeId, seg.point);
@@ -6071,7 +6600,7 @@ var VectorEditorController = (_class3 = class {
   }
   downPen(screen, p, input) {
     const before = this.snapshot();
-    const sp = this.pen ? _optionalChain([this, 'access', _157 => _157.getNode, 'call', _158 => _158(this.pen.nodeId), 'optionalAccess', _159 => _159.subpaths, 'access', _160 => _160[this.pen.subpath]]) : void 0;
+    const sp = this.pen ? _optionalChain([this, 'access', _179 => _179.getNode, 'call', _180 => _180(this.pen.nodeId), 'optionalAccess', _181 => _181.subpaths, 'access', _182 => _182[this.pen.subpath]]) : void 0;
     if (this.pen && sp) {
       const pen = this.pen;
       const first = { nodeId: pen.nodeId, subpath: pen.subpath, index: 0 };
@@ -6165,6 +6694,11 @@ var VectorEditorController = (_class3 = class {
   pointerMove(screen, input = {}) {
     const p = this.screenToDocument(screen);
     const drag = this.drag;
+    if (!drag && (this.tool === "shapeBuilder" || this.tool === "paintBucket")) {
+      this.pointer = p;
+      if (this.hoverBuilder(p, !!input.alt)) this.notify();
+      return;
+    }
     if (!drag) {
       const hover = this.computeHover(screen);
       const pointerMatters = this.tool === "pen" && !!this.pen;
@@ -6296,6 +6830,8 @@ var VectorEditorController = (_class3 = class {
         this.notify(true);
         return;
       }
+      case "builder":
+        return this.moveBuilder(drag, p);
       case "stroke": {
         const last = drag.points[drag.points.length - 1];
         if (Math.hypot(p.x - last.x, p.y - last.y) * this.viewport.zoom < 1.5) return;
@@ -6326,7 +6862,7 @@ var VectorEditorController = (_class3 = class {
       }
       case "shape": {
         const node = this.getNode(drag.nodeId);
-        if (_optionalChain([node, 'optionalAccess', _161 => _161.type]) !== "path") return;
+        if (_optionalChain([node, 'optionalAccess', _183 => _183.type]) !== "path") return;
         const leave = { at: drag.start, constrain: input.shift ? drag.tool === "line" ? "angle" : "square" : null, curves: false };
         let end = this.snapDrawn(p, leave, input, () => drag.targets ??= this.drawingTargets(null));
         if (!this.snappedToObject && drag.tool !== "line" && !input.shift && !input.mod && this.snap.objects && drag.targets) end = this.matchShapeSize(drag.targets, drag.start, end, input.alt);
@@ -6384,14 +6920,14 @@ var VectorEditorController = (_class3 = class {
         for (const q of drag.lazy.push([p.x, p.y])) {
           if (Math.hypot(q[0] - last[0], q[1] - last[1]) * this.viewport.zoom < 1.5) continue;
           drag.points.push(q);
-          _optionalChain([drag, 'access', _162 => _162.pressures, 'optionalAccess', _163 => _163.push, 'call', _164 => _164(drag.pressure)]);
+          _optionalChain([drag, 'access', _184 => _184.pressures, 'optionalAccess', _185 => _185.push, 'call', _186 => _186(drag.pressure)]);
           moved = true;
         }
         const string = drag.lazy.string();
         const node = this.getNode(drag.nodeId);
-        if (_optionalChain([node, 'optionalAccess', _165 => _165.type]) !== "path") return;
+        if (_optionalChain([node, 'optionalAccess', _187 => _187.type]) !== "path") return;
         if (!moved) {
-          if (string && _optionalChain([this, 'access', _166 => _166.interaction, 'optionalAccess', _167 => _167.type]) === "draw") {
+          if (string && _optionalChain([this, 'access', _188 => _188.interaction, 'optionalAccess', _189 => _189.type]) === "draw") {
             this.interaction = { ...this.interaction, string: [{ x: string[0][0], y: string[0][1] }, { x: string[1][0], y: string[1][1] }] };
             this.notify();
           }
@@ -6427,8 +6963,8 @@ var VectorEditorController = (_class3 = class {
     }
     this.setGuides(res);
     return {
-      dx: _optionalChain([res, 'optionalAccess', _168 => _168.x]) ? dx + res.dx : axes.x ? this.gridValue(origin.x + dx) - origin.x : dx,
-      dy: _optionalChain([res, 'optionalAccess', _169 => _169.y]) ? dy + res.dy : axes.y ? this.gridValue(origin.y + dy) - origin.y : dy
+      dx: _optionalChain([res, 'optionalAccess', _190 => _190.x]) ? dx + res.dx : axes.x ? this.gridValue(origin.x + dx) - origin.x : dx,
+      dy: _optionalChain([res, 'optionalAccess', _191 => _191.y]) ? dy + res.dy : axes.y ? this.gridValue(origin.y + dy) - origin.y : dy
     };
   }
   /** The anchor a point drag snaps by, where it started: the grabbed one, else the moving one nearest the press. */
@@ -6507,7 +7043,7 @@ var VectorEditorController = (_class3 = class {
         if (drag.moved) return this.commit("Corner Radius", drag.before);
         if (drag.alt) {
           const kind = nextVectorCornerKind(drag.widget.kind);
-          this.doc = this.updateAnchors(drag.base, drag.refs, (a) => setAnchorCorner(a, _nullishCoalesce(_optionalChain([a, 'access', _170 => _170.corner, 'optionalAccess', _171 => _171.radius]), () => ( 0)), kind));
+          this.doc = this.updateAnchors(drag.base, drag.refs, (a) => setAnchorCorner(a, _nullishCoalesce(_optionalChain([a, 'access', _192 => _192.corner, 'optionalAccess', _193 => _193.radius]), () => ( 0)), kind));
           return this.commit("Corner Kind", drag.before);
         }
         const ref = drag.widget.ref;
@@ -6526,6 +7062,8 @@ var VectorEditorController = (_class3 = class {
         } else this.notify();
         return;
       }
+      case "builder":
+        return this.upBuilder(drag);
       case "stroke": {
         this.notify();
         if (drag.tool === "knife") this.knife(drag.points);
@@ -6551,14 +7089,14 @@ var VectorEditorController = (_class3 = class {
       }
       case "pencil": {
         const node = this.getNode(drag.nodeId);
-        if (_optionalChain([node, 'optionalAccess', _172 => _172.type]) !== "path" || drag.points.length < 2) {
+        if (_optionalChain([node, 'optionalAccess', _194 => _194.type]) !== "path" || drag.points.length < 2) {
           this.doc = drag.before.doc;
           this.notify(true);
           return;
         }
         for (const q of drag.lazy.finish()) {
           drag.points.push(q);
-          _optionalChain([drag, 'access', _173 => _173.pressures, 'optionalAccess', _174 => _174.push, 'call', _175 => _175(drag.pressure)]);
+          _optionalChain([drag, 'access', _195 => _195.pressures, 'optionalAccess', _196 => _196.push, 'call', _197 => _197(drag.pressure)]);
         }
         const shape = this.editing.recognizeShapes ? recognizeInkShape(drag.points, { minSize: 6 / this.viewport.zoom }) : null;
         if (shape) {
@@ -6566,7 +7104,7 @@ var VectorEditorController = (_class3 = class {
           this.selection = [drag.nodeId];
           return this.commit(`Draw ${inkShapeLabel(shape)}`, drag.before);
         }
-        const fitted = _chunkGVB7ZPLZcjs.fitCubics.call(void 0, drag.points, 1.5 / this.viewport.zoom, { cornerAngleDeg: 60 });
+        const fitted = _chunkVNYRI265cjs.fitCubics.call(void 0, drag.points, 1.5 / this.viewport.zoom, { cornerAngleDeg: 60 });
         const anchors = [];
         for (const c of fitted) {
           if (!anchors.length) anchors.push({ x: c.p0[0], y: c.p0[1] });
@@ -6597,7 +7135,8 @@ var VectorEditorController = (_class3 = class {
     this.drag = null;
     this.interaction = null;
     this.guides = null;
-    if (drag.kind === "pan") {
+    if (drag.kind === "pan" || drag.kind === "builder") {
+      if (drag.kind === "builder") this.builderPreview = null;
       this.notify();
       return;
     }
@@ -6629,7 +7168,7 @@ var VectorEditorController = (_class3 = class {
         this.convertAnchors(a.in || a.out ? "corner" : "smooth", [anchor]);
         return;
       }
-      const id = _nullishCoalesce(_optionalChain([this, 'access', _176 => _176.hover, 'optionalAccess', _177 => _177.segment, 'optionalAccess', _178 => _178.nodeId]), () => ( this.editingId));
+      const id = _nullishCoalesce(_optionalChain([this, 'access', _198 => _198.hover, 'optionalAccess', _199 => _199.segment, 'optionalAccess', _200 => _200.nodeId]), () => ( this.editingId));
       if (id) {
         const node = this.getNode(id);
         const seg = node ? nearestSegment(node, this.toLocal(id, p)) : null;
@@ -6712,7 +7251,7 @@ var VectorEditorController = (_class3 = class {
           this.finishPath();
           return true;
         }
-        if (this.tool === "select" && this.selection.length === 1 && _optionalChain([this, 'access', _179 => _179.getNode, 'call', _180 => _180(this.selection[0]), 'optionalAccess', _181 => _181.type]) === "path") {
+        if (this.tool === "select" && this.selection.length === 1 && _optionalChain([this, 'access', _201 => _201.getNode, 'call', _202 => _202(this.selection[0]), 'optionalAccess', _203 => _203.type]) === "path") {
           this.tool = "direct";
           this.editingId = this.selection[0];
           this.notify();
@@ -6832,6 +7371,7 @@ function pencilPressureProfile(points, pressures) {
 // src/vector/render.ts
 var fmt = (n) => Math.round(n * 100) / 100;
 var fmtMatrix = (m) => `matrix(${m.map((n) => Math.round(n * 1e6) / 1e6).join(" ")})`;
+var VECTOR_BUILDER_HATCH_GAP = 6;
 function renderNode(node, defs, idPrefix) {
   if (node.visible === false) return null;
   if (node.type === "group") {
@@ -6854,7 +7394,7 @@ function renderNode(node, defs, idPrefix) {
     strokeWidth: _nullishCoalesce(node.strokeWidth, () => ( 1)),
     ...node.strokeLinecap ? { strokeLinecap: node.strokeLinecap } : {},
     ...node.strokeLinejoin ? { strokeLinejoin: node.strokeLinejoin } : {},
-    ..._optionalChain([node, 'access', _182 => _182.strokeDasharray, 'optionalAccess', _183 => _183.length]) ? { strokeDasharray: node.strokeDasharray.join(" ") } : {},
+    ..._optionalChain([node, 'access', _204 => _204.strokeDasharray, 'optionalAccess', _205 => _205.length]) ? { strokeDasharray: node.strokeDasharray.join(" ") } : {},
     fillRule: _nullishCoalesce(node.fillRule, () => ( "nonzero")),
     opacity: _nullishCoalesce(node.opacity, () => ( 1))
   };
@@ -6878,7 +7418,7 @@ function screenOutline(state, node) {
   const v2 = state.viewport;
   const view = [v2.zoom, 0, 0, v2.zoom, v2.x, v2.y];
   const parent = _nullishCoalesce(vectorParentMatrix(state.document.nodes, node.id), () => ( IDENTITY_MATRIX));
-  return collectWithMatrix(node, parent).map(({ path, parent: m }) => _chunkGVB7ZPLZcjs.bezierPathToSvg.call(void 0, _chunkGVB7ZPLZcjs.transformBezierPath.call(void 0, vectorPathWorldBezier(path, m), view), { precision: 2 })).join(" ");
+  return collectWithMatrix(node, parent).map(({ path, parent: m }) => _chunkVNYRI265cjs.bezierPathToSvg.call(void 0, _chunkVNYRI265cjs.transformBezierPath.call(void 0, vectorPathWorldBezier(path, m), view), { precision: 2 })).join(" ");
 }
 function collectWithMatrix(node, parent) {
   if (node.type === "path") return [{ path: node, parent }];
@@ -6903,9 +7443,9 @@ function getVectorOverlayRenderData(state) {
   };
   for (const id of state.selection) outline(id, true);
   if (state.editingId) outline(state.editingId, true);
-  if (_optionalChain([state, 'access', _184 => _184.hover, 'optionalAccess', _185 => _185.nodeId]) && !state.interaction) outline(state.hover.nodeId, false);
+  if (_optionalChain([state, 'access', _206 => _206.hover, 'optionalAccess', _207 => _207.nodeId]) && !state.interaction) outline(state.hover.nodeId, false);
   let selectionBox = null;
-  if (state.tool === "select" && state.selectionFrame && _optionalChain([state, 'access', _186 => _186.interaction, 'optionalAccess', _187 => _187.type]) !== "marquee") {
+  if (state.tool === "select" && state.selectionFrame && _optionalChain([state, 'access', _208 => _208.interaction, 'optionalAccess', _209 => _209.type]) !== "marquee") {
     const g = getVectorSelectionBoxGeometry(state.selectionFrame, state.viewport);
     selectionBox = { ...g.box, angle: g.angle, transform: g.transform, corners: g.corners, handles: g.handles };
   }
@@ -6915,9 +7455,9 @@ function getVectorOverlayRenderData(state) {
     const a = getAnchorWorld(doc, ref);
     const s = toScreen(state, a);
     const closes = !!state.pen && state.pen.nodeId === ref.nodeId && state.pen.subpath === ref.subpath && ref.index === 0;
-    return { ref, x: s.x, y: s.y, type: _nullishCoalesce(a.type, () => ( inferAnchorType(a))), selected: selected(ref), hovered: sameAnchor(_optionalChain([state, 'access', _188 => _188.hover, 'optionalAccess', _189 => _189.anchor]), ref), closes };
+    return { ref, x: s.x, y: s.y, type: _nullishCoalesce(a.type, () => ( inferAnchorType(a))), selected: selected(ref), hovered: sameAnchor(_optionalChain([state, 'access', _210 => _210.hover, 'optionalAccess', _211 => _211.anchor]), ref), closes };
   });
-  if (state.tool === "pen" && !state.pen && _optionalChain([state, 'access', _190 => _190.hover, 'optionalAccess', _191 => _191.anchor])) {
+  if (state.tool === "pen" && !state.pen && _optionalChain([state, 'access', _212 => _212.hover, 'optionalAccess', _213 => _213.anchor])) {
     const a = getAnchorWorld(doc, state.hover.anchor);
     if (a) {
       const s = toScreen(state, a);
@@ -6926,15 +7466,15 @@ function getVectorOverlayRenderData(state) {
   }
   const handles = getVisibleHandles(state).flatMap((ref) => {
     const a = getAnchorWorld(doc, ref);
-    const h = _optionalChain([a, 'optionalAccess', _192 => _192[ref.handle]]);
+    const h = _optionalChain([a, 'optionalAccess', _214 => _214[ref.handle]]);
     if (!a || !h) return [];
     const s = toScreen(state, h);
     const sa = toScreen(state, a);
-    const hovered = !!_optionalChain([state, 'access', _193 => _193.hover, 'optionalAccess', _194 => _194.handle]) && sameAnchor(state.hover.handle, ref) && state.hover.handle.handle === ref.handle;
+    const hovered = !!_optionalChain([state, 'access', _215 => _215.hover, 'optionalAccess', _216 => _216.handle]) && sameAnchor(state.hover.handle, ref) && state.hover.handle.handle === ref.handle;
     return [{ ref, x: s.x, y: s.y, anchorX: sa.x, anchorY: sa.y, hovered }];
   });
   let marquee = null;
-  if (_optionalChain([state, 'access', _195 => _195.interaction, 'optionalAccess', _196 => _196.type]) === "marquee") {
+  if (_optionalChain([state, 'access', _217 => _217.interaction, 'optionalAccess', _218 => _218.type]) === "marquee") {
     const b = state.interaction.bounds;
     const tl = toScreen(state, b);
     marquee = { x: tl.x, y: tl.y, width: b.width * z, height: b.height * z };
@@ -6942,7 +7482,7 @@ function getVectorOverlayRenderData(state) {
   let penPreview = null;
   if (state.tool === "pen" && state.pen && state.pointer && !state.interaction) {
     const node = findVectorNode(doc.nodes, state.pen.nodeId);
-    const sp = _optionalChain([node, 'optionalAccess', _197 => _197.type]) === "path" ? node.subpaths[state.pen.subpath] : void 0;
+    const sp = _optionalChain([node, 'optionalAccess', _219 => _219.type]) === "path" ? node.subpaths[state.pen.subpath] : void 0;
     const last = sp ? getAnchorWorld(doc, { nodeId: state.pen.nodeId, subpath: state.pen.subpath, index: sp.anchors.length - 1 }) : void 0;
     if (last) {
       const a = toScreen(state, last);
@@ -6955,9 +7495,9 @@ function getVectorOverlayRenderData(state) {
   const artboard = { x: origin.x, y: origin.y, width: doc.width * z, height: doc.height * z };
   let status = null;
   const it = state.interaction;
-  if (_optionalChain([it, 'optionalAccess', _198 => _198.type]) === "rotate") status = `${Math.round(it.angle)}\xB0`;
-  else if (_optionalChain([it, 'optionalAccess', _199 => _199.type]) === "move" || _optionalChain([it, 'optionalAccess', _200 => _200.type]) === "anchors") status = `\u0394 ${fmt(it.dx)}, ${fmt(it.dy)}`;
-  else if (_optionalChain([it, 'optionalAccess', _201 => _201.type]) === "scale" || _optionalChain([it, 'optionalAccess', _202 => _202.type]) === "draw") {
+  if (_optionalChain([it, 'optionalAccess', _220 => _220.type]) === "rotate") status = `${Math.round(it.angle)}\xB0`;
+  else if (_optionalChain([it, 'optionalAccess', _221 => _221.type]) === "move" || _optionalChain([it, 'optionalAccess', _222 => _222.type]) === "anchors") status = `\u0394 ${fmt(it.dx)}, ${fmt(it.dy)}`;
+  else if (_optionalChain([it, 'optionalAccess', _223 => _223.type]) === "scale" || _optionalChain([it, 'optionalAccess', _224 => _224.type]) === "draw") {
     const b = it.type === "draw" ? findVectorNode(doc.nodes, it.nodeId) ? vectorNodeBounds(findVectorNode(doc.nodes, it.nodeId)) : null : state.selectionFrame;
     if (b) status = `W ${fmt(b.width)} \xD7 H ${fmt(b.height)}`;
   }
@@ -6974,24 +7514,24 @@ function getVectorOverlayRenderData(state) {
     }
   }
   let toolStroke = null;
-  if (_optionalChain([it, 'optionalAccess', _203 => _203.type]) === "stroke") {
+  if (_optionalChain([it, 'optionalAccess', _225 => _225.type]) === "stroke") {
     const pts = it.points.map((q) => toScreen(state, q));
     const d = pts.map((q, i) => `${i ? "L" : "M"}${fmt(q.x)} ${fmt(q.y)}`).join("") + (pts.length === 1 ? `L${fmt(pts[0].x)} ${fmt(pts[0].y)}` : "");
     toolStroke = { tool: it.tool, d, width: fmt(it.width * z) };
   }
   let pencilString = null;
-  if (_optionalChain([it, 'optionalAccess', _204 => _204.type]) === "draw" && it.string) {
+  if (_optionalChain([it, 'optionalAccess', _226 => _226.type]) === "draw" && it.string) {
     const a = toScreen(state, it.string[0]);
     const b = toScreen(state, it.string[1]);
     pencilString = { x1: fmt(a.x), y1: fmt(a.y), x2: fmt(b.x), y2: fmt(b.y) };
   }
-  const dragged = _optionalChain([it, 'optionalAccess', _205 => _205.type]) === "corner" ? it.ref : null;
+  const dragged = _optionalChain([it, 'optionalAccess', _227 => _227.type]) === "corner" ? it.ref : null;
   const cornerWidgets = getVectorCornerWidgets(state).map((w) => {
     const s = toScreen(state, w);
-    return { ref: w.ref, x: fmt(s.x), y: fmt(s.y), radius: w.radius, kind: w.kind, hovered: sameAnchor(_optionalChain([state, 'access', _206 => _206.hover, 'optionalAccess', _207 => _207.corner]), w.ref), active: !!dragged };
+    return { ref: w.ref, x: fmt(s.x), y: fmt(s.y), radius: w.radius, kind: w.kind, hovered: sameAnchor(_optionalChain([state, 'access', _228 => _228.hover, 'optionalAccess', _229 => _229.corner]), w.ref), active: !!dragged };
   });
-  if (_optionalChain([it, 'optionalAccess', _208 => _208.type]) === "corner") status = `R ${fmt(it.radius)}`;
-  const cutPoint = state.tool === "scissors" && _optionalChain([state, 'access', _209 => _209.hover, 'optionalAccess', _210 => _210.segment]) && !it ? (({ x, y }) => ({ x: fmt(x), y: fmt(y) }))(toScreen(state, state.hover.segment.point)) : null;
+  if (_optionalChain([it, 'optionalAccess', _230 => _230.type]) === "corner") status = `R ${fmt(it.radius)}`;
+  const cutPoint = state.tool === "scissors" && _optionalChain([state, 'access', _231 => _231.hover, 'optionalAccess', _232 => _232.segment]) && !it ? (({ x, y }) => ({ x: fmt(x), y: fmt(y) }))(toScreen(state, state.hover.segment.point)) : null;
   const sc = (p) => {
     const q = toScreen(state, p);
     return { x: fmt(q.x), y: fmt(q.y) };
@@ -6999,14 +7539,34 @@ function getVectorOverlayRenderData(state) {
   const sameWidth = (a, b) => !!a && a.nodeId === b.nodeId && a.index === b.index;
   const widthPoints = getVectorWidthHandles(state).map((h) => {
     const c = sc(h);
-    const hw = _optionalChain([state, 'access', _211 => _211.hover, 'optionalAccess', _212 => _212.widthPoint]);
+    const hw = _optionalChain([state, 'access', _233 => _233.hover, 'optionalAccess', _234 => _234.widthPoint]);
     const hovered = hw && sameWidth(hw, h.ref) && hw.subpath === h.ref.subpath ? hw.part : null;
-    return { ref: h.ref, x: c.x, y: c.y, left: sc(h.left), right: sc(h.right), selected: h.selected, hovered, active: _optionalChain([it, 'optionalAccess', _213 => _213.type]) === "width" && sameWidth(it.ref, h.ref) };
+    return { ref: h.ref, x: c.x, y: c.y, left: sc(h.left), right: sc(h.right), selected: h.selected, hovered, active: _optionalChain([it, 'optionalAccess', _235 => _235.type]) === "width" && sameWidth(it.ref, h.ref) };
   });
-  const spot = state.tool === "width" && !it ? _optionalChain([state, 'access', _214 => _214.hover, 'optionalAccess', _215 => _215.strokeSpot]) : null;
+  const spot = state.tool === "width" && !it ? _optionalChain([state, 'access', _236 => _236.hover, 'optionalAccess', _237 => _237.strokeSpot]) : null;
   const widthSpot = spot ? { ...sc(spot.point), left: sc(spot.left), right: sc(spot.right) } : null;
-  if (_optionalChain([it, 'optionalAccess', _216 => _216.type]) === "width") status = it.mode === "move" ? "Move width point" : `W ${fmt(it.width)}`;
-  return { outlines, selectionBox, anchors, handles, marquee, penPreview, artboard, guides, status, toolStroke, pencilString, cutPoint, cornerWidgets, widthPoints, widthSpot };
+  if (_optionalChain([it, 'optionalAccess', _238 => _238.type]) === "width") status = it.mode === "move" ? "Move width point" : `W ${fmt(it.width)}`;
+  let builder = null;
+  if (state.builder) {
+    const v2 = state.viewport;
+    const view = [v2.zoom, 0, 0, v2.zoom, v2.x, v2.y];
+    const svg = (path) => _chunkVNYRI265cjs.bezierPathToSvg.call(void 0, path, { precision: 2 });
+    const screen = state.builder.faces.map((f) => _chunkVNYRI265cjs.transformBezierPath.call(void 0, f, view));
+    const hatch = state.builder.mode !== "fill";
+    const trail = state.builder.trail && state.builder.trail.length > 1 ? state.builder.trail.map((q, i) => `${i ? "L" : "M"}${sc(q).x} ${sc(q).y}`).join("") : null;
+    builder = {
+      mode: state.builder.mode,
+      faces: screen.map(svg),
+      hatches: screen.map((f) => hatch ? svg(_chunkVNYRI265cjs.hatchPath.call(void 0, f, { gap: VECTOR_BUILDER_HATCH_GAP })) : ""),
+      lines: state.builder.lines.map((l) => svg(_chunkVNYRI265cjs.transformBezierPath.call(void 0, l, view))),
+      trail
+    };
+    if (state.builder.mode !== "fill" && _optionalChain([it, 'optionalAccess', _239 => _239.type]) === "builder") {
+      const n = state.builder.faces.length;
+      status = state.builder.mode === "erase" ? `Delete ${n} ${n === 1 ? "face" : "faces"}` : `Merge ${n} ${n === 1 ? "face" : "faces"}`;
+    }
+  }
+  return { outlines, selectionBox, anchors, handles, marquee, penPreview, artboard, guides, status, toolStroke, pencilString, cutPoint, cornerWidgets, widthPoints, widthSpot, builder };
 }
 var VECTOR_OVERLAY_THEME = {
   accent: "#0ea5e9",
@@ -7022,7 +7582,14 @@ var VECTOR_OVERLAY_THEME = {
   /** Radius of a live corner widget (a ring with a dot). */
   cornerWidgetRadius: 4,
   /** Half the diagonal of a width point's diamond. */
-  widthPointSize: 5
+  widthPointSize: 5,
+  /** Shape Builder faces to merge and paint bucket regions. */
+  builderFill: "rgba(14, 165, 233, 0.22)",
+  /** Shape Builder faces and line pieces an Alt gesture deletes. */
+  builderErase: "#ef4444",
+  builderEraseFill: "rgba(239, 68, 68, 0.22)",
+  /** Opacity of the hatch lines over Shape Builder faces (drawn in the face's outline colour). */
+  builderHatchOpacity: 0.6
 };
 function vectorDiamondPath(x, y, r = VECTOR_OVERLAY_THEME.widthPointSize) {
   return `M${fmt(x)} ${fmt(y - r)}L${fmt(x + r)} ${fmt(y)}L${fmt(x)} ${fmt(y + r)}L${fmt(x - r)} ${fmt(y)}Z`;
@@ -7046,7 +7613,7 @@ function isVectorTextTarget(target) {
   if (!el || typeof el !== "object") return false;
   const tag = (_nullishCoalesce(el.tagName, () => ( ""))).toUpperCase();
   if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT") return true;
-  return !!el.isContentEditable || _optionalChain([el, 'access', _217 => _217.getAttribute, 'optionalCall', _218 => _218("contenteditable")]) === "true";
+  return !!el.isContentEditable || _optionalChain([el, 'access', _240 => _240.getAttribute, 'optionalCall', _241 => _241("contenteditable")]) === "true";
 }
 function getVectorSelectionStyle(state) {
   const paths = [];
@@ -7054,12 +7621,12 @@ function getVectorSelectionStyle(state) {
     const node = findVectorNode(state.document.nodes, id);
     if (node) paths.push(...collect(node));
   }
-  const anchorMode = state.tool === "direct" && !!_optionalChain([state, 'access', _219 => _219.selectedAnchors, 'optionalAccess', _220 => _220.length]);
+  const anchorMode = state.tool === "direct" && !!_optionalChain([state, 'access', _242 => _242.selectedAnchors, 'optionalAccess', _243 => _243.length]);
   if (anchorMode) {
     for (const r of state.selectedAnchors) {
       if (paths.some((p) => p.id === r.nodeId)) continue;
       const node = findVectorNode(state.document.nodes, r.nodeId);
-      if (_optionalChain([node, 'optionalAccess', _221 => _221.type]) === "path") paths.push(node);
+      if (_optionalChain([node, 'optionalAccess', _244 => _244.type]) === "path") paths.push(node);
     }
   }
   if (!paths.length) return null;
@@ -7070,7 +7637,7 @@ function getVectorSelectionStyle(state) {
     for (const c of vectorCorners(p.subpaths)) {
       if (anchorMode && !state.selectedAnchors.some((r) => r.nodeId === p.id && r.subpath === c.subpath && r.index === c.index)) continue;
       const corner = p.subpaths[c.subpath].anchors[c.index].corner;
-      corners2.push({ radius: _nullishCoalesce(_optionalChain([corner, 'optionalAccess', _222 => _222.radius]), () => ( 0)), kind: _nullishCoalesce(_optionalChain([corner, 'optionalAccess', _223 => _223.kind]), () => ( "round")) });
+      corners2.push({ radius: _nullishCoalesce(_optionalChain([corner, 'optionalAccess', _245 => _245.radius]), () => ( 0)), kind: _nullishCoalesce(_optionalChain([corner, 'optionalAccess', _246 => _246.kind]), () => ( "round")) });
     }
   }
   const c0 = _nullishCoalesce(corners2[0], () => ( { radius: 0, kind: "round" }));
@@ -7138,6 +7705,14 @@ var VECTOR_PATH_ACTIONS = [
   { id: "smooth", label: "\u223F", title: "Smooth", enabled: (s, p) => s + p > 0, run: (c) => c.smoothPaths() },
   { id: "outline", label: "\u22A1", title: "Outline Stroke", enabled: (s) => s > 0, run: (c) => c.outlineStroke() }
 ];
+var VECTOR_PATHFINDER_ACTIONS = [
+  { id: "divide", label: "\u229E", title: "Divide", min: 1 },
+  { id: "trim", label: "\u29C9", title: "Trim", min: 2 },
+  { id: "merge", label: "\u29C8", title: "Merge", min: 2 },
+  { id: "crop", label: "\u2317", title: "Crop", min: 2 },
+  { id: "outline", label: "\u2B1A", title: "Outline", min: 1 },
+  { id: "minusBack", label: "\u2296", title: "Minus Back", min: 2 }
+];
 var VECTOR_EDIT_TOGGLES = [
   { key: "keepShapeOnDelete", label: "Keep", title: "Keep shape when deleting points" },
   { key: "curvatureMoves", label: "Curv", title: "Curvature point moves (Alt flips while dragging)" },
@@ -7210,17 +7785,17 @@ function createVectorCommands(controller, options = {}) {
   const base = { group, ...options.scope ? { scope: options.scope } : {} };
   const hasSelection = () => controller.getState().selection.length ? true : "Nothing is selected.";
   const ids = (params) => {
-    const list2 = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _224 => _224.ids]), () => ( controller.getState().selection));
+    const list2 = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _247 => _247.ids]), () => ( controller.getState().selection));
     for (const id of list2) if (!controller.getNode(id)) fail(`There is no node "${id}".`);
     if (!list2.length) fail("Nothing is selected; pass ids.");
     return list2;
   };
-  const enabledFor = (_, params) => _optionalChain([params, 'optionalAccess', _225 => _225.ids, 'optionalAccess', _226 => _226.length]) ? true : hasSelection();
+  const enabledFor = (_, params) => _optionalChain([params, 'optionalAccess', _248 => _248.ids, 'optionalAccess', _249 => _249.length]) ? true : hasSelection();
   const anchorsOf = (refs) => {
     if (!refs) return [...controller.getState().selectedAnchors];
     for (const r of refs) {
       const node = controller.getNode(r.nodeId);
-      if (_optionalChain([node, 'optionalAccess', _227 => _227.type]) !== "path" || !_optionalChain([node, 'access', _228 => _228.subpaths, 'access', _229 => _229[r.subpath], 'optionalAccess', _230 => _230.anchors, 'access', _231 => _231[r.index]])) fail(`There is no anchor ${r.index} on subpath ${r.subpath} of "${r.nodeId}".`);
+      if (_optionalChain([node, 'optionalAccess', _250 => _250.type]) !== "path" || !_optionalChain([node, 'access', _251 => _251.subpaths, 'access', _252 => _252[r.subpath], 'optionalAccess', _253 => _253.anchors, 'access', _254 => _254[r.index]])) fail(`There is no anchor ${r.index} on subpath ${r.subpath} of "${r.nodeId}".`);
     }
     return refs;
   };
@@ -7311,7 +7886,7 @@ function createVectorCommands(controller, options = {}) {
       run: (_ctx, params) => {
         const id = controller.addPath(params.d, { ...pickStyle(params), ...params.name ? { name: params.name } : {} });
         const node = controller.getNode(id);
-        if (_optionalChain([node, 'optionalAccess', _232 => _232.type]) === "path" && !node.subpaths.length) {
+        if (_optionalChain([node, 'optionalAccess', _255 => _255.type]) === "path" && !node.subpaths.length) {
           controller.undo();
           fail("The path data has no points.");
         }
@@ -7343,10 +7918,10 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { radius: { type: "number", minimum: 0 }, kind: { type: "string", enum: VECTOR_CORNER_KINDS }, ids: IDS, anchors: ANCHORS } },
       undoable: true,
       run: (_ctx, params) => {
-        const refs = _optionalChain([params, 'optionalAccess', _233 => _233.anchors]) ? anchorsOf(params.anchors) : void 0;
-        const target = { refs, ids: _optionalChain([params, 'optionalAccess', _234 => _234.ids]) ? ids(params) : void 0 };
-        if (_optionalChain([params, 'optionalAccess', _235 => _235.radius]) !== void 0) check(controller.setCornerRadius(params.radius, { ...target, kind: params.kind }));
-        else if (_optionalChain([params, 'optionalAccess', _236 => _236.kind])) check(controller.setCornerKind(params.kind, target));
+        const refs = _optionalChain([params, 'optionalAccess', _256 => _256.anchors]) ? anchorsOf(params.anchors) : void 0;
+        const target = { refs, ids: _optionalChain([params, 'optionalAccess', _257 => _257.ids]) ? ids(params) : void 0 };
+        if (_optionalChain([params, 'optionalAccess', _258 => _258.radius]) !== void 0) check(controller.setCornerRadius(params.radius, { ...target, kind: params.kind }));
+        else if (_optionalChain([params, 'optionalAccess', _259 => _259.kind])) check(controller.setCornerKind(params.kind, target));
         else fail("Pass `radius` and / or `kind`.");
         return { ok: true };
       }
@@ -7381,12 +7956,12 @@ function createVectorCommands(controller, options = {}) {
       undoable: true,
       run: (_ctx, params) => {
         const target = { ids: ids(params) };
-        if (_optionalChain([params, 'optionalAccess', _237 => _237.preset])) check(controller.setWidthProfile(params.preset, target));
-        else if (_optionalChain([params, 'optionalAccess', _238 => _238.points]) !== void 0) check(controller.setWidthProfile(_nullishCoalesce(params.points, () => ( null)), target));
-        else if (_optionalChain([params, 'optionalAccess', _239 => _239.taper]) || _optionalChain([params, 'optionalAccess', _240 => _240.wave])) check(controller.setWidthProfile({ taper: params.taper, wave: params.wave }, target));
+        if (_optionalChain([params, 'optionalAccess', _260 => _260.preset])) check(controller.setWidthProfile(params.preset, target));
+        else if (_optionalChain([params, 'optionalAccess', _261 => _261.points]) !== void 0) check(controller.setWidthProfile(_nullishCoalesce(params.points, () => ( null)), target));
+        else if (_optionalChain([params, 'optionalAccess', _262 => _262.taper]) || _optionalChain([params, 'optionalAccess', _263 => _263.wave])) check(controller.setWidthProfile({ taper: params.taper, wave: params.wave }, target));
         else fail("Pass `preset`, `points`, `taper` or `wave`.");
         const node = controller.getNode(target.ids[0]);
-        return { ok: true, points: _optionalChain([node, 'optionalAccess', _241 => _241.type]) === "path" ? _nullishCoalesce(node.strokeWidthProfile, () => ( [])) : [] };
+        return { ok: true, points: _optionalChain([node, 'optionalAccess', _264 => _264.type]) === "path" ? _nullishCoalesce(node.strokeWidthProfile, () => ( [])) : [] };
       }
     },
     {
@@ -7399,7 +7974,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       undoable: true,
       run: (_ctx, params) => {
-        const created = controller.outlineStroke({ ids: _optionalChain([params, 'optionalAccess', _242 => _242.ids]) ? ids(params) : void 0 });
+        const created = controller.outlineStroke({ ids: _optionalChain([params, 'optionalAccess', _265 => _265.ids]) ? ids(params) : void 0 });
         if (!created.length) fail("No selected path has a stroke.");
         return { ids: created };
       }
@@ -7461,6 +8036,62 @@ function createVectorCommands(controller, options = {}) {
         return { id };
       }
     },
+    {
+      ...base,
+      id: `${prefix}pathfinder`,
+      label: "Pathfinder\u2026",
+      keywords: ["divide", "trim", "merge", "crop", "outline", "minus back", "split", "faces"],
+      description: "Pathfinder over the given paths (bottom to top): divide (every face its own shape, painted like the top-most shape over it; open unfilled paths cut), trim (hidden parts removed), merge (trim, then touching parts of one fill joined), crop (the top shape crops the others), outline (outlines cut into open strokes where they meet) or minusBack (the top shape minus everything below). Results replace the paths, grouped when there are several.",
+      params: { type: "object", properties: { operation: { type: "string", enum: [...VECTOR_PATHFINDER_OPERATIONS] }, ids: IDS }, required: ["operation"] },
+      undoable: true,
+      run: (_ctx, params) => {
+        if (!VECTOR_PATHFINDER_OPERATIONS.includes(params.operation)) fail(`Unknown Pathfinder operation "${params.operation}".`);
+        const created = controller.pathfinder(params.operation, { ids: ids(params) });
+        if (!created.length) fail("Nothing came out: select paths that overlap (two or more, except for divide and outline).");
+        return { ids: created, selection: [...controller.getState().selection] };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}shapeBuilderFaces`,
+      label: "List Shape Builder Faces",
+      keywords: ["shape builder", "regions", "faces", "planar"],
+      description: "Lists the faces the given paths divide the plane into: path data, area, a point inside and the ids of the paths filling each (empty when only outlines enclose it).",
+      params: { type: "object", properties: { ids: IDS } },
+      run: (_ctx, params) => ({ faces: controller.getShapeBuilderFaces({ ids: ids(params) }) })
+    },
+    {
+      ...base,
+      id: `${prefix}shapeBuilder`,
+      label: "Shape Builder",
+      keywords: ["merge faces", "build shape", "combine regions", "delete region"],
+      description: "Shape Builder gesture over the faces of the given paths: `points` is the pointer path in document units (one point is a click; [[x, y], \u2026]; use the points from shapeBuilderFaces). Merges the faces it touches into one shape, or with `erase: true` deletes them, the pieces of unfilled open paths and the edges of other outlines (cut where paths meet) within `tolerance`; a deleted edge opens its path there, and edges bounding a deleted face go with it. Shapes covering those faces lose that area. Returns the counts of faces, line pieces and edges.",
+      params: {
+        type: "object",
+        properties: { points: POINTS, erase: { type: "boolean" }, tolerance: { type: "number", minimum: 0 }, ids: IDS },
+        required: ["points"]
+      },
+      undoable: true,
+      run: (_ctx, params) => {
+        const result = controller.shapeBuilder(params.points.map(([x, y]) => ({ x, y })), { ids: ids(params), erase: params.erase, tolerance: params.tolerance });
+        check(result);
+        return { merged: result.merged, faces: result.faces, lines: result.lines, edges: result.edges };
+      }
+    },
+    {
+      ...base,
+      id: `${prefix}fillRegion`,
+      label: "Fill Region",
+      keywords: ["paint bucket", "live paint", "fill area", "enclosed"],
+      description: "Paint bucket: fills the area the visible outlines enclose around `point` (crossings split, nested shapes left as holes) with a new path in the current fill, below the selection or on top. `gap` closes gaps up to that size between loose ends.",
+      params: { type: "object", properties: { point: { type: "array", items: { type: "number" }, minItems: 2, maxItems: 2, description: "[x, y] in document units." }, gap: { type: "number", minimum: 0 } }, required: ["point"] },
+      undoable: true,
+      run: (_ctx, params) => {
+        const id = controller.fillRegion({ x: params.point[0], y: params.point[1] }, { gap: params.gap });
+        if (!id) fail("No closed region surrounds that point.");
+        return { id };
+      }
+    },
     {
       ...base,
       id: `${prefix}align`,
@@ -7514,7 +8145,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       undoable: true,
       run: (_ctx, params) => {
-        const id = controller.group({ ids: ids(params), name: _optionalChain([params, 'optionalAccess', _243 => _243.name]) });
+        const id = controller.group({ ids: ids(params), name: _optionalChain([params, 'optionalAccess', _266 => _266.name]) });
         if (!id) fail("Only nodes that share a parent can be grouped.");
         return { id };
       }
@@ -7542,7 +8173,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { anchors: ANCHORS, keepShape: { type: "boolean" } } },
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.deleteAnchors(anchorsOf(_optionalChain([params, 'optionalAccess', _244 => _244.anchors])), { keepShape: _optionalChain([params, 'optionalAccess', _245 => _245.keepShape]) }));
+        check(controller.deleteAnchors(anchorsOf(_optionalChain([params, 'optionalAccess', _267 => _267.anchors])), { keepShape: _optionalChain([params, 'optionalAccess', _268 => _268.keepShape]) }));
         return { ok: true };
       }
     },
@@ -7597,7 +8228,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { ids: IDS, tolerance: { type: "number", minimum: 0 } } },
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.joinPaths({ ids: _optionalChain([params, 'optionalAccess', _246 => _246.ids]) ? ids(params) : void 0, tolerance: _optionalChain([params, 'optionalAccess', _247 => _247.tolerance]) }));
+        check(controller.joinPaths({ ids: _optionalChain([params, 'optionalAccess', _269 => _269.ids]) ? ids(params) : void 0, tolerance: _optionalChain([params, 'optionalAccess', _270 => _270.tolerance]) }));
         return { selection: controller.getState().selection };
       }
     },
@@ -7611,7 +8242,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { axis: { type: "string", enum: ["horizontal", "vertical", "both"] }, anchors: ANCHORS } },
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.averageAnchors(_nullishCoalesce(_optionalChain([params, 'optionalAccess', _248 => _248.axis]), () => ( "both")), anchorsOf(_optionalChain([params, 'optionalAccess', _249 => _249.anchors]))));
+        check(controller.averageAnchors(_nullishCoalesce(_optionalChain([params, 'optionalAccess', _271 => _271.axis]), () => ( "both")), anchorsOf(_optionalChain([params, 'optionalAccess', _272 => _272.anchors]))));
         return { ok: true };
       }
     },
@@ -7625,7 +8256,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.removeRedundantPoints({ ids: _optionalChain([params, 'optionalAccess', _250 => _250.ids]) ? ids(params) : void 0, tolerance: _optionalChain([params, 'optionalAccess', _251 => _251.tolerance]) }));
+        check(controller.removeRedundantPoints({ ids: _optionalChain([params, 'optionalAccess', _273 => _273.ids]) ? ids(params) : void 0, tolerance: _optionalChain([params, 'optionalAccess', _274 => _274.tolerance]) }));
         return { ok: true };
       }
     },
@@ -7638,7 +8269,7 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { ids: IDS, amount: { type: "number", minimum: 0, maximum: 1 }, anchors: ANCHORS } },
       undoable: true,
       run: (_ctx, params) => {
-        check(controller.smoothPaths({ ids: _optionalChain([params, 'optionalAccess', _252 => _252.ids]) ? ids(params) : void 0, amount: _optionalChain([params, 'optionalAccess', _253 => _253.amount]), refs: _optionalChain([params, 'optionalAccess', _254 => _254.anchors]) }));
+        check(controller.smoothPaths({ ids: _optionalChain([params, 'optionalAccess', _275 => _275.ids]) ? ids(params) : void 0, amount: _optionalChain([params, 'optionalAccess', _276 => _276.amount]), refs: _optionalChain([params, 'optionalAccess', _277 => _277.anchors]) }));
         return { ok: true };
       }
     },
@@ -7651,14 +8282,14 @@ function createVectorCommands(controller, options = {}) {
       params: { type: "object", properties: { nodeId: { type: "string" }, x: { type: "number" }, y: { type: "number" }, anchors: ANCHORS } },
       undoable: true,
       run: (_ctx, params) => {
-        if (_optionalChain([params, 'optionalAccess', _255 => _255.nodeId]) !== void 0) {
+        if (_optionalChain([params, 'optionalAccess', _278 => _278.nodeId]) !== void 0) {
           if (!controller.getNode(params.nodeId)) fail(`There is no node "${params.nodeId}".`);
           if (params.x === void 0 || params.y === void 0) fail("Pass x and y with nodeId.");
           const created = controller.cutPathAt(params.nodeId, { x: params.x, y: params.y });
           if (!created) fail("Nothing to cut there (the end of an open path, or a locked path).");
           return { ids: created };
         }
-        check(controller.cutAtAnchors(anchorsOf(_optionalChain([params, 'optionalAccess', _256 => _256.anchors]))));
+        check(controller.cutAtAnchors(anchorsOf(_optionalChain([params, 'optionalAccess', _279 => _279.anchors]))));
         return { ids: controller.getState().selection };
       }
     },
@@ -7709,7 +8340,7 @@ function createVectorCommands(controller, options = {}) {
       },
       run: (_ctx, params) => {
         const patch = {};
-        for (const key of ["keepShapeOnDelete", "curvatureMoves", "pencilSmoothing", "recognizeShapes", "eraserSize", "pencilPressure"]) if (_optionalChain([params, 'optionalAccess', _257 => _257[key]]) !== void 0) patch[key] = params[key];
+        for (const key of ["keepShapeOnDelete", "curvatureMoves", "pencilSmoothing", "recognizeShapes", "eraserSize", "pencilPressure"]) if (_optionalChain([params, 'optionalAccess', _280 => _280[key]]) !== void 0) patch[key] = params[key];
         controller.setEditing(patch);
         return { editing: controller.getState().editing };
       }
@@ -7734,7 +8365,7 @@ function createVectorCommands(controller, options = {}) {
       keywords: ["download", "save", "markup"],
       description: "Returns the document as SVG markup.",
       params: { type: "object", properties: { precision: { type: "integer", minimum: 0, maximum: 8 } } },
-      run: (_ctx, params) => ({ svg: controller.toSvg({ precision: _optionalChain([params, 'optionalAccess', _258 => _258.precision]) }) })
+      run: (_ctx, params) => ({ svg: controller.toSvg({ precision: _optionalChain([params, 'optionalAccess', _281 => _281.precision]) }) })
     },
     {
       ...base,
@@ -7932,5 +8563,21 @@ function createVectorCommands(controller, options = {}) {
 
 
 
-exports.DEFAULT_VECTOR_PATH_EDIT = DEFAULT_VECTOR_PATH_EDIT; exports.DEFAULT_VECTOR_SNAP = DEFAULT_VECTOR_SNAP; exports.IDENTITY_MATRIX = IDENTITY_MATRIX; exports.KAPPA = KAPPA2; exports.LazyMouse = LazyMouse; exports.VECTOR_ARROWHEADS = VECTOR_ARROWHEADS; exports.VECTOR_ARROWHEAD_LABELS = VECTOR_ARROWHEAD_LABELS; exports.VECTOR_CLIPBOARD_TYPE = VECTOR_CLIPBOARD_TYPE; exports.VECTOR_CONSTRUCTION_ANGLES = VECTOR_CONSTRUCTION_ANGLES; exports.VECTOR_CORNER_KINDS = VECTOR_CORNER_KINDS; exports.VECTOR_CORNER_KIND_LABELS = VECTOR_CORNER_KIND_LABELS; exports.VECTOR_CORNER_WIDGET_INSET = VECTOR_CORNER_WIDGET_INSET; exports.VECTOR_EDIT_TOGGLES = VECTOR_EDIT_TOGGLES; exports.VECTOR_INK_MAX_CORNERS = VECTOR_INK_MAX_CORNERS; exports.VECTOR_OVERLAY_THEME = VECTOR_OVERLAY_THEME; exports.VECTOR_PATH_ACTIONS = VECTOR_PATH_ACTIONS; exports.VECTOR_PENCIL_STRING_PX = VECTOR_PENCIL_STRING_PX; exports.VECTOR_PRESSURE_NOMINAL = VECTOR_PRESSURE_NOMINAL; exports.VECTOR_ROTATE_HANDLE_OFFSET = VECTOR_ROTATE_HANDLE_OFFSET; exports.VECTOR_STROKE_ALIGN_LABELS = VECTOR_STROKE_ALIGN_LABELS; exports.VECTOR_STYLE_KEYS = VECTOR_STYLE_KEYS; exports.VECTOR_TOOLS = VECTOR_TOOLS; exports.VECTOR_TOOL_GLYPHS = VECTOR_TOOL_GLYPHS; exports.VECTOR_TOOL_SHORTCUTS = VECTOR_TOOL_SHORTCUTS; exports.VECTOR_TRANSFORM_HANDLES = VECTOR_TRANSFORM_HANDLES; exports.VECTOR_WIDTH_PRESETS = VECTOR_WIDTH_PRESETS; exports.VECTOR_WIDTH_PRESET_IDS = VECTOR_WIDTH_PRESET_IDS; exports.VECTOR_WIDTH_PROFILE_MAX_POINTS = VECTOR_WIDTH_PROFILE_MAX_POINTS; exports.VECTOR_WIDTH_PROFILE_MAX_SCALE = VECTOR_WIDTH_PROFILE_MAX_SCALE; exports.VECTOR_WIDTH_SAME_T = VECTOR_WIDTH_SAME_T; exports.VectorEditorController = VectorEditorController; exports.VectorSnapTargets = VectorSnapTargets; exports.applyMatrix = applyMatrix; exports.applyMatrixLinear = applyMatrixLinear; exports.applyVectorCornersAttribute = applyVectorCornersAttribute; exports.arrowheadInset = arrowheadInset; exports.arrowheadPath = arrowheadPath; exports.arrowheadWeight = arrowheadWeight; exports.bendSegment = bendSegment; exports.bezierToSubpaths = bezierToSubpaths; exports.boundsFromPoints = boundsFromPoints; exports.boundsIntersect = boundsIntersect; exports.cloneAnchor = cloneAnchor; exports.cloneSubpath = cloneSubpath; exports.cloneVectorDocument = cloneVectorDocument; exports.cloneVectorNode = cloneVectorNode; exports.collectPathNodes = collectPathNodes; exports.constrainToLeave = constrainToLeave; exports.convertAnchor = convertAnchor; exports.cornerBisectorPoint = cornerBisectorPoint; exports.cornerRadiusChange = cornerRadiusChange; exports.cornerSetback = cornerSetback; exports.createVectorCommands = createVectorCommands; exports.curvatureMoveAnchor = curvatureMoveAnchor; exports.cutSubpathAt = cutSubpathAt; exports.dashIntervals = dashIntervals; exports.decomposeRigid = decomposeRigid; exports.effectiveStrokeAlign = effectiveStrokeAlign; exports.ellipseSubpath = ellipseSubpath; exports.eraseFromFill = eraseFromFill; exports.eraseFromOutline = eraseFromOutline; exports.eraserRegion = eraserRegion; exports.expandVectorCorners = expandVectorCorners; exports.expandVectorCornersOf = expandVectorCornersOf; exports.findVectorNode = findVectorNode; exports.fitCornerRadius = fitCornerRadius; exports.generateWidthProfile = generateWidthProfile; exports.getAnchor = getAnchor; exports.getAnchorWorld = getAnchorWorld; exports.getEditablePathIds = getEditablePathIds; exports.getTransformHandlePositions = getTransformHandlePositions; exports.getVectorCornerWidgets = getVectorCornerWidgets; exports.getVectorOverlayRenderData = getVectorOverlayRenderData; exports.getVectorSceneRenderData = getVectorSceneRenderData; exports.getVectorSelectionBoxGeometry = getVectorSelectionBoxGeometry; exports.getVectorSelectionFrame = getVectorSelectionFrame; exports.getVectorSelectionStyle = getVectorSelectionStyle; exports.getVectorWidthHandles = getVectorWidthHandles; exports.getVisibleAnchors = getVisibleAnchors; exports.getVisibleHandles = getVisibleHandles; exports.hasPaint = hasPaint; exports.hasStrokeExtras = hasStrokeExtras; exports.hasVectorCorners = hasVectorCorners; exports.hitTestVectorNode = hitTestVectorNode; exports.hitTestVectorNodes = hitTestVectorNodes; exports.hitTestVectorStroke = hitTestVectorStroke; exports.inferAnchorType = inferAnchorType; exports.insertAnchor = insertAnchor; exports.insertWidthPoint = insertWidthPoint; exports.invertMatrix = invertMatrix; exports.isClosedBezierShape = isClosedBezierShape; exports.isIdentityMatrix = isIdentityMatrix; exports.isUniformWidthProfile = isUniformWidthProfile; exports.isVectorTextTarget = isVectorTextTarget; exports.joinSubpaths = joinSubpaths; exports.knifePath = knifePath; exports.lineSubpath = lineSubpath; exports.locateVectorNode = locateVectorNode; exports.matrixRotation = matrixRotation; exports.mirrorWidthProfile = mirrorWidthProfile; exports.moveAnchorHandle = moveAnchorHandle; exports.multiplyMatrices = multiplyMatrices; exports.nearestSegment = nearestSegment; exports.nearestStrokePosition = nearestStrokePosition; exports.nextVectorCornerKind = nextVectorCornerKind; exports.nodeMatrix = nodeMatrix; exports.parseSvgTransform = parseSvgTransform; exports.parseVectorSvg = parseVectorSvg; exports.polygonSubpath = polygonSubpath; exports.polylineBounds = polylineBounds; exports.pressureWidthProfile = pressureWidthProfile; exports.recognizeInkShape = recognizeInkShape; exports.rectSubpath = rectSubpath; exports.removeAnchorKeepingShape = removeAnchorKeepingShape; exports.removeAnchors = removeAnchors; exports.removeAnchorsKeepingShape = removeAnchorsKeepingShape; exports.removeRedundantPoints = removeRedundantPoints; exports.removeWidthPoints = removeWidthPoints; exports.reverseSubpath = reverseSubpath; exports.reverseWidthProfile = reverseWidthProfile; exports.rotateMatrix = rotateMatrix; exports.roundSubpaths = roundSubpaths; exports.sanitizeWidthProfile = sanitizeWidthProfile; exports.scaleFor = scaleFor; exports.scaleMatrix = scaleMatrix; exports.setAnchorCorner = setAnchorCorner; exports.setSubpathCorners = setSubpathCorners; exports.setWidthPoint = setWidthPoint; exports.simplifyPolyline = simplifyPolyline; exports.smoothSubpath = smoothSubpath; exports.splitIntoFaces = splitIntoFaces; exports.splitSubpathAt = splitSubpathAt; exports.starSubpath = starSubpath; exports.strokePositionPoint = strokePositionPoint; exports.strokeWidthProfileOf = strokeWidthProfileOf; exports.subpathPointAt = subpathPointAt; exports.subpathSegment = subpathSegment; exports.subpathSegmentCount = subpathSegmentCount; exports.subpathsToBezier = subpathsToBezier; exports.taperWaveFactor = taperWaveFactor; exports.toVectorKeyInput = toVectorKeyInput; exports.toVectorModifiers = toVectorModifiers; exports.toVectorPointerInput = toVectorPointerInput; exports.transformVectorNode = transformVectorNode; exports.translateAnchor = translateAnchor; exports.translateMatrix = translateMatrix; exports.unionBounds = unionBounds; exports.variableStrokeOutline = variableStrokeOutline; exports.variableStrokeRings = variableStrokeRings; exports.vectorCornerAt = vectorCornerAt; exports.vectorCorners = vectorCorners; exports.vectorCornersAttribute = vectorCornersAttribute; exports.vectorDiamondPath = vectorDiamondPath; exports.vectorDocumentToSvg = vectorDocumentToSvg; exports.vectorInkShapeName = vectorInkShapeName; exports.vectorNodeBounds = vectorNodeBounds; exports.vectorNodeRotation = vectorNodeRotation; exports.vectorNodeToBezier = vectorNodeToBezier; exports.vectorPaintToHex = vectorPaintToHex; exports.vectorPaintToSvg = vectorPaintToSvg; exports.vectorParentMatrix = vectorParentMatrix; exports.vectorPathData = vectorPathData; exports.vectorPathWorldBezier = vectorPathWorldBezier; exports.vectorResizeCursor = vectorResizeCursor; exports.vectorStrokeLineArea = vectorStrokeLineArea; exports.vectorStrokeOutline = vectorStrokeOutline; exports.vectorStrokeOutlinePath = vectorStrokeOutlinePath; exports.vectorStrokeParts = vectorStrokeParts; exports.vectorStrokeReach = vectorStrokeReach; exports.vectorStrokeSvgParts = vectorStrokeSvgParts; exports.vectorStrokeWidthGeometry = vectorStrokeWidthGeometry; exports.vectorToolLabel = vectorToolLabel; exports.vectorWorldMatrix = vectorWorldMatrix; exports.walkVectorNodes = walkVectorNodes; exports.widthProfileAt = widthProfileAt; exports.widthProfileFromAttribute = widthProfileFromAttribute; exports.widthProfileMaxScale = widthProfileMaxScale; exports.widthProfilePreset = widthProfilePreset; exports.widthProfilePresetId = widthProfilePresetId; exports.widthProfileToAttribute = widthProfileToAttribute;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.DEFAULT_VECTOR_PATH_EDIT = DEFAULT_VECTOR_PATH_EDIT; exports.DEFAULT_VECTOR_SNAP = DEFAULT_VECTOR_SNAP; exports.IDENTITY_MATRIX = IDENTITY_MATRIX; exports.KAPPA = KAPPA2; exports.LazyMouse = LazyMouse; exports.VECTOR_ARROWHEADS = VECTOR_ARROWHEADS; exports.VECTOR_ARROWHEAD_LABELS = VECTOR_ARROWHEAD_LABELS; exports.VECTOR_BUILDER_HATCH_GAP = VECTOR_BUILDER_HATCH_GAP; exports.VECTOR_CLIPBOARD_TYPE = VECTOR_CLIPBOARD_TYPE; exports.VECTOR_CONSTRUCTION_ANGLES = VECTOR_CONSTRUCTION_ANGLES; exports.VECTOR_CORNER_KINDS = VECTOR_CORNER_KINDS; exports.VECTOR_CORNER_KIND_LABELS = VECTOR_CORNER_KIND_LABELS; exports.VECTOR_CORNER_WIDGET_INSET = VECTOR_CORNER_WIDGET_INSET; exports.VECTOR_EDIT_TOGGLES = VECTOR_EDIT_TOGGLES; exports.VECTOR_FILL_GAP = VECTOR_FILL_GAP; exports.VECTOR_INK_MAX_CORNERS = VECTOR_INK_MAX_CORNERS; exports.VECTOR_OVERLAY_THEME = VECTOR_OVERLAY_THEME; exports.VECTOR_PATHFINDER_ACTIONS = VECTOR_PATHFINDER_ACTIONS; exports.VECTOR_PATHFINDER_LABELS = VECTOR_PATHFINDER_LABELS; exports.VECTOR_PATHFINDER_OPERATIONS = VECTOR_PATHFINDER_OPERATIONS; exports.VECTOR_PATH_ACTIONS = VECTOR_PATH_ACTIONS; exports.VECTOR_PENCIL_STRING_PX = VECTOR_PENCIL_STRING_PX; exports.VECTOR_PRESSURE_NOMINAL = VECTOR_PRESSURE_NOMINAL; exports.VECTOR_ROTATE_HANDLE_OFFSET = VECTOR_ROTATE_HANDLE_OFFSET; exports.VECTOR_STROKE_ALIGN_LABELS = VECTOR_STROKE_ALIGN_LABELS; exports.VECTOR_STYLE_KEYS = VECTOR_STYLE_KEYS; exports.VECTOR_TOOLS = VECTOR_TOOLS; exports.VECTOR_TOOL_GLYPHS = VECTOR_TOOL_GLYPHS; exports.VECTOR_TOOL_SHORTCUTS = VECTOR_TOOL_SHORTCUTS; exports.VECTOR_TRANSFORM_HANDLES = VECTOR_TRANSFORM_HANDLES; exports.VECTOR_WIDTH_PRESETS = VECTOR_WIDTH_PRESETS; exports.VECTOR_WIDTH_PRESET_IDS = VECTOR_WIDTH_PRESET_IDS; exports.VECTOR_WIDTH_PROFILE_MAX_POINTS = VECTOR_WIDTH_PROFILE_MAX_POINTS; exports.VECTOR_WIDTH_PROFILE_MAX_SCALE = VECTOR_WIDTH_PROFILE_MAX_SCALE; exports.VECTOR_WIDTH_SAME_T = VECTOR_WIDTH_SAME_T; exports.VectorEditorController = VectorEditorController; exports.VectorSnapTargets = VectorSnapTargets; exports.addBuilderHit = addBuilderHit; exports.applyMatrix = applyMatrix; exports.applyMatrixLinear = applyMatrixLinear; exports.applyVectorCornersAttribute = applyVectorCornersAttribute; exports.arrowheadInset = arrowheadInset; exports.arrowheadPath = arrowheadPath; exports.arrowheadWeight = arrowheadWeight; exports.bendSegment = bendSegment; exports.bezierToSubpaths = bezierToSubpaths; exports.boundsFromPoints = boundsFromPoints; exports.boundsIntersect = boundsIntersect; exports.cloneAnchor = cloneAnchor; exports.cloneSubpath = cloneSubpath; exports.cloneVectorDocument = cloneVectorDocument; exports.cloneVectorNode = cloneVectorNode; exports.collectPathNodes = collectPathNodes; exports.constrainToLeave = constrainToLeave; exports.convertAnchor = convertAnchor; exports.cornerBisectorPoint = cornerBisectorPoint; exports.cornerRadiusChange = cornerRadiusChange; exports.cornerSetback = cornerSetback; exports.createVectorCommands = createVectorCommands; exports.curvatureMoveAnchor = curvatureMoveAnchor; exports.cutSubpathAt = cutSubpathAt; exports.dashIntervals = dashIntervals; exports.decomposeRigid = decomposeRigid; exports.effectiveStrokeAlign = effectiveStrokeAlign; exports.ellipseSubpath = ellipseSubpath; exports.eraseFromFill = eraseFromFill; exports.eraseFromOutline = eraseFromOutline; exports.eraserRegion = eraserRegion; exports.expandVectorCorners = expandVectorCorners; exports.expandVectorCornersOf = expandVectorCornersOf; exports.findVectorNode = findVectorNode; exports.fitCornerRadius = fitCornerRadius; exports.generateWidthProfile = generateWidthProfile; exports.getAnchor = getAnchor; exports.getAnchorWorld = getAnchorWorld; exports.getEditablePathIds = getEditablePathIds; exports.getTransformHandlePositions = getTransformHandlePositions; exports.getVectorCornerWidgets = getVectorCornerWidgets; exports.getVectorOverlayRenderData = getVectorOverlayRenderData; exports.getVectorSceneRenderData = getVectorSceneRenderData; exports.getVectorSelectionBoxGeometry = getVectorSelectionBoxGeometry; exports.getVectorSelectionFrame = getVectorSelectionFrame; exports.getVectorSelectionStyle = getVectorSelectionStyle; exports.getVectorWidthHandles = getVectorWidthHandles; exports.getVisibleAnchors = getVisibleAnchors; exports.getVisibleHandles = getVisibleHandles; exports.hasPaint = hasPaint; exports.hasStrokeExtras = hasStrokeExtras; exports.hasVectorCorners = hasVectorCorners; exports.hitTestVectorNode = hitTestVectorNode; exports.hitTestVectorNodes = hitTestVectorNodes; exports.hitTestVectorStroke = hitTestVectorStroke; exports.inferAnchorType = inferAnchorType; exports.insertAnchor = insertAnchor; exports.insertWidthPoint = insertWidthPoint; exports.invertMatrix = invertMatrix; exports.isClosedBezierShape = isClosedBezierShape; exports.isIdentityMatrix = isIdentityMatrix; exports.isUniformWidthProfile = isUniformWidthProfile; exports.isVectorTextTarget = isVectorTextTarget; exports.joinSubpaths = joinSubpaths; exports.knifePath = knifePath; exports.lineSubpath = lineSubpath; exports.locateVectorNode = locateVectorNode; exports.matrixRotation = matrixRotation; exports.mirrorWidthProfile = mirrorWidthProfile; exports.moveAnchorHandle = moveAnchorHandle; exports.multiplyMatrices = multiplyMatrices; exports.nearestSegment = nearestSegment; exports.nearestStrokePosition = nearestStrokePosition; exports.nextVectorCornerKind = nextVectorCornerKind; exports.nodeMatrix = nodeMatrix; exports.parseSvgTransform = parseSvgTransform; exports.parseVectorSvg = parseVectorSvg; exports.planShapeBuilder = planShapeBuilder; exports.polygonSubpath = polygonSubpath; exports.polylineBounds = polylineBounds; exports.pressureWidthProfile = pressureWidthProfile; exports.recognizeInkShape = recognizeInkShape; exports.rectSubpath = rectSubpath; exports.removeAnchorKeepingShape = removeAnchorKeepingShape; exports.removeAnchors = removeAnchors; exports.removeAnchorsKeepingShape = removeAnchorsKeepingShape; exports.removeRedundantPoints = removeRedundantPoints; exports.removeWidthPoints = removeWidthPoints; exports.reverseSubpath = reverseSubpath; exports.reverseWidthProfile = reverseWidthProfile; exports.rotateMatrix = rotateMatrix; exports.roundSubpaths = roundSubpaths; exports.samplePolyline = samplePolyline; exports.sanitizeWidthProfile = sanitizeWidthProfile; exports.scaleFor = scaleFor; exports.scaleMatrix = scaleMatrix; exports.setAnchorCorner = setAnchorCorner; exports.setSubpathCorners = setSubpathCorners; exports.setWidthPoint = setWidthPoint; exports.simplifyPolyline = simplifyPolyline; exports.smoothSubpath = smoothSubpath; exports.splitIntoFaces = splitIntoFaces; exports.splitSubpathAt = splitSubpathAt; exports.starSubpath = starSubpath; exports.strokePositionPoint = strokePositionPoint; exports.strokeWidthProfileOf = strokeWidthProfileOf; exports.subpathEnclosesArea = subpathEnclosesArea; exports.subpathPointAt = subpathPointAt; exports.subpathSegment = subpathSegment; exports.subpathSegmentCount = subpathSegmentCount; exports.subpathsToBezier = subpathsToBezier; exports.taperWaveFactor = taperWaveFactor; exports.toVectorKeyInput = toVectorKeyInput; exports.toVectorModifiers = toVectorModifiers; exports.toVectorPointerInput = toVectorPointerInput; exports.transformVectorNode = transformVectorNode; exports.translateAnchor = translateAnchor; exports.translateMatrix = translateMatrix; exports.unionBounds = unionBounds; exports.variableStrokeOutline = variableStrokeOutline; exports.variableStrokeRings = variableStrokeRings; exports.vectorBuilderErasedEdges = vectorBuilderErasedEdges; exports.vectorCornerAt = vectorCornerAt; exports.vectorCorners = vectorCorners; exports.vectorCornersAttribute = vectorCornersAttribute; exports.vectorDiamondPath = vectorDiamondPath; exports.vectorDocumentToSvg = vectorDocumentToSvg; exports.vectorFillMap = vectorFillMap; exports.vectorInkShapeName = vectorInkShapeName; exports.vectorNodeBounds = vectorNodeBounds; exports.vectorNodeRotation = vectorNodeRotation; exports.vectorNodeToBezier = vectorNodeToBezier; exports.vectorPaintToHex = vectorPaintToHex; exports.vectorPaintToSvg = vectorPaintToSvg; exports.vectorParentMatrix = vectorParentMatrix; exports.vectorPathData = vectorPathData; exports.vectorPathEntries = vectorPathEntries; exports.vectorPathWorldBezier = vectorPathWorldBezier; exports.vectorPathfinderShape = vectorPathfinderShape; exports.vectorResizeCursor = vectorResizeCursor; exports.vectorResultStyle = vectorResultStyle; exports.vectorShapeBuilderHit = vectorShapeBuilderHit; exports.vectorShapeBuilderMap = vectorShapeBuilderMap; exports.vectorStrokeLineArea = vectorStrokeLineArea; exports.vectorStrokeOutline = vectorStrokeOutline; exports.vectorStrokeOutlinePath = vectorStrokeOutlinePath; exports.vectorStrokeParts = vectorStrokeParts; exports.vectorStrokeReach = vectorStrokeReach; exports.vectorStrokeSvgParts = vectorStrokeSvgParts; exports.vectorStrokeWidthGeometry = vectorStrokeWidthGeometry; exports.vectorToolLabel = vectorToolLabel; exports.vectorWorldMatrix = vectorWorldMatrix; exports.walkVectorNodes = walkVectorNodes; exports.widthProfileAt = widthProfileAt; exports.widthProfileFromAttribute = widthProfileFromAttribute; exports.widthProfileMaxScale = widthProfileMaxScale; exports.widthProfilePreset = widthProfilePreset; exports.widthProfilePresetId = widthProfilePresetId; exports.widthProfileToAttribute = widthProfileToAttribute;
 //# sourceMappingURL=index.cjs.map