@pixerate/editor 0.32.0 → 0.33.0

package/dist/vector/index.cjs

@@ -189,9 +189,20 @@ function collectPathNodes(node) {
   });
   return out;
 }
-function vectorNodeBounds(node) {
-  if (node.type === "group") return unionBounds(node.children.map(vectorNodeBounds));
-  const b = _chunkM4XE4UMTcjs.bezierPathBounds.call(void 0, subpathsToBezier(node.subpaths));
+function nodeMatrix(node) {
+  return _nullishCoalesce(node.transform, () => ( IDENTITY_MATRIX));
+}
+function vectorPathWorldBezier(node, parent = IDENTITY_MATRIX) {
+  const m = multiplyMatrices(nodeMatrix(node), parent);
+  const path = subpathsToBezier(node.subpaths);
+  return isIdentityMatrix(m) ? path : _chunkM4XE4UMTcjs.transformBezierPath.call(void 0, path, m);
+}
+function vectorNodeBounds(node, parent = IDENTITY_MATRIX) {
+  if (node.type === "group") {
+    const m = multiplyMatrices(nodeMatrix(node), parent);
+    return unionBounds(node.children.map((c) => vectorNodeBounds(c, m)));
+  }
+  const b = _chunkM4XE4UMTcjs.bezierPathBounds.call(void 0, vectorPathWorldBezier(node, parent));
   if (!b) return null;
   return { x: b.minX, y: b.minY, width: b.maxX - b.minX, height: b.maxY - b.minY };
 }
@@ -216,10 +227,13 @@ function boundsIntersect(a, b) {
 function boundsFromPoints(a, b) {
   return { x: Math.min(a.x, b.x), y: Math.min(a.y, b.y), width: Math.abs(b.x - a.x), height: Math.abs(b.y - a.y) };
 }
-function hitTestVectorNode(node, p, tolerance = 0) {
+function hitTestVectorNode(node, p, tolerance = 0, parent = IDENTITY_MATRIX) {
   if (node.visible === false) return false;
-  if (node.type === "group") return node.children.some((c) => hitTestVectorNode(c, p, tolerance));
-  const path = subpathsToBezier(node.subpaths);
+  if (node.type === "group") {
+    const m = multiplyMatrices(nodeMatrix(node), parent);
+    return node.children.some((c) => hitTestVectorNode(c, p, tolerance, m));
+  }
+  const path = vectorPathWorldBezier(node, parent);
   if (path.length === 0) return false;
   const point = [p.x, p.y];
   if (hasPaint(node.fill) && _chunkM4XE4UMTcjs.pointInBezierPath.call(void 0, path, point, _nullishCoalesce(node.fillRule, () => ( "nonzero")))) return true;
@@ -268,7 +282,38 @@ function rotateMatrix(degrees, origin = { x: 0, y: 0 }) {
 function applyMatrix(m, p) {
   return { x: m[0] * p.x + m[2] * p.y + m[4], y: m[1] * p.x + m[3] * p.y + m[5] };
 }
-function transformVectorNode(node, m) {
+function isIdentityMatrix(m, eps = 1e-12) {
+  return Math.abs(m[0] - 1) < eps && Math.abs(m[1]) < eps && Math.abs(m[2]) < eps && Math.abs(m[3] - 1) < eps && Math.abs(m[4]) < eps && Math.abs(m[5]) < eps;
+}
+function invertMatrix(m) {
+  const [a, b, c, d, e, f] = m;
+  const det = a * d - b * c;
+  if (!det || !Number.isFinite(det)) return IDENTITY_MATRIX;
+  return [d / det, -b / det, -c / det, a / det, (c * f - d * e) / det, (b * e - a * f) / det];
+}
+function applyMatrixLinear(m, v) {
+  return { x: m[0] * v.x + m[2] * v.y, y: m[1] * v.x + m[3] * v.y };
+}
+function matrixRotation(m) {
+  const [a, b, c, d] = m;
+  const mirrored = a * d - b * c < 0;
+  const deg = (mirrored ? Math.atan2(-b - c, d - a) : Math.atan2(b - c, a + d)) * 180 / Math.PI;
+  return Math.abs(deg) < 1e-9 ? 0 : deg;
+}
+function decomposeRigid(m) {
+  const [a, b, c, d, e, f] = m;
+  const deg = matrixRotation(m);
+  if (deg === 0) return { rigid: IDENTITY_MATRIX, residual: m };
+  const r = deg * Math.PI / 180;
+  const cos = Math.cos(r);
+  const sin = Math.sin(r);
+  return {
+    rigid: [cos, sin, -sin, cos, e, f],
+    residual: [cos * a + sin * b, -sin * a + cos * b, cos * c + sin * d, -sin * c + cos * d, 0, 0]
+  };
+}
+function bakeIntoGeometry(node, m) {
+  if (isIdentityMatrix(m)) return node;
   if (node.type === "group") return { ...node, children: node.children.map((c) => transformVectorNode(c, m)) };
   const path = node;
   return {
@@ -286,6 +331,36 @@ function transformVectorNode(node, m) {
     }))
   };
 }
+function transformVectorNode(node, m) {
+  const total = multiplyMatrices(nodeMatrix(node), m);
+  const { rigid, residual } = decomposeRigid(total);
+  const { transform: _old, ...rest } = node;
+  const baked = bakeIntoGeometry(rest, residual);
+  return isIdentityMatrix(rigid) ? baked : { ...baked, transform: rigid };
+}
+function vectorNodeRotation(node, parent = IDENTITY_MATRIX) {
+  return matrixRotation(multiplyMatrices(nodeMatrix(node), parent));
+}
+function vectorWorldMatrix(nodes, id) {
+  const search = (list, parent) => {
+    for (const n of list) {
+      const m = multiplyMatrices(nodeMatrix(n), parent);
+      if (n.id === id) return m;
+      if (n.type === "group") {
+        const found = search(n.children, m);
+        if (found) return found;
+      }
+    }
+    return null;
+  };
+  return search(nodes, IDENTITY_MATRIX);
+}
+function vectorParentMatrix(nodes, id) {
+  const node = findVectorNode(nodes, id);
+  const world = vectorWorldMatrix(nodes, id);
+  if (!node || !world) return null;
+  return multiplyMatrices(invertMatrix(nodeMatrix(node)), world);
+}
 function translateAnchor(a, dx, dy) {
   const next = cloneAnchor(a);
   next.x += dx;
@@ -478,6 +553,7 @@ function vectorDocumentToSvg(doc, options = {}) {
   const indent = (depth) => pretty ? "  ".repeat(depth) : "";
   const common = (node) => {
     let out2 = ` id="${escapeAttr(node.id)}"`;
+    if (node.transform) out2 += ` transform="matrix(${node.transform.map((n) => _chunkM4XE4UMTcjs.formatNumber.call(void 0, n, 6)).join(" ")})"`;
     if (node.opacity !== void 0 && node.opacity < 1) out2 += ` opacity="${num(node.opacity)}"`;
     if (node.visible === false) out2 += ` display="none"`;
     return out2;
@@ -855,6 +931,24 @@ function getAnchor(doc, ref) {
   const node = findVectorNode(doc.nodes, ref.nodeId);
   return _optionalChain([node, 'optionalAccess', _14 => _14.type]) === "path" ? _optionalChain([node, 'access', _15 => _15.subpaths, 'access', _16 => _16[ref.subpath], 'optionalAccess', _17 => _17.anchors, 'access', _18 => _18[ref.index]]) : void 0;
 }
+function getAnchorWorld(doc, ref) {
+  const a = getAnchor(doc, ref);
+  if (!a) return void 0;
+  const m = _nullishCoalesce(vectorWorldMatrix(doc.nodes, ref.nodeId), () => ( IDENTITY_MATRIX));
+  const p = applyMatrix(m, a);
+  return { x: p.x, y: p.y, ...a.in ? { in: applyMatrix(m, a.in) } : {}, ...a.out ? { out: applyMatrix(m, a.out) } : {}, ...a.type ? { type: a.type } : {} };
+}
+function getVectorSelectionFrame(doc, ids) {
+  const nodes = ids.map((id) => ({ node: findVectorNode(doc.nodes, id), parent: _nullishCoalesce(vectorParentMatrix(doc.nodes, id), () => ( IDENTITY_MATRIX)) })).filter((n) => n.node);
+  if (!nodes.length) return null;
+  const angles = nodes.map((n) => matrixRotation(multiplyMatrices(nodeMatrix(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 = rotateMatrix(-angle);
+  const b = unionBounds(nodes.map((n) => vectorNodeBounds(n.node, multiplyMatrices(n.parent, unrotate))));
+  return b ? { ...b, angle } : null;
+}
+var normalizeAngle = (a) => ((a + 180) % 360 + 360) % 360 - 180;
 function getTransformHandlePositions(box) {
   const { x, y, width: w, height: h } = box;
   return [
@@ -869,17 +963,28 @@ function getTransformHandlePositions(box) {
     { handle: "rotate", x: x + w / 2, y: y - VECTOR_ROTATE_HANDLE_OFFSET }
   ];
 }
-var RESIZE_CURSORS = {
-  nw: "nwse-resize",
-  se: "nwse-resize",
-  ne: "nesw-resize",
-  sw: "nesw-resize",
-  n: "ns-resize",
-  s: "ns-resize",
-  e: "ew-resize",
-  w: "ew-resize",
-  rotate: "grab"
-};
+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 = rotateMatrix(frame.angle, { x: viewport.x, y: viewport.y });
+  const toScreen2 = (p) => frame.angle ? applyMatrix(rot, p) : { x: p.x, y: p.y };
+  const handles = getTransformHandlePositions(box).map((h) => ({ ...h, screen: toScreen2(h) }));
+  const corners = [
+    { x: box.x, y: box.y },
+    { x: box.x + box.width, y: box.y },
+    { x: box.x + box.width, y: box.y + box.height },
+    { x: box.x, y: box.y + box.height }
+  ].map(toScreen2);
+  const r = (n) => Math.round(n * 1e3) / 1e3;
+  return { box, angle: frame.angle, transform: frame.angle ? `rotate(${r(frame.angle)} ${r(viewport.x)} ${r(viewport.y)})` : "", handles, corners };
+}
+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 };
+function vectorResizeCursor(handle, angle = 0) {
+  if (handle === "rotate") return "grab";
+  const a = ((HANDLE_ANGLES[handle] + angle) % 180 + 180) % 180;
+  return RESIZE_CURSOR_ORDER[Math.round(a / 45) % 4];
+}
 var TOOL_LABELS = {
   select: "Select",
   direct: "Direct Select",
@@ -938,6 +1043,7 @@ function mapTree(nodes, fn) {
   }
   return changed ? out : nodes;
 }
+var isRoot = (m) => m === 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 = (_class = class {
@@ -1018,6 +1124,7 @@ var VectorEditorController = (_class = class {
       selectedAnchors: this.anchors,
       editingId: this.editingId,
       selectionBounds: this.boundsOf(this.selection),
+      selectionFrame: this.frameOf(this.selectedRoots()),
       viewport: this.viewport,
       defaults: this.defaults,
       snap: this.snap,
@@ -1048,7 +1155,23 @@ var VectorEditorController = (_class = class {
     });
   }
   boundsOf(ids) {
-    return unionBounds(ids.map((id) => this.getNode(id)).map((n) => n ? vectorNodeBounds(n) : null));
+    return unionBounds(
+      ids.map((id) => {
+        const n = this.getNode(id);
+        return n ? vectorNodeBounds(n, _nullishCoalesce(vectorParentMatrix(this.doc.nodes, id), () => ( IDENTITY_MATRIX))) : null;
+      })
+    );
+  }
+  frameOf(ids) {
+    return getVectorSelectionFrame(this.doc, ids);
+  }
+  /** Local → document matrix of a node in `doc` (default: the current document). */
+  worldOf(id, doc = this.doc) {
+    return _nullishCoalesce(vectorWorldMatrix(doc.nodes, id), () => ( IDENTITY_MATRIX));
+  }
+  /** A document point in node `id`'s own space. */
+  toLocal(id, p, doc = this.doc) {
+    return applyMatrix(invertMatrix(this.worldOf(id, doc)), p);
   }
   cursorFor() {
     if (_optionalChain([this, 'access', _21 => _21.drag, 'optionalAccess', _22 => _22.kind]) === "pan" || this.spaceHeld) return this.drag ? "grabbing" : "grab";
@@ -1057,14 +1180,14 @@ var VectorEditorController = (_class = class {
     const h = this.hover;
     switch (this.tool) {
       case "select":
-        if (_optionalChain([h, 'optionalAccess', _27 => _27.transformHandle])) return RESIZE_CURSORS[h.transformHandle];
-        return _optionalChain([h, 'optionalAccess', _28 => _28.nodeId]) ? "move" : "default";
+        if (_optionalChain([h, 'optionalAccess', _27 => _27.transformHandle])) return vectorResizeCursor(h.transformHandle, _nullishCoalesce(_optionalChain([this, 'access', _28 => _28.frameOf, 'call', _29 => _29(this.selectedRoots()), 'optionalAccess', _30 => _30.angle]), () => ( 0)));
+        return _optionalChain([h, 'optionalAccess', _31 => _31.nodeId]) ? "move" : "default";
       case "direct":
-        if (_optionalChain([h, 'optionalAccess', _29 => _29.anchor]) || _optionalChain([h, 'optionalAccess', _30 => _30.handle])) return "pointer";
-        if (_optionalChain([h, 'optionalAccess', _31 => _31.segment])) return "copy";
-        return _optionalChain([h, 'optionalAccess', _32 => _32.nodeId]) ? "move" : "default";
+        if (_optionalChain([h, 'optionalAccess', _32 => _32.anchor]) || _optionalChain([h, 'optionalAccess', _33 => _33.handle])) return "pointer";
+        if (_optionalChain([h, 'optionalAccess', _34 => _34.segment])) return "copy";
+        return _optionalChain([h, 'optionalAccess', _35 => _35.nodeId]) ? "move" : "default";
       case "pen":
-        return _optionalChain([h, 'optionalAccess', _33 => _33.anchor]) ? "pointer" : "crosshair";
+        return _optionalChain([h, 'optionalAccess', _36 => _36.anchor]) ? "pointer" : "crosshair";
       default:
         return "crosshair";
     }
@@ -1084,7 +1207,7 @@ var VectorEditorController = (_class = class {
       this.selection = s.selection.filter((id) => this.getNode(id));
       this.anchors = s.anchors.filter((r) => getAnchor(this.doc, r));
       this.editingId = s.editingId && this.getNode(s.editingId) ? s.editingId : null;
-      this.pen = s.pen && _optionalChain([this, 'access', _34 => _34.getNode, 'call', _35 => _35(s.pen.nodeId), 'optionalAccess', _36 => _36.subpaths, 'optionalAccess', _37 => _37[s.pen.subpath]]) ? s.pen : null;
+      this.pen = s.pen && _optionalChain([this, 'access', _37 => _37.getNode, 'call', _38 => _38(s.pen.nodeId), 'optionalAccess', _39 => _39.subpaths, 'optionalAccess', _40 => _40[s.pen.subpath]]) ? s.pen : null;
     } finally {
       this.applying = false;
     }
@@ -1443,10 +1566,10 @@ var VectorEditorController = (_class = class {
     return this.selection.filter((id) => {
       let covered = false;
       const loc = locateVectorNode(this.doc.nodes, id);
-      let parent = _nullishCoalesce(_optionalChain([loc, 'optionalAccess', _38 => _38.parent]), () => ( null));
+      let parent = _nullishCoalesce(_optionalChain([loc, 'optionalAccess', _41 => _41.parent]), () => ( null));
       while (parent) {
         if (this.selection.includes(parent.id)) covered = true;
-        parent = _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _39 => _39(this.doc.nodes, parent.id), 'optionalAccess', _40 => _40.parent]), () => ( null));
+        parent = _nullishCoalesce(_optionalChain([locateVectorNode, 'call', _42 => _42(this.doc.nodes, parent.id), 'optionalAccess', _43 => _43.parent]), () => ( null));
       }
       return !covered;
     });
@@ -1454,6 +1577,11 @@ var VectorEditorController = (_class = class {
   // -------------------------------------------------------------------------
   // Transforms
   // -------------------------------------------------------------------------
+  /** `m`, given in a frame rotated by `angle`, as a document-space matrix. */
+  inFrame(angle, m) {
+    if (!angle) return m;
+    return multiplyMatrices(multiplyMatrices(rotateMatrix(-angle), m), rotateMatrix(angle));
+  }
   /** Applies a matrix to the selected (or given) nodes as one undo step. */
   transform(matrix, options = {}) {
     const ids = new Set(_nullishCoalesce(options.ids, () => ( this.selectedRoots())));
@@ -1463,8 +1591,25 @@ var VectorEditorController = (_class = class {
     });
     return { ok: true };
   }
+  /** `doc` with nodes `ids` moved by `m`, given in document space. */
   transformed(doc, ids, m) {
-    const nodes = mapTree(doc.nodes, (n) => ids.has(n.id) && !n.locked ? transformVectorNode(n, m) : n);
+    const visit = (list, parent) => {
+      let changed = false;
+      const out = list.map((n) => {
+        let next = n;
+        if (ids.has(n.id) && !n.locked) {
+          const local = isRoot(parent) ? m : multiplyMatrices(multiplyMatrices(parent, m), invertMatrix(parent));
+          next = transformVectorNode(n, local);
+        } else if (n.type === "group") {
+          const children = visit(n.children, multiplyMatrices(nodeMatrix(n), parent));
+          if (children !== n.children) next = { ...n, children };
+        }
+        if (next !== n) changed = true;
+        return next;
+      });
+      return changed ? out : list;
+    };
+    const nodes = visit(doc.nodes, IDENTITY_MATRIX);
     return nodes === doc.nodes ? doc : { ...doc, nodes };
   }
   translate(dx, dy, options = {}) {
@@ -1476,26 +1621,48 @@ var VectorEditorController = (_class = class {
     }
     return this.transform(translateMatrix(dx, dy), { ids: options.ids, label: "Move" });
   }
-  /** Scales around `origin` (default: the selection centre). */
+  /** The selection frame's centre in document space. */
+  frameCenter(frame) {
+    return applyMatrix(rotateMatrix(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
+   * share a rotation) around `origin` (default: the box centre, in document space).
+   */
   scale(sx, sy = sx, options = {}) {
-    const b = this.boundsOf(_nullishCoalesce(options.ids, () => ( this.selectedRoots())));
-    if (!b) return { ok: false, message: "Nothing is selected." };
-    const origin = _nullishCoalesce(options.origin, () => ( { x: b.x + b.width / 2, y: b.y + b.height / 2 }));
-    return this.transform(scaleMatrix(sx, sy, origin), { ids: options.ids, label: "Scale" });
+    const frame = this.frameOf(_nullishCoalesce(options.ids, () => ( this.selectedRoots())));
+    if (!frame) return { ok: false, message: "Nothing is selected." };
+    const origin = applyMatrix(rotateMatrix(-frame.angle), _nullishCoalesce(options.origin, () => ( this.frameCenter(frame))));
+    return this.transform(this.inFrame(frame.angle, scaleMatrix(sx, sy, origin)), { ids: options.ids, label: "Scale" });
   }
   /** Rotates clockwise by `degrees` around `origin` (default: the selection centre). */
   rotate(degrees, options = {}) {
-    const b = this.boundsOf(_nullishCoalesce(options.ids, () => ( this.selectedRoots())));
-    if (!b) return { ok: false, message: "Nothing is selected." };
-    const origin = _nullishCoalesce(options.origin, () => ( { x: b.x + b.width / 2, y: b.y + b.height / 2 }));
+    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(rotateMatrix(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 = {}) {
+    const ids = _nullishCoalesce(options.ids, () => ( this.selectedRoots()));
+    if (!ids.length) return { ok: false, message: "Nothing is selected." };
+    this.change("Set Rotation", () => {
+      for (const id of ids) {
+        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]), rotateMatrix(delta, this.frameCenter(frame)));
+      }
+    });
+    return { ok: true };
+  }
+  /** Mirrors along the selection box's own axes. */
   flip(axis, options = {}) {
-    const b = this.boundsOf(_nullishCoalesce(options.ids, () => ( this.selectedRoots())));
-    if (!b) return { ok: false, message: "Nothing is selected." };
-    const c = { x: b.x + b.width / 2, y: b.y + b.height / 2 };
+    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" ? scaleMatrix(-1, 1, c) : scaleMatrix(1, -1, c);
-    return this.transform(m, { ids: options.ids, label: axis === "horizontal" ? "Flip Horizontal" : "Flip Vertical" });
+    return this.transform(this.inFrame(frame.angle, m), { ids: options.ids, label: axis === "horizontal" ? "Flip Horizontal" : "Flip Vertical" });
   }
   /**
    * Aligns the selected nodes to their combined bounds, or to the artboard when one node is
@@ -1585,8 +1752,8 @@ var VectorEditorController = (_class = class {
     if (!ids.length) return null;
     const locs = ids.map((id2) => locateVectorNode(this.doc.nodes, id2));
     if (locs.some((l) => !l)) return null;
-    const parent = _nullishCoalesce(_optionalChain([locs, 'access', _41 => _41[0], 'access', _42 => _42.parent, 'optionalAccess', _43 => _43.id]), () => ( null));
-    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _44 => _44.parent, 'optionalAccess', _45 => _45.id]), () => ( null))) !== parent)) return null;
+    const parent = _nullishCoalesce(_optionalChain([locs, 'access', _44 => _44[0], 'access', _45 => _45.parent, 'optionalAccess', _46 => _46.id]), () => ( null));
+    if (locs.some((l) => (_nullishCoalesce(_optionalChain([l, 'access', _47 => _47.parent, 'optionalAccess', _48 => _48.id]), () => ( null))) !== parent)) return null;
     const id = this.newId();
     this.change("Group", () => {
       const set = new Set(ids);
@@ -1609,7 +1776,7 @@ var VectorEditorController = (_class = class {
   }
   /** Replaces selected groups with their children. */
   ungroup(options = {}) {
-    const groups = (_nullishCoalesce(options.ids, () => ( this.selection))).map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _46 => _46.type]) === "group");
+    const groups = (_nullishCoalesce(options.ids, () => ( this.selection))).map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _49 => _49.type]) === "group");
     if (!groups.length) return { ok: false, message: "Select a group to ungroup." };
     const set = new Set(groups.map((g) => g.id));
     this.change("Ungroup", () => {
@@ -1620,7 +1787,10 @@ var VectorEditorController = (_class = class {
           if (set.has(n.id) && n.type === "group") {
             changed = true;
             const opacity = n.opacity;
-            out.push(...n.children.map((c) => opacity !== void 0 && opacity < 1 ? { ...c, opacity: (_nullishCoalesce(c.opacity, () => ( 1))) * opacity } : c));
+            const m = nodeMatrix(n);
+            out.push(
+              ...n.children.map((c) => n.transform ? transformVectorNode(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);
             if (children !== n.children) changed = true;
@@ -1668,15 +1838,22 @@ var VectorEditorController = (_class = class {
     if (paths.length < 2) return null;
     const result = _chunkM4XE4UMTcjs.pathBoolean.call(void 0, 
       BOOLEAN_OPS[op],
-      paths.map((p) => ({ path: subpathsToBezier(p.subpaths.filter((s) => s.anchors.length > 1).map((s) => ({ ...s, closed: true }))), fillRule: _nullishCoalesce(p.fillRule, () => ( "nonzero")) }))
+      paths.map((p) => ({
+        path: vectorPathWorldBezier(
+          { ...p, subpaths: p.subpaths.filter((s) => s.anchors.length > 1).map((s) => ({ ...s, closed: true })) },
+          _nullishCoalesce(vectorParentMatrix(this.doc.nodes, p.id), () => ( IDENTITY_MATRIX))
+        ),
+        fillRule: _nullishCoalesce(p.fillRule, () => ( "nonzero"))
+      }))
     );
-    const subpaths = bezierToSubpaths(result.path);
-    if (result.error || !subpaths.length) return null;
     const base = paths[0];
+    const anchorRoot = _nullishCoalesce(roots.find((r) => findVectorNode([this.getNode(r)], base.id)), () => ( base.id));
+    const subpaths = bezierToSubpaths(this.intoParentSpace(anchorRoot, result.path));
+    if (result.error || !subpaths.length) return null;
     const id = this.newId();
-    const node = { ...cloneVectorNode(base), id, name: BOOLEAN_LABELS[op], subpaths };
+    const { transform: _t, ...baseRest } = cloneVectorNode(base);
+    const node = { ...baseRest, id, name: BOOLEAN_LABELS[op], subpaths };
     const drop = /* @__PURE__ */ new Set([...paths.map((p) => p.id), ...roots]);
-    const anchorRoot = _nullishCoalesce(roots.find((r) => findVectorNode([this.getNode(r)], base.id)), () => ( base.id));
     this.change(BOOLEAN_LABELS[op], () => {
       this.setDoc(mapTree(this.doc.nodes, (n) => n.id === anchorRoot ? node : drop.has(n.id) ? null : n));
       this.selection = [id];
@@ -1694,9 +1871,11 @@ var VectorEditorController = (_class = class {
     });
     if (paths.length < 2) return null;
     const id = this.newId();
-    const node = { ...cloneVectorNode(paths[0]), id, name: "Compound Path", subpaths: paths.flatMap((p) => cloneVectorNode(p).subpaths) };
-    const drop = /* @__PURE__ */ new Set([...paths.map((p) => p.id), ...roots]);
     const first = _nullishCoalesce(roots.find((r) => findVectorNode([this.getNode(r)], paths[0].id)), () => ( paths[0].id));
+    const subpaths = paths.flatMap((p) => bezierToSubpaths(this.intoParentSpace(first, vectorPathWorldBezier(p, _nullishCoalesce(vectorParentMatrix(this.doc.nodes, p.id), () => ( IDENTITY_MATRIX))))));
+    const { transform: _t, ...baseRest } = cloneVectorNode(paths[0]);
+    const node = { ...baseRest, id, name: "Compound Path", subpaths };
+    const drop = /* @__PURE__ */ new Set([...paths.map((p) => p.id), ...roots]);
     this.change("Combine", () => {
       this.setDoc(mapTree(this.doc.nodes, (n) => n.id === first ? node : drop.has(n.id) ? null : n));
       this.selection = [id];
@@ -1704,9 +1883,14 @@ var VectorEditorController = (_class = class {
     });
     return id;
   }
+  /** A document-space path mapped into the parent space of node `id`. */
+  intoParentSpace(id, path) {
+    const parent = _nullishCoalesce(vectorParentMatrix(this.doc.nodes, id), () => ( IDENTITY_MATRIX));
+    return isRoot(parent) ? path : _chunkM4XE4UMTcjs.transformBezierPath.call(void 0, path, invertMatrix(parent));
+  }
   /** Splits selected compound paths into one path per subpath. */
   breakApart(options = {}) {
-    const paths = (_nullishCoalesce(options.ids, () => ( this.selection))).map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _47 => _47.type]) === "path" && n.subpaths.length > 1);
+    const paths = (_nullishCoalesce(options.ids, () => ( this.selection))).map((id) => this.getNode(id)).filter((n) => _optionalChain([n, 'optionalAccess', _50 => _50.type]) === "path" && n.subpaths.length > 1);
     if (!paths.length) return { ok: false, message: "Select a compound path to break apart." };
     const created = [];
     const set = new Set(paths.map((p) => p.id));
@@ -1743,23 +1927,30 @@ var VectorEditorController = (_class = class {
     });
     return nodes === doc.nodes ? doc : { ...doc, nodes };
   }
+  /** Moves anchors by a document-space offset (converted into each node's own space). */
   movedAnchors(doc, refs, dx, dy) {
-    return this.updateAnchors(doc, refs, (a) => translateAnchor(a, dx, dy));
+    const local = /* @__PURE__ */ new Map();
+    for (const r of refs) if (!local.has(r.nodeId)) local.set(r.nodeId, applyMatrixLinear(invertMatrix(this.worldOf(r.nodeId, doc)), { x: dx, y: dy }));
+    return this.updateAnchors(doc, refs, (a, ref) => {
+      const d = local.get(ref.nodeId);
+      return translateAnchor(a, d.x, d.y);
+    });
   }
-  /** Moves one anchor to a position (handles follow). */
+  /** Moves one anchor to a document position (handles follow). */
   moveAnchor(ref, to) {
-    const a = getAnchor(this.doc, ref);
+    const a = getAnchorWorld(this.doc, ref);
     if (!a) return { ok: false, message: "There is no such anchor." };
     this.change("Move Point", () => {
       this.doc = this.movedAnchors(this.doc, [ref], to.x - a.x, to.y - a.y);
     });
     return { ok: true };
   }
-  /** Moves one handle (see `moveAnchorHandle` for how the opposite handle follows). */
+  /** Moves one handle to a document position (see `moveAnchorHandle` for how the opposite handle follows). */
   moveHandle(ref, to, options = {}) {
     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) => moveAnchorHandle(a, ref.handle, to, options.breakHandles));
+      this.doc = this.updateAnchors(this.doc, [ref], (a) => moveAnchorHandle(a, ref.handle, local, options.breakHandles));
     });
     return { ok: true };
   }
@@ -1778,11 +1969,11 @@ var VectorEditorController = (_class = class {
     });
     return { ok: true };
   }
-  /** Adds an anchor on the nearest segment of `nodeId` to `point` (shape unchanged). */
+  /** Adds an anchor on the nearest segment of `nodeId` to document point `point` (shape unchanged). */
   insertAnchorAt(nodeId, point) {
     const node = this.getNode(nodeId);
-    if (_optionalChain([node, 'optionalAccess', _48 => _48.type]) !== "path") return null;
-    const hit = nearestSegment(node, point);
+    if (_optionalChain([node, 'optionalAccess', _51 => _51.type]) !== "path") return null;
+    const hit = nearestSegment(node, this.toLocal(nodeId, point));
     if (!hit) return null;
     const { subpath, index } = insertAnchor(node.subpaths[hit.subpath], hit.segment, hit.t);
     const ref = { nodeId, subpath: hit.subpath, index };
@@ -1816,7 +2007,7 @@ var VectorEditorController = (_class = class {
   setClosed(closed, nodeId) {
     const targets = nodeId ? (() => {
       const n = this.getNode(nodeId);
-      return _optionalChain([n, 'optionalAccess', _49 => _49.type]) === "path" ? n.subpaths.map((_, s) => ({ nodeId, subpath: s })) : [];
+      return _optionalChain([n, 'optionalAccess', _52 => _52.type]) === "path" ? n.subpaths.map((_, s) => ({ nodeId, subpath: s })) : [];
     })() : this.anchors.map((r) => ({ nodeId: r.nodeId, subpath: r.subpath }));
     if (!targets.length) return { ok: false, message: "Select a path or points." };
     this.change(closed ? "Close Path" : "Open Path", () => {
@@ -1843,7 +2034,7 @@ var VectorEditorController = (_class = class {
   finishPath() {
     if (!this.pen) return;
     const node = this.getNode(this.pen.nodeId);
-    const sp = _optionalChain([node, 'optionalAccess', _50 => _50.subpaths, 'access', _51 => _51[this.pen.subpath]]);
+    const sp = _optionalChain([node, 'optionalAccess', _53 => _53.subpaths, 'access', _54 => _54[this.pen.subpath]]);
     const pen = this.pen;
     this.pen = null;
     this.pointer = null;
@@ -1887,7 +2078,7 @@ var VectorEditorController = (_class = class {
       if (trimmed.startsWith("{")) {
         try {
           const data = JSON.parse(trimmed);
-          if (_optionalChain([data, 'optionalAccess', _52 => _52.type]) === VECTOR_CLIPBOARD_TYPE && Array.isArray(data.nodes)) nodes = data.nodes;
+          if (_optionalChain([data, 'optionalAccess', _55 => _55.type]) === VECTOR_CLIPBOARD_TYPE && Array.isArray(data.nodes)) nodes = data.nodes;
         } catch (e2) {
           nodes = null;
         }
@@ -1899,7 +2090,7 @@ var VectorEditorController = (_class = class {
         }
       }
     } else nodes = this.clipboard;
-    if (!_optionalChain([nodes, 'optionalAccess', _53 => _53.length])) return [];
+    if (!_optionalChain([nodes, 'optionalAccess', _56 => _56.length])) return [];
     const offset = _nullishCoalesce(options.offset, () => ( (text && !text.trim().startsWith("{") ? { x: 0, y: 0 } : { x: 10, y: 10 })));
     const copies = nodes.map((n) => transformVectorNode(this.freshIds(n), translateMatrix(offset.x, offset.y)));
     this.change("Paste", () => {
@@ -1939,20 +2130,18 @@ var VectorEditorController = (_class = class {
   }
   hitTransformHandle(screen) {
     if (this.tool !== "select" || !this.selection.length) return null;
-    const b = this.boundsOf(this.selectedRoots());
-    if (!b) return null;
-    const tl = this.documentToScreen(b);
-    const box = { x: tl.x, y: tl.y, width: b.width * this.viewport.zoom, height: b.height * this.viewport.zoom };
+    const frame = this.frameOf(this.selectedRoots());
+    if (!frame) return null;
+    const { box, handles } = getVectorSelectionBoxGeometry(frame, this.viewport);
     const r = this.hitRadius + 2;
-    const handles = getTransformHandlePositions(box);
     const usable = box.width < 2 * r || box.height < 2 * r ? handles.filter((h) => h.handle.length === 2 || h.handle === "rotate") : handles;
-    for (const h of usable) if (Math.abs(h.x - screen.x) <= r && Math.abs(h.y - screen.y) <= r) return h.handle;
+    for (const h of usable) if (Math.hypot(h.screen.x - screen.x, h.screen.y - screen.y) <= r * Math.SQRT2) return h.handle;
     return null;
   }
   hitHandle(screen) {
     for (const ref of getVisibleHandles(this.view()).reverse()) {
-      const a = getAnchor(this.doc, ref);
-      const h = _optionalChain([a, 'optionalAccess', _54 => _54[ref.handle]]);
+      const a = getAnchorWorld(this.doc, ref);
+      const h = _optionalChain([a, 'optionalAccess', _57 => _57[ref.handle]]);
       if (!h) continue;
       const s = this.documentToScreen(h);
       if (Math.hypot(s.x - screen.x, s.y - screen.y) <= this.hitRadius) return ref;
@@ -1963,7 +2152,7 @@ var VectorEditorController = (_class = class {
     let best = null;
     let bestD = Infinity;
     for (const ref of refs) {
-      const a = getAnchor(this.doc, ref);
+      const a = getAnchorWorld(this.doc, ref);
       if (!a) continue;
       const s = this.documentToScreen(a);
       const d = Math.hypot(s.x - screen.x, s.y - screen.y);
@@ -1977,18 +2166,18 @@ var VectorEditorController = (_class = class {
   /** Deepest unlocked visible path under `p`. */
   hitPath(p) {
     const tol = this.tolerance();
-    const search = (list) => {
+    const search = (list, parent) => {
       for (let i = list.length - 1; i >= 0; i--) {
         const n = list[i];
         if (n.visible === false || n.locked) continue;
         if (n.type === "group") {
-          const found = search(n.children);
+          const found = search(n.children, multiplyMatrices(nodeMatrix(n), parent));
           if (found) return found;
-        } else if (hitTestVectorNode(n, p, tol)) return n;
+        } else if (hitTestVectorNode(n, p, tol, parent)) return n;
       }
       return null;
     };
-    return search(this.doc.nodes);
+    return search(this.doc.nodes, IDENTITY_MATRIX);
   }
   /** Endpoints of open subpaths of unlocked visible paths (pen tool resumes from them). */
   openEndpoints() {
@@ -2019,8 +2208,11 @@ var VectorEditorController = (_class = class {
         if (anchor) return { nodeId: anchor.nodeId, anchor };
         for (const id of getEditablePathIds(this.view())) {
           const node = this.getNode(id);
-          const seg = nearestSegment(node, p);
-          if (seg && seg.distance <= this.tolerance()) return { nodeId: id, segment: { nodeId: id, subpath: seg.subpath, segment: seg.segment, t: seg.t, point: seg.point } };
+          const seg = nearestSegment(node, this.toLocal(id, p));
+          if (seg && seg.distance <= this.tolerance()) {
+            const point = applyMatrix(this.worldOf(id), seg.point);
+            return { nodeId: id, segment: { nodeId: id, subpath: seg.subpath, segment: seg.segment, t: seg.t, point } };
+          }
         }
         const path = this.hitPath(p);
         return path ? { nodeId: path.id } : null;
@@ -2065,9 +2257,10 @@ var VectorEditorController = (_class = class {
   downSelect(screen, p, input) {
     const handle = this.hitTransformHandle(screen);
     if (handle) {
-      const bounds = this.boundsOf(this.selectedRoots());
+      const frame = this.frameOf(this.selectedRoots());
       const before = this.snapshot();
-      this.drag = handle === "rotate" ? { kind: "rotate", start: p, center: { x: bounds.x + bounds.width / 2, y: bounds.y + bounds.height / 2 }, before, base: this.doc } : { kind: "scale", handle, start: p, bounds, before, base: this.doc };
+      const center = applyMatrix(rotateMatrix(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;
@@ -2133,7 +2326,7 @@ var VectorEditorController = (_class = class {
     }
     for (const id of getEditablePathIds(this.view())) {
       const node = this.getNode(id);
-      const seg = nearestSegment(node, p);
+      const seg = nearestSegment(node, this.toLocal(id, p));
       if (!seg || seg.distance > this.tolerance()) continue;
       const sp = node.subpaths[seg.subpath];
       if (input.alt) {
@@ -2174,7 +2367,7 @@ var VectorEditorController = (_class = class {
   }
   downPen(screen, p, input) {
     const before = this.snapshot();
-    const sp = this.pen ? _optionalChain([this, 'access', _55 => _55.getNode, 'call', _56 => _56(this.pen.nodeId), 'optionalAccess', _57 => _57.subpaths, 'access', _58 => _58[this.pen.subpath]]) : void 0;
+    const sp = this.pen ? _optionalChain([this, 'access', _58 => _58.getNode, 'call', _59 => _59(this.pen.nodeId), 'optionalAccess', _60 => _60.subpaths, 'access', _61 => _61[this.pen.subpath]]) : void 0;
     if (this.pen && sp) {
       const pen = this.pen;
       const first = { nodeId: pen.nodeId, subpath: pen.subpath, index: 0 };
@@ -2187,8 +2380,9 @@ var VectorEditorController = (_class = class {
         return;
       }
       let pt2 = this.snapPoint(p);
-      const last = sp.anchors[sp.anchors.length - 1];
+      const last = getAnchorWorld(this.doc, { nodeId: pen.nodeId, subpath: pen.subpath, index: sp.anchors.length - 1 });
       if (input.shift) pt2 = constrain45(last, pt2);
+      pt2 = this.toLocal(pen.nodeId, pt2);
       const node2 = this.getNode(pen.nodeId);
       const anchors = [...sp.anchors, { x: pt2.x, y: pt2.y }];
       this.replaceNode(pen.nodeId, { ...node2, subpaths: node2.subpaths.map((s, i) => i === pen.subpath ? { ...s, anchors } : s) });
@@ -2294,9 +2488,11 @@ var VectorEditorController = (_class = class {
         return;
       }
       case "scale": {
-        const { sx, sy, origin } = scaleFor(drag.handle, drag.bounds, p, input);
+        const angle = drag.frame.angle;
+        const q = angle ? applyMatrix(rotateMatrix(-angle), p) : p;
+        const { sx, sy, origin } = scaleFor(drag.handle, drag.frame, q, input);
         const ids = new Set(this.selectedRoots());
-        this.doc = this.transformed(drag.base, ids, scaleMatrix(sx, sy, origin));
+        this.doc = this.transformed(drag.base, ids, this.inFrame(angle, scaleMatrix(sx, sy, origin)));
         this.interaction = { type: "scale", handle: drag.handle, sx, sy };
         this.notify(true);
         return;
@@ -2316,7 +2512,7 @@ var VectorEditorController = (_class = class {
         this.interaction = { type: "marquee", bounds };
         if (drag.anchorsMode) {
           const inside = getVisibleAnchors(this.view()).filter((r) => {
-            const a = getAnchor(this.doc, r);
+            const a = getAnchorWorld(this.doc, r);
             return a.x >= bounds.x && a.x <= bounds.x + bounds.width && a.y >= bounds.y && a.y <= bounds.y + bounds.height;
           });
           this.anchors = [...drag.baseAnchors, ...inside.filter((r) => !drag.baseAnchors.some((b) => sameRef(b, r)))];
@@ -2336,7 +2532,7 @@ var VectorEditorController = (_class = class {
         if (!drag.moved && Math.hypot(dx, dy) * this.viewport.zoom < 2) return;
         drag.moved = true;
         if (input.shift) Math.abs(dx) > Math.abs(dy) ? dy = 0 : dx = 0;
-        const lead = this.anchors.length ? getAnchor(drag.base, this.anchors[0]) : void 0;
+        const lead = this.anchors.length ? getAnchorWorld(drag.base, this.anchors[0]) : void 0;
         ({ dx, dy } = this.snapDelta(dx, dy, _nullishCoalesce(lead, () => ( null))));
         this.doc = this.movedAnchors(drag.base, this.anchors, dx, dy);
         this.interaction = { type: "anchors", dx, dy };
@@ -2344,16 +2540,17 @@ var VectorEditorController = (_class = class {
         return;
       }
       case "handle": {
-        const anchor = getAnchor(drag.base, drag.ref);
+        const anchor = getAnchorWorld(drag.base, drag.ref);
         let pt = this.snapPoint(p);
         if (input.shift && anchor) pt = constrain45(anchor, pt);
-        this.doc = this.updateAnchors(drag.base, [drag.ref], (a) => moveAnchorHandle(a, drag.ref.handle, pt, input.alt));
+        const local = this.toLocal(drag.ref.nodeId, pt, drag.base);
+        this.doc = this.updateAnchors(drag.base, [drag.ref], (a) => moveAnchorHandle(a, drag.ref.handle, local, input.alt));
         this.interaction = { type: "handle", ref: drag.ref };
         this.notify(true);
         return;
       }
       case "pull": {
-        const anchor = getAnchor(drag.base, drag.ref);
+        const anchor = getAnchorWorld(drag.base, drag.ref);
         if (!anchor) return;
         if (Math.hypot(p.x - anchor.x, p.y - anchor.y) * this.viewport.zoom < 2) {
           this.doc = drag.base;
@@ -2363,7 +2560,7 @@ var VectorEditorController = (_class = class {
         let pt = p;
         if (input.shift) pt = constrain45(anchor, pt);
         const side = drag.closing ? "in" : "out";
-        const pos = drag.closing ? { x: 2 * anchor.x - pt.x, y: 2 * anchor.y - pt.y } : pt;
+        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 moveAnchorHandle(a, side, pos, true);
           return moveAnchorHandle({ ...a, type: "symmetric" }, side, pos);
@@ -2373,7 +2570,7 @@ var VectorEditorController = (_class = class {
       }
       case "shape": {
         const node = this.getNode(drag.nodeId);
-        if (_optionalChain([node, 'optionalAccess', _59 => _59.type]) !== "path") return;
+        if (_optionalChain([node, 'optionalAccess', _62 => _62.type]) !== "path") return;
         let end = this.snapPoint(p);
         let start = drag.start;
         let bounds;
@@ -2405,7 +2602,7 @@ var VectorEditorController = (_class = class {
         if (Math.hypot(p.x - last[0], p.y - last[1]) * this.viewport.zoom < 1.5) return;
         drag.points.push([p.x, p.y]);
         const node = this.getNode(drag.nodeId);
-        if (_optionalChain([node, 'optionalAccess', _60 => _60.type]) !== "path") return;
+        if (_optionalChain([node, 'optionalAccess', _63 => _63.type]) !== "path") return;
         this.replaceNode(drag.nodeId, { ...node, subpaths: [{ anchors: drag.points.map(([x, y]) => ({ x, y })), closed: false }] });
         const xs = drag.points.map((q) => q[0]);
         const ys = drag.points.map((q) => q[1]);
@@ -2472,7 +2669,7 @@ var VectorEditorController = (_class = class {
       }
       case "pencil": {
         const node = this.getNode(drag.nodeId);
-        if (_optionalChain([node, 'optionalAccess', _61 => _61.type]) !== "path" || drag.points.length < 2) {
+        if (_optionalChain([node, 'optionalAccess', _64 => _64.type]) !== "path" || drag.points.length < 2) {
           this.doc = drag.before.doc;
           this.notify(true);
           return;
@@ -2537,10 +2734,10 @@ var VectorEditorController = (_class = class {
         this.convertAnchors(a.in || a.out ? "corner" : "smooth", [anchor]);
         return;
       }
-      const id = _nullishCoalesce(_optionalChain([this, 'access', _62 => _62.hover, 'optionalAccess', _63 => _63.segment, 'optionalAccess', _64 => _64.nodeId]), () => ( this.editingId));
+      const id = _nullishCoalesce(_optionalChain([this, 'access', _65 => _65.hover, 'optionalAccess', _66 => _66.segment, 'optionalAccess', _67 => _67.nodeId]), () => ( this.editingId));
       if (id) {
         const node = this.getNode(id);
-        const seg = node ? nearestSegment(node, p) : null;
+        const seg = node ? nearestSegment(node, this.toLocal(id, p)) : null;
         if (seg && seg.distance <= this.tolerance()) this.insertAnchorAt(id, p);
       }
       return;
@@ -2615,7 +2812,7 @@ var VectorEditorController = (_class = class {
           this.finishPath();
           return true;
         }
-        if (this.tool === "select" && this.selection.length === 1 && _optionalChain([this, 'access', _65 => _65.getNode, 'call', _66 => _66(this.selection[0]), 'optionalAccess', _67 => _67.type]) === "path") {
+        if (this.tool === "select" && this.selection.length === 1 && _optionalChain([this, 'access', _68 => _68.getNode, 'call', _69 => _69(this.selection[0]), 'optionalAccess', _70 => _70.type]) === "path") {
           this.tool = "direct";
           this.editingId = this.selection[0];
           this.notify();
@@ -2692,11 +2889,12 @@ function scaleFor(handle, b, p, mods = {}) {
 
 // src/vector/render.ts
 var fmt = (n) => Math.round(n * 100) / 100;
+var fmtMatrix = (m) => `matrix(${m.map((n) => Math.round(n * 1e6) / 1e6).join(" ")})`;
 function renderNode(node, defs, idPrefix) {
   if (node.visible === false) return null;
   if (node.type === "group") {
     const children = node.children.map((c) => renderNode(c, defs, idPrefix)).filter((c) => !!c);
-    return { kind: "group", id: node.id, opacity: _nullishCoalesce(node.opacity, () => ( 1)), children };
+    return { kind: "group", id: node.id, ...node.transform ? { transform: fmtMatrix(node.transform) } : {}, opacity: _nullishCoalesce(node.opacity, () => ( 1)), children };
   }
   const fill = vectorPaintToSvg(node.fill, `${idPrefix}fill-${node.id}`);
   const stroke = vectorPaintToSvg(node.stroke, `${idPrefix}stroke-${node.id}`);
@@ -2705,13 +2903,14 @@ function renderNode(node, defs, idPrefix) {
   return {
     kind: "path",
     id: node.id,
+    ...node.transform ? { transform: fmtMatrix(node.transform) } : {},
     d: vectorPathData(node),
     fill: fill.value,
     stroke: stroke.value,
     strokeWidth: _nullishCoalesce(node.strokeWidth, () => ( 1)),
     ...node.strokeLinecap ? { strokeLinecap: node.strokeLinecap } : {},
     ...node.strokeLinejoin ? { strokeLinejoin: node.strokeLinejoin } : {},
-    ..._optionalChain([node, 'access', _68 => _68.strokeDasharray, 'optionalAccess', _69 => _69.length]) ? { strokeDasharray: node.strokeDasharray.join(" ") } : {},
+    ..._optionalChain([node, 'access', _71 => _71.strokeDasharray, 'optionalAccess', _72 => _72.length]) ? { strokeDasharray: node.strokeDasharray.join(" ") } : {},
     fillRule: _nullishCoalesce(node.fillRule, () => ( "nonzero")),
     opacity: _nullishCoalesce(node.opacity, () => ( 1))
   };
@@ -2733,8 +2932,14 @@ function getVectorSceneRenderData(state, options = {}) {
 var toScreen = (state, p) => ({ x: p.x * state.viewport.zoom + state.viewport.x, y: p.y * state.viewport.zoom + state.viewport.y });
 function screenOutline(state, node) {
   const v = state.viewport;
-  const paths = node.type === "path" ? [node] : collect(node);
-  return paths.map((p) => _chunkM4XE4UMTcjs.bezierPathToSvg.call(void 0, _chunkM4XE4UMTcjs.transformBezierPath.call(void 0, subpathsToBezier(p.subpaths), [v.zoom, 0, 0, v.zoom, v.x, v.y]), { precision: 2 })).join(" ");
+  const view = [v.zoom, 0, 0, v.zoom, v.x, v.y];
+  const parent = _nullishCoalesce(vectorParentMatrix(state.document.nodes, node.id), () => ( IDENTITY_MATRIX));
+  return collectWithMatrix(node, parent).map(({ path, parent: m }) => _chunkM4XE4UMTcjs.bezierPathToSvg.call(void 0, _chunkM4XE4UMTcjs.transformBezierPath.call(void 0, vectorPathWorldBezier(path, m), view), { precision: 2 })).join(" ");
+}
+function collectWithMatrix(node, parent) {
+  if (node.type === "path") return [{ path: node, parent }];
+  const m = multiplyMatrices(nodeMatrix(node), parent);
+  return node.children.flatMap((c) => collectWithMatrix(c, m));
 }
 function collect(node) {
   if (node.type === "path") return [node];
@@ -2754,40 +2959,38 @@ function getVectorOverlayRenderData(state) {
   };
   for (const id of state.selection) outline(id, true);
   if (state.editingId) outline(state.editingId, true);
-  if (_optionalChain([state, 'access', _70 => _70.hover, 'optionalAccess', _71 => _71.nodeId]) && !state.interaction) outline(state.hover.nodeId, false);
+  if (_optionalChain([state, 'access', _73 => _73.hover, 'optionalAccess', _74 => _74.nodeId]) && !state.interaction) outline(state.hover.nodeId, false);
   let selectionBox = null;
-  if (state.tool === "select" && state.selectionBounds && _optionalChain([state, 'access', _72 => _72.interaction, 'optionalAccess', _73 => _73.type]) !== "marquee") {
-    const b = state.selectionBounds;
-    const tl = toScreen(state, b);
-    const box = { x: tl.x, y: tl.y, width: b.width * z, height: b.height * z };
-    selectionBox = { ...box, handles: getTransformHandlePositions(box) };
+  if (state.tool === "select" && state.selectionFrame && _optionalChain([state, 'access', _75 => _75.interaction, 'optionalAccess', _76 => _76.type]) !== "marquee") {
+    const g = getVectorSelectionBoxGeometry(state.selectionFrame, state.viewport);
+    selectionBox = { ...g.box, angle: g.angle, transform: g.transform, corners: g.corners, handles: g.handles };
   }
   const selected = (r) => state.selectedAnchors.some((a) => a.nodeId === r.nodeId && a.subpath === r.subpath && a.index === r.index);
   const sameAnchor = (a, b) => !!a && a.nodeId === b.nodeId && a.subpath === b.subpath && a.index === b.index;
   const anchors = getVisibleAnchors(state).map((ref) => {
-    const a = getAnchor(doc, ref);
+    const a = getAnchorWorld(doc, ref);
     const s = toScreen(state, a);
     const closes = !!state.pen && state.pen.nodeId === ref.nodeId && state.pen.subpath === ref.subpath && ref.index === 0;
-    return { ref, x: s.x, y: s.y, type: _nullishCoalesce(a.type, () => ( inferAnchorType(a))), selected: selected(ref), hovered: sameAnchor(_optionalChain([state, 'access', _74 => _74.hover, 'optionalAccess', _75 => _75.anchor]), ref), closes };
+    return { ref, x: s.x, y: s.y, type: _nullishCoalesce(a.type, () => ( inferAnchorType(a))), selected: selected(ref), hovered: sameAnchor(_optionalChain([state, 'access', _77 => _77.hover, 'optionalAccess', _78 => _78.anchor]), ref), closes };
   });
-  if (state.tool === "pen" && !state.pen && _optionalChain([state, 'access', _76 => _76.hover, 'optionalAccess', _77 => _77.anchor])) {
-    const a = getAnchor(doc, state.hover.anchor);
+  if (state.tool === "pen" && !state.pen && _optionalChain([state, 'access', _79 => _79.hover, 'optionalAccess', _80 => _80.anchor])) {
+    const a = getAnchorWorld(doc, state.hover.anchor);
     if (a) {
       const s = toScreen(state, a);
       anchors.push({ ref: state.hover.anchor, x: s.x, y: s.y, type: _nullishCoalesce(a.type, () => ( "corner")), selected: false, hovered: true, closes: false });
     }
   }
   const handles = getVisibleHandles(state).flatMap((ref) => {
-    const a = getAnchor(doc, ref);
-    const h = _optionalChain([a, 'optionalAccess', _78 => _78[ref.handle]]);
+    const a = getAnchorWorld(doc, ref);
+    const h = _optionalChain([a, 'optionalAccess', _81 => _81[ref.handle]]);
     if (!a || !h) return [];
     const s = toScreen(state, h);
     const sa = toScreen(state, a);
-    const hovered = !!_optionalChain([state, 'access', _79 => _79.hover, 'optionalAccess', _80 => _80.handle]) && sameAnchor(state.hover.handle, ref) && state.hover.handle.handle === ref.handle;
+    const hovered = !!_optionalChain([state, 'access', _82 => _82.hover, 'optionalAccess', _83 => _83.handle]) && sameAnchor(state.hover.handle, ref) && state.hover.handle.handle === ref.handle;
     return [{ ref, x: s.x, y: s.y, anchorX: sa.x, anchorY: sa.y, hovered }];
   });
   let marquee = null;
-  if (_optionalChain([state, 'access', _81 => _81.interaction, 'optionalAccess', _82 => _82.type]) === "marquee") {
+  if (_optionalChain([state, 'access', _84 => _84.interaction, 'optionalAccess', _85 => _85.type]) === "marquee") {
     const b = state.interaction.bounds;
     const tl = toScreen(state, b);
     marquee = { x: tl.x, y: tl.y, width: b.width * z, height: b.height * z };
@@ -2795,8 +2998,8 @@ function getVectorOverlayRenderData(state) {
   let penPreview = null;
   if (state.tool === "pen" && state.pen && state.pointer && !state.interaction) {
     const node = findVectorNode(doc.nodes, state.pen.nodeId);
-    const sp = _optionalChain([node, 'optionalAccess', _83 => _83.type]) === "path" ? node.subpaths[state.pen.subpath] : void 0;
-    const last = _optionalChain([sp, 'optionalAccess', _84 => _84.anchors, 'access', _85 => _85[sp.anchors.length - 1]]);
+    const sp = _optionalChain([node, 'optionalAccess', _86 => _86.type]) === "path" ? node.subpaths[state.pen.subpath] : void 0;
+    const last = sp ? getAnchorWorld(doc, { nodeId: state.pen.nodeId, subpath: state.pen.subpath, index: sp.anchors.length - 1 }) : void 0;
     if (last) {
       const a = toScreen(state, last);
       const p = toScreen(state, state.pointer);
@@ -2808,10 +3011,10 @@ function getVectorOverlayRenderData(state) {
   const artboard = { x: origin.x, y: origin.y, width: doc.width * z, height: doc.height * z };
   let status = null;
   const it = state.interaction;
-  if (_optionalChain([it, 'optionalAccess', _86 => _86.type]) === "rotate") status = `${Math.round(it.angle)}\xB0`;
-  else if (_optionalChain([it, 'optionalAccess', _87 => _87.type]) === "move" || _optionalChain([it, 'optionalAccess', _88 => _88.type]) === "anchors") status = `\u0394 ${fmt(it.dx)}, ${fmt(it.dy)}`;
-  else if (_optionalChain([it, 'optionalAccess', _89 => _89.type]) === "scale" || _optionalChain([it, 'optionalAccess', _90 => _90.type]) === "draw") {
-    const b = it.type === "draw" ? findVectorNode(doc.nodes, it.nodeId) ? vectorNodeBounds(findVectorNode(doc.nodes, it.nodeId)) : null : state.selectionBounds;
+  if (_optionalChain([it, 'optionalAccess', _87 => _87.type]) === "rotate") status = `${Math.round(it.angle)}\xB0`;
+  else if (_optionalChain([it, 'optionalAccess', _88 => _88.type]) === "move" || _optionalChain([it, 'optionalAccess', _89 => _89.type]) === "anchors") status = `\u0394 ${fmt(it.dx)}, ${fmt(it.dy)}`;
+  else if (_optionalChain([it, 'optionalAccess', _90 => _90.type]) === "scale" || _optionalChain([it, 'optionalAccess', _91 => _91.type]) === "draw") {
+    const b = it.type === "draw" ? findVectorNode(doc.nodes, it.nodeId) ? vectorNodeBounds(findVectorNode(doc.nodes, it.nodeId)) : null : state.selectionFrame;
     if (b) status = `W ${fmt(b.width)} \xD7 H ${fmt(b.height)}`;
   }
   return { outlines, selectionBox, anchors, handles, marquee, penPreview, artboard, status };
@@ -2838,7 +3041,7 @@ function isVectorTextTarget(target) {
   if (!el || typeof el !== "object") return false;
   const tag = (_nullishCoalesce(el.tagName, () => ( ""))).toUpperCase();
   if (tag === "INPUT" || tag === "TEXTAREA" || tag === "SELECT") return true;
-  return !!el.isContentEditable || _optionalChain([el, 'access', _91 => _91.getAttribute, 'optionalCall', _92 => _92("contenteditable")]) === "true";
+  return !!el.isContentEditable || _optionalChain([el, 'access', _92 => _92.getAttribute, 'optionalCall', _93 => _93("contenteditable")]) === "true";
 }
 function getVectorSelectionStyle(state) {
   const paths = [];
@@ -2897,23 +3100,25 @@ function createVectorCommands(controller, options = {}) {
   const base = { group, ...options.scope ? { scope: options.scope } : {} };
   const hasSelection = () => controller.getState().selection.length ? true : "Nothing is selected.";
   const ids = (params) => {
-    const list2 = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _93 => _93.ids]), () => ( controller.getState().selection));
+    const list2 = _nullishCoalesce(_optionalChain([params, 'optionalAccess', _94 => _94.ids]), () => ( controller.getState().selection));
     for (const id of list2) if (!controller.getNode(id)) fail(`There is no node "${id}".`);
     if (!list2.length) fail("Nothing is selected; pass ids.");
     return list2;
   };
-  const enabledFor = (_, params) => _optionalChain([params, 'optionalAccess', _94 => _94.ids, 'optionalAccess', _95 => _95.length]) ? true : hasSelection();
+  const enabledFor = (_, params) => _optionalChain([params, 'optionalAccess', _95 => _95.ids, 'optionalAccess', _96 => _96.length]) ? true : hasSelection();
   const list = () => {
     const state = controller.getState();
     const out = [];
     const visit = (nodes, depth) => {
       for (const n of nodes) {
-        const b = vectorNodeBounds(n);
+        const parent = _nullishCoalesce(vectorParentMatrix(state.document.nodes, n.id), () => ( IDENTITY_MATRIX));
+        const b = vectorNodeBounds(n, parent);
         out.push({
           id: n.id,
           type: n.type,
           ...n.name ? { name: n.name } : {},
           depth,
+          rotation: Math.round(vectorNodeRotation(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,
@@ -2987,7 +3192,7 @@ function createVectorCommands(controller, options = {}) {
       run: (_ctx, params) => {
         const id = controller.addPath(params.d, { ...pickStyle(params), ...params.name ? { name: params.name } : {} });
         const node = controller.getNode(id);
-        if (_optionalChain([node, 'optionalAccess', _96 => _96.type]) === "path" && !node.subpaths.length) {
+        if (_optionalChain([node, 'optionalAccess', _97 => _97.type]) === "path" && !node.subpaths.length) {
           controller.undo();
           fail("The path data has no points.");
         }
@@ -3015,10 +3220,18 @@ function createVectorCommands(controller, options = {}) {
       id: `${prefix}transform`,
       label: "Transform\u2026",
       keywords: ["move", "translate", "scale", "resize", "rotate", "flip"],
-      description: "Moves (dx, dy), scales (sx, sy) and/or rotates (degrees clockwise) nodes around their combined centre, in that order.",
+      description: "Moves (dx, dy), scales (sx, sy, along the selection box axes) and/or rotates (`rotate`: by degrees clockwise around the combined centre; `angle`: to an absolute rotation, each node around its own centre), in that order.",
       params: {
         type: "object",
-        properties: { ids: IDS, dx: { type: "number" }, dy: { type: "number" }, sx: { type: "number" }, sy: { type: "number" }, rotate: { type: "number" } }
+        properties: {
+          ids: IDS,
+          dx: { type: "number" },
+          dy: { type: "number" },
+          sx: { type: "number" },
+          sy: { type: "number" },
+          rotate: { type: "number" },
+          angle: { type: "number" }
+        }
       },
       enabled: enabledFor,
       undoable: true,
@@ -3027,6 +3240,7 @@ function createVectorCommands(controller, options = {}) {
         if (params.dx || params.dy) check(controller.translate(_nullishCoalesce(params.dx, () => ( 0)), _nullishCoalesce(params.dy, () => ( 0)), { ids: target }));
         if (params.sx !== void 0 || params.sy !== void 0) check(controller.scale(_nullishCoalesce(params.sx, () => ( 1)), _nullishCoalesce(_nullishCoalesce(params.sy, () => ( params.sx)), () => ( 1)), { ids: target }));
         if (params.rotate) check(controller.rotate(params.rotate, { ids: target }));
+        if (params.angle !== void 0) check(controller.setRotation(params.angle, { ids: target }));
         return { ok: true };
       }
     },
@@ -3111,7 +3325,7 @@ function createVectorCommands(controller, options = {}) {
       enabled: enabledFor,
       undoable: true,
       run: (_ctx, params) => {
-        const id = controller.group({ ids: ids(params), name: _optionalChain([params, 'optionalAccess', _97 => _97.name]) });
+        const id = controller.group({ ids: ids(params), name: _optionalChain([params, 'optionalAccess', _98 => _98.name]) });
         if (!id) fail("Only nodes that share a parent can be grouped.");
         return { id };
       }
@@ -3150,7 +3364,7 @@ function createVectorCommands(controller, options = {}) {
       keywords: ["download", "save", "markup"],
       description: "Returns the document as SVG markup.",
       params: { type: "object", properties: { precision: { type: "integer", minimum: 0, maximum: 8 } } },
-      run: (_ctx, params) => ({ svg: controller.toSvg({ precision: _optionalChain([params, 'optionalAccess', _98 => _98.precision]) }) })
+      run: (_ctx, params) => ({ svg: controller.toSvg({ precision: _optionalChain([params, 'optionalAccess', _99 => _99.precision]) }) })
     },
     {
       ...base,
@@ -3239,5 +3453,19 @@ function createVectorCommands(controller, options = {}) {
 
 
 
-exports.IDENTITY_MATRIX = IDENTITY_MATRIX; exports.KAPPA = KAPPA; exports.VECTOR_CLIPBOARD_TYPE = VECTOR_CLIPBOARD_TYPE; exports.VECTOR_OVERLAY_THEME = VECTOR_OVERLAY_THEME; exports.VECTOR_ROTATE_HANDLE_OFFSET = VECTOR_ROTATE_HANDLE_OFFSET; exports.VECTOR_TOOLS = VECTOR_TOOLS; exports.VECTOR_TOOL_GLYPHS = VECTOR_TOOL_GLYPHS; exports.VECTOR_TOOL_SHORTCUTS = VECTOR_TOOL_SHORTCUTS; exports.VECTOR_TRANSFORM_HANDLES = VECTOR_TRANSFORM_HANDLES; exports.VectorEditorController = VectorEditorController; exports.applyMatrix = applyMatrix; exports.bezierToSubpaths = bezierToSubpaths; exports.boundsFromPoints = boundsFromPoints; exports.boundsIntersect = boundsIntersect; exports.cloneAnchor = cloneAnchor; exports.cloneSubpath = cloneSubpath; exports.cloneVectorDocument = cloneVectorDocument; exports.cloneVectorNode = cloneVectorNode; exports.collectPathNodes = collectPathNodes; exports.convertAnchor = convertAnchor; exports.createVectorCommands = createVectorCommands; exports.ellipseSubpath = ellipseSubpath; exports.findVectorNode = findVectorNode; exports.getAnchor = getAnchor; exports.getEditablePathIds = getEditablePathIds; exports.getTransformHandlePositions = getTransformHandlePositions; exports.getVectorOverlayRenderData = getVectorOverlayRenderData; exports.getVectorSceneRenderData = getVectorSceneRenderData; exports.getVectorSelectionStyle = getVectorSelectionStyle; exports.getVisibleAnchors = getVisibleAnchors; exports.getVisibleHandles = getVisibleHandles; exports.hasPaint = hasPaint; exports.hitTestVectorNode = hitTestVectorNode; exports.hitTestVectorNodes = hitTestVectorNodes; exports.inferAnchorType = inferAnchorType; exports.insertAnchor = insertAnchor; exports.isVectorTextTarget = isVectorTextTarget; exports.lineSubpath = lineSubpath; exports.locateVectorNode = locateVectorNode; exports.moveAnchorHandle = moveAnchorHandle; exports.multiplyMatrices = multiplyMatrices; exports.nearestSegment = nearestSegment; exports.parseSvgTransform = parseSvgTransform; exports.parseVectorSvg = parseVectorSvg; exports.polygonSubpath = polygonSubpath; exports.rectSubpath = rectSubpath; exports.removeAnchors = removeAnchors; exports.reverseSubpath = reverseSubpath; exports.rotateMatrix = rotateMatrix; exports.roundSubpaths = roundSubpaths; exports.scaleFor = scaleFor; exports.scaleMatrix = scaleMatrix; exports.starSubpath = starSubpath; exports.subpathSegment = subpathSegment; exports.subpathSegmentCount = subpathSegmentCount; exports.subpathsToBezier = subpathsToBezier; exports.toVectorKeyInput = toVectorKeyInput; exports.toVectorModifiers = toVectorModifiers; exports.toVectorPointerInput = toVectorPointerInput; exports.transformVectorNode = transformVectorNode; exports.translateAnchor = translateAnchor; exports.translateMatrix = translateMatrix; exports.unionBounds = unionBounds; exports.vectorDocumentToSvg = vectorDocumentToSvg; exports.vectorNodeBounds = vectorNodeBounds; exports.vectorNodeToBezier = vectorNodeToBezier; exports.vectorPaintToHex = vectorPaintToHex; exports.vectorPaintToSvg = vectorPaintToSvg; exports.vectorPathData = vectorPathData; exports.vectorToolLabel = vectorToolLabel; exports.walkVectorNodes = walkVectorNodes;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.IDENTITY_MATRIX = IDENTITY_MATRIX; exports.KAPPA = KAPPA; exports.VECTOR_CLIPBOARD_TYPE = VECTOR_CLIPBOARD_TYPE; exports.VECTOR_OVERLAY_THEME = VECTOR_OVERLAY_THEME; exports.VECTOR_ROTATE_HANDLE_OFFSET = VECTOR_ROTATE_HANDLE_OFFSET; exports.VECTOR_TOOLS = VECTOR_TOOLS; exports.VECTOR_TOOL_GLYPHS = VECTOR_TOOL_GLYPHS; exports.VECTOR_TOOL_SHORTCUTS = VECTOR_TOOL_SHORTCUTS; exports.VECTOR_TRANSFORM_HANDLES = VECTOR_TRANSFORM_HANDLES; exports.VectorEditorController = VectorEditorController; exports.applyMatrix = applyMatrix; exports.applyMatrixLinear = applyMatrixLinear; exports.bezierToSubpaths = bezierToSubpaths; exports.boundsFromPoints = boundsFromPoints; exports.boundsIntersect = boundsIntersect; exports.cloneAnchor = cloneAnchor; exports.cloneSubpath = cloneSubpath; exports.cloneVectorDocument = cloneVectorDocument; exports.cloneVectorNode = cloneVectorNode; exports.collectPathNodes = collectPathNodes; exports.convertAnchor = convertAnchor; exports.createVectorCommands = createVectorCommands; exports.decomposeRigid = decomposeRigid; exports.ellipseSubpath = ellipseSubpath; exports.findVectorNode = findVectorNode; exports.getAnchor = getAnchor; exports.getAnchorWorld = getAnchorWorld; exports.getEditablePathIds = getEditablePathIds; exports.getTransformHandlePositions = getTransformHandlePositions; exports.getVectorOverlayRenderData = getVectorOverlayRenderData; exports.getVectorSceneRenderData = getVectorSceneRenderData; exports.getVectorSelectionBoxGeometry = getVectorSelectionBoxGeometry; exports.getVectorSelectionFrame = getVectorSelectionFrame; exports.getVectorSelectionStyle = getVectorSelectionStyle; exports.getVisibleAnchors = getVisibleAnchors; exports.getVisibleHandles = getVisibleHandles; exports.hasPaint = hasPaint; exports.hitTestVectorNode = hitTestVectorNode; exports.hitTestVectorNodes = hitTestVectorNodes; exports.inferAnchorType = inferAnchorType; exports.insertAnchor = insertAnchor; exports.invertMatrix = invertMatrix; exports.isIdentityMatrix = isIdentityMatrix; exports.isVectorTextTarget = isVectorTextTarget; exports.lineSubpath = lineSubpath; exports.locateVectorNode = locateVectorNode; exports.matrixRotation = matrixRotation; exports.moveAnchorHandle = moveAnchorHandle; exports.multiplyMatrices = multiplyMatrices; exports.nearestSegment = nearestSegment; exports.nodeMatrix = nodeMatrix; exports.parseSvgTransform = parseSvgTransform; exports.parseVectorSvg = parseVectorSvg; exports.polygonSubpath = polygonSubpath; exports.rectSubpath = rectSubpath; exports.removeAnchors = removeAnchors; exports.reverseSubpath = reverseSubpath; exports.rotateMatrix = rotateMatrix; exports.roundSubpaths = roundSubpaths; exports.scaleFor = scaleFor; exports.scaleMatrix = scaleMatrix; exports.starSubpath = starSubpath; exports.subpathSegment = subpathSegment; exports.subpathSegmentCount = subpathSegmentCount; exports.subpathsToBezier = subpathsToBezier; exports.toVectorKeyInput = toVectorKeyInput; exports.toVectorModifiers = toVectorModifiers; exports.toVectorPointerInput = toVectorPointerInput; exports.transformVectorNode = transformVectorNode; exports.translateAnchor = translateAnchor; exports.translateMatrix = translateMatrix; exports.unionBounds = unionBounds; exports.vectorDocumentToSvg = vectorDocumentToSvg; exports.vectorNodeBounds = vectorNodeBounds; exports.vectorNodeRotation = vectorNodeRotation; exports.vectorNodeToBezier = vectorNodeToBezier; exports.vectorPaintToHex = vectorPaintToHex; exports.vectorPaintToSvg = vectorPaintToSvg; exports.vectorParentMatrix = vectorParentMatrix; exports.vectorPathData = vectorPathData; exports.vectorPathWorldBezier = vectorPathWorldBezier; exports.vectorResizeCursor = vectorResizeCursor; exports.vectorToolLabel = vectorToolLabel; exports.vectorWorldMatrix = vectorWorldMatrix; exports.walkVectorNodes = walkVectorNodes;
 //# sourceMappingURL=index.cjs.map