@pixerate/editor 0.49.0 → 0.51.0

package/dist/vector/index.cjs

@@ -40,7 +40,7 @@ var _chunkQKLRAA4Tcjs = require('../chunk-QKLRAA4T.cjs');
 
 
 
-var _chunkVNYRI265cjs = require('../chunk-VNYRI265.cjs');
+var _chunkYNSK4MGTcjs = require('../chunk-YNSK4MGT.cjs');
 
 
 
@@ -350,7 +350,7 @@ function spanVectorGradientStops(g, from, to, expanded = expandVectorGradientSto
 var hasExplicitGradientGeometry = (g) => finitePoint(g.start) && finitePoint(g.end);
 function shorthandPoints(g) {
   if (g.type === "linear" || g.type === "reflected") {
-    const c = _chunkVNYRI265cjs.angleToSvgLinearCoords.call(void 0, Number.isFinite(g.angle) ? g.angle : 180);
+    const c = _chunkYNSK4MGTcjs.angleToSvgLinearCoords.call(void 0, Number.isFinite(g.angle) ? g.angle : 180);
     const start2 = g.type === "linear" ? { x: c.x1, y: c.y1 } : { x: 0.5, y: 0.5 };
     const end = { x: c.x2, y: c.y2 };
     return { start: start2, end, width: add(start2, perp(sub(end, start2))) };
@@ -918,7 +918,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) : _chunkVNYRI265cjs.segmentLength.call(void 0, this.curve);
+    this.length = this.straight ? Math.hypot(b.x - a.x, b.y - a.y) : _chunkYNSK4MGTcjs.segmentLength.call(void 0, this.curve);
   }
   /** Unit direction the side leaves the corner in (towards its first control point off the corner). */
   direction() {
@@ -936,10 +936,10 @@ var Side = class {
       const t2 = this.length > EPS ? Math.min(1, Math.max(0, s / this.length)) : 0;
       return { t: t2, p: add2(vec(this.curve[0]), mul2(u, s)), dir: u };
     }
-    const t = _chunkVNYRI265cjs.segmentParamAtLength.call(void 0, this.curve, s, this.length);
-    const d = vec(_chunkVNYRI265cjs.segmentDerivative.call(void 0, this.curve, t));
+    const t = _chunkYNSK4MGTcjs.segmentParamAtLength.call(void 0, this.curve, s, this.length);
+    const d = vec(_chunkYNSK4MGTcjs.segmentDerivative.call(void 0, this.curve, t));
     const l = len(d);
-    return { t, p: vec(_chunkVNYRI265cjs.segmentPoint.call(void 0, this.curve, t)), dir: l > EPS ? mul2(d, 1 / l) : u };
+    return { t, p: vec(_chunkYNSK4MGTcjs.segmentPoint.call(void 0, this.curve, t)), dir: l > EPS ? mul2(d, 1 / l) : u };
   }
 };
 function cornerOf(sp, s, i) {
@@ -1040,7 +1040,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 = _chunkVNYRI265cjs.subSegment.call(void 0, seg, s0, Math.max(s0, s1));
+    const part = _chunkYNSK4MGTcjs.subSegment.call(void 0, seg, s0, Math.max(s0, s1));
     return { out: vec(part[1]), in: vec(part[2]) };
   });
   const anchors = [];
@@ -1343,7 +1343,7 @@ function flatten(segments, closed, tol) {
     corner.push(isCorner);
   };
   for (const seg of segments) {
-    const flat = _chunkVNYRI265cjs.flattenChain.call(void 0, [seg], tol);
+    const flat = _chunkYNSK4MGTcjs.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));
   }
@@ -1433,7 +1433,7 @@ function variableStrokeRings(path, options) {
     const last = out[out.length - 1];
     if (!last || dist(last, p) > 1e-12) out.push(p);
   };
