@pixerate/editor 0.108.0 → 0.109.0

package/dist/vector/index.cjs

@@ -42,6 +42,7 @@ var _chunkMUUXNRU4cjs = require('../chunk-MUUXNRU4.cjs');
 
 
 
+var _chunkJLYX4V57cjs = require('../chunk-JLYX4V57.cjs');
 
 
 
@@ -310,7 +311,6 @@ var _chunkMUUXNRU4cjs = require('../chunk-MUUXNRU4.cjs');
 
 
 
-var _chunkUTEVPQTScjs = require('../chunk-UTEVPQTS.cjs');
 
 
 
@@ -328,7 +328,6 @@ var _chunkUTEVPQTScjs = require('../chunk-UTEVPQTS.cjs');
 
 
 
-var _chunkXGD3FSNCcjs = require('../chunk-XGD3FSNC.cjs');
 
 
 
@@ -348,6 +347,7 @@ var _chunkXGD3FSNCcjs = require('../chunk-XGD3FSNC.cjs');
 
 
 
+var _chunkW3GXSUSQcjs = require('../chunk-W3GXSUSQ.cjs');
 
 
 
@@ -365,15 +365,15 @@ var _chunkXGD3FSNCcjs = require('../chunk-XGD3FSNC.cjs');
 
 
 
-var _chunkDWGZUSEScjs = require('../chunk-DWGZUSES.cjs');
+var _chunkXGD3FSNCcjs = require('../chunk-XGD3FSNC.cjs');
 
 
 var _chunkQKLRAA4Tcjs = require('../chunk-QKLRAA4T.cjs');
+require('../chunk-2FHLHZAL.cjs');
 require('../chunk-MR3Z4OQI.cjs');
 
 
 var _chunkA6PHCAGXcjs = require('../chunk-A6PHCAGX.cjs');
-require('../chunk-2FHLHZAL.cjs');
 
 // src/vector/gradientTool.ts
 var VECTOR_GRADIENT_STOP_GAP = 12;
@@ -387,9 +387,9 @@ var fmt = (n) => Math.round(n * 100) / 100;
 var apply = (m, p) => ({ x: m[0] * p.x + m[2] * p.y + m[4], y: m[1] * p.x + m[3] * p.y + m[5] });
 function vectorGradientTargetPath(doc, selection, target, layer = null) {
   for (const id of selection) {
-    const node = _chunkUTEVPQTScjs.findVectorNode.call(void 0, doc.nodes, id);
+    const node = _chunkW3GXSUSQcjs.findVectorNode.call(void 0, doc.nodes, id);
     if (!node) continue;
-    const path = _chunkUTEVPQTScjs.collectPathNodes.call(void 0, node).find((p) => _chunkUTEVPQTScjs.isVectorGradient.call(void 0, _chunkUTEVPQTScjs.vectorTargetPaint.call(void 0, p, target, layer)));
+    const path = _chunkW3GXSUSQcjs.collectPathNodes.call(void 0, node).find((p) => _chunkW3GXSUSQcjs.isVectorGradient.call(void 0, _chunkW3GXSUSQcjs.vectorTargetPaint.call(void 0, p, target, layer)));
     if (path) return path;
   }
   return null;
@@ -397,24 +397,24 @@ function vectorGradientTargetPath(doc, selection, target, layer = null) {
 function getVectorGradientAnnotator(doc, selection, viewport, target, layer = null) {
   const path = vectorGradientTargetPath(doc, selection, target, layer);
   if (!path) return null;
-  const gradient = _chunkUTEVPQTScjs.vectorTargetPaint.call(void 0, path, target, layer);
-  const world = _nullishCoalesce(_chunkUTEVPQTScjs.vectorWorldMatrix.call(void 0, doc.nodes, path.id), () => ( _chunkDWGZUSEScjs.IDENTITY_MATRIX));
-  const screen = _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, world, [viewport.zoom, 0, 0, viewport.zoom, viewport.x, viewport.y]);
-  const bounds = _chunkUTEVPQTScjs.vectorPathLocalBounds.call(void 0, path);
-  const h = _chunkUTEVPQTScjs.vectorGradientHandles.call(void 0, gradient, bounds, screen);
+  const gradient = _chunkW3GXSUSQcjs.vectorTargetPaint.call(void 0, path, target, layer);
+  const world = _nullishCoalesce(_chunkW3GXSUSQcjs.vectorWorldMatrix.call(void 0, doc.nodes, path.id), () => ( _chunkW3GXSUSQcjs.IDENTITY_MATRIX));
+  const screen = _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, world, [viewport.zoom, 0, 0, viewport.zoom, viewport.x, viewport.y]);
+  const bounds = _chunkJLYX4V57cjs.vectorPathLocalBounds.call(void 0, path);
+  const h = _chunkW3GXSUSQcjs.vectorGradientHandles.call(void 0, gradient, bounds, screen);
   const v = { x: h.end.x - h.start.x, y: h.end.y - h.start.y };
   const len = Math.hypot(v.x, v.y);
   const normal = len > 1e-9 ? { x: -v.y / len, y: v.x / len } : { x: 0, y: 1 };
   const at = (t, gap) => ({ x: h.start.x + v.x * t + normal.x * gap, y: h.start.y + v.y * t + normal.y * gap });
-  const sorted = _chunkUTEVPQTScjs.sortedVectorGradientStops.call(void 0, gradient);
+  const sorted = _chunkW3GXSUSQcjs.sortedVectorGradientStops.call(void 0, gradient);
   const stops = sorted.map((s, index) => ({ ...s, index, ...at(s.offset, VECTOR_GRADIENT_STOP_GAP) }));
   const midpoints = sorted.slice(0, -1).flatMap((s, index) => {
-    const pos = _chunkUTEVPQTScjs.vectorGradientMidpointPosition.call(void 0, sorted, index);
+    const pos = _chunkW3GXSUSQcjs.vectorGradientMidpointPosition.call(void 0, sorted, index);
     return pos === null || sorted[index + 1].offset - s.offset < 1e-6 ? [] : [{ index, midpoint: _nullishCoalesce(s.midpoint, () => ( 0.5)), ...at(pos, -VECTOR_GRADIENT_MIDPOINT_GAP) }];
   });
   let extent = null;
-  if (_chunkUTEVPQTScjs.isCentredVectorGradient.call(void 0, gradient.type)) {
-    const frame = _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, _chunkUTEVPQTScjs.vectorGradientMatrix.call(void 0, gradient, bounds), screen);
+  if (_chunkW3GXSUSQcjs.isCentredVectorGradient.call(void 0, gradient.type)) {
+    const frame = _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, _chunkW3GXSUSQcjs.vectorGradientMatrix.call(void 0, gradient, bounds), screen);
     const pts = gradient.type === "diamond" ? [{ x: 1, y: 0 }, { x: 0, y: 1 }, { x: -1, y: 0 }, { x: 0, y: -1 }] : Array.from({ length: 48 }, (_, k) => ({ x: Math.cos(k * Math.PI / 24), y: Math.sin(k * Math.PI / 24) }));
     extent = `M${pts.map((p) => apply(frame, p)).map((p) => `${fmt(p.x)} ${fmt(p.y)}`).join("L")}Z`;
   }
@@ -431,7 +431,7 @@ function hitVectorGradientAnnotator(a, p) {
   const near = (q, r) => !!q && Math.hypot(q.x - p.x, q.y - p.y) <= r;
   for (let i = a.stops.length - 1; i >= 0; i--) if (near(a.stops[i], STOP_HIT)) return { kind: "stop", index: a.stops[i].index };
   for (const m of a.midpoints) if (near(m, MIDPOINT_HIT)) return { kind: "midpoint", index: m.index };
-  const centred = _chunkUTEVPQTScjs.isCentredVectorGradient.call(void 0, a.gradient.type);
+  const centred = _chunkW3GXSUSQcjs.isCentredVectorGradient.call(void 0, a.gradient.type);
   if (near(a.end, HANDLE_HIT)) return { kind: "handle", handle: centred ? "radius" : "end" };
   if (a.focal && near(a.focal, HANDLE_HIT) && !near(a.start, 1)) return { kind: "handle", handle: "focal" };
   if (near(a.start, HANDLE_HIT)) return { kind: "handle", handle: "start" };
@@ -467,8 +467,8 @@ function paintColors(p) {
   return [];
 }
 function vectorBlendColorDistance(a, b) {
-  const pa = _chunkUTEVPQTScjs.collectPathNodes.call(void 0, a)[0];
-  const pb = _chunkUTEVPQTScjs.collectPathNodes.call(void 0, b)[0];
+  const pa = _chunkW3GXSUSQcjs.collectPathNodes.call(void 0, a)[0];
+  const pb = _chunkW3GXSUSQcjs.collectPathNodes.call(void 0, b)[0];
   if (!pa || !pb) return 0;
   let d = 0;
   for (const key of ["fill", "stroke"]) {
@@ -486,7 +486,7 @@ function vectorBlendColorDistance(a, b) {
   return d;
 }
 var centreOf = (n) => {
-  const b = _chunkUTEVPQTScjs.vectorNodeBounds.call(void 0, n);
+  const b = _chunkW3GXSUSQcjs.vectorNodeBounds.call(void 0, n);
   return b ? [b.x + b.width / 2, b.y + b.height / 2] : [0, 0];
 };
 function vectorBlendStepCount(a, b, options, length) {
@@ -498,8 +498,8 @@ function vectorBlendStepCount(a, b, options, length) {
   if (o.spacing === "smoothColor") {
     const cd = vectorBlendColorDistance(a, b);
     if (cd > 1 / 255) return Math.min(VECTOR_BLEND_MAX_SMOOTH_STEPS, Math.max(1, Math.ceil(cd * 255 / 2)));
-    const ba = _chunkUTEVPQTScjs.vectorNodeBounds.call(void 0, a);
-    const bb = _chunkUTEVPQTScjs.vectorNodeBounds.call(void 0, b);
+    const ba = _chunkW3GXSUSQcjs.vectorNodeBounds.call(void 0, a);
+    const bb = _chunkW3GXSUSQcjs.vectorNodeBounds.call(void 0, b);
     const dist3 = ba && bb ? Math.max(Math.abs(ba.x - bb.x), Math.abs(ba.y - bb.y), Math.abs(ba.x + ba.width - bb.x - bb.width), Math.abs(ba.y + ba.height - bb.y - bb.height)) : length;
     return Math.min(VECTOR_BLEND_MAX_SMOOTH_STEPS, Math.max(1, Math.ceil(dist3 / 2)));
   }
@@ -514,9 +514,9 @@ function vectorBlendRail(sp) {
     pts.push(p);
     angles.push(Math.atan2(tangent[1], tangent[0]));
   };
-  const count = _chunkUTEVPQTScjs.subpathSegmentCount.call(void 0, sp);
+  const count = _chunkW3GXSUSQcjs.subpathSegmentCount.call(void 0, sp);
   for (let i = 0; i < count; i++) {
-    const seg = _chunkUTEVPQTScjs.subpathSegment.call(void 0, sp, i);
+    const seg = _chunkW3GXSUSQcjs.subpathSegment.call(void 0, sp, i);
     const samples = seg.length === 2 ? 1 : 32;
     if (i === 0) push(seg[0], _chunkXGD3FSNCcjs.segmentTangent.call(void 0, seg, 0));
     for (let k = 1; k <= samples; k++) push(_chunkXGD3FSNCcjs.segmentPoint.call(void 0, seg, k / samples), _chunkXGD3FSNCcjs.segmentTangent.call(void 0, seg, k / samples));
@@ -574,7 +574,7 @@ function morphFor(a, b, blend) {
   let byKey = inner.get(b);
   if (!byKey) inner.set(b, byKey = /* @__PURE__ */ new Map());
   let morph = byKey.get(key);
-  if (!morph) byKey.set(key, morph = _chunkUTEVPQTScjs.createVectorMorph.call(void 0, a, b, { linear: blend.linear, starts }));
+  if (!morph) byKey.set(key, morph = _chunkJLYX4V57cjs.createVectorMorph.call(void 0, a, b, { linear: blend.linear, starts }));
   return morph;
 }
 var wrapAngle = (a) => Math.atan2(Math.sin(a), Math.cos(a));
@@ -607,16 +607,16 @@ function generateVectorBlendChildren(group) {
         const p = vectorBlendRailAt(spine.rail, s0 + (s1 - s0) * t);
         const dx = p.point[0] - (p0.point[0] + (p1.point[0] - p0.point[0]) * t);
         const dy = p.point[1] - (p0.point[1] + (p1.point[1] - p0.point[1]) * t);
-        let m = Math.hypot(dx, dy) > 1e-9 ? _chunkDWGZUSEScjs.translateMatrix.call(void 0, dx, dy) : _chunkDWGZUSEScjs.IDENTITY_MATRIX;
+        let m = Math.hypot(dx, dy) > 1e-9 ? _chunkW3GXSUSQcjs.translateMatrix.call(void 0, dx, dy) : _chunkW3GXSUSQcjs.IDENTITY_MATRIX;
         if (blend.orientToSpine) {
           const turn = wrapAngle(p.angle - (p0.angle + wrapAngle(p1.angle - p0.angle) * t));
           if (Math.abs(turn) > 1e-9) {
             const c = centreOf(step);
             const origin = { x: c[0] + m[4], y: c[1] + m[5] };
-            m = _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, m, _chunkDWGZUSEScjs.rotateMatrix.call(void 0, turn * 180 / Math.PI, origin));
+            m = _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, m, _chunkW3GXSUSQcjs.rotateMatrix.call(void 0, turn * 180 / Math.PI, origin));
           }
         }
-        if (m !== _chunkDWGZUSEScjs.IDENTITY_MATRIX) step = _chunkUTEVPQTScjs.transformVectorNode.call(void 0, step, m);
+        if (m !== _chunkW3GXSUSQcjs.IDENTITY_MATRIX) step = _chunkW3GXSUSQcjs.transformVectorNode.call(void 0, step, m);
       }
       out.push(asStep(step, `${group.id}~${++counter}`));
     }
@@ -663,13 +663,13 @@ function expandVectorBlend(group, newId) {
   return { ...rest, children: group.children.map((c) => c.blendStep ? plain(c, newId) : c) };
 }
 function releaseVectorBlend(group, newId) {
-  const m = _chunkUTEVPQTScjs.nodeMatrix.call(void 0, group);
+  const m = _chunkW3GXSUSQcjs.nodeMatrix.call(void 0, group);
   const opacity = group.opacity;
-  const keys = vectorBlendKeys(group).map((c) => group.transform ? _chunkUTEVPQTScjs.transformVectorNode.call(void 0, c, m) : c).map((c) => opacity !== void 0 && opacity < 1 ? { ...c, opacity: (_nullishCoalesce(c.opacity, () => ( 1))) * opacity } : c);
+  const keys = vectorBlendKeys(group).map((c) => group.transform ? _chunkW3GXSUSQcjs.transformVectorNode.call(void 0, c, m) : c).map((c) => opacity !== void 0 && opacity < 1 ? { ...c, opacity: (_nullishCoalesce(c.opacity, () => ( 1))) * opacity } : c);
   const spine = _optionalChain([group, 'access', _13 => _13.blend, 'optionalAccess', _14 => _14.spine]);
   if (!spine || spine.anchors.length < 2) return keys;
   const path = { id: newId(), type: "path", name: "Spine", fill: null, stroke: null, subpaths: [{ closed: spine.closed, anchors: spine.anchors.map((a) => ({ ...a })) }] };
-  return [...keys, group.transform ? _chunkUTEVPQTScjs.transformVectorNode.call(void 0, path, m) : path];
+  return [...keys, group.transform ? _chunkW3GXSUSQcjs.transformVectorNode.call(void 0, path, m) : path];
 }
 
 // src/vector/distort.ts
@@ -706,7 +706,7 @@ function vectorDistortQuad(b, handle, d, mode = "distort") {
   if (side) for (const k of side) q[k] = { x: q[k].x + d.x, y: q[k].y + d.y };
   return q;
 }
-var about = (o, m) => _chunkDWGZUSEScjs.matrixAbout.call(void 0, m, o);
+var about = (o, m) => _chunkW3GXSUSQcjs.matrixAbout.call(void 0, m, o);
 function vectorShearForSide(b, handle, d, fromCenter = false) {
   const center = { x: b.x + b.width / 2, y: b.y + b.height / 2 };
   if (handle === "n" || handle === "s") {
@@ -722,22 +722,22 @@ function vectorShearForSide(b, handle, d, fromCenter = false) {
   return [1, 0, 0, 1, 0, 0];
 }
 function vectorSkewMatrix(ax, ay, origin = { x: 0, y: 0 }) {
-  return _chunkDWGZUSEScjs.skewMatrix.call(void 0, ax, ay, origin);
+  return _chunkW3GXSUSQcjs.skewMatrix.call(void 0, ax, ay, origin);
 }
 function mapEffects(node, f) {
   if (!_optionalChain([node, 'access', _15 => _15.effects, 'optionalAccess', _16 => _16.length])) return void 0;
   return node.effects.map((e) => {
     if (e.type !== "envelope") return e;
-    if (e.params.style === "mesh") return e.params.mesh ? { ...e, params: { ...e.params, mesh: _chunkDWGZUSEScjs.mapWarpMeshPoints.call(void 0, e.params.mesh, f) } } : e;
-    const bounds = _chunkUTEVPQTScjs.vectorEffectInputBounds.call(void 0, node, e.id);
-    if (!bounds || !_chunkUTEVPQTScjs.vectorEnvelopeMap.call(void 0, e.params, bounds)) return e;
-    return { ...e, params: { ...e.params, style: "mesh", mesh: _chunkDWGZUSEScjs.mapWarpMeshPoints.call(void 0, _chunkUTEVPQTScjs.vectorEnvelopeMesh.call(void 0, e.params, bounds), f) } };
+    if (e.params.style === "mesh") return e.params.mesh ? { ...e, params: { ...e.params, mesh: _chunkW3GXSUSQcjs.mapWarpMeshPoints.call(void 0, e.params.mesh, f) } } : e;
+    const bounds = _chunkW3GXSUSQcjs.vectorEffectInputBounds.call(void 0, node, e.id);
+    if (!bounds || !_chunkW3GXSUSQcjs.vectorEnvelopeMap.call(void 0, e.params, bounds)) return e;
+    return { ...e, params: { ...e.params, style: "mesh", mesh: _chunkW3GXSUSQcjs.mapWarpMeshPoints.call(void 0, _chunkW3GXSUSQcjs.vectorEnvelopeMesh.call(void 0, e.params, bounds), f) } };
   });
 }
 function distortVectorNode(node, parentToDoc, f, tolerance = VECTOR_DISTORT_TOLERANCE) {
-  const toDoc = _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, _chunkUTEVPQTScjs.nodeMatrix.call(void 0, node), parentToDoc);
-  const inv = _chunkDWGZUSEScjs.invertMatrix.call(void 0, toDoc);
-  const local = (p) => _chunkDWGZUSEScjs.applyMatrix.call(void 0, inv, f(_chunkDWGZUSEScjs.applyMatrix.call(void 0, toDoc, p)));
+  const toDoc = _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, _chunkW3GXSUSQcjs.nodeMatrix.call(void 0, node), parentToDoc);
+  const inv = _chunkW3GXSUSQcjs.invertMatrix.call(void 0, toDoc);
+  const local = (p) => _chunkW3GXSUSQcjs.applyMatrix.call(void 0, inv, f(_chunkW3GXSUSQcjs.applyMatrix.call(void 0, toDoc, p)));
   const effects = mapEffects(node, local);
   if (node.type === "group") {
     const group = node;
@@ -747,16 +747,16 @@ function distortVectorNode(node, parentToDoc, f, tolerance = VECTOR_DISTORT_TOLE
       ...group,
       children,
       ...effects ? { effects } : {},
-      ...spine ? { blend: { ...group.blend, spine: _chunkUTEVPQTScjs.mapVectorSubpaths.call(void 0, [spine], local, tolerance)[0] } } : {}
+      ...spine ? { blend: { ...group.blend, spine: _chunkW3GXSUSQcjs.mapVectorSubpaths.call(void 0, [spine], local, tolerance)[0] } } : {}
     };
   }
   const path = node;
   return {
     ...path,
     ...effects ? { effects } : {},
-    ...path.fill !== void 0 ? { fill: _chunkUTEVPQTScjs.mapVectorPaint.call(void 0, path.fill, local) } : {},
-    ...path.stroke !== void 0 ? { stroke: _chunkUTEVPQTScjs.mapVectorPaint.call(void 0, path.stroke, local) } : {},
-    subpaths: _chunkUTEVPQTScjs.mapVectorSubpaths.call(void 0, path.subpaths, local, tolerance)
+    ...path.fill !== void 0 ? { fill: _chunkW3GXSUSQcjs.mapVectorPaint.call(void 0, path.fill, local) } : {},
+    ...path.stroke !== void 0 ? { stroke: _chunkW3GXSUSQcjs.mapVectorPaint.call(void 0, path.stroke, local) } : {},
+    subpaths: _chunkW3GXSUSQcjs.mapVectorSubpaths.call(void 0, path.subpaths, local, tolerance)
   };
 }
 
@@ -817,11 +817,11 @@ var LABELS = {
 };
 var fmtLength = (n) => String(Math.round(n * 100) / 100);
 function nodeFrame(node, parent, aabb) {
-  const angle = _chunkDWGZUSEScjs.matrixRotation.call(void 0, _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, _chunkUTEVPQTScjs.nodeMatrix.call(void 0, node), parent));
-  const b = angle ? _chunkUTEVPQTScjs.vectorNodeBounds.call(void 0, node, _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, parent, _chunkDWGZUSEScjs.rotateMatrix.call(void 0, -angle))) : aabb !== void 0 ? aabb : _chunkUTEVPQTScjs.vectorNodeBounds.call(void 0, node, parent);
+  const angle = _chunkW3GXSUSQcjs.matrixRotation.call(void 0, _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, _chunkW3GXSUSQcjs.nodeMatrix.call(void 0, node), parent));
+  const b = angle ? _chunkW3GXSUSQcjs.vectorNodeBounds.call(void 0, node, _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, parent, _chunkW3GXSUSQcjs.rotateMatrix.call(void 0, -angle))) : aabb !== void 0 ? aabb : _chunkW3GXSUSQcjs.vectorNodeBounds.call(void 0, node, parent);
   if (!b) return null;
   const c = { x: b.x + b.width / 2, y: b.y + b.height / 2 };
-  return { width: b.width, height: b.height, centre: angle ? _chunkDWGZUSEScjs.applyMatrix.call(void 0, _chunkDWGZUSEScjs.rotateMatrix.call(void 0, angle), c) : c };
+  return { width: b.width, height: b.height, centre: angle ? _chunkW3GXSUSQcjs.applyMatrix.call(void 0, _chunkW3GXSUSQcjs.rotateMatrix.call(void 0, angle), c) : c };
 }
 function contains(node, ids) {
   if (ids.has(node.id)) return true;
@@ -893,13 +893,13 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
     let segmentBudget = segments ? BUDGET : 0;
     const visit = (list, parent) => {
       for (const n of list) {
-        const m = _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, _chunkUTEVPQTScjs.nodeMatrix.call(void 0, n), parent);
+        const m = _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, _chunkW3GXSUSQcjs.nodeMatrix.call(void 0, n), parent);
         if (n.type === "group") visit(n.children, m);
         else if (ids.has(n.id) && n.visible !== false) {
           n.subpaths.forEach((sp, s) => {
             sp.anchors.forEach((a, i) => {
               if (anchors <= 0 || moving(n.id, s, i)) return;
-              this.pushAnchor(_chunkDWGZUSEScjs.applyMatrix.call(void 0, m, a));
+              this.pushAnchor(_chunkW3GXSUSQcjs.applyMatrix.call(void 0, m, a));
               anchors--;
             });
             segmentBudget = this.pushSegments(sp, m, (i) => moving(n.id, s, i), segmentBudget);
@@ -907,7 +907,7 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
         }
       }
     };
-    visit(doc.nodes, _chunkDWGZUSEScjs.IDENTITY_MATRIX);
+    visit(doc.nodes, _chunkW3GXSUSQcjs.IDENTITY_MATRIX);
   }
   pushAnchor(p) {
     this.points.push({ p, kind: "anchor" });
@@ -917,10 +917,10 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
   /** The segments of `sp` (mapped by `m`) that stay put while the anchors `moving` accepts move. */
   pushSegments(sp, m, moving, budget) {
     const n = sp.anchors.length;
-    const count = _chunkUTEVPQTScjs.subpathSegmentCount.call(void 0, sp);
+    const count = _chunkW3GXSUSQcjs.subpathSegmentCount.call(void 0, sp);
     for (let i = 0; i < count && budget > 0; i++) {
       if (moving(i) || moving((i + 1) % n)) continue;
-      const seg = _chunkUTEVPQTScjs.subpathSegment.call(void 0, sp, i).map((q) => toPoint(_chunkDWGZUSEScjs.applyMatrix.call(void 0, m, toVec(q))));
+      const seg = _chunkW3GXSUSQcjs.subpathSegment.call(void 0, sp, i).map((q) => toPoint(_chunkW3GXSUSQcjs.applyMatrix.call(void 0, m, toVec(q))));
       let minX = Infinity;
       let minY = Infinity;
       let maxX = -Infinity;
@@ -975,12 +975,12 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
     const visit = (list, parent) => {
       for (const stored of list) {
         if (exclude.has(stored.id) || stored.visible === false) continue;
-        if (_chunkUTEVPQTScjs.isVectorMaskActive.call(void 0, stored) && !contains(stored, exclude)) {
-          visit(_chunkUTEVPQTScjs.vectorAppearanceNodes.call(void 0, stored), _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, _chunkUTEVPQTScjs.nodeMatrix.call(void 0, stored), parent));
+        if (_chunkW3GXSUSQcjs.isVectorMaskActive.call(void 0, stored) && !contains(stored, exclude)) {
+          visit(_chunkW3GXSUSQcjs.vectorAppearanceNodes.call(void 0, stored), _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, _chunkW3GXSUSQcjs.nodeMatrix.call(void 0, stored), parent));
           continue;
         }
-        const n = contains(stored, exclude) ? stored : _chunkUTEVPQTScjs.expandVectorAppearance.call(void 0, stored);
-        const m = _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, _chunkUTEVPQTScjs.nodeMatrix.call(void 0, n), parent);
+        const n = contains(stored, exclude) ? stored : _chunkW3GXSUSQcjs.expandVectorAppearance.call(void 0, stored);
+        const m = _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, _chunkW3GXSUSQcjs.nodeMatrix.call(void 0, n), parent);
         if (n.type === "group") {
           visit(n.children, m);
           continue;
@@ -989,32 +989,32 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
         for (const sp of n.subpaths) {
           for (const a of sp.anchors) {
             if (anchors-- <= 0) break;
-            const p = _chunkDWGZUSEScjs.applyMatrix.call(void 0, m, a);
+            const p = _chunkW3GXSUSQcjs.applyMatrix.call(void 0, m, a);
             if (gather === "drawing") self.pushAnchor(p);
             else self.points.push({ p, kind: "anchor" });
           }
           if (gather !== "bounds") segments = self.pushSegments(sp, m, () => false, segments);
         }
-        const b = _chunkUTEVPQTScjs.vectorNodeBounds.call(void 0, n, parent);
+        const b = _chunkW3GXSUSQcjs.vectorNodeBounds.call(void 0, n, parent);
         const f = nodeFrame(n, parent, b);
         if (b) self.pushRect(b, "edge", _nullishCoalesce(_optionalChain([f, 'optionalAccess', _24 => _24.centre]), () => ( null)));
       }
     };
-    visit(doc.nodes, _chunkDWGZUSEScjs.IDENTITY_MATRIX);
+    visit(doc.nodes, _chunkW3GXSUSQcjs.IDENTITY_MATRIX);
     const objects = (list, parent) => {
       for (const n of list) {
         if (exclude.has(n.id) || n.visible === false || self.boxes.length >= BUDGET) continue;
         if (n.type === "group" && contains(n, exclude)) {
-          objects(n.children, _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, _chunkUTEVPQTScjs.nodeMatrix.call(void 0, n), parent));
+          objects(n.children, _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, _chunkW3GXSUSQcjs.nodeMatrix.call(void 0, n), parent));
           continue;
         }
-        const b = _chunkUTEVPQTScjs.vectorNodeBounds.call(void 0, n, parent);
+        const b = _chunkW3GXSUSQcjs.vectorNodeBounds.call(void 0, n, parent);
         if (b) self.boxes.push(b);
         const f = nodeFrame(n, parent, b);
         if (f) self.sizes.push(f.width, f.height);
       }
     };
-    objects(doc.nodes, _chunkDWGZUSEScjs.IDENTITY_MATRIX);
+    objects(doc.nodes, _chunkW3GXSUSQcjs.IDENTITY_MATRIX);
     return sort ? self.index() : self;
   }
   // -------------------------------------------------------------------------
@@ -1295,8 +1295,8 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
    * may match another object's width or height instead.
    */
   snapScale(frame, handle, sx, sy, mods, tol) {
-    const toDoc = frame.angle ? _chunkDWGZUSEScjs.rotateMatrix.call(void 0, frame.angle) : _chunkDWGZUSEScjs.IDENTITY_MATRIX;
-    const toLocal = frame.angle ? _chunkDWGZUSEScjs.rotateMatrix.call(void 0, -frame.angle) : _chunkDWGZUSEScjs.IDENTITY_MATRIX;
+    const toDoc = frame.angle ? _chunkW3GXSUSQcjs.rotateMatrix.call(void 0, frame.angle) : _chunkW3GXSUSQcjs.IDENTITY_MATRIX;
+    const toLocal = frame.angle ? _chunkW3GXSUSQcjs.rotateMatrix.call(void 0, -frame.angle) : _chunkW3GXSUSQcjs.IDENTITY_MATRIX;
     const corner = handle.length === 2;
     const proportional = !!mods.shift;
     const centre = { x: frame.x + frame.width / 2, y: frame.y + frame.height / 2 };
@@ -1313,7 +1313,7 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
     let ny = sy;
     let snap = { hx: null, hy: null, on: null };
     if (corner && !proportional) {
-      const p = _chunkDWGZUSEScjs.applyMatrix.call(void 0, toDoc, { x: origin.x + d0.x * sx, y: origin.y + d0.y * sy });
+      const p = _chunkW3GXSUSQcjs.applyMatrix.call(void 0, toDoc, { x: origin.x + d0.x * sx, y: origin.y + d0.y * sy });
       const hx = nearest(p.x, this.xs);
       const hy = nearest(p.y, this.ys);
       const on = this.nearestPoint(p, tol);
@@ -1324,7 +1324,7 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
       tries.push({ tx: null, ty: _nullishCoalesce(_optionalChain([hy, 'optionalAccess', _37 => _37.v]), () => ( null)), s: { hx: null, hy, on: null } });
       for (const { tx, ty, s } of tries) {
         if (tx === null && ty === null) continue;
-        const q = _chunkDWGZUSEScjs.applyMatrix.call(void 0, toLocal, { x: _nullishCoalesce(tx, () => ( p.x)), y: _nullishCoalesce(ty, () => ( p.y)) });
+        const q = _chunkW3GXSUSQcjs.applyMatrix.call(void 0, toLocal, { x: _nullishCoalesce(tx, () => ( p.x)), y: _nullishCoalesce(ty, () => ( p.y)) });
         let cx = (q.x - origin.x) / d0.x;
         let cy = (q.y - origin.y) / d0.y;
         if (!frame.angle) {
@@ -1358,8 +1358,8 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
       for (const h of [handle, ...ends]) {
         const hv = handlePos(h, frame);
         const v = { x: hv.x - origin.x, y: hv.y - origin.y };
-        const base = _chunkDWGZUSEScjs.applyMatrix.call(void 0, toDoc, { x: origin.x + c.x * v.x, y: origin.y + c.y * v.y });
-        const dir = _chunkDWGZUSEScjs.applyMatrix.call(void 0, toDoc, { x: e.x * v.x, y: e.y * v.y });
+        const base = _chunkW3GXSUSQcjs.applyMatrix.call(void 0, toDoc, { x: origin.x + c.x * v.x, y: origin.y + c.y * v.y });
+        const dir = _chunkW3GXSUSQcjs.applyMatrix.call(void 0, toDoc, { x: e.x * v.x, y: e.y * v.y });
         const p = { x: base.x + dir.x * s0, y: base.y + dir.y * s0 };
         const l2 = dir.x * dir.x + dir.y * dir.y;
         const on = l2 > 1e-18 ? this.nearestPoint(p, tol) : null;
@@ -1381,7 +1381,7 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
       }
     }
     const out = { sx: nx, sy: ny, snapped: false, lines: [], labels: [] };
-    const handleAt = () => _chunkDWGZUSEScjs.applyMatrix.call(void 0, toDoc, { x: origin.x + d0.x * out.sx, y: origin.y + d0.y * out.sy });
+    const handleAt = () => _chunkW3GXSUSQcjs.applyMatrix.call(void 0, toDoc, { x: origin.x + d0.x * out.sx, y: origin.y + d0.y * out.sy });
     if (snap.on) {
       out.snapped = true;
       out.labels.push(this.label(snap.on.p, snap.on.kind));
@@ -1416,7 +1416,7 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
       { x: box.x1, y: box.y0 },
       { x: box.x1, y: box.y1 },
       { x: box.x0, y: box.y1 }
-    ].map((q) => _chunkDWGZUSEScjs.applyMatrix.call(void 0, toDoc, q));
+    ].map((q) => _chunkW3GXSUSQcjs.applyMatrix.call(void 0, toDoc, q));
     const pminY = Math.min(...page.map((q) => q.y));
     const pmaxY = Math.max(...page.map((q) => q.y));
     const pminX = Math.min(...page.map((q) => q.x));
@@ -1431,8 +1431,8 @@ var VectorSnapTargets = (_class = class _VectorSnapTargets {
       out.snapped = true;
       const off = tol * 2;
       const [a, b] = axis === "x" ? [{ x: box.x0, y: box.y1 + off }, { x: box.x1, y: box.y1 + off }] : [{ x: box.x1 + off, y: box.y0 }, { x: box.x1 + off, y: box.y1 }];
-      const pa = _chunkDWGZUSEScjs.applyMatrix.call(void 0, toDoc, a);
-      const pb = _chunkDWGZUSEScjs.applyMatrix.call(void 0, toDoc, b);
+      const pa = _chunkW3GXSUSQcjs.applyMatrix.call(void 0, toDoc, a);
+      const pb = _chunkW3GXSUSQcjs.applyMatrix.call(void 0, toDoc, b);
       out.lines.push(line("size", pa, pb));
       out.labels.push(this.label({ x: (pa.x + pb.x) / 2, y: (pa.y + pb.y) / 2 }, "size", `${axis === "x" ? "W" : "H"} ${fmtLength(axis === "x" ? box.x1 - box.x0 : box.y1 - box.y0)}`));
     }
@@ -1523,12 +1523,12 @@ var unit = (x, y) => {
   return l > 1e-12 && Number.isFinite(l) ? [x / l, y / l] : null;
 };
 function cubicOf(sp, i) {
-  const s = _chunkUTEVPQTScjs.subpathSegment.call(void 0, sp, i);
+  const s = _chunkW3GXSUSQcjs.subpathSegment.call(void 0, sp, i);
   if (s.length === 4) return s;
   const [a, b] = s;
   return [a, [a[0] + (b[0] - a[0]) / 3, a[1] + (b[1] - a[1]) / 3], [a[0] + 2 * (b[0] - a[0]) / 3, a[1] + 2 * (b[1] - a[1]) / 3], b];
 }
-var isLine = (sp, i) => _chunkUTEVPQTScjs.subpathSegment.call(void 0, sp, i).length === 2;
+var isLine = (sp, i) => _chunkW3GXSUSQcjs.subpathSegment.call(void 0, sp, i).length === 2;
 function startTangent(c) {
   for (let k = 1; k < 4; k++) {
     const u = unit(c[k][0] - c[0][0], c[k][1] - c[0][1]);
@@ -1548,10 +1548,10 @@ function sample(c, n, out, withStart) {
 }
 var onAnchor = (a, h) => !h || Math.abs(h.x - a.x) < EPS && Math.abs(h.y - a.y) < EPS;
 function tidy(a, keepType = true) {
-  const next = _chunkUTEVPQTScjs.cloneAnchor.call(void 0, a);
+  const next = _chunkW3GXSUSQcjs.cloneAnchor.call(void 0, a);
   if (onAnchor(next, next.in)) delete next.in;
   if (onAnchor(next, next.out)) delete next.out;
-  const shown = _chunkUTEVPQTScjs.inferAnchorType.call(void 0, next);
+  const shown = _chunkW3GXSUSQcjs.inferAnchorType.call(void 0, next);
   const type = keepType && a.type ? a.type === "symmetric" && shown !== "symmetric" ? shown === "corner" ? "corner" : "smooth" : a.type === "smooth" && shown === "corner" ? "corner" : a.type : shown;
   if (type === "corner") delete next.type;
   else next.type = type;
@@ -1595,7 +1595,7 @@ function fitAcross(pts, N, t0, t1) {
   return goldenMin(fit, 0, 1);
 }
 function removeAnchorKeepingShape(sp, index) {
-  const anchors = sp.anchors.map(_chunkUTEVPQTScjs.cloneAnchor);
+  const anchors = sp.anchors.map(_chunkW3GXSUSQcjs.cloneAnchor);
   const n = anchors.length;
   if (index < 0 || index >= n) return { anchors, closed: sp.closed };
   if ((sp.closed || index > 0 && index < n - 1) && n >= 3) {
@@ -1629,12 +1629,12 @@ function removeAnchorKeepingShape(sp, index) {
 }
 function removeAnchorsKeepingShape(sp, indices) {
   const order = [...new Set(indices)].filter((i) => i >= 0 && i < sp.anchors.length).sort((a, b) => b - a);
-  return order.reduce((acc, i) => removeAnchorKeepingShape(acc, i), { anchors: sp.anchors.map(_chunkUTEVPQTScjs.cloneAnchor), closed: sp.closed });
+  return order.reduce((acc, i) => removeAnchorKeepingShape(acc, i), { anchors: sp.anchors.map(_chunkW3GXSUSQcjs.cloneAnchor), closed: sp.closed });
 }
 function bendSegment(sp, segment, t, p) {
-  const anchors = sp.anchors.map(_chunkUTEVPQTScjs.cloneAnchor);
+  const anchors = sp.anchors.map(_chunkW3GXSUSQcjs.cloneAnchor);
   const n = anchors.length;
-  if (segment < 0 || segment >= _chunkUTEVPQTScjs.subpathSegmentCount.call(void 0, sp) || !Number.isFinite(t) || !Number.isFinite(p.x) || !Number.isFinite(p.y)) return { anchors, closed: sp.closed };
+  if (segment < 0 || segment >= _chunkW3GXSUSQcjs.subpathSegmentCount.call(void 0, sp) || !Number.isFinite(t) || !Number.isFinite(p.x) || !Number.isFinite(p.y)) return { anchors, closed: sp.closed };
   const tc = Math.min(0.95, Math.max(0.05, t));
   const ia = segment;
   const ib = (segment + 1) % n;
@@ -1645,16 +1645,16 @@ function bendSegment(sp, segment, t, p) {
   const oy = (p.y - (a.y + (b.y - a.y) * tc)) / k;
   const c1 = { x: a.x + (b.x - a.x) / 3 + ox, y: a.y + (b.y - a.y) / 3 + oy };
   const c2 = { x: b.x + (a.x - b.x) / 3 + ox, y: b.y + (a.y - b.y) / 3 + oy };
-  anchors[ia] = _chunkUTEVPQTScjs.moveAnchorHandle.call(void 0, a, "out", c1);
-  anchors[ib] = _chunkUTEVPQTScjs.moveAnchorHandle.call(void 0, b, "in", c2);
+  anchors[ia] = _chunkW3GXSUSQcjs.moveAnchorHandle.call(void 0, a, "out", c1);
+  anchors[ib] = _chunkW3GXSUSQcjs.moveAnchorHandle.call(void 0, b, "in", c2);
   return { anchors, closed: sp.closed };
 }
 function subpathPointAt(sp, segment, t) {
-  const [x, y] = _chunkXGD3FSNCcjs.segmentPoint.call(void 0, _chunkUTEVPQTScjs.subpathSegment.call(void 0, sp, segment), t);
+  const [x, y] = _chunkXGD3FSNCcjs.segmentPoint.call(void 0, _chunkW3GXSUSQcjs.subpathSegment.call(void 0, sp, segment), t);
   return { x, y };
 }
 function curvatureMoveAnchor(sp, index, q) {
-  const anchors = sp.anchors.map(_chunkUTEVPQTScjs.cloneAnchor);
+  const anchors = sp.anchors.map(_chunkW3GXSUSQcjs.cloneAnchor);
   const a = sp.anchors[index];
   if (!a) return { anchors, closed: sp.closed };
   const own = [
@@ -1699,7 +1699,7 @@ function curvatureMoveAnchor(sp, index, q) {
 function cutSubpathAt(sp, at) {
   const n = sp.anchors.length;
   const cuts = [...new Set(at)].filter((i) => Number.isInteger(i) && i >= 0 && i < n && (sp.closed || i > 0 && i < n - 1)).sort((a, b) => a - b);
-  if (!cuts.length || n < 2) return [{ anchors: sp.anchors.map(_chunkUTEVPQTScjs.cloneAnchor), closed: sp.closed }];
+  if (!cuts.length || n < 2) return [{ anchors: sp.anchors.map(_chunkW3GXSUSQcjs.cloneAnchor), closed: sp.closed }];
   const first = cuts[0];
   const run = sp.closed ? Array.from({ length: n + 1 }, (_, i) => sp.anchors[(first + i) % n]) : sp.anchors;
   const cutSet = new Set(sp.closed ? [...cuts.map((c) => (c - first + n) % n), n] : cuts);
@@ -1707,7 +1707,7 @@ function cutSubpathAt(sp, at) {
   let cur = [];
   run.forEach((a, i) => {
     if (!cutSet.has(i)) {
-      cur.push(_chunkUTEVPQTScjs.cloneAnchor.call(void 0, a));
+      cur.push(_chunkW3GXSUSQcjs.cloneAnchor.call(void 0, a));
       return;
     }
     if (cur.length) {
@@ -1722,10 +1722,10 @@ function cutSubpathAt(sp, at) {
 }
 function splitSubpathAt(sp, segment, t, endTolerance = 1e-6) {
   const n = sp.anchors.length;
-  if (segment < 0 || segment >= _chunkUTEVPQTScjs.subpathSegmentCount.call(void 0, sp)) return [{ anchors: sp.anchors.map(_chunkUTEVPQTScjs.cloneAnchor), closed: sp.closed }];
+  if (segment < 0 || segment >= _chunkW3GXSUSQcjs.subpathSegmentCount.call(void 0, sp)) return [{ anchors: sp.anchors.map(_chunkW3GXSUSQcjs.cloneAnchor), closed: sp.closed }];
   if (t <= endTolerance) return cutSubpathAt(sp, [segment]);
   if (t >= 1 - endTolerance) return cutSubpathAt(sp, [(segment + 1) % n]);
-  const { subpath, index } = _chunkUTEVPQTScjs.insertAnchor.call(void 0, sp, segment, t);
+  const { subpath, index } = _chunkW3GXSUSQcjs.insertAnchor.call(void 0, sp, segment, t);
   return cutSubpathAt(subpath, [index]);
 }
 var endOf = (sp, last) => sp.anchors[last ? sp.anchors.length - 1 : 0];
@@ -1747,7 +1747,7 @@ function joinSubpaths(subpaths, tolerance) {
   const closed = [];
   let open = [];
   for (const sp of subpaths) {
-    const copy = { anchors: sp.anchors.map(_chunkUTEVPQTScjs.cloneAnchor), closed: sp.closed };
+    const copy = { anchors: sp.anchors.map(_chunkW3GXSUSQcjs.cloneAnchor), closed: sp.closed };
     if (sp.closed || sp.anchors.length < 2) {
       if (sp.anchors.length) closed.push(copy);
     } else open.push(copy);
@@ -1802,7 +1802,7 @@ function smoothSubpath(sp, amount = 1, only) {
   const t = Math.min(1, Math.max(0, amount));
   const orig = sp.anchors;
   const n = orig.length;
-  const anchors = orig.map(_chunkUTEVPQTScjs.cloneAnchor);
+  const anchors = orig.map(_chunkW3GXSUSQcjs.cloneAnchor);
   if (n < 3 || t === 0) return { anchors, closed: sp.closed };
   for (let i = 0; i < n; i++) {
     if (!sp.closed && (i === 0 || i === n - 1)) continue;
@@ -1831,8 +1831,8 @@ function smoothSubpath(sp, amount = 1, only) {
 }
 function segsOf(sp) {
   const out = [];
-  for (let i = 0; i < _chunkUTEVPQTScjs.subpathSegmentCount.call(void 0, sp); i++) {
-    const s = _chunkUTEVPQTScjs.subpathSegment.call(void 0, sp, i);
+  for (let i = 0; i < _chunkW3GXSUSQcjs.subpathSegmentCount.call(void 0, sp); i++) {
+    const s = _chunkW3GXSUSQcjs.subpathSegment.call(void 0, sp, i);
     out.push(s.length === 2 ? { c: s, line: true } : { c: s, line: false });
   }
   return out;
@@ -1889,7 +1889,7 @@ function removeRedundantPoints(sp, tolerance) {
   const tol = Math.max(tolerance, 1e-9);
   const types = new Map(sp.anchors.filter((a) => a.type).map((a) => [`${a.x},${a.y}`, a.type]));
   const segs = segsOf(sp).filter((s) => !isZeroSeg(s));
-  if (!segs.length) return { anchors: sp.anchors.map(_chunkUTEVPQTScjs.cloneAnchor), closed: sp.closed };
+  if (!segs.length) return { anchors: sp.anchors.map(_chunkW3GXSUSQcjs.cloneAnchor), closed: sp.closed };
   const minSegs = sp.closed ? 2 : 1;
   let changed = true;
   while (changed && segs.length > minSegs) {
@@ -1907,7 +1907,7 @@ function removeRedundantPoints(sp, tolerance) {
       break;
     }
   }
-  return _nullishCoalesce(segsToSubpath(segs, sp.closed, types), () => ( { anchors: sp.anchors.map(_chunkUTEVPQTScjs.cloneAnchor), closed: sp.closed }));
+  return _nullishCoalesce(segsToSubpath(segs, sp.closed, types), () => ( { anchors: sp.anchors.map(_chunkW3GXSUSQcjs.cloneAnchor), closed: sp.closed }));
 }
 
 // src/vector/ink.ts
@@ -2141,22 +2141,22 @@ function vectorPathEntries(doc, roots, options = {}) {
   const out = [];
   const visit = (stored, parent, inside) => {
     if (stored.visible === false || stored.locked && !options.locked) return;
-    const node = options.expand === false ? stored : _chunkUTEVPQTScjs.expandVectorAppearance.call(void 0, _chunkUTEVPQTScjs.vectorMaskedGeometry.call(void 0, stored));
+    const node = options.expand === false ? stored : _chunkW3GXSUSQcjs.expandVectorAppearance.call(void 0, _chunkW3GXSUSQcjs.vectorMaskedGeometry.call(void 0, stored));
     const picked = inside || roots === null || roots.includes(node.id);
     if (node.type === "group") {
-      const m = _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, _chunkUTEVPQTScjs.nodeMatrix.call(void 0, node), parent);
+      const m = _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, _chunkW3GXSUSQcjs.nodeMatrix.call(void 0, 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, _chunkDWGZUSEScjs.IDENTITY_MATRIX, false);
+  for (const n of doc.nodes) visit(n, _chunkW3GXSUSQcjs.IDENTITY_MATRIX, false);
   return out;
 }
 var usable = (sp) => sp.anchors.length > 1;
 function worldOf(entry, subpaths) {
-  return _chunkUTEVPQTScjs.vectorPathWorldBezier.call(void 0, { ...entry.node, subpaths }, entry.parent);
+  return _chunkW3GXSUSQcjs.vectorPathWorldBezier.call(void 0, { ...entry.node, subpaths }, entry.parent);
 }
 function subpathEnclosesArea(sp) {
-  const contour = _chunkXGD3FSNCcjs.pathToContours.call(void 0, _chunkUTEVPQTScjs.subpathsToBezier.call(void 0, [{ ...sp, closed: true }]))[0];
+  const contour = _chunkXGD3FSNCcjs.pathToContours.call(void 0, _chunkW3GXSUSQcjs.subpathsToBezier.call(void 0, [{ ...sp, closed: true }]))[0];
   if (!contour) return false;
   const segs = _chunkXGD3FSNCcjs.closeContour.call(void 0, contour, true);
   const b = _chunkXGD3FSNCcjs.bezierPathBounds.call(void 0, _chunkXGD3FSNCcjs.contoursToPath.call(void 0, [{ segments: segs, closed: true }]));
@@ -2171,11 +2171,11 @@ function vectorPathfinderShape(entry, op) {
   const subpaths = node.subpaths.filter(usable);
   const closed = subpaths.map((s) => ({ ...s, closed: true }));
   const fillRule = _nullishCoalesce(node.fillRule, () => ( "nonzero"));
-  if (_chunkUTEVPQTScjs.hasPaint.call(void 0, node.fill)) return { path: worldOf(entry, closed), fillRule, key: `fill:${paintKey(node.fill)}`, paint: "fill" };
+  if (_chunkW3GXSUSQcjs.hasPaint.call(void 0, 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 (_chunkUTEVPQTScjs.hasPaint.call(void 0, node.stroke) && (_nullishCoalesce(node.strokeWidth, () => ( 1))) > 0) {
-    const path = _chunkUTEVPQTScjs.vectorStrokeOutline.call(void 0, { ...node, subpaths }, entry.parent);
+  if (_chunkW3GXSUSQcjs.hasPaint.call(void 0, node.stroke) && (_nullishCoalesce(node.strokeWidth, () => ( 1))) > 0) {
+    const path = _chunkW3GXSUSQcjs.vectorStrokeOutline.call(void 0, { ...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" };
@@ -2199,7 +2199,7 @@ function vectorResultStyle(node, paint, edge = false) {
   const base = { ...rest, fillRule: "nonzero" };
   if (edge) {
     for (const k of STROKE_KEYS) delete base[k];
-    const stroke = paint === "stroke" || !_chunkUTEVPQTScjs.hasPaint.call(void 0, node.fill) ? node.stroke : node.fill;
+    const stroke = paint === "stroke" || !_chunkW3GXSUSQcjs.hasPaint.call(void 0, node.fill) ? node.stroke : node.fill;
     return { ...base, fill: null, stroke: _nullishCoalesce(stroke, () => ( "#000000")), strokeWidth: _nullishCoalesce(node.strokeWidth, () => ( 1)) };
   }
   if (paint === "stroke") {
@@ -2211,7 +2211,7 @@ function vectorResultStyle(node, paint, edge = false) {
 function vectorShapeBuilderMap(entries) {
   const lines = [];
   const inputs = entries.map((entry) => {
-    const filled = _chunkUTEVPQTScjs.hasPaint.call(void 0, entry.node.fill);
+    const filled = _chunkW3GXSUSQcjs.hasPaint.call(void 0, 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")) };
@@ -2316,7 +2316,7 @@ function planShapeBuilder(m, touched, erase) {
       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 = _chunkUTEVPQTScjs.hasPaint.call(void 0, entry.node.fill);
+    const fillCloses = _chunkW3GXSUSQcjs.hasPaint.call(void 0, entry.node.fill);
     let cut = false;
     for (const piece of cuts) {
       const r = rest.length ? _chunkJEYDXRWQcjs.cutOutPiece.call(void 0, rest, piece, fillCloses, m.tolerance) : null;
@@ -2407,18 +2407,18 @@ function getEditablePathIds(state) {
   if (state.tool === "direct") {
     if (state.editingId) ids.add(state.editingId);
     for (const id of state.selection) {
-      const node = _chunkUTEVPQTScjs.findVectorNode.call(void 0, state.document.nodes, id);
+      const node = _chunkW3GXSUSQcjs.findVectorNode.call(void 0, state.document.nodes, id);
       if (node && !node.locked) {
-        for (const p of _chunkUTEVPQTScjs.collectPathNodes.call(void 0, node)) if (!p.locked) ids.add(p.id);
+        for (const p of _chunkW3GXSUSQcjs.collectPathNodes.call(void 0, node)) if (!p.locked) ids.add(p.id);
       }
     }
   }
-  return [...ids].filter((id) => _optionalChain([_chunkUTEVPQTScjs.findVectorNode.call(void 0, state.document.nodes, id), 'optionalAccess', _38 => _38.type]) === "path");
+  return [...ids].filter((id) => _optionalChain([_chunkW3GXSUSQcjs.findVectorNode.call(void 0, state.document.nodes, id), 'optionalAccess', _38 => _38.type]) === "path");
 }
 function getVisibleAnchors(state) {
   const out = [];
   for (const id of getEditablePathIds(state)) {
-    const node = _chunkUTEVPQTScjs.findVectorNode.call(void 0, state.document.nodes, id);
+    const node = _chunkW3GXSUSQcjs.findVectorNode.call(void 0, state.document.nodes, id);
     node.subpaths.forEach((sp, s) => sp.anchors.forEach((_, i) => out.push({ nodeId: id, subpath: s, index: i })));
   }
   return out;
@@ -2436,7 +2436,7 @@ function getVisibleHandles(state) {
     out.push({ nodeId: node.id, subpath: s, index: i, handle });
   };
   if (state.tool === "pen" && state.pen) {
-    const node = _chunkUTEVPQTScjs.findVectorNode.call(void 0, state.document.nodes, state.pen.nodeId);
+    const node = _chunkW3GXSUSQcjs.findVectorNode.call(void 0, state.document.nodes, state.pen.nodeId);
     const sp = _optionalChain([node, 'optionalAccess', _41 => _41.type]) === "path" ? node.subpaths[state.pen.subpath] : void 0;
     if (_optionalChain([node, 'optionalAccess', _42 => _42.type]) === "path" && sp) {
       const last = sp.anchors.length - 1;
@@ -2449,7 +2449,7 @@ function getVisibleHandles(state) {
   const editable = new Set(getEditablePathIds(state));
   for (const ref of state.selectedAnchors) {
     if (!editable.has(ref.nodeId)) continue;
-    const node = _chunkUTEVPQTScjs.findVectorNode.call(void 0, state.document.nodes, ref.nodeId);
+    const node = _chunkW3GXSUSQcjs.findVectorNode.call(void 0, state.document.nodes, ref.nodeId);
     const sp = node.subpaths[ref.subpath];
     if (!sp) continue;
     const n = sp.anchors.length;
@@ -2468,26 +2468,26 @@ function getVectorCornerWidgets(state) {
   const zoom = state.viewport.zoom;
   const out = [];
   for (const id of getEditablePathIds(state)) {
-    const node = _chunkUTEVPQTScjs.findVectorNode.call(void 0, state.document.nodes, id);
+    const node = _chunkW3GXSUSQcjs.findVectorNode.call(void 0, state.document.nodes, id);
     const picked = state.selectedAnchors.filter((r) => r.nodeId === id);
-    const m = _nullishCoalesce(_chunkUTEVPQTScjs.vectorWorldMatrix.call(void 0, state.document.nodes, id), () => ( _chunkDWGZUSEScjs.IDENTITY_MATRIX));
-    for (const c of _chunkUTEVPQTScjs.vectorCorners.call(void 0, node.subpaths)) {
+    const m = _nullishCoalesce(_chunkW3GXSUSQcjs.vectorWorldMatrix.call(void 0, state.document.nodes, id), () => ( _chunkW3GXSUSQcjs.IDENTITY_MATRIX));
+    for (const c of _chunkW3GXSUSQcjs.vectorCorners.call(void 0, node.subpaths)) {
       if (picked.length && !picked.some((r) => r.subpath === c.subpath && r.index === c.index)) continue;
       const side = Math.min(c.lu, c.lv);
       if (side * zoom < 3 * VECTOR_CORNER_WIDGET_INSET) continue;
       const a = node.subpaths[c.subpath].anchors[c.index];
       const radius = _nullishCoalesce(_optionalChain([a, 'access', _43 => _43.corner, 'optionalAccess', _44 => _44.radius]), () => ( 0));
-      const drawn = _chunkUTEVPQTScjs.fitCornerRadius.call(void 0, c, radius);
+      const drawn = _chunkW3GXSUSQcjs.fitCornerRadius.call(void 0, c, radius);
       const k = Math.min(Math.max(drawn / c.sin, VECTOR_CORNER_WIDGET_INSET / (zoom * Math.sqrt(1 + c.cos))), side / 2);
-      const p = _chunkDWGZUSEScjs.applyMatrix.call(void 0, m, _chunkUTEVPQTScjs.cornerBisectorPoint.call(void 0, c, k));
+      const p = _chunkW3GXSUSQcjs.applyMatrix.call(void 0, m, _chunkW3GXSUSQcjs.cornerBisectorPoint.call(void 0, c, k));
       out.push({ ref: { nodeId: id, subpath: c.subpath, index: c.index }, x: p.x, y: p.y, radius, drawnRadius: drawn, kind: _nullishCoalesce(_optionalChain([a, 'access', _45 => _45.corner, 'optionalAccess', _46 => _46.kind]), () => ( "round")), corner: c });
     }
   }
   return out;
 }
 function vectorStrokeWidthGeometry(node) {
-  if (!_chunkUTEVPQTScjs.hasPaint.call(void 0, node.stroke) || !((_nullishCoalesce(node.strokeWidth, () => ( 1))) > 0)) return null;
-  const parts = _chunkUTEVPQTScjs.vectorStrokeParts.call(void 0, _chunkUTEVPQTScjs.subpathsToBezier.call(void 0, node.subpaths), node);
+  if (!_chunkW3GXSUSQcjs.hasPaint.call(void 0, node.stroke) || !((_nullishCoalesce(node.strokeWidth, () => ( 1))) > 0)) return null;
+  const parts = _chunkW3GXSUSQcjs.vectorStrokeParts.call(void 0, _chunkW3GXSUSQcjs.subpathsToBezier.call(void 0, node.subpaths), node);
   return parts.line.length ? { line: parts.line, unit: parts.drawWidth / 2 } : null;
 }
 function shiftWidthPoints(profile, indices, dt) {
@@ -2500,30 +2500,30 @@ function getVectorWidthHandles(state) {
   if (state.tool !== "width") return [];
   const ids = /* @__PURE__ */ new Set();
   for (const id of state.selection) {
-    const n = _chunkUTEVPQTScjs.findVectorNode.call(void 0, state.document.nodes, id);
-    if (n) for (const p of _chunkUTEVPQTScjs.collectPathNodes.call(void 0, n)) ids.add(p.id);
+    const n = _chunkW3GXSUSQcjs.findVectorNode.call(void 0, state.document.nodes, id);
+    if (n) for (const p of _chunkW3GXSUSQcjs.collectPathNodes.call(void 0, n)) ids.add(p.id);
   }
   if (_optionalChain([state, 'access', _47 => _47.hover, 'optionalAccess', _48 => _48.nodeId])) ids.add(state.hover.nodeId);
   if (_optionalChain([state, 'access', _49 => _49.interaction, 'optionalAccess', _50 => _50.type]) === "width") ids.add(state.interaction.ref.nodeId);
   for (const r of state.selectedWidthPoints) ids.add(r.nodeId);
   const out = [];
   for (const id of ids) {
-    const node = _chunkUTEVPQTScjs.findVectorNode.call(void 0, state.document.nodes, id);
+    const node = _chunkW3GXSUSQcjs.findVectorNode.call(void 0, state.document.nodes, id);
     if (_optionalChain([node, 'optionalAccess', _51 => _51.type]) !== "path" || node.visible === false || !_optionalChain([node, 'access', _52 => _52.strokeWidthProfile, 'optionalAccess', _53 => _53.length])) continue;
     const g = vectorStrokeWidthGeometry(node);
     if (!g) continue;
-    const profile = _chunkUTEVPQTScjs.sanitizeWidthProfile.call(void 0, node.strokeWidthProfile);
-    const m = _nullishCoalesce(_chunkUTEVPQTScjs.vectorWorldMatrix.call(void 0, state.document.nodes, id), () => ( _chunkDWGZUSEScjs.IDENTITY_MATRIX));
+    const profile = _chunkW3GXSUSQcjs.sanitizeWidthProfile.call(void 0, node.strokeWidthProfile);
+    const m = _nullishCoalesce(_chunkW3GXSUSQcjs.vectorWorldMatrix.call(void 0, state.document.nodes, id), () => ( _chunkW3GXSUSQcjs.IDENTITY_MATRIX));
     const contours = node.subpaths.length;
     for (let sp = 0; sp < contours; sp++) {
       profile.forEach((w, index) => {
-        const at = _chunkUTEVPQTScjs.strokePositionPoint.call(void 0, g.line, sp, w.t);
+        const at = _chunkW3GXSUSQcjs.strokePositionPoint.call(void 0, g.line, sp, w.t);
         if (!at) return;
         const n = { x: at.tangent[1], y: -at.tangent[0] };
         const c = { x: at.point[0], y: at.point[1] };
-        const p = _chunkDWGZUSEScjs.applyMatrix.call(void 0, m, c);
-        const l = _chunkDWGZUSEScjs.applyMatrix.call(void 0, m, { x: c.x + n.x * w.left * g.unit, y: c.y + n.y * w.left * g.unit });
-        const r = _chunkDWGZUSEScjs.applyMatrix.call(void 0, m, { x: c.x - n.x * w.right * g.unit, y: c.y - n.y * w.right * g.unit });
+        const p = _chunkW3GXSUSQcjs.applyMatrix.call(void 0, m, c);
+        const l = _chunkW3GXSUSQcjs.applyMatrix.call(void 0, m, { x: c.x + n.x * w.left * g.unit, y: c.y + n.y * w.left * g.unit });
+        const r = _chunkW3GXSUSQcjs.applyMatrix.call(void 0, m, { x: c.x - n.x * w.right * g.unit, y: c.y - n.y * w.right * g.unit });
         out.push({
           ref: { nodeId: id, index, subpath: sp },
           x: p.x,
@@ -2541,24 +2541,24 @@ function getVectorWidthHandles(state) {
   return out;
 }
 function getAnchor(doc, ref) {
-  const node = _chunkUTEVPQTScjs.findVectorNode.call(void 0, doc.nodes, ref.nodeId);
+  const node = _chunkW3GXSUSQcjs.findVectorNode.call(void 0, doc.nodes, ref.nodeId);
   return _optionalChain([node, 'optionalAccess', _54 => _54.type]) === "path" ? _optionalChain([node, 'access', _55 => _55.subpaths, 'access', _56 => _56[ref.subpath], 'optionalAccess', _57 => _57.anchors, 'access', _58 => _58[ref.index]]) : void 0;
 }
 function getAnchorWorld(doc, ref) {
   const a = getAnchor(doc, ref);
   if (!a) return void 0;
-  const m = _nullishCoalesce(_chunkUTEVPQTScjs.vectorWorldMatrix.call(void 0, doc.nodes, ref.nodeId), () => ( _chunkDWGZUSEScjs.IDENTITY_MATRIX));
-  const p = _chunkDWGZUSEScjs.applyMatrix.call(void 0, m, a);
-  return { x: p.x, y: p.y, ...a.in ? { in: _chunkDWGZUSEScjs.applyMatrix.call(void 0, m, a.in) } : {}, ...a.out ? { out: _chunkDWGZUSEScjs.applyMatrix.call(void 0, m, a.out) } : {}, ...a.type ? { type: a.type } : {} };
+  const m = _nullishCoalesce(_chunkW3GXSUSQcjs.vectorWorldMatrix.call(void 0, doc.nodes, ref.nodeId), () => ( _chunkW3GXSUSQcjs.IDENTITY_MATRIX));
+  const p = _chunkW3GXSUSQcjs.applyMatrix.call(void 0, m, a);
+  return { x: p.x, y: p.y, ...a.in ? { in: _chunkW3GXSUSQcjs.applyMatrix.call(void 0, m, a.in) } : {}, ...a.out ? { out: _chunkW3GXSUSQcjs.applyMatrix.call(void 0, m, a.out) } : {}, ...a.type ? { type: a.type } : {} };
 }
 function getVectorSelectionFrame(doc, ids) {
-  const nodes = ids.map((id) => ({ node: _chunkUTEVPQTScjs.findVectorNode.call(void 0, doc.nodes, id), parent: _nullishCoalesce(_chunkUTEVPQTScjs.vectorParentMatrix.call(void 0, doc.nodes, id), () => ( _chunkDWGZUSEScjs.IDENTITY_MATRIX)) })).filter((n) => n.node);
+  const nodes = ids.map((id) => ({ node: _chunkW3GXSUSQcjs.findVectorNode.call(void 0, doc.nodes, id), parent: _nullishCoalesce(_chunkW3GXSUSQcjs.vectorParentMatrix.call(void 0, doc.nodes, id), () => ( _chunkW3GXSUSQcjs.IDENTITY_MATRIX)) })).filter((n) => n.node);
   if (!nodes.length) return null;
-  const angles = nodes.map((n) => _chunkDWGZUSEScjs.matrixRotation.call(void 0, _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, _chunkUTEVPQTScjs.nodeMatrix.call(void 0, n.node), n.parent)));
+  const angles = nodes.map((n) => _chunkW3GXSUSQcjs.matrixRotation.call(void 0, _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, _chunkW3GXSUSQcjs.nodeMatrix.call(void 0, n.node), n.parent)));
   const same = angles.every((a) => Math.abs(normalizeAngle(a - angles[0])) < 1e-6);
   const angle = same ? angles[0] : 0;
-  const unrotate = _chunkDWGZUSEScjs.rotateMatrix.call(void 0, -angle);
-  const b = _chunkUTEVPQTScjs.unionBounds.call(void 0, nodes.map((n) => _chunkUTEVPQTScjs.vectorNodeBounds.call(void 0, n.node, _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, n.parent, unrotate))));
+  const unrotate = _chunkW3GXSUSQcjs.rotateMatrix.call(void 0, -angle);
+  const b = _chunkW3GXSUSQcjs.unionBounds.call(void 0, nodes.map((n) => _chunkW3GXSUSQcjs.vectorNodeBounds.call(void 0, n.node, _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, n.parent, unrotate))));
   return b ? { ...b, angle } : null;
 }
 var normalizeAngle = (a) => ((a + 180) % 360 + 360) % 360 - 180;
@@ -2579,8 +2579,8 @@ function getTransformHandlePositions(box) {
 function getVectorSelectionBoxGeometry(frame, viewport) {
   const z = viewport.zoom;
   const box = { x: frame.x * z + viewport.x, y: frame.y * z + viewport.y, width: frame.width * z, height: frame.height * z };
-  const rot = _chunkDWGZUSEScjs.rotateMatrix.call(void 0, frame.angle, { x: viewport.x, y: viewport.y });
-  const toScreen2 = (p) => frame.angle ? _chunkDWGZUSEScjs.applyMatrix.call(void 0, rot, p) : { x: p.x, y: p.y };
+  const rot = _chunkW3GXSUSQcjs.rotateMatrix.call(void 0, frame.angle, { x: viewport.x, y: viewport.y });
+  const toScreen2 = (p) => frame.angle ? _chunkW3GXSUSQcjs.applyMatrix.call(void 0, rot, p) : { x: p.x, y: p.y };
   const handles = getTransformHandlePositions(box).map((h) => ({ ...h, screen: toScreen2(h) }));
   const corners2 = [
     { x: box.x, y: box.y },
@@ -2593,10 +2593,10 @@ function getVectorSelectionBoxGeometry(frame, viewport) {
 }
 function getVectorEnvelopeTarget(doc, selection) {
   if (selection.length !== 1) return null;
-  const node = _chunkUTEVPQTScjs.findVectorNode.call(void 0, doc.nodes, selection[0]);
-  if (!node || !_chunkUTEVPQTScjs.vectorNodeEnvelope.call(void 0, node)) return null;
-  const frame = _chunkUTEVPQTScjs.vectorEnvelopeFrame.call(void 0, node);
-  return frame ? { node, frame, world: _nullishCoalesce(_chunkUTEVPQTScjs.vectorWorldMatrix.call(void 0, doc.nodes, node.id), () => ( _chunkDWGZUSEScjs.IDENTITY_MATRIX)) } : null;
+  const node = _chunkW3GXSUSQcjs.findVectorNode.call(void 0, doc.nodes, selection[0]);
+  if (!node || !_chunkW3GXSUSQcjs.vectorNodeEnvelope.call(void 0, node)) return null;
+  const frame = _chunkW3GXSUSQcjs.vectorEnvelopeFrame.call(void 0, node);
+  return frame ? { node, frame, world: _nullishCoalesce(_chunkW3GXSUSQcjs.vectorWorldMatrix.call(void 0, doc.nodes, node.id), () => ( _chunkW3GXSUSQcjs.IDENTITY_MATRIX)) } : null;
 }
 var RESIZE_CURSOR_ORDER = ["ew-resize", "nwse-resize", "ns-resize", "nesw-resize"];
 var HANDLE_ANGLES = { e: 0, se: 45, s: 90, sw: 135, w: 180, nw: 225, n: 270, ne: 315 };
@@ -2707,7 +2707,7 @@ var VECTOR_PATHFINDER_LABELS = {
 function normalizeVectorTree(nodes, prefer) {
   let changed = false;
   const out = nodes.map((n) => {
-    let next = n.type === "path" ? _chunkUTEVPQTScjs.normalizeVectorPaintStacks.call(void 0, n, prefer) : n;
+    let next = n.type === "path" ? _chunkW3GXSUSQcjs.normalizeVectorPaintStacks.call(void 0, n, prefer) : n;
     if (next.type === "group") {
       const children = normalizeVectorTree(next.children, prefer);
       if (children !== next.children) next = { ...next, children };
@@ -2718,7 +2718,7 @@ function normalizeVectorTree(nodes, prefer) {
   return changed ? out : nodes;
 }
 function loadedDocument(doc) {
-  const copy = _chunkUTEVPQTScjs.cloneVectorDocument.call(void 0, doc);
+  const copy = _chunkW3GXSUSQcjs.cloneVectorDocument.call(void 0, doc);
   const nodes = normalizeVectorTree(copy.nodes, "stack");
   return nodes === copy.nodes ? copy : { ...copy, nodes };
 }
@@ -2764,7 +2764,7 @@ var placementOf = (n) => ({
   ...n.locked ? { locked: true } : {},
   ...n.booleanOperation ? { booleanOperation: n.booleanOperation } : {}
 });
-var isRoot = (m) => m === _chunkDWGZUSEScjs.IDENTITY_MATRIX || m[0] === 1 && m[1] === 0 && m[2] === 0 && m[3] === 1 && m[4] === 0 && m[5] === 0;
+var isRoot = (m) => m === _chunkW3GXSUSQcjs.IDENTITY_MATRIX || m[0] === 1 && m[1] === 0 && m[2] === 0 && m[3] === 1 && m[4] === 0 && m[5] === 0;
 var idCounter = 0;
 var defaultCreateId = () => `vn-${Date.now().toString(36)}${(++idCounter).toString(36)}`;
 var VectorEditorController = (_class3 = class {
@@ -2869,7 +2869,7 @@ var VectorEditorController = (_class3 = class {
     return this.doc;
   }
   getNode(id) {
-    return _chunkUTEVPQTScjs.findVectorNode.call(void 0, this.doc.nodes, id);
+    return _chunkW3GXSUSQcjs.findVectorNode.call(void 0, this.doc.nodes, id);
   }
   computeState() {
     const h = this.history.getState();
@@ -2928,10 +2928,10 @@ var VectorEditorController = (_class3 = class {
     });
   }
   boundsOf(ids) {
-    return _chunkUTEVPQTScjs.unionBounds.call(void 0, 
+    return _chunkW3GXSUSQcjs.unionBounds.call(void 0, 
       ids.map((id) => {
         const n = this.getNode(id);
-        return n ? _chunkUTEVPQTScjs.vectorNodeBounds.call(void 0, n, _nullishCoalesce(_chunkUTEVPQTScjs.vectorParentMatrix.call(void 0, this.doc.nodes, id), () => ( _chunkDWGZUSEScjs.IDENTITY_MATRIX))) : null;
+        return n ? _chunkW3GXSUSQcjs.vectorNodeBounds.call(void 0, n, _nullishCoalesce(_chunkW3GXSUSQcjs.vectorParentMatrix.call(void 0, this.doc.nodes, id), () => ( _chunkW3GXSUSQcjs.IDENTITY_MATRIX))) : null;
       })
     );
   }
@@ -2940,11 +2940,11 @@ var VectorEditorController = (_class3 = class {
   }
   /** Local → document matrix of a node in `doc` (default: the current document). */
   worldOf(id, doc = this.doc) {
-    return _nullishCoalesce(_chunkUTEVPQTScjs.vectorWorldMatrix.call(void 0, doc.nodes, id), () => ( _chunkDWGZUSEScjs.IDENTITY_MATRIX));
+    return _nullishCoalesce(_chunkW3GXSUSQcjs.vectorWorldMatrix.call(void 0, doc.nodes, id), () => ( _chunkW3GXSUSQcjs.IDENTITY_MATRIX));
   }
   /** A document point in node `id`'s own space. */
   toLocal(id, p, doc = this.doc) {
-    return _chunkDWGZUSEScjs.applyMatrix.call(void 0, _chunkDWGZUSEScjs.invertMatrix.call(void 0, this.worldOf(id, doc)), p);
+    return _chunkW3GXSUSQcjs.applyMatrix.call(void 0, _chunkW3GXSUSQcjs.invertMatrix.call(void 0, this.worldOf(id, doc)), p);
   }
   cursorFor() {
     if (_optionalChain([this, 'access', _61 => _61.drag, 'optionalAccess', _62 => _62.kind]) === "pan" || this.spaceHeld) return this.drag ? "grabbing" : "grab";
@@ -3057,9 +3057,9 @@ var VectorEditorController = (_class3 = class {
     this.setDoc(mapTree(this.doc.nodes, (n) => n.id === id ? next : n));
   }
   freshIds(node) {
-    const copy = _chunkUTEVPQTScjs.cloneVectorNode.call(void 0, node);
+    const copy = _chunkW3GXSUSQcjs.cloneVectorNode.call(void 0, node);
     const used = /* @__PURE__ */ new Set();
-    _chunkUTEVPQTScjs.walkVectorNodes.call(void 0, this.doc.nodes, (n) => used.add(n.id));
+    _chunkW3GXSUSQcjs.walkVectorNodes.call(void 0, this.doc.nodes, (n) => used.add(n.id));
     const next = () => {
       let id = this.createId();
       while (used.has(id)) id = this.createId();
@@ -3255,7 +3255,7 @@ var VectorEditorController = (_class3 = class {
   /** Replaces the document with parsed SVG markup (one undo step). */
   loadSvg(svg, options = {}) {
     try {
-      const doc = _chunkUTEVPQTScjs.parseVectorSvg.call(void 0, svg, { createId: () => this.createId() });
+      const doc = _chunkJLYX4V57cjs.parseVectorSvg.call(void 0, svg, { createId: () => this.createId() });
       this.setDocument(doc, { history: options.history, label: "Import SVG" });
       return { ok: true };
     } catch (error) {
@@ -3265,7 +3265,7 @@ var VectorEditorController = (_class3 = class {
   /** Adds the nodes of SVG markup on top of the document, selected. */
   importSvg(svg) {
     try {
-      const parsed = _chunkUTEVPQTScjs.parseVectorSvg.call(void 0, svg);
+      const parsed = _chunkJLYX4V57cjs.parseVectorSvg.call(void 0, svg);
       const nodes = parsed.nodes.map((n) => this.freshIds(n));
       if (!nodes.length) return { ok: false, message: "The SVG has no shapes the editor can read." };
       this.change("Import SVG", () => {
@@ -3279,21 +3279,21 @@ var VectorEditorController = (_class3 = class {
     }
   }
   toSvg(options) {
-    return _chunkUTEVPQTScjs.vectorDocumentToSvg.call(void 0, this.doc, options);
+    return _chunkJLYX4V57cjs.vectorDocumentToSvg.call(void 0, this.doc, options);
   }
   toJSON() {
-    return _chunkUTEVPQTScjs.cloneVectorDocument.call(void 0, this.doc);
+    return _chunkW3GXSUSQcjs.cloneVectorDocument.call(void 0, this.doc);
   }
   /** Adds a node (ids are kept unless taken). Returns its id. */
   addNode(node, options = {}) {
     const taken = (() => {
       let clash = false;
-      _chunkUTEVPQTScjs.walkVectorNodes.call(void 0, [node], (n) => {
+      _chunkW3GXSUSQcjs.walkVectorNodes.call(void 0, [node], (n) => {
         if (this.getNode(n.id)) clash = true;
       });
       return clash;
     })();
-    const next = taken ? this.freshIds(node) : _chunkUTEVPQTScjs.cloneVectorNode.call(void 0, node);
+    const next = taken ? this.freshIds(node) : _chunkW3GXSUSQcjs.cloneVectorNode.call(void 0, node);
     this.change(_nullishCoalesce(options.label, () => ( `Add ${next.type === "group" ? "Group" : _nullishCoalesce(next.name, () => ( "Path"))}`)), () => {
       const insert = (list) => {
         const copy = list.slice();
@@ -3317,24 +3317,24 @@ var VectorEditorController = (_class3 = class {
     let subpath;
     switch (input.kind) {
       case "rect":
-        subpath = _chunkUTEVPQTScjs.rectSubpath.call(void 0, b);
+        subpath = _chunkW3GXSUSQcjs.rectSubpath.call(void 0, b);
         break;
       case "ellipse":
-        subpath = _chunkUTEVPQTScjs.ellipseSubpath.call(void 0, b);
+        subpath = _chunkW3GXSUSQcjs.ellipseSubpath.call(void 0, b);
         break;
       case "polygon":
-        subpath = _chunkUTEVPQTScjs.polygonSubpath.call(void 0, b, _nullishCoalesce(input.sides, () => ( d.polygonSides)));
+        subpath = _chunkW3GXSUSQcjs.polygonSubpath.call(void 0, b, _nullishCoalesce(input.sides, () => ( d.polygonSides)));
         break;
       case "star":
-        subpath = _chunkUTEVPQTScjs.starSubpath.call(void 0, b, _nullishCoalesce(input.points, () => ( d.starPoints)), _nullishCoalesce(input.innerRatio, () => ( d.starInnerRatio)));
+        subpath = _chunkW3GXSUSQcjs.starSubpath.call(void 0, b, _nullishCoalesce(input.points, () => ( d.starPoints)), _nullishCoalesce(input.innerRatio, () => ( d.starInnerRatio)));
         break;
       case "line":
-        subpath = _chunkUTEVPQTScjs.lineSubpath.call(void 0, { x: b.x, y: b.y }, { x: b.x + b.width, y: b.y + b.height });
+        subpath = _chunkW3GXSUSQcjs.lineSubpath.call(void 0, { x: b.x, y: b.y }, { x: b.x + b.width, y: b.y + b.height });
         break;
     }
     const radius = _nullishCoalesce(input.cornerRadius, () => ( d.cornerRadius));
     const kind = _nullishCoalesce(input.cornerKind, () => ( d.cornerKind));
-    if ((input.kind === "rect" || input.kind === "polygon" || input.kind === "star") && radius > 0) subpath = _chunkUTEVPQTScjs.setSubpathCorners.call(void 0, subpath, radius, kind);
+    if ((input.kind === "rect" || input.kind === "polygon" || input.kind === "star") && radius > 0) subpath = _chunkW3GXSUSQcjs.setSubpathCorners.call(void 0, subpath, radius, kind);
     const names = { rect: "Rectangle", ellipse: "Ellipse", polygon: "Polygon", star: "Star", line: "Line" };
     const style = this.styleFor(input.kind === "line");
     const own = {};
@@ -3350,7 +3350,7 @@ var VectorEditorController = (_class3 = class {
   }
   /** Adds a path from SVG path data. Returns its id. */
   addPath(d, style = {}, options = {}) {
-    const subpaths = _chunkUTEVPQTScjs.bezierToSubpaths.call(void 0, d);
+    const subpaths = _chunkW3GXSUSQcjs.bezierToSubpaths.call(void 0, d);
     const { name, ...own } = style;
     const node = withStyle({ id: this.newId(), type: "path", name: _nullishCoalesce(name, () => ( "Path")), ...this.styleFor(false), subpaths }, own);
     return this.addNode(node, { label: "Add Path", ...options });
@@ -3366,8 +3366,8 @@ var VectorEditorController = (_class3 = class {
     for (const key of ["startArrow", "endArrow", "arrowAlign", "startArrowScale", "endArrowScale"]) if (d[key]) out[key] = d[key];
     if (_optionalChain([d, 'access', _113 => _113.strokeWidthProfile, 'optionalAccess', _114 => _114.length])) out.strokeWidthProfile = d.strokeWidthProfile.map((p) => ({ ...p }));
     let styled = out;
-    if (Array.isArray(d.fills)) styled = _chunkUTEVPQTScjs.withVectorFills.call(void 0, styled, open ? [] : d.fills);
-    if (Array.isArray(d.strokes)) styled = _chunkUTEVPQTScjs.withVectorStrokes.call(void 0, styled, d.strokes);
+    if (Array.isArray(d.fills)) styled = _chunkW3GXSUSQcjs.withVectorFills.call(void 0, styled, open ? [] : d.fills);
+    if (Array.isArray(d.strokes)) styled = _chunkW3GXSUSQcjs.withVectorStrokes.call(void 0, styled, d.strokes);
     return styled;
   }
   /** Merges `patch` into a node (paths take style and geometry; groups name / visibility / opacity). */
@@ -3384,7 +3384,7 @@ var VectorEditorController = (_class3 = class {
     for (const id of ids) {
       const node = this.getNode(id);
       if (!node) return { ok: false, message: `There is no node "${id}".` };
-      for (const p of _chunkUTEVPQTScjs.collectPathNodes.call(void 0, node)) targets.add(p.id);
+      for (const p of _chunkW3GXSUSQcjs.collectPathNodes.call(void 0, node)) targets.add(p.id);
     }
     if (!targets.size) return { ok: false, message: "Nothing is selected." };
     this.change(_nullishCoalesce(options.label, () => ( "Change Style")), () => {
@@ -3401,13 +3401,13 @@ var VectorEditorController = (_class3 = class {
     let points;
     if (profile === null) points = [];
     else if (typeof profile === "string") {
-      const preset = _chunkUTEVPQTScjs.widthProfilePreset.call(void 0, profile);
+      const preset = _chunkW3GXSUSQcjs.widthProfilePreset.call(void 0, profile);
       if (!preset) return { ok: false, message: `There is no width profile "${profile}".` };
       points = preset;
-    } else if (Array.isArray(profile)) points = _chunkUTEVPQTScjs.sanitizeWidthProfile.call(void 0, profile);
+    } else if (Array.isArray(profile)) points = _chunkW3GXSUSQcjs.sanitizeWidthProfile.call(void 0, profile);
     else {
       const p = profile;
-      points = p.taper || p.wave ? _chunkUTEVPQTScjs.generateWidthProfile.call(void 0, p) : [];
+      points = p.taper || p.wave ? _chunkW3GXSUSQcjs.generateWidthProfile.call(void 0, p) : [];
     }
     this.widthPoints = [];
     this.widthEdit = null;
@@ -3438,7 +3438,7 @@ var VectorEditorController = (_class3 = class {
     for (const id of ids) {
       const node = this.getNode(id);
       if (node && !node.locked) {
-        for (const p of _chunkUTEVPQTScjs.collectPathNodes.call(void 0, node)) if (!p.locked) out.set(p.id, p);
+        for (const p of _chunkW3GXSUSQcjs.collectPathNodes.call(void 0, node)) if (!p.locked) out.set(p.id, p);
       }
     }
     return [...out.values()];
@@ -3456,12 +3456,12 @@ var VectorEditorController = (_class3 = class {
     const next = /* @__PURE__ */ new Map();
     let first = null;
     for (const path of paths) {
-      const paint = _chunkUTEVPQTScjs.vectorTargetPaint.call(void 0, path, target, layer);
-      const base = _chunkUTEVPQTScjs.isVectorGradient.call(void 0, paint) ? paint : _chunkUTEVPQTScjs.defaultVectorGradient.call(void 0, _nullishCoalesce(patch.type, () => ( "linear")), paint);
-      const g = _chunkUTEVPQTScjs.applyVectorGradientPatch.call(void 0, base, patch);
+      const paint = _chunkW3GXSUSQcjs.vectorTargetPaint.call(void 0, path, target, layer);
+      const base = _chunkW3GXSUSQcjs.isVectorGradient.call(void 0, paint) ? paint : _chunkW3GXSUSQcjs.defaultVectorGradient.call(void 0, _nullishCoalesce(patch.type, () => ( "linear")), paint);
+      const g = _chunkW3GXSUSQcjs.applyVectorGradientPatch.call(void 0, base, patch);
       if (!g) return { ok: false, message: "That is not a valid gradient: it needs at least one stop with an offset and a colour." };
       first ??= g;
-      next.set(path.id, _chunkUTEVPQTScjs.withVectorTargetPaint.call(void 0, path, target, layer, g));
+      next.set(path.id, _chunkW3GXSUSQcjs.withVectorTargetPaint.call(void 0, path, target, layer, g));
     }
     this.change(_nullishCoalesce(options.label, () => ( "Gradient")), () => this.setDoc(mapTree(this.doc.nodes, (n) => _nullishCoalesce(next.get(n.id), () => ( n)))), options.merge);
     const stops = _nullishCoalesce(_optionalChain([first, 'optionalAccess', _115 => _115.stops, 'access', _116 => _116.length]), () => ( 0));
@@ -3471,14 +3471,14 @@ var VectorEditorController = (_class3 = class {
   /** Applies `fn` to every target gradient of the selection (paths whose paint is not a gradient are skipped). */
   editGradients(label, fn, merge) {
     const { target, layer } = this.gradientEdit;
-    const paths = this.gradientPaths().filter((p) => _chunkUTEVPQTScjs.isVectorGradient.call(void 0, _chunkUTEVPQTScjs.vectorTargetPaint.call(void 0, p, target, layer)));
+    const paths = this.gradientPaths().filter((p) => _chunkW3GXSUSQcjs.isVectorGradient.call(void 0, _chunkW3GXSUSQcjs.vectorTargetPaint.call(void 0, p, target, layer)));
     if (!paths.length) return { ok: false, message: "The selection has no gradient." };
     const next = /* @__PURE__ */ new Map();
     for (const path of paths) {
-      const g = _chunkUTEVPQTScjs.vectorTargetPaint.call(void 0, path, target, layer);
-      const stops = fn(_chunkUTEVPQTScjs.sortedVectorGradientStops.call(void 0, g));
+      const g = _chunkW3GXSUSQcjs.vectorTargetPaint.call(void 0, path, target, layer);
+      const stops = fn(_chunkW3GXSUSQcjs.sortedVectorGradientStops.call(void 0, g));
       if (!stops) return { ok: false, message: "A gradient keeps at least two stops." };
-      next.set(path.id, _chunkUTEVPQTScjs.withVectorTargetPaint.call(void 0, path, target, layer, { ...g, stops }));
+      next.set(path.id, _chunkW3GXSUSQcjs.withVectorTargetPaint.call(void 0, path, target, layer, { ...g, stops }));
     }
     this.change(label, () => this.setDoc(mapTree(this.doc.nodes, (n) => _nullishCoalesce(next.get(n.id), () => ( n)))), merge);
     return { ok: true };
@@ -3506,7 +3506,7 @@ var VectorEditorController = (_class3 = class {
           }
           return out;
         });
-        if (patch.offset !== void 0 && Number.isFinite(patch.offset)) ({ stops: next, index: moved } = _chunkUTEVPQTScjs.moveVectorGradientStop.call(void 0, next, index, patch.offset));
+        if (patch.offset !== void 0 && Number.isFinite(patch.offset)) ({ stops: next, index: moved } = _chunkW3GXSUSQcjs.moveVectorGradientStop.call(void 0, next, index, patch.offset));
         return next;
       },
       options.merge
@@ -3519,8 +3519,8 @@ var VectorEditorController = (_class3 = class {
     let index = 0;
     const { target, layer } = this.gradientEdit;
     const result = this.editGradients("Add Gradient Stop", (stops) => {
-      const path = this.gradientPaths().find((p) => _chunkUTEVPQTScjs.isVectorGradient.call(void 0, _chunkUTEVPQTScjs.vectorTargetPaint.call(void 0, p, target, layer)));
-      const r = _chunkUTEVPQTScjs.insertVectorGradientStop.call(void 0, { ..._chunkUTEVPQTScjs.vectorTargetPaint.call(void 0, path, target, layer), stops }, offset);
+      const path = this.gradientPaths().find((p) => _chunkW3GXSUSQcjs.isVectorGradient.call(void 0, _chunkW3GXSUSQcjs.vectorTargetPaint.call(void 0, p, target, layer)));
+      const r = _chunkW3GXSUSQcjs.insertVectorGradientStop.call(void 0, { ..._chunkW3GXSUSQcjs.vectorTargetPaint.call(void 0, path, target, layer), stops }, offset);
       index = r.index;
       return r.stops;
     });
@@ -3529,7 +3529,7 @@ var VectorEditorController = (_class3 = class {
   }
   /** Removes stop `index` of the selection's gradients (never below two stops). */
   removeGradientStop(index) {
-    const result = this.editGradients("Delete Gradient Stop", (stops) => _chunkUTEVPQTScjs.removeVectorGradientStop.call(void 0, stops, index));
+    const result = this.editGradients("Delete Gradient Stop", (stops) => _chunkW3GXSUSQcjs.removeVectorGradientStop.call(void 0, stops, index));
     if (result.ok) this.selectGradientStop(null);
     return result;
   }
@@ -3540,7 +3540,7 @@ var VectorEditorController = (_class3 = class {
   /** `doc` with path `id`'s `target` paint replaced. */
   withGradient(doc, id, target, g) {
     const layer = this.gradientEdit.layer;
-    return { ...doc, nodes: mapTree(doc.nodes, (n) => n.id === id && n.type === "path" ? _chunkUTEVPQTScjs.withVectorTargetPaint.call(void 0, n, target, layer, g) : n) };
+    return { ...doc, nodes: mapTree(doc.nodes, (n) => n.id === id && n.type === "path" ? _chunkW3GXSUSQcjs.withVectorTargetPaint.call(void 0, n, target, layer, g) : n) };
   }
   downGradient(screen, p, input) {
     const before = this.snapshot();
@@ -3583,48 +3583,48 @@ var VectorEditorController = (_class3 = class {
       const end = constrained(drag.startDoc, p);
       let doc = base;
       for (const id2 of drag.targets) {
-        const node2 = _chunkUTEVPQTScjs.findVectorNode.call(void 0, base.nodes, id2);
+        const node2 = _chunkW3GXSUSQcjs.findVectorNode.call(void 0, base.nodes, id2);
         if (!node2) continue;
-        const paint = _chunkUTEVPQTScjs.vectorTargetPaint.call(void 0, node2, target, this.gradientEdit.layer);
-        const g2 = _chunkUTEVPQTScjs.isVectorGradient.call(void 0, paint) ? paint : _chunkUTEVPQTScjs.defaultVectorGradient.call(void 0, "linear", paint);
-        doc = this.withGradient(doc, id2, target, _chunkUTEVPQTScjs.setVectorGradientVector.call(void 0, g2, _chunkUTEVPQTScjs.vectorPathLocalBounds.call(void 0, node2), this.toLocal(id2, drag.startDoc, base), this.toLocal(id2, end, base)));
+        const paint = _chunkW3GXSUSQcjs.vectorTargetPaint.call(void 0, node2, target, this.gradientEdit.layer);
+        const g2 = _chunkW3GXSUSQcjs.isVectorGradient.call(void 0, paint) ? paint : _chunkW3GXSUSQcjs.defaultVectorGradient.call(void 0, "linear", paint);
+        doc = this.withGradient(doc, id2, target, _chunkW3GXSUSQcjs.setVectorGradientVector.call(void 0, g2, _chunkJLYX4V57cjs.vectorPathLocalBounds.call(void 0, node2), this.toLocal(id2, drag.startDoc, base), this.toLocal(id2, end, base)));
       }
       this.doc = doc;
       this.notify(true);
       return;
     }
     const id = drag.nodeId;
-    const node = _chunkUTEVPQTScjs.findVectorNode.call(void 0, base.nodes, id);
-    const g = _chunkUTEVPQTScjs.vectorTargetPaint.call(void 0, node, target, this.gradientEdit.layer);
-    const bounds = _chunkUTEVPQTScjs.vectorPathLocalBounds.call(void 0, node);
+    const node = _chunkW3GXSUSQcjs.findVectorNode.call(void 0, base.nodes, id);
+    const g = _chunkW3GXSUSQcjs.vectorTargetPaint.call(void 0, node, target, this.gradientEdit.layer);
+    const bounds = _chunkJLYX4V57cjs.vectorPathLocalBounds.call(void 0, node);
     const local = (q) => this.toLocal(id, q, base);
     const part = drag.part;
     let next = g;
     if (part.kind === "handle") {
       let to = p;
       if (part.handle === "end" || part.handle === "radius") to = constrained(this.screenToDocument(drag.annotator.start), p);
-      next = _chunkUTEVPQTScjs.moveVectorGradientHandle.call(void 0, g, bounds, part.handle, local(to), local(drag.startDoc));
+      next = _chunkW3GXSUSQcjs.moveVectorGradientHandle.call(void 0, g, bounds, part.handle, local(to), local(drag.startDoc));
     } else if (part.kind === "bar") {
-      next = _chunkUTEVPQTScjs.moveVectorGradientHandle.call(void 0, g, bounds, "start", local(p), local(drag.startDoc));
+      next = _chunkW3GXSUSQcjs.moveVectorGradientHandle.call(void 0, g, bounds, "start", local(p), local(drag.startDoc));
     } else {
       const a = drag.annotator;
       const pos = vectorGradientBarPosition(a, screen);
-      const stops = _chunkUTEVPQTScjs.sortedVectorGradientStops.call(void 0, g);
+      const stops = _chunkW3GXSUSQcjs.sortedVectorGradientStops.call(void 0, g);
       if (part.kind === "stop") {
         const off = Math.abs(pos.across - VECTOR_GRADIENT_STOP_GAP) > VECTOR_GRADIENT_OFF_BAR;
-        const removed = off ? _chunkUTEVPQTScjs.removeVectorGradientStop.call(void 0, stops, part.index) : null;
+        const removed = off ? _chunkW3GXSUSQcjs.removeVectorGradientStop.call(void 0, stops, part.index) : null;
         if (removed) {
           next = { ...g, stops: removed };
           drag.stop = null;
         } else {
-          const r = _chunkUTEVPQTScjs.moveVectorGradientStop.call(void 0, stops, part.index, Math.min(1, Math.max(0, pos.offset)));
+          const r = _chunkW3GXSUSQcjs.moveVectorGradientStop.call(void 0, stops, part.index, Math.min(1, Math.max(0, pos.offset)));
           next = { ...g, stops: r.stops };
           drag.stop = r.index;
         }
         this.interaction = { type: "gradient", part: "stop", ...removed ? { removing: true } : {} };
         this.gradientEdit = { ...this.gradientEdit, stop: drag.stop };
       } else {
-        const m = _chunkUTEVPQTScjs.vectorGradientMidpointFromPosition.call(void 0, stops, part.index, pos.offset);
+        const m = _chunkW3GXSUSQcjs.vectorGradientMidpointFromPosition.call(void 0, stops, part.index, pos.offset);
         if (m !== null) next = { ...g, stops: stops.map((s, i) => i !== part.index ? s : Math.abs(m - 0.5) < 1e-3 ? (({ midpoint: _m, ...rest }) => rest)(s) : { ...s, midpoint: m }) };
       }
     }
@@ -3663,7 +3663,7 @@ var VectorEditorController = (_class3 = class {
     this.change(count > 1 ? "Delete Width Points" : "Delete Width Point", () => {
       for (const [id, indices] of byNode) {
         const node = this.getNode(id);
-        const rest = _chunkUTEVPQTScjs.removeWidthPoints.call(void 0, _chunkUTEVPQTScjs.sanitizeWidthProfile.call(void 0, node.strokeWidthProfile), indices);
+        const rest = _chunkW3GXSUSQcjs.removeWidthPoints.call(void 0, _chunkW3GXSUSQcjs.sanitizeWidthProfile.call(void 0, node.strokeWidthProfile), indices);
         this.replaceNode(id, withStyle(node, { strokeWidthProfile: rest.length ? rest : null }));
       }
     });
@@ -3699,25 +3699,25 @@ var VectorEditorController = (_class3 = class {
     const left = num(values.left);
     const right = num(values.right);
     const scale = (w) => w === void 0 ? void 0 : Math.max(0, w) / g.unit;
-    const profile = _chunkUTEVPQTScjs.sanitizeWidthProfile.call(void 0, node.strokeWidthProfile);
+    const profile = _chunkW3GXSUSQcjs.sanitizeWidthProfile.call(void 0, node.strokeWidthProfile);
     let points;
     let index;
     const existing = _nullishCoalesce(target.index, () => ( null));
     if (existing === null) {
       if (t === void 0) return { ok: false, message: "A new width point needs a position t." };
-      if (profile.length >= _chunkUTEVPQTScjs.VECTOR_WIDTH_PROFILE_MAX_POINTS) return { ok: false, message: "The profile has too many width points." };
-      ({ points, index } = _chunkUTEVPQTScjs.insertWidthPoint.call(void 0, profile.length ? profile : null, t, { left: scale(left), right: scale(right) }, { step: true }));
+      if (profile.length >= _chunkW3GXSUSQcjs.VECTOR_WIDTH_PROFILE_MAX_POINTS) return { ok: false, message: "The profile has too many width points." };
+      ({ points, index } = _chunkW3GXSUSQcjs.insertWidthPoint.call(void 0, profile.length ? profile : null, t, { left: scale(left), right: scale(right) }, { step: true }));
     } else {
       const p = profile[existing];
       if (!p) return { ok: false, message: "There is no such width point." };
       const sides2 = { left: _nullishCoalesce(scale(left), () => ( p.left)), right: _nullishCoalesce(scale(right), () => ( p.right)) };
       const tt = t === void 0 ? p.t : Math.min(Math.max(t, 0), 1);
-      if (Math.abs(tt - p.t) <= _chunkUTEVPQTScjs.VECTOR_WIDTH_SAME_T) {
-        points = _chunkUTEVPQTScjs.setWidthPoint.call(void 0, profile, existing, sides2);
+      if (Math.abs(tt - p.t) <= _chunkW3GXSUSQcjs.VECTOR_WIDTH_SAME_T) {
+        points = _chunkW3GXSUSQcjs.setWidthPoint.call(void 0, profile, existing, sides2);
         index = existing;
       } else {
-        const rest = _chunkUTEVPQTScjs.removeWidthPoints.call(void 0, profile, [existing]);
-        if (rest.length) ({ points, index } = _chunkUTEVPQTScjs.insertWidthPoint.call(void 0, rest, tt, sides2, { step: true }));
+        const rest = _chunkW3GXSUSQcjs.removeWidthPoints.call(void 0, profile, [existing]);
+        if (rest.length) ({ points, index } = _chunkW3GXSUSQcjs.insertWidthPoint.call(void 0, rest, tt, sides2, { step: true }));
         else {
           points = [{ t: tt, ...sides2 }];
           index = 0;
@@ -3765,15 +3765,15 @@ var VectorEditorController = (_class3 = class {
     if (_optionalChain([node, 'optionalAccess', _134 => _134.type]) !== "path") return null;
     const g = vectorStrokeWidthGeometry(node);
     if (!g) return null;
-    const profile = _chunkUTEVPQTScjs.sanitizeWidthProfile.call(void 0, node.strokeWidthProfile);
+    const profile = _chunkW3GXSUSQcjs.sanitizeWidthProfile.call(void 0, node.strokeWidthProfile);
     const p = index === null ? null : profile[index];
     if (index !== null && !p) return null;
     const tt = p ? p.t : Math.min(Math.max(_nullishCoalesce(t, () => ( 0)), 0), 1);
-    const sides2 = _nullishCoalesce(p, () => ( _chunkUTEVPQTScjs.widthProfileAt.call(void 0, profile.length ? profile : null, tt)));
+    const sides2 = _nullishCoalesce(p, () => ( _chunkW3GXSUSQcjs.widthProfileAt.call(void 0, profile.length ? profile : null, tt)));
     const sp = Math.min(Math.max(0, subpath), Math.max(0, node.subpaths.length - 1));
-    const at = _chunkUTEVPQTScjs.strokePositionPoint.call(void 0, g.line, sp, tt);
+    const at = _chunkW3GXSUSQcjs.strokePositionPoint.call(void 0, g.line, sp, tt);
     const round = (v) => Math.round(v * 1e6) / 1e6;
-    const q = at ? _chunkDWGZUSEScjs.applyMatrix.call(void 0, this.worldOf(nodeId), { x: at.point[0], y: at.point[1] }) : { x: 0, y: 0 };
+    const q = at ? _chunkW3GXSUSQcjs.applyMatrix.call(void 0, this.worldOf(nodeId), { x: at.point[0], y: at.point[1] }) : { x: 0, y: 0 };
     const point = { x: round(q.x), y: round(q.y) };
     return { nodeId, subpath: sp, index, t: round(tt), left: round(sides2.left * g.unit), right: round(sides2.right * g.unit), point };
   }
@@ -3787,7 +3787,7 @@ var VectorEditorController = (_class3 = class {
     const refs = this.cornerTargets(options);
     if (!refs.length) return { ok: false, message: "Nothing is selected." };
     this.change(radius > 0 ? "Corner Radius" : "Sharpen Corners", () => {
-      this.doc = this.updateAnchors(this.doc, refs, (a) => _chunkUTEVPQTScjs.setAnchorCorner.call(void 0, a, radius, options.kind));
+      this.doc = this.updateAnchors(this.doc, refs, (a) => _chunkW3GXSUSQcjs.setAnchorCorner.call(void 0, a, radius, options.kind));
     });
     return { ok: true };
   }
@@ -3796,7 +3796,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) => _chunkUTEVPQTScjs.setAnchorCorner.call(void 0, a, _nullishCoalesce(_optionalChain([a, 'access', _135 => _135.corner, 'optionalAccess', _136 => _136.radius]), () => ( 0)), kind));
+      this.doc = this.updateAnchors(this.doc, refs, (a) => _chunkW3GXSUSQcjs.setAnchorCorner.call(void 0, a, _nullishCoalesce(_optionalChain([a, 'access', _135 => _135.corner, 'optionalAccess', _136 => _136.radius]), () => ( 0)), kind));
     });
     return { ok: true };
   }
@@ -3808,7 +3808,7 @@ var VectorEditorController = (_class3 = class {
     for (const id of _nullishCoalesce(options.ids, () => ( this.selection))) {
       const node = this.getNode(id);
       if (!node) continue;
-      for (const p of _chunkUTEVPQTScjs.collectPathNodes.call(void 0, node)) {
+      for (const p of _chunkW3GXSUSQcjs.collectPathNodes.call(void 0, node)) {
         if (p.locked) continue;
         p.subpaths.forEach((sp, s) => sp.anchors.forEach((_, i) => out.push({ nodeId: p.id, subpath: s, index: i })));
       }
@@ -3822,25 +3822,25 @@ var VectorEditorController = (_class3 = class {
    */
   outlineStroke(options = {}) {
     const roots = _nullishCoalesce(options.ids, () => ( this.selectedRoots()));
-    const strokesOf = (p) => _chunkUTEVPQTScjs.vectorPaintLayerNodes.call(void 0, p).filter((l) => l.kind === "stroke" && l.drawn && (_nullishCoalesce(l.node.strokeWidth, () => ( 1))) > 0);
+    const strokesOf = (p) => _chunkW3GXSUSQcjs.vectorPaintLayerNodes.call(void 0, p).filter((l) => l.kind === "stroke" && l.drawn && (_nullishCoalesce(l.node.strokeWidth, () => ( 1))) > 0);
     const paths = [];
     for (const id of roots) {
       const node = this.getNode(id);
       if (node) {
-        for (const p of _chunkUTEVPQTScjs.collectPathNodes.call(void 0, node)) if (!p.locked && strokesOf(p).length) paths.push(p);
+        for (const p of _chunkW3GXSUSQcjs.collectPathNodes.call(void 0, node)) if (!p.locked && strokesOf(p).length) paths.push(p);
       }
     }
     if (!paths.length) return [];
     const created = [];
     const replace = /* @__PURE__ */ new Map();
     for (const p of paths) {
-      const { effects, ...rest } = _chunkUTEVPQTScjs.cloneVectorNode.call(void 0, p);
-      const unstroked = _chunkUTEVPQTScjs.withVectorStrokes.call(void 0, rest, []);
-      for (const key of _chunkUTEVPQTScjs.VECTOR_STROKE_SETTING_KEYS) delete unstroked[key];
-      const list = _chunkUTEVPQTScjs.vectorFills.call(void 0, p).length ? [{ ...unstroked, ...effects ? { effects } : {} }] : [];
+      const { effects, ...rest } = _chunkW3GXSUSQcjs.cloneVectorNode.call(void 0, p);
+      const unstroked = _chunkW3GXSUSQcjs.withVectorStrokes.call(void 0, rest, []);
+      for (const key of _chunkW3GXSUSQcjs.VECTOR_STROKE_SETTING_KEYS) delete unstroked[key];
+      const list = _chunkW3GXSUSQcjs.vectorFills.call(void 0, p).length ? [{ ...unstroked, ...effects ? { effects } : {} }] : [];
       const layers = strokesOf(p);
       for (const l of layers) {
-        const outline = _chunkUTEVPQTScjs.bezierToSubpaths.call(void 0, _chunkUTEVPQTScjs.vectorStrokeOutlinePath.call(void 0, _chunkUTEVPQTScjs.vectorAppearanceOutline.call(void 0, p), l.node));
+        const outline = _chunkW3GXSUSQcjs.bezierToSubpaths.call(void 0, _chunkW3GXSUSQcjs.vectorStrokeOutlinePath.call(void 0, _chunkW3GXSUSQcjs.vectorAppearanceOutline.call(void 0, p), l.node));
         if (!outline.length) continue;
         const id = this.newId();
         const { strokes: _s, fills: _f, ...plain2 } = unstroked;
@@ -3848,7 +3848,7 @@ var VectorEditorController = (_class3 = class {
         const fill = { paint: l.layer.paint };
         if (l.layer.opacity !== void 0) fill.opacity = l.layer.opacity;
         if (l.layer.blendMode) fill.blendMode = l.layer.blendMode;
-        list.push(_chunkUTEVPQTScjs.withVectorFills.call(void 0, { ...plain2, id, name, subpaths: outline, stroke: null, fillRule: "nonzero" }, [fill]));
+        list.push(_chunkW3GXSUSQcjs.withVectorFills.call(void 0, { ...plain2, id, name, subpaths: outline, stroke: null, fillRule: "nonzero" }, [fill]));
         created.push(id);
       }
       replace.set(p.id, list);
@@ -3875,7 +3875,7 @@ var VectorEditorController = (_class3 = class {
     for (const id of list) {
       const node = this.getNode(id);
       if (!node) return `There is no node "${id}".`;
-      for (const p of _chunkUTEVPQTScjs.collectPathNodes.call(void 0, node)) if (!p.blendStep) out.set(p.id, p);
+      for (const p of _chunkW3GXSUSQcjs.collectPathNodes.call(void 0, node)) if (!p.blendStep) out.set(p.id, p);
     }
     if (!out.size) return "The selection has no paths (fills and strokes belong to paths).";
     return [...out.values()];
@@ -3886,10 +3886,10 @@ var VectorEditorController = (_class3 = class {
     if (typeof targets === "string") return { ok: false, message: targets };
     const next = /* @__PURE__ */ new Map();
     for (const path of targets) {
-      const stack = kind === "fill" ? _chunkUTEVPQTScjs.vectorFills.call(void 0, path) : _chunkUTEVPQTScjs.vectorStrokes.call(void 0, path);
+      const stack = kind === "fill" ? _chunkW3GXSUSQcjs.vectorFills.call(void 0, path) : _chunkW3GXSUSQcjs.vectorStrokes.call(void 0, path);
       const result = fn(stack.map((l) => ({ ...l })), path);
       if (typeof result === "string") return { ok: false, message: result };
-      next.set(path.id, kind === "fill" ? _chunkUTEVPQTScjs.withVectorFills.call(void 0, path, result) : _chunkUTEVPQTScjs.withVectorStrokes.call(void 0, path, result));
+      next.set(path.id, kind === "fill" ? _chunkW3GXSUSQcjs.withVectorFills.call(void 0, path, result) : _chunkW3GXSUSQcjs.withVectorStrokes.call(void 0, path, result));
     }
     this.change(label, () => this.setDoc(mapTree(this.doc.nodes, (n) => _nullishCoalesce(next.get(n.id), () => ( n)))), merge);
     return { ok: true };
@@ -3905,7 +3905,7 @@ var VectorEditorController = (_class3 = class {
       const paint = patch.paint;
       if (paint === null || typeof paint === "string" && paint.trim()) set.paint = paint === null ? null : paint.trim();
       else {
-        const g = _chunkUTEVPQTScjs.sanitizeVectorGradient.call(void 0, paint);
+        const g = _chunkW3GXSUSQcjs.sanitizeVectorGradient.call(void 0, paint);
         if (!g) return "paint must be a CSS colour, a gradient { type, stops: [{ offset, color }] } or null.";
         set.paint = g;
       }
@@ -3917,7 +3917,7 @@ var VectorEditorController = (_class3 = class {
       else unset.push("opacity");
     }
     if (patch.blendMode !== void 0) {
-      if (!_chunkUTEVPQTScjs.isVectorBlendMode.call(void 0, patch.blendMode)) return `Unknown blend mode "${String(patch.blendMode)}". Use one of: ${_chunkUTEVPQTScjs.VECTOR_BLEND_MODES.join(", ")}.`;
+      if (!_chunkW3GXSUSQcjs.isVectorBlendMode.call(void 0, patch.blendMode)) return `Unknown blend mode "${String(patch.blendMode)}". Use one of: ${_chunkW3GXSUSQcjs.VECTOR_BLEND_MODES.join(", ")}.`;
       if (patch.blendMode !== "normal") set.blendMode = patch.blendMode;
       else unset.push("blendMode");
     }
@@ -3927,8 +3927,8 @@ var VectorEditorController = (_class3 = class {
       else set.visible = false;
     }
     if (kind === "stroke") {
-      const settings = _chunkUTEVPQTScjs.sanitizeVectorStrokeSettings.call(void 0, patch);
-      for (const key of _chunkUTEVPQTScjs.VECTOR_STROKE_SETTING_KEYS) {
+      const settings = _chunkW3GXSUSQcjs.sanitizeVectorStrokeSettings.call(void 0, patch);
+      for (const key of _chunkW3GXSUSQcjs.VECTOR_STROKE_SETTING_KEYS) {
         if (!(key in patch) || patch[key] === void 0) continue;
         if (patch[key] === null || key === "strokeDasharray" && Array.isArray(patch[key]) && !patch[key].length) unset.push(key);
         else if (settings[key] === void 0) return `Invalid ${key}: ${JSON.stringify(patch[key])}.`;
@@ -3946,7 +3946,7 @@ var VectorEditorController = (_class3 = class {
     const patch = this.layerPatch(kind, layer);
     if (typeof patch === "string") return { ok: false, message: patch };
     return this.editStacks(kind, options.ids, kind === "fill" ? "Add Fill" : "Add Stroke", (stack, path) => {
-      const base = kind === "fill" ? { paint: "#808080" } : _chunkUTEVPQTScjs.newVectorStrokeLayer.call(void 0, path, {});
+      const base = kind === "fill" ? { paint: "#808080" } : _chunkW3GXSUSQcjs.newVectorStrokeLayer.call(void 0, path, {});
       const added = { ...base, ...patch.set };
       for (const key of patch.unset) delete added[key];
       const at = options.index === void 0 ? stack.length : Math.min(stack.length, Math.max(0, Math.round(options.index)));
@@ -3997,12 +3997,12 @@ var VectorEditorController = (_class3 = class {
   }
   /** Replaces the whole fill or stroke stack of the selected (or given) paths (malformed layers are dropped). */
   setPaintLayers(kind, layers, options = {}) {
-    const clean = kind === "fill" ? _chunkUTEVPQTScjs.sanitizeVectorFills.call(void 0, layers) : _chunkUTEVPQTScjs.sanitizeVectorStrokes.call(void 0, layers);
+    const clean = kind === "fill" ? _chunkW3GXSUSQcjs.sanitizeVectorFills.call(void 0, layers) : _chunkW3GXSUSQcjs.sanitizeVectorStrokes.call(void 0, layers);
     return this.editStacks(kind, options.ids, kind === "fill" ? "Set Fills" : "Set Strokes", () => clean);
   }
   /** Sets the blend mode of the selected (or given) nodes (paths or groups); `normal` removes it. */
   setBlendMode(mode, options = {}) {
-    if (!_chunkUTEVPQTScjs.isVectorBlendMode.call(void 0, mode)) return { ok: false, message: `Unknown blend mode "${String(mode)}". Use one of: ${_chunkUTEVPQTScjs.VECTOR_BLEND_MODES.join(", ")}.` };
+    if (!_chunkW3GXSUSQcjs.isVectorBlendMode.call(void 0, mode)) return { ok: false, message: `Unknown blend mode "${String(mode)}". Use one of: ${_chunkW3GXSUSQcjs.VECTOR_BLEND_MODES.join(", ")}.` };
     const ids = _nullishCoalesce(options.ids, () => ( this.selectedRoots()));
     if (!ids.length) return { ok: false, message: "Nothing is selected." };
     for (const id of ids) if (!this.getNode(id)) return { ok: false, message: `There is no node "${id}".` };
@@ -4025,7 +4025,7 @@ var VectorEditorController = (_class3 = class {
    * ids (one per node, in order), empty for an unknown type or nothing selected.
    */
   addFilter(type, options = {}) {
-    if (!_chunkUTEVPQTScjs.isVectorFilterType.call(void 0, type)) return [];
+    if (!_chunkW3GXSUSQcjs.isVectorFilterType.call(void 0, type)) return [];
     const targets = this.effectTargets(options.ids);
     if (!targets.length) return [];
     const created = [];
@@ -4034,12 +4034,12 @@ var VectorEditorController = (_class3 = class {
       const list = _nullishCoalesce(node.filters, () => ( []));
       let k = list.length + 1;
       while (list.some((f) => f.id === `filter${k}`)) k++;
-      const filter = _chunkUTEVPQTScjs.createVectorFilter.call(void 0, type, `filter${k}`, options.params);
+      const filter = _chunkW3GXSUSQcjs.createVectorFilter.call(void 0, type, `filter${k}`, options.params);
       const at = options.index === void 0 ? list.length : Math.min(list.length, Math.max(0, Math.round(options.index)));
       next.set(node.id, { ...node, filters: [...list.slice(0, at), filter, ...list.slice(at)] });
       created.push(filter.id);
     }
-    this.change(`Add ${_chunkUTEVPQTScjs.VECTOR_FILTER_LABELS[type]}`, () => this.setDoc(mapTree(this.doc.nodes, (n) => _nullishCoalesce(next.get(n.id), () => ( n)))));
+    this.change(`Add ${_chunkW3GXSUSQcjs.VECTOR_FILTER_LABELS[type]}`, () => this.setDoc(mapTree(this.doc.nodes, (n) => _nullishCoalesce(next.get(n.id), () => ( n)))));
     return created;
   }
   editFilters(nodeId, label, fn, merge) {
@@ -4059,12 +4059,12 @@ var VectorEditorController = (_class3 = class {
     const current = _optionalChain([this, 'access', _137 => _137.getNode, 'call', _138 => _138(nodeId), 'optionalAccess', _139 => _139.filters, 'optionalAccess', _140 => _140.find, 'call', _141 => _141((f) => f.id === filterId)]);
     return this.editFilters(
       nodeId,
-      `Edit ${current ? _chunkUTEVPQTScjs.VECTOR_FILTER_LABELS[current.type] : "Filter"}`,
+      `Edit ${current ? _chunkW3GXSUSQcjs.VECTOR_FILTER_LABELS[current.type] : "Filter"}`,
       (list) => {
         const i = list.findIndex((f2) => f2.id === filterId);
         if (i < 0) return `Node "${nodeId}" has no filter "${filterId}".`;
         const f = list[i];
-        const params = patch.params ? _chunkUTEVPQTScjs.normalizeVectorFilterParams.call(void 0, f.type, patch.params, f.params) : f.params;
+        const params = patch.params ? _chunkW3GXSUSQcjs.normalizeVectorFilterParams.call(void 0, f.type, patch.params, f.params) : f.params;
         const next = { ...f, params, ...patch.enabled !== void 0 ? { enabled: patch.enabled } : {} };
         if (next.enabled !== false) delete next.enabled;
         return list.map((x, j) => j === i ? next : x);
@@ -4101,7 +4101,7 @@ var VectorEditorController = (_class3 = class {
    */
   addEffect(type, options = {}) {
     const targets = this.effectTargets(options.ids);
-    if (!targets.length || !_chunkUTEVPQTScjs.createVectorEffect.call(void 0, type, "")) return [];
+    if (!targets.length || !_chunkW3GXSUSQcjs.createVectorEffect.call(void 0, type, "")) return [];
     const created = [];
     const next = /* @__PURE__ */ new Map();
     for (const node of targets) {
@@ -4110,15 +4110,15 @@ var VectorEditorController = (_class3 = class {
       while (list.some((e) => e.id === `fx${k}`)) k++;
       const params = { ..._nullishCoalesce(options.params, () => ( {})) };
       if (type === "repeater" && params.position === void 0) {
-        const b = _chunkXGD3FSNCcjs.bezierPathBounds.call(void 0, _chunkUTEVPQTScjs.vectorAppearanceOutline.call(void 0, node));
+        const b = _chunkXGD3FSNCcjs.bezierPathBounds.call(void 0, _chunkW3GXSUSQcjs.vectorAppearanceOutline.call(void 0, 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 = _chunkUTEVPQTScjs.createVectorEffect.call(void 0, type, `fx${k}`, params);
+      const effect = _chunkW3GXSUSQcjs.createVectorEffect.call(void 0, type, `fx${k}`, params);
       const at = options.index === void 0 ? list.length : Math.min(list.length, Math.max(0, Math.round(options.index)));
       next.set(node.id, { ...node, effects: [...list.slice(0, at), effect, ...list.slice(at)] });
       created.push(effect.id);
     }
-    this.change(`Add ${_chunkUTEVPQTScjs.VECTOR_EFFECT_LABELS[type]}`, () => this.setDoc(mapTree(this.doc.nodes, (n) => _nullishCoalesce(next.get(n.id), () => ( n)))));
+    this.change(`Add ${_chunkW3GXSUSQcjs.VECTOR_EFFECT_LABELS[type]}`, () => this.setDoc(mapTree(this.doc.nodes, (n) => _nullishCoalesce(next.get(n.id), () => ( n)))));
     return created;
   }
   editEffects(nodeId, label, fn, merge) {
@@ -4138,7 +4138,7 @@ var VectorEditorController = (_class3 = class {
     const merge = options.merge === true ? `effect:${nodeId}:${effectId}` : options.merge || void 0;
     const node = this.getNode(nodeId);
     const current = _optionalChain([node, 'optionalAccess', _142 => _142.effects, 'optionalAccess', _143 => _143.find, 'call', _144 => _144((e) => e.id === effectId)]);
-    const label = current ? _nullishCoalesce(_chunkUTEVPQTScjs.VECTOR_EFFECT_LABELS[current.type], () => ( "Effect")) : "Effect";
+    const label = current ? _nullishCoalesce(_chunkW3GXSUSQcjs.VECTOR_EFFECT_LABELS[current.type], () => ( "Effect")) : "Effect";
     return this.editEffects(
       nodeId,
       `Edit ${label}`,
@@ -4147,7 +4147,7 @@ var VectorEditorController = (_class3 = class {
         if (i < 0) return `Node "${nodeId}" has no effect "${effectId}".`;
         const e = list[i];
         const raw = patch.params && e.type === "envelope" && node ? this.envelopeParams(node, e, patch.params) : patch.params;
-        const params = raw ? _chunkUTEVPQTScjs.normalizeVectorEffectParams.call(void 0, e.type, raw, e.params) : e.params;
+        const params = raw ? _chunkW3GXSUSQcjs.normalizeVectorEffectParams.call(void 0, e.type, raw, e.params) : e.params;
         const next = { ...e, params, ...patch.enabled !== void 0 ? { enabled: patch.enabled } : {} };
         if (next.enabled !== false) delete next.enabled;
         return list.map((x, j) => j === i ? next : x);
@@ -4178,16 +4178,16 @@ var VectorEditorController = (_class3 = class {
    * nodes (empty when none was live).
    */
   expandAppearance(options = {}) {
-    const roots = (_nullishCoalesce(options.ids, () => ( this.selectedRoots()))).map((id) => this.getNode(id)).filter((n) => !!n && _chunkUTEVPQTScjs.hasVectorAppearance.call(void 0, n));
+    const roots = (_nullishCoalesce(options.ids, () => ( this.selectedRoots()))).map((id) => this.getNode(id)).filter((n) => !!n && _chunkW3GXSUSQcjs.hasVectorAppearance.call(void 0, n));
     if (!roots.length) return [];
     const fresh = (n) => {
       const id = n.id.includes("~fx") ? this.newId() : n.id;
       return n.type === "group" ? { ...n, id, children: n.children.map(fresh) } : { ...n, id };
     };
     const bake = (n) => {
-      if (!_chunkUTEVPQTScjs.hasVectorAppearance.call(void 0, n)) return n;
-      if (!_chunkUTEVPQTScjs.hasOwnVectorAppearance.call(void 0, n)) return { ...n, children: n.children.map(bake) };
-      let e = _chunkUTEVPQTScjs.expandVectorAppearance.call(void 0, n);
+      if (!_chunkW3GXSUSQcjs.hasVectorAppearance.call(void 0, n)) return n;
+      if (!_chunkW3GXSUSQcjs.hasOwnVectorAppearance.call(void 0, n)) return { ...n, children: n.children.map(bake) };
+      let e = _chunkW3GXSUSQcjs.expandVectorAppearance.call(void 0, n);
       if (e.type === "group" && e.children.length === 1 && e.children[0].type === "path") {
         const { id: _id, opacity, name, ...child } = e.children[0];
         const k = (_nullishCoalesce(e.opacity, () => ( 1))) * (_nullishCoalesce(opacity, () => ( 1)));
@@ -4222,7 +4222,7 @@ var VectorEditorController = (_class3 = class {
     const drop = new Set(ids.filter((id) => this.getNode(id)));
     if (!drop.size) return { ok: false, message: "Nothing to delete." };
     this.change(_nullishCoalesce(options.label, () => ( "Delete")), () => {
-      this.setDoc(mapTree(this.doc.nodes, (n) => drop.has(n.id) ? null : _chunkUTEVPQTScjs.isVectorMaskGroup.call(void 0, n) && drop.has(n.children[0].id) ? { ...n, mask: null } : n));
+      this.setDoc(mapTree(this.doc.nodes, (n) => drop.has(n.id) ? null : _chunkW3GXSUSQcjs.isVectorMaskGroup.call(void 0, n) && drop.has(n.children[0].id) ? { ...n, mask: null } : n));
       this.selection = this.selection.filter((id) => !drop.has(id) && this.getNode(id));
       this.anchors = this.anchors.filter((r) => getAnchor(this.doc, r));
       if (this.editingId && !this.getNode(this.editingId)) this.editingId = null;
@@ -4270,11 +4270,11 @@ var VectorEditorController = (_class3 = class {
   selectedRoots() {
     return this.selection.filter((id) => {
       let covered = false;
-      const loc = _chunkUTEVPQTScjs.locateVectorNode.call(void 0, this.doc.nodes, id);
+      const loc = _chunkW3GXSUSQcjs.locateVectorNode.call(void 0, this.doc.nodes, id);
       let parent = _nullishCoalesce(_optionalChain([loc, 'optionalAccess', _145 => _145.parent]), () => ( null));
       while (parent) {
         if (this.selection.includes(parent.id)) covered = true;
-        parent = _nullishCoalesce(_optionalChain([_chunkUTEVPQTScjs.locateVectorNode.call(void 0, this.doc.nodes, parent.id), 'optionalAccess', _146 => _146.parent]), () => ( null));
+        parent = _nullishCoalesce(_optionalChain([_chunkW3GXSUSQcjs.locateVectorNode.call(void 0, this.doc.nodes, parent.id), 'optionalAccess', _146 => _146.parent]), () => ( null));
       }
       return !covered;
     });
@@ -4285,12 +4285,12 @@ var VectorEditorController = (_class3 = class {
   /** `m`, given in a frame rotated by `angle`, as a document-space matrix. */
   inFrame(angle, m) {
     if (!angle) return m;
-    return _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, _chunkDWGZUSEScjs.rotateMatrix.call(void 0, -angle), m), _chunkDWGZUSEScjs.rotateMatrix.call(void 0, angle));
+    return _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, _chunkW3GXSUSQcjs.rotateMatrix.call(void 0, -angle), m), _chunkW3GXSUSQcjs.rotateMatrix.call(void 0, angle));
   }
   /** The selection frame's corners in document space, clockwise from the top left. */
   frameCorners(frame) {
-    const rot = _chunkDWGZUSEScjs.rotateMatrix.call(void 0, frame.angle);
-    return vectorBoxCorners(frame).map((c) => frame.angle ? _chunkDWGZUSEScjs.applyMatrix.call(void 0, rot, c) : c);
+    const rot = _chunkW3GXSUSQcjs.rotateMatrix.call(void 0, frame.angle);
+    return vectorBoxCorners(frame).map((c) => frame.angle ? _chunkW3GXSUSQcjs.applyMatrix.call(void 0, rot, c) : c);
   }
   /** `doc` with nodes `ids` sent through `f` (a map of document space), each in its own space (see `distortVectorNode`). */
   distorted(doc, ids, f, tolerance = VECTOR_DISTORT_TOLERANCE) {
@@ -4300,7 +4300,7 @@ var VectorEditorController = (_class3 = class {
         let next = n;
         if (ids.has(n.id) && !n.locked) next = distortVectorNode(n, parent, f, tolerance);
         else if (n.type === "group") {
-          const children = visit(n.children, _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, _chunkUTEVPQTScjs.nodeMatrix.call(void 0, n), parent));
+          const children = visit(n.children, _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, _chunkW3GXSUSQcjs.nodeMatrix.call(void 0, n), parent));
           if (children !== n.children) next = { ...n, children };
         }
         if (next !== n) changed = true;
@@ -4308,7 +4308,7 @@ var VectorEditorController = (_class3 = class {
       });
       return changed ? out : list;
     };
-    const nodes = visit(doc.nodes, _chunkDWGZUSEScjs.IDENTITY_MATRIX);
+    const nodes = visit(doc.nodes, _chunkW3GXSUSQcjs.IDENTITY_MATRIX);
     return nodes === doc.nodes ? doc : { ...doc, nodes };
   }
   /**
@@ -4350,13 +4350,13 @@ var VectorEditorController = (_class3 = class {
     const frame = this.frameOf(_nullishCoalesce(options.ids, () => ( this.selectedRoots())));
     if (!frame) return { ok: false, message: "Nothing is selected." };
     if (![ax, ay].every((v) => Number.isFinite(v) && Math.abs(v) < 89.9)) return { ok: false, message: "Skew angles must be between \u221289.9\xB0 and 89.9\xB0." };
-    const origin = _chunkDWGZUSEScjs.applyMatrix.call(void 0, _chunkDWGZUSEScjs.rotateMatrix.call(void 0, -frame.angle), _nullishCoalesce(options.origin, () => ( this.frameCenter(frame))));
+    const origin = _chunkW3GXSUSQcjs.applyMatrix.call(void 0, _chunkW3GXSUSQcjs.rotateMatrix.call(void 0, -frame.angle), _nullishCoalesce(options.origin, () => ( this.frameCenter(frame))));
     return this.transform(this.inFrame(frame.angle, vectorSkewMatrix(ax, ay, origin)), { ids: options.ids, label: "Skew" });
   }
   /** A selection box handle dragged in Free Distort mode. */
   moveDistort(drag, p, input) {
     const angle = drag.frame.angle;
-    const unrotate = (v) => angle ? _chunkDWGZUSEScjs.applyMatrix.call(void 0, _chunkDWGZUSEScjs.rotateMatrix.call(void 0, -angle), v) : v;
+    const unrotate = (v) => angle ? _chunkW3GXSUSQcjs.applyMatrix.call(void 0, _chunkW3GXSUSQcjs.rotateMatrix.call(void 0, -angle), v) : v;
     const q = unrotate(p);
     const q0 = unrotate(drag.start);
     const d = { x: q.x - q0.x, y: q.y - q0.y };
@@ -4368,13 +4368,13 @@ var VectorEditorController = (_class3 = class {
       const m = this.inFrame(angle, vectorShearForSide(drag.frame, drag.handle, d, !!input.alt));
       drag.op = "Skew";
       this.doc = this.transformed(drag.base, ids, m);
-      this.interaction = { type: "distort", mode: "skew", corners: from.map((c) => _chunkDWGZUSEScjs.applyMatrix.call(void 0, m, c)) };
+      this.interaction = { type: "distort", mode: "skew", corners: from.map((c) => _chunkW3GXSUSQcjs.applyMatrix.call(void 0, m, c)) };
       this.notify(true);
       return;
     }
     const mode = corner && input.mod && input.alt && input.shift ? "perspective" : "distort";
-    const rot = _chunkDWGZUSEScjs.rotateMatrix.call(void 0, angle);
-    const quad = vectorDistortQuad(drag.frame, drag.handle, d, mode).map((c) => angle ? _chunkDWGZUSEScjs.applyMatrix.call(void 0, rot, c) : c);
+    const rot = _chunkW3GXSUSQcjs.rotateMatrix.call(void 0, angle);
+    const quad = vectorDistortQuad(drag.frame, drag.handle, d, mode).map((c) => angle ? _chunkW3GXSUSQcjs.applyMatrix.call(void 0, rot, c) : c);
     const h = _chunkMUUXNRU4cjs.homographyFromPoints.call(void 0, from, quad);
     if (!h || !_chunkMUUXNRU4cjs.homographyKeepsQuad.call(void 0, h, from)) return;
     drag.op = mode === "perspective" ? "Perspective" : "Distort";
@@ -4392,11 +4392,11 @@ var VectorEditorController = (_class3 = class {
   /** Envelope parameters for `node` after `patch`: a preset switched to a mesh becomes the mesh it stood for. */
   envelopeParams(node, current, patch) {
     if (patch.style !== "mesh" || patch.mesh !== void 0 || !current || current.params.style === "mesh") return patch;
-    const frame = _chunkUTEVPQTScjs.vectorEnvelopeFrame.call(void 0, node, current.id);
+    const frame = _chunkW3GXSUSQcjs.vectorEnvelopeFrame.call(void 0, node, current.id);
     if (!frame) return patch;
     const rows = typeof patch.rows === "number" ? patch.rows : current.params.rows;
     const columns = typeof patch.columns === "number" ? patch.columns : current.params.columns;
-    return { ...patch, mesh: _chunkDWGZUSEScjs.resizeWarpMesh.call(void 0, frame.mesh, columns, rows) };
+    return { ...patch, mesh: _chunkW3GXSUSQcjs.resizeWarpMesh.call(void 0, frame.mesh, columns, rows) };
   }
   /**
    * Gives the selected (or given) nodes an envelope distortion, or changes the one they have: a
@@ -4416,14 +4416,14 @@ var VectorEditorController = (_class3 = class {
       const list = _nullishCoalesce(node.effects, () => ( []));
       const current = _nullishCoalesce(list.find((e) => e.type === "envelope"), () => ( null));
       if (current) {
-        const p = _chunkUTEVPQTScjs.normalizeVectorEffectParams.call(void 0, "envelope", this.envelopeParams(node, current, raw), current.params);
+        const p = _chunkW3GXSUSQcjs.normalizeVectorEffectParams.call(void 0, "envelope", this.envelopeParams(node, current, raw), current.params);
         const { enabled: _e, ...rest } = current;
         next.set(node.id, { ...node, effects: list.map((e) => e === current ? { ...rest, params: p } : e) });
         out.push({ nodeId: node.id, effectId: current.id });
       } else {
         let k = list.length + 1;
         while (list.some((e) => e.id === `fx${k}`)) k++;
-        const effect = _chunkUTEVPQTScjs.createVectorEffect.call(void 0, "envelope", `fx${k}`, raw);
+        const effect = _chunkW3GXSUSQcjs.createVectorEffect.call(void 0, "envelope", `fx${k}`, raw);
         next.set(node.id, { ...node, effects: [...list, effect] });
         out.push({ nodeId: node.id, effectId: effect.id });
       }
@@ -4443,7 +4443,7 @@ var VectorEditorController = (_class3 = class {
     const ids = _nullishCoalesce(options.ids, () => ( this.selectedRoots()));
     if (ids.length < 2) return { ok: false, message: "Select the objects and, on top of them, the shape to use as the envelope." };
     const order = /* @__PURE__ */ new Map();
-    _chunkUTEVPQTScjs.walkVectorNodes.call(void 0, this.doc.nodes, (n) => order.set(n.id, order.size));
+    _chunkW3GXSUSQcjs.walkVectorNodes.call(void 0, this.doc.nodes, (n) => order.set(n.id, order.size));
     const sorted = ids.filter((id) => order.has(id)).sort((a, b) => order.get(a) - order.get(b));
     const topId = sorted[sorted.length - 1];
     const top = this.getNode(topId);
@@ -4451,26 +4451,26 @@ var VectorEditorController = (_class3 = class {
     if (!top || !outline) return { ok: false, message: "The top object must be a path with a closed outline." };
     const contents = sorted.slice(0, -1).map((id) => this.getNode(id));
     if (contents.some((n) => n.locked)) return { ok: false, message: "Locked objects cannot be enveloped." };
-    const parents = contents.map((n) => _nullishCoalesce(_optionalChain([_chunkUTEVPQTScjs.locateVectorNode.call(void 0, this.doc.nodes, n.id), 'optionalAccess', _153 => _153.parent, 'optionalAccess', _154 => _154.id]), () => ( null)));
+    const parents = contents.map((n) => _nullishCoalesce(_optionalChain([_chunkW3GXSUSQcjs.locateVectorNode.call(void 0, this.doc.nodes, n.id), 'optionalAccess', _153 => _153.parent, 'optionalAccess', _154 => _154.id]), () => ( null)));
     if (parents.some((p) => p !== parents[0])) return { ok: false, message: "The objects to envelope must be in the same group." };
     const target = contents.length === 1 ? contents[0] : { id: this.newId(), type: "group", name: "Envelope", children: contents.map((n) => n) };
-    const parentToDoc = parents[0] ? this.worldOf(parents[0]) : _chunkDWGZUSEScjs.IDENTITY_MATRIX;
-    const targetToDoc = _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, _chunkUTEVPQTScjs.nodeMatrix.call(void 0, target), parentToDoc);
-    const toLocal = _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, this.worldOf(topId), _chunkDWGZUSEScjs.invertMatrix.call(void 0, targetToDoc));
+    const parentToDoc = parents[0] ? this.worldOf(parents[0]) : _chunkW3GXSUSQcjs.IDENTITY_MATRIX;
+    const targetToDoc = _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, _chunkW3GXSUSQcjs.nodeMatrix.call(void 0, target), parentToDoc);
+    const toLocal = _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, this.worldOf(topId), _chunkW3GXSUSQcjs.invertMatrix.call(void 0, targetToDoc));
     const local = {
       closed: true,
       anchors: outline.anchors.map((a) => ({
-        ..._chunkDWGZUSEScjs.applyMatrix.call(void 0, toLocal, a),
-        ...a.in ? { in: _chunkDWGZUSEScjs.applyMatrix.call(void 0, toLocal, a.in) } : {},
-        ...a.out ? { out: _chunkDWGZUSEScjs.applyMatrix.call(void 0, toLocal, a.out) } : {}
+        ..._chunkW3GXSUSQcjs.applyMatrix.call(void 0, toLocal, a),
+        ...a.in ? { in: _chunkW3GXSUSQcjs.applyMatrix.call(void 0, toLocal, a.in) } : {},
+        ...a.out ? { out: _chunkW3GXSUSQcjs.applyMatrix.call(void 0, toLocal, a.out) } : {}
       }))
     };
-    const mesh = _chunkUTEVPQTScjs.vectorMeshFromOutline.call(void 0, local, _nullishCoalesce(options.columns, () => ( 4)), _nullishCoalesce(options.rows, () => ( 4)));
+    const mesh = _chunkW3GXSUSQcjs.vectorMeshFromOutline.call(void 0, local, _nullishCoalesce(options.columns, () => ( 4)), _nullishCoalesce(options.rows, () => ( 4)));
     if (!mesh) return { ok: false, message: "The top object\u2019s outline is too small to use as an envelope." };
     const list = _nullishCoalesce(target.effects, () => ( []));
     let k = list.length + 1;
     while (list.some((e) => e.id === `fx${k}`)) k++;
-    const effect = _chunkUTEVPQTScjs.createVectorEffect.call(void 0, "envelope", `fx${k}`, { style: "mesh", mesh });
+    const effect = _chunkW3GXSUSQcjs.createVectorEffect.call(void 0, "envelope", `fx${k}`, { style: "mesh", mesh });
     const enveloped = { ...target, effects: [...list, effect] };
     this.change("Make Envelope with Top Object", () => {
       let nodes = spliceTree(this.doc.nodes, topId, []);
@@ -4498,7 +4498,7 @@ var VectorEditorController = (_class3 = class {
     const replace = /* @__PURE__ */ new Map();
     for (const node of targets) {
       const effect = node.effects.find((e) => e.type === "envelope");
-      const frame = _chunkUTEVPQTScjs.vectorEnvelopeFrame.call(void 0, node, effect.id);
+      const frame = _chunkW3GXSUSQcjs.vectorEnvelopeFrame.call(void 0, node, effect.id);
       const rest = node.effects.filter((e) => e !== effect);
       const { effects: _e, ...plain2 } = node;
       const kept = rest.length ? { ...plain2, effects: rest } : plain2;
@@ -4513,7 +4513,7 @@ var VectorEditorController = (_class3 = class {
         type: "path",
         name: "Envelope",
         ...node.transform ? { transform: node.transform } : {},
-        subpaths: [_chunkUTEVPQTScjs.vectorMeshOutline.call(void 0, frame.mesh)],
+        subpaths: [_chunkW3GXSUSQcjs.vectorMeshOutline.call(void 0, frame.mesh)],
         fill: null,
         stroke: "#808080",
         strokeWidth: 1
@@ -4539,11 +4539,11 @@ var VectorEditorController = (_class3 = class {
     const target = this.envelopeTarget();
     if (!target) return null;
     const { mesh } = target.frame;
-    const pts = _chunkDWGZUSEScjs.warpMeshEditPoints.call(void 0, mesh);
+    const pts = _chunkW3GXSUSQcjs.warpMeshEditPoints.call(void 0, mesh);
     let best = null;
     let bestD = Infinity;
     for (const index of [...pts.handles.map((h) => h.index), ...pts.anchors]) {
-      const s = this.documentToScreen(_chunkDWGZUSEScjs.applyMatrix.call(void 0, target.world, mesh.points[index]));
+      const s = this.documentToScreen(_chunkW3GXSUSQcjs.applyMatrix.call(void 0, target.world, mesh.points[index]));
       const d = Math.hypot(s.x - screen.x, s.y - screen.y);
       if (d <= this.hitRadius && d < bestD - 0.5) {
         best = index;
@@ -4551,8 +4551,8 @@ var VectorEditorController = (_class3 = class {
       }
     }
     if (best !== null) return { target, index: best, s: 0, t: 0 };
-    const local = _chunkDWGZUSEScjs.applyMatrix.call(void 0, _chunkDWGZUSEScjs.invertMatrix.call(void 0, target.world), p);
-    const at = _chunkDWGZUSEScjs.warpMeshParamAt.call(void 0, mesh, local);
+    const local = _chunkW3GXSUSQcjs.applyMatrix.call(void 0, _chunkW3GXSUSQcjs.invertMatrix.call(void 0, target.world), p);
+    const at = _chunkW3GXSUSQcjs.warpMeshParamAt.call(void 0, mesh, local);
     if (at.distance > this.tolerance()) return null;
     return { target, index: null, s: at.s, t: at.t };
   }
@@ -4577,7 +4577,7 @@ var VectorEditorController = (_class3 = class {
       this.notify();
       return;
     }
-    const node = _chunkUTEVPQTScjs.hitTestVectorNodes.call(void 0, this.doc.nodes, p, this.tolerance(), { entered: this.enteredGroups() });
+    const node = _chunkW3GXSUSQcjs.hitTestVectorNodes.call(void 0, this.doc.nodes, p, this.tolerance(), { entered: this.enteredGroups() });
     if (node) this.selection = input.shift ? this.selection.includes(node.id) ? this.selection.filter((id) => id !== node.id) : [...this.selection, node.id] : [node.id];
     else if (!input.shift) this.selection = [];
     this.anchors = [];
@@ -4588,7 +4588,7 @@ var VectorEditorController = (_class3 = class {
     const d = { x: local.x - drag.start.x, y: local.y - drag.start.y };
     if (!drag.moved && Math.hypot(d.x, d.y) * this.viewport.zoom < 1) return;
     drag.moved = true;
-    const mesh = drag.index !== null ? _chunkDWGZUSEScjs.dragWarpMeshPoint.call(void 0, drag.base, drag.index, d) : _chunkDWGZUSEScjs.pullWarpMesh.call(void 0, drag.base, drag.s, drag.t, d);
+    const mesh = drag.index !== null ? _chunkW3GXSUSQcjs.dragWarpMeshPoint.call(void 0, drag.base, drag.index, d) : _chunkW3GXSUSQcjs.pullWarpMesh.call(void 0, drag.base, drag.s, drag.t, d);
     const nodes = mapTree(drag.baseDoc.nodes, (n) => {
       if (n.id !== drag.nodeId) return n;
       const effects = (_nullishCoalesce(n.effects, () => ( []))).map(
@@ -4615,10 +4615,10 @@ var VectorEditorController = (_class3 = class {
       const out = list.map((n) => {
         let next = n;
         if (ids.has(n.id) && !n.locked) {
-          const local = isRoot(parent) ? m : _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, parent, m), _chunkDWGZUSEScjs.invertMatrix.call(void 0, parent));
-          next = _chunkUTEVPQTScjs.transformVectorNode.call(void 0, n, local);
+          const local = isRoot(parent) ? m : _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, parent, m), _chunkW3GXSUSQcjs.invertMatrix.call(void 0, parent));
+          next = _chunkW3GXSUSQcjs.transformVectorNode.call(void 0, n, local);
         } else if (n.type === "group") {
-          const children = visit(n.children, _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, _chunkUTEVPQTScjs.nodeMatrix.call(void 0, n), parent));
+          const children = visit(n.children, _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, _chunkW3GXSUSQcjs.nodeMatrix.call(void 0, n), parent));
           if (children !== n.children) next = { ...n, children };
         }
         if (next !== n) changed = true;
@@ -4626,7 +4626,7 @@ var VectorEditorController = (_class3 = class {
       });
       return changed ? out : list;
     };
-    const nodes = visit(doc.nodes, _chunkDWGZUSEScjs.IDENTITY_MATRIX);
+    const nodes = visit(doc.nodes, _chunkW3GXSUSQcjs.IDENTITY_MATRIX);
     return nodes === doc.nodes ? doc : { ...doc, nodes };
   }
   translate(dx, dy, options = {}) {
@@ -4636,11 +4636,11 @@ var VectorEditorController = (_class3 = class {
       });
       return { ok: true };
     }
-    return this.transform(_chunkDWGZUSEScjs.translateMatrix.call(void 0, dx, dy), { ids: options.ids, label: "Move" });
+    return this.transform(_chunkW3GXSUSQcjs.translateMatrix.call(void 0, dx, dy), { ids: options.ids, label: "Move" });
   }
   /** The selection frame's centre in document space. */
   frameCenter(frame) {
-    return _chunkDWGZUSEScjs.applyMatrix.call(void 0, _chunkDWGZUSEScjs.rotateMatrix.call(void 0, frame.angle), { x: frame.x + frame.width / 2, y: frame.y + frame.height / 2 });
+    return _chunkW3GXSUSQcjs.applyMatrix.call(void 0, _chunkW3GXSUSQcjs.rotateMatrix.call(void 0, frame.angle), { x: frame.x + frame.width / 2, y: frame.y + frame.height / 2 });
   }
   /**
    * Scales along the selection box's own axes (rotated with the selection when its nodes
@@ -4649,15 +4649,15 @@ var VectorEditorController = (_class3 = class {
   scale(sx, sy = sx, options = {}) {
     const frame = this.frameOf(_nullishCoalesce(options.ids, () => ( this.selectedRoots())));
     if (!frame) return { ok: false, message: "Nothing is selected." };
-    const origin = _chunkDWGZUSEScjs.applyMatrix.call(void 0, _chunkDWGZUSEScjs.rotateMatrix.call(void 0, -frame.angle), _nullishCoalesce(options.origin, () => ( this.frameCenter(frame))));
-    return this.transform(this.inFrame(frame.angle, _chunkDWGZUSEScjs.scaleMatrix.call(void 0, sx, sy, origin)), { ids: options.ids, label: "Scale" });
+    const origin = _chunkW3GXSUSQcjs.applyMatrix.call(void 0, _chunkW3GXSUSQcjs.rotateMatrix.call(void 0, -frame.angle), _nullishCoalesce(options.origin, () => ( this.frameCenter(frame))));
+    return this.transform(this.inFrame(frame.angle, _chunkW3GXSUSQcjs.scaleMatrix.call(void 0, sx, sy, origin)), { ids: options.ids, label: "Scale" });
   }
   /** Rotates clockwise by `degrees` around `origin` (default: the selection centre). */
   rotate(degrees, options = {}) {
     const frame = this.frameOf(_nullishCoalesce(options.ids, () => ( this.selectedRoots())));
     if (!frame) return { ok: false, message: "Nothing is selected." };
     const origin = _nullishCoalesce(options.origin, () => ( this.frameCenter(frame)));
-    return this.transform(_chunkDWGZUSEScjs.rotateMatrix.call(void 0, degrees, origin), { ids: options.ids, label: "Rotate" });
+    return this.transform(_chunkW3GXSUSQcjs.rotateMatrix.call(void 0, degrees, origin), { ids: options.ids, label: "Rotate" });
   }
   /** Sets each selected (or given) node's rotation to `degrees`, turning it around its own centre. */
   setRotation(degrees, options = {}) {
@@ -4668,7 +4668,7 @@ var VectorEditorController = (_class3 = class {
         const frame = this.frameOf([id]);
         if (!frame) continue;
         const delta = normalizeAngle(degrees - frame.angle);
-        if (Math.abs(delta) > 1e-9) this.doc = this.transformed(this.doc, /* @__PURE__ */ new Set([id]), _chunkDWGZUSEScjs.rotateMatrix.call(void 0, delta, this.frameCenter(frame)));
+        if (Math.abs(delta) > 1e-9) this.doc = this.transformed(this.doc, /* @__PURE__ */ new Set([id]), _chunkW3GXSUSQcjs.rotateMatrix.call(void 0, delta, this.frameCenter(frame)));
       }
     });
     return { ok: true };
@@ -4678,7 +4678,7 @@ var VectorEditorController = (_class3 = class {
     const frame = this.frameOf(_nullishCoalesce(options.ids, () => ( this.selectedRoots())));
     if (!frame) return { ok: false, message: "Nothing is selected." };
     const c = { x: frame.x + frame.width / 2, y: frame.y + frame.height / 2 };
-    const m = axis === "horizontal" ? _chunkDWGZUSEScjs.scaleMatrix.call(void 0, -1, 1, c) : _chunkDWGZUSEScjs.scaleMatrix.call(void 0, 1, -1, c);
+    const m = axis === "horizontal" ? _chunkW3GXSUSQcjs.scaleMatrix.call(void 0, -1, 1, c) : _chunkW3GXSUSQcjs.scaleMatrix.call(void 0, 1, -1, c);
     return this.transform(this.inFrame(frame.angle, m), { ids: options.ids, label: axis === "horizontal" ? "Flip Horizontal" : "Flip Vertical" });
   }
   /**
@@ -4701,7 +4701,7 @@ var VectorEditorController = (_class3 = class {
         if (edge === "top") dy = target.y - b.y;
         if (edge === "middle") dy = target.y + target.height / 2 - (b.y + b.height / 2);
         if (edge === "bottom") dy = target.y + target.height - (b.y + b.height);
-        if (dx || dy) this.doc = this.transformed(this.doc, /* @__PURE__ */ new Set([id]), _chunkDWGZUSEScjs.translateMatrix.call(void 0, dx, dy));
+        if (dx || dy) this.doc = this.transformed(this.doc, /* @__PURE__ */ new Set([id]), _chunkW3GXSUSQcjs.translateMatrix.call(void 0, dx, dy));
       }
     });
     return { ok: true };
@@ -4723,7 +4723,7 @@ var VectorEditorController = (_class3 = class {
       let cursor = pos(first);
       for (const item of items) {
         const d = cursor - pos(item.b);
-        if (Math.abs(d) > 1e-9) this.doc = this.transformed(this.doc, /* @__PURE__ */ new Set([item.id]), horizontal ? _chunkDWGZUSEScjs.translateMatrix.call(void 0, d, 0) : _chunkDWGZUSEScjs.translateMatrix.call(void 0, 0, d));
+        if (Math.abs(d) > 1e-9) this.doc = this.transformed(this.doc, /* @__PURE__ */ new Set([item.id]), horizontal ? _chunkW3GXSUSQcjs.translateMatrix.call(void 0, d, 0) : _chunkW3GXSUSQcjs.translateMatrix.call(void 0, 0, d));
         cursor += size(item.b) + gap;
       }
     });
@@ -4747,14 +4747,14 @@ var VectorEditorController = (_class3 = class {
   }
   withDuplicates(doc, ids, offset, created) {
     const set = new Set(ids);
-    const m = _chunkDWGZUSEScjs.translateMatrix.call(void 0, offset.x, offset.y);
+    const m = _chunkW3GXSUSQcjs.translateMatrix.call(void 0, offset.x, offset.y);
     const insert = (list) => {
       const out = [];
       for (const node of list) {
         const n = node.type === "group" ? { ...node, children: insert(node.children) } : node;
         out.push(n);
         if (set.has(node.id)) {
-          const copy = _chunkUTEVPQTScjs.transformVectorNode.call(void 0, this.freshIds(node), m);
+          const copy = _chunkW3GXSUSQcjs.transformVectorNode.call(void 0, this.freshIds(node), m);
           created.push(copy.id);
           out.push(copy);
         }
@@ -4767,7 +4767,7 @@ var VectorEditorController = (_class3 = class {
   group(options = {}) {
     const ids = _nullishCoalesce(options.ids, () => ( this.selectedRoots()));
     if (!ids.length) return null;
-    const locs = ids.map((id2) => _chunkUTEVPQTScjs.locateVectorNode.call(void 0, this.doc.nodes, id2));
+    const locs = ids.map((id2) => _chunkW3GXSUSQcjs.locateVectorNode.call(void 0, this.doc.nodes, id2));
     if (locs.some((l) => !l)) return null;
     const parent = _nullishCoalesce(_optionalChain([locs, 'access', _158 => _158[0], 'access', _159 => _159.parent, 'optionalAccess', _160 => _160.id]), () => ( null));
     if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _161 => _161.parent, 'optionalAccess', _162 => _162.id]), () => ( null))) !== parent)) return null;
@@ -4804,9 +4804,9 @@ var VectorEditorController = (_class3 = class {
           if (set.has(n.id) && n.type === "group") {
             changed = true;
             const opacity = n.opacity;
-            const m = _chunkUTEVPQTScjs.nodeMatrix.call(void 0, n);
+            const m = _chunkW3GXSUSQcjs.nodeMatrix.call(void 0, n);
             out.push(
-              ...n.children.map((c) => c.blendStep ? (({ blendStep: _s, locked: _l, ...rest }) => rest)(c) : c).map((c) => c.booleanOperation ? (({ booleanOperation: _b, ...rest }) => rest)(c) : c).map((c) => n.transform ? _chunkUTEVPQTScjs.transformVectorNode.call(void 0, c, m) : c).map((c) => opacity !== void 0 && opacity < 1 ? { ...c, opacity: (_nullishCoalesce(c.opacity, () => ( 1))) * opacity } : c)
+              ...n.children.map((c) => c.blendStep ? (({ blendStep: _s, locked: _l, ...rest }) => rest)(c) : c).map((c) => c.booleanOperation ? (({ booleanOperation: _b, ...rest }) => rest)(c) : c).map((c) => n.transform ? _chunkW3GXSUSQcjs.transformVectorNode.call(void 0, c, m) : c).map((c) => opacity !== void 0 && opacity < 1 ? { ...c, opacity: (_nullishCoalesce(c.opacity, () => ( 1))) * opacity } : c)
             );
           } else if (n.type === "group") {
             const children = flatten(n.children);
@@ -4858,16 +4858,16 @@ var VectorEditorController = (_class3 = class {
     const result = _chunkXGD3FSNCcjs.pathBoolean.call(void 0, 
       BOOLEAN_OPS[op],
       entries.map((e) => ({
-        path: _chunkUTEVPQTScjs.vectorPathWorldBezier.call(void 0, { ...e.node, subpaths: e.node.subpaths.filter((s) => s.anchors.length > 1).map((s) => ({ ...s, closed: true })) }, e.parent),
+        path: _chunkW3GXSUSQcjs.vectorPathWorldBezier.call(void 0, { ...e.node, subpaths: e.node.subpaths.filter((s) => s.anchors.length > 1).map((s) => ({ ...s, closed: true })) }, e.parent),
         fillRule: _nullishCoalesce(e.node.fillRule, () => ( "nonzero"))
       }))
     );
     const base = entries[0].node;
     const anchorRoot = _nullishCoalesce(roots.find((r) => this.holds(r, base.id)), () => ( base.id));
-    const subpaths = _chunkUTEVPQTScjs.bezierToSubpaths.call(void 0, this.intoParentSpace(anchorRoot, result.path));
+    const subpaths = _chunkW3GXSUSQcjs.bezierToSubpaths.call(void 0, this.intoParentSpace(anchorRoot, result.path));
     if (result.error || !subpaths.length) return null;
     const id = this.newId();
-    const { transform: _t, effects: _e, booleanOperation: _b, ...baseRest } = _chunkUTEVPQTScjs.cloneVectorNode.call(void 0, base);
+    const { transform: _t, effects: _e, booleanOperation: _b, ...baseRest } = _chunkW3GXSUSQcjs.cloneVectorNode.call(void 0, base);
     const node = { ...baseRest, id, name: BOOLEAN_LABELS[op], subpaths };
     const drop = /* @__PURE__ */ new Set([...entries.map((e) => e.node.id), ...roots]);
     this.change(BOOLEAN_LABELS[op], () => {
@@ -4881,20 +4881,20 @@ var VectorEditorController = (_class3 = class {
   /** Whether stored node `rootId` holds `id` as drawn (`id` may be an expanded path inside it). */
   holds(rootId, id) {
     const n = this.getNode(rootId);
-    return !!n && (!!_chunkUTEVPQTScjs.findVectorNode.call(void 0, [n], id) || !!_chunkUTEVPQTScjs.findVectorNode.call(void 0, [_chunkUTEVPQTScjs.expandVectorAppearance.call(void 0, n)], id) || !!_chunkUTEVPQTScjs.findVectorNode.call(void 0, [_chunkUTEVPQTScjs.vectorMaskedGeometry.call(void 0, n)], id));
+    return !!n && (!!_chunkW3GXSUSQcjs.findVectorNode.call(void 0, [n], id) || !!_chunkW3GXSUSQcjs.findVectorNode.call(void 0, [_chunkW3GXSUSQcjs.expandVectorAppearance.call(void 0, n)], id) || !!_chunkW3GXSUSQcjs.findVectorNode.call(void 0, [_chunkW3GXSUSQcjs.vectorMaskedGeometry.call(void 0, n)], id));
   }
   liveBooleanOp(op, roots) {
     const nodes = roots.map((id2) => this.getNode(id2));
     if (!nodes.length || nodes.some((n) => !n)) return null;
     const label = `Live ${BOOLEAN_LABELS[op]}`;
     const lone = nodes.length === 1 ? nodes[0] : null;
-    if (_chunkUTEVPQTScjs.isVectorLiveBoolean.call(void 0, lone)) {
+    if (_chunkW3GXSUSQcjs.isVectorLiveBoolean.call(void 0, lone)) {
       const children = lone.children.map((c) => c.booleanOperation ? (({ booleanOperation: _b, ...rest }) => rest)(c) : c);
       this.change(label, () => this.replaceNode(lone.id, { ...lone, liveBoolean: op, children }));
       return lone.id;
     }
-    const parents = roots.map((id2) => _nullishCoalesce(_optionalChain([_chunkUTEVPQTScjs.locateVectorNode.call(void 0, this.doc.nodes, id2), 'optionalAccess', _164 => _164.parent]), () => ( null)));
-    if (parents.every((g) => _chunkUTEVPQTScjs.isVectorLiveBoolean.call(void 0, g))) {
+    const parents = roots.map((id2) => _nullishCoalesce(_optionalChain([_chunkW3GXSUSQcjs.locateVectorNode.call(void 0, this.doc.nodes, id2), 'optionalAccess', _164 => _164.parent]), () => ( null)));
+    if (parents.every((g) => _chunkW3GXSUSQcjs.isVectorLiveBoolean.call(void 0, g))) {
       const set = new Set(roots);
       this.change(
         label,
@@ -4945,8 +4945,8 @@ var VectorEditorController = (_class3 = class {
     const paths = entries.map((e) => e.node);
     const id = this.newId();
     const first = _nullishCoalesce(roots.find((r) => this.holds(r, paths[0].id)), () => ( paths[0].id));
-    const subpaths = entries.flatMap((e) => _chunkUTEVPQTScjs.bezierToSubpaths.call(void 0, this.intoParentSpace(first, _chunkUTEVPQTScjs.vectorPathWorldBezier.call(void 0, e.node, e.parent))));
-    const { transform: _t, effects: _e, booleanOperation: _b, ...baseRest } = _chunkUTEVPQTScjs.cloneVectorNode.call(void 0, paths[0]);
+    const subpaths = entries.flatMap((e) => _chunkW3GXSUSQcjs.bezierToSubpaths.call(void 0, this.intoParentSpace(first, _chunkW3GXSUSQcjs.vectorPathWorldBezier.call(void 0, e.node, e.parent))));
+    const { transform: _t, effects: _e, booleanOperation: _b, ...baseRest } = _chunkW3GXSUSQcjs.cloneVectorNode.call(void 0, paths[0]);
     const node = { ...baseRest, id, name: "Compound Path", subpaths };
     const drop = /* @__PURE__ */ new Set([...paths.map((p) => p.id), ...roots]);
     this.change("Combine", () => {
@@ -4958,8 +4958,8 @@ var VectorEditorController = (_class3 = class {
   }
   /** A document-space path mapped into the parent space of node `id`. */
   intoParentSpace(id, path) {
-    const parent = _nullishCoalesce(_chunkUTEVPQTScjs.vectorParentMatrix.call(void 0, this.doc.nodes, id), () => ( _chunkDWGZUSEScjs.IDENTITY_MATRIX));
-    return isRoot(parent) ? path : _chunkXGD3FSNCcjs.transformBezierPath.call(void 0, path, _chunkDWGZUSEScjs.invertMatrix.call(void 0, parent));
+    const parent = _nullishCoalesce(_chunkW3GXSUSQcjs.vectorParentMatrix.call(void 0, this.doc.nodes, id), () => ( _chunkW3GXSUSQcjs.IDENTITY_MATRIX));
+    return isRoot(parent) ? path : _chunkXGD3FSNCcjs.transformBezierPath.call(void 0, path, _chunkW3GXSUSQcjs.invertMatrix.call(void 0, parent));
   }
   /** Splits selected compound paths into one path per subpath. */
   breakApart(options = {}) {
@@ -5004,7 +5004,7 @@ var VectorEditorController = (_class3 = class {
     const topRoot = _nullishCoalesce([...roots].reverse().find((r) => this.holds(r, last)), () => ( last));
     const nodes = [];
     for (const piece of result.pieces) {
-      const subpaths = _chunkUTEVPQTScjs.bezierToSubpaths.call(void 0, this.intoParentSpace(topRoot, piece.path)).map((sp) => piece.open ? { ...sp, closed: false } : sp);
+      const subpaths = _chunkW3GXSUSQcjs.bezierToSubpaths.call(void 0, 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");
@@ -5031,7 +5031,7 @@ var VectorEditorController = (_class3 = class {
     const out = /* @__PURE__ */ new Map();
     for (const id of _nullishCoalesce(ids, () => ( this.selection))) {
       const node = this.getNode(id);
-      const group = isVectorBlendGroup(node) ? node : _optionalChain([_chunkUTEVPQTScjs.locateVectorNode.call(void 0, this.doc.nodes, id), 'optionalAccess', _169 => _169.parent]);
+      const group = isVectorBlendGroup(node) ? node : _optionalChain([_chunkW3GXSUSQcjs.locateVectorNode.call(void 0, this.doc.nodes, id), 'optionalAccess', _169 => _169.parent]);
       if (isVectorBlendGroup(group)) out.set(group.id, group);
     }
     return [...out.values()];
@@ -5048,7 +5048,7 @@ var VectorEditorController = (_class3 = class {
       return !!n && !n.blendStep && !n.locked;
     });
     if (ids.length < 2) return null;
-    const locs = ids.map((id2) => _chunkUTEVPQTScjs.locateVectorNode.call(void 0, this.doc.nodes, id2));
+    const locs = ids.map((id2) => _chunkW3GXSUSQcjs.locateVectorNode.call(void 0, this.doc.nodes, id2));
     const parent = _nullishCoalesce(_optionalChain([locs, 'access', _170 => _170[0], 'access', _171 => _171.parent, 'optionalAccess', _172 => _172.id]), () => ( null));
     if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _173 => _173.parent, 'optionalAccess', _174 => _174.id]), () => ( null))) !== parent)) return null;
     const order = input.keepOrder ? ids : ids.slice().sort((a, b) => locs[ids.indexOf(a)].index - locs[ids.indexOf(b)].index);
@@ -5088,7 +5088,7 @@ var VectorEditorController = (_class3 = class {
    * Returns the group's id, or why it could not.
    */
   makeMask(type, options = {}) {
-    if (!_chunkUTEVPQTScjs.isVectorMaskType.call(void 0, type)) return { ok: false, message: `Unknown mask type "${type}": use clip, alpha or luminance.` };
+    if (!_chunkW3GXSUSQcjs.isVectorMaskType.call(void 0, type)) return { ok: false, message: `Unknown mask type "${type}": use clip, alpha or luminance.` };
     const ids = [...new Set(_nullishCoalesce(options.ids, () => ( this.selectedRoots())))];
     if (ids.length < 2) return { ok: false, message: "Select at least two objects: the topmost becomes the mask, the ones below show through it." };
     for (const id2 of ids) {
@@ -5097,7 +5097,7 @@ var VectorEditorController = (_class3 = class {
       if (n.locked) return { ok: false, message: `"${id2}" is locked; unlock it first.` };
       if (n.blendStep) return { ok: false, message: `"${id2}" is a blend step; select its blend instead.` };
     }
-    const locs = ids.map((id2) => _chunkUTEVPQTScjs.locateVectorNode.call(void 0, this.doc.nodes, id2));
+    const locs = ids.map((id2) => _chunkW3GXSUSQcjs.locateVectorNode.call(void 0, this.doc.nodes, id2));
     const parent = _nullishCoalesce(_optionalChain([locs, 'access', _175 => _175[0], 'access', _176 => _176.parent, 'optionalAccess', _177 => _177.id]), () => ( null));
     if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _178 => _178.parent, 'optionalAccess', _179 => _179.id]), () => ( null))) !== parent)) return { ok: false, message: "The objects must share a parent (group them, or pick objects at one level)." };
     const order = ids.slice().sort((a, b) => locs[ids.indexOf(a)].index - locs[ids.indexOf(b)].index);
@@ -5131,10 +5131,10 @@ var VectorEditorController = (_class3 = class {
     const out = /* @__PURE__ */ new Map();
     for (const id of _nullishCoalesce(ids, () => ( this.selection))) {
       const n = this.getNode(id);
-      if (_chunkUTEVPQTScjs.isVectorMaskGroup.call(void 0, n)) out.set(n.id, n);
+      if (_chunkW3GXSUSQcjs.isVectorMaskGroup.call(void 0, n)) out.set(n.id, n);
       else {
-        const parent = _optionalChain([_chunkUTEVPQTScjs.locateVectorNode.call(void 0, this.doc.nodes, id), 'optionalAccess', _180 => _180.parent]);
-        if (_chunkUTEVPQTScjs.isVectorMaskGroup.call(void 0, parent)) out.set(parent.id, parent);
+        const parent = _optionalChain([_chunkW3GXSUSQcjs.locateVectorNode.call(void 0, this.doc.nodes, id), 'optionalAccess', _180 => _180.parent]);
+        if (_chunkW3GXSUSQcjs.isVectorMaskGroup.call(void 0, parent)) out.set(parent.id, parent);
       }
     }
     return [...out.values()];
@@ -5160,9 +5160,9 @@ var VectorEditorController = (_class3 = class {
           this.replaceNode(g.id, { ...rest, children });
           continue;
         }
-        const m = _chunkUTEVPQTScjs.nodeMatrix.call(void 0, g);
+        const m = _chunkW3GXSUSQcjs.nodeMatrix.call(void 0, g);
         const opacity = g.opacity;
-        const flat = children.map((c) => g.transform ? _chunkUTEVPQTScjs.transformVectorNode.call(void 0, c, m) : c).map((c) => opacity !== void 0 && opacity < 1 ? { ...c, opacity: (_nullishCoalesce(c.opacity, () => ( 1))) * opacity } : c);
+        const flat = children.map((c) => g.transform ? _chunkW3GXSUSQcjs.transformVectorNode.call(void 0, c, m) : c).map((c) => opacity !== void 0 && opacity < 1 ? { ...c, opacity: (_nullishCoalesce(c.opacity, () => ( 1))) * opacity } : c);
         this.setDoc(spliceTree(this.doc.nodes, g.id, flat));
       }
       this.selection = released;
@@ -5176,7 +5176,7 @@ var VectorEditorController = (_class3 = class {
    * (`enabled: false` hides the mask, so the contents draw whole) and on. One undo step.
    */
   setMaskOptions(patch, options = {}) {
-    if (patch.type !== void 0 && !_chunkUTEVPQTScjs.isVectorMaskType.call(void 0, patch.type)) return { ok: false, message: `Unknown mask type "${patch.type}": use clip, alpha or luminance.` };
+    if (patch.type !== void 0 && !_chunkW3GXSUSQcjs.isVectorMaskType.call(void 0, patch.type)) return { ok: false, message: `Unknown mask type "${patch.type}": use clip, alpha or luminance.` };
     if (patch.invert !== void 0 && typeof patch.invert !== "boolean") return { ok: false, message: "invert must be true or false." };
     if (patch.enabled !== void 0 && typeof patch.enabled !== "boolean") return { ok: false, message: "enabled must be true or false." };
     const groups = this.maskTargets(options.ids);
@@ -5185,7 +5185,7 @@ var VectorEditorController = (_class3 = class {
     this.change("Mask Options", () => {
       this.setDoc(
         mapTree(this.doc.nodes, (n) => {
-          if (!set.has(n.id) || !_chunkUTEVPQTScjs.isVectorMaskGroup.call(void 0, n)) return n;
+          if (!set.has(n.id) || !_chunkW3GXSUSQcjs.isVectorMaskGroup.call(void 0, n)) return n;
           const type = _nullishCoalesce(patch.type, () => ( n.mask.type));
           const invert = _nullishCoalesce(patch.invert, () => ( !!n.mask.invert));
           const [source, ...rest] = n.children;
@@ -5239,13 +5239,13 @@ var VectorEditorController = (_class3 = class {
     const node = this.getNode(nodeId);
     if (!isVectorBlendGroup(group)) return { ok: false, message: `"${blendId}" is not a blend.` };
     if (!node || node.blendStep || node.locked || node.id === blendId) return { ok: false, message: `"${nodeId}" cannot be a key.` };
-    const parentOf = (id) => _nullishCoalesce(_optionalChain([_chunkUTEVPQTScjs.locateVectorNode.call(void 0, this.doc.nodes, id), 'optionalAccess', _185 => _185.parent, 'optionalAccess', _186 => _186.id]), () => ( null));
+    const parentOf = (id) => _nullishCoalesce(_optionalChain([_chunkW3GXSUSQcjs.locateVectorNode.call(void 0, this.doc.nodes, id), 'optionalAccess', _185 => _185.parent, 'optionalAccess', _186 => _186.id]), () => ( null));
     if (parentOf(blendId) !== parentOf(nodeId)) return { ok: false, message: "The new key must sit beside the blend (same parent)." };
     const start = options.start;
     this.change("Blend", () => {
       const blend = start !== null && start !== void 0 ? { ...group.blend, starts: { ...group.blend.starts, [nodeId]: start } } : group.blend;
-      const m = _chunkDWGZUSEScjs.invertMatrix.call(void 0, _chunkUTEVPQTScjs.nodeMatrix.call(void 0, group));
-      const key = group.transform ? _chunkUTEVPQTScjs.transformVectorNode.call(void 0, node, m) : node;
+      const m = _chunkW3GXSUSQcjs.invertMatrix.call(void 0, _chunkW3GXSUSQcjs.nodeMatrix.call(void 0, group));
+      const key = group.transform ? _chunkW3GXSUSQcjs.transformVectorNode.call(void 0, node, m) : node;
       const without = mapTree(this.doc.nodes, (n) => n.id === nodeId ? null : n);
       this.setDoc(spliceTree(without, blendId, [{ ...group, blend, children: [...group.children, key] }]));
       this.selection = [blendId];
@@ -5271,7 +5271,7 @@ var VectorEditorController = (_class3 = class {
     if (!groups.length) return [];
     const set = new Set(groups.map((g) => g.id));
     const used = /* @__PURE__ */ new Set();
-    _chunkUTEVPQTScjs.walkVectorNodes.call(void 0, this.doc.nodes, (n) => used.add(n.id));
+    _chunkW3GXSUSQcjs.walkVectorNodes.call(void 0, this.doc.nodes, (n) => used.add(n.id));
     const fresh = () => {
       let id = this.createId();
       while (used.has(id)) id = this.createId();
@@ -5309,14 +5309,14 @@ var VectorEditorController = (_class3 = class {
   replaceBlendSpine(options = {}) {
     const roots = _nullishCoalesce(options.ids, () => ( this.selectedRoots()));
     const groups = this.blendTargets(roots);
-    const paths = roots.map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _187 => _187.type]) === "path" && !n.blendStep && !isVectorBlendGroup(_optionalChain([_chunkUTEVPQTScjs.locateVectorNode.call(void 0, this.doc.nodes, n.id), 'optionalAccess', _188 => _188.parent])));
+    const paths = roots.map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _187 => _187.type]) === "path" && !n.blendStep && !isVectorBlendGroup(_optionalChain([_chunkW3GXSUSQcjs.locateVectorNode.call(void 0, this.doc.nodes, n.id), 'optionalAccess', _188 => _188.parent])));
     if (groups.length !== 1 || paths.length !== 1) return { ok: false, message: "Select one blend and one path to be its spine." };
     const group = groups[0];
     const path = paths[0];
     const first = path.subpaths.find((sp) => sp.anchors.length >= 2);
     if (!first) return { ok: false, message: "The spine needs a path with at least two points." };
-    const m = _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, this.worldOf(path.id), _chunkDWGZUSEScjs.invertMatrix.call(void 0, this.worldOf(group.id)));
-    const spine = _chunkUTEVPQTScjs.transformVectorNode.call(void 0, { id: "", type: "path", subpaths: [first] }, m).subpaths[0];
+    const m = _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, this.worldOf(path.id), _chunkW3GXSUSQcjs.invertMatrix.call(void 0, this.worldOf(group.id)));
+    const spine = _chunkW3GXSUSQcjs.transformVectorNode.call(void 0, { id: "", type: "path", subpaths: [first] }, m).subpaths[0];
     this.change("Replace Spine", () => {
       const withSpine = { ...group, blend: { ...group.blend, spine } };
       const targets = vectorBlendKeyTargets(withSpine);
@@ -5324,11 +5324,11 @@ var VectorEditorController = (_class3 = class {
       const children = withSpine.children.map((c) => {
         if (c.blendStep) return c;
         const target = targets[k++];
-        const b = _chunkUTEVPQTScjs.vectorNodeBounds.call(void 0, c);
+        const b = _chunkW3GXSUSQcjs.vectorNodeBounds.call(void 0, c);
         if (!target || !b) return c;
         const dx = target[0] - (b.x + b.width / 2);
         const dy = target[1] - (b.y + b.height / 2);
-        return Math.hypot(dx, dy) > 1e-9 ? _chunkUTEVPQTScjs.transformVectorNode.call(void 0, c, _chunkDWGZUSEScjs.translateMatrix.call(void 0, dx, dy)) : c;
+        return Math.hypot(dx, dy) > 1e-9 ? _chunkW3GXSUSQcjs.transformVectorNode.call(void 0, c, _chunkW3GXSUSQcjs.translateMatrix.call(void 0, dx, dy)) : c;
       });
       this.setDoc(mapTree(this.doc.nodes, (n) => n.id === path.id ? null : n.id === group.id ? { ...withSpine, children } : n));
       this.selection = [group.id];
@@ -5396,15 +5396,15 @@ var VectorEditorController = (_class3 = class {
       let nodes = this.doc.nodes;
       m.entries.forEach((entry, i) => {
         const node = entry.node;
-        const toLocal = (path) => _chunkXGD3FSNCcjs.transformBezierPath.call(void 0, path, _chunkDWGZUSEScjs.invertMatrix.call(void 0, _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, _chunkUTEVPQTScjs.nodeMatrix.call(void 0, node), entry.parent)));
+        const toLocal = (path) => _chunkXGD3FSNCcjs.transformBezierPath.call(void 0, path, _chunkW3GXSUSQcjs.invertMatrix.call(void 0, _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, _chunkW3GXSUSQcjs.nodeMatrix.call(void 0, node), entry.parent)));
         const list = [];
         const r = plan.replace.get(i);
         if (r === void 0) list.push(node);
-        else if (_optionalChain([r, 'optionalAccess', _191 => _191.kind]) === "fill") list.push({ ...node, fillRule: "nonzero", subpaths: _chunkUTEVPQTScjs.bezierToSubpaths.call(void 0, toLocal(r.path)) });
-        else if (_optionalChain([r, 'optionalAccess', _192 => _192.kind]) === "outline") list.push({ ...node, subpaths: _chunkUTEVPQTScjs.bezierToSubpaths.call(void 0, toLocal(r.path)) });
+        else if (_optionalChain([r, 'optionalAccess', _191 => _191.kind]) === "fill") list.push({ ...node, fillRule: "nonzero", subpaths: _chunkW3GXSUSQcjs.bezierToSubpaths.call(void 0, toLocal(r.path)) });
+        else if (_optionalChain([r, 'optionalAccess', _192 => _192.kind]) === "outline") list.push({ ...node, subpaths: _chunkW3GXSUSQcjs.bezierToSubpaths.call(void 0, toLocal(r.path)) });
         else if (_optionalChain([r, 'optionalAccess', _193 => _193.kind]) === "pieces") {
           r.paths.forEach(
-            (path, k) => list.push({ ...node, id: k === 0 ? node.id : this.newId(), subpaths: _chunkUTEVPQTScjs.bezierToSubpaths.call(void 0, toLocal(path)).map((sp) => ({ ...sp, closed: false })) })
+            (path, k) => list.push({ ...node, id: k === 0 ? node.id : this.newId(), subpaths: _chunkW3GXSUSQcjs.bezierToSubpaths.call(void 0, toLocal(path)).map((sp) => ({ ...sp, closed: false })) })
           );
         }
         if (plan.merged && plan.merged.style === i) {
@@ -5415,9 +5415,9 @@ var VectorEditorController = (_class3 = class {
             id: mergedId,
             name: "Shape",
             ...node.transform ? { transform: node.transform } : {},
-            subpaths: _chunkUTEVPQTScjs.bezierToSubpaths.call(void 0, toLocal(plan.merged.path))
+            subpaths: _chunkW3GXSUSQcjs.bezierToSubpaths.call(void 0, toLocal(plan.merged.path))
           };
-          if (plan.merged.currentFill || !_chunkUTEVPQTScjs.hasPaint.call(void 0, merged.fill)) merged.fill = _chunkUTEVPQTScjs.hasPaint.call(void 0, this.defaults.fill) ? this.defaults.fill : "#808080";
+          if (plan.merged.currentFill || !_chunkW3GXSUSQcjs.hasPaint.call(void 0, merged.fill)) merged.fill = _chunkW3GXSUSQcjs.hasPaint.call(void 0, this.defaults.fill) ? this.defaults.fill : "#808080";
           list.push(merged);
         }
         if (r === void 0 && list.length === 1) return;
@@ -5454,14 +5454,14 @@ var VectorEditorController = (_class3 = class {
     if (!_optionalChain([region, 'optionalAccess', _200 => _200.length])) return null;
     let below = null;
     const roots = new Set(this.selectedRoots());
-    _chunkUTEVPQTScjs.walkVectorNodes.call(void 0, this.doc.nodes, (n) => {
+    _chunkW3GXSUSQcjs.walkVectorNodes.call(void 0, this.doc.nodes, (n) => {
       if (!below && roots.has(n.id)) below = n.id;
     });
-    const subpaths = _chunkUTEVPQTScjs.bezierToSubpaths.call(void 0, below ? this.intoParentSpace(below, region) : region);
+    const subpaths = _chunkW3GXSUSQcjs.bezierToSubpaths.call(void 0, 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 (!_chunkUTEVPQTScjs.hasPaint.call(void 0, node.fill)) node.fill = "#808080";
+    if (!_chunkW3GXSUSQcjs.hasPaint.call(void 0, node.fill)) node.fill = "#808080";
     const target = below;
     this.change("Fill Region", () => {
       if (target) {
@@ -5563,10 +5563,10 @@ var VectorEditorController = (_class3 = class {
   /** Moves anchors by a document-space offset (converted into each node's own space). */
   movedAnchors(doc, refs, dx, dy) {
     const local = /* @__PURE__ */ new Map();
-    for (const r of refs) if (!local.has(r.nodeId)) local.set(r.nodeId, _chunkDWGZUSEScjs.applyMatrixLinear.call(void 0, _chunkDWGZUSEScjs.invertMatrix.call(void 0, this.worldOf(r.nodeId, doc)), { x: dx, y: dy }));
+    for (const r of refs) if (!local.has(r.nodeId)) local.set(r.nodeId, _chunkW3GXSUSQcjs.applyMatrixLinear.call(void 0, _chunkW3GXSUSQcjs.invertMatrix.call(void 0, this.worldOf(r.nodeId, doc)), { x: dx, y: dy }));
     return this.updateAnchors(doc, refs, (a, ref) => {
       const d = local.get(ref.nodeId);
-      return _chunkUTEVPQTScjs.translateAnchor.call(void 0, a, d.x, d.y);
+      return _chunkW3GXSUSQcjs.translateAnchor.call(void 0, a, d.x, d.y);
     });
   }
   /**
@@ -5584,7 +5584,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 = _chunkUTEVPQTScjs.findVectorNode.call(void 0, doc.nodes, ref.nodeId);
+    const node = _chunkW3GXSUSQcjs.findVectorNode.call(void 0, doc.nodes, ref.nodeId);
     if (_optionalChain([node, 'optionalAccess', _205 => _205.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);
@@ -5593,7 +5593,7 @@ var VectorEditorController = (_class3 = class {
   }
   /** `doc` with segment `ref` bent through document point `p` at parameter `t`. */
   bent(doc, ref, t, p) {
-    const node = _chunkUTEVPQTScjs.findVectorNode.call(void 0, doc.nodes, ref.nodeId);
+    const node = _chunkW3GXSUSQcjs.findVectorNode.call(void 0, doc.nodes, ref.nodeId);
     if (_optionalChain([node, 'optionalAccess', _206 => _206.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);
@@ -5618,7 +5618,7 @@ var VectorEditorController = (_class3 = class {
     if (!getAnchor(this.doc, ref)) return { ok: false, message: "There is no such anchor." };
     const local = this.toLocal(ref.nodeId, to);
     this.change("Move Handle", () => {
-      this.doc = this.updateAnchors(this.doc, [ref], (a) => _chunkUTEVPQTScjs.moveAnchorHandle.call(void 0, a, ref.handle, local, options.breakHandles));
+      this.doc = this.updateAnchors(this.doc, [ref], (a) => _chunkW3GXSUSQcjs.moveAnchorHandle.call(void 0, a, ref.handle, local, options.breakHandles));
     });
     return { ok: true };
   }
@@ -5630,7 +5630,7 @@ var VectorEditorController = (_class3 = class {
         if (n.type !== "path") return n;
         const mine = refs.filter((r) => r.nodeId === n.id);
         if (!mine.length) return n;
-        const subpaths = n.subpaths.map((sp, s) => mine.filter((r) => r.subpath === s).reduce((acc, r) => _chunkUTEVPQTScjs.convertAnchor.call(void 0, acc, r.index, type), sp));
+        const subpaths = n.subpaths.map((sp, s) => mine.filter((r) => r.subpath === s).reduce((acc, r) => _chunkW3GXSUSQcjs.convertAnchor.call(void 0, acc, r.index, type), sp));
         return { ...n, subpaths };
       });
       this.setDoc(nodes);
@@ -5641,9 +5641,9 @@ var VectorEditorController = (_class3 = class {
   insertAnchorAt(nodeId, point) {
     const node = this.getNode(nodeId);
     if (_optionalChain([node, 'optionalAccess', _208 => _208.type]) !== "path") return null;
-    const hit = _chunkUTEVPQTScjs.nearestSegment.call(void 0, node, this.toLocal(nodeId, point));
+    const hit = _chunkW3GXSUSQcjs.nearestSegment.call(void 0, node, this.toLocal(nodeId, point));
     if (!hit) return null;
-    const { subpath, index } = _chunkUTEVPQTScjs.insertAnchor.call(void 0, node.subpaths[hit.subpath], hit.segment, hit.t);
+    const { subpath, index } = _chunkW3GXSUSQcjs.insertAnchor.call(void 0, node.subpaths[hit.subpath], hit.segment, hit.t);
     const ref = { nodeId, subpath: hit.subpath, index };
     this.change("Add Point", () => {
       this.replaceNode(nodeId, { ...node, subpaths: node.subpaths.map((sp, i) => i === hit.subpath ? subpath : sp) });
@@ -5668,7 +5668,7 @@ var VectorEditorController = (_class3 = class {
         const subpaths = n.subpaths.map((sp, s) => {
           const indices = mine.filter((r) => r.subpath === s).map((r) => r.index);
           if (!indices.length) return sp;
-          return keepShape ? removeAnchorsKeepingShape(sp, indices) : _chunkUTEVPQTScjs.removeAnchors.call(void 0, sp, indices);
+          return keepShape ? removeAnchorsKeepingShape(sp, indices) : _chunkW3GXSUSQcjs.removeAnchors.call(void 0, sp, indices);
         }).filter((sp) => sp.anchors.length > 1);
         return subpaths.length ? { ...n, subpaths } : null;
       });
@@ -5699,13 +5699,13 @@ var VectorEditorController = (_class3 = class {
   }
   /** Reverses the direction of every subpath of the selected paths. */
   reversePaths(ids = this.selection) {
-    const set = new Set(ids.flatMap((id) => this.getNode(id) ? _chunkUTEVPQTScjs.collectPathNodes.call(void 0, this.getNode(id)) : []).map((p) => p.id));
+    const set = new Set(ids.flatMap((id) => this.getNode(id) ? _chunkW3GXSUSQcjs.collectPathNodes.call(void 0, this.getNode(id)) : []).map((p) => p.id));
     if (!set.size) return { ok: false, message: "Select a path." };
     this.change("Reverse Path", () => {
       this.setDoc(
         mapTree(
           this.doc.nodes,
-          (n) => n.type === "path" && set.has(n.id) ? { ...n, subpaths: n.subpaths.map(_chunkUTEVPQTScjs.reverseSubpath), ..._optionalChain([n, 'access', _210 => _210.strokeWidthProfile, 'optionalAccess', _211 => _211.length]) ? { strokeWidthProfile: _chunkUTEVPQTScjs.reverseWidthProfile.call(void 0, n.strokeWidthProfile) } : {} } : n
+          (n) => n.type === "path" && set.has(n.id) ? { ...n, subpaths: n.subpaths.map(_chunkW3GXSUSQcjs.reverseSubpath), ..._optionalChain([n, 'access', _210 => _210.strokeWidthProfile, 'optionalAccess', _211 => _211.length]) ? { strokeWidthProfile: _chunkW3GXSUSQcjs.reverseWidthProfile.call(void 0, n.strokeWidthProfile) } : {} } : n
         )
       );
       this.anchors = [];
@@ -5722,20 +5722,20 @@ var VectorEditorController = (_class3 = class {
     for (const id of roots) {
       const node = this.getNode(id);
       if (node && !node.locked) {
-        for (const p of _chunkUTEVPQTScjs.collectPathNodes.call(void 0, node)) if (!p.locked) out.set(p.id, p);
+        for (const p of _chunkW3GXSUSQcjs.collectPathNodes.call(void 0, node)) if (!p.locked) out.set(p.id, p);
       }
     }
     const order = [];
-    _chunkUTEVPQTScjs.walkVectorNodes.call(void 0, this.doc.nodes, (n) => {
+    _chunkW3GXSUSQcjs.walkVectorNodes.call(void 0, this.doc.nodes, (n) => {
       if (out.has(n.id)) order.push(n.id);
     });
     return order.map((id) => out.get(id));
   }
   /** Subpaths of node `from` mapped into node `to`'s own space. */
   subpathsIn(from, to) {
-    const m = _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, this.worldOf(from.id), _chunkDWGZUSEScjs.invertMatrix.call(void 0, this.worldOf(to)));
+    const m = _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, this.worldOf(from.id), _chunkW3GXSUSQcjs.invertMatrix.call(void 0, this.worldOf(to)));
     if (isRoot(m)) return from.subpaths;
-    const map = (p) => _chunkDWGZUSEScjs.applyMatrix.call(void 0, m, p);
+    const map = (p) => _chunkW3GXSUSQcjs.applyMatrix.call(void 0, m, p);
     return from.subpaths.map((sp) => ({
       closed: sp.closed,
       anchors: sp.anchors.map((a) => ({ ...map(a), ...a.in ? { in: map(a.in) } : {}, ...a.out ? { out: map(a.out) } : {}, ...a.type ? { type: a.type } : {}, ...a.corner ? { corner: { ...a.corner } } : {} }))
@@ -5845,7 +5845,7 @@ var VectorEditorController = (_class3 = class {
     const node = this.getNode(nodeId);
     if (_optionalChain([node, 'optionalAccess', _212 => _212.type]) !== "path" || node.locked) return null;
     const local = this.toLocal(nodeId, point);
-    const hit = _chunkUTEVPQTScjs.nearestSegment.call(void 0, node, local);
+    const hit = _chunkW3GXSUSQcjs.nearestSegment.call(void 0, node, local);
     if (!hit) return null;
     const sp = node.subpaths[hit.subpath];
     const n = sp.anchors.length;
@@ -5889,25 +5889,25 @@ var VectorEditorController = (_class3 = class {
   /** Visible, unlocked paths a stroke over `points` can reach: in `ids`, the selection, or (with neither) any whose bounds it crosses. */
   strokeTargets(points, ids, pad) {
     const blocked = /* @__PURE__ */ new Set();
-    _chunkUTEVPQTScjs.walkVectorNodes.call(void 0, this.doc.nodes, (n, parent) => {
+    _chunkW3GXSUSQcjs.walkVectorNodes.call(void 0, this.doc.nodes, (n, parent) => {
       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', _213 => _213.length]) || this.selection.length) return this.pathTargets(_nullishCoalesce(ids, () => ( this.selection))).filter(visible);
-    const box = _chunkUTEVPQTScjs.polylineBounds.call(void 0, points.map(toPoint2), pad);
+    const box = _chunkW3GXSUSQcjs.polylineBounds.call(void 0, points.map(toPoint2), pad);
     if (!box) return [];
     const out = [];
-    _chunkUTEVPQTScjs.walkVectorNodes.call(void 0, this.doc.nodes, (n) => {
+    _chunkW3GXSUSQcjs.walkVectorNodes.call(void 0, this.doc.nodes, (n) => {
       if (n.type !== "path" || !visible(n)) return;
-      const b = _chunkUTEVPQTScjs.vectorNodeBounds.call(void 0, n, _nullishCoalesce(_chunkUTEVPQTScjs.vectorParentMatrix.call(void 0, this.doc.nodes, n.id), () => ( _chunkDWGZUSEScjs.IDENTITY_MATRIX)));
-      if (b && _chunkUTEVPQTScjs.boundsIntersect.call(void 0, b, box)) out.push(n);
+      const b = _chunkW3GXSUSQcjs.vectorNodeBounds.call(void 0, n, _nullishCoalesce(_chunkW3GXSUSQcjs.vectorParentMatrix.call(void 0, this.doc.nodes, n.id), () => ( _chunkW3GXSUSQcjs.IDENTITY_MATRIX)));
+      if (b && _chunkW3GXSUSQcjs.boundsIntersect.call(void 0, b, box)) out.push(n);
     });
     return out;
   }
   /** A stroke's points in node `id`'s own space. */
   localPoints(id, points) {
-    const inv = _chunkDWGZUSEScjs.invertMatrix.call(void 0, this.worldOf(id));
-    return points.map((p) => toPoint2(_chunkDWGZUSEScjs.applyMatrix.call(void 0, inv, p)));
+    const inv = _chunkW3GXSUSQcjs.invertMatrix.call(void 0, this.worldOf(id));
+    return points.map((p) => toPoint2(_chunkW3GXSUSQcjs.applyMatrix.call(void 0, inv, p)));
   }
   /**
    * Knife: cuts closed paths along the polyline `points` (document space) wherever it crosses
@@ -5916,14 +5916,14 @@ var VectorEditorController = (_class3 = class {
    * when nothing was cut).
    */
   knife(points, options = {}) {
-    const pts = _chunkUTEVPQTScjs.simplifyPolyline.call(void 0, points.map(toPoint2), 0.25 / this.viewport.zoom).map(([x, y]) => ({ x, y }));
+    const pts = _chunkW3GXSUSQcjs.simplifyPolyline.call(void 0, points.map(toPoint2), 0.25 / this.viewport.zoom).map(([x, y]) => ({ x, y }));
     if (pts.length < 2) return [];
     const plan = [];
     for (const node of this.strokeTargets(pts, options.ids, 0)) {
       const closed = node.subpaths.filter((sp) => sp.anchors.length > 1);
       if (!closed.length || closed.some((sp) => !sp.closed)) continue;
-      const result = _chunkUTEVPQTScjs.knifePath.call(void 0, _chunkUTEVPQTScjs.subpathsToBezier.call(void 0, closed), _nullishCoalesce(node.fillRule, () => ( "nonzero")), this.localPoints(node.id, pts));
-      if (result) plan.push({ node, pieces: result.map((path) => _chunkUTEVPQTScjs.bezierToSubpaths.call(void 0, path)) });
+      const result = _chunkW3GXSUSQcjs.knifePath.call(void 0, _chunkW3GXSUSQcjs.subpathsToBezier.call(void 0, closed), _nullishCoalesce(node.fillRule, () => ( "nonzero")), this.localPoints(node.id, pts));
+      if (result) plan.push({ node, pieces: result.map((path) => _chunkW3GXSUSQcjs.bezierToSubpaths.call(void 0, path)) });
     }
     if (!plan.length) return [];
     const created = [];
@@ -5945,22 +5945,22 @@ var VectorEditorController = (_class3 = class {
   erase(points, options = {}) {
     const width = _nullishCoalesce(options.size, () => ( this.editing.eraserSize));
     if (!(width > 0) || !points.length) return [];
-    const pts = _chunkUTEVPQTScjs.simplifyPolyline.call(void 0, points.map(toPoint2), Math.min(width * 0.05, 0.25 / this.viewport.zoom));
-    const region = _chunkUTEVPQTScjs.eraserRegion.call(void 0, pts, width);
+    const pts = _chunkW3GXSUSQcjs.simplifyPolyline.call(void 0, points.map(toPoint2), Math.min(width * 0.05, 0.25 / this.viewport.zoom));
+    const region = _chunkW3GXSUSQcjs.eraserRegion.call(void 0, pts, width);
     if (!region.length) return [];
     const plan = [];
     const rb = _chunkXGD3FSNCcjs.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 = _chunkXGD3FSNCcjs.transformBezierPath.call(void 0, region, _chunkDWGZUSEScjs.invertMatrix.call(void 0, this.worldOf(node.id)));
+      const local = _chunkXGD3FSNCcjs.transformBezierPath.call(void 0, region, _chunkW3GXSUSQcjs.invertMatrix.call(void 0, this.worldOf(node.id)));
       const live = node.subpaths.filter((sp) => sp.anchors.length > 1);
       if (!live.length) continue;
-      if (_chunkUTEVPQTScjs.hasPaint.call(void 0, node.fill) && live.every((sp) => sp.closed)) {
-        const faces = _chunkUTEVPQTScjs.eraseFromFill.call(void 0, _chunkUTEVPQTScjs.subpathsToBezier.call(void 0, live), _nullishCoalesce(node.fillRule, () => ( "nonzero")), local);
-        if (faces) plan.push({ node, pieces: faces.map((f) => _chunkUTEVPQTScjs.bezierToSubpaths.call(void 0, f)) });
+      if (_chunkW3GXSUSQcjs.hasPaint.call(void 0, node.fill) && live.every((sp) => sp.closed)) {
+        const faces = _chunkW3GXSUSQcjs.eraseFromFill.call(void 0, _chunkW3GXSUSQcjs.subpathsToBezier.call(void 0, live), _nullishCoalesce(node.fillRule, () => ( "nonzero")), local);
+        if (faces) plan.push({ node, pieces: faces.map((f) => _chunkW3GXSUSQcjs.bezierToSubpaths.call(void 0, f)) });
         continue;
       }
-      const results = live.map((sp) => _chunkUTEVPQTScjs.eraseFromOutline.call(void 0, sp, local));
+      const results = live.map((sp) => _chunkW3GXSUSQcjs.eraseFromOutline.call(void 0, sp, local));
       if (results.every((r) => !r)) continue;
       const subpaths = live.flatMap((sp, i) => _nullishCoalesce(results[i], () => ( [sp])));
       plan.push({ node, pieces: live.length === 1 ? subpaths.map((sp) => [sp]) : [subpaths] });
@@ -6002,7 +6002,7 @@ var VectorEditorController = (_class3 = class {
   // -------------------------------------------------------------------------
   /** Copies the selection. Returns JSON text for the system clipboard (or null). */
   copy() {
-    const nodes = this.selectedRoots().map((id) => this.getNode(id)).filter((n) => !!n).map((n) => _chunkUTEVPQTScjs.cloneVectorNode.call(void 0, n));
+    const nodes = this.selectedRoots().map((id) => this.getNode(id)).filter((n) => !!n).map((n) => _chunkW3GXSUSQcjs.cloneVectorNode.call(void 0, n));
     if (!nodes.length) return null;
     this.clipboard = nodes;
     return JSON.stringify({ type: VECTOR_CLIPBOARD_TYPE, nodes });
@@ -6029,7 +6029,7 @@ var VectorEditorController = (_class3 = class {
         }
       } else if (/<svg[\s>]/i.test(trimmed)) {
         try {
-          nodes = _chunkUTEVPQTScjs.parseVectorSvg.call(void 0, trimmed).nodes;
+          nodes = _chunkJLYX4V57cjs.parseVectorSvg.call(void 0, trimmed).nodes;
         } catch (e4) {
           nodes = null;
         }
@@ -6037,13 +6037,13 @@ var VectorEditorController = (_class3 = class {
     } else nodes = this.clipboard;
     if (!_optionalChain([nodes, 'optionalAccess', _217 => _217.length])) return [];
     const offset = _nullishCoalesce(options.offset, () => ( (text && !text.trim().startsWith("{") ? { x: 0, y: 0 } : { x: 10, y: 10 })));
-    const copies = nodes.map((n) => _chunkUTEVPQTScjs.transformVectorNode.call(void 0, this.freshIds(n), _chunkDWGZUSEScjs.translateMatrix.call(void 0, offset.x, offset.y)));
+    const copies = nodes.map((n) => _chunkW3GXSUSQcjs.transformVectorNode.call(void 0, this.freshIds(n), _chunkW3GXSUSQcjs.translateMatrix.call(void 0, offset.x, offset.y)));
     this.change("Paste", () => {
       this.setDoc([...this.doc.nodes, ...copies]);
       this.selection = copies.map((n) => n.id);
       this.anchors = [];
     });
-    if (!text) this.clipboard = copies.map((n) => _chunkUTEVPQTScjs.cloneVectorNode.call(void 0, n));
+    if (!text) this.clipboard = copies.map((n) => _chunkW3GXSUSQcjs.cloneVectorNode.call(void 0, n));
     return copies.map((n) => n.id);
   }
   // -------------------------------------------------------------------------
@@ -6127,7 +6127,7 @@ var VectorEditorController = (_class3 = class {
   /** Deepest unlocked visible path under `p`. */
   /** Live groups being edited (selected, or holding the selection or the edited path): their children are hit as stored. */
   enteredGroups() {
-    return _chunkUTEVPQTScjs.vectorEnteredGroups.call(void 0, this.doc.nodes, this.editingId ? [...this.selection, this.editingId] : this.selection);
+    return _chunkW3GXSUSQcjs.vectorEnteredGroups.call(void 0, this.doc.nodes, this.editingId ? [...this.selection, this.editingId] : this.selection);
   }
   hitPath(p) {
     const tol = this.tolerance();
@@ -6137,19 +6137,19 @@ var VectorEditorController = (_class3 = class {
         const n = list[i];
         if (n.visible === false || n.locked) continue;
         if (n.type === "group") {
-          if ((_chunkUTEVPQTScjs.hasOwnVectorAppearance.call(void 0, n) || _chunkUTEVPQTScjs.isVectorMaskActive.call(void 0, n)) && !entered.has(n.id) && !_chunkUTEVPQTScjs.hitTestVectorNode.call(void 0, n, p, tol, parent, { entered })) continue;
-          const found = search(n.children, _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, _chunkUTEVPQTScjs.nodeMatrix.call(void 0, n), parent));
+          if ((_chunkW3GXSUSQcjs.hasOwnVectorAppearance.call(void 0, n) || _chunkW3GXSUSQcjs.isVectorMaskActive.call(void 0, n)) && !entered.has(n.id) && !_chunkW3GXSUSQcjs.hitTestVectorNode.call(void 0, n, p, tol, parent, { entered })) continue;
+          const found = search(n.children, _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, _chunkW3GXSUSQcjs.nodeMatrix.call(void 0, n), parent));
           if (found) return found;
-        } else if (_chunkUTEVPQTScjs.hitTestVectorNode.call(void 0, n, p, tol, parent, { entered })) return n;
+        } else if (_chunkW3GXSUSQcjs.hitTestVectorNode.call(void 0, n, p, tol, parent, { entered })) return n;
       }
       return null;
     };
-    return search(this.doc.nodes, _chunkDWGZUSEScjs.IDENTITY_MATRIX);
+    return search(this.doc.nodes, _chunkW3GXSUSQcjs.IDENTITY_MATRIX);
   }
   /** Endpoints of open subpaths of unlocked visible paths (pen tool resumes from them). */
   openEndpoints() {
     const out = [];
-    _chunkUTEVPQTScjs.walkVectorNodes.call(void 0, this.doc.nodes, (n) => {
+    _chunkW3GXSUSQcjs.walkVectorNodes.call(void 0, this.doc.nodes, (n) => {
       if (n.type !== "path" || n.locked || n.visible === false) return;
       n.subpaths.forEach((sp, s) => {
         if (sp.closed || sp.anchors.length < 1) return;
@@ -6165,7 +6165,7 @@ var VectorEditorController = (_class3 = class {
       case "select": {
         const handle = this.hitTransformHandle(screen);
         if (handle) return { nodeId: null, transformHandle: handle };
-        const node = _chunkUTEVPQTScjs.hitTestVectorNodes.call(void 0, this.doc.nodes, p, this.tolerance(), { entered: this.enteredGroups() });
+        const node = _chunkW3GXSUSQcjs.hitTestVectorNodes.call(void 0, this.doc.nodes, p, this.tolerance(), { entered: this.enteredGroups() });
         return node ? { nodeId: node.id } : null;
       }
       case "direct": {
@@ -6177,9 +6177,9 @@ var VectorEditorController = (_class3 = class {
         if (widget) return { nodeId: widget.ref.nodeId, corner: widget.ref };
         for (const id of getEditablePathIds(this.view())) {
           const node = this.getNode(id);
-          const seg = _chunkUTEVPQTScjs.nearestSegment.call(void 0, node, this.toLocal(id, p));
+          const seg = _chunkW3GXSUSQcjs.nearestSegment.call(void 0, node, this.toLocal(id, p));
           if (seg && seg.distance <= this.tolerance()) {
-            const point = _chunkDWGZUSEScjs.applyMatrix.call(void 0, this.worldOf(id), seg.point);
+            const point = _chunkW3GXSUSQcjs.applyMatrix.call(void 0, this.worldOf(id), seg.point);
             return { nodeId: id, segment: { nodeId: id, subpath: seg.subpath, segment: seg.segment, t: seg.t, point } };
           }
         }
@@ -6216,7 +6216,7 @@ var VectorEditorController = (_class3 = class {
       case "envelope": {
         const hit = this.hitEnvelope(screen, p);
         if (hit) return { nodeId: hit.target.node.id, envelope: { nodeId: hit.target.node.id, index: hit.index } };
-        const node = _chunkUTEVPQTScjs.hitTestVectorNodes.call(void 0, this.doc.nodes, p, this.tolerance(), { entered: this.enteredGroups() });
+        const node = _chunkW3GXSUSQcjs.hitTestVectorNodes.call(void 0, this.doc.nodes, p, this.tolerance(), { entered: this.enteredGroups() });
         return node ? { nodeId: node.id } : null;
       }
       default:
@@ -6252,19 +6252,19 @@ var VectorEditorController = (_class3 = class {
   strokeSpotAt(p) {
     let best = null;
     const tol = this.tolerance();
-    _chunkUTEVPQTScjs.walkVectorNodes.call(void 0, this.doc.nodes, (n) => {
+    _chunkW3GXSUSQcjs.walkVectorNodes.call(void 0, this.doc.nodes, (n) => {
       if (n.type !== "path" || n.visible === false || n.locked) return;
       if (hiddenOrLocked(this.doc.nodes, n.id)) return;
       const g = vectorStrokeWidthGeometry(n);
       if (!g) return;
       const m = this.worldOf(n.id);
-      const local = _chunkDWGZUSEScjs.applyMatrix.call(void 0, _chunkDWGZUSEScjs.invertMatrix.call(void 0, m), p);
-      const near = _chunkUTEVPQTScjs.nearestStrokePosition.call(void 0, g.line, [local.x, local.y]);
+      const local = _chunkW3GXSUSQcjs.applyMatrix.call(void 0, _chunkW3GXSUSQcjs.invertMatrix.call(void 0, m), p);
+      const near = _chunkW3GXSUSQcjs.nearestStrokePosition.call(void 0, g.line, [local.x, local.y]);
       if (!near) return;
-      const profile = _chunkUTEVPQTScjs.strokeWidthProfileOf.call(void 0, n);
-      const w = _chunkUTEVPQTScjs.widthProfileAt.call(void 0, profile, near.t);
+      const profile = _chunkW3GXSUSQcjs.strokeWidthProfileOf.call(void 0, n);
+      const w = _chunkW3GXSUSQcjs.widthProfileAt.call(void 0, profile, near.t);
       const reach = Math.max(near.side === "left" ? w.left : w.right, 0) * g.unit + tol;
-      if (near.distance > reach || near.distance > _chunkUTEVPQTScjs.widthProfileMaxScale.call(void 0, profile) * g.unit + tol) return;
+      if (near.distance > reach || near.distance > _chunkW3GXSUSQcjs.widthProfileMaxScale.call(void 0, profile) * g.unit + tol) return;
       if (best && near.distance >= best.distance) return;
       const nx = near.tangent[1];
       const ny = -near.tangent[0];
@@ -6273,9 +6273,9 @@ var VectorEditorController = (_class3 = class {
         nodeId: n.id,
         subpath: near.contour,
         t: near.t,
-        point: _chunkDWGZUSEScjs.applyMatrix.call(void 0, m, { x: cx, y: cy }),
-        left: _chunkDWGZUSEScjs.applyMatrix.call(void 0, m, { x: cx + nx * w.left * g.unit, y: cy + ny * w.left * g.unit }),
-        right: _chunkDWGZUSEScjs.applyMatrix.call(void 0, m, { x: cx - nx * w.right * g.unit, y: cy - ny * w.right * g.unit }),
+        point: _chunkW3GXSUSQcjs.applyMatrix.call(void 0, m, { x: cx, y: cy }),
+        left: _chunkW3GXSUSQcjs.applyMatrix.call(void 0, m, { x: cx + nx * w.left * g.unit, y: cy + ny * w.left * g.unit }),
+        right: _chunkW3GXSUSQcjs.applyMatrix.call(void 0, m, { x: cx - nx * w.right * g.unit, y: cy - ny * w.right * g.unit }),
         distance: near.distance
       };
     });
@@ -6306,11 +6306,11 @@ var VectorEditorController = (_class3 = class {
     let t;
     let subpath;
     if (hit) {
-      profile = _chunkUTEVPQTScjs.sanitizeWidthProfile.call(void 0, node.strokeWidthProfile);
+      profile = _chunkW3GXSUSQcjs.sanitizeWidthProfile.call(void 0, node.strokeWidthProfile);
       ref = { nodeId: node.id, index: hit.ref.index, subpath: hit.ref.subpath };
       t = _nullishCoalesce(_optionalChain([profile, 'access', _225 => _225[ref.index], 'optionalAccess', _226 => _226.t]), () => ( 0));
       subpath = hit.ref.subpath;
-      if (hit.ref.part === "center") mode = input.alt && profile.length < _chunkUTEVPQTScjs.VECTOR_WIDTH_PROFILE_MAX_POINTS ? "copy" : "move";
+      if (hit.ref.part === "center") mode = input.alt && profile.length < _chunkW3GXSUSQcjs.VECTOR_WIDTH_PROFILE_MAX_POINTS ? "copy" : "move";
       else if (input.alt) side = hit.ref.part;
       const same = this.widthPoints.length > 0 && this.widthPoints[0].nodeId === node.id;
       const selected = same && this.widthPoints.some((r) => r.index === ref.index);
@@ -6325,8 +6325,8 @@ var VectorEditorController = (_class3 = class {
       } else if (mode === "copy" || !selected) this.widthPoints = [ref];
       if (mode !== "copy") group = this.widthPoints.filter((r) => r.index !== ref.index).map((r) => r.index);
     } else {
-      const near = _chunkUTEVPQTScjs.nearestStrokePosition.call(void 0, g.line, [local.x, local.y]);
-      const inserted = _chunkUTEVPQTScjs.insertWidthPoint.call(void 0, _chunkUTEVPQTScjs.strokeWidthProfileOf.call(void 0, node), near.t);
+      const near = _chunkW3GXSUSQcjs.nearestStrokePosition.call(void 0, g.line, [local.x, local.y]);
+      const inserted = _chunkW3GXSUSQcjs.insertWidthPoint.call(void 0, _chunkW3GXSUSQcjs.strokeWidthProfileOf.call(void 0, node), near.t);
       profile = inserted.points;
       subpath = near.contour;
       t = near.t;
@@ -6334,7 +6334,7 @@ var VectorEditorController = (_class3 = class {
       if (input.alt) side = near.side;
       this.widthPoints = [ref];
     }
-    const at = _chunkUTEVPQTScjs.strokePositionPoint.call(void 0, g.line, subpath, t);
+    const at = _chunkW3GXSUSQcjs.strokePositionPoint.call(void 0, g.line, subpath, t);
     if (!at) return;
     const base = { ...this.doc, nodes: mapTree(this.doc.nodes, (n) => n.id === node.id ? { ...n, strokeWidthProfile: profile } : n) };
     this.doc = base;
@@ -6368,16 +6368,16 @@ var VectorEditorController = (_class3 = class {
    */
   snapWidthT(drag, node, line2, t, skip) {
     const m = this.worldOf(node.id, drag.base);
-    const at = _chunkUTEVPQTScjs.strokePositionPoint.call(void 0, line2, drag.ref.subpath, t);
+    const at = _chunkW3GXSUSQcjs.strokePositionPoint.call(void 0, line2, drag.ref.subpath, t);
     if (!at) return t;
-    const here = this.documentToScreen(_chunkDWGZUSEScjs.applyMatrix.call(void 0, m, { x: at.point[0], y: at.point[1] }));
+    const here = this.documentToScreen(_chunkW3GXSUSQcjs.applyMatrix.call(void 0, m, { x: at.point[0], y: at.point[1] }));
     let best = t;
     let bestD = this.hitRadius;
     drag.profile.forEach((w, i) => {
       if (i === skip || drag.group.includes(i)) return;
-      const q = _chunkUTEVPQTScjs.strokePositionPoint.call(void 0, line2, drag.ref.subpath, w.t);
+      const q = _chunkW3GXSUSQcjs.strokePositionPoint.call(void 0, line2, drag.ref.subpath, w.t);
       if (!q) return;
-      const s = this.documentToScreen(_chunkDWGZUSEScjs.applyMatrix.call(void 0, m, { x: q.point[0], y: q.point[1] }));
+      const s = this.documentToScreen(_chunkW3GXSUSQcjs.applyMatrix.call(void 0, m, { x: q.point[0], y: q.point[1] }));
       const d = Math.hypot(s.x - here.x, s.y - here.y);
       if (d <= bestD) {
         best = w.t;
@@ -6394,18 +6394,18 @@ var VectorEditorController = (_class3 = class {
       for (let i = list.length - 1; i >= 0; i--) {
         const n = list[i];
         if (n.visible === false || n.locked) continue;
-        const m = _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, _chunkUTEVPQTScjs.nodeMatrix.call(void 0, n), parent);
+        const m = _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, _chunkW3GXSUSQcjs.nodeMatrix.call(void 0, n), parent);
         if (n.type === "group") {
           visit(n.children, m);
           continue;
         }
-        const hit = _chunkUTEVPQTScjs.nearestSegment.call(void 0, n, _chunkDWGZUSEScjs.applyMatrix.call(void 0, _chunkDWGZUSEScjs.invertMatrix.call(void 0, m), p));
+        const hit = _chunkW3GXSUSQcjs.nearestSegment.call(void 0, n, _chunkW3GXSUSQcjs.applyMatrix.call(void 0, _chunkW3GXSUSQcjs.invertMatrix.call(void 0, m), p));
         if (hit && hit.distance <= tol && (!best || hit.distance < best.distance - 1e-9)) {
-          best = { nodeId: n.id, subpath: hit.subpath, segment: hit.segment, t: hit.t, point: _chunkDWGZUSEScjs.applyMatrix.call(void 0, m, hit.point), distance: hit.distance };
+          best = { nodeId: n.id, subpath: hit.subpath, segment: hit.segment, t: hit.t, point: _chunkW3GXSUSQcjs.applyMatrix.call(void 0, m, hit.point), distance: hit.distance };
         }
       }
     };
-    visit(this.doc.nodes, _chunkDWGZUSEScjs.IDENTITY_MATRIX);
+    visit(this.doc.nodes, _chunkW3GXSUSQcjs.IDENTITY_MATRIX);
     if (!best) return null;
     const { distance: _d, ...seg } = best;
     return seg;
@@ -6462,7 +6462,7 @@ var VectorEditorController = (_class3 = class {
   }
   /** The shape under the pointer for the Blend tool, and the anchor of its first subpath under it. */
   blendHit(screen, p) {
-    const node = _chunkUTEVPQTScjs.hitTestVectorNodes.call(void 0, this.doc.nodes, p, this.tolerance());
+    const node = _chunkW3GXSUSQcjs.hitTestVectorNodes.call(void 0, this.doc.nodes, p, this.tolerance());
     if (!node) return null;
     let anchor = null;
     if (node.type === "path" && node.subpaths[0]) {
@@ -6505,13 +6505,13 @@ var VectorEditorController = (_class3 = class {
     if (handle) {
       const frame = this.frameOf(this.selectedRoots());
       const before = this.snapshot();
-      const center = _chunkDWGZUSEScjs.applyMatrix.call(void 0, _chunkDWGZUSEScjs.rotateMatrix.call(void 0, frame.angle), { x: frame.x + frame.width / 2, y: frame.y + frame.height / 2 });
+      const center = _chunkW3GXSUSQcjs.applyMatrix.call(void 0, _chunkW3GXSUSQcjs.rotateMatrix.call(void 0, frame.angle), { x: frame.x + frame.width / 2, y: frame.y + frame.height / 2 });
       this.drag = handle === "rotate" ? { kind: "rotate", start: p, center, before, base: this.doc } : { kind: "scale", handle, start: p, frame, before, base: this.doc };
       this.interaction = handle === "rotate" ? { type: "rotate", angle: 0 } : { type: "scale", handle, sx: 1, sy: 1 };
       this.notify();
       return;
     }
-    const node = _chunkUTEVPQTScjs.hitTestVectorNodes.call(void 0, this.doc.nodes, p, this.tolerance(), { entered: this.enteredGroups() });
+    const node = _chunkW3GXSUSQcjs.hitTestVectorNodes.call(void 0, this.doc.nodes, p, this.tolerance(), { entered: this.enteredGroups() });
     if (node) {
       const selected = this.selection.includes(node.id);
       if (input.shift) {
@@ -6579,12 +6579,12 @@ var VectorEditorController = (_class3 = class {
     }
     for (const id of getEditablePathIds(this.view())) {
       const node = this.getNode(id);
-      const seg = _chunkUTEVPQTScjs.nearestSegment.call(void 0, node, this.toLocal(id, p));
+      const seg = _chunkW3GXSUSQcjs.nearestSegment.call(void 0, node, this.toLocal(id, p));
       if (!seg || seg.distance > this.tolerance()) continue;
       const sp = node.subpaths[seg.subpath];
       if (input.alt) {
         const before = this.snapshot();
-        const { subpath, index } = _chunkUTEVPQTScjs.insertAnchor.call(void 0, sp, seg.segment, seg.t);
+        const { subpath, index } = _chunkW3GXSUSQcjs.insertAnchor.call(void 0, sp, seg.segment, seg.t);
         this.replaceNode(id, { ...node, subpaths: node.subpaths.map((s, i) => i === seg.subpath ? subpath : s) });
         const ref = { nodeId: id, subpath: seg.subpath, index };
         this.anchors = [ref];
@@ -6651,7 +6651,7 @@ var VectorEditorController = (_class3 = class {
       let node2 = this.getNode(endpoint.nodeId);
       let index = endpoint.index;
       if (index === 0 && node2.subpaths[endpoint.subpath].anchors.length > 1) {
-        node2 = { ...node2, subpaths: node2.subpaths.map((s, i) => i === endpoint.subpath ? _chunkUTEVPQTScjs.reverseSubpath.call(void 0, s) : s) };
+        node2 = { ...node2, subpaths: node2.subpaths.map((s, i) => i === endpoint.subpath ? _chunkW3GXSUSQcjs.reverseSubpath.call(void 0, s) : s) };
         this.replaceNode(node2.id, node2);
         index = node2.subpaths[endpoint.subpath].anchors.length - 1;
       }
@@ -6754,7 +6754,7 @@ var VectorEditorController = (_class3 = class {
           drag.targets = void 0;
         }
         ({ dx, dy } = this.snapMove(drag, dx, dy, input));
-        this.doc = this.transformed(drag.base, new Set(this.selectedRoots()), _chunkDWGZUSEScjs.translateMatrix.call(void 0, dx, dy));
+        this.doc = this.transformed(drag.base, new Set(this.selectedRoots()), _chunkW3GXSUSQcjs.translateMatrix.call(void 0, dx, dy));
         this.interaction = { type: "move", dx, dy };
         this.notify(true);
         return;
@@ -6762,7 +6762,7 @@ var VectorEditorController = (_class3 = class {
       case "scale": {
         if (this.freeDistort && drag.handle !== "rotate") return this.moveDistort(drag, p, input);
         const angle = drag.frame.angle;
-        const q = angle ? _chunkDWGZUSEScjs.applyMatrix.call(void 0, _chunkDWGZUSEScjs.rotateMatrix.call(void 0, -angle), p) : p;
+        const q = angle ? _chunkW3GXSUSQcjs.applyMatrix.call(void 0, _chunkW3GXSUSQcjs.rotateMatrix.call(void 0, -angle), p) : p;
         let { sx, sy, origin } = scaleFor(drag.handle, drag.frame, q, input);
         if (this.snap.objects && !input.mod && drag.handle !== "rotate") {
           drag.targets ??= VectorSnapTargets.forResize(drag.base, this.selectedRoots());
@@ -6771,7 +6771,7 @@ var VectorEditorController = (_class3 = class {
           this.setGuides(res);
         } else this.setGuides(null);
         const ids = new Set(this.selectedRoots());
-        this.doc = this.transformed(drag.base, ids, this.inFrame(angle, _chunkDWGZUSEScjs.scaleMatrix.call(void 0, sx, sy, origin)));
+        this.doc = this.transformed(drag.base, ids, this.inFrame(angle, _chunkW3GXSUSQcjs.scaleMatrix.call(void 0, sx, sy, origin)));
         this.interaction = { type: "scale", handle: drag.handle, sx, sy };
         this.notify(true);
         return;
@@ -6781,13 +6781,13 @@ var VectorEditorController = (_class3 = class {
         const a1 = Math.atan2(p.y - drag.center.y, p.x - drag.center.x);
         let angle = (a1 - a0) * 180 / Math.PI;
         if (input.shift) angle = Math.round(angle / 15) * 15;
-        this.doc = this.transformed(drag.base, new Set(this.selectedRoots()), _chunkDWGZUSEScjs.rotateMatrix.call(void 0, angle, drag.center));
+        this.doc = this.transformed(drag.base, new Set(this.selectedRoots()), _chunkW3GXSUSQcjs.rotateMatrix.call(void 0, angle, drag.center));
         this.interaction = { type: "rotate", angle };
         this.notify(true);
         return;
       }
       case "marquee": {
-        const bounds = _chunkUTEVPQTScjs.boundsFromPoints.call(void 0, drag.start, p);
+        const bounds = _chunkW3GXSUSQcjs.boundsFromPoints.call(void 0, drag.start, p);
         this.interaction = { type: "marquee", bounds };
         if (drag.anchorsMode) {
           const inside = getVisibleAnchors(this.view()).filter((r) => {
@@ -6797,8 +6797,8 @@ var VectorEditorController = (_class3 = class {
           this.anchors = [...drag.baseAnchors, ...inside.filter((r) => !drag.baseAnchors.some((b) => sameRef(b, r)))];
         } else {
           const hits = this.doc.nodes.filter((n) => !n.locked && n.visible !== false).filter((n) => {
-            const b = _chunkUTEVPQTScjs.vectorNodeBounds.call(void 0, n);
-            return b && _chunkUTEVPQTScjs.boundsIntersect.call(void 0, b, bounds);
+            const b = _chunkW3GXSUSQcjs.vectorNodeBounds.call(void 0, n);
+            return b && _chunkW3GXSUSQcjs.boundsIntersect.call(void 0, b, bounds);
           }).map((n) => n.id);
           this.selection = [.../* @__PURE__ */ new Set([...drag.base, ...hits])];
         }
@@ -6830,7 +6830,7 @@ var VectorEditorController = (_class3 = class {
         const leave = anchor ? { at: { x: anchor.x, y: anchor.y }, constrain: input.shift ? "angle" : null } : null;
         const pt = this.snapDrawn(p, leave, input, () => drag.targets ??= VectorSnapTargets.forHandle(drag.base, drag.ref.nodeId));
         const local = this.toLocal(drag.ref.nodeId, pt, drag.base);
-        this.doc = this.updateAnchors(drag.base, [drag.ref], (a) => _chunkUTEVPQTScjs.moveAnchorHandle.call(void 0, a, drag.ref.handle, local, input.alt));
+        this.doc = this.updateAnchors(drag.base, [drag.ref], (a) => _chunkW3GXSUSQcjs.moveAnchorHandle.call(void 0, a, drag.ref.handle, local, input.alt));
         this.interaction = { type: "handle", ref: drag.ref };
         this.notify(true);
         return;
@@ -6839,10 +6839,10 @@ var VectorEditorController = (_class3 = class {
         if (!drag.moved && Math.hypot(p.x - drag.start.x, p.y - drag.start.y) * this.viewport.zoom < 3) return;
         drag.moved = true;
         const c = drag.widget.corner;
-        const inv = _chunkDWGZUSEScjs.invertMatrix.call(void 0, this.worldOf(drag.widget.ref.nodeId, drag.base));
-        const d = _chunkDWGZUSEScjs.applyMatrixLinear.call(void 0, inv, { x: p.x - drag.start.x, y: p.y - drag.start.y });
-        const radius = Math.max(0, Math.min(c.maxRadius, drag.widget.drawnRadius + _chunkUTEVPQTScjs.cornerRadiusChange.call(void 0, c, d)));
-        this.doc = this.updateAnchors(drag.base, drag.refs, (a) => _chunkUTEVPQTScjs.setAnchorCorner.call(void 0, a, radius));
+        const inv = _chunkW3GXSUSQcjs.invertMatrix.call(void 0, this.worldOf(drag.widget.ref.nodeId, drag.base));
+        const d = _chunkW3GXSUSQcjs.applyMatrixLinear.call(void 0, inv, { x: p.x - drag.start.x, y: p.y - drag.start.y });
+        const radius = Math.max(0, Math.min(c.maxRadius, drag.widget.drawnRadius + _chunkW3GXSUSQcjs.cornerRadiusChange.call(void 0, c, d)));
+        this.doc = this.updateAnchors(drag.base, drag.refs, (a) => _chunkW3GXSUSQcjs.setAnchorCorner.call(void 0, a, radius));
         this.interaction = { type: "corner", ref: drag.widget.ref, radius };
         this.notify(true);
         return;
@@ -6879,8 +6879,8 @@ var VectorEditorController = (_class3 = class {
         const side = drag.closing ? "in" : "out";
         const pos = this.toLocal(drag.ref.nodeId, drag.closing ? { x: 2 * anchor.x - pt.x, y: 2 * anchor.y - pt.y } : pt, drag.base);
         this.doc = this.updateAnchors(drag.base, [drag.ref], (a) => {
-          if (drag.outOnly || drag.altBreaks && input.alt) return _chunkUTEVPQTScjs.moveAnchorHandle.call(void 0, a, side, pos, true);
-          return _chunkUTEVPQTScjs.moveAnchorHandle.call(void 0, { ...a, type: "symmetric" }, side, pos);
+          if (drag.outOnly || drag.altBreaks && input.alt) return _chunkW3GXSUSQcjs.moveAnchorHandle.call(void 0, a, side, pos, true);
+          return _chunkW3GXSUSQcjs.moveAnchorHandle.call(void 0, { ...a, type: "symmetric" }, side, pos);
         });
         this.notify(true);
         return;
@@ -6908,7 +6908,7 @@ var VectorEditorController = (_class3 = class {
           if (input.alt) start = { x: start.x - w, y: start.y - h };
           const x2 = drag.start.x + w;
           const y2 = drag.start.y + h;
-          bounds = _chunkUTEVPQTScjs.boundsFromPoints.call(void 0, start, { x: x2, y: y2 });
+          bounds = _chunkW3GXSUSQcjs.boundsFromPoints.call(void 0, start, { x: x2, y: y2 });
         }
         const shaped = this.createShapeNode({ kind: drag.tool, ...bounds });
         this.replaceNode(drag.nodeId, { ...node, subpaths: shaped.subpaths });
@@ -6919,32 +6919,32 @@ var VectorEditorController = (_class3 = class {
       case "width": {
         if (!drag.moved && Math.hypot(p.x - drag.start.x, p.y - drag.start.y) * this.viewport.zoom < 2) return;
         drag.moved = true;
-        const node = _chunkUTEVPQTScjs.findVectorNode.call(void 0, drag.base.nodes, drag.ref.nodeId);
+        const node = _chunkW3GXSUSQcjs.findVectorNode.call(void 0, drag.base.nodes, drag.ref.nodeId);
         const local = this.toLocal(node.id, p, drag.base);
         const src = drag.profile[drag.source];
         let profile;
         let index = drag.source;
         if (drag.mode !== "width") {
           const g = vectorStrokeWidthGeometry(node);
-          const near = g ? _chunkUTEVPQTScjs.nearestStrokePosition.call(void 0, g.line, [local.x, local.y], drag.ref.subpath) : null;
+          const near = g ? _chunkW3GXSUSQcjs.nearestStrokePosition.call(void 0, g.line, [local.x, local.y], drag.ref.subpath) : null;
           if (!g || !near) return;
           const t = drag.group.length ? near.t : this.snapWidthT(drag, node, g.line, near.t, drag.source);
           if (drag.mode === "copy") {
-            ({ points: profile, index } = _chunkUTEVPQTScjs.insertWidthPoint.call(void 0, drag.profile, t, { left: src.left, right: src.right }, { step: true }));
+            ({ points: profile, index } = _chunkW3GXSUSQcjs.insertWidthPoint.call(void 0, drag.profile, t, { left: src.left, right: src.right }, { step: true }));
           } else if (drag.group.length) {
             const shifted = shiftWidthPoints(drag.profile, [drag.source, ...drag.group], t - src.t);
             profile = shifted.points;
             drag.renumber = shifted.renumber;
             index = _nullishCoalesce(shifted.renumber.get(drag.source), () => ( drag.source));
-          } else profile = _chunkUTEVPQTScjs.setWidthPoint.call(void 0, drag.profile, drag.source, { t });
+          } else profile = _chunkW3GXSUSQcjs.setWidthPoint.call(void 0, drag.profile, drag.source, { t });
         } else {
           const off = ((local.x - drag.origin.x) * drag.normal.x + (local.y - drag.origin.y) * drag.normal.y) / drag.unit;
           const patch = drag.side === "both" ? { left: Math.abs(off), right: Math.abs(off) } : drag.side === "left" ? { left: Math.max(0, off) } : { right: Math.max(0, -off) };
-          profile = _chunkUTEVPQTScjs.setWidthPoint.call(void 0, drag.profile, drag.source, patch);
+          profile = _chunkW3GXSUSQcjs.setWidthPoint.call(void 0, drag.profile, drag.source, patch);
           if (drag.group.length) {
             const dl = profile[drag.source].left - src.left;
             const dr = profile[drag.source].right - src.right;
-            for (const i of drag.group) profile = _chunkUTEVPQTScjs.setWidthPoint.call(void 0, profile, i, { left: Math.max(0, drag.profile[i].left + dl), right: Math.max(0, drag.profile[i].right + dr) });
+            for (const i of drag.group) profile = _chunkW3GXSUSQcjs.setWidthPoint.call(void 0, profile, i, { left: Math.max(0, drag.profile[i].left + dl), right: Math.max(0, drag.profile[i].right + dr) });
           }
         }
         this.doc = { ...drag.base, nodes: mapTree(drag.base.nodes, (n) => n.id === node.id ? { ...n, strokeWidthProfile: profile } : n) };
@@ -7089,8 +7089,8 @@ var VectorEditorController = (_class3 = class {
       case "corner": {
         if (drag.moved) return this.commit("Corner Radius", drag.before);
         if (drag.alt) {
-          const kind = _chunkUTEVPQTScjs.nextVectorCornerKind.call(void 0, drag.widget.kind);
-          this.doc = this.updateAnchors(drag.base, drag.refs, (a) => _chunkUTEVPQTScjs.setAnchorCorner.call(void 0, a, _nullishCoalesce(_optionalChain([a, 'access', _243 => _243.corner, 'optionalAccess', _244 => _244.radius]), () => ( 0)), kind));
+          const kind = _chunkW3GXSUSQcjs.nextVectorCornerKind.call(void 0, drag.widget.kind);
+          this.doc = this.updateAnchors(drag.base, drag.refs, (a) => _chunkW3GXSUSQcjs.setAnchorCorner.call(void 0, a, _nullishCoalesce(_optionalChain([a, 'access', _243 => _243.corner, 'optionalAccess', _244 => _244.radius]), () => ( 0)), kind));
           return this.commit("Corner Kind", drag.before);
         }
         const ref = drag.widget.ref;
@@ -7135,7 +7135,7 @@ var VectorEditorController = (_class3 = class {
         return this.commit(drag.label, drag.before);
       case "shape": {
         const node = this.getNode(drag.nodeId);
-        const b = node ? _chunkUTEVPQTScjs.vectorNodeBounds.call(void 0, node) : null;
+        const b = node ? _chunkW3GXSUSQcjs.vectorNodeBounds.call(void 0, node) : null;
         const min = 2 / this.viewport.zoom;
         if (!b || b.width < min && b.height < min) {
           this.doc = drag.before.doc;
@@ -7171,7 +7171,7 @@ var VectorEditorController = (_class3 = class {
           anchors[anchors.length - 1].out = { x: c.p1[0], y: c.p1[1] };
           anchors.push({ x: c.p3[0], y: c.p3[1], in: { x: c.p2[0], y: c.p2[1] } });
         }
-        const subpaths = anchors.length > 1 ? _chunkUTEVPQTScjs.bezierToSubpaths.call(void 0, _chunkUTEVPQTScjs.subpathsToBezier.call(void 0, [{ anchors, closed: false }])) : node.subpaths;
+        const subpaths = anchors.length > 1 ? _chunkW3GXSUSQcjs.bezierToSubpaths.call(void 0, _chunkW3GXSUSQcjs.subpathsToBezier.call(void 0, [{ anchors, closed: false }])) : node.subpaths;
         const profile = drag.pressures ? pencilPressureProfile(drag.points, drag.pressures) : [];
         this.replaceNode(drag.nodeId, { ...node, subpaths, ...profile.length ? { strokeWidthProfile: profile } : {} });
         this.selection = [drag.nodeId];
@@ -7234,7 +7234,7 @@ var VectorEditorController = (_class3 = class {
       const id = _nullishCoalesce(_optionalChain([this, 'access', _252 => _252.hover, 'optionalAccess', _253 => _253.segment, 'optionalAccess', _254 => _254.nodeId]), () => ( this.editingId));
       if (id) {
         const node = this.getNode(id);
-        const seg = node ? _chunkUTEVPQTScjs.nearestSegment.call(void 0, node, this.toLocal(id, p)) : null;
+        const seg = node ? _chunkW3GXSUSQcjs.nearestSegment.call(void 0, node, this.toLocal(id, p)) : null;
         if (seg && seg.distance <= this.tolerance()) this.insertAnchorAt(id, p);
       }
       return;
@@ -7387,11 +7387,11 @@ function inkShapeLabel(shape) {
 function inkShapeSubpath(shape) {
   switch (shape.kind) {
     case "line":
-      return _chunkUTEVPQTScjs.lineSubpath.call(void 0, { x: shape.a[0], y: shape.a[1] }, { x: shape.b[0], y: shape.b[1] });
+      return _chunkW3GXSUSQcjs.lineSubpath.call(void 0, { x: shape.a[0], y: shape.a[1] }, { x: shape.b[0], y: shape.b[1] });
     case "rect":
-      return _chunkUTEVPQTScjs.rectSubpath.call(void 0, shape);
+      return _chunkW3GXSUSQcjs.rectSubpath.call(void 0, shape);
     case "ellipse":
-      return _chunkUTEVPQTScjs.ellipseSubpath.call(void 0, shape);
+      return _chunkW3GXSUSQcjs.ellipseSubpath.call(void 0, shape);
     case "polygon":
       return { anchors: shape.points.map(([x, y]) => ({ x, y })), closed: true };
   }
@@ -7428,17 +7428,17 @@ function withStyle(node, style) {
   const { fills, strokes, ...shorthand } = style;
   let next = { ...node, ...shorthand };
   if ("strokeWidthProfile" in style) {
-    const p = style.strokeWidthProfile ? _chunkUTEVPQTScjs.sanitizeWidthProfile.call(void 0, style.strokeWidthProfile) : [];
+    const p = style.strokeWidthProfile ? _chunkW3GXSUSQcjs.sanitizeWidthProfile.call(void 0, style.strokeWidthProfile) : [];
     if (p.length) next.strokeWidthProfile = p;
     else delete next.strokeWidthProfile;
   }
-  next = _chunkUTEVPQTScjs.normalizeVectorPaintStacks.call(void 0, next, "shorthand");
-  if (fills !== void 0) next = _chunkUTEVPQTScjs.withVectorFills.call(void 0, next, _chunkUTEVPQTScjs.sanitizeVectorFills.call(void 0, _nullishCoalesce(fills, () => ( []))));
-  if (strokes !== void 0) next = _chunkUTEVPQTScjs.withVectorStrokes.call(void 0, next, _chunkUTEVPQTScjs.sanitizeVectorStrokes.call(void 0, _nullishCoalesce(strokes, () => ( []))));
+  next = _chunkW3GXSUSQcjs.normalizeVectorPaintStacks.call(void 0, next, "shorthand");
+  if (fills !== void 0) next = _chunkW3GXSUSQcjs.withVectorFills.call(void 0, next, _chunkW3GXSUSQcjs.sanitizeVectorFills.call(void 0, _nullishCoalesce(fills, () => ( []))));
+  if (strokes !== void 0) next = _chunkW3GXSUSQcjs.withVectorStrokes.call(void 0, next, _chunkW3GXSUSQcjs.sanitizeVectorStrokes.call(void 0, _nullishCoalesce(strokes, () => ( []))));
   return next;
 }
 function hiddenOrLocked(nodes, id) {
-  const loc = _chunkUTEVPQTScjs.locateVectorNode.call(void 0, nodes, id);
+  const loc = _chunkW3GXSUSQcjs.locateVectorNode.call(void 0, nodes, id);
   if (!loc) return false;
   const n = loc.list[loc.index];
   if (n.locked || n.visible === false) return true;
@@ -7451,7 +7451,7 @@ function pencilPressureProfile(points, pressures) {
   for (let i = 1; i < n; i++) s.push(s[i - 1] + Math.hypot(points[i][0] - points[i - 1][0], points[i][1] - points[i - 1][1]));
   const total = s[n - 1];
   if (!(total > 0)) return [];
-  return _chunkUTEVPQTScjs.pressureWidthProfile.call(void 0, s.map((d, i) => ({ t: d / total, pressure: pressures[i] })));
+  return _chunkW3GXSUSQcjs.pressureWidthProfile.call(void 0, s.map((d, i) => ({ t: d / total, pressure: pressures[i] })));
 }
 
 // src/vector/render.ts
@@ -7460,9 +7460,9 @@ var fmtMatrix = (m) => `matrix(${m.map((n) => Math.round(n * 1e6) / 1e6).join("
 var VECTOR_BUILDER_HATCH_GAP = 6;
 function nodeFinish(node, filters, idPrefix) {
   const out = {};
-  const blend = _chunkUTEVPQTScjs.vectorBlendModeCss.call(void 0, node.blendMode);
+  const blend = _chunkW3GXSUSQcjs.vectorBlendModeCss.call(void 0, node.blendMode);
   if (blend) out.blendMode = blend;
-  const filter = _chunkUTEVPQTScjs.vectorNodeFilterSvg.call(void 0, node, `${idPrefix}filter-${node.id}`);
+  const filter = _chunkJLYX4V57cjs.vectorNodeFilterSvg.call(void 0, node, `${idPrefix}filter-${node.id}`);
   if (filter) {
     filters.push(filter);
     out.filter = `url(#${filter.id})`;
@@ -7479,16 +7479,16 @@ function lineStyle(node) {
 }
 function renderLayers(node, defs, idPrefix) {
   const out = [];
-  for (const l of _chunkUTEVPQTScjs.vectorPaintLayerNodes.call(void 0, node)) {
+  for (const l of _chunkW3GXSUSQcjs.vectorPaintLayerNodes.call(void 0, node)) {
     if (!l.drawn) continue;
     const role = l.kind;
-    const paint = _chunkUTEVPQTScjs.vectorPaintToSvg.call(void 0, l.layer.paint, `${idPrefix}${role}-${node.id}-${l.index}`, { node: l.node, ...role === "stroke" ? { role } : {} });
+    const paint = _chunkJLYX4V57cjs.vectorPaintToSvg.call(void 0, l.layer.paint, `${idPrefix}${role}-${node.id}-${l.index}`, { node: l.node, ...role === "stroke" ? { role } : {} });
     defs.push(...paint.defs);
-    const blend = _chunkUTEVPQTScjs.vectorBlendModeCss.call(void 0, l.layer.blendMode);
+    const blend = _chunkW3GXSUSQcjs.vectorBlendModeCss.call(void 0, l.layer.blendMode);
     const base = { kind: role, index: l.index, opacity: _nullishCoalesce(l.layer.opacity, () => ( 1)), ...blend ? { blendMode: blend } : {} };
     if (role === "fill") out.push({ ...base, fill: paint.value, stroke: "none", strokeWidth: 0 });
     else {
-      const strokeParts = _chunkUTEVPQTScjs.vectorStrokeSvgParts.call(void 0, l.node, `${idPrefix}clip-${node.id}-${l.index}`);
+      const strokeParts = _chunkJLYX4V57cjs.vectorStrokeSvgParts.call(void 0, l.node, `${idPrefix}clip-${node.id}-${l.index}`);
       out.push({ ...base, fill: "none", stroke: paint.value, ...lineStyle(l.node), ...strokeParts ? { strokeParts } : {} });
     }
   }
@@ -7496,11 +7496,11 @@ function renderLayers(node, defs, idPrefix) {
 }
 function renderNode(stored, defs, filters, idPrefix) {
   if (stored.visible === false) return null;
-  const node = _chunkUTEVPQTScjs.expandVectorAppearance.call(void 0, stored);
+  const node = _chunkW3GXSUSQcjs.expandVectorAppearance.call(void 0, stored);
   if (node.type === "group") {
     const finish2 = nodeFinish(node, filters, idPrefix);
-    const masked = _chunkUTEVPQTScjs.isVectorMaskGroup.call(void 0, node) ? renderMask(node, defs, filters, idPrefix) : null;
-    const list = _chunkUTEVPQTScjs.isVectorMaskGroup.call(void 0, node) ? node.children.slice(1) : node.children;
+    const masked = _chunkW3GXSUSQcjs.isVectorMaskGroup.call(void 0, node) ? renderMask(node, defs, filters, idPrefix) : null;
+    const list = _chunkW3GXSUSQcjs.isVectorMaskGroup.call(void 0, node) ? node.children.slice(1) : node.children;
     const children = list.map((c) => renderNode(c, defs, filters, idPrefix)).filter((c) => !!c);
     return {
       kind: "group",
@@ -7517,12 +7517,12 @@ function renderNode(stored, defs, filters, idPrefix) {
     kind: "path",
     id: node.id,
     ...node.transform ? { transform: fmtMatrix(node.transform) } : {},
-    d: _chunkUTEVPQTScjs.vectorPathData.call(void 0, node),
+    d: _chunkW3GXSUSQcjs.vectorPathData.call(void 0, node),
     fillRule: _nullishCoalesce(node.fillRule, () => ( "nonzero")),
     opacity: _nullishCoalesce(node.opacity, () => ( 1)),
     ...finish
   };
-  if (_chunkUTEVPQTScjs.needsVectorPaintLayers.call(void 0, node)) {
+  if (_chunkW3GXSUSQcjs.needsVectorPaintLayers.call(void 0, node)) {
     const layers = renderLayers(node, defs, idPrefix);
     const fill2 = layers.filter((l) => l.kind === "fill").at(-1);
     const stroke2 = layers.filter((l) => l.kind === "stroke").at(-1);
@@ -7538,10 +7538,10 @@ function renderNode(stored, defs, filters, idPrefix) {
       layers
     };
   }
-  const fill = _chunkUTEVPQTScjs.vectorPaintToSvg.call(void 0, node.fill, `${idPrefix}fill-${node.id}`, { node });
-  const stroke = _chunkUTEVPQTScjs.vectorPaintToSvg.call(void 0, node.stroke, `${idPrefix}stroke-${node.id}`, { node, role: "stroke" });
+  const fill = _chunkJLYX4V57cjs.vectorPaintToSvg.call(void 0, node.fill, `${idPrefix}fill-${node.id}`, { node });
+  const stroke = _chunkJLYX4V57cjs.vectorPaintToSvg.call(void 0, node.stroke, `${idPrefix}stroke-${node.id}`, { node, role: "stroke" });
   defs.push(...fill.defs, ...stroke.defs);
-  const strokeParts = stroke.value !== "none" ? _chunkUTEVPQTScjs.vectorStrokeSvgParts.call(void 0, node, `${idPrefix}clip-${node.id}`) : void 0;
+  const strokeParts = stroke.value !== "none" ? _chunkJLYX4V57cjs.vectorStrokeSvgParts.call(void 0, node, `${idPrefix}clip-${node.id}`) : void 0;
   return {
     ...common,
     ...strokeParts ? { strokeParts } : {},
@@ -7551,8 +7551,8 @@ function renderNode(stored, defs, filters, idPrefix) {
   };
 }
 function renderMask(group, defs, filters, idPrefix) {
-  if (!_chunkUTEVPQTScjs.isVectorMaskActive.call(void 0, group)) return null;
-  const data = _chunkUTEVPQTScjs.vectorMaskRenderData.call(void 0, group, `${idPrefix}mask-${group.id}`, `${idPrefix}mask-filter-${group.id}`);
+  if (!_chunkW3GXSUSQcjs.isVectorMaskActive.call(void 0, group)) return null;
+  const data = _chunkW3GXSUSQcjs.vectorMaskRenderData.call(void 0, group, `${idPrefix}mask-${group.id}`, `${idPrefix}mask-filter-${group.id}`);
   if (!data) return null;
   const { invertFilter, ...mask } = data;
   if (invertFilter) filters.push(invertFilter);
@@ -7580,17 +7580,17 @@ var toScreen = (state, p) => ({ x: p.x * state.viewport.zoom + state.viewport.x,
 function screenOutline(state, node, entered) {
   const v = state.viewport;
   const view = [v.zoom, 0, 0, v.zoom, v.x, v.y];
-  const parent = _nullishCoalesce(_chunkUTEVPQTScjs.vectorParentMatrix.call(void 0, state.document.nodes, node.id), () => ( _chunkDWGZUSEScjs.IDENTITY_MATRIX));
+  const parent = _nullishCoalesce(_chunkW3GXSUSQcjs.vectorParentMatrix.call(void 0, state.document.nodes, node.id), () => ( _chunkW3GXSUSQcjs.IDENTITY_MATRIX));
   return outlinePaths(node, parent, entered).map((path) => _chunkXGD3FSNCcjs.bezierPathToSvg.call(void 0, _chunkXGD3FSNCcjs.transformBezierPath.call(void 0, path, view), { precision: 2 })).join(" ");
 }
 function outlinePaths(node, parent, entered) {
-  if (node.type === "path") return [_chunkUTEVPQTScjs.vectorPathWorldBezier.call(void 0, node, parent, { effects: false })];
-  const m = _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, _chunkUTEVPQTScjs.nodeMatrix.call(void 0, node), parent);
-  if ((_chunkUTEVPQTScjs.hasOwnVectorAppearance.call(void 0, node) || _chunkUTEVPQTScjs.isVectorMaskActive.call(void 0, node)) && !entered.has(node.id)) return [_chunkXGD3FSNCcjs.transformBezierPath.call(void 0, _chunkUTEVPQTScjs.vectorAppearanceOutline.call(void 0, node), m)];
+  if (node.type === "path") return [_chunkW3GXSUSQcjs.vectorPathWorldBezier.call(void 0, node, parent, { effects: false })];
+  const m = _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, _chunkW3GXSUSQcjs.nodeMatrix.call(void 0, node), parent);
+  if ((_chunkW3GXSUSQcjs.hasOwnVectorAppearance.call(void 0, node) || _chunkW3GXSUSQcjs.isVectorMaskActive.call(void 0, node)) && !entered.has(node.id)) return [_chunkXGD3FSNCcjs.transformBezierPath.call(void 0, _chunkW3GXSUSQcjs.vectorAppearanceOutline.call(void 0, node), m)];
   return node.children.filter((c) => c.visible !== false).flatMap((c) => outlinePaths(c, m, entered));
 }
 function getVectorEnteredGroups(state) {
-  return _chunkUTEVPQTScjs.vectorEnteredGroups.call(void 0, state.document.nodes, state.editingId ? [...state.selection, state.editingId] : state.selection);
+  return _chunkW3GXSUSQcjs.vectorEnteredGroups.call(void 0, state.document.nodes, state.editingId ? [...state.selection, state.editingId] : state.selection);
 }
 function collect(node) {
   if (node.type === "path") return [node];
@@ -7604,7 +7604,7 @@ function getVectorOverlayRenderData(state) {
   const seen = /* @__PURE__ */ new Set();
   const outline = (id, selected2) => {
     if (seen.has(id)) return;
-    const node = _chunkUTEVPQTScjs.findVectorNode.call(void 0, doc.nodes, id);
+    const node = _chunkW3GXSUSQcjs.findVectorNode.call(void 0, doc.nodes, id);
     if (!node || node.visible === false) return;
     seen.add(id);
     outlines.push({ id, d: screenOutline(state, node, entered), selected: selected2 });
@@ -7623,7 +7623,7 @@ 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, () => ( _chunkUTEVPQTScjs.inferAnchorType.call(void 0, a))), selected: selected(ref), hovered: sameAnchor(_optionalChain([state, 'access', _273 => _273.hover, 'optionalAccess', _274 => _274.anchor]), ref), closes };
+    return { ref, x: s.x, y: s.y, type: _nullishCoalesce(a.type, () => ( _chunkW3GXSUSQcjs.inferAnchorType.call(void 0, a))), selected: selected(ref), hovered: sameAnchor(_optionalChain([state, 'access', _273 => _273.hover, 'optionalAccess', _274 => _274.anchor]), ref), closes };
   });
   if (state.tool === "pen" && !state.pen && _optionalChain([state, 'access', _275 => _275.hover, 'optionalAccess', _276 => _276.anchor])) {
     const a = getAnchorWorld(doc, state.hover.anchor);
@@ -7649,7 +7649,7 @@ function getVectorOverlayRenderData(state) {
   }
   let penPreview = null;
   if (state.tool === "pen" && state.pen && state.pointer && !state.interaction) {
-    const node = _chunkUTEVPQTScjs.findVectorNode.call(void 0, doc.nodes, state.pen.nodeId);
+    const node = _chunkW3GXSUSQcjs.findVectorNode.call(void 0, doc.nodes, state.pen.nodeId);
     const sp = _optionalChain([node, 'optionalAccess', _282 => _282.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) {
@@ -7666,7 +7666,7 @@ function getVectorOverlayRenderData(state) {
   if (_optionalChain([it, 'optionalAccess', _283 => _283.type]) === "rotate") status = `${Math.round(it.angle)}\xB0`;
   else if (_optionalChain([it, 'optionalAccess', _284 => _284.type]) === "move" || _optionalChain([it, 'optionalAccess', _285 => _285.type]) === "anchors") status = `\u0394 ${fmt2(it.dx)}, ${fmt2(it.dy)}`;
   else if (_optionalChain([it, 'optionalAccess', _286 => _286.type]) === "scale" || _optionalChain([it, 'optionalAccess', _287 => _287.type]) === "draw") {
-    const b = it.type === "draw" ? _chunkUTEVPQTScjs.findVectorNode.call(void 0, doc.nodes, it.nodeId) ? _chunkUTEVPQTScjs.vectorNodeBounds.call(void 0, _chunkUTEVPQTScjs.findVectorNode.call(void 0, doc.nodes, it.nodeId)) : null : state.selectionFrame;
+    const b = it.type === "draw" ? _chunkW3GXSUSQcjs.findVectorNode.call(void 0, doc.nodes, it.nodeId) ? _chunkW3GXSUSQcjs.vectorNodeBounds.call(void 0, _chunkW3GXSUSQcjs.findVectorNode.call(void 0, doc.nodes, it.nodeId)) : null : state.selectionFrame;
     if (b) status = `W ${fmt2(b.width)} \xD7 H ${fmt2(b.height)}`;
   }
   const guides = { lines: [], labels: [] };
@@ -7766,35 +7766,35 @@ function maskOverlay(state) {
         if (want.has(n.id)) any = true;
         continue;
       }
-      const m = _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, _chunkUTEVPQTScjs.nodeMatrix.call(void 0, n), parent);
+      const m = _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, _chunkW3GXSUSQcjs.nodeMatrix.call(void 0, n), parent);
       const inside = visit(n.children, m);
       const hit = want.has(n.id) || inside;
       if (hit) any = true;
-      if (!hit || !_chunkUTEVPQTScjs.isVectorMaskGroup.call(void 0, n)) continue;
-      const summary = _chunkUTEVPQTScjs.vectorMaskSummary.call(void 0, n);
+      if (!hit || !_chunkW3GXSUSQcjs.isVectorMaskGroup.call(void 0, n)) continue;
+      const summary = _chunkW3GXSUSQcjs.vectorMaskSummary.call(void 0, n);
       const d = outlinePaths(n.children[0], m, /* @__PURE__ */ new Set()).map((path) => _chunkXGD3FSNCcjs.bezierPathToSvg.call(void 0, _chunkXGD3FSNCcjs.transformBezierPath.call(void 0, path, view), { precision: 2 })).join(" ");
       out.push({ id: n.id, maskId: summary.maskId, d, type: summary.type, invert: summary.invert, enabled: summary.enabled, editing: want.has(summary.maskId) });
     }
     return any;
   };
-  visit(state.document.nodes, _chunkDWGZUSEScjs.IDENTITY_MATRIX);
+  visit(state.document.nodes, _chunkW3GXSUSQcjs.IDENTITY_MATRIX);
   return out;
 }
 function envelopeOverlay(state) {
   const target = getVectorEnvelopeTarget(state.document, state.selection);
   if (!target) return null;
   const v = state.viewport;
-  const m = _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, target.world, [v.zoom, 0, 0, v.zoom, v.x, v.y]);
+  const m = _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, target.world, [v.zoom, 0, 0, v.zoom, v.x, v.y]);
   const sc = (p) => ({ x: fmt2(m[0] * p.x + m[2] * p.y + m[4]), y: fmt2(m[1] * p.x + m[3] * p.y + m[5]) });
   const { mesh } = target.frame;
-  const grid = _chunkDWGZUSEScjs.warpMeshGridCurves.call(void 0, mesh).map((c) => {
+  const grid = _chunkW3GXSUSQcjs.warpMeshGridCurves.call(void 0, mesh).map((c) => {
     const [a, b, cc, d] = c.map(sc);
     return `M${a.x} ${a.y}C${b.x} ${b.y} ${cc.x} ${cc.y} ${d.x} ${d.y}`;
   }).join("");
   const hover = _optionalChain([state, 'access', _305 => _305.hover, 'optionalAccess', _306 => _306.envelope, 'optionalAccess', _307 => _307.nodeId]) === target.node.id ? state.hover.envelope.index : void 0;
   const it = state.interaction;
   const active = _optionalChain([it, 'optionalAccess', _308 => _308.type]) === "envelope" && it.nodeId === target.node.id ? it.index : void 0;
-  const pts = _chunkDWGZUSEScjs.warpMeshEditPoints.call(void 0, mesh);
+  const pts = _chunkW3GXSUSQcjs.warpMeshEditPoints.call(void 0, mesh);
   return {
     nodeId: target.node.id,
     grid,
@@ -7806,16 +7806,16 @@ function envelopeOverlay(state) {
   };
 }
 var VECTOR_ENVELOPE_STYLE_OPTIONS = [
-  ..._chunkDWGZUSEScjs.WARP_STYLES.map((value) => ({ value, label: _chunkDWGZUSEScjs.WARP_STYLE_LABELS[value] })),
+  ..._chunkW3GXSUSQcjs.WARP_STYLES.map((value) => ({ value, label: _chunkW3GXSUSQcjs.WARP_STYLE_LABELS[value] })),
   { value: "mesh", label: "Mesh" }
 ];
 function getVectorEnvelopePanel(state) {
-  const nodes = state.selection.map((id) => _chunkUTEVPQTScjs.findVectorNode.call(void 0, state.document.nodes, id)).filter((n) => !!n && !n.blendStep);
+  const nodes = state.selection.map((id) => _chunkW3GXSUSQcjs.findVectorNode.call(void 0, state.document.nodes, id)).filter((n) => !!n && !n.blendStep);
   if (!nodes.length) return null;
   const one = nodes.length === 1 ? nodes[0] : null;
   const first = _optionalChain([one, 'optionalAccess', _309 => _309.effects, 'optionalAccess', _310 => _310.find, 'call', _311 => _311((e) => e.type === "envelope")]);
   const order = /* @__PURE__ */ new Map();
-  _chunkUTEVPQTScjs.walkVectorNodes.call(void 0, state.document.nodes, (n) => order.set(n.id, order.size));
+  _chunkW3GXSUSQcjs.walkVectorNodes.call(void 0, state.document.nodes, (n) => order.set(n.id, order.size));
   const top = nodes.length > 1 ? nodes.slice().sort((a, b) => (_nullishCoalesce(order.get(a.id), () => ( 0))) - (_nullishCoalesce(order.get(b.id), () => ( 0))))[nodes.length - 1] : null;
   return {
     nodeId: _nullishCoalesce(_optionalChain([one, 'optionalAccess', _312 => _312.id]), () => ( null)),
@@ -7832,7 +7832,7 @@ function gradientOverlay(state) {
   const hover = state.interaction ? null : _optionalChain([state, 'access', _318 => _318.hover, 'optionalAccess', _319 => _319.gradient]);
   const handleHovered = (h) => _optionalChain([hover, 'optionalAccess', _320 => _320.kind]) === "handle" && hover.handle === h;
   const pt = (p) => ({ x: fmt2(p.x), y: fmt2(p.y) });
-  const centred = _chunkUTEVPQTScjs.isCentredVectorGradient.call(void 0, a.gradient.type);
+  const centred = _chunkW3GXSUSQcjs.isCentredVectorGradient.call(void 0, a.gradient.type);
   const removing = _optionalChain([state, 'access', _321 => _321.interaction, 'optionalAccess', _322 => _322.type]) === "gradient" && !!state.interaction.removing;
   return {
     nodeId: a.nodeId,
@@ -7859,8 +7859,8 @@ function gradientOverlay(state) {
 function selectedBlends(state) {
   const out = /* @__PURE__ */ new Map();
   for (const id of state.selection) {
-    const node = _chunkUTEVPQTScjs.findVectorNode.call(void 0, state.document.nodes, id);
-    const group = isVectorBlendGroup(node) ? node : _optionalChain([_chunkUTEVPQTScjs.locateVectorNode.call(void 0, state.document.nodes, id), 'optionalAccess', _325 => _325.parent]);
+    const node = _chunkW3GXSUSQcjs.findVectorNode.call(void 0, state.document.nodes, id);
+    const group = isVectorBlendGroup(node) ? node : _optionalChain([_chunkW3GXSUSQcjs.locateVectorNode.call(void 0, state.document.nodes, id), 'optionalAccess', _325 => _325.parent]);
     if (isVectorBlendGroup(group)) out.set(group.id, group);
   }
   return [...out.values()];
@@ -7876,8 +7876,8 @@ function blendOverlay(state) {
   const spines = selectedBlends(state).flatMap((g) => {
     const s = vectorBlendSpine(g);
     if (!s) return [];
-    const m = _chunkDWGZUSEScjs.multiplyMatrices.call(void 0, _nullishCoalesce(_chunkUTEVPQTScjs.vectorWorldMatrix.call(void 0, doc.nodes, g.id), () => ( _chunkDWGZUSEScjs.IDENTITY_MATRIX)), view);
-    const d = _chunkXGD3FSNCcjs.bezierPathToSvg.call(void 0, _chunkXGD3FSNCcjs.transformBezierPath.call(void 0, _chunkUTEVPQTScjs.subpathsToBezier.call(void 0, [s.spine], { corners: false }), m), { precision: 2 });
+    const m = _chunkW3GXSUSQcjs.multiplyMatrices.call(void 0, _nullishCoalesce(_chunkW3GXSUSQcjs.vectorWorldMatrix.call(void 0, doc.nodes, g.id), () => ( _chunkW3GXSUSQcjs.IDENTITY_MATRIX)), view);
+    const d = _chunkXGD3FSNCcjs.bezierPathToSvg.call(void 0, _chunkXGD3FSNCcjs.transformBezierPath.call(void 0, _chunkW3GXSUSQcjs.subpathsToBezier.call(void 0, [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);
@@ -7887,12 +7887,12 @@ function blendOverlay(state) {
   let start = null;
   const anchors = [];
   if (state.tool === "blend") {
-    const from = state.blendStart ? _chunkUTEVPQTScjs.findVectorNode.call(void 0, doc.nodes, state.blendStart.nodeId) : void 0;
+    const from = state.blendStart ? _chunkW3GXSUSQcjs.findVectorNode.call(void 0, doc.nodes, state.blendStart.nodeId) : void 0;
     if (from && state.blendStart) {
       const a = state.blendStart.anchor === null ? void 0 : getAnchorWorld(doc, { nodeId: from.id, subpath: 0, index: state.blendStart.anchor });
       start = { d: screenOutline(state, from, /* @__PURE__ */ new Set()), anchor: a ? sc(a, view) : null };
     }
-    const hovered = _optionalChain([state, 'access', _326 => _326.hover, 'optionalAccess', _327 => _327.nodeId]) ? _chunkUTEVPQTScjs.findVectorNode.call(void 0, doc.nodes, state.hover.nodeId) : void 0;
+    const hovered = _optionalChain([state, 'access', _326 => _326.hover, 'optionalAccess', _327 => _327.nodeId]) ? _chunkW3GXSUSQcjs.findVectorNode.call(void 0, doc.nodes, state.hover.nodeId) : void 0;
     if (_optionalChain([hovered, 'optionalAccess', _328 => _328.type]) === "path" && hovered.subpaths[0]) {
       hovered.subpaths[0].anchors.forEach((_, index) => {
         const a = getAnchorWorld(doc, { nodeId: hovered.id, subpath: 0, index });
@@ -7906,11 +7906,11 @@ function getVectorBlendControls(state) {
   const blends = selectedBlends(state);
   const doc = state.document;
   const roots = state.selection.filter((id) => {
-    const node = _chunkUTEVPQTScjs.findVectorNode.call(void 0, doc.nodes, id);
-    return !!node && !node.blendStep && !node.locked && !state.selection.includes(_nullishCoalesce(_optionalChain([_chunkUTEVPQTScjs.locateVectorNode.call(void 0, doc.nodes, id), 'optionalAccess', _332 => _332.parent, 'optionalAccess', _333 => _333.id]), () => ( "")));
+    const node = _chunkW3GXSUSQcjs.findVectorNode.call(void 0, doc.nodes, id);
+    return !!node && !node.blendStep && !node.locked && !state.selection.includes(_nullishCoalesce(_optionalChain([_chunkW3GXSUSQcjs.locateVectorNode.call(void 0, doc.nodes, id), 'optionalAccess', _332 => _332.parent, 'optionalAccess', _333 => _333.id]), () => ( "")));
   });
-  const parents = new Set(roots.map((id) => _nullishCoalesce(_optionalChain([_chunkUTEVPQTScjs.locateVectorNode.call(void 0, doc.nodes, id), 'optionalAccess', _334 => _334.parent, 'optionalAccess', _335 => _335.id]), () => ( null))));
-  const paths = roots.filter((id) => _optionalChain([_chunkUTEVPQTScjs.findVectorNode.call(void 0, doc.nodes, id), 'optionalAccess', _336 => _336.type]) === "path" && !isVectorBlendGroup(_optionalChain([_chunkUTEVPQTScjs.locateVectorNode.call(void 0, doc.nodes, id), 'optionalAccess', _337 => _337.parent])));
+  const parents = new Set(roots.map((id) => _nullishCoalesce(_optionalChain([_chunkW3GXSUSQcjs.locateVectorNode.call(void 0, doc.nodes, id), 'optionalAccess', _334 => _334.parent, 'optionalAccess', _335 => _335.id]), () => ( null))));
+  const paths = roots.filter((id) => _optionalChain([_chunkW3GXSUSQcjs.findVectorNode.call(void 0, doc.nodes, id), 'optionalAccess', _336 => _336.type]) === "path" && !isVectorBlendGroup(_optionalChain([_chunkW3GXSUSQcjs.locateVectorNode.call(void 0, doc.nodes, id), 'optionalAccess', _337 => _337.parent])));
   const first = blends[0];
   return {
     ids: blends.map((g) => g.id),
@@ -7978,14 +7978,14 @@ function isVectorTextTarget(target) {
 function getVectorSelectionStyle(state) {
   const paths = [];
   for (const id of state.selection) {
-    const node = _chunkUTEVPQTScjs.findVectorNode.call(void 0, state.document.nodes, id);
+    const node = _chunkW3GXSUSQcjs.findVectorNode.call(void 0, state.document.nodes, id);
     if (node) paths.push(...collect(node));
   }
   const anchorMode = state.tool === "direct" && !!_optionalChain([state, 'access', _342 => _342.selectedAnchors, 'optionalAccess', _343 => _343.length]);
   if (anchorMode) {
     for (const r of state.selectedAnchors) {
       if (paths.some((p) => p.id === r.nodeId)) continue;
-      const node = _chunkUTEVPQTScjs.findVectorNode.call(void 0, state.document.nodes, r.nodeId);
+      const node = _chunkW3GXSUSQcjs.findVectorNode.call(void 0, state.document.nodes, r.nodeId);
       if (_optionalChain([node, 'optionalAccess', _344 => _344.type]) === "path") paths.push(node);
     }
   }
@@ -7994,7 +7994,7 @@ function getVectorSelectionStyle(state) {
   const same = (get) => paths.every((p) => JSON.stringify(_nullishCoalesce(get(p), () => ( null))) === JSON.stringify(_nullishCoalesce(get(first), () => ( null))));
   const corners2 = [];
   for (const p of paths) {
-    for (const c of _chunkUTEVPQTScjs.vectorCorners.call(void 0, p.subpaths)) {
+    for (const c of _chunkW3GXSUSQcjs.vectorCorners.call(void 0, 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', _345 => _345.radius]), () => ( 0)), kind: _nullishCoalesce(_optionalChain([corner, 'optionalAccess', _346 => _346.kind]), () => ( "round")) });
@@ -8013,7 +8013,7 @@ function getVectorSelectionStyle(state) {
     startArrowScale: _nullishCoalesce(first.startArrowScale, () => ( 1)),
     endArrowScale: _nullishCoalesce(first.endArrowScale, () => ( 1)),
     strokeWidthProfile: profileOf(first),
-    widthProfile: _chunkUTEVPQTScjs.widthProfilePresetId.call(void 0, profileOf(first)),
+    widthProfile: _chunkW3GXSUSQcjs.widthProfilePresetId.call(void 0, profileOf(first)),
     cornerRadius: c0.radius,
     cornerKind: c0.kind,
     corners: corners2.length,
@@ -8037,8 +8037,8 @@ function getVectorSelectionStyle(state) {
   };
 }
 function profileOf(p) {
-  const points = _chunkUTEVPQTScjs.sanitizeWidthProfile.call(void 0, p.strokeWidthProfile);
-  return points.length && _chunkUTEVPQTScjs.widthProfilePresetId.call(void 0, points) !== "uniform" ? points : null;
+  const points = _chunkW3GXSUSQcjs.sanitizeWidthProfile.call(void 0, p.strokeWidthProfile);
+  return points.length && _chunkW3GXSUSQcjs.widthProfilePresetId.call(void 0, points) !== "uniform" ? points : null;
 }
 var VECTOR_STROKE_ALIGN_LABELS = { center: "Center", inside: "Inside", outside: "Outside" };
 var VECTOR_CORNER_KIND_LABELS = { round: "Round", inverted: "Inverted", chamfer: "Chamfer" };
@@ -8064,19 +8064,19 @@ var VECTOR_STROKE_GRADIENT_MODE_LABELS = { within: "Within stroke", along: "Alon
 function getVectorGradientEditor(state) {
   const paths = [];
   for (const id of state.selection) {
-    const node = _chunkUTEVPQTScjs.findVectorNode.call(void 0, state.document.nodes, id);
+    const node = _chunkW3GXSUSQcjs.findVectorNode.call(void 0, state.document.nodes, id);
     if (node) paths.push(...collect(node));
   }
   if (!paths.length) return null;
   const { target, layer } = state.gradientEdit;
-  const paint = _chunkUTEVPQTScjs.vectorTargetPaint.call(void 0, paths[0], target, _nullishCoalesce(layer, () => ( null)));
-  const gradient = _chunkUTEVPQTScjs.isVectorGradient.call(void 0, paint) ? paint : null;
-  const sorted = gradient ? _chunkUTEVPQTScjs.sortedVectorGradientStops.call(void 0, gradient) : [];
+  const paint = _chunkW3GXSUSQcjs.vectorTargetPaint.call(void 0, paths[0], target, _nullishCoalesce(layer, () => ( null)));
+  const gradient = _chunkW3GXSUSQcjs.isVectorGradient.call(void 0, paint) ? paint : null;
+  const sorted = gradient ? _chunkW3GXSUSQcjs.sortedVectorGradientStops.call(void 0, gradient) : [];
   const stopIndex = state.gradientEdit.stop;
   const stops = sorted.map((s, index) => ({ ...s, index, selected: index === stopIndex }));
   const sel = stopIndex !== null && sorted[stopIndex] ? { ...sorted[stopIndex], index: stopIndex, last: stopIndex === sorted.length - 1 } : null;
-  const preview = gradient ? `linear-gradient(to right, ${_chunkUTEVPQTScjs.expandVectorGradientStops.call(void 0, gradient).map((s) => {
-    const c = _chunkUTEVPQTScjs.parseVectorColor.call(void 0, s.color);
+  const preview = gradient ? `linear-gradient(to right, ${_chunkW3GXSUSQcjs.expandVectorGradientStops.call(void 0, gradient).map((s) => {
+    const c = _chunkW3GXSUSQcjs.parseVectorColor.call(void 0, s.color);
     const a = (_nullishCoalesce(_optionalChain([c, 'optionalAccess', _347 => _347[3]]), () => ( 1))) * (_nullishCoalesce(s.opacity, () => ( 1)));
     const color = c ? `rgba(${Math.round(c[0] * 255)}, ${Math.round(c[1] * 255)}, ${Math.round(c[2] * 255)}, ${Math.round(a * 1e3) / 1e3})` : s.color;
     return `${color} ${Math.round(s.offset * 1e4) / 100}%`;
@@ -8094,7 +8094,7 @@ function getVectorGradientEditor(state) {
     interpolation: _nullishCoalesce(_optionalChain([gradient, 'optionalAccess', _350 => _350.interpolation]), () => ( "srgb")),
     smoothness: _nullishCoalesce(_optionalChain([gradient, 'optionalAccess', _351 => _351.smoothness]), () => ( 0)),
     strokeMode: _nullishCoalesce(_optionalChain([gradient, 'optionalAccess', _352 => _352.strokeMode]), () => ( "within")),
-    mixed: paths.some((p) => JSON.stringify(_nullishCoalesce(_chunkUTEVPQTScjs.vectorTargetPaint.call(void 0, p, target, _nullishCoalesce(layer, () => ( null))), () => ( null))) !== JSON.stringify(_nullishCoalesce(paint, () => ( null))))
+    mixed: paths.some((p) => JSON.stringify(_nullishCoalesce(_chunkW3GXSUSQcjs.vectorTargetPaint.call(void 0, p, target, _nullishCoalesce(layer, () => ( null))), () => ( null))) !== JSON.stringify(_nullishCoalesce(paint, () => ( null))))
   };
 }
 var VECTOR_PATH_ACTIONS = [
@@ -8118,9 +8118,9 @@ var VECTOR_EDIT_TOGGLES = [
   { key: "curvatureMoves", label: "Curv", title: "Curvature point moves (Alt flips while dragging)" },
   { key: "recognizeShapes", label: "Shapes", title: "Turn pencil scribbles into shapes" }
 ];
-var VECTOR_EFFECT_MENU = _chunkUTEVPQTScjs.VECTOR_EFFECT_TYPES.map((type) => ({ type, label: _chunkUTEVPQTScjs.VECTOR_EFFECT_LABELS[type] }));
+var VECTOR_EFFECT_MENU = _chunkW3GXSUSQcjs.VECTOR_EFFECT_TYPES.map((type) => ({ type, label: _chunkW3GXSUSQcjs.VECTOR_EFFECT_LABELS[type] }));
 function getVectorEffectsPanel(state) {
-  const nodes = state.selection.map((id) => _chunkUTEVPQTScjs.findVectorNode.call(void 0, state.document.nodes, id)).filter((n) => !!n && !n.blendStep);
+  const nodes = state.selection.map((id) => _chunkW3GXSUSQcjs.findVectorNode.call(void 0, state.document.nodes, id)).filter((n) => !!n && !n.blendStep);
   if (!nodes.length) return null;
   const one = nodes.length === 1 ? nodes[0] : null;
   return {
@@ -8129,20 +8129,20 @@ function getVectorEffectsPanel(state) {
     effects: (_nullishCoalesce(_optionalChain([one, 'optionalAccess', _354 => _354.effects]), () => ( []))).map((e) => ({
       id: e.id,
       type: e.type,
-      label: _nullishCoalesce(_chunkUTEVPQTScjs.VECTOR_EFFECT_LABELS[e.type], () => ( e.type)),
+      label: _nullishCoalesce(_chunkW3GXSUSQcjs.VECTOR_EFFECT_LABELS[e.type], () => ( e.type)),
       enabled: e.enabled !== false,
       params: e.params,
       // The Envelope panel (`getVectorEnvelopePanel`) edits an envelope's warp and mesh.
-      specs: e.type === "envelope" ? [] : _nullishCoalesce(_chunkUTEVPQTScjs.VECTOR_EFFECT_PARAM_SPECS[e.type], () => ( []))
+      specs: e.type === "envelope" ? [] : _nullishCoalesce(_chunkW3GXSUSQcjs.VECTOR_EFFECT_PARAM_SPECS[e.type], () => ( []))
     })),
-    expandable: nodes.some(_chunkUTEVPQTScjs.hasVectorAppearance)
+    expandable: nodes.some(_chunkW3GXSUSQcjs.hasVectorAppearance)
   };
 }
 function vectorPaintSwatch(paint) {
   if (typeof paint === "string") return paint;
-  if (_chunkUTEVPQTScjs.isVectorGradient.call(void 0, paint)) {
-    return `linear-gradient(to right, ${_chunkUTEVPQTScjs.expandVectorGradientStops.call(void 0, paint).map((s) => {
-      const c = _chunkUTEVPQTScjs.parseVectorColor.call(void 0, s.color);
+  if (_chunkW3GXSUSQcjs.isVectorGradient.call(void 0, paint)) {
+    return `linear-gradient(to right, ${_chunkW3GXSUSQcjs.expandVectorGradientStops.call(void 0, paint).map((s) => {
+      const c = _chunkW3GXSUSQcjs.parseVectorColor.call(void 0, s.color);
       const a = (_nullishCoalesce(_optionalChain([c, 'optionalAccess', _355 => _355[3]]), () => ( 1))) * (_nullishCoalesce(s.opacity, () => ( 1)));
       const color = c ? `rgba(${Math.round(c[0] * 255)}, ${Math.round(c[1] * 255)}, ${Math.round(c[2] * 255)}, ${Math.round(a * 1e3) / 1e3})` : s.color;
       return `${color} ${Math.round(s.offset * 1e4) / 100}%`;
@@ -8151,7 +8151,7 @@ function vectorPaintSwatch(paint) {
   return "transparent";
 }
 function getVectorAppearancePanel(state) {
-  const nodes = state.selection.map((id) => _chunkUTEVPQTScjs.findVectorNode.call(void 0, state.document.nodes, id)).filter((n) => !!n && !n.blendStep);
+  const nodes = state.selection.map((id) => _chunkW3GXSUSQcjs.findVectorNode.call(void 0, state.document.nodes, id)).filter((n) => !!n && !n.blendStep);
   if (!nodes.length) return null;
   const paths = [];
   for (const n of nodes) for (const p of collect(n)) if (!p.blendStep && !paths.some((q) => q.id === p.id)) paths.push(p);
@@ -8163,7 +8163,7 @@ function getVectorAppearancePanel(state) {
     paint: l.paint,
     color: vectorPaintToHex(l.paint),
     swatch: vectorPaintSwatch(l.paint),
-    gradient: _chunkUTEVPQTScjs.isVectorGradient.call(void 0, l.paint),
+    gradient: _chunkW3GXSUSQcjs.isVectorGradient.call(void 0, l.paint),
     opacity: _nullishCoalesce(l.opacity, () => ( 1)),
     blendMode: _nullishCoalesce(l.blendMode, () => ( "normal")),
     visible: l.visible !== false,
@@ -8171,8 +8171,8 @@ function getVectorAppearancePanel(state) {
     ...(_nullishCoalesce(l.kind, () => ( "paint"))) !== "paint" ? { unknownKind: String(l.kind) } : {},
     editing: edit.target === kind && (edit.layer === null ? index === count - 1 : edit.layer === index)
   });
-  const fills = first ? _chunkUTEVPQTScjs.vectorFills.call(void 0, first) : [];
-  const strokes = first ? _chunkUTEVPQTScjs.vectorStrokes.call(void 0, first) : [];
+  const fills = first ? _chunkW3GXSUSQcjs.vectorFills.call(void 0, first) : [];
+  const strokes = first ? _chunkW3GXSUSQcjs.vectorStrokes.call(void 0, first) : [];
   const same = (get) => paths.every((p) => JSON.stringify(get(p)) === JSON.stringify(get(first)));
   const one = nodes.length === 1 ? nodes[0] : null;
   return {
@@ -8182,22 +8182,22 @@ function getVectorAppearancePanel(state) {
     strokes: strokes.map((l, i) => layer("stroke", l, i, strokes.length)),
     blendMode: _nullishCoalesce(nodes[0].blendMode, () => ( "normal")),
     mixed: {
-      fills: !!first && !same(_chunkUTEVPQTScjs.vectorFills),
-      strokes: !!first && !same(_chunkUTEVPQTScjs.vectorStrokes),
+      fills: !!first && !same(_chunkW3GXSUSQcjs.vectorFills),
+      strokes: !!first && !same(_chunkW3GXSUSQcjs.vectorStrokes),
       blendMode: nodes.some((n) => (_nullishCoalesce(n.blendMode, () => ( "normal"))) !== (_nullishCoalesce(nodes[0].blendMode, () => ( "normal"))))
     },
     filterNodeId: _nullishCoalesce(_optionalChain([one, 'optionalAccess', _356 => _356.id]), () => ( null)),
     filters: (_nullishCoalesce(_optionalChain([one, 'optionalAccess', _357 => _357.filters]), () => ( []))).map((f) => ({
       id: f.id,
       type: f.type,
-      label: _nullishCoalesce(_chunkUTEVPQTScjs.VECTOR_FILTER_LABELS[f.type], () => ( f.type)),
+      label: _nullishCoalesce(_chunkW3GXSUSQcjs.VECTOR_FILTER_LABELS[f.type], () => ( f.type)),
       enabled: f.enabled !== false,
       params: f.params,
-      specs: _nullishCoalesce(_chunkUTEVPQTScjs.VECTOR_FILTER_PARAM_SPECS[f.type], () => ( []))
+      specs: _nullishCoalesce(_chunkW3GXSUSQcjs.VECTOR_FILTER_PARAM_SPECS[f.type], () => ( []))
     }))
   };
 }
-var VECTOR_BLEND_MODE_MENU = _chunkUTEVPQTScjs.VECTOR_BLEND_MODES.map((mode) => ({ mode, label: _chunkUTEVPQTScjs.VECTOR_BLEND_MODE_LABELS[mode] }));
+var VECTOR_BLEND_MODE_MENU = _chunkW3GXSUSQcjs.VECTOR_BLEND_MODES.map((mode) => ({ mode, label: _chunkW3GXSUSQcjs.VECTOR_BLEND_MODE_LABELS[mode] }));
 var VECTOR_MASK_TYPE_LABELS = { clip: "Clip", alpha: "Alpha", luminance: "Luminance" };
 var VECTOR_MASK_TYPE_OPTIONS = [
   { value: "clip", label: "Clip", title: "Clipping mask: the contents show inside the mask's outline" },
@@ -8207,7 +8207,7 @@ var VECTOR_MASK_TYPE_OPTIONS = [
 function getVectorMaskPanel(state) {
   const doc = state.document;
   if (!state.selection.length) return null;
-  const locs = state.selection.map((id) => _chunkUTEVPQTScjs.locateVectorNode.call(void 0, doc.nodes, id));
+  const locs = state.selection.map((id) => _chunkW3GXSUSQcjs.locateVectorNode.call(void 0, doc.nodes, id));
   let makeHint = null;
   if (state.selection.length < 2) makeHint = "Select two or more objects: the topmost becomes the mask.";
   else if (locs.some((l) => !l)) makeHint = "Select objects in the document.";
@@ -8216,9 +8216,9 @@ function getVectorMaskPanel(state) {
   let group = null;
   const first = locs[0];
   const node = first ? first.list[first.index] : null;
-  const owner = _chunkUTEVPQTScjs.isVectorMaskGroup.call(void 0, node) ? node : _chunkUTEVPQTScjs.isVectorMaskGroup.call(void 0, _optionalChain([first, 'optionalAccess', _363 => _363.parent])) ? first.parent : null;
+  const owner = _chunkW3GXSUSQcjs.isVectorMaskGroup.call(void 0, node) ? node : _chunkW3GXSUSQcjs.isVectorMaskGroup.call(void 0, _optionalChain([first, 'optionalAccess', _363 => _363.parent])) ? first.parent : null;
   if (owner && state.selection.every((id) => id === owner.id || owner.children.some((c) => c.id === id))) {
-    const summary = _chunkUTEVPQTScjs.vectorMaskSummary.call(void 0, owner);
+    const summary = _chunkW3GXSUSQcjs.vectorMaskSummary.call(void 0, owner);
     const editing = state.selection.includes(owner.id) ? "group" : state.selection.includes(summary.maskId) ? "mask" : "contents";
     group = { ...summary, id: owner.id, ...owner.name ? { name: owner.name } : {}, editing };
   }
@@ -8267,13 +8267,13 @@ var BLEND_PROPS = {
   linear: { type: "boolean", description: "Move anchors in straight lines instead of the rotation-aware morph." }
 };
 var checkBlendOptions = (params) => {
-  if (_optionalChain([params, 'optionalAccess', _364 => _364.spacing]) !== void 0 && !_chunkUTEVPQTScjs.VECTOR_BLEND_SPACINGS.includes(params.spacing)) fail(`Unknown blend spacing "${params.spacing}".`);
+  if (_optionalChain([params, 'optionalAccess', _364 => _364.spacing]) !== void 0 && !_chunkW3GXSUSQcjs.VECTOR_BLEND_SPACINGS.includes(params.spacing)) fail(`Unknown blend spacing "${params.spacing}".`);
   if (_optionalChain([params, 'optionalAccess', _365 => _365.steps]) !== void 0 && !(Number.isFinite(params.steps) && params.steps >= 1)) fail("steps must be at least 1.");
   if (_optionalChain([params, 'optionalAccess', _366 => _366.distance]) !== void 0 && !(Number.isFinite(params.distance) && params.distance > 0)) fail("distance must be positive.");
 };
 var POINT = { type: "object", properties: { x: { type: "number" }, y: { type: "number" } }, required: ["x", "y"] };
 var GRADIENT_PROPS = {
-  type: { type: "string", enum: _chunkUTEVPQTScjs.VECTOR_GRADIENT_TYPES, description: "linear, radial, conic (an angle sweep), reflected (linear mirrored about the start) or diamond." },
+  type: { type: "string", enum: _chunkW3GXSUSQcjs.VECTOR_GRADIENT_TYPES, description: "linear, radial, conic (an angle sweep), reflected (linear mirrored about the start) or diamond." },
   stops: {
     type: "array",
     minItems: 1,
@@ -8298,10 +8298,10 @@ var GRADIENT_PROPS = {
   focal: { ...POINT, description: "Radial focal point (where t = 0), in `units`." },
   focalRadius: { type: "number", minimum: 0, maximum: 0.99, description: "Radial focal circle radius as a fraction of the radius (SVG fr)." },
   units: { type: "string", enum: ["objectBoundingBox", "userSpaceOnUse"], description: "Space of start / end / width / focal: fractions of the shape box (default) or the node's own coordinates." },
-  spread: { type: "string", enum: _chunkUTEVPQTScjs.VECTOR_GRADIENT_SPREADS, description: "What paints past the ends: pad (default), reflect or repeat." },
-  interpolation: { type: "string", enum: _chunkUTEVPQTScjs.VECTOR_GRADIENT_INTERPOLATIONS, description: "Colour mixing space: srgb (default), linear (light) or oklab." },
+  spread: { type: "string", enum: _chunkW3GXSUSQcjs.VECTOR_GRADIENT_SPREADS, description: "What paints past the ends: pad (default), reflect or repeat." },
+  interpolation: { type: "string", enum: _chunkW3GXSUSQcjs.VECTOR_GRADIENT_INTERPOLATIONS, description: "Colour mixing space: srgb (default), linear (light) or oklab." },
   smoothness: { type: "number", minimum: 0, maximum: 1, description: "Bends the ramp along a smooth spline through the stops (0 = straight)." },
-  strokeMode: { type: "string", enum: _chunkUTEVPQTScjs.VECTOR_STROKE_GRADIENT_MODES, description: "On strokes: within (default, like a fill), along the path or across it." }
+  strokeMode: { type: "string", enum: _chunkW3GXSUSQcjs.VECTOR_STROKE_GRADIENT_MODES, description: "On strokes: within (default, like a fill), along the path or across it." }
 };
 var PAINT = {
   description: 'A CSS colour, `null` for none, or a gradient object: `{ type: "linear" | "radial" | "conic" | "reflected" | "diamond", stops: [{ offset, color, opacity?, midpoint? }] }` plus the shorthand `angle` / `cx, cy, r` or explicit `start`, `end`, `width`, `focal`, `focalRadius`, `units`, and `spread`, `interpolation`, `smoothness`, `strokeMode` (see vector.setGradient).',
@@ -8309,7 +8309,7 @@ var PAINT = {
 };
 var BLEND_MODE = {
   type: "string",
-  enum: _chunkUTEVPQTScjs.VECTOR_BLEND_MODES,
+  enum: _chunkW3GXSUSQcjs.VECTOR_BLEND_MODES,
   description: "How it mixes with what is under it (CSS mix-blend-mode names; linear-dodge draws as plus-lighter). Default normal."
 };
 var FILL_LAYER_PROPS = {
@@ -8324,8 +8324,8 @@ var STROKE_SETTING_PROPS = {
   strokeLinejoin: { type: "string", enum: ["miter", "round", "bevel"], description: "Line join (default miter)." },
   strokeDasharray: { type: ["array", "null"], items: { type: "number", minimum: 0 }, description: "Dash and gap lengths in document units; null or [] for a solid line." },
   strokeAlign: { type: "string", enum: ["center", "inside", "outside"], description: "Where the stroke sits on the outline (closed shapes only; open paths stroke centred). Default center." },
-  startArrow: { type: ["string", "null"], enum: [..._chunkUTEVPQTScjs.VECTOR_ARROWHEADS, null], description: "Head at the start of an open path, or null for none." },
-  endArrow: { type: ["string", "null"], enum: [..._chunkUTEVPQTScjs.VECTOR_ARROWHEADS, null], description: "Head at the end of an open path, or null for none." },
+  startArrow: { type: ["string", "null"], enum: [..._chunkW3GXSUSQcjs.VECTOR_ARROWHEADS, null], description: "Head at the start of an open path, or null for none." },
+  endArrow: { type: ["string", "null"], enum: [..._chunkW3GXSUSQcjs.VECTOR_ARROWHEADS, null], description: "Head at the end of an open path, or null for none." },
   arrowAlign: { type: "string", enum: ["extend", "tip"], description: "`extend`: the tip sits past the end point; `tip`: on it, the stroke shortened under the head." },
   startArrowScale: { type: "number", exclusiveMinimum: 0, description: "Start head size as a multiple of the stroke width (default 1)." },
   endArrowScale: { type: "number", exclusiveMinimum: 0, description: "End head size as a multiple of the stroke width (default 1)." },
@@ -8342,7 +8342,7 @@ var STYLE_PROPS = {
   fillRule: { type: "string", enum: ["nonzero", "evenodd"], description: "Which areas count as inside (default nonzero)." }
 };
 var checkPaint = (paint, where) => {
-  if (paint && typeof paint === "object") return _nullishCoalesce(_chunkUTEVPQTScjs.sanitizeVectorGradient.call(void 0, paint), () => ( fail(`${where} is not a valid gradient: give a type and at least one stop { offset, color }.`)));
+  if (paint && typeof paint === "object") return _nullishCoalesce(_chunkW3GXSUSQcjs.sanitizeVectorGradient.call(void 0, paint), () => ( fail(`${where} is not a valid gradient: give a type and at least one stop { offset, color }.`)));
   return paint;
 };
 var pickStyle = (params) => {
@@ -8356,7 +8356,7 @@ var pickStyle = (params) => {
       if (!l || typeof l !== "object") fail(`${key}[${i}] must be a layer object { paint, \u2026 }.`);
       const layer = l;
       checkPaint(layer.paint, `${key}[${i}].paint`);
-      if (layer.blendMode !== void 0 && !_chunkUTEVPQTScjs.isVectorBlendMode.call(void 0, layer.blendMode)) fail(`${key}[${i}].blendMode "${String(layer.blendMode)}" is not one of: ${_chunkUTEVPQTScjs.VECTOR_BLEND_MODES.join(", ")}.`);
+      if (layer.blendMode !== void 0 && !_chunkW3GXSUSQcjs.isVectorBlendMode.call(void 0, layer.blendMode)) fail(`${key}[${i}].blendMode "${String(layer.blendMode)}" is not one of: ${_chunkW3GXSUSQcjs.VECTOR_BLEND_MODES.join(", ")}.`);
     });
   }
   return out;
@@ -8389,19 +8389,19 @@ function createVectorCommands(controller, options = {}) {
     const out = [];
     const visit = (nodes, depth) => {
       for (const n of nodes) {
-        const parent = _nullishCoalesce(_chunkUTEVPQTScjs.vectorParentMatrix.call(void 0, state.document.nodes, n.id), () => ( _chunkDWGZUSEScjs.IDENTITY_MATRIX));
-        const b = _chunkUTEVPQTScjs.vectorNodeBounds.call(void 0, n, parent);
+        const parent = _nullishCoalesce(_chunkW3GXSUSQcjs.vectorParentMatrix.call(void 0, state.document.nodes, n.id), () => ( _chunkW3GXSUSQcjs.IDENTITY_MATRIX));
+        const b = _chunkW3GXSUSQcjs.vectorNodeBounds.call(void 0, n, parent);
         out.push({
           id: n.id,
           type: n.type,
           ...n.name ? { name: n.name } : {},
           depth,
-          rotation: Math.round(_chunkUTEVPQTScjs.vectorNodeRotation.call(void 0, n, parent) * 100) / 100,
+          rotation: Math.round(_chunkW3GXSUSQcjs.vectorNodeRotation.call(void 0, n, parent) * 100) / 100,
           bounds: b && { x: Math.round(b.x * 100) / 100, y: Math.round(b.y * 100) / 100, width: Math.round(b.width * 100) / 100, height: Math.round(b.height * 100) / 100 },
           visible: n.visible !== false,
           locked: !!n.locked,
           selected: state.selection.includes(n.id),
-          ...n.type === "path" ? { fill: _nullishCoalesce(n.fill, () => ( null)), stroke: _nullishCoalesce(n.stroke, () => ( null)), strokeWidth: _nullishCoalesce(n.strokeWidth, () => ( 1)), d: _chunkUTEVPQTScjs.vectorPathData.call(void 0, n, 2) } : { children: n.children.length },
+          ...n.type === "path" ? { fill: _nullishCoalesce(n.fill, () => ( null)), stroke: _nullishCoalesce(n.stroke, () => ( null)), strokeWidth: _nullishCoalesce(n.strokeWidth, () => ( 1)), d: _chunkW3GXSUSQcjs.vectorPathData.call(void 0, n, 2) } : { children: n.children.length },
           ...n.type === "group" && n.blend ? { blend: { ...resolveVectorBlendOptions(n.blend), spine: !!n.blend.spine, keys: vectorBlendKeys(n).map((k) => k.id) } } : {},
           ...n.blendStep ? { blendStep: true } : {},
           ..._optionalChain([n, 'access', _375 => _375.effects, 'optionalAccess', _376 => _376.length]) ? { effects: n.effects } : {},
@@ -8411,7 +8411,7 @@ function createVectorCommands(controller, options = {}) {
           ...n.type === "path" && Array.isArray(n.strokes) ? { strokes: n.strokes } : {},
           ...n.blendMode && n.blendMode !== "normal" ? { blendMode: n.blendMode } : {},
           ..._optionalChain([n, 'access', _377 => _377.filters, 'optionalAccess', _378 => _378.length]) ? { filters: n.filters } : {},
-          ..._chunkUTEVPQTScjs.isVectorMaskGroup.call(void 0, n) ? { mask: _chunkUTEVPQTScjs.vectorMaskSummary.call(void 0, n) } : {}
+          ..._chunkW3GXSUSQcjs.isVectorMaskGroup.call(void 0, n) ? { mask: _chunkW3GXSUSQcjs.vectorMaskSummary.call(void 0, n) } : {}
         });
         if (n.type === "group") visit(n.children, depth + 1);
       }
@@ -8424,7 +8424,7 @@ function createVectorCommands(controller, options = {}) {
     return {
       id: n.id,
       type: n.type,
-      ...n.type === "path" ? { fills: _chunkUTEVPQTScjs.vectorFills.call(void 0, n), strokes: _chunkUTEVPQTScjs.vectorStrokes.call(void 0, n), fillRule: _nullishCoalesce(n.fillRule, () => ( "nonzero")) } : {},
+      ...n.type === "path" ? { fills: _chunkW3GXSUSQcjs.vectorFills.call(void 0, n), strokes: _chunkW3GXSUSQcjs.vectorStrokes.call(void 0, n), fillRule: _nullishCoalesce(n.fillRule, () => ( "nonzero")) } : {},
       blendMode: _nullishCoalesce(n.blendMode, () => ( "normal")),
       opacity: _nullishCoalesce(n.opacity, () => ( 1)),
       filters: _nullishCoalesce(n.filters, () => ( []))
@@ -8436,10 +8436,10 @@ function createVectorCommands(controller, options = {}) {
     return n;
   };
   const layerIndex = (id, kind, index, key = "index") => {
-    const stack = kind === "fill" ? _chunkUTEVPQTScjs.vectorFills.call(void 0, pathOf(id)) : _chunkUTEVPQTScjs.vectorStrokes.call(void 0, pathOf(id));
+    const stack = kind === "fill" ? _chunkW3GXSUSQcjs.vectorFills.call(void 0, pathOf(id)) : _chunkW3GXSUSQcjs.vectorStrokes.call(void 0, pathOf(id));
     if (!Number.isInteger(index) || !stack[index]) fail(`${key} ${index} is out of range: "${id}" has ${stack.length} ${kind}${stack.length === 1 ? "" : "s"} (0 is the bottom). Read them with vector.getAppearance.`);
   };
-  const stackResult = (id, kind) => kind === "fill" ? { id, fills: _chunkUTEVPQTScjs.vectorFills.call(void 0, pathOf(id)) } : { id, strokes: _chunkUTEVPQTScjs.vectorStrokes.call(void 0, pathOf(id)) };
+  const stackResult = (id, kind) => kind === "fill" ? { id, fills: _chunkW3GXSUSQcjs.vectorFills.call(void 0, pathOf(id)) } : { id, strokes: _chunkW3GXSUSQcjs.vectorStrokes.call(void 0, pathOf(id)) };
   const layerPatchOf = (params, keys) => {
     const out = {};
     for (const key of keys) if (params[key] !== void 0) out[key] = key === "paint" ? checkPaint(params[key], "paint") : params[key];
@@ -8551,7 +8551,7 @@ function createVectorCommands(controller, options = {}) {
     additionalProperties: false
   };
   const checkFilterParams = (type, params) => {
-    const allowed = _chunkUTEVPQTScjs.vectorFilterParamKeys.call(void 0, type);
+    const allowed = _chunkW3GXSUSQcjs.vectorFilterParamKeys.call(void 0, type);
     for (const key of Object.keys(_nullishCoalesce(params, () => ( {})))) if (!allowed.includes(key)) fail(`${type} has no parameter "${key}"; it takes ${allowed.join(", ")}.`);
   };
   const filtersResult = (id) => ({ id, filters: _nullishCoalesce(_optionalChain([controller, 'access', _380 => _380.getNode, 'call', _381 => _381(id), 'optionalAccess', _382 => _382.filters]), () => ( [])) });
@@ -8559,7 +8559,7 @@ function createVectorCommands(controller, options = {}) {
     const node = _nullishCoalesce(controller.getNode(nodeId), () => ( fail(`There is no node "${nodeId}".`)));
     return _nullishCoalesce(_optionalChain([node, 'access', _383 => _383.filters, 'optionalAccess', _384 => _384.find, 'call', _385 => _385((f) => f.id === filterId)]), () => ( fail(`Node "${nodeId}" has no filter "${filterId}"; it has ${(_nullishCoalesce(node.filters, () => ( []))).map((f) => `"${f.id}" (${f.type})`).join(", ") || "none"}.`)));
   };
-  const maskResult = (id) => ({ id, mask: _nullishCoalesce(_chunkUTEVPQTScjs.vectorMaskSummary.call(void 0, controller.getNode(id)), () => ( fail(`"${id}" is not a mask group.`))) });
+  const maskResult = (id) => ({ id, mask: _nullishCoalesce(_chunkW3GXSUSQcjs.vectorMaskSummary.call(void 0, controller.getNode(id)), () => ( fail(`"${id}" is not a mask group.`))) });
   const maskInputs = (params) => {
     const list2 = [...new Set(ids(params))];
     if (list2.length < 2) fail(`Masking needs at least two objects (the mask and what it masks); got ${list2.length}. Pass ids, or select more.`);
@@ -8569,7 +8569,7 @@ function createVectorCommands(controller, options = {}) {
   };
   const maskTargets = (params) => {
     const list2 = ids(params);
-    const groups = list2.map((id) => controller.getNode(id)).filter((n) => _chunkUTEVPQTScjs.isVectorMaskGroup.call(void 0, n));
+    const groups = list2.map((id) => controller.getNode(id)).filter((n) => _chunkW3GXSUSQcjs.isVectorMaskGroup.call(void 0, n));
     if (!groups.length) fail(`None of ${list2.map((id) => `"${id}"`).join(", ")} is a mask group. Mask groups have a \`mask\` in vector.list; make one with vector.makeClippingMask or vector.makeOpacityMask.`);
     return groups.map((g) => g.id);
   };
@@ -8700,7 +8700,7 @@ function createVectorCommands(controller, options = {}) {
       params: {
         type: "object",
         properties: {
-          type: { type: "string", enum: _chunkUTEVPQTScjs.VECTOR_FILTER_TYPES, description: "The filter type." },
+          type: { type: "string", enum: _chunkW3GXSUSQcjs.VECTOR_FILTER_TYPES, description: "The filter type." },
           params: FILTER_PARAMS,
           index: { type: "integer", minimum: 0, description: "Position in the stack (default: last)." },
           ids: IDS
@@ -8711,7 +8711,7 @@ function createVectorCommands(controller, options = {}) {
       undoable: true,
       enabled: enabledFor,
       run: (_ctx, params) => {
-        if (!_chunkUTEVPQTScjs.VECTOR_FILTER_TYPES.includes(params.type)) fail(`Unknown filter type "${params.type}"; use one of ${_chunkUTEVPQTScjs.VECTOR_FILTER_TYPES.join(", ")}.`);
+        if (!_chunkW3GXSUSQcjs.VECTOR_FILTER_TYPES.includes(params.type)) fail(`Unknown filter type "${params.type}"; use one of ${_chunkW3GXSUSQcjs.VECTOR_FILTER_TYPES.join(", ")}.`);
         checkFilterParams(params.type, params.params);
         const targets = ids(params);
         const created = controller.addFilter(params.type, { ids: targets, params: params.params, index: params.index });
@@ -8827,7 +8827,7 @@ function createVectorCommands(controller, options = {}) {
           width: { type: "number", description: "For a line: the x offset of its end." },
           height: { type: "number", description: "For a line: the y offset of its end." },
           cornerRadius: { type: "number", minimum: 0, description: "Live corner radius of a rect, polygon or star." },
-          cornerKind: { type: "string", enum: _chunkUTEVPQTScjs.VECTOR_CORNER_KINDS },
+          cornerKind: { type: "string", enum: _chunkW3GXSUSQcjs.VECTOR_CORNER_KINDS },
           sides: { type: "integer", minimum: 3 },
           points: { type: "integer", minimum: 3 },
           innerRatio: { type: "number", minimum: 0, maximum: 1 },
@@ -8884,7 +8884,7 @@ function createVectorCommands(controller, options = {}) {
       undoable: true,
       run: (_ctx, params) => {
         const { ids: _i, target, ...patch } = _nullishCoalesce(params, () => ( {}));
-        if (patch.type !== void 0 && !_chunkUTEVPQTScjs.VECTOR_GRADIENT_TYPES.includes(patch.type)) fail(`Unknown gradient type "${patch.type}".`);
+        if (patch.type !== void 0 && !_chunkW3GXSUSQcjs.VECTOR_GRADIENT_TYPES.includes(patch.type)) fail(`Unknown gradient type "${patch.type}".`);
         if (patch.stops !== void 0 && !(Array.isArray(patch.stops) && patch.stops.length)) fail("stops needs at least one { offset, color }.");
         check(controller.setGradient(patch, { ids: ids(params), target: _nullishCoalesce(target, () => ( "fill")) }));
         const id = ids(params)[0];
@@ -8901,7 +8901,7 @@ function createVectorCommands(controller, options = {}) {
       label: "Corner Radius\u2026",
       keywords: ["round", "rounded", "corners", "radius", "fillet", "chamfer", "live corners"],
       description: "Sets the live corner radius (and optionally `kind`: round, inverted or chamfer) of `anchors`, else the selected points (direct tool), else every corner of `ids` / the selection. Radius 0 makes corners sharp; radii shrink to fit short sides. The anchors stay editable.",
-      params: { type: "object", properties: { radius: { type: "number", minimum: 0 }, kind: { type: "string", enum: _chunkUTEVPQTScjs.VECTOR_CORNER_KINDS }, ids: IDS, anchors: ANCHORS } },
+      params: { type: "object", properties: { radius: { type: "number", minimum: 0 }, kind: { type: "string", enum: _chunkW3GXSUSQcjs.VECTOR_CORNER_KINDS }, ids: IDS, anchors: ANCHORS } },
       undoable: true,
       run: (_ctx, params) => {
         const refs = _optionalChain([params, 'optionalAccess', _403 => _403.anchors]) ? anchorsOf(params.anchors) : void 0;
@@ -8922,7 +8922,7 @@ function createVectorCommands(controller, options = {}) {
         type: "object",
         properties: {
           ids: IDS,
-          preset: { type: "string", enum: _chunkUTEVPQTScjs.VECTOR_WIDTH_PRESET_IDS },
+          preset: { type: "string", enum: _chunkW3GXSUSQcjs.VECTOR_WIDTH_PRESET_IDS },
           points: WIDTH_POINTS,
           taper: {
             type: "object",
@@ -9045,7 +9045,7 @@ function createVectorCommands(controller, options = {}) {
         type: "object",
         properties: {
           ids: IDS,
-          preset: { type: "string", enum: _chunkDWGZUSEScjs.WARP_STYLES },
+          preset: { type: "string", enum: _chunkW3GXSUSQcjs.WARP_STYLES },
           bend: { type: "number", minimum: -100, maximum: 100 },
           horizontal: { type: "number", minimum: -100, maximum: 100 },
           vertical: { type: "number", minimum: -100, maximum: 100 },
@@ -9074,7 +9074,7 @@ function createVectorCommands(controller, options = {}) {
           check(r);
           return { nodeId: r.nodeId };
         }
-        if (params.preset !== void 0 && !_chunkDWGZUSEScjs.WARP_STYLES.includes(params.preset)) fail(`Unknown warp preset "${params.preset}".`);
+        if (params.preset !== void 0 && !_chunkW3GXSUSQcjs.WARP_STYLES.includes(params.preset)) fail(`Unknown warp preset "${params.preset}".`);
         const patch = {};
         if (params.preset) patch.style = params.preset;
         for (const k of ["bend", "horizontal", "vertical"]) if (params[k] !== void 0) patch[k] = params[k];
@@ -9089,7 +9089,7 @@ function createVectorCommands(controller, options = {}) {
           if (params.mesh.points) {
             const even = (n) => Array.from({ length: n + 1 }, (_, i) => i / n);
             const mesh = { us: even(columns), vs: even(rows), points: params.mesh.points.map((p) => ({ x: p.x, y: p.y })) };
-            if (!_chunkDWGZUSEScjs.isValidWarpMesh.call(void 0, mesh)) fail(`A ${columns} \xD7 ${rows} mesh needs ${(3 * columns + 1) * (3 * rows + 1)} finite points.`);
+            if (!_chunkW3GXSUSQcjs.isValidWarpMesh.call(void 0, mesh)) fail(`A ${columns} \xD7 ${rows} mesh needs ${(3 * columns + 1) * (3 * rows + 1)} finite points.`);
             patch.mesh = mesh;
           }
         }
@@ -9172,7 +9172,7 @@ function createVectorCommands(controller, options = {}) {
       params: {
         type: "object",
         properties: {
-          type: { type: "string", enum: _chunkUTEVPQTScjs.VECTOR_EFFECT_TYPES },
+          type: { type: "string", enum: _chunkW3GXSUSQcjs.VECTOR_EFFECT_TYPES },
           params: { type: "object", description: EFFECT_PARAMS_DESCRIPTION },
           index: { type: "integer", minimum: 0, description: "Position in the stack (default: last)." },
           ids: IDS
@@ -9182,7 +9182,7 @@ function createVectorCommands(controller, options = {}) {
       undoable: true,
       enabled: enabledFor,
       run: (_ctx, params) => {
-        if (!_chunkUTEVPQTScjs.VECTOR_EFFECT_TYPES.includes(params.type)) fail(`Unknown effect type "${params.type}".`);
+        if (!_chunkW3GXSUSQcjs.VECTOR_EFFECT_TYPES.includes(params.type)) fail(`Unknown effect type "${params.type}".`);
         const targets = ids(params);
         const created = controller.addEffect(params.type, { ids: targets, params: params.params, index: params.index });
         if (!created.length) fail("Nothing to add the effect to.");
@@ -9327,10 +9327,10 @@ function createVectorCommands(controller, options = {}) {
       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: [..._chunkUTEVPQTScjs.VECTOR_PATHFINDER_OPERATIONS] }, ids: IDS }, required: ["operation"] },
+      params: { type: "object", properties: { operation: { type: "string", enum: [..._chunkW3GXSUSQcjs.VECTOR_PATHFINDER_OPERATIONS] }, ids: IDS }, required: ["operation"] },
       undoable: true,
       run: (_ctx, params) => {
-        if (!_chunkUTEVPQTScjs.VECTOR_PATHFINDER_OPERATIONS.includes(params.operation)) fail(`Unknown Pathfinder operation "${params.operation}".`);
+        if (!_chunkW3GXSUSQcjs.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] };
@@ -9636,7 +9636,7 @@ function createVectorCommands(controller, options = {}) {
       label: "Choose Tool\u2026",
       keywords: ["pen", "pencil", "select", "rectangle", "ellipse"],
       description: "Switches the canvas tool.",
-      params: { type: "object", properties: { tool: { type: "string", enum: [..._chunkUTEVPQTScjs.VECTOR_TOOLS] } }, required: ["tool"] },
+      params: { type: "object", properties: { tool: { type: "string", enum: [..._chunkW3GXSUSQcjs.VECTOR_TOOLS] } }, required: ["tool"] },
       run: (_ctx, params) => {
         controller.setTool(params.tool);
         return { tool: params.tool };
@@ -10126,5 +10126,5 @@ function createVectorCommands(controller, options = {}) {
 
 
 
-exports.DEFAULT_VECTOR_BLEND_DISTANCE = DEFAULT_VECTOR_BLEND_DISTANCE; exports.DEFAULT_VECTOR_BLEND_STEPS = DEFAULT_VECTOR_BLEND_STEPS; exports.DEFAULT_VECTOR_PATH_EDIT = DEFAULT_VECTOR_PATH_EDIT; exports.DEFAULT_VECTOR_SNAP = DEFAULT_VECTOR_SNAP; exports.IDENTITY_MATRIX = _chunkDWGZUSEScjs.IDENTITY_MATRIX; exports.KAPPA = _chunkUTEVPQTScjs.KAPPA; exports.LazyMouse = LazyMouse; exports.VECTOR_ARROWHEADS = _chunkUTEVPQTScjs.VECTOR_ARROWHEADS; exports.VECTOR_ARROWHEAD_LABELS = VECTOR_ARROWHEAD_LABELS; exports.VECTOR_BLEND_MAX_SMOOTH_STEPS = VECTOR_BLEND_MAX_SMOOTH_STEPS; exports.VECTOR_BLEND_MAX_STEPS = VECTOR_BLEND_MAX_STEPS; exports.VECTOR_BLEND_MODES = _chunkUTEVPQTScjs.VECTOR_BLEND_MODES; exports.VECTOR_BLEND_MODE_LABELS = _chunkUTEVPQTScjs.VECTOR_BLEND_MODE_LABELS; exports.VECTOR_BLEND_MODE_MENU = VECTOR_BLEND_MODE_MENU; exports.VECTOR_BLEND_SPACINGS = _chunkUTEVPQTScjs.VECTOR_BLEND_SPACINGS; exports.VECTOR_BLEND_SPACING_LABELS = VECTOR_BLEND_SPACING_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 = _chunkUTEVPQTScjs.VECTOR_CORNER_KINDS; exports.VECTOR_CORNER_KIND_LABELS = VECTOR_CORNER_KIND_LABELS; exports.VECTOR_CORNER_WIDGET_INSET = VECTOR_CORNER_WIDGET_INSET; exports.VECTOR_DISTORT_TOLERANCE = VECTOR_DISTORT_TOLERANCE; exports.VECTOR_EDIT_TOGGLES = VECTOR_EDIT_TOGGLES; exports.VECTOR_EFFECT_DEFAULTS = _chunkUTEVPQTScjs.VECTOR_EFFECT_DEFAULTS; exports.VECTOR_EFFECT_LABELS = _chunkUTEVPQTScjs.VECTOR_EFFECT_LABELS; exports.VECTOR_EFFECT_MENU = VECTOR_EFFECT_MENU; exports.VECTOR_EFFECT_PARAM_SPECS = _chunkUTEVPQTScjs.VECTOR_EFFECT_PARAM_SPECS; exports.VECTOR_EFFECT_TYPES = _chunkUTEVPQTScjs.VECTOR_EFFECT_TYPES; exports.VECTOR_ENVELOPE_STYLE_OPTIONS = VECTOR_ENVELOPE_STYLE_OPTIONS; exports.VECTOR_FILL_GAP = VECTOR_FILL_GAP; exports.VECTOR_FILTER_DEFAULTS = _chunkUTEVPQTScjs.VECTOR_FILTER_DEFAULTS; exports.VECTOR_FILTER_LABELS = _chunkUTEVPQTScjs.VECTOR_FILTER_LABELS; exports.VECTOR_FILTER_MENU = _chunkUTEVPQTScjs.VECTOR_FILTER_MENU; exports.VECTOR_FILTER_PARAM_SPECS = _chunkUTEVPQTScjs.VECTOR_FILTER_PARAM_SPECS; exports.VECTOR_FILTER_TYPES = _chunkUTEVPQTScjs.VECTOR_FILTER_TYPES; exports.VECTOR_GRADIENT_INTERPOLATIONS = _chunkUTEVPQTScjs.VECTOR_GRADIENT_INTERPOLATIONS; exports.VECTOR_GRADIENT_INTERPOLATION_LABELS = VECTOR_GRADIENT_INTERPOLATION_LABELS; exports.VECTOR_GRADIENT_MAX_PERIODS = _chunkUTEVPQTScjs.VECTOR_GRADIENT_MAX_PERIODS; exports.VECTOR_GRADIENT_MIDPOINT_GAP = VECTOR_GRADIENT_MIDPOINT_GAP; exports.VECTOR_GRADIENT_MIN_STOPS = _chunkUTEVPQTScjs.VECTOR_GRADIENT_MIN_STOPS; exports.VECTOR_GRADIENT_OFF_BAR = VECTOR_GRADIENT_OFF_BAR; exports.VECTOR_GRADIENT_SPREADS = _chunkUTEVPQTScjs.VECTOR_GRADIENT_SPREADS; exports.VECTOR_GRADIENT_SPREAD_LABELS = VECTOR_GRADIENT_SPREAD_LABELS; exports.VECTOR_GRADIENT_STOP_GAP = VECTOR_GRADIENT_STOP_GAP; exports.VECTOR_GRADIENT_TYPES = _chunkUTEVPQTScjs.VECTOR_GRADIENT_TYPES; exports.VECTOR_GRADIENT_TYPE_LABELS = VECTOR_GRADIENT_TYPE_LABELS; exports.VECTOR_INK_MAX_CORNERS = VECTOR_INK_MAX_CORNERS; exports.VECTOR_MASK_TYPES = _chunkUTEVPQTScjs.VECTOR_MASK_TYPES; exports.VECTOR_MASK_TYPE_LABELS = VECTOR_MASK_TYPE_LABELS; exports.VECTOR_MASK_TYPE_OPTIONS = VECTOR_MASK_TYPE_OPTIONS; exports.VECTOR_MERGE_MODES = _chunkUTEVPQTScjs.VECTOR_MERGE_MODES; 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 = _chunkUTEVPQTScjs.VECTOR_PATHFINDER_OPERATIONS; exports.VECTOR_PATH_ACTIONS = VECTOR_PATH_ACTIONS; exports.VECTOR_PENCIL_STRING_PX = VECTOR_PENCIL_STRING_PX; exports.VECTOR_PRESSURE_NOMINAL = _chunkUTEVPQTScjs.VECTOR_PRESSURE_NOMINAL; exports.VECTOR_ROTATE_HANDLE_OFFSET = VECTOR_ROTATE_HANDLE_OFFSET; exports.VECTOR_STROKE_ALIGN_LABELS = VECTOR_STROKE_ALIGN_LABELS; exports.VECTOR_STROKE_GRADIENT_MODES = _chunkUTEVPQTScjs.VECTOR_STROKE_GRADIENT_MODES; exports.VECTOR_STROKE_GRADIENT_MODE_LABELS = VECTOR_STROKE_GRADIENT_MODE_LABELS; exports.VECTOR_STROKE_SETTING_KEYS = _chunkUTEVPQTScjs.VECTOR_STROKE_SETTING_KEYS; exports.VECTOR_STYLE_KEYS = VECTOR_STYLE_KEYS; exports.VECTOR_TOOLS = _chunkUTEVPQTScjs.VECTOR_TOOLS; exports.VECTOR_TOOL_GLYPHS = VECTOR_TOOL_GLYPHS; exports.VECTOR_TOOL_SHORTCUTS = VECTOR_TOOL_SHORTCUTS; exports.VECTOR_TRANSFORM_HANDLES = _chunkUTEVPQTScjs.VECTOR_TRANSFORM_HANDLES; exports.VECTOR_WARP_STYLES = _chunkDWGZUSEScjs.WARP_STYLES; exports.VECTOR_WARP_STYLE_LABELS = _chunkDWGZUSEScjs.WARP_STYLE_LABELS; exports.VECTOR_WIDTH_PRESETS = _chunkUTEVPQTScjs.VECTOR_WIDTH_PRESETS; exports.VECTOR_WIDTH_PRESET_IDS = _chunkUTEVPQTScjs.VECTOR_WIDTH_PRESET_IDS; exports.VECTOR_WIDTH_PROFILE_MAX_POINTS = _chunkUTEVPQTScjs.VECTOR_WIDTH_PROFILE_MAX_POINTS; exports.VECTOR_WIDTH_PROFILE_MAX_SCALE = _chunkUTEVPQTScjs.VECTOR_WIDTH_PROFILE_MAX_SCALE; exports.VECTOR_WIDTH_SAME_T = _chunkUTEVPQTScjs.VECTOR_WIDTH_SAME_T; exports.VectorEditorController = VectorEditorController; exports.VectorSnapTargets = VectorSnapTargets; exports.activeVectorEffects = _chunkUTEVPQTScjs.activeVectorEffects; exports.activeVectorFilters = _chunkUTEVPQTScjs.activeVectorFilters; exports.addBuilderHit = addBuilderHit; exports.applyMatrix = _chunkDWGZUSEScjs.applyMatrix; exports.applyMatrixLinear = _chunkDWGZUSEScjs.applyMatrixLinear; exports.applyVectorBlendOptions = applyVectorBlendOptions; exports.applyVectorCornersAttribute = _chunkUTEVPQTScjs.applyVectorCornersAttribute; exports.applyVectorEffects = _chunkUTEVPQTScjs.applyVectorEffects; exports.applyVectorGradientPatch = _chunkUTEVPQTScjs.applyVectorGradientPatch; exports.applyVectorGradientSpread = _chunkUTEVPQTScjs.applyVectorGradientSpread; exports.applyVectorHomography = _chunkMUUXNRU4cjs.applyHomography; exports.arrowheadInset = _chunkUTEVPQTScjs.arrowheadInset; exports.arrowheadPath = _chunkUTEVPQTScjs.arrowheadPath; exports.arrowheadWeight = _chunkUTEVPQTScjs.arrowheadWeight; exports.bendSegment = bendSegment; exports.bezierToSubpaths = _chunkUTEVPQTScjs.bezierToSubpaths; exports.boundsFromPoints = _chunkUTEVPQTScjs.boundsFromPoints; exports.boundsIntersect = _chunkUTEVPQTScjs.boundsIntersect; exports.clearVectorLiveBooleanCache = _chunkUTEVPQTScjs.clearVectorLiveBooleanCache; exports.cloneAnchor = _chunkUTEVPQTScjs.cloneAnchor; exports.cloneSubpath = _chunkUTEVPQTScjs.cloneSubpath; exports.cloneVectorDocument = _chunkUTEVPQTScjs.cloneVectorDocument; exports.cloneVectorNode = _chunkUTEVPQTScjs.cloneVectorNode; exports.collectPathNodes = _chunkUTEVPQTScjs.collectPathNodes; exports.constrainToLeave = constrainToLeave; exports.convertAnchor = _chunkUTEVPQTScjs.convertAnchor; exports.convertVectorGradient = _chunkUTEVPQTScjs.convertVectorGradient; exports.cornerBisectorPoint = _chunkUTEVPQTScjs.cornerBisectorPoint; exports.cornerRadiusChange = _chunkUTEVPQTScjs.cornerRadiusChange; exports.cornerSetback = _chunkUTEVPQTScjs.cornerSetback; exports.correspondMorphContours = _chunkUTEVPQTScjs.correspondMorphContours; exports.createVectorCommands = createVectorCommands; exports.createVectorEffect = _chunkUTEVPQTScjs.createVectorEffect; exports.createVectorFilter = _chunkUTEVPQTScjs.createVectorFilter; exports.createVectorMorph = _chunkUTEVPQTScjs.createVectorMorph; exports.curvatureMoveAnchor = curvatureMoveAnchor; exports.cutSubpathAt = cutSubpathAt; exports.dashIntervals = _chunkUTEVPQTScjs.dashIntervals; exports.decomposeRigid = _chunkDWGZUSEScjs.decomposeRigid; exports.defaultVectorGradient = _chunkUTEVPQTScjs.defaultVectorGradient; exports.distortVectorNode = distortVectorNode; exports.dragVectorMeshPoint = _chunkDWGZUSEScjs.dragWarpMeshPoint; exports.effectPathLength = _chunkUTEVPQTScjs.effectPathLength; exports.effectPathVertexCount = _chunkUTEVPQTScjs.effectPathVertexCount; exports.effectiveStrokeAlign = _chunkUTEVPQTScjs.effectiveStrokeAlign; exports.ellipseSubpath = _chunkUTEVPQTScjs.ellipseSubpath; exports.eraseFromFill = _chunkUTEVPQTScjs.eraseFromFill; exports.eraseFromOutline = _chunkUTEVPQTScjs.eraseFromOutline; exports.eraserRegion = _chunkUTEVPQTScjs.eraserRegion; exports.evalVectorMesh = _chunkDWGZUSEScjs.evalWarpMesh; exports.evaluateVectorPathKeyframes = _chunkUTEVPQTScjs.evaluateVectorPathKeyframes; exports.expandVectorAppearance = _chunkUTEVPQTScjs.expandVectorAppearance; exports.expandVectorAppearances = _chunkUTEVPQTScjs.expandVectorAppearances; exports.expandVectorBlend = expandVectorBlend; exports.expandVectorCorners = _chunkUTEVPQTScjs.expandVectorCorners; exports.expandVectorCornersOf = _chunkUTEVPQTScjs.expandVectorCornersOf; exports.expandVectorGradientSpread = _chunkUTEVPQTScjs.expandVectorGradientSpread; exports.expandVectorGradientStops = _chunkUTEVPQTScjs.expandVectorGradientStops; exports.explicitVectorGradient = _chunkUTEVPQTScjs.explicitVectorGradient; exports.findVectorNode = _chunkUTEVPQTScjs.findVectorNode; exports.fitCornerRadius = _chunkUTEVPQTScjs.fitCornerRadius; exports.fitVectorMesh = _chunkDWGZUSEScjs.fitWarpMesh; exports.foldVectorBooleanOperands = _chunkUTEVPQTScjs.foldVectorBooleanOperands; exports.generateVectorBlendChildren = generateVectorBlendChildren; exports.generateWidthProfile = _chunkUTEVPQTScjs.generateWidthProfile; exports.getAnchor = getAnchor; exports.getAnchorWorld = getAnchorWorld; exports.getEditablePathIds = getEditablePathIds; exports.getTransformHandlePositions = getTransformHandlePositions; exports.getVectorAppearancePanel = getVectorAppearancePanel; exports.getVectorBlendControls = getVectorBlendControls; exports.getVectorCornerWidgets = getVectorCornerWidgets; exports.getVectorEffectsPanel = getVectorEffectsPanel; exports.getVectorEnteredGroups = getVectorEnteredGroups; exports.getVectorEnvelopePanel = getVectorEnvelopePanel; exports.getVectorEnvelopeTarget = getVectorEnvelopeTarget; exports.getVectorGradientAnnotator = getVectorGradientAnnotator; exports.getVectorGradientEditor = getVectorGradientEditor; exports.getVectorMaskPanel = getVectorMaskPanel; 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.gradientMidpointRemap = _chunkUTEVPQTScjs.gradientMidpointRemap; exports.hasExplicitGradientGeometry = _chunkUTEVPQTScjs.hasExplicitGradientGeometry; exports.hasOwnVectorAppearance = _chunkUTEVPQTScjs.hasOwnVectorAppearance; exports.hasPaint = _chunkUTEVPQTScjs.hasPaint; exports.hasStrokeExtras = _chunkUTEVPQTScjs.hasStrokeExtras; exports.hasVectorAppearance = _chunkUTEVPQTScjs.hasVectorAppearance; exports.hasVectorCorners = _chunkUTEVPQTScjs.hasVectorCorners; exports.hasVectorPaintStacks = _chunkUTEVPQTScjs.hasVectorPaintStacks; exports.hitTestVectorNode = _chunkUTEVPQTScjs.hitTestVectorNode; exports.hitTestVectorNodes = _chunkUTEVPQTScjs.hitTestVectorNodes; exports.hitTestVectorPaintLayer = _chunkUTEVPQTScjs.hitTestVectorPaintLayer; exports.hitTestVectorPaintStack = _chunkUTEVPQTScjs.hitTestVectorPaintStack; exports.hitTestVectorStroke = _chunkUTEVPQTScjs.hitTestVectorStroke; exports.hitVectorGradientAnnotator = hitVectorGradientAnnotator; exports.inferAnchorType = _chunkUTEVPQTScjs.inferAnchorType; exports.insertAnchor = _chunkUTEVPQTScjs.insertAnchor; exports.insertVectorGradientStop = _chunkUTEVPQTScjs.insertVectorGradientStop; exports.insertWidthPoint = _chunkUTEVPQTScjs.insertWidthPoint; exports.interpolateMorphContours = _chunkUTEVPQTScjs.interpolateMorphContours; exports.interpolateRigidMatrix = _chunkUTEVPQTScjs.interpolateRigidMatrix; exports.interpolateVectorColor = _chunkUTEVPQTScjs.interpolateVectorColor; exports.interpolateVectorPaint = _chunkUTEVPQTScjs.interpolateVectorPaint; exports.interpolateVectorPaths = _chunkUTEVPQTScjs.interpolateVectorPaths; exports.interpolateVectorStyle = _chunkUTEVPQTScjs.interpolateVectorStyle; exports.interpolateWidthProfiles = _chunkUTEVPQTScjs.interpolateWidthProfiles; exports.invertMatrix = _chunkDWGZUSEScjs.invertMatrix; exports.isCentredVectorGradient = _chunkUTEVPQTScjs.isCentredVectorGradient; exports.isClosedBezierShape = _chunkUTEVPQTScjs.isClosedBezierShape; exports.isDrawnVectorPaintLayer = _chunkUTEVPQTScjs.isDrawnVectorPaintLayer; exports.isIdentityMatrix = _chunkDWGZUSEScjs.isIdentityMatrix; exports.isPlainVectorPaintLayer = _chunkUTEVPQTScjs.isPlainVectorPaintLayer; exports.isUniformWidthProfile = _chunkUTEVPQTScjs.isUniformWidthProfile; exports.isValidVectorMesh = _chunkDWGZUSEScjs.isValidWarpMesh; exports.isVectorBlendGroup = isVectorBlendGroup; exports.isVectorBlendMode = _chunkUTEVPQTScjs.isVectorBlendMode; exports.isVectorFilterType = _chunkUTEVPQTScjs.isVectorFilterType; exports.isVectorGradient = _chunkUTEVPQTScjs.isVectorGradient; exports.isVectorLiveBoolean = _chunkUTEVPQTScjs.isVectorLiveBoolean; exports.isVectorMaskActive = _chunkUTEVPQTScjs.isVectorMaskActive; exports.isVectorMaskGroup = _chunkUTEVPQTScjs.isVectorMaskGroup; exports.isVectorMaskType = _chunkUTEVPQTScjs.isVectorMaskType; exports.isVectorTextTarget = isVectorTextTarget; exports.joinSubpaths = joinSubpaths; exports.knifePath = _chunkUTEVPQTScjs.knifePath; exports.lineSubpath = _chunkUTEVPQTScjs.lineSubpath; exports.locateVectorNode = _chunkUTEVPQTScjs.locateVectorNode; exports.mapBezierPath = _chunkUTEVPQTScjs.mapBezierPath; exports.mapVectorGradient = _chunkUTEVPQTScjs.mapVectorGradient; exports.mapVectorMeshPoints = _chunkDWGZUSEScjs.mapWarpMeshPoints; exports.mapVectorPaint = _chunkUTEVPQTScjs.mapVectorPaint; exports.mapVectorPoints = _chunkUTEVPQTScjs.mapVectorPoints; exports.mapVectorSubpaths = _chunkUTEVPQTScjs.mapVectorSubpaths; exports.matrixRotation = _chunkDWGZUSEScjs.matrixRotation; exports.mergePaths = _chunkUTEVPQTScjs.mergePaths; exports.mirrorWidthProfile = _chunkUTEVPQTScjs.mirrorWidthProfile; exports.morphContourToSubpath = _chunkUTEVPQTScjs.morphContourToSubpath; exports.morphPathsCross = _chunkUTEVPQTScjs.morphPathsCross; exports.moveAnchorHandle = _chunkUTEVPQTScjs.moveAnchorHandle; exports.moveVectorGradientHandle = _chunkUTEVPQTScjs.moveVectorGradientHandle; exports.moveVectorGradientStop = _chunkUTEVPQTScjs.moveVectorGradientStop; exports.multiplyMatrices = _chunkDWGZUSEScjs.multiplyMatrices; exports.nearestSegment = _chunkUTEVPQTScjs.nearestSegment; exports.nearestStrokePosition = _chunkUTEVPQTScjs.nearestStrokePosition; exports.needsVectorPaintLayers = _chunkUTEVPQTScjs.needsVectorPaintLayers; exports.newVectorStrokeLayer = _chunkUTEVPQTScjs.newVectorStrokeLayer; exports.nextVectorCornerKind = _chunkUTEVPQTScjs.nextVectorCornerKind; exports.nodeMatrix = _chunkUTEVPQTScjs.nodeMatrix; exports.normalizeVectorEffectParams = _chunkUTEVPQTScjs.normalizeVectorEffectParams; exports.normalizeVectorFilterParams = _chunkUTEVPQTScjs.normalizeVectorFilterParams; exports.normalizeVectorPaintStacks = _chunkUTEVPQTScjs.normalizeVectorPaintStacks; exports.offsetPaths = _chunkUTEVPQTScjs.offsetPaths; exports.orderVectorQuad = _chunkMUUXNRU4cjs.orderQuad; exports.parseSvgTransform = _chunkUTEVPQTScjs.parseSvgTransform; exports.parseVectorColor = _chunkUTEVPQTScjs.parseVectorColor; exports.parseVectorSvg = _chunkUTEVPQTScjs.parseVectorSvg; exports.pathsCenter = _chunkUTEVPQTScjs.pathsCenter; exports.patternAttrs = _chunkUTEVPQTScjs.patternAttrs; exports.periodicVectorGradientStops = _chunkUTEVPQTScjs.periodicVectorGradientStops; exports.pinVectorGradient = _chunkUTEVPQTScjs.pinVectorGradient; exports.planShapeBuilder = planShapeBuilder; exports.polygonSubpath = _chunkUTEVPQTScjs.polygonSubpath; exports.polylineBounds = _chunkUTEVPQTScjs.polylineBounds; exports.pressureWidthProfile = _chunkUTEVPQTScjs.pressureWidthProfile; exports.puckerBloatPaths = _chunkUTEVPQTScjs.puckerBloatPaths; exports.pullVectorMesh = _chunkDWGZUSEScjs.pullWarpMesh; exports.recognizeInkShape = recognizeInkShape; exports.rectSubpath = _chunkUTEVPQTScjs.rectSubpath; exports.refineMorphContour = _chunkUTEVPQTScjs.refineMorphContour; exports.refreshVectorBlends = refreshVectorBlends; exports.releaseVectorBlend = releaseVectorBlend; exports.removeAnchorKeepingShape = removeAnchorKeepingShape; exports.removeAnchors = _chunkUTEVPQTScjs.removeAnchors; exports.removeAnchorsKeepingShape = removeAnchorsKeepingShape; exports.removeRedundantPoints = removeRedundantPoints; exports.removeVectorGradientStop = _chunkUTEVPQTScjs.removeVectorGradientStop; exports.removeVectorMeshSplitU = _chunkDWGZUSEScjs.removeWarpMeshSplitU; exports.removeVectorMeshSplitV = _chunkDWGZUSEScjs.removeWarpMeshSplitV; exports.removeWidthPoints = _chunkUTEVPQTScjs.removeWidthPoints; exports.repeatPaths = _chunkUTEVPQTScjs.repeatPaths; exports.resampleGradientStops = _chunkUTEVPQTScjs.resampleGradientStops; exports.resizeVectorMesh = _chunkDWGZUSEScjs.resizeWarpMesh; exports.resolveVectorBlendOptions = resolveVectorBlendOptions; exports.reverseMorphContour = _chunkUTEVPQTScjs.reverseMorphContour; exports.reverseSubpath = _chunkUTEVPQTScjs.reverseSubpath; exports.reverseVectorGradient = _chunkUTEVPQTScjs.reverseVectorGradient; exports.reverseWidthProfile = _chunkUTEVPQTScjs.reverseWidthProfile; exports.rotateMatrix = _chunkDWGZUSEScjs.rotateMatrix; exports.roundCornerPaths = _chunkUTEVPQTScjs.roundCornerPaths; exports.roundSubpaths = _chunkUTEVPQTScjs.roundSubpaths; exports.samplePlainStops = _chunkUTEVPQTScjs.samplePlainStops; exports.samplePolyline = samplePolyline; exports.sampleVectorGradient = _chunkUTEVPQTScjs.sampleVectorGradient; exports.sampleVectorGradientAt = _chunkUTEVPQTScjs.sampleVectorGradientAt; exports.sampleVectorPaintDefAt = _chunkUTEVPQTScjs.sampleVectorPaintDefAt; exports.sanitizeVectorEffects = _chunkUTEVPQTScjs.sanitizeVectorEffects; exports.sanitizeVectorFills = _chunkUTEVPQTScjs.sanitizeVectorFills; exports.sanitizeVectorFilters = _chunkUTEVPQTScjs.sanitizeVectorFilters; exports.sanitizeVectorGradient = _chunkUTEVPQTScjs.sanitizeVectorGradient; exports.sanitizeVectorMask = _chunkUTEVPQTScjs.sanitizeVectorMask; exports.sanitizeVectorStrokeSettings = _chunkUTEVPQTScjs.sanitizeVectorStrokeSettings; exports.sanitizeVectorStrokes = _chunkUTEVPQTScjs.sanitizeVectorStrokes; exports.sanitizeWidthProfile = _chunkUTEVPQTScjs.sanitizeWidthProfile; exports.scaleFor = scaleFor; exports.scaleMatrix = _chunkDWGZUSEScjs.scaleMatrix; exports.setAnchorCorner = _chunkUTEVPQTScjs.setAnchorCorner; exports.setSubpathCorners = _chunkUTEVPQTScjs.setSubpathCorners; exports.setVectorGradientVector = _chunkUTEVPQTScjs.setVectorGradientVector; exports.setWidthPoint = _chunkUTEVPQTScjs.setWidthPoint; exports.simplifyPolyline = _chunkUTEVPQTScjs.simplifyPolyline; exports.smoothSubpath = smoothSubpath; exports.solve8 = _chunkMUUXNRU4cjs.solve8; exports.sortedVectorGradientStops = _chunkUTEVPQTScjs.sortedVectorGradientStops; exports.spanVectorGradientStops = _chunkUTEVPQTScjs.spanVectorGradientStops; exports.splitIntoFaces = _chunkUTEVPQTScjs.splitIntoFaces; exports.splitSubpathAt = splitSubpathAt; exports.splitVectorMeshU = _chunkDWGZUSEScjs.splitWarpMeshU; exports.splitVectorMeshV = _chunkDWGZUSEScjs.splitWarpMeshV; exports.starSubpath = _chunkUTEVPQTScjs.starSubpath; exports.strokePositionPoint = _chunkUTEVPQTScjs.strokePositionPoint; exports.strokeWidthProfileOf = _chunkUTEVPQTScjs.strokeWidthProfileOf; exports.subpathEnclosesArea = subpathEnclosesArea; exports.subpathPointAt = subpathPointAt; exports.subpathSegment = _chunkUTEVPQTScjs.subpathSegment; exports.subpathSegmentCount = _chunkUTEVPQTScjs.subpathSegmentCount; exports.subpathToMorphContour = _chunkUTEVPQTScjs.subpathToMorphContour; exports.subpathsToBezier = _chunkUTEVPQTScjs.subpathsToBezier; exports.taperWaveFactor = _chunkUTEVPQTScjs.taperWaveFactor; exports.toVectorKeyInput = toVectorKeyInput; exports.toVectorModifiers = toVectorModifiers; exports.toVectorPointerInput = toVectorPointerInput; exports.transformVectorEffects = _chunkUTEVPQTScjs.transformVectorEffects; exports.transformVectorGradient = _chunkUTEVPQTScjs.transformVectorGradient; exports.transformVectorNode = _chunkUTEVPQTScjs.transformVectorNode; exports.transformVectorPaint = _chunkUTEVPQTScjs.transformVectorPaint; exports.translateAnchor = _chunkUTEVPQTScjs.translateAnchor; exports.translateMatrix = _chunkDWGZUSEScjs.translateMatrix; exports.trimIntervals = _chunkUTEVPQTScjs.trimIntervals; exports.trimPaths = _chunkUTEVPQTScjs.trimPaths; exports.trimPathsIndividually = _chunkUTEVPQTScjs.trimPathsIndividually; exports.turnMorphContour = _chunkUTEVPQTScjs.turnMorphContour; exports.twistPaths = _chunkUTEVPQTScjs.twistPaths; exports.unionBounds = _chunkUTEVPQTScjs.unionBounds; exports.variableStrokeOutline = _chunkUTEVPQTScjs.variableStrokeOutline; exports.variableStrokeRings = _chunkUTEVPQTScjs.variableStrokeRings; exports.vectorAppearanceNodes = _chunkUTEVPQTScjs.vectorAppearanceNodes; exports.vectorAppearanceOutline = _chunkUTEVPQTScjs.vectorAppearanceOutline; exports.vectorAppearanceShapes = _chunkUTEVPQTScjs.vectorAppearanceShapes; exports.vectorBlendColorDistance = vectorBlendColorDistance; exports.vectorBlendKeyTargets = vectorBlendKeyTargets; exports.vectorBlendKeys = vectorBlendKeys; exports.vectorBlendModeCss = _chunkUTEVPQTScjs.vectorBlendModeCss; exports.vectorBlendModeFromCss = _chunkUTEVPQTScjs.vectorBlendModeFromCss; exports.vectorBlendRail = vectorBlendRail; exports.vectorBlendRailAt = vectorBlendRailAt; exports.vectorBlendSpine = vectorBlendSpine; exports.vectorBlendStepCount = vectorBlendStepCount; exports.vectorBoxCorners = vectorBoxCorners; exports.vectorBoxMatrix = _chunkUTEVPQTScjs.vectorBoxMatrix; exports.vectorBuilderErasedEdges = vectorBuilderErasedEdges; exports.vectorChildAppearanceShapes = _chunkUTEVPQTScjs.vectorChildAppearanceShapes; exports.vectorCornerAt = _chunkUTEVPQTScjs.vectorCornerAt; exports.vectorCorners = _chunkUTEVPQTScjs.vectorCorners; exports.vectorCornersAttribute = _chunkUTEVPQTScjs.vectorCornersAttribute; exports.vectorDiamondPath = vectorDiamondPath; exports.vectorDistortQuad = vectorDistortQuad; exports.vectorDocumentToSvg = _chunkUTEVPQTScjs.vectorDocumentToSvg; exports.vectorEffectInputBounds = _chunkUTEVPQTScjs.vectorEffectInputBounds; exports.vectorEffectInputPaths = _chunkUTEVPQTScjs.vectorEffectInputPaths; exports.vectorEnteredGroups = _chunkUTEVPQTScjs.vectorEnteredGroups; exports.vectorEnvelopeFrame = _chunkUTEVPQTScjs.vectorEnvelopeFrame; exports.vectorEnvelopeMap = _chunkUTEVPQTScjs.vectorEnvelopeMap; exports.vectorEnvelopeMesh = _chunkUTEVPQTScjs.vectorEnvelopeMesh; exports.vectorFillMap = vectorFillMap; exports.vectorFills = _chunkUTEVPQTScjs.vectorFills; exports.vectorFilterMarkup = _chunkUTEVPQTScjs.vectorFilterMarkup; exports.vectorFilterParamKeys = _chunkUTEVPQTScjs.vectorFilterParamKeys; exports.vectorFilterReach = _chunkUTEVPQTScjs.vectorFilterReach; exports.vectorFilterSvg = _chunkUTEVPQTScjs.vectorFilterSvg; exports.vectorGradientArea = _chunkUTEVPQTScjs.vectorGradientArea; exports.vectorGradientAspect = _chunkUTEVPQTScjs.vectorGradientAspect; exports.vectorGradientBarPosition = vectorGradientBarPosition; exports.vectorGradientFocalParam = _chunkUTEVPQTScjs.vectorGradientFocalParam; exports.vectorGradientHandles = _chunkUTEVPQTScjs.vectorGradientHandles; exports.vectorGradientMatrix = _chunkUTEVPQTScjs.vectorGradientMatrix; exports.vectorGradientMidpointFromPosition = _chunkUTEVPQTScjs.vectorGradientMidpointFromPosition; exports.vectorGradientMidpointPosition = _chunkUTEVPQTScjs.vectorGradientMidpointPosition; exports.vectorGradientNeedsExpansion = _chunkUTEVPQTScjs.vectorGradientNeedsExpansion; exports.vectorGradientParam = _chunkUTEVPQTScjs.vectorGradientParam; exports.vectorGradientPoints = _chunkUTEVPQTScjs.vectorGradientPoints; exports.vectorGradientRamp = _chunkUTEVPQTScjs.vectorGradientRamp; exports.vectorGradientSvgDefs = _chunkUTEVPQTScjs.vectorGradientSvgDefs; exports.vectorGradientTAt = _chunkUTEVPQTScjs.vectorGradientTAt; exports.vectorGradientTargetPath = vectorGradientTargetPath; exports.vectorGradientUnitsMatrix = _chunkUTEVPQTScjs.vectorGradientUnitsMatrix; exports.vectorHomography = _chunkMUUXNRU4cjs.homographyFromPoints; exports.vectorHomographyKeepsQuad = _chunkMUUXNRU4cjs.homographyKeepsQuad; exports.vectorIdentityMesh = _chunkDWGZUSEScjs.identityWarpMesh; exports.vectorInkShapeName = vectorInkShapeName; exports.vectorLiveBooleanSteps = _chunkUTEVPQTScjs.vectorLiveBooleanSteps; exports.vectorMaskContains = _chunkUTEVPQTScjs.vectorMaskContains; exports.vectorMaskContentBounds = _chunkUTEVPQTScjs.vectorMaskContentBounds; exports.vectorMaskContents = _chunkUTEVPQTScjs.vectorMaskContents; exports.vectorMaskOwner = _chunkUTEVPQTScjs.vectorMaskOwner; exports.vectorMaskRegion = _chunkUTEVPQTScjs.vectorMaskRegion; exports.vectorMaskRegionPath = _chunkUTEVPQTScjs.vectorMaskRegionPath; exports.vectorMaskRegionShapes = _chunkUTEVPQTScjs.vectorMaskRegionShapes; exports.vectorMaskRenderData = _chunkUTEVPQTScjs.vectorMaskRenderData; exports.vectorMaskSource = _chunkUTEVPQTScjs.vectorMaskSource; exports.vectorMaskSummary = _chunkUTEVPQTScjs.vectorMaskSummary; exports.vectorMaskedGeometry = _chunkUTEVPQTScjs.vectorMaskedGeometry; exports.vectorMaskedLocalBounds = _chunkUTEVPQTScjs.vectorMaskedLocalBounds; exports.vectorMaskedShapes = _chunkUTEVPQTScjs.vectorMaskedShapes; exports.vectorMeshColumns = _chunkDWGZUSEScjs.warpMeshColumns; exports.vectorMeshControlBounds = _chunkDWGZUSEScjs.warpMeshControlBounds; exports.vectorMeshEditPoints = _chunkDWGZUSEScjs.warpMeshEditPoints; exports.vectorMeshFromOutline = _chunkUTEVPQTScjs.vectorMeshFromOutline; exports.vectorMeshGridCurves = _chunkDWGZUSEScjs.warpMeshGridCurves; exports.vectorMeshOutline = _chunkUTEVPQTScjs.vectorMeshOutline; exports.vectorMeshParamAt = _chunkDWGZUSEScjs.warpMeshParamAt; exports.vectorMeshRows = _chunkDWGZUSEScjs.warpMeshRows; exports.vectorNodeBounds = _chunkUTEVPQTScjs.vectorNodeBounds; exports.vectorNodeEnvelope = _chunkUTEVPQTScjs.vectorNodeEnvelope; exports.vectorNodeFilterSvg = _chunkUTEVPQTScjs.vectorNodeFilterSvg; exports.vectorNodeLocalPaintBounds = _chunkUTEVPQTScjs.vectorNodeLocalPaintBounds; exports.vectorNodeRotation = _chunkUTEVPQTScjs.vectorNodeRotation; exports.vectorNodeToBezier = _chunkUTEVPQTScjs.vectorNodeToBezier; exports.vectorOperandOperation = _chunkUTEVPQTScjs.vectorOperandOperation; exports.vectorPaintLayerNodes = _chunkUTEVPQTScjs.vectorPaintLayerNodes; exports.vectorPaintSwatch = vectorPaintSwatch; exports.vectorPaintToHex = vectorPaintToHex; exports.vectorPaintToSvg = _chunkUTEVPQTScjs.vectorPaintToSvg; exports.vectorParentMatrix = _chunkUTEVPQTScjs.vectorParentMatrix; exports.vectorPathData = _chunkUTEVPQTScjs.vectorPathData; exports.vectorPathEntries = vectorPathEntries; exports.vectorPathLocalBounds = _chunkUTEVPQTScjs.vectorPathLocalBounds; exports.vectorPathWorldBezier = _chunkUTEVPQTScjs.vectorPathWorldBezier; exports.vectorPathfinderShape = vectorPathfinderShape; exports.vectorRepeaterCopies = _chunkUTEVPQTScjs.vectorRepeaterCopies; exports.vectorResizeCursor = vectorResizeCursor; exports.vectorResultStyle = vectorResultStyle; exports.vectorShapeBuilderHit = vectorShapeBuilderHit; exports.vectorShapeBuilderMap = vectorShapeBuilderMap; exports.vectorShearForSide = vectorShearForSide; exports.vectorSkewMatrix = vectorSkewMatrix; exports.vectorStacksHaveGradient = _chunkUTEVPQTScjs.vectorStacksHaveGradient; exports.vectorStrokeGradientDefs = _chunkUTEVPQTScjs.vectorStrokeGradientDefs; exports.vectorStrokeLineArea = _chunkUTEVPQTScjs.vectorStrokeLineArea; exports.vectorStrokeOutline = _chunkUTEVPQTScjs.vectorStrokeOutline; exports.vectorStrokeOutlinePath = _chunkUTEVPQTScjs.vectorStrokeOutlinePath; exports.vectorStrokeParts = _chunkUTEVPQTScjs.vectorStrokeParts; exports.vectorStrokeReach = _chunkUTEVPQTScjs.vectorStrokeReach; exports.vectorStrokeSettings = _chunkUTEVPQTScjs.vectorStrokeSettings; exports.vectorStrokeStackReach = _chunkUTEVPQTScjs.vectorStrokeStackReach; exports.vectorStrokeSvgParts = _chunkUTEVPQTScjs.vectorStrokeSvgParts; exports.vectorStrokeWidthGeometry = vectorStrokeWidthGeometry; exports.vectorStrokes = _chunkUTEVPQTScjs.vectorStrokes; exports.vectorTargetPaint = _chunkUTEVPQTScjs.vectorTargetPaint; exports.vectorToolLabel = vectorToolLabel; exports.vectorWarpPresetGrid = _chunkDWGZUSEScjs.warpPresetGrid; exports.vectorWarpPresetMesh = _chunkDWGZUSEScjs.warpPresetMesh; exports.vectorWorldMatrix = _chunkUTEVPQTScjs.vectorWorldMatrix; exports.walkVectorNodes = _chunkUTEVPQTScjs.walkVectorNodes; exports.widthProfileAt = _chunkUTEVPQTScjs.widthProfileAt; exports.widthProfileFromAttribute = _chunkUTEVPQTScjs.widthProfileFromAttribute; exports.widthProfileMaxScale = _chunkUTEVPQTScjs.widthProfileMaxScale; exports.widthProfilePreset = _chunkUTEVPQTScjs.widthProfilePreset; exports.widthProfilePresetId = _chunkUTEVPQTScjs.widthProfilePresetId; exports.widthProfileToAttribute = _chunkUTEVPQTScjs.widthProfileToAttribute; exports.wigglePaths = _chunkUTEVPQTScjs.wigglePaths; exports.withVectorFills = _chunkUTEVPQTScjs.withVectorFills; exports.withVectorStrokes = _chunkUTEVPQTScjs.withVectorStrokes; exports.withVectorTargetPaint = _chunkUTEVPQTScjs.withVectorTargetPaint; exports.zigzagPaths = _chunkUTEVPQTScjs.zigzagPaths;
+exports.DEFAULT_VECTOR_BLEND_DISTANCE = DEFAULT_VECTOR_BLEND_DISTANCE; exports.DEFAULT_VECTOR_BLEND_STEPS = DEFAULT_VECTOR_BLEND_STEPS; exports.DEFAULT_VECTOR_PATH_EDIT = DEFAULT_VECTOR_PATH_EDIT; exports.DEFAULT_VECTOR_SNAP = DEFAULT_VECTOR_SNAP; exports.IDENTITY_MATRIX = _chunkW3GXSUSQcjs.IDENTITY_MATRIX; exports.KAPPA = _chunkW3GXSUSQcjs.KAPPA; exports.LazyMouse = LazyMouse; exports.VECTOR_ARROWHEADS = _chunkW3GXSUSQcjs.VECTOR_ARROWHEADS; exports.VECTOR_ARROWHEAD_LABELS = VECTOR_ARROWHEAD_LABELS; exports.VECTOR_BLEND_MAX_SMOOTH_STEPS = VECTOR_BLEND_MAX_SMOOTH_STEPS; exports.VECTOR_BLEND_MAX_STEPS = VECTOR_BLEND_MAX_STEPS; exports.VECTOR_BLEND_MODES = _chunkW3GXSUSQcjs.VECTOR_BLEND_MODES; exports.VECTOR_BLEND_MODE_LABELS = _chunkW3GXSUSQcjs.VECTOR_BLEND_MODE_LABELS; exports.VECTOR_BLEND_MODE_MENU = VECTOR_BLEND_MODE_MENU; exports.VECTOR_BLEND_SPACINGS = _chunkW3GXSUSQcjs.VECTOR_BLEND_SPACINGS; exports.VECTOR_BLEND_SPACING_LABELS = VECTOR_BLEND_SPACING_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 = _chunkW3GXSUSQcjs.VECTOR_CORNER_KINDS; exports.VECTOR_CORNER_KIND_LABELS = VECTOR_CORNER_KIND_LABELS; exports.VECTOR_CORNER_WIDGET_INSET = VECTOR_CORNER_WIDGET_INSET; exports.VECTOR_DISTORT_TOLERANCE = VECTOR_DISTORT_TOLERANCE; exports.VECTOR_EDIT_TOGGLES = VECTOR_EDIT_TOGGLES; exports.VECTOR_EFFECT_DEFAULTS = _chunkW3GXSUSQcjs.VECTOR_EFFECT_DEFAULTS; exports.VECTOR_EFFECT_LABELS = _chunkW3GXSUSQcjs.VECTOR_EFFECT_LABELS; exports.VECTOR_EFFECT_MENU = VECTOR_EFFECT_MENU; exports.VECTOR_EFFECT_PARAM_SPECS = _chunkW3GXSUSQcjs.VECTOR_EFFECT_PARAM_SPECS; exports.VECTOR_EFFECT_TYPES = _chunkW3GXSUSQcjs.VECTOR_EFFECT_TYPES; exports.VECTOR_ENVELOPE_STYLE_OPTIONS = VECTOR_ENVELOPE_STYLE_OPTIONS; exports.VECTOR_FILL_GAP = VECTOR_FILL_GAP; exports.VECTOR_FILTER_DEFAULTS = _chunkW3GXSUSQcjs.VECTOR_FILTER_DEFAULTS; exports.VECTOR_FILTER_LABELS = _chunkW3GXSUSQcjs.VECTOR_FILTER_LABELS; exports.VECTOR_FILTER_MENU = _chunkW3GXSUSQcjs.VECTOR_FILTER_MENU; exports.VECTOR_FILTER_PARAM_SPECS = _chunkW3GXSUSQcjs.VECTOR_FILTER_PARAM_SPECS; exports.VECTOR_FILTER_TYPES = _chunkW3GXSUSQcjs.VECTOR_FILTER_TYPES; exports.VECTOR_GRADIENT_INTERPOLATIONS = _chunkW3GXSUSQcjs.VECTOR_GRADIENT_INTERPOLATIONS; exports.VECTOR_GRADIENT_INTERPOLATION_LABELS = VECTOR_GRADIENT_INTERPOLATION_LABELS; exports.VECTOR_GRADIENT_MAX_PERIODS = _chunkW3GXSUSQcjs.VECTOR_GRADIENT_MAX_PERIODS; exports.VECTOR_GRADIENT_MIDPOINT_GAP = VECTOR_GRADIENT_MIDPOINT_GAP; exports.VECTOR_GRADIENT_MIN_STOPS = _chunkW3GXSUSQcjs.VECTOR_GRADIENT_MIN_STOPS; exports.VECTOR_GRADIENT_OFF_BAR = VECTOR_GRADIENT_OFF_BAR; exports.VECTOR_GRADIENT_SPREADS = _chunkW3GXSUSQcjs.VECTOR_GRADIENT_SPREADS; exports.VECTOR_GRADIENT_SPREAD_LABELS = VECTOR_GRADIENT_SPREAD_LABELS; exports.VECTOR_GRADIENT_STOP_GAP = VECTOR_GRADIENT_STOP_GAP; exports.VECTOR_GRADIENT_TYPES = _chunkW3GXSUSQcjs.VECTOR_GRADIENT_TYPES; exports.VECTOR_GRADIENT_TYPE_LABELS = VECTOR_GRADIENT_TYPE_LABELS; exports.VECTOR_INK_MAX_CORNERS = VECTOR_INK_MAX_CORNERS; exports.VECTOR_MASK_TYPES = _chunkW3GXSUSQcjs.VECTOR_MASK_TYPES; exports.VECTOR_MASK_TYPE_LABELS = VECTOR_MASK_TYPE_LABELS; exports.VECTOR_MASK_TYPE_OPTIONS = VECTOR_MASK_TYPE_OPTIONS; exports.VECTOR_MERGE_MODES = _chunkW3GXSUSQcjs.VECTOR_MERGE_MODES; 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 = _chunkW3GXSUSQcjs.VECTOR_PATHFINDER_OPERATIONS; exports.VECTOR_PATH_ACTIONS = VECTOR_PATH_ACTIONS; exports.VECTOR_PENCIL_STRING_PX = VECTOR_PENCIL_STRING_PX; exports.VECTOR_PRESSURE_NOMINAL = _chunkW3GXSUSQcjs.VECTOR_PRESSURE_NOMINAL; exports.VECTOR_ROTATE_HANDLE_OFFSET = VECTOR_ROTATE_HANDLE_OFFSET; exports.VECTOR_STROKE_ALIGN_LABELS = VECTOR_STROKE_ALIGN_LABELS; exports.VECTOR_STROKE_GRADIENT_MODES = _chunkW3GXSUSQcjs.VECTOR_STROKE_GRADIENT_MODES; exports.VECTOR_STROKE_GRADIENT_MODE_LABELS = VECTOR_STROKE_GRADIENT_MODE_LABELS; exports.VECTOR_STROKE_SETTING_KEYS = _chunkW3GXSUSQcjs.VECTOR_STROKE_SETTING_KEYS; exports.VECTOR_STYLE_KEYS = VECTOR_STYLE_KEYS; exports.VECTOR_TOOLS = _chunkW3GXSUSQcjs.VECTOR_TOOLS; exports.VECTOR_TOOL_GLYPHS = VECTOR_TOOL_GLYPHS; exports.VECTOR_TOOL_SHORTCUTS = VECTOR_TOOL_SHORTCUTS; exports.VECTOR_TRANSFORM_HANDLES = _chunkW3GXSUSQcjs.VECTOR_TRANSFORM_HANDLES; exports.VECTOR_WARP_STYLES = _chunkW3GXSUSQcjs.WARP_STYLES; exports.VECTOR_WARP_STYLE_LABELS = _chunkW3GXSUSQcjs.WARP_STYLE_LABELS; exports.VECTOR_WIDTH_PRESETS = _chunkW3GXSUSQcjs.VECTOR_WIDTH_PRESETS; exports.VECTOR_WIDTH_PRESET_IDS = _chunkW3GXSUSQcjs.VECTOR_WIDTH_PRESET_IDS; exports.VECTOR_WIDTH_PROFILE_MAX_POINTS = _chunkW3GXSUSQcjs.VECTOR_WIDTH_PROFILE_MAX_POINTS; exports.VECTOR_WIDTH_PROFILE_MAX_SCALE = _chunkW3GXSUSQcjs.VECTOR_WIDTH_PROFILE_MAX_SCALE; exports.VECTOR_WIDTH_SAME_T = _chunkW3GXSUSQcjs.VECTOR_WIDTH_SAME_T; exports.VectorEditorController = VectorEditorController; exports.VectorSnapTargets = VectorSnapTargets; exports.activeVectorEffects = _chunkW3GXSUSQcjs.activeVectorEffects; exports.activeVectorFilters = _chunkW3GXSUSQcjs.activeVectorFilters; exports.addBuilderHit = addBuilderHit; exports.applyMatrix = _chunkW3GXSUSQcjs.applyMatrix; exports.applyMatrixLinear = _chunkW3GXSUSQcjs.applyMatrixLinear; exports.applyVectorBlendOptions = applyVectorBlendOptions; exports.applyVectorCornersAttribute = _chunkJLYX4V57cjs.applyVectorCornersAttribute; exports.applyVectorEffects = _chunkW3GXSUSQcjs.applyVectorEffects; exports.applyVectorGradientPatch = _chunkW3GXSUSQcjs.applyVectorGradientPatch; exports.applyVectorGradientSpread = _chunkW3GXSUSQcjs.applyVectorGradientSpread; exports.applyVectorHomography = _chunkMUUXNRU4cjs.applyHomography; exports.arrowheadInset = _chunkW3GXSUSQcjs.arrowheadInset; exports.arrowheadPath = _chunkW3GXSUSQcjs.arrowheadPath; exports.arrowheadWeight = _chunkW3GXSUSQcjs.arrowheadWeight; exports.bendSegment = bendSegment; exports.bezierToSubpaths = _chunkW3GXSUSQcjs.bezierToSubpaths; exports.boundsFromPoints = _chunkW3GXSUSQcjs.boundsFromPoints; exports.boundsIntersect = _chunkW3GXSUSQcjs.boundsIntersect; exports.clearVectorLiveBooleanCache = _chunkW3GXSUSQcjs.clearVectorLiveBooleanCache; exports.cloneAnchor = _chunkW3GXSUSQcjs.cloneAnchor; exports.cloneSubpath = _chunkW3GXSUSQcjs.cloneSubpath; exports.cloneVectorDocument = _chunkW3GXSUSQcjs.cloneVectorDocument; exports.cloneVectorNode = _chunkW3GXSUSQcjs.cloneVectorNode; exports.collectPathNodes = _chunkW3GXSUSQcjs.collectPathNodes; exports.constrainToLeave = constrainToLeave; exports.convertAnchor = _chunkW3GXSUSQcjs.convertAnchor; exports.convertVectorGradient = _chunkW3GXSUSQcjs.convertVectorGradient; exports.cornerBisectorPoint = _chunkW3GXSUSQcjs.cornerBisectorPoint; exports.cornerRadiusChange = _chunkW3GXSUSQcjs.cornerRadiusChange; exports.cornerSetback = _chunkW3GXSUSQcjs.cornerSetback; exports.correspondMorphContours = _chunkJLYX4V57cjs.correspondMorphContours; exports.createVectorCommands = createVectorCommands; exports.createVectorEffect = _chunkW3GXSUSQcjs.createVectorEffect; exports.createVectorFilter = _chunkW3GXSUSQcjs.createVectorFilter; exports.createVectorMorph = _chunkJLYX4V57cjs.createVectorMorph; exports.curvatureMoveAnchor = curvatureMoveAnchor; exports.cutSubpathAt = cutSubpathAt; exports.dashIntervals = _chunkW3GXSUSQcjs.dashIntervals; exports.decomposeRigid = _chunkW3GXSUSQcjs.decomposeRigid; exports.defaultVectorGradient = _chunkW3GXSUSQcjs.defaultVectorGradient; exports.distortVectorNode = distortVectorNode; exports.dragVectorMeshPoint = _chunkW3GXSUSQcjs.dragWarpMeshPoint; exports.effectPathLength = _chunkW3GXSUSQcjs.effectPathLength; exports.effectPathVertexCount = _chunkW3GXSUSQcjs.effectPathVertexCount; exports.effectiveStrokeAlign = _chunkW3GXSUSQcjs.effectiveStrokeAlign; exports.ellipseSubpath = _chunkW3GXSUSQcjs.ellipseSubpath; exports.eraseFromFill = _chunkW3GXSUSQcjs.eraseFromFill; exports.eraseFromOutline = _chunkW3GXSUSQcjs.eraseFromOutline; exports.eraserRegion = _chunkW3GXSUSQcjs.eraserRegion; exports.evalVectorMesh = _chunkW3GXSUSQcjs.evalWarpMesh; exports.evaluateVectorPathKeyframes = _chunkJLYX4V57cjs.evaluateVectorPathKeyframes; exports.expandVectorAppearance = _chunkW3GXSUSQcjs.expandVectorAppearance; exports.expandVectorAppearances = _chunkW3GXSUSQcjs.expandVectorAppearances; exports.expandVectorBlend = expandVectorBlend; exports.expandVectorCorners = _chunkW3GXSUSQcjs.expandVectorCorners; exports.expandVectorCornersOf = _chunkW3GXSUSQcjs.expandVectorCornersOf; exports.expandVectorGradientSpread = _chunkW3GXSUSQcjs.expandVectorGradientSpread; exports.expandVectorGradientStops = _chunkW3GXSUSQcjs.expandVectorGradientStops; exports.explicitVectorGradient = _chunkW3GXSUSQcjs.explicitVectorGradient; exports.findVectorNode = _chunkW3GXSUSQcjs.findVectorNode; exports.fitCornerRadius = _chunkW3GXSUSQcjs.fitCornerRadius; exports.fitVectorMesh = _chunkW3GXSUSQcjs.fitWarpMesh; exports.foldVectorBooleanOperands = _chunkW3GXSUSQcjs.foldVectorBooleanOperands; exports.generateVectorBlendChildren = generateVectorBlendChildren; exports.generateWidthProfile = _chunkW3GXSUSQcjs.generateWidthProfile; exports.getAnchor = getAnchor; exports.getAnchorWorld = getAnchorWorld; exports.getEditablePathIds = getEditablePathIds; exports.getTransformHandlePositions = getTransformHandlePositions; exports.getVectorAppearancePanel = getVectorAppearancePanel; exports.getVectorBlendControls = getVectorBlendControls; exports.getVectorCornerWidgets = getVectorCornerWidgets; exports.getVectorEffectsPanel = getVectorEffectsPanel; exports.getVectorEnteredGroups = getVectorEnteredGroups; exports.getVectorEnvelopePanel = getVectorEnvelopePanel; exports.getVectorEnvelopeTarget = getVectorEnvelopeTarget; exports.getVectorGradientAnnotator = getVectorGradientAnnotator; exports.getVectorGradientEditor = getVectorGradientEditor; exports.getVectorMaskPanel = getVectorMaskPanel; 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.gradientMidpointRemap = _chunkW3GXSUSQcjs.gradientMidpointRemap; exports.hasExplicitGradientGeometry = _chunkW3GXSUSQcjs.hasExplicitGradientGeometry; exports.hasOwnVectorAppearance = _chunkW3GXSUSQcjs.hasOwnVectorAppearance; exports.hasPaint = _chunkW3GXSUSQcjs.hasPaint; exports.hasStrokeExtras = _chunkW3GXSUSQcjs.hasStrokeExtras; exports.hasVectorAppearance = _chunkW3GXSUSQcjs.hasVectorAppearance; exports.hasVectorCorners = _chunkW3GXSUSQcjs.hasVectorCorners; exports.hasVectorPaintStacks = _chunkW3GXSUSQcjs.hasVectorPaintStacks; exports.hitTestVectorNode = _chunkW3GXSUSQcjs.hitTestVectorNode; exports.hitTestVectorNodes = _chunkW3GXSUSQcjs.hitTestVectorNodes; exports.hitTestVectorPaintLayer = _chunkW3GXSUSQcjs.hitTestVectorPaintLayer; exports.hitTestVectorPaintStack = _chunkW3GXSUSQcjs.hitTestVectorPaintStack; exports.hitTestVectorStroke = _chunkW3GXSUSQcjs.hitTestVectorStroke; exports.hitVectorGradientAnnotator = hitVectorGradientAnnotator; exports.inferAnchorType = _chunkW3GXSUSQcjs.inferAnchorType; exports.insertAnchor = _chunkW3GXSUSQcjs.insertAnchor; exports.insertVectorGradientStop = _chunkW3GXSUSQcjs.insertVectorGradientStop; exports.insertWidthPoint = _chunkW3GXSUSQcjs.insertWidthPoint; exports.interpolateMorphContours = _chunkJLYX4V57cjs.interpolateMorphContours; exports.interpolateRigidMatrix = _chunkJLYX4V57cjs.interpolateRigidMatrix; exports.interpolateVectorColor = _chunkJLYX4V57cjs.interpolateVectorColor; exports.interpolateVectorPaint = _chunkJLYX4V57cjs.interpolateVectorPaint; exports.interpolateVectorPaths = _chunkJLYX4V57cjs.interpolateVectorPaths; exports.interpolateVectorStyle = _chunkJLYX4V57cjs.interpolateVectorStyle; exports.interpolateWidthProfiles = _chunkJLYX4V57cjs.interpolateWidthProfiles; exports.invertMatrix = _chunkW3GXSUSQcjs.invertMatrix; exports.isCentredVectorGradient = _chunkW3GXSUSQcjs.isCentredVectorGradient; exports.isClosedBezierShape = _chunkW3GXSUSQcjs.isClosedBezierShape; exports.isDrawnVectorPaintLayer = _chunkW3GXSUSQcjs.isDrawnVectorPaintLayer; exports.isIdentityMatrix = _chunkW3GXSUSQcjs.isIdentityMatrix; exports.isPlainVectorPaintLayer = _chunkW3GXSUSQcjs.isPlainVectorPaintLayer; exports.isUniformWidthProfile = _chunkW3GXSUSQcjs.isUniformWidthProfile; exports.isValidVectorMesh = _chunkW3GXSUSQcjs.isValidWarpMesh; exports.isVectorBlendGroup = isVectorBlendGroup; exports.isVectorBlendMode = _chunkW3GXSUSQcjs.isVectorBlendMode; exports.isVectorFilterType = _chunkW3GXSUSQcjs.isVectorFilterType; exports.isVectorGradient = _chunkW3GXSUSQcjs.isVectorGradient; exports.isVectorLiveBoolean = _chunkW3GXSUSQcjs.isVectorLiveBoolean; exports.isVectorMaskActive = _chunkW3GXSUSQcjs.isVectorMaskActive; exports.isVectorMaskGroup = _chunkW3GXSUSQcjs.isVectorMaskGroup; exports.isVectorMaskType = _chunkW3GXSUSQcjs.isVectorMaskType; exports.isVectorTextTarget = isVectorTextTarget; exports.joinSubpaths = joinSubpaths; exports.knifePath = _chunkW3GXSUSQcjs.knifePath; exports.lineSubpath = _chunkW3GXSUSQcjs.lineSubpath; exports.locateVectorNode = _chunkW3GXSUSQcjs.locateVectorNode; exports.mapBezierPath = _chunkW3GXSUSQcjs.mapBezierPath; exports.mapVectorGradient = _chunkW3GXSUSQcjs.mapVectorGradient; exports.mapVectorMeshPoints = _chunkW3GXSUSQcjs.mapWarpMeshPoints; exports.mapVectorPaint = _chunkW3GXSUSQcjs.mapVectorPaint; exports.mapVectorPoints = _chunkW3GXSUSQcjs.mapVectorPoints; exports.mapVectorSubpaths = _chunkW3GXSUSQcjs.mapVectorSubpaths; exports.matrixRotation = _chunkW3GXSUSQcjs.matrixRotation; exports.mergePaths = _chunkW3GXSUSQcjs.mergePaths; exports.mirrorWidthProfile = _chunkW3GXSUSQcjs.mirrorWidthProfile; exports.morphContourToSubpath = _chunkJLYX4V57cjs.morphContourToSubpath; exports.morphPathsCross = _chunkJLYX4V57cjs.morphPathsCross; exports.moveAnchorHandle = _chunkW3GXSUSQcjs.moveAnchorHandle; exports.moveVectorGradientHandle = _chunkW3GXSUSQcjs.moveVectorGradientHandle; exports.moveVectorGradientStop = _chunkW3GXSUSQcjs.moveVectorGradientStop; exports.multiplyMatrices = _chunkW3GXSUSQcjs.multiplyMatrices; exports.nearestSegment = _chunkW3GXSUSQcjs.nearestSegment; exports.nearestStrokePosition = _chunkW3GXSUSQcjs.nearestStrokePosition; exports.needsVectorPaintLayers = _chunkW3GXSUSQcjs.needsVectorPaintLayers; exports.newVectorStrokeLayer = _chunkW3GXSUSQcjs.newVectorStrokeLayer; exports.nextVectorCornerKind = _chunkW3GXSUSQcjs.nextVectorCornerKind; exports.nodeMatrix = _chunkW3GXSUSQcjs.nodeMatrix; exports.normalizeVectorEffectParams = _chunkW3GXSUSQcjs.normalizeVectorEffectParams; exports.normalizeVectorFilterParams = _chunkW3GXSUSQcjs.normalizeVectorFilterParams; exports.normalizeVectorPaintStacks = _chunkW3GXSUSQcjs.normalizeVectorPaintStacks; exports.offsetPaths = _chunkW3GXSUSQcjs.offsetPaths; exports.orderVectorQuad = _chunkMUUXNRU4cjs.orderQuad; exports.parseSvgTransform = _chunkJLYX4V57cjs.parseSvgTransform; exports.parseVectorColor = _chunkW3GXSUSQcjs.parseVectorColor; exports.parseVectorSvg = _chunkJLYX4V57cjs.parseVectorSvg; exports.pathsCenter = _chunkW3GXSUSQcjs.pathsCenter; exports.patternAttrs = _chunkW3GXSUSQcjs.patternAttrs; exports.periodicVectorGradientStops = _chunkW3GXSUSQcjs.periodicVectorGradientStops; exports.pinVectorGradient = _chunkW3GXSUSQcjs.pinVectorGradient; exports.planShapeBuilder = planShapeBuilder; exports.polygonSubpath = _chunkW3GXSUSQcjs.polygonSubpath; exports.polylineBounds = _chunkW3GXSUSQcjs.polylineBounds; exports.pressureWidthProfile = _chunkW3GXSUSQcjs.pressureWidthProfile; exports.puckerBloatPaths = _chunkW3GXSUSQcjs.puckerBloatPaths; exports.pullVectorMesh = _chunkW3GXSUSQcjs.pullWarpMesh; exports.recognizeInkShape = recognizeInkShape; exports.rectSubpath = _chunkW3GXSUSQcjs.rectSubpath; exports.refineMorphContour = _chunkJLYX4V57cjs.refineMorphContour; exports.refreshVectorBlends = refreshVectorBlends; exports.releaseVectorBlend = releaseVectorBlend; exports.removeAnchorKeepingShape = removeAnchorKeepingShape; exports.removeAnchors = _chunkW3GXSUSQcjs.removeAnchors; exports.removeAnchorsKeepingShape = removeAnchorsKeepingShape; exports.removeRedundantPoints = removeRedundantPoints; exports.removeVectorGradientStop = _chunkW3GXSUSQcjs.removeVectorGradientStop; exports.removeVectorMeshSplitU = _chunkW3GXSUSQcjs.removeWarpMeshSplitU; exports.removeVectorMeshSplitV = _chunkW3GXSUSQcjs.removeWarpMeshSplitV; exports.removeWidthPoints = _chunkW3GXSUSQcjs.removeWidthPoints; exports.repeatPaths = _chunkW3GXSUSQcjs.repeatPaths; exports.resampleGradientStops = _chunkJLYX4V57cjs.resampleGradientStops; exports.resizeVectorMesh = _chunkW3GXSUSQcjs.resizeWarpMesh; exports.resolveVectorBlendOptions = resolveVectorBlendOptions; exports.reverseMorphContour = _chunkJLYX4V57cjs.reverseMorphContour; exports.reverseSubpath = _chunkW3GXSUSQcjs.reverseSubpath; exports.reverseVectorGradient = _chunkW3GXSUSQcjs.reverseVectorGradient; exports.reverseWidthProfile = _chunkW3GXSUSQcjs.reverseWidthProfile; exports.rotateMatrix = _chunkW3GXSUSQcjs.rotateMatrix; exports.roundCornerPaths = _chunkW3GXSUSQcjs.roundCornerPaths; exports.roundSubpaths = _chunkW3GXSUSQcjs.roundSubpaths; exports.samplePlainStops = _chunkW3GXSUSQcjs.samplePlainStops; exports.samplePolyline = samplePolyline; exports.sampleVectorGradient = _chunkW3GXSUSQcjs.sampleVectorGradient; exports.sampleVectorGradientAt = _chunkW3GXSUSQcjs.sampleVectorGradientAt; exports.sampleVectorPaintDefAt = _chunkW3GXSUSQcjs.sampleVectorPaintDefAt; exports.sanitizeVectorEffects = _chunkW3GXSUSQcjs.sanitizeVectorEffects; exports.sanitizeVectorFills = _chunkW3GXSUSQcjs.sanitizeVectorFills; exports.sanitizeVectorFilters = _chunkW3GXSUSQcjs.sanitizeVectorFilters; exports.sanitizeVectorGradient = _chunkW3GXSUSQcjs.sanitizeVectorGradient; exports.sanitizeVectorMask = _chunkW3GXSUSQcjs.sanitizeVectorMask; exports.sanitizeVectorStrokeSettings = _chunkW3GXSUSQcjs.sanitizeVectorStrokeSettings; exports.sanitizeVectorStrokes = _chunkW3GXSUSQcjs.sanitizeVectorStrokes; exports.sanitizeWidthProfile = _chunkW3GXSUSQcjs.sanitizeWidthProfile; exports.scaleFor = scaleFor; exports.scaleMatrix = _chunkW3GXSUSQcjs.scaleMatrix; exports.setAnchorCorner = _chunkW3GXSUSQcjs.setAnchorCorner; exports.setSubpathCorners = _chunkW3GXSUSQcjs.setSubpathCorners; exports.setVectorGradientVector = _chunkW3GXSUSQcjs.setVectorGradientVector; exports.setWidthPoint = _chunkW3GXSUSQcjs.setWidthPoint; exports.simplifyPolyline = _chunkW3GXSUSQcjs.simplifyPolyline; exports.smoothSubpath = smoothSubpath; exports.solve8 = _chunkMUUXNRU4cjs.solve8; exports.sortedVectorGradientStops = _chunkW3GXSUSQcjs.sortedVectorGradientStops; exports.spanVectorGradientStops = _chunkW3GXSUSQcjs.spanVectorGradientStops; exports.splitIntoFaces = _chunkW3GXSUSQcjs.splitIntoFaces; exports.splitSubpathAt = splitSubpathAt; exports.splitVectorMeshU = _chunkW3GXSUSQcjs.splitWarpMeshU; exports.splitVectorMeshV = _chunkW3GXSUSQcjs.splitWarpMeshV; exports.starSubpath = _chunkW3GXSUSQcjs.starSubpath; exports.strokePositionPoint = _chunkW3GXSUSQcjs.strokePositionPoint; exports.strokeWidthProfileOf = _chunkW3GXSUSQcjs.strokeWidthProfileOf; exports.subpathEnclosesArea = subpathEnclosesArea; exports.subpathPointAt = subpathPointAt; exports.subpathSegment = _chunkW3GXSUSQcjs.subpathSegment; exports.subpathSegmentCount = _chunkW3GXSUSQcjs.subpathSegmentCount; exports.subpathToMorphContour = _chunkJLYX4V57cjs.subpathToMorphContour; exports.subpathsToBezier = _chunkW3GXSUSQcjs.subpathsToBezier; exports.taperWaveFactor = _chunkW3GXSUSQcjs.taperWaveFactor; exports.toVectorKeyInput = toVectorKeyInput; exports.toVectorModifiers = toVectorModifiers; exports.toVectorPointerInput = toVectorPointerInput; exports.transformVectorEffects = _chunkW3GXSUSQcjs.transformVectorEffects; exports.transformVectorGradient = _chunkW3GXSUSQcjs.transformVectorGradient; exports.transformVectorNode = _chunkW3GXSUSQcjs.transformVectorNode; exports.transformVectorPaint = _chunkW3GXSUSQcjs.transformVectorPaint; exports.translateAnchor = _chunkW3GXSUSQcjs.translateAnchor; exports.translateMatrix = _chunkW3GXSUSQcjs.translateMatrix; exports.trimIntervals = _chunkW3GXSUSQcjs.trimIntervals; exports.trimPaths = _chunkW3GXSUSQcjs.trimPaths; exports.trimPathsIndividually = _chunkW3GXSUSQcjs.trimPathsIndividually; exports.turnMorphContour = _chunkJLYX4V57cjs.turnMorphContour; exports.twistPaths = _chunkW3GXSUSQcjs.twistPaths; exports.unionBounds = _chunkW3GXSUSQcjs.unionBounds; exports.variableStrokeOutline = _chunkW3GXSUSQcjs.variableStrokeOutline; exports.variableStrokeRings = _chunkW3GXSUSQcjs.variableStrokeRings; exports.vectorAppearanceNodes = _chunkW3GXSUSQcjs.vectorAppearanceNodes; exports.vectorAppearanceOutline = _chunkW3GXSUSQcjs.vectorAppearanceOutline; exports.vectorAppearanceShapes = _chunkW3GXSUSQcjs.vectorAppearanceShapes; exports.vectorBlendColorDistance = vectorBlendColorDistance; exports.vectorBlendKeyTargets = vectorBlendKeyTargets; exports.vectorBlendKeys = vectorBlendKeys; exports.vectorBlendModeCss = _chunkW3GXSUSQcjs.vectorBlendModeCss; exports.vectorBlendModeFromCss = _chunkW3GXSUSQcjs.vectorBlendModeFromCss; exports.vectorBlendRail = vectorBlendRail; exports.vectorBlendRailAt = vectorBlendRailAt; exports.vectorBlendSpine = vectorBlendSpine; exports.vectorBlendStepCount = vectorBlendStepCount; exports.vectorBoxCorners = vectorBoxCorners; exports.vectorBoxMatrix = _chunkW3GXSUSQcjs.vectorBoxMatrix; exports.vectorBuilderErasedEdges = vectorBuilderErasedEdges; exports.vectorChildAppearanceShapes = _chunkW3GXSUSQcjs.vectorChildAppearanceShapes; exports.vectorCornerAt = _chunkW3GXSUSQcjs.vectorCornerAt; exports.vectorCorners = _chunkW3GXSUSQcjs.vectorCorners; exports.vectorCornersAttribute = _chunkJLYX4V57cjs.vectorCornersAttribute; exports.vectorDiamondPath = vectorDiamondPath; exports.vectorDistortQuad = vectorDistortQuad; exports.vectorDocumentToSvg = _chunkJLYX4V57cjs.vectorDocumentToSvg; exports.vectorEffectInputBounds = _chunkW3GXSUSQcjs.vectorEffectInputBounds; exports.vectorEffectInputPaths = _chunkW3GXSUSQcjs.vectorEffectInputPaths; exports.vectorEnteredGroups = _chunkW3GXSUSQcjs.vectorEnteredGroups; exports.vectorEnvelopeFrame = _chunkW3GXSUSQcjs.vectorEnvelopeFrame; exports.vectorEnvelopeMap = _chunkW3GXSUSQcjs.vectorEnvelopeMap; exports.vectorEnvelopeMesh = _chunkW3GXSUSQcjs.vectorEnvelopeMesh; exports.vectorFillMap = vectorFillMap; exports.vectorFills = _chunkW3GXSUSQcjs.vectorFills; exports.vectorFilterMarkup = _chunkW3GXSUSQcjs.vectorFilterMarkup; exports.vectorFilterParamKeys = _chunkW3GXSUSQcjs.vectorFilterParamKeys; exports.vectorFilterReach = _chunkW3GXSUSQcjs.vectorFilterReach; exports.vectorFilterSvg = _chunkW3GXSUSQcjs.vectorFilterSvg; exports.vectorGradientArea = _chunkW3GXSUSQcjs.vectorGradientArea; exports.vectorGradientAspect = _chunkW3GXSUSQcjs.vectorGradientAspect; exports.vectorGradientBarPosition = vectorGradientBarPosition; exports.vectorGradientFocalParam = _chunkW3GXSUSQcjs.vectorGradientFocalParam; exports.vectorGradientHandles = _chunkW3GXSUSQcjs.vectorGradientHandles; exports.vectorGradientMatrix = _chunkW3GXSUSQcjs.vectorGradientMatrix; exports.vectorGradientMidpointFromPosition = _chunkW3GXSUSQcjs.vectorGradientMidpointFromPosition; exports.vectorGradientMidpointPosition = _chunkW3GXSUSQcjs.vectorGradientMidpointPosition; exports.vectorGradientNeedsExpansion = _chunkW3GXSUSQcjs.vectorGradientNeedsExpansion; exports.vectorGradientParam = _chunkW3GXSUSQcjs.vectorGradientParam; exports.vectorGradientPoints = _chunkW3GXSUSQcjs.vectorGradientPoints; exports.vectorGradientRamp = _chunkW3GXSUSQcjs.vectorGradientRamp; exports.vectorGradientSvgDefs = _chunkW3GXSUSQcjs.vectorGradientSvgDefs; exports.vectorGradientTAt = _chunkW3GXSUSQcjs.vectorGradientTAt; exports.vectorGradientTargetPath = vectorGradientTargetPath; exports.vectorGradientUnitsMatrix = _chunkW3GXSUSQcjs.vectorGradientUnitsMatrix; exports.vectorHomography = _chunkMUUXNRU4cjs.homographyFromPoints; exports.vectorHomographyKeepsQuad = _chunkMUUXNRU4cjs.homographyKeepsQuad; exports.vectorIdentityMesh = _chunkW3GXSUSQcjs.identityWarpMesh; exports.vectorInkShapeName = vectorInkShapeName; exports.vectorLiveBooleanSteps = _chunkW3GXSUSQcjs.vectorLiveBooleanSteps; exports.vectorMaskContains = _chunkW3GXSUSQcjs.vectorMaskContains; exports.vectorMaskContentBounds = _chunkW3GXSUSQcjs.vectorMaskContentBounds; exports.vectorMaskContents = _chunkW3GXSUSQcjs.vectorMaskContents; exports.vectorMaskOwner = _chunkW3GXSUSQcjs.vectorMaskOwner; exports.vectorMaskRegion = _chunkW3GXSUSQcjs.vectorMaskRegion; exports.vectorMaskRegionPath = _chunkW3GXSUSQcjs.vectorMaskRegionPath; exports.vectorMaskRegionShapes = _chunkW3GXSUSQcjs.vectorMaskRegionShapes; exports.vectorMaskRenderData = _chunkW3GXSUSQcjs.vectorMaskRenderData; exports.vectorMaskSource = _chunkW3GXSUSQcjs.vectorMaskSource; exports.vectorMaskSummary = _chunkW3GXSUSQcjs.vectorMaskSummary; exports.vectorMaskedGeometry = _chunkW3GXSUSQcjs.vectorMaskedGeometry; exports.vectorMaskedLocalBounds = _chunkW3GXSUSQcjs.vectorMaskedLocalBounds; exports.vectorMaskedShapes = _chunkW3GXSUSQcjs.vectorMaskedShapes; exports.vectorMeshColumns = _chunkW3GXSUSQcjs.warpMeshColumns; exports.vectorMeshControlBounds = _chunkW3GXSUSQcjs.warpMeshControlBounds; exports.vectorMeshEditPoints = _chunkW3GXSUSQcjs.warpMeshEditPoints; exports.vectorMeshFromOutline = _chunkW3GXSUSQcjs.vectorMeshFromOutline; exports.vectorMeshGridCurves = _chunkW3GXSUSQcjs.warpMeshGridCurves; exports.vectorMeshOutline = _chunkW3GXSUSQcjs.vectorMeshOutline; exports.vectorMeshParamAt = _chunkW3GXSUSQcjs.warpMeshParamAt; exports.vectorMeshRows = _chunkW3GXSUSQcjs.warpMeshRows; exports.vectorNodeBounds = _chunkW3GXSUSQcjs.vectorNodeBounds; exports.vectorNodeEnvelope = _chunkW3GXSUSQcjs.vectorNodeEnvelope; exports.vectorNodeFilterSvg = _chunkJLYX4V57cjs.vectorNodeFilterSvg; exports.vectorNodeLocalPaintBounds = _chunkJLYX4V57cjs.vectorNodeLocalPaintBounds; exports.vectorNodeRotation = _chunkW3GXSUSQcjs.vectorNodeRotation; exports.vectorNodeToBezier = _chunkW3GXSUSQcjs.vectorNodeToBezier; exports.vectorOperandOperation = _chunkW3GXSUSQcjs.vectorOperandOperation; exports.vectorPaintLayerNodes = _chunkW3GXSUSQcjs.vectorPaintLayerNodes; exports.vectorPaintSwatch = vectorPaintSwatch; exports.vectorPaintToHex = vectorPaintToHex; exports.vectorPaintToSvg = _chunkJLYX4V57cjs.vectorPaintToSvg; exports.vectorParentMatrix = _chunkW3GXSUSQcjs.vectorParentMatrix; exports.vectorPathData = _chunkW3GXSUSQcjs.vectorPathData; exports.vectorPathEntries = vectorPathEntries; exports.vectorPathLocalBounds = _chunkJLYX4V57cjs.vectorPathLocalBounds; exports.vectorPathWorldBezier = _chunkW3GXSUSQcjs.vectorPathWorldBezier; exports.vectorPathfinderShape = vectorPathfinderShape; exports.vectorRepeaterCopies = _chunkW3GXSUSQcjs.vectorRepeaterCopies; exports.vectorResizeCursor = vectorResizeCursor; exports.vectorResultStyle = vectorResultStyle; exports.vectorShapeBuilderHit = vectorShapeBuilderHit; exports.vectorShapeBuilderMap = vectorShapeBuilderMap; exports.vectorShearForSide = vectorShearForSide; exports.vectorSkewMatrix = vectorSkewMatrix; exports.vectorStacksHaveGradient = _chunkW3GXSUSQcjs.vectorStacksHaveGradient; exports.vectorStrokeGradientDefs = _chunkJLYX4V57cjs.vectorStrokeGradientDefs; exports.vectorStrokeLineArea = _chunkW3GXSUSQcjs.vectorStrokeLineArea; exports.vectorStrokeOutline = _chunkW3GXSUSQcjs.vectorStrokeOutline; exports.vectorStrokeOutlinePath = _chunkW3GXSUSQcjs.vectorStrokeOutlinePath; exports.vectorStrokeParts = _chunkW3GXSUSQcjs.vectorStrokeParts; exports.vectorStrokeReach = _chunkW3GXSUSQcjs.vectorStrokeReach; exports.vectorStrokeSettings = _chunkW3GXSUSQcjs.vectorStrokeSettings; exports.vectorStrokeStackReach = _chunkW3GXSUSQcjs.vectorStrokeStackReach; exports.vectorStrokeSvgParts = _chunkJLYX4V57cjs.vectorStrokeSvgParts; exports.vectorStrokeWidthGeometry = vectorStrokeWidthGeometry; exports.vectorStrokes = _chunkW3GXSUSQcjs.vectorStrokes; exports.vectorTargetPaint = _chunkW3GXSUSQcjs.vectorTargetPaint; exports.vectorToolLabel = vectorToolLabel; exports.vectorWarpPresetGrid = _chunkW3GXSUSQcjs.warpPresetGrid; exports.vectorWarpPresetMesh = _chunkW3GXSUSQcjs.warpPresetMesh; exports.vectorWorldMatrix = _chunkW3GXSUSQcjs.vectorWorldMatrix; exports.walkVectorNodes = _chunkW3GXSUSQcjs.walkVectorNodes; exports.widthProfileAt = _chunkW3GXSUSQcjs.widthProfileAt; exports.widthProfileFromAttribute = _chunkJLYX4V57cjs.widthProfileFromAttribute; exports.widthProfileMaxScale = _chunkW3GXSUSQcjs.widthProfileMaxScale; exports.widthProfilePreset = _chunkW3GXSUSQcjs.widthProfilePreset; exports.widthProfilePresetId = _chunkW3GXSUSQcjs.widthProfilePresetId; exports.widthProfileToAttribute = _chunkJLYX4V57cjs.widthProfileToAttribute; exports.wigglePaths = _chunkW3GXSUSQcjs.wigglePaths; exports.withVectorFills = _chunkW3GXSUSQcjs.withVectorFills; exports.withVectorStrokes = _chunkW3GXSUSQcjs.withVectorStrokes; exports.withVectorTargetPaint = _chunkW3GXSUSQcjs.withVectorTargetPaint; exports.zigzagPaths = _chunkW3GXSUSQcjs.zigzagPaths;
 //# sourceMappingURL=index.cjs.map