-  for (const contour of _chunkVNYRI265cjs.pathToContours.call(void 0, path)) {
+  for (const contour of _chunkYNSK4MGTcjs.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;
@@ -1559,7 +1559,7 @@ function variableStrokeOutline(path, options) {
   const tol = options.tolerance && options.tolerance > 0 ? options.tolerance : 0.05;
   let polygons;
   try {
-    polygons = _chunkVNYRI265cjs.polygonBoolean.call(void 0, "union", [{ rings: pieces, fillRule: "nonzero" }]);
+    polygons = _chunkYNSK4MGTcjs.polygonBoolean.call(void 0, "union", [{ rings: pieces, fillRule: "nonzero" }]);
   } catch (e3) {
     return [];
   }
@@ -1567,11 +1567,11 @@ function variableStrokeOutline(path, options) {
   for (const polygon2 of polygons) {
     for (const ring of polygon2) {
       if (ring.length < 3) continue;
-      const cubics = _chunkVNYRI265cjs.fitCubics.call(void 0, ring, tol, { closed: true, cornerAngleDeg: 25 });
+      const cubics = _chunkYNSK4MGTcjs.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 (_chunkVNYRI265cjs.isStraightCubic.call(void 0, c, tol * 0.02)) {
+        if (_chunkYNSK4MGTcjs.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] });
       });
@@ -1582,17 +1582,17 @@ function variableStrokeOutline(path, options) {
 }
 function nearestStrokePosition(path, p, only) {
   let best = null;
-  _chunkVNYRI265cjs.pathToContours.call(void 0, path).forEach((c, ci) => {
+  _chunkYNSK4MGTcjs.pathToContours.call(void 0, path).forEach((c, ci) => {
     if (!c.segments.length || only !== void 0 && ci !== only) return;
-    const lengths = c.segments.map((s) => _chunkVNYRI265cjs.segmentLength.call(void 0, s));
+    const lengths = c.segments.map((s) => _chunkYNSK4MGTcjs.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 = _chunkVNYRI265cjs.segmentNearest.call(void 0, seg, p);
+      const near2 = _chunkYNSK4MGTcjs.segmentNearest.call(void 0, seg, p);
       if (!best || near2.distance < best.distance) {
-        const s = acc + _chunkVNYRI265cjs.segmentLength.call(void 0, seg, 0, near2.t);
-        const tan = _chunkVNYRI265cjs.segmentTangent.call(void 0, seg, near2.t);
+        const s = acc + _chunkYNSK4MGTcjs.segmentLength.call(void 0, seg, 0, near2.t);
+        const tan = _chunkYNSK4MGTcjs.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";
@@ -1609,9 +1609,9 @@ function evalSeg(seg, t) {
   return pts[0];
 }
 function strokePositionPoint(path, index, t) {
-  const c = _chunkVNYRI265cjs.pathToContours.call(void 0, path)[index];
+  const c = _chunkYNSK4MGTcjs.pathToContours.call(void 0, path)[index];
   if (!_optionalChain([c, 'optionalAccess', _32 => _32.segments, 'access', _33 => _33.length])) return null;
-  const lengths = c.segments.map((s) => _chunkVNYRI265cjs.segmentLength.call(void 0, s));
+  const lengths = c.segments.map((s) => _chunkYNSK4MGTcjs.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++) {
@@ -1622,11 +1622,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 (_chunkVNYRI265cjs.segmentLength.call(void 0, seg, 0, mid) < target) lo = mid;
+        if (_chunkYNSK4MGTcjs.segmentLength.call(void 0, seg, 0, mid) < target) lo = mid;
         else hi = mid;
       }
       const u = (lo + hi) / 2;
-      const tan = _chunkVNYRI265cjs.segmentTangent.call(void 0, seg, u);
+      const tan = _chunkYNSK4MGTcjs.segmentTangent.call(void 0, seg, u);
       return { point: evalSeg(seg, u), tangent: [tan[0], tan[1]] };
     }
     want -= lengths[i];
@@ -1638,7 +1638,7 @@ function strokePositionPoint(path, index, t) {
 var KAPPA = 0.5522847498307936;
 var NOTCH = 0.7;
 function isClosedBezierShape(path) {
-  const contours = _chunkVNYRI265cjs.pathToContours.call(void 0, path).filter((c) => c.segments.length > 0);
+  const contours = _chunkYNSK4MGTcjs.pathToContours.call(void 0, path).filter((c) => c.segments.length > 0);
   return contours.length > 0 && contours.every((c) => c.closed);
 }
 function effectiveStrokeAlign(style, closedShape) {
@@ -1659,7 +1659,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 _chunkVNYRI265cjs.outlineStroke.call(void 0, parts.line, { width: parts.drawWidth, join, cap, ...dash, ...tolerance ? { tolerance } : {} });
+  return _chunkYNSK4MGTcjs.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) {
@@ -1740,16 +1740,16 @@ function arrowheadPath(kind, tip, dir, hw) {
   }
 }
 var toVec = (p) => ({ x: p[0], y: p[1] });
-var segLen = (s) => _chunkVNYRI265cjs.segmentLength.call(void 0, s);
+var segLen = (s) => _chunkYNSK4MGTcjs.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 = _chunkVNYRI265cjs.segmentTangent.call(void 0, s2, 0);
+    const t2 = _chunkYNSK4MGTcjs.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 = _chunkVNYRI265cjs.segmentTangent.call(void 0, s, 1);
+  const t = _chunkYNSK4MGTcjs.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]) };
 }
@@ -1760,7 +1760,7 @@ function pointAlong(segs, fromStart, dist5) {
     const l = segLen(s);
     if (acc + l >= dist5) {
       const want = fromStart ? dist5 - acc : l - (dist5 - acc);
-      const pts = _chunkVNYRI265cjs.trimSegments.call(void 0, [s], 0, want);
+      const pts = _chunkYNSK4MGTcjs.trimSegments.call(void 0, [s], 0, want);
       const p = pts.length ? pts[0][pts[0].length - 1] : s[0];
       return toVec(p);
     }
@@ -1770,7 +1770,7 @@ function pointAlong(segs, fromStart, dist5) {
 }
 function vectorStrokeParts(path, style) {
   const width = _nullishCoalesce(style.strokeWidth, () => ( 1));
-  const contours = _chunkVNYRI265cjs.pathToContours.call(void 0, path).filter((c) => c.segments.length > 0);
+  const contours = _chunkYNSK4MGTcjs.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;
@@ -1810,26 +1810,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 ? _chunkVNYRI265cjs.trimSegments.call(void 0, c.segments, s0, total - s1, lengths) : [] };
+    return { closed: false, segments: total - s1 > s0 ? _chunkYNSK4MGTcjs.trimSegments.call(void 0, c.segments, s0, total - s1, lengths) : [] };
   });
-  return { align, line: _chunkVNYRI265cjs.contoursToPath.call(void 0, trimmed), drawWidth, heads };
+  return { align, line: _chunkYNSK4MGTcjs.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 = _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.align === "inside") area = _chunkYNSK4MGTcjs.pathBoolean.call(void 0, "intersection", [stroke, fill]).path;
+  else if (parts.align === "outside") area = _chunkYNSK4MGTcjs.pathBoolean.call(void 0, "difference", [stroke, fill]).path;
   if (!parts.heads.length) return area;
-  return _chunkVNYRI265cjs.pathBoolean.call(void 0, "union", [area, ...parts.heads.map((h) => h.path)]).path;
+  return _chunkYNSK4MGTcjs.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 (_chunkVNYRI265cjs.pointInBezierPath.call(void 0, h.path, point) || tolerance > 0 && _chunkVNYRI265cjs.distanceToBezierPath.call(void 0, h.path, point) <= tolerance) return true;
+    if (_chunkYNSK4MGTcjs.pointInBezierPath.call(void 0, h.path, point) || tolerance > 0 && _chunkYNSK4MGTcjs.distanceToBezierPath.call(void 0, h.path, point) <= tolerance) return true;
   }
   if (!parts.line.length) return false;
   const profile = strokeWidthProfileOf(style);
@@ -1847,13 +1847,13 @@ function hitTestVectorStroke(path, p, style, tolerance = 0) {
       reach = Math.max(reach, width / 2 * (w.left + w.right) / 2);
     }
   } else {
-    d = _chunkVNYRI265cjs.distanceToBezierPath.call(void 0, parts.line, point);
+    d = _chunkYNSK4MGTcjs.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 = _chunkVNYRI265cjs.pointInBezierPath.call(void 0, path, point, _nullishCoalesce(style.fillRule, () => ( "nonzero")));
+  const inside = _chunkYNSK4MGTcjs.pointInBezierPath.call(void 0, path, point, _nullishCoalesce(style.fillRule, () => ( "nonzero")));
   return parts.align === "inside" ? inside : !inside;
 }
 function vectorStrokeReach(style) {
@@ -1876,9 +1876,9 @@ function raise(seg) {
   return [p0, [p0[0] + 2 / 3 * (p1[0] - p0[0]), p0[1] + 2 / 3 * (p1[1] - p0[1])], [p2[0] + 2 / 3 * (p1[0] - p2[0]), p2[1] + 2 / 3 * (p1[1] - p2[1])], p2];
 }
 function subsOf(path) {
-  return _chunkVNYRI265cjs.pathToContours.call(void 0, path).map((c) => ({ segs: _chunkVNYRI265cjs.closeContour.call(void 0, c).filter((s) => !degenerate(s)).map(raise), closed: c.closed })).filter((s) => s.segs.length > 0);
+  return _chunkYNSK4MGTcjs.pathToContours.call(void 0, path).map((c) => ({ segs: _chunkYNSK4MGTcjs.closeContour.call(void 0, c).filter((s) => !degenerate(s)).map(raise), closed: c.closed })).filter((s) => s.segs.length > 0);
 }
-var subsToPath = (subs) => _chunkVNYRI265cjs.contoursToPath.call(void 0, subs.map((s) => ({ segments: s.segs, closed: s.closed })));
+var subsToPath = (subs) => _chunkYNSK4MGTcjs.contoursToPath.call(void 0, subs.map((s) => ({ segments: s.segs, closed: s.closed })));
 var unit2 = (x, y) => {
   const l = Math.hypot(x, y);
   return l > 1e-12 && Number.isFinite(l) ? [x / l, y / l] : null;
@@ -1901,13 +1901,13 @@ function endTangent(s) {
 function tangentAt(s, t) {
   if (t <= 1e-9) return startTangent(s);
   if (t >= 1 - 1e-9) return endTangent(s);
-  const d = _chunkVNYRI265cjs.segmentDerivative.call(void 0, s, t);
+  const d = _chunkYNSK4MGTcjs.segmentDerivative.call(void 0, s, t);
   return _nullishCoalesce(unit2(d[0], d[1]), () => ( startTangent(s)));
 }
 var perp2 = (v2) => [-v2[1], v2[0]];
 function effectPathLength(path) {
   let total = 0;
-  for (const s of subsOf(path)) for (const seg of s.segs) total += _chunkVNYRI265cjs.segmentLength.call(void 0, seg);
+  for (const s of subsOf(path)) for (const seg of s.segs) total += _chunkYNSK4MGTcjs.segmentLength.call(void 0, seg);
   return total;
 }
 function effectPathVertexCount(path) {
@@ -1919,7 +1919,7 @@ var Measured = class {
   
   constructor(path) {
     this.segs = subsOf(path).flatMap((s) => s.segs);
-    this.lens = this.segs.map((s) => _chunkVNYRI265cjs.segmentLength.call(void 0, s));
+    this.lens = this.segs.map((s) => _chunkYNSK4MGTcjs.segmentLength.call(void 0, s));
     this.total = this.lens.reduce((a, b) => a + b, 0);
   }
   /**
@@ -1927,7 +1927,7 @@ var Measured = class {
    * starts where it ends (across the start of a closed path).
    */
   append(sa, sb, out) {
-    for (const piece of _chunkVNYRI265cjs.trimSegments.call(void 0, this.segs, sa, sb, this.lens)) {
+    for (const piece of _chunkYNSK4MGTcjs.trimSegments.call(void 0, this.segs, sa, sb, this.lens)) {
       if (degenerate(piece)) continue;
       const last = _optionalChain([out, 'access', _38 => _38[out.length - 1], 'optionalAccess', _39 => _39.segs]);
       const end = _optionalChain([last, 'optionalAccess', _40 => _40[last.length - 1], 'optionalAccess', _41 => _41.at, 'call', _42 => _42(-1)]);
@@ -2042,7 +2042,7 @@ function offsetPaths(paths, amount, join = "miter", miterLimit = 4, copies = 1,
   const n = Math.min(1e3, Math.max(1, Math.round(Number.isFinite(copies) ? copies : 1)));
   return paths.map((p) => {
     const out = [];
-    for (let i = 0; i < n; i++) out.push(..._chunkVNYRI265cjs.offsetPath.call(void 0, p, amount * (i + 1 + copyOffset), { join, miterLimit }));
+    for (let i = 0; i < n; i++) out.push(..._chunkYNSK4MGTcjs.offsetPath.call(void 0, p, amount * (i + 1 + copyOffset), { join, miterLimit }));
     return out;
   });
 }
@@ -2078,10 +2078,10 @@ function twistPaths(paths, angle, center) {
       const segs = [];
       for (const seg of sub5.segs) {
         const cubic = seg.length === 2 ? [seg[0], seg[0], seg[1], seg[1]] : seg;
-        const len2 = _chunkVNYRI265cjs.segmentLength.call(void 0, seg);
+        const len2 = _chunkYNSK4MGTcjs.segmentLength.call(void 0, seg);
         const m = Math.min(64, Math.max(1, Math.ceil(Math.abs(a) * len2 / rmax / 0.15 + len2 / 50)));
         for (let i = 0; i < m; i++) {
-          const q = _chunkVNYRI265cjs.subSegment.call(void 0, cubic, i / m, (i + 1) / m);
+          const q = _chunkYNSK4MGTcjs.subSegment.call(void 0, cubic, i / m, (i + 1) / m);
           const p0 = map(q[0]);
           const p3 = map(q[3]);
           const h1 = jac(q[0], [q[1][0] - q[0][0], q[1][1] - q[0][1]]);
@@ -2097,7 +2097,7 @@ function twistPaths(paths, angle, center) {
 function resample(sub5, m) {
   const segs = sub5.segs;
   const n = segs.length;
-  const lens = segs.map((s) => _chunkVNYRI265cjs.segmentLength.call(void 0, s));
+  const lens = segs.map((s) => _chunkYNSK4MGTcjs.segmentLength.call(void 0, s));
   const out = [];
   for (let j = 0; j < n; j++) {
     const piece = lens[j] / m;
@@ -2112,8 +2112,8 @@ function resample(sub5, m) {
         }
         out.push({ p: segs[j][0], tan, lenPrev: prev === null ? 0 : lens[prev] / m, lenNext: piece });
       } else {
-        const t = _chunkVNYRI265cjs.segmentParamAtLength.call(void 0, segs[j], piece * k, lens[j]);
-        out.push({ p: _chunkVNYRI265cjs.segmentPoint.call(void 0, segs[j], t), tan: tangentAt(segs[j], t), lenPrev: piece, lenNext: piece });
+        const t = _chunkYNSK4MGTcjs.segmentParamAtLength.call(void 0, segs[j], piece * k, lens[j]);
+        out.push({ p: _chunkYNSK4MGTcjs.segmentPoint.call(void 0, segs[j], t), tan: tangentAt(segs[j], t), lenPrev: piece, lenNext: piece });
       }
     }
   }
@@ -2211,7 +2211,7 @@ function mergePaths(paths, mode = "merge") {
   if (mode === "merge" || !(mode in MERGE_OPS)) return paths.flat();
   const inputs = paths.filter((p) => p.length > 0).map((path) => ({ path, fillRule: "nonzero" }));
   if (!inputs.length) return [];
-  return _chunkVNYRI265cjs.pathBoolean.call(void 0, MERGE_OPS[mode], inputs).path;
+  return _chunkYNSK4MGTcjs.pathBoolean.call(void 0, MERGE_OPS[mode], inputs).path;
 }
 function vectorRepeaterCopies(r, pivot) {
   const copies = Math.max(0, Number.isFinite(r.copies) ? Math.min(r.copies, 1e3) : 0);
@@ -2234,10 +2234,10 @@ function vectorRepeaterCopies(r, pivot) {
   return out;
 }
 function repeatPaths(paths, r, pivot) {
-  return vectorRepeaterCopies(r, pivot).map((copy) => ({ copy, paths: paths.map((p) => _chunkVNYRI265cjs.transformBezierPath.call(void 0, p, copy.matrix)) }));
+  return vectorRepeaterCopies(r, pivot).map((copy) => ({ copy, paths: paths.map((p) => _chunkYNSK4MGTcjs.transformBezierPath.call(void 0, p, copy.matrix)) }));
 }
 function pathsCenter(paths) {
-  const b = _chunkVNYRI265cjs.bezierPathBounds.call(void 0, paths.flat());
+  const b = _chunkYNSK4MGTcjs.bezierPathBounds.call(void 0, paths.flat());
   return b ? { x: (b.minX + b.maxX) / 2, y: (b.minY + b.maxY) / 2 } : { x: 0, y: 0 };
 }
 
@@ -2306,13 +2306,13 @@ function refit(seg, pieces, f, tol) {
   const last = pieces[pieces.length - 1];
   const t0 = !same(first[1], first[0]) ? first[1] : first[2];
   const t1 = !same(last[2], last[3]) ? last[2] : last[1];
-  const fitted = _chunkVNYRI265cjs.fitCubicRun.call(void 0, samples, tol / 2, [t0.x - first[0].x, t0.y - first[0].y], [last[3].x - t1.x, last[3].y - t1.y]);
+  const fitted = _chunkYNSK4MGTcjs.fitCubicRun.call(void 0, samples, tol / 2, [t0.x - first[0].x, t0.y - first[0].y], [last[3].x - t1.x, last[3].y - t1.y]);
   if (!fitted.length || fitted.length >= pieces.length) return pieces;
   const chain = fitted.map((c) => [c.p0, c.p1, c.p2, c.p3]);
   for (let i = 0; i < n; i++) {
     const q = toPoint(f(evalCubic(seg, (i + 0.5) / n)));
     let best = Infinity;
-    for (const c of chain) best = Math.min(best, _chunkVNYRI265cjs.segmentNearest.call(void 0, c, q).distance);
+    for (const c of chain) best = Math.min(best, _chunkYNSK4MGTcjs.segmentNearest.call(void 0, c, q).distance);
     if (best > tol) return pieces;
   }
   return fitted.map((c) => [toVec2(c.p0), toVec2(c.p1), toVec2(c.p2), toVec2(c.p3)]);
@@ -3243,7 +3243,7 @@ function pathsBounds(paths) {
   let maxX = -Infinity;
   let maxY = -Infinity;
   for (const p of paths) {
-    const b = _chunkVNYRI265cjs.bezierPathBounds.call(void 0, p);
+    const b = _chunkYNSK4MGTcjs.bezierPathBounds.call(void 0, p);
     if (!b) continue;
     minX = Math.min(minX, b.minX);
     minY = Math.min(minY, b.minY);
@@ -3409,7 +3409,7 @@ function foldVectorBooleanOperands(operands) {
   for (let i = start + 1; i < operands.length; i++) {
     const o = operands[i];
     foldSteps++;
-    const r = _chunkVNYRI265cjs.pathBoolean.call(void 0, _nullishCoalesce(PATH_OPS[o.operation], () => ( "union")), [
+    const r = _chunkYNSK4MGTcjs.pathBoolean.call(void 0, _nullishCoalesce(PATH_OPS[o.operation], () => ( "union")), [
       { path: acc, fillRule: accRule },
       { path: o.path, fillRule: o.fillRule }
     ]);
@@ -3496,7 +3496,7 @@ function childShapes(child, index) {
   const k = _nullishCoalesce(child.opacity, () => ( 1));
   return vectorAppearanceShapes(child).map((s) => ({
     source: s.source,
-    path: m && !isIdentityMatrix(m) ? _chunkVNYRI265cjs.transformBezierPath.call(void 0, s.path, m) : s.path,
+    path: m && !isIdentityMatrix(m) ? _chunkYNSK4MGTcjs.transformBezierPath.call(void 0, s.path, m) : s.path,
     opacity: s.opacity * k,
     order: [index, ...s.order]
   }));
@@ -3508,7 +3508,7 @@ function liveBooleanShapes(group) {
     const shapes = childShapes(child, i);
     if (!shapes.length) return;
     source ??= shapes[0].source;
-    const path = shapes.length === 1 ? shapes[0].path : _chunkVNYRI265cjs.pathBoolean.call(void 0, "union", shapes.map((s) => ({ path: s.path, fillRule: _nullishCoalesce(s.source.fillRule, () => ( "nonzero")) }))).path;
+    const path = shapes.length === 1 ? shapes[0].path : _chunkYNSK4MGTcjs.pathBoolean.call(void 0, "union", shapes.map((s) => ({ path: s.path, fillRule: _nullishCoalesce(s.source.fillRule, () => ( "nonzero")) }))).path;
     const fillRule = shapes.length === 1 ? _nullishCoalesce(shapes[0].source.fillRule, () => ( "nonzero")) : "nonzero";
     operands.push({ path, fillRule, operation: vectorOperandOperation(group, child) });
   });
@@ -3740,7 +3740,7 @@ function vectorNodeToBezier(node) {
 }
 function vectorPathData(input, precision = 3) {
   const subpaths = Array.isArray(input) ? input : input.subpaths;
-  return _chunkVNYRI265cjs.bezierPathToSvg.call(void 0, subpathsToBezier(subpaths), { precision });
+  return _chunkYNSK4MGTcjs.bezierPathToSvg.call(void 0, subpathsToBezier(subpaths), { precision });
 }
 function inferAnchorType(a) {
   if (isOnAnchor(a, a.in) || isOnAnchor(a, a.out)) return "corner";
@@ -3756,7 +3756,7 @@ function inferAnchorType(a) {
   return Math.abs(li - lo) <= 1e-3 * Math.max(li, lo) ? "symmetric" : "smooth";
 }
 function bezierToSubpaths(input) {
-  const path = _chunkVNYRI265cjs.toBezierPath.call(void 0, input);
+  const path = _chunkYNSK4MGTcjs.toBezierPath.call(void 0, input);
   const out = [];
   let current = null;
   const last = () => current.anchors[current.anchors.length - 1];
@@ -3853,7 +3853,7 @@ function nodeMatrix(node) {
 function vectorPathWorldBezier(node, parent = IDENTITY_MATRIX, options = {}) {
   const m = multiplyMatrices(nodeMatrix(node), parent);
   const path = options.effects === false || !hasOwnVectorAppearance(node) ? subpathsToBezier(node.subpaths) : vectorAppearanceOutline(node);
-  return isIdentityMatrix(m) ? path : _chunkVNYRI265cjs.transformBezierPath.call(void 0, path, m);
+  return isIdentityMatrix(m) ? path : _chunkYNSK4MGTcjs.transformBezierPath.call(void 0, path, m);
 }
 function vectorNodeBounds(node, parent = IDENTITY_MATRIX) {
   node = expandVectorAppearance(node);
@@ -3861,7 +3861,7 @@ function vectorNodeBounds(node, parent = IDENTITY_MATRIX) {
     const m = multiplyMatrices(nodeMatrix(node), parent);
     return unionBounds(node.children.map((c) => vectorNodeBounds(c, m)));
   }
-  const b = _chunkVNYRI265cjs.bezierPathBounds.call(void 0, vectorPathWorldBezier(node, parent));
+  const b = _chunkYNSK4MGTcjs.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 };
 }
@@ -3896,9 +3896,9 @@ function hitTestVectorNode(node, p, tolerance = 0, parent = IDENTITY_MATRIX, opt
   const path = vectorPathWorldBezier(node, parent);
   if (path.length === 0) return false;
   const point = [p.x, p.y];
-  if (hasPaint(node.fill) && _chunkVNYRI265cjs.pointInBezierPath.call(void 0, path, point, _nullishCoalesce(node.fillRule, () => ( "nonzero")))) return true;
+  if (hasPaint(node.fill) && _chunkYNSK4MGTcjs.pointInBezierPath.call(void 0, path, point, _nullishCoalesce(node.fillRule, () => ( "nonzero")))) return true;
   if (hasPaint(node.stroke)) return hitTestVectorStroke(path, p, node, tolerance);
-  return _chunkVNYRI265cjs.distanceToBezierPath.call(void 0, path, point) <= tolerance;
+  return _chunkYNSK4MGTcjs.distanceToBezierPath.call(void 0, path, point) <= tolerance;
 }
 function vectorStrokeOutline(node, parent = IDENTITY_MATRIX) {
   if (!hasPaint(node.stroke) || !((_nullishCoalesce(node.strokeWidth, () => ( 1))) > 0)) return [];
@@ -3918,9 +3918,9 @@ function nearestSegment(node, p) {
     const count = subpathSegmentCount(sp);
     for (let i = 0; i < count; i++) {
       const seg = subpathSegment(sp, i);
-      const hit = _chunkVNYRI265cjs.segmentNearest.call(void 0, seg, [p.x, p.y]);
+      const hit = _chunkYNSK4MGTcjs.segmentNearest.call(void 0, seg, [p.x, p.y]);
       if (!best || hit.distance < best.distance) {
-        const pt2 = _chunkVNYRI265cjs.segmentPoint.call(void 0, seg, hit.t);
+        const pt2 = _chunkYNSK4MGTcjs.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 };
       }
     }
@@ -4106,7 +4106,7 @@ function insertAnchor(sp, segment, t) {
   const ia = segment;
   const ib = (segment + 1) % n;
   const seg = subpathSegment(sp, segment);
-  const [left2, right] = _chunkVNYRI265cjs.splitSegment.call(void 0, seg, t);
+  const [left2, right] = _chunkYNSK4MGTcjs.splitSegment.call(void 0, seg, t);
   const mid = left2[left2.length - 1];
   const anchor = { x: mid[0], y: mid[1] };
   if (seg.length === 4) {
@@ -4217,10 +4217,10 @@ var unit3 = (v2) => {
 };
 function flattenedSubpaths(node) {
   const out = [];
-  for (const contour of _chunkVNYRI265cjs.pathToContours.call(void 0, subpathsToBezier(node.subpaths))) {
-    const segs = _chunkVNYRI265cjs.closeContour.call(void 0, contour);
+  for (const contour of _chunkYNSK4MGTcjs.pathToContours.call(void 0, subpathsToBezier(node.subpaths))) {
+    const segs = _chunkYNSK4MGTcjs.closeContour.call(void 0, contour);
     if (!segs.length) continue;
-    const ring = _chunkVNYRI265cjs.flattenChain.call(void 0, segs, TOLERANCE);
+    const ring = _chunkYNSK4MGTcjs.flattenChain.call(void 0, segs, TOLERANCE);
     const pts = ring.map(([x, y]) => ({ x, y })).filter((p, i, a) => i === 0 || Math.hypot(p.x - a[i - 1].x, p.y - a[i - 1].y) > 1e-9);
     if (contour.closed && pts.length > 2 && Math.hypot(pts[0].x - pts[pts.length - 1].x, pts[0].y - pts[pts.length - 1].y) < 1e-9) pts.pop();
     if (pts.length >= 2) out.push({ pts, closed: contour.closed && pts.length > 2 });
@@ -4362,7 +4362,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}:${_chunkVNYRI265cjs.formatNumber.call(void 0, a.corner.radius, precision)}${a.corner.kind && a.corner.kind !== "round" ? `:${a.corner.kind}` : ""}`);
+      out.push(`${s}.${i}:${_chunkYNSK4MGTcjs.formatNumber.call(void 0, a.corner.radius, precision)}${a.corner.kind && a.corner.kind !== "round" ? `:${a.corner.kind}` : ""}`);
     })
   );
   return out.join(" ");
@@ -4381,7 +4381,7 @@ function applyVectorCornersAttribute(subpaths, value) {
 }
 var escapeAttr = (value) => value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 function vectorPathLocalBounds(node) {
-  const b = _chunkVNYRI265cjs.bezierPathBounds.call(void 0, subpathsToBezier(node.subpaths));
+  const b = _chunkYNSK4MGTcjs.bezierPathBounds.call(void 0, subpathsToBezier(node.subpaths));
   return b ? { x: b.minX, y: b.minY, width: b.maxX - b.minX, height: b.maxY - b.minY } : null;
 }
 var paintCache = /* @__PURE__ */ new WeakMap();
@@ -4421,22 +4421,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 = _chunkVNYRI265cjs.bezierPathBounds.call(void 0, path);
+    const b = _chunkYNSK4MGTcjs.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: _chunkVNYRI265cjs.bezierPathToSvg.call(void 0, parts.line, { precision }),
+    d: _chunkYNSK4MGTcjs.bezierPathToSvg.call(void 0, parts.line, { precision }),
     width: parts.drawWidth,
-    ...profiled && (_nullishCoalesce(node.strokeWidth, () => ( 1))) > 0 ? { outline: _chunkVNYRI265cjs.bezierPathToSvg.call(void 0, vectorStrokeLineArea(parts, node), { precision }) } : {},
+    ...profiled && (_nullishCoalesce(node.strokeWidth, () => ( 1))) > 0 ? { outline: _chunkYNSK4MGTcjs.bezierPathToSvg.call(void 0, vectorStrokeLineArea(parts, node), { precision }) } : {},
     clip,
-    heads: parts.heads.map((h) => _chunkVNYRI265cjs.bezierPathToSvg.call(void 0, h.path, { precision }))
+    heads: parts.heads.map((h) => _chunkYNSK4MGTcjs.bezierPathToSvg.call(void 0, h.path, { precision }))
   };
 }
 function widthProfileToAttribute(points, precision = 4) {
-  return points.map((p) => [p.t, p.left, p.right].map((n) => _chunkVNYRI265cjs.formatNumber.call(void 0, n, precision)).join(",")).join(";");
+  return points.map((p) => [p.t, p.left, p.right].map((n) => _chunkYNSK4MGTcjs.formatNumber.call(void 0, n, precision)).join(",")).join(";");
 }
 function widthProfileFromAttribute(value) {
   if (!value) return [];
@@ -4495,11 +4495,11 @@ function vectorDocumentToSvg(doc, options = {}) {
   const pretty = options.pretty !== false;
   const defs = [];
   const lines = [];
-  const num2 = (n) => _chunkVNYRI265cjs.formatNumber.call(void 0, n, precision);
+  const num2 = (n) => _chunkYNSK4MGTcjs.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) => _chunkVNYRI265cjs.formatNumber.call(void 0, n, 6)).join(" ")})"`;
+    if (node.transform) out2 += ` transform="matrix(${node.transform.map((n) => _chunkYNSK4MGTcjs.formatNumber.call(void 0, n, 6)).join(" ")})"`;
     if (node.opacity !== void 0 && node.opacity < 1) out2 += ` opacity="${num2(node.opacity)}"`;
     if (node.visible === false) out2 += ` display="none"`;
     if (node.blendStep) out2 += ` data-vector-blend-step=""`;
@@ -4539,7 +4539,7 @@ function vectorDocumentToSvg(doc, options = {}) {
     defs.push(...paintMarkup(node.fill, fill.defs), ...paintMarkup(node.stroke, stroke.defs));
     const d = vectorPathData(node, precision);
     const corners2 = vectorCornersAttribute(node.subpaths, precision);
-    const live = corners2 ? ` data-vector-d="${_chunkVNYRI265cjs.bezierPathToSvg.call(void 0, subpathsToBezier(node.subpaths, { corners: false }), { precision })}" data-vector-corners="${corners2}"` : "";
+    const live = corners2 ? ` data-vector-d="${_chunkYNSK4MGTcjs.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="${num2(width)}"`;
@@ -4570,7 +4570,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 = _chunkVNYRI265cjs.bezierPathToSvg.call(void 0, vectorStrokeOutlinePath(subpathsToBezier(node.subpaths), node), { precision });
+      const area = _chunkYNSK4MGTcjs.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 = "";
@@ -4788,7 +4788,7 @@ function resolveGradient(id, raw) {
   const y2 = at2("y2", 0);
   if (!user && plain3) {
     const angle = Math.round((Math.atan2(x2 - x1, -(y2 - y1)) * 180 / Math.PI + 360) % 360);
-    const c = _chunkVNYRI265cjs.angleToSvgLinearCoords.call(void 0, angle);
+    const c = _chunkYNSK4MGTcjs.angleToSvgLinearCoords.call(void 0, angle);
     const len2 = Math.hypot(x2 - x1, y2 - y1);
     const d = len2 > 0 ? { x: (x2 - x1) / len2, y: (y2 - y1) / len2 } : { x: 0, y: 1 };
     const along2 = (x, y) => x * d.x + y * d.y;
@@ -5178,7 +5178,7 @@ function refineMorphContour(c, segments) {
   const identity = Array.from({ length: c.closed ? have : have + 1 }, (_, i) => i);
   if (have >= segments) return { contour: c, anchors: identity };
   const segs = Array.from({ length: have }, (_, k) => segOf(c, k));
-  const lens = segs.map((s) => _chunkVNYRI265cjs.segmentLength.call(void 0, s));
+  const lens = segs.map((s) => _chunkYNSK4MGTcjs.segmentLength.call(void 0, s));
   const sum = lens.reduce((a, b) => a + b, 0);
   const extra = segments - have;
   const want = lens.map((l) => sum > 1e-12 ? l / sum * extra : extra / have);
@@ -5195,9 +5195,9 @@ function refineMorphContour(c, segments) {
     let rest = seg.slice();
     let t0 = 0;
     for (let j = 1; j < pieces; j++) {
-      const t = _chunkVNYRI265cjs.segmentParamAtLength.call(void 0, seg, lens[k] * j / pieces, lens[k]);
+      const t = _chunkYNSK4MGTcjs.segmentParamAtLength.call(void 0, seg, lens[k] * j / pieces, lens[k]);
       const u = Math.min(1, Math.max(0, (t - t0) / (1 - t0 || 1)));
-      const [l, r] = _chunkVNYRI265cjs.splitSegment.call(void 0, rest, u);
+      const [l, r] = _chunkYNSK4MGTcjs.splitSegment.call(void 0, rest, u);
       pts.push(l[1], l[2], l[3]);
       rest = r;
       t0 = t;
@@ -5359,7 +5359,7 @@ function correspondMorphContours(a, b, options = {}) {
   const bb = boundsOfPoints(b.flatMap((c) => c.pts));
   const contourLength = (c) => {
     let l = 0;
-    for (let k = 0; k < curvesOf(c); k++) l += _chunkVNYRI265cjs.segmentLength.call(void 0, segOf(c, k));
+    for (let k = 0; k < curvesOf(c); k++) l += _chunkYNSK4MGTcjs.segmentLength.call(void 0, segOf(c, k));
     return l;
   };
   const pairs = [];
@@ -5868,8 +5868,8 @@ function vectorBlendRail(sp) {
   for (let i = 0; i < count; i++) {
     const seg = subpathSegment(sp, i);
     const samples = seg.length === 2 ? 1 : 32;
-    if (i === 0) push(seg[0], _chunkVNYRI265cjs.segmentTangent.call(void 0, seg, 0));
-    for (let k = 1; k <= samples; k++) push(_chunkVNYRI265cjs.segmentPoint.call(void 0, seg, k / samples), _chunkVNYRI265cjs.segmentTangent.call(void 0, seg, k / samples));
+    if (i === 0) push(seg[0], _chunkYNSK4MGTcjs.segmentTangent.call(void 0, seg, 0));
+    for (let k = 1; k <= samples; k++) push(_chunkYNSK4MGTcjs.segmentPoint.call(void 0, seg, k / samples), _chunkYNSK4MGTcjs.segmentTangent.call(void 0, seg, k / samples));
   }
   if (pts.length < 2) return null;
   const cum = [0];
@@ -6555,13 +6555,13 @@ var VectorSnapTargets = (_class3 = class _VectorSnapTargets {
     const pt2 = toPoint2(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 = _chunkVNYRI265cjs.segmentNearest.call(void 0, s.seg, pt2);
+      const hit = _chunkYNSK4MGTcjs.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 ? toVec3(_chunkVNYRI265cjs.segmentPoint.call(void 0, near2[0].seg, near2[0].t)) : null;
+    return near2.length ? toVec3(_chunkYNSK4MGTcjs.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) {
@@ -6570,7 +6570,7 @@ var VectorSnapTargets = (_class3 = 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 _chunkVNYRI265cjs.segmentIntersections.call(void 0, list[i].seg, list[j].seg)) {
+        for (const hit of _chunkYNSK4MGTcjs.segmentIntersections.call(void 0, list[i].seg, list[j].seg)) {
           const q = toVec3(hit.point);
           const d = distance(q, p);
           if (d <= tol && d < bestD) {
@@ -6892,15 +6892,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 = _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 p = _chunkYNSK4MGTcjs.segmentPoint.call(void 0, seg, t);
+    return cond([p[0] - b[0], p[1] - b[1]], _chunkYNSK4MGTcjs.segmentDerivative.call(void 0, seg, t));
   };
   const vals = [];
   let scale3 = 0;
   for (let i = 0; i <= CURVE_SAMPLES; i++) {
     const t = i / CURVE_SAMPLES;
-    const p = _chunkVNYRI265cjs.segmentPoint.call(void 0, seg, t);
-    const d = _chunkVNYRI265cjs.segmentDerivative.call(void 0, seg, t);
+    const p = _chunkYNSK4MGTcjs.segmentPoint.call(void 0, seg, t);
+    const d = _chunkYNSK4MGTcjs.segmentDerivative.call(void 0, seg, t);
     const r = [p[0] - b[0], p[1] - b[1]];
     vals.push(cond(r, d));
     scale3 = Math.max(scale3, Math.hypot(r[0], r[1]) * Math.hypot(d[0], d[1]));
@@ -6927,8 +6927,8 @@ function solveOnSegment(seg, base, cond) {
       } else hi = m;
     }
     const t = (lo + hi) / 2;
-    const p = _chunkVNYRI265cjs.segmentPoint.call(void 0, seg, t);
-    const dv = _chunkVNYRI265cjs.segmentDerivative.call(void 0, seg, t);
+    const p = _chunkYNSK4MGTcjs.segmentPoint.call(void 0, seg, t);
+    const dv = _chunkYNSK4MGTcjs.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;
@@ -6965,7 +6965,7 @@ function endTangent2(c) {
   return [1, 0];
 }
 function sample(c, n, out, withStart) {
-  for (let i = withStart ? 0 : 1; i <= n; i++) out.push(_chunkVNYRI265cjs.segmentPoint.call(void 0, c, i / n));
+  for (let i = withStart ? 0 : 1; i <= n; i++) out.push(_chunkYNSK4MGTcjs.segmentPoint.call(void 0, c, i / n));
 }
 var onAnchor2 = (a, h) => !h || Math.abs(h.x - a.x) < EPS4 && Math.abs(h.y - a.y) < EPS4;
 function tidy(a, keepType = true) {
@@ -7011,7 +7011,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 _chunkVNYRI265cjs.fitCubicWithTangents.call(void 0, pts, u, t0, t1);
+    return _chunkYNSK4MGTcjs.fitCubicWithTangents.call(void 0, pts, u, t0, t1);
   };
   return goldenMin(fit, 0, 1);
 }
@@ -7071,7 +7071,7 @@ function bendSegment(sp, segment, t, p) {
   return { anchors, closed: sp.closed };
 }
 function subpathPointAt(sp, segment, t) {
-  const [x, y] = _chunkVNYRI265cjs.segmentPoint.call(void 0, subpathSegment(sp, segment), t);
+  const [x, y] = _chunkYNSK4MGTcjs.segmentPoint.call(void 0, subpathSegment(sp, segment), t);
   return { x, y };
 }
 function curvatureMoveAnchor(sp, index, q) {
@@ -7332,12 +7332,12 @@ function removeRedundantPoints(sp, tolerance) {
 }
 
 // src/vector/pathCut.ts
-var loopArea = (l) => _chunkVNYRI265cjs.contourSignedArea.call(void 0, l.segs);
+var loopArea = (l) => _chunkYNSK4MGTcjs.contourSignedArea.call(void 0, l.segs);
 function loopSample(l) {
   const k = l.chord.findIndex((c) => !c);
-  return _chunkVNYRI265cjs.segmentPoint.call(void 0, l.segs[k >= 0 ? k : 0], 0.5);
+  return _chunkYNSK4MGTcjs.segmentPoint.call(void 0, l.segs[k >= 0 ? k : 0], 0.5);
 }
-var contains2 = (l, p) => _chunkVNYRI265cjs.windingNumber.call(void 0, [l.segs], p) !== 0;
+var contains2 = (l, p) => _chunkYNSK4MGTcjs.windingNumber.call(void 0, [l.segs], p) !== 0;
 function groupFaces(loops) {
   const usable2 = loops.filter((l) => l.segs.length && Math.abs(loopArea(l)) > 1e-12);
   if (!usable2.length) return [];
@@ -7353,12 +7353,12 @@ function groupFaces(loops) {
   return outers.reverse().map((o) => faces.get(o));
 }
 function faceToPath(face) {
-  return _chunkVNYRI265cjs.contoursToPath.call(void 0, face.loops.map((l) => ({ segments: l.segs, closed: true })));
+  return _chunkYNSK4MGTcjs.contoursToPath.call(void 0, face.loops.map((l) => ({ segments: l.segs, closed: true })));
 }
 function facesOf(path, fillRule) {
-  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());
+  const normalized = _chunkYNSK4MGTcjs.normalizeBezierPath.call(void 0, path, fillRule);
+  const loops = _chunkYNSK4MGTcjs.pathToContours.call(void 0, normalized).map((c) => {
+    const segs = _chunkYNSK4MGTcjs.closeContour.call(void 0, c, true).map((s) => s.slice());
     return { segs, chord: segs.map(() => false) };
   });
   return groupFaces(loops);
@@ -7428,7 +7428,7 @@ function lineHits(p, q, seg) {
   const scale3 = 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, scale3)) {
-    const point = _chunkVNYRI265cjs.segmentPoint.call(void 0, seg, t);
+    const point = _chunkYNSK4MGTcjs.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 });
   }
@@ -7441,7 +7441,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() : _chunkVNYRI265cjs.subSegment.call(void 0, l.segs[k], t0, t1);
+    const piece = t0 <= 0 && t1 >= 1 ? l.segs[k].slice() : _chunkYNSK4MGTcjs.subSegment.call(void 0, l.segs[k], t0, t1);
     if (!degenerate2(piece, eps)) {
       segs.push(piece);
       chord.push(l.chord[k]);
@@ -7466,7 +7466,7 @@ function knifePath(path, fillRule, knife) {
   if (pts.length < 2) return null;
   let faces = facesOf(path, fillRule);
   if (!faces.length) return null;
-  const b = _chunkVNYRI265cjs.bezierPathBounds.call(void 0, path);
+  const b = _chunkYNSK4MGTcjs.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;
@@ -7480,7 +7480,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 = _chunkVNYRI265cjs.segmentBounds.call(void 0, seg);
+            const sb = _chunkYNSK4MGTcjs.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;
@@ -7495,7 +7495,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 _chunkVNYRI265cjs.windingNumber.call(void 0, face2.loops.map((l) => l.segs), q) !== 0;
+        return _chunkYNSK4MGTcjs.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];
@@ -7555,33 +7555,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 _chunkVNYRI265cjs.outlineStroke.call(void 0, line2, { width, cap: "round", join: "round" });
+  return _chunkYNSK4MGTcjs.outlineStroke.call(void 0, line2, { width, cap: "round", join: "round" });
 }
 function eraseFromFill(path, fillRule, region) {
-  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;
+  const overlap = _chunkYNSK4MGTcjs.pathBoolean.call(void 0, "intersection", [{ path, fillRule }, { path: region }]).path;
+  if (!_chunkYNSK4MGTcjs.pathToContours.call(void 0, overlap).some((c) => Math.abs(_chunkYNSK4MGTcjs.contourSignedArea.call(void 0, _chunkYNSK4MGTcjs.closeContour.call(void 0, c, true))) > 1e-9)) return null;
+  const rest = _chunkYNSK4MGTcjs.pathBoolean.call(void 0, "difference", [{ path, fillRule }, { path: region }]).path;
   return splitIntoFaces(rest);
 }
 function eraseFromOutline(sp, region) {
-  const regionSegs = _chunkVNYRI265cjs.pathToContours.call(void 0, region).flatMap((c) => _chunkVNYRI265cjs.closeContour.call(void 0, c, true));
+  const regionSegs = _chunkYNSK4MGTcjs.pathToContours.call(void 0, region).flatMap((c) => _chunkYNSK4MGTcjs.closeContour.call(void 0, c, true));
   if (!regionSegs.length) return null;
-  const rb = _chunkVNYRI265cjs.bezierPathBounds.call(void 0, region);
+  const rb = _chunkYNSK4MGTcjs.bezierPathBounds.call(void 0, region);
   const count = subpathSegmentCount(sp);
   if (!rb || count === 0) return null;
-  const removed = (p) => _chunkVNYRI265cjs.pointInBezierPath.call(void 0, region, p, "nonzero");
+  const removed = (p) => _chunkYNSK4MGTcjs.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 = _chunkVNYRI265cjs.segmentBounds.call(void 0, seg);
+    const sb = _chunkYNSK4MGTcjs.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 = _chunkVNYRI265cjs.segmentBounds.call(void 0, r);
+        const b = _chunkYNSK4MGTcjs.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 _chunkVNYRI265cjs.segmentIntersections.call(void 0, seg, r)) if (hit.ta > 1e-9 && hit.ta < 1 - 1e-9) ts.push(hit.ta);
+        for (const hit of _chunkYNSK4MGTcjs.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);
@@ -7589,7 +7589,7 @@ function eraseFromOutline(sp, region) {
       const t0 = ts[k];
       const t1 = ts[k + 1];
       if (t1 - t0 < 1e-9) continue;
-      if (removed(_chunkVNYRI265cjs.segmentPoint.call(void 0, seg, (t0 + t1) / 2))) {
+      if (removed(_chunkYNSK4MGTcjs.segmentPoint.call(void 0, seg, (t0 + t1) / 2))) {
         any = true;
         if (cur.length) runs.push(cur);
         cur = [];
@@ -7608,7 +7608,7 @@ function eraseFromOutline(sp, region) {
   for (const run of runs) {
     const anchors = [];
     for (const { seg, t0, t1 } of run) {
-      const c = _chunkVNYRI265cjs.subSegment.call(void 0, subpathSegment(sp, seg), t0, t1);
+      const c = _chunkYNSK4MGTcjs.subSegment.call(void 0, subpathSegment(sp, seg), t0, t1);
       const line2 = c.length === 2;
       const start = c[0];
       const end = c[c.length - 1];
@@ -7917,14 +7917,14 @@ 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];
+  const contour = _chunkYNSK4MGTcjs.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 }]));
+  const segs = _chunkYNSK4MGTcjs.closeContour.call(void 0, contour, true);
+  const b = _chunkYNSK4MGTcjs.bezierPathBounds.call(void 0, _chunkYNSK4MGTcjs.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);
+  return Math.abs(_chunkYNSK4MGTcjs.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) {
@@ -7977,18 +7977,18 @@ function vectorShapeBuilderMap(entries) {
     lines.push(!subpaths.some((s) => s.closed));
     return { path: worldOf(entry, subpaths), fillRule: _nullishCoalesce(entry.node.fillRule, () => ( "nonzero")) };
   });
-  const map = _chunkVNYRI265cjs.PlanarMap.build(inputs);
+  const map = _chunkYNSK4MGTcjs.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 path = _chunkYNSK4MGTcjs.contoursToPath.call(void 0, [{ segments: c.segments, closed: c.closed }]);
+    return { path, segments: c.segments, closed: c.closed, source: c.source, bounds: _chunkYNSK4MGTcjs.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);
+    const b = _chunkYNSK4MGTcjs.bezierPathBounds.call(void 0, input.path);
     if (b) size = Math.max(size, b.maxX - b.minX, b.maxY - b.minY);
   }
   return {
@@ -8008,7 +8008,7 @@ function pieceNear(pieces, p, tol) {
   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);
+    const d = _chunkYNSK4MGTcjs.distanceToBezierPath.call(void 0, piece.path, point);
     if (d <= tol && (!best || d < best.d)) best = { index, d };
   });
   return best;
@@ -8045,8 +8045,8 @@ function addBuilderHit(touched, hit) {
 }
 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 mid = _chunkYNSK4MGTcjs.segmentPoint.call(void 0, seg, 0.5);
+  const t = _chunkYNSK4MGTcjs.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])];
@@ -8080,7 +8080,7 @@ function planShapeBuilder(m, touched, erase) {
     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;
+      const r = rest.length ? _chunkYNSK4MGTcjs.cutOutPiece.call(void 0, rest, piece, fillCloses, m.tolerance) : null;
       if (r) {
         rest = r;
         cut = true;
@@ -8101,7 +8101,7 @@ function planShapeBuilder(m, touched, erase) {
 }
 function vectorFillMap(doc, gap = 0) {
   const entries = vectorPathEntries(doc, null, { locked: true });
-  return _chunkVNYRI265cjs.PlanarMap.build(
+  return _chunkYNSK4MGTcjs.PlanarMap.build(
     entries.map((e) => ({ path: worldOf(e, e.node.subpaths.filter(usable)), fills: false })),
     { gap, maxSegments: 2e4 }
   );
@@ -9624,7 +9624,7 @@ var VectorEditorController = (_class5 = class {
       while (list.some((e) => e.id === `fx${k}`)) k++;
       const params = { ..._nullishCoalesce(options.params, () => ( {})) };
       if (type === "repeater" && params.position === void 0) {
-        const b = _chunkVNYRI265cjs.bezierPathBounds.call(void 0, vectorAppearanceOutline(node));
+        const b = _chunkYNSK4MGTcjs.bezierPathBounds.call(void 0, vectorAppearanceOutline(node));
         if (b && b.maxX - b.minX > 0) params.position = { x: Math.round((b.maxX - b.minX) * 1.25 * 100) / 100, y: 0 };
       }
       const effect = createVectorEffect(type, `fx${k}`, params);
@@ -10369,7 +10369,7 @@ var VectorEditorController = (_class5 = class {
     if (options.live) return this.liveBooleanOp(op, roots);
     const entries = vectorPathEntries(this.doc, roots, { locked: true });
     if (entries.length < 2) return null;
-    const result = _chunkVNYRI265cjs.pathBoolean.call(void 0, 
+    const result = _chunkYNSK4MGTcjs.pathBoolean.call(void 0, 
       BOOLEAN_OPS[op],
       entries.map((e) => ({
         path: vectorPathWorldBezier({ ...e.node, subpaths: e.node.subpaths.filter((s) => s.anchors.length > 1).map((s) => ({ ...s, closed: true })) }, e.parent),
@@ -10473,7 +10473,7 @@ var VectorEditorController = (_class5 = 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 : _chunkVNYRI265cjs.transformBezierPath.call(void 0, path, invertMatrix(parent));
+    return isRoot(parent) ? path : _chunkYNSK4MGTcjs.transformBezierPath.call(void 0, path, invertMatrix(parent));
   }
   /** Splits selected compound paths into one path per subpath. */
   breakApart(options = {}) {
@@ -10512,7 +10512,7 @@ var VectorEditorController = (_class5 = class {
     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);
+    const result = _chunkYNSK4MGTcjs.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) => this.holds(r, last)), () => ( last));
@@ -10721,7 +10721,7 @@ var VectorEditorController = (_class5 = class {
       const p = m.map.faceInterior(index);
       return {
         index,
-        d: _chunkVNYRI265cjs.bezierPathToSvg.call(void 0, f.path, { precision: 3 }),
+        d: _chunkYNSK4MGTcjs.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
@@ -10763,7 +10763,7 @@ var VectorEditorController = (_class5 = class {
       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 toLocal = (path) => _chunkYNSK4MGTcjs.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);
@@ -10845,7 +10845,7 @@ var VectorEditorController = (_class5 = class {
   hoverBuilder(p, alt) {
     if (this.tool === "paintBucket") {
       const region = _nullishCoalesce(_optionalChain([this, 'access', _301 => _301.fillMap, 'call', _302 => _302(this.editing.fillGap), 'optionalAccess', _303 => _303.regionAt, 'call', _304 => _304([p.x, p.y])]), () => ( null));
-      const key2 = region ? _chunkVNYRI265cjs.bezierPathToSvg.call(void 0, region, { precision: 2 }) : null;
+      const key2 = region ? _chunkYNSK4MGTcjs.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;
@@ -11316,10 +11316,10 @@ var VectorEditorController = (_class5 = class {
     const region = eraserRegion(pts, width);
     if (!region.length) return [];
     const plan = [];
-    const rb = _chunkVNYRI265cjs.bezierPathBounds.call(void 0, region);
+    const rb = _chunkYNSK4MGTcjs.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 = _chunkVNYRI265cjs.transformBezierPath.call(void 0, region, invertMatrix(this.worldOf(node.id)));
+      const local = _chunkYNSK4MGTcjs.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)) {
@@ -12531,7 +12531,7 @@ var VectorEditorController = (_class5 = class {
           this.selection = [drag.nodeId];
           return this.commit(`Draw ${inkShapeLabel(shape)}`, drag.before);
         }
-        const fitted = _chunkVNYRI265cjs.fitCubics.call(void 0, drag.points, 1.5 / this.viewport.zoom, { cornerAngleDeg: 60 });
+        const fitted = _chunkYNSK4MGTcjs.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] });
@@ -12863,12 +12863,12 @@ function screenOutline(state, node, entered) {
   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 outlinePaths(node, parent, entered).map((path) => _chunkVNYRI265cjs.bezierPathToSvg.call(void 0, _chunkVNYRI265cjs.transformBezierPath.call(void 0, path, view), { precision: 2 })).join(" ");
+  return outlinePaths(node, parent, entered).map((path) => _chunkYNSK4MGTcjs.bezierPathToSvg.call(void 0, _chunkYNSK4MGTcjs.transformBezierPath.call(void 0, path, view), { precision: 2 })).join(" ");
 }
 function outlinePaths(node, parent, entered) {
   if (node.type === "path") return [vectorPathWorldBezier(node, parent, { effects: false })];
   const m = multiplyMatrices(nodeMatrix(node), parent);
-  if (hasOwnVectorAppearance(node) && !entered.has(node.id)) return [_chunkVNYRI265cjs.transformBezierPath.call(void 0, vectorAppearanceOutline(node), m)];
+  if (hasOwnVectorAppearance(node) && !entered.has(node.id)) return [_chunkYNSK4MGTcjs.transformBezierPath.call(void 0, vectorAppearanceOutline(node), m)];
   return node.children.filter((c) => c.visible !== false).flatMap((c) => outlinePaths(c, m, entered));
 }
 function getVectorEnteredGroups(state) {
@@ -13000,15 +13000,15 @@ function getVectorOverlayRenderData(state) {
   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 svg = (path) => _chunkYNSK4MGTcjs.bezierPathToSvg.call(void 0, path, { precision: 2 });
+    const screen = state.builder.faces.map((f) => _chunkYNSK4MGTcjs.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))),
+      hatches: screen.map((f) => hatch ? svg(_chunkYNSK4MGTcjs.hatchPath.call(void 0, f, { gap: VECTOR_BUILDER_HATCH_GAP })) : ""),
+      lines: state.builder.lines.map((l) => svg(_chunkYNSK4MGTcjs.transformBezierPath.call(void 0, l, view))),
       trail
     };
     if (state.builder.mode !== "fill" && _optionalChain([it, 'optionalAccess', _395 => _395.type]) === "builder") {
@@ -13131,7 +13131,7 @@ function blendOverlay(state) {
     const s = vectorBlendSpine(g);
     if (!s) return [];
     const m = multiplyMatrices(_nullishCoalesce(vectorWorldMatrix(doc.nodes, g.id), () => ( IDENTITY_MATRIX)), view);
-    const d = _chunkVNYRI265cjs.bezierPathToSvg.call(void 0, _chunkVNYRI265cjs.transformBezierPath.call(void 0, subpathsToBezier([s.spine], { corners: false }), m), { precision: 2 });
+    const d = _chunkYNSK4MGTcjs.bezierPathToSvg.call(void 0, _chunkYNSK4MGTcjs.transformBezierPath.call(void 0, subpathsToBezier([s.spine], { corners: false }), m), { precision: 2 });
     const keys = s.stops.map((stop) => {
       const p = vectorBlendRailAt(s.rail, stop).point;
       return sc({ x: p[0], y: p[1] }, m);