@pixerate/editor 0.24.0 → 0.25.0

package/dist/canvas/index.cjs

@@ -1,4 +1,4 @@
-"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6;
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class; var _class2; var _class3; var _class4; var _class5; var _class6; var _class7;
 
 
 var _chunk26BVFKHUcjs = require('../chunk-26BVFKHU.cjs');
@@ -8,6 +8,13 @@ var _chunk26BVFKHUcjs = require('../chunk-26BVFKHU.cjs');
 
 
 
+var _chunk4BVP64JJcjs = require('../chunk-4BVP64JJ.cjs');
+
+
+
+
+
+
 
 
 
@@ -129,11 +136,11 @@ function createFanOutTrajectory(options = {}) {
     const oneMinusT = 1 - t;
     const x = oneMinusT * oneMinusT * origin.x + 2 * oneMinusT * t * midX + t * t * target.x;
     const y = oneMinusT * oneMinusT * origin.y + 2 * oneMinusT * t * midY + t * t * target.y;
-    const scale = startScale + (endScale - startScale) * progress;
+    const scale2 = startScale + (endScale - startScale) * progress;
     const opacity = startOpacity + (endOpacity - startOpacity) * progress;
     return {
       position: { x, y },
-      scale,
+      scale: scale2,
       opacity
     };
   };
@@ -447,7 +454,7 @@ function isValidUrl(url) {
   try {
     const parsed = new URL(url);
     return parsed.protocol === "http:" || parsed.protocol === "https:";
-  } catch (e2) {
+  } catch (e3) {
     return false;
   }
 }
@@ -466,7 +473,7 @@ function parseCanvasClipboardData(raw) {
       const edges = Array.isArray(parsed.edges) ? parsed.edges.filter(isValidCanvasEdge) : void 0;
       return { ...parsed, edges };
     }
-  } catch (e3) {
+  } catch (e4) {
   }
   return null;
 }
@@ -1160,7 +1167,7 @@ function spacingCandidate(rects, moving, horizontal, tolerance) {
     return best2;
   };
   const crossMid = (a, b) => (Math.max(crossStart(a), crossStart(b)) + Math.min(crossEnd(a), crossEnd(b))) / 2;
-  const segment = (from, to, cross) => horizontal ? { orientation: "horizontal", kind: "spacing", x1: from, y1: cross, x2: to, y2: cross } : { orientation: "vertical", kind: "spacing", x1: cross, y1: from, x2: cross, y2: to };
+  const segment = (from, to, cross2) => horizontal ? { orientation: "horizontal", kind: "spacing", x1: from, y1: cross2, x2: to, y2: cross2 } : { orientation: "vertical", kind: "spacing", x1: cross2, y1: from, x2: cross2, y2: to };
   const candidates = [];
   if (before && after) {
     const b = before;
@@ -1474,7 +1481,7 @@ function parseCanvasScenes(input) {
   if (typeof input === "string") {
     try {
       value = JSON.parse(input);
-    } catch (e4) {
+    } catch (e5) {
       return [];
     }
   }
@@ -1717,7 +1724,7 @@ function multiPolygonBounds(input) {
   return minX === Infinity ? null : { minX, minY, maxX, maxY };
 }
 function pointInRings(point, rings, fillRule = "nonzero") {
-  const [px, py] = point;
+  const [px2, py] = point;
   let winding = 0;
   for (const ring of rings) {
     const n = ring.length;
@@ -1725,9 +1732,9 @@ function pointInRings(point, rings, fillRule = "nonzero") {
       const [ax, ay] = ring[i];
       const [bx, by] = ring[(i + 1) % n];
       if (ay <= py && by > py) {
-        if (ax + (py - ay) / (by - ay) * (bx - ax) > px) winding++;
+        if (ax + (py - ay) / (by - ay) * (bx - ax) > px2) winding++;
       } else if (by <= py && ay > py) {
-        if (ax + (py - ay) / (by - ay) * (bx - ax) > px) winding--;
+        if (ax + (py - ay) / (by - ay) * (bx - ax) > px2) winding--;
       }
     }
   }
@@ -1852,9 +1859,9 @@ function splitPass(segments, pool, eps) {
       ]) {
         for (const p of [other.a, other.b]) {
           if (p.id === seg.a.id || p.id === seg.b.id) continue;
-          const { t: t2, dist: dist2 } = project(seg.a, seg.b, p);
+          const { t: t2, dist: dist3 } = project(seg.a, seg.b, p);
           const len = Math.hypot(seg.b.x - seg.a.x, seg.b.y - seg.a.y);
-          if (dist2 <= eps && t2 * len > eps && (1 - t2) * len > eps) {
+          if (dist3 <= eps && t2 * len > eps && (1 - t2) * len > eps) {
             addSplit(split, t2, p);
             touched = true;
           }
@@ -1988,14 +1995,14 @@ function buildOverlay(inputs, options) {
 function insideFlags(windings, fillRules) {
   return windings.map((w, k) => fillRules[k] === "evenodd" ? (w & 1) === 1 : w !== 0);
 }
-function traceRings(directed) {
+function traceRings(directed2) {
   const outgoing = /* @__PURE__ */ new Map();
-  for (const e of directed) {
+  for (const e of directed2) {
     const list = outgoing.get(e.from.id);
     if (list) list.push(e);
     else outgoing.set(e.from.id, [e]);
   }
-  const TWO_PI = Math.PI * 2;
+  const TWO_PI2 = Math.PI * 2;
   const next = (incoming) => {
     const candidates = outgoing.get(incoming.to.id);
     if (!candidates) return void 0;
@@ -2004,8 +2011,8 @@ function traceRings(directed) {
     let bestTurn = Infinity;
     for (const c of candidates) {
       let turn = back - c.angle;
-      turn -= Math.floor(turn / TWO_PI) * TWO_PI;
-      if (turn <= 1e-15) turn = TWO_PI;
+      turn -= Math.floor(turn / TWO_PI2) * TWO_PI2;
+      if (turn <= 1e-15) turn = TWO_PI2;
       if (turn < bestTurn) {
         bestTurn = turn;
         best = c;
@@ -2015,11 +2022,11 @@ function traceRings(directed) {
   };
   const used = /* @__PURE__ */ new Set();
   const rings = [];
-  for (const start of directed) {
+  for (const start of directed2) {
     if (used.has(start)) continue;
     const ring = [];
     let edge = start;
-    let guard = directed.length + 1;
+    let guard = directed2.length + 1;
     while (edge && !used.has(edge) && guard-- > 0) {
       used.add(edge);
       ring.push(edge.from);
@@ -2043,9 +2050,9 @@ function removeCollinear(ring, eps) {
       const dx = nxt[0] - prev[0];
       const dy = nxt[1] - prev[1];
       const len = Math.hypot(dx, dy);
-      const cross = (cur[0] - prev[0]) * dy - (cur[1] - prev[1]) * dx;
-      const dot2 = (cur[0] - prev[0]) * dx + (cur[1] - prev[1]) * dy;
-      if (len > 0 && Math.abs(cross) / len <= eps && dot2 > 0 && dot2 < len * len) {
+      const cross2 = (cur[0] - prev[0]) * dy - (cur[1] - prev[1]) * dx;
+      const dot3 = (cur[0] - prev[0]) * dx + (cur[1] - prev[1]) * dy;
+      if (len > 0 && Math.abs(cross2) / len <= eps && dot3 > 0 && dot3 < len * len) {
         changed = true;
         continue;
       }
@@ -2087,15 +2094,15 @@ function assemble(rings, eps) {
   return polygons;
 }
 function extract(overlay, isInside) {
-  const directed = [];
+  const directed2 = [];
   overlay.edges.forEach((edge, i) => {
     const l = isInside(insideFlags(overlay.left[i], overlay.fillRules));
     const r = isInside(insideFlags(overlay.right[i], overlay.fillRules));
     if (l === r) return;
     const [from, to] = l ? [edge.a, edge.b] : [edge.b, edge.a];
-    directed.push({ from, to, angle: Math.atan2(to.y - from.y, to.x - from.x) });
+    directed2.push({ from, to, angle: Math.atan2(to.y - from.y, to.x - from.x) });
   });
-  return assemble(traceRings(directed), overlay.eps);
+  return assemble(traceRings(directed2), overlay.eps);
 }
 function predicate(operation) {
   switch (operation) {
@@ -2978,9 +2985,9 @@ function rdp(points, tolerance) {
     let maxDist = -1;
     let index = -1;
     for (let i = s + 1; i < e; i++) {
-      const dist2 = segmentDistance(points[i], points[s], points[e]);
-      if (dist2 > maxDist) {
-        maxDist = dist2;
+      const dist3 = segmentDistance(points[i], points[s], points[e]);
+      if (dist3 > maxDist) {
+        maxDist = dist3;
         index = i;
       }
     }
@@ -2996,9 +3003,9 @@ function simplifyRing(ring, tolerance) {
   let far = 0;
   let farDist = -1;
   for (let i = 1; i < ring.length; i++) {
-    const dist2 = Math.hypot(ring[i][0] - ring[0][0], ring[i][1] - ring[0][1]);
-    if (dist2 > farDist) {
-      farDist = dist2;
+    const dist3 = Math.hypot(ring[i][0] - ring[0][0], ring[i][1] - ring[0][1]);
+    if (dist3 > farDist) {
+      farDist = dist3;
       far = i;
     }
   }
@@ -3036,273 +3043,2559 @@ function polygonToSvgPath(input, options = {}) {
   return fit ? fitted : ringsToPath(rings, f);
 }
 
-// src/canvas/shapeNodes.ts
-var SHAPE_DATA_KEY = "shape";
-var SHAPE_NODE_TYPE = "shape";
-var SHAPE_OPERATIONS = ["unite", "intersect", "subtract", "exclude", "divide"];
-var BOOLEAN_FOR = {
-  unite: "union",
-  intersect: "intersection",
-  subtract: "difference",
-  exclude: "xor"
-};
-function isShapeNode(node) {
-  return !!node && isShapeDescription(_optionalChain([node, 'access', _71 => _71.data, 'optionalAccess', _72 => _72[SHAPE_DATA_KEY]]));
-}
-function getNodeShape(node) {
-  const shape = _optionalChain([node, 'optionalAccess', _73 => _73.data, 'optionalAccess', _74 => _74[SHAPE_DATA_KEY]]);
-  return isShapeDescription(shape) ? shape : null;
+// src/canvas/pathops/bezier.ts
+var sub2 = (a, b) => [a[0] - b[0], a[1] - b[1]];
+var add2 = (a, b) => [a[0] + b[0], a[1] + b[1]];
+var scale = (a, s) => [a[0] * s, a[1] * s];
+var dot2 = (a, b) => a[0] * b[0] + a[1] * b[1];
+var cross = (a, b) => a[0] * b[1] - a[1] * b[0];
+var dist2 = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1]);
+var lerp = (a, b, t) => [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
+var samePoint = (a, b) => a[0] === b[0] && a[1] === b[1];
+function unit2(v) {
+  const l = Math.hypot(v[0], v[1]);
+  return l > 0 && Number.isFinite(l) ? [v[0] / l, v[1] / l] : null;
+}
+function segmentPoint(seg, t) {
+  const n = seg.length;
+  if (n === 2) return lerp(seg[0], seg[1], t);
+  const mt = 1 - t;
+  if (n === 3) {
+    const a2 = mt * mt;
+    const b2 = 2 * mt * t;
+    const c2 = t * t;
+    return [a2 * seg[0][0] + b2 * seg[1][0] + c2 * seg[2][0], a2 * seg[0][1] + b2 * seg[1][1] + c2 * seg[2][1]];
+  }
+  const a = mt * mt * mt;
+  const b = 3 * mt * mt * t;
+  const c = 3 * mt * t * t;
+  const d = t * t * t;
+  return [
+    a * seg[0][0] + b * seg[1][0] + c * seg[2][0] + d * seg[3][0],
+    a * seg[0][1] + b * seg[1][1] + c * seg[2][1] + d * seg[3][1]
+  ];
 }
-function shapeNodeToPolygon(node, lookup, options = {}) {
-  const shape = getNodeShape(node);
-  if (!shape) return null;
-  const size = getNodeSize(node, options);
-  const origin = node.parentId && lookup ? getAbsolutePosition(node, lookup) : node.position;
-  const { rings, fillRule } = shapeToPolygon(shape, size, { tolerance: options.tolerance });
-  return {
-    rings: rings.map((ring) => ring.map(([x, y]) => [x + origin.x, y + origin.y])),
-    fillRule
-  };
+function segmentDerivative(seg, t) {
+  const n = seg.length;
+  if (n === 2) return sub2(seg[1], seg[0]);
+  if (n === 3) {
+    const a2 = sub2(seg[1], seg[0]);
+    const b2 = sub2(seg[2], seg[1]);
+    return [2 * ((1 - t) * a2[0] + t * b2[0]), 2 * ((1 - t) * a2[1] + t * b2[1])];
+  }
+  const a = sub2(seg[1], seg[0]);
+  const b = sub2(seg[2], seg[1]);
+  const c = sub2(seg[3], seg[2]);
+  const mt = 1 - t;
+  return [
+    3 * (mt * mt * a[0] + 2 * mt * t * b[0] + t * t * c[0]),
+    3 * (mt * mt * a[1] + 2 * mt * t * b[1] + t * t * c[1])
+  ];
 }
-var idCounter = 0;
-function defaultId2(index) {
-  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return crypto.randomUUID();
-  idCounter += 1;
-  return `shape-${Date.now().toString(36)}-${idCounter}-${index}`;
+function segmentSecondDerivative(seg, t) {
+  const n = seg.length;
+  if (n === 2) return [0, 0];
+  if (n === 3) return [2 * (seg[2][0] - 2 * seg[1][0] + seg[0][0]), 2 * (seg[2][1] - 2 * seg[1][1] + seg[0][1])];
+  const a = [seg[2][0] - 2 * seg[1][0] + seg[0][0], seg[2][1] - 2 * seg[1][1] + seg[0][1]];
+  const b = [seg[3][0] - 2 * seg[2][0] + seg[1][0], seg[3][1] - 2 * seg[2][1] + seg[1][1]];
+  return [6 * ((1 - t) * a[0] + t * b[0]), 6 * ((1 - t) * a[1] + t * b[1])];
+}
+function segmentTangent(seg, t) {
+  const d = unit2(segmentDerivative(seg, t));
+  if (d) return d;
+  const h = t < 0.5 ? Math.min(1, t + 1e-6) : Math.max(0, t - 1e-6);
+  const e = unit2(segmentDerivative(seg, h));
+  if (e) return e;
+  return _nullishCoalesce(unit2(sub2(seg[seg.length - 1], seg[0])), () => ( [1, 0]));
+}
+function segmentCurvature(seg, t) {
+  if (seg.length === 2) return 0;
+  let d = segmentDerivative(seg, t);
+  let tt = t;
+  if (Math.hypot(d[0], d[1]) < 1e-12) {
+    tt = t < 0.5 ? Math.min(1, t + 1e-6) : Math.max(0, t - 1e-6);
+    d = segmentDerivative(seg, tt);
+  }
+  const dd = segmentSecondDerivative(seg, tt);
+  const len = Math.hypot(d[0], d[1]);
+  if (!(len > 0)) return 0;
+  return cross(d, dd) / (len * len * len);
+}
+function splitSegment(seg, t) {
+  const n = seg.length;
+  if (n === 2) {
+    const m2 = lerp(seg[0], seg[1], t);
+    return [
+      [seg[0], m2],
+      [m2, seg[1]]
+    ];
+  }
+  if (n === 3) {
+    const a2 = lerp(seg[0], seg[1], t);
+    const b2 = lerp(seg[1], seg[2], t);
+    const m2 = lerp(a2, b2, t);
+    return [
+      [seg[0], a2, m2],
+      [m2, b2, seg[2]]
+    ];
+  }
+  const a = lerp(seg[0], seg[1], t);
+  const b = lerp(seg[1], seg[2], t);
+  const c = lerp(seg[2], seg[3], t);
+  const ab = lerp(a, b, t);
+  const bc = lerp(b, c, t);
+  const m = lerp(ab, bc, t);
+  return [
+    [seg[0], a, ab, m],
+    [m, bc, c, seg[3]]
+  ];
 }
-function stackOrder(nodes, ids) {
-  return nodes.map((node, index) => ({ node, index, z: typeof node.zIndex === "number" ? node.zIndex : 0 })).filter((entry) => ids.has(entry.node.id)).sort((a, b) => a.z - b.z || a.index - b.index).map((entry) => entry.node);
+function subSegment(seg, t0, t1) {
+  if (t1 < t0) return subSegment(seg, t1, t0).reverse();
+  if (t0 <= 0 && t1 >= 1) return [...seg];
+  let s = [...seg];
+  if (t1 < 1) s = splitSegment(s, t1)[0];
+  if (t0 > 0) s = splitSegment(s, t1 > 0 ? t0 / t1 : 0)[1];
+  return s;
+}
+function isStraightSegment(seg, tol) {
+  if (seg.length === 2) return true;
+  const a = seg[0];
+  const b = seg[seg.length - 1];
+  const chord = sub2(b, a);
+  const len = Math.hypot(chord[0], chord[1]);
+  for (let i = 1; i < seg.length - 1; i++) {
+    const v = sub2(seg[i], a);
+    if (len === 0) {
+      if (Math.hypot(v[0], v[1]) > tol) return false;
+      continue;
+    }
+    if (Math.abs(cross(chord, v)) / len > tol) return false;
+    const along = dot2(chord, v) / len;
+    if (along < -tol || along > len + tol) return false;
+  }
+  return true;
 }
-function canCombineShapeNodes(nodes, ids) {
-  const idSet = new Set(ids);
-  const shapes = nodes.filter((n) => idSet.has(n.id) && isShapeNode(n));
-  if (shapes.some((n) => isLocked(n))) return { ok: false, reason: "locked" };
-  if (shapes.length < 2) return { ok: false, reason: "too-few" };
-  return { ok: true, shapeIds: shapes.map((n) => n.id) };
+function quadraticRoots(a, b, c, out) {
+  const push = (t) => {
+    if (t > 1e-12 && t < 1 - 1e-12) out.push(t);
+  };
+  const scaleAbs = Math.max(Math.abs(a), Math.abs(b), Math.abs(c));
+  if (scaleAbs === 0) return;
+  if (Math.abs(a) <= 1e-12 * scaleAbs) {
+    if (b !== 0) push(-c / b);
+    return;
+  }
+  const disc = b * b - 4 * a * c;
+  if (disc < 0) return;
+  const sq = Math.sqrt(disc);
+  const q = -0.5 * (b + (b >= 0 ? sq : -sq));
+  push(q / a);
+  if (q !== 0) push(c / q);
 }
-function combineShapeNodes(nodes, ids, operation, options = {}) {
-  const idList = [...ids];
-  const check = canCombineShapeNodes(nodes, idList);
-  if (!check.ok) return { ok: false, operation, reason: check.reason };
-  const lookup = createNodeLookup(nodes);
-  const shapeIds = new Set(check.shapeIds);
-  const ordered = stackOrder(nodes, shapeIds);
-  const operands = ordered.map((node) => shapeNodeToPolygon(node, lookup, options));
-  const parentIds = new Set(ordered.map((n) => _nullishCoalesce(n.parentId, () => ( ""))));
-  const sharedParent = parentIds.size === 1 ? ordered[0].parentId : void 0;
-  const parentOrigin = sharedParent && lookup.get(sharedParent) ? getAbsolutePosition(lookup.get(sharedParent), lookup) : { x: 0, y: 0 };
-  const pickSource = () => {
-    const style = _nullishCoalesce(options.styleFrom, () => ( "bottom"));
-    if (style === "top") return ordered[ordered.length - 1];
-    if (style === "first") {
-      const first = idList.find((id) => shapeIds.has(id));
-      return first && lookup.get(first) || ordered[0];
+function segmentExtrema(seg, axis) {
+  const out = [];
+  if (seg.length === 3) {
+    const d = seg[0][axis] - 2 * seg[1][axis] + seg[2][axis];
+    if (d !== 0) {
+      const t = (seg[0][axis] - seg[1][axis]) / d;
+      if (t > 1e-12 && t < 1 - 1e-12) out.push(t);
     }
-    if (typeof style === "object") return shapeIds.has(style.id) && lookup.get(style.id) || ordered[0];
-    return ordered[0];
-  };
-  const createId = _nullishCoalesce(options.createId, () => ( defaultId2));
-  const build = (polygon, source, index) => {
-    const bounds = multiPolygonBounds(polygon);
-    if (!bounds) return null;
-    const width = bounds.maxX - bounds.minX;
-    const height = bounds.maxY - bounds.minY;
-    if (!(width > 0) || !(height > 0)) return null;
-    const d = polygonToSvgPath(polygon, {
-      precision: options.precision,
-      simplify: options.simplify,
-      offset: { x: -bounds.minX, y: -bounds.minY },
-      curves: _nullishCoalesce(options.curves, () => ( "fit")),
-      curveTolerance: _nullishCoalesce(_nullishCoalesce(options.curveTolerance, () => ( options.tolerance)), () => ( 0.25)),
-      cornerAngleDeg: options.cornerAngleDeg
-    });
-    if (!d) return null;
-    const sourceShape = getNodeShape(source);
-    const shape = {
-      kind: "path",
-      d,
-      viewBox: [0, 0, roundSize(width), roundSize(height)],
-      fillRule: "nonzero"
-    };
-    for (const key of ["fill", "stroke", "strokeWidth", "opacity"]) {
-      if (sourceShape[key] !== void 0) shape[key] = sourceShape[key];
+  } else if (seg.length === 4) {
+    const p0 = seg[0][axis];
+    const p1 = seg[1][axis];
+    const p2 = seg[2][axis];
+    const p3 = seg[3][axis];
+    const a = -p0 + 3 * p1 - 3 * p2 + p3;
+    const b = 2 * (p0 - 2 * p1 + p2);
+    const c = p1 - p0;
+    quadraticRoots(a, b, c, out);
+  }
+  return out.sort((x, y) => x - y);
+}
+function segmentBounds(seg) {
+  const a = seg[0];
+  const b = seg[seg.length - 1];
+  let minX = Math.min(a[0], b[0]);
+  let maxX = Math.max(a[0], b[0]);
+  let minY = Math.min(a[1], b[1]);
+  let maxY = Math.max(a[1], b[1]);
+  for (const axis of [0, 1]) {
+    for (const t of segmentExtrema(seg, axis)) {
+      const p = segmentPoint(seg, t);
+      if (axis === 0) {
+        minX = Math.min(minX, p[0]);
+        maxX = Math.max(maxX, p[0]);
+      } else {
+        minY = Math.min(minY, p[1]);
+        maxY = Math.max(maxY, p[1]);
+      }
     }
-    const {
-      [LOCKED_DATA_KEY]: _locked,
-      [LOCKED_PREVIOUS_FLAGS_KEY]: _previous,
-      ...data
-    } = _nullishCoalesce(source.data, () => ( {}));
-    const {
-      measured: _measured,
-      selected: _selected,
-      dragging: _dragging,
-      positionAbsolute: _positionAbsolute,
-      internals: _internals,
-      parentId: _parentId,
-      ...rest
-    } = source;
-    const node = {
-      ...rest,
-      id: createId(index),
-      position: { x: bounds.minX - parentOrigin.x, y: bounds.minY - parentOrigin.y },
-      width,
-      height,
-      data: { ...data, [SHAPE_DATA_KEY]: shape }
-    };
-    if (sharedParent) node.parentId = sharedParent;
-    if (options.nodeType !== void 0) node.type = options.nodeType;
-    if (source.style) node.style = withStyleSize(source.style, { width, height });
-    if (options.select !== false) node.selected = true;
-    return node;
-  };
-  const created = [];
-  if (operation === "divide") {
-    const pieces = dividePolygons(operands, { epsilon: options.epsilon });
-    pieces.forEach((piece) => {
-      const source = ordered[piece.operands[piece.operands.length - 1]];
-      const node = build([piece.polygon], source, created.length);
-      if (node) created.push(node);
-    });
-  } else {
-    const result = polygonBoolean(BOOLEAN_FOR[operation], operands, { epsilon: options.epsilon });
-    const node = build(result, pickSource(), 0);
-    if (node) created.push(node);
   }
-  if (created.length === 0) return { ok: false, operation, reason: "empty" };
-  return { ok: true, operation, removeIds: ordered.map((n) => n.id), nodes: created };
-}
-function roundSize(value) {
-  return Math.round(value * 1e3) / 1e3;
+  return { minX, minY, maxX, maxY };
 }
-function applyShapeCombination(nodes, change, options = {}) {
-  const remove = new Set(change.removeIds);
-  const insertAt = nodes.findIndex((n) => remove.has(n.id));
-  const deselect = options.deselect !== false && change.nodes.some((n) => n.selected);
+function monotoneParams(seg) {
+  if (seg.length === 2) return [];
+  const ts = [...segmentExtrema(seg, 0), ...segmentExtrema(seg, 1)].sort((a, b) => a - b);
   const out = [];
-  nodes.forEach((node, index) => {
-    if (index === insertAt) out.push(...change.nodes);
-    if (remove.has(node.id)) return;
-    out.push(deselect && node.selected ? { ...node, selected: false } : node);
-  });
-  if (insertAt === -1) out.push(...change.nodes);
-  return out;
-}
-function revertShapeCombination(nodes, change, previous) {
-  const created = new Set(change.nodes.map((n) => n.id));
-  const removed = new Set(change.removeIds);
-  const out = nodes.filter((n) => !created.has(n.id));
-  previous.forEach((node, index) => {
-    if (!removed.has(node.id) || out.some((n) => n.id === node.id)) return;
-    out.splice(Math.min(index, out.length), 0, node);
-  });
+  for (const t of ts) if (out.length === 0 || t - out[out.length - 1] > 1e-9) out.push(t);
   return out;
 }
-
-// src/canvas/resizeSnap.ts
-var RESIZE_HANDLES = [
-  "top-left",
-  "top",
-  "top-right",
-  "right",
-  "bottom-right",
-  "bottom",
-  "bottom-left",
-  "left"
+function segmentAreaTerm(seg) {
+  if (seg.length === 2) return (seg[0][0] * seg[1][1] - seg[1][0] * seg[0][1]) / 2;
+  const nodes = [-Math.sqrt(3 / 5), 0, Math.sqrt(3 / 5)];
+  const weights = [5 / 9, 8 / 9, 5 / 9];
+  let sum = 0;
+  for (let i = 0; i < 3; i++) {
+    const t = (nodes[i] + 1) / 2;
+    const p = segmentPoint(seg, t);
+    const d = segmentDerivative(seg, t);
+    sum += weights[i] * (p[0] * d[1] - p[1] * d[0]);
+  }
+  return sum / 4;
+}
+var GL_X = [
+  -0.9602898564975363,
+  -0.7966664774136267,
+  -0.525532409916329,
+  -0.1834346424956498,
+  0.1834346424956498,
+  0.525532409916329,
+  0.7966664774136267,
+  0.9602898564975363
 ];
-function resizeHandleAxes(handle) {
-  const x = handle.includes("left") ? -1 : handle.includes("right") ? 1 : 0;
-  const y = handle.includes("top") ? -1 : handle.includes("bottom") ? 1 : 0;
-  return { x, y };
-}
-function inferResizeHandle(start, next, eps = 1e-6) {
-  const moved = (a, b) => Math.abs(a - b) > eps;
-  const left = moved(start.x, next.x);
-  const right = moved(start.x + start.width, next.x + next.width);
-  const top = moved(start.y, next.y);
-  const bottom = moved(start.y + start.height, next.y + next.height);
-  const h = left ? "left" : right ? "right" : "";
-  const v = top ? "top" : bottom ? "bottom" : "";
-  if (h && v) return `${v}-${h}`;
-  return h || v || null;
-}
-function within(axis, v, tolerance) {
-  const { values } = axis;
+var GL_W = [
+  0.1012285362903763,
+  0.2223810344533745,
+  0.3137066458778873,
+  0.362683783378362,
+  0.362683783378362,
+  0.3137066458778873,
+  0.2223810344533745,
+  0.1012285362903763
+];
+function glLength(seg, t0, t1) {
+  const half = (t1 - t0) / 2;
+  const mid = (t0 + t1) / 2;
+  let sum = 0;
+  for (let i = 0; i < GL_X.length; i++) {
+    const d = segmentDerivative(seg, mid + half * GL_X[i]);
+    sum += GL_W[i] * Math.hypot(d[0], d[1]);
+  }
+  return sum * half;
+}
+function adaptiveLength(seg, t0, t1, whole, tol, depth) {
+  const m = (t0 + t1) / 2;
+  const left = glLength(seg, t0, m);
+  const right = glLength(seg, m, t1);
+  if (depth >= 18 || Math.abs(left + right - whole) <= tol) return left + right;
+  return adaptiveLength(seg, t0, m, left, tol / 2, depth + 1) + adaptiveLength(seg, m, t1, right, tol / 2, depth + 1);
+}
+function segmentLength(seg, t0 = 0, t1 = 1, tolerance = 1e-9) {
+  if (t1 < t0) return segmentLength(seg, t1, t0, tolerance);
+  if (seg.length === 2) return dist2(seg[0], seg[1]) * (t1 - t0);
+  const whole = glLength(seg, t0, t1);
+  return adaptiveLength(seg, t0, t1, whole, Math.max(tolerance, whole * 1e-12), 0);
+}
+function segmentParamAtLength(seg, length, total = segmentLength(seg)) {
+  if (!(total > 0) || length <= 0) return 0;
+  if (length >= total) return 1;
+  if (seg.length === 2) return length / total;
   let lo = 0;
-  let hi = values.length;
-  while (lo < hi) {
-    const mid = lo + hi >>> 1;
-    if (values[mid] < v - tolerance) lo = mid + 1;
-    else hi = mid;
+  let hi = 1;
+  let t = length / total;
+  for (let i = 0; i < 40; i++) {
+    const err = segmentLength(seg, 0, t) - length;
+    if (Math.abs(err) <= 1e-10 * Math.max(1, total)) break;
+    if (err > 0) hi = t;
+    else lo = t;
+    const d = segmentDerivative(seg, t);
+    const speed = Math.hypot(d[0], d[1]);
+    let next = speed > 0 ? t - err / speed : (lo + hi) / 2;
+    if (!(next > lo && next < hi)) next = (lo + hi) / 2;
+    t = next;
+  }
+  return t;
+}
+function segmentNearest(seg, p) {
+  if (seg.length === 2) {
+    const d = sub2(seg[1], seg[0]);
+    const len2 = dot2(d, d);
+    const t = len2 === 0 ? 0 : Math.max(0, Math.min(1, dot2(sub2(p, seg[0]), d) / len2));
+    return { t, distance: dist2(p, segmentPoint(seg, t)) };
+  }
+  const samples = 16;
+  let best = { t: 0, distance: dist2(p, seg[0]) };
+  const candidates = [];
+  let prev = Infinity;
+  let prevT = 0;
+  let descending = false;
+  for (let i = 0; i <= samples; i++) {
+    const t = i / samples;
+    const d = dist2(p, segmentPoint(seg, t));
+    if (d < best.distance) best = { t, distance: d };
+    if (i > 0 && d > prev && descending) candidates.push(prevT);
+    descending = d < prev;
+    prev = d;
+    prevT = t;
+  }
+  candidates.push(best.t, 1);
+  for (const start of candidates) {
+    let t = start;
+    for (let k = 0; k < 12; k++) {
+      const q = segmentPoint(seg, t);
+      const d1 = segmentDerivative(seg, t);
+      const d2 = segmentSecondDerivative(seg, t);
+      const diff = sub2(q, p);
+      const f = dot2(diff, d1);
+      const fp = dot2(d1, d1) + dot2(diff, d2);
+      if (!(Math.abs(fp) > 1e-300)) break;
+      const next = Math.max(0, Math.min(1, t - f / fp));
+      if (Math.abs(next - t) < 1e-14) {
+        t = next;
+        break;
+      }
+      t = next;
+    }
+    const d = dist2(p, segmentPoint(seg, t));
+    if (d < best.distance) best = { t, distance: d };
   }
-  const out = [];
-  for (let i = lo; i < values.length && values[i] <= v + tolerance; i++) out.push(values[i]);
-  return out;
+  return best;
 }
-function matching(axis, v, eps) {
-  const { values, rects } = axis;
+function arcToCubics(from, cmd) {
+  const [x0, y0] = from;
+  const { x, y } = cmd;
+  if (x0 === x && y0 === y) return [];
+  let rx = Math.abs(cmd.rx);
+  let ry = Math.abs(cmd.ry);
+  if (rx === 0 || ry === 0) return [[from, [x, y]]];
+  const phi = cmd.rotation * Math.PI / 180;
+  const cos = Math.cos(phi);
+  const sin = Math.sin(phi);
+  const dx = (x0 - x) / 2;
+  const dy = (y0 - y) / 2;
+  const x1p = cos * dx + sin * dy;
+  const y1p = -sin * dx + cos * dy;
+  const lambda = x1p * x1p / (rx * rx) + y1p * y1p / (ry * ry);
+  if (lambda > 1) {
+    const s = Math.sqrt(lambda);
+    rx *= s;
+    ry *= s;
+  }
+  const num = rx * rx * ry * ry - rx * rx * y1p * y1p - ry * ry * x1p * x1p;
+  const den = rx * rx * y1p * y1p + ry * ry * x1p * x1p;
+  let coef = den === 0 ? 0 : Math.sqrt(Math.max(0, num / den));
+  if (cmd.largeArc === cmd.sweep) coef = -coef;
+  const cxp = coef * rx * y1p / ry;
+  const cyp = -coef * ry * x1p / rx;
+  const cx = cos * cxp - sin * cyp + (x0 + x) / 2;
+  const cy = sin * cxp + cos * cyp + (y0 + y) / 2;
+  const angle = (ux, uy, vx, vy) => Math.atan2(ux * vy - uy * vx, ux * vx + uy * vy);
+  const theta1 = angle(1, 0, (x1p - cxp) / rx, (y1p - cyp) / ry);
+  let delta = angle((x1p - cxp) / rx, (y1p - cyp) / ry, (-x1p - cxp) / rx, (-y1p - cyp) / ry);
+  if (!cmd.sweep && delta > 0) delta -= 2 * Math.PI;
+  else if (cmd.sweep && delta < 0) delta += 2 * Math.PI;
+  const n = Math.max(1, Math.ceil(Math.abs(delta) / (Math.PI / 2) - 1e-9));
+  const step = delta / n;
+  const k = 4 / 3 * Math.tan(step / 4);
+  const map = (ux, uy) => {
+    const ex = rx * ux;
+    const ey = ry * uy;
+    return [cos * ex - sin * ey + cx, sin * ex + cos * ey + cy];
+  };
   const out = [];
-  for (let i = 0; i < values.length; i++) if (Math.abs(values[i] - v) <= eps) out.push(rects[i]);
+  let prev = from;
+  for (let i = 0; i < n; i++) {
+    const a0 = theta1 + step * i;
+    const a1 = a0 + step;
+    const c0 = Math.cos(a0);
+    const s0 = Math.sin(a0);
+    const c1 = Math.cos(a1);
+    const s1 = Math.sin(a1);
+    const end = i === n - 1 ? [x, y] : map(c1, s1);
+    out.push([prev, map(c0 - k * s0, s0 + k * c0), map(c1 + k * s1, s1 - k * c1), end]);
+    prev = end;
+  }
   return out;
 }
-function snapResize(rect, handle, targets, options = {}) {
-  const index = Array.isArray(targets) ? createGuideIndex(targets) : targets;
-  const zoom = options.zoom && options.zoom > 0 ? options.zoom : 1;
-  const tolerance = (_nullishCoalesce(options.threshold, () => ( 6))) / zoom;
-  const eps = 0.5 / zoom;
-  const useEdges = options.edges !== false;
-  const useCentres = options.centres !== false;
-  const grid = _nullishCoalesce(options.gridSize, () => ( 0));
-  const axes = resizeHandleAxes(handle);
-  const unchanged = { rect: { ...rect }, guides: [], snappedX: false, snappedY: false, changed: false };
-  if (![rect.x, rect.y, rect.width, rect.height].every(Number.isFinite)) return unchanged;
-  const x0 = rect.x;
-  const x1 = rect.x + rect.width;
-  const y0 = rect.y;
-  const y1 = rect.y + rect.height;
-  const bestHit = (horizontal) => {
-    const dir = horizontal ? axes.x : axes.y;
-    if (dir === 0) return null;
-    const moving = horizontal ? dir < 0 ? x0 : x1 : dir < 0 ? y0 : y1;
-    const fixed = horizontal ? dir < 0 ? x1 : x0 : dir < 0 ? y1 : y0;
-    const min = _nullishCoalesce((horizontal ? options.minWidth : options.minHeight), () => ( 0));
-    const valid = (t) => {
-      const size = dir < 0 ? fixed - t : t - fixed;
-      return Number.isFinite(size) && size > 1e-9 && size >= min;
-    };
-    let best = null;
-    const consider = (values, kind) => {
-      for (const t of values) {
-        if (!valid(t)) continue;
-        if (!best || Math.abs(t - moving) < Math.abs(best.value - moving)) best = { value: t, kind };
-      }
-    };
-    if (useEdges) consider(within(horizontal ? index.edgeX : index.edgeY, moving, tolerance), "edge");
-    if (useCentres) consider(within(horizontal ? index.centreX : index.centreY, moving, tolerance), "centre");
-    if (!best && grid > 0) {
-      const origin = horizontal ? _nullishCoalesce(_optionalChain([options, 'access', _75 => _75.gridOrigin, 'optionalAccess', _76 => _76.x]), () => ( 0)) : _nullishCoalesce(_optionalChain([options, 'access', _77 => _77.gridOrigin, 'optionalAccess', _78 => _78.y]), () => ( 0));
-      consider([snapToGrid(moving, grid, origin)], "grid");
+function isBezierCommandList(input) {
+  return Array.isArray(input) && !input.some((c) => c && c.type === "A");
+}
+function toBezierPath(input) {
+  const commands = typeof input === "string" ? parseSvgPath(input) : isBezierCommandList(input) ? input : input;
+  const out = [];
+  let current = [0, 0];
+  let start = [0, 0];
+  let open = false;
+  const ensureMove = () => {
+    if (!open) {
+      out.push({ type: "M", x: start[0], y: start[1] });
+      current = start;
+      open = true;
     }
-    return best;
-  };
-  let nx0 = x0;
-  let nx1 = x1;
-  let ny0 = y0;
-  let ny1 = y1;
-  const setEdge = (horizontal, value) => {
-    const dir = horizontal ? axes.x : axes.y;
-    if (horizontal) {
-      if (dir < 0) nx0 = value;
-      else nx1 = value;
-    } else if (dir < 0) ny0 = value;
-    else ny1 = value;
   };
-  let hitX = bestHit(true);
-  let hitY = bestHit(false);
-  const ratio = rect.height > 0 ? rect.width / rect.height : 0;
+  for (const cmd of commands) {
+    switch (cmd.type) {
+      case "M":
+        start = [cmd.x, cmd.y];
+        current = start;
+        out.push({ type: "M", x: cmd.x, y: cmd.y });
+        open = true;
+        break;
+      case "L":
+        ensureMove();
+        out.push({ type: "L", x: cmd.x, y: cmd.y });
+        current = [cmd.x, cmd.y];
+        break;
+      case "Q":
+        ensureMove();
+        out.push({ type: "Q", x1: cmd.x1, y1: cmd.y1, x: cmd.x, y: cmd.y });
+        current = [cmd.x, cmd.y];
+        break;
+      case "C":
+        ensureMove();
+        out.push({ type: "C", x1: cmd.x1, y1: cmd.y1, x2: cmd.x2, y2: cmd.y2, x: cmd.x, y: cmd.y });
+        current = [cmd.x, cmd.y];
+        break;
+      case "A": {
+        ensureMove();
+        for (const c of arcToCubics(current, cmd)) {
+          if (c.length === 2) out.push({ type: "L", x: c[1][0], y: c[1][1] });
+          else out.push({ type: "C", x1: c[1][0], y1: c[1][1], x2: c[2][0], y2: c[2][1], x: c[3][0], y: c[3][1] });
+        }
+        current = [cmd.x, cmd.y];
+        break;
+      }
+      case "Z":
+        if (open) out.push({ type: "Z" });
+        open = false;
+        current = start;
+        break;
+    }
+  }
+  return out;
+}
+function pathToContours(input) {
+  const path = toBezierPath(input);
+  const contours = [];
+  let current = null;
+  let pen = [0, 0];
+  let start = [0, 0];
+  const push = (seg) => {
+    if (!current) {
+      current = { segments: [], closed: false };
+      contours.push(current);
+    }
+    if (seg.every((p) => samePoint(p, seg[0]))) return;
+    current.segments.push(seg);
+  };
+  for (const cmd of path) {
+    switch (cmd.type) {
+      case "M":
+        start = [cmd.x, cmd.y];
+        pen = start;
+        current = { segments: [], closed: false };
+        contours.push(current);
+        break;
+      case "L":
+        push([pen, [cmd.x, cmd.y]]);
+        pen = [cmd.x, cmd.y];
+        break;
+      case "Q":
+        push([pen, [cmd.x1, cmd.y1], [cmd.x, cmd.y]]);
+        pen = [cmd.x, cmd.y];
+        break;
+      case "C":
+        push([pen, [cmd.x1, cmd.y1], [cmd.x2, cmd.y2], [cmd.x, cmd.y]]);
+        pen = [cmd.x, cmd.y];
+        break;
+      case "Z":
+        if (current) current.closed = true;
+        current = null;
+        pen = start;
+        break;
+    }
+  }
+  return contours;
+}
+function contoursToPath(contours) {
+  const out = [];
+  for (const contour of contours) {
+    const segs = contour.segments;
+    if (segs.length === 0) continue;
+    out.push({ type: "M", x: segs[0][0][0], y: segs[0][0][1] });
+    let count = segs.length;
+    if (contour.closed && count > 1) {
+      const last = segs[count - 1];
+      if (last.length === 2 && samePoint(last[1], segs[0][0])) count--;
+    }
+    for (let i = 0; i < count; i++) {
+      const s = segs[i];
+      const end = s[s.length - 1];
+      if (s.length === 2) out.push({ type: "L", x: end[0], y: end[1] });
+      else if (s.length === 3) out.push({ type: "Q", x1: s[1][0], y1: s[1][1], x: end[0], y: end[1] });
+      else out.push({ type: "C", x1: s[1][0], y1: s[1][1], x2: s[2][0], y2: s[2][1], x: end[0], y: end[1] });
+    }
+    if (contour.closed) out.push({ type: "Z" });
+  }
+  return out;
+}
+function bezierPathToSvg(input, options = {}) {
+  const path = toBezierPath(input);
+  const precision = _nullishCoalesce(options.precision, () => ( 3));
+  const dx = _nullishCoalesce(_optionalChain([options, 'access', _71 => _71.offset, 'optionalAccess', _72 => _72.x]), () => ( 0));
+  const dy = _nullishCoalesce(_optionalChain([options, 'access', _73 => _73.offset, 'optionalAccess', _74 => _74.y]), () => ( 0));
+  const fx = (n) => formatNumber2(n + dx, precision);
+  const fy = (n) => formatNumber2(n + dy, precision);
+  let d = "";
+  for (const c of path) {
+    switch (c.type) {
+      case "M":
+        d += `M${fx(c.x)} ${fy(c.y)}`;
+        break;
+      case "L":
+        d += `L${fx(c.x)} ${fy(c.y)}`;
+        break;
+      case "Q":
+        d += `Q${fx(c.x1)} ${fy(c.y1)} ${fx(c.x)} ${fy(c.y)}`;
+        break;
+      case "C":
+        d += `C${fx(c.x1)} ${fy(c.y1)} ${fx(c.x2)} ${fy(c.y2)} ${fx(c.x)} ${fy(c.y)}`;
+        break;
+      case "Z":
+        d += "Z";
+        break;
+    }
+  }
+  return d;
+}
+function transformBezierPath(input, m) {
+  const [a, b, c, d, e, f] = m;
+  const X = (x, y) => a * x + c * y + e;
+  const Y = (x, y) => b * x + d * y + f;
+  return toBezierPath(input).map((cmd) => {
+    switch (cmd.type) {
+      case "M":
+      case "L":
+        return { type: cmd.type, x: X(cmd.x, cmd.y), y: Y(cmd.x, cmd.y) };
+      case "Q":
+        return { type: "Q", x1: X(cmd.x1, cmd.y1), y1: Y(cmd.x1, cmd.y1), x: X(cmd.x, cmd.y), y: Y(cmd.x, cmd.y) };
+      case "C":
+        return {
+          type: "C",
+          x1: X(cmd.x1, cmd.y1),
+          y1: Y(cmd.x1, cmd.y1),
+          x2: X(cmd.x2, cmd.y2),
+          y2: Y(cmd.x2, cmd.y2),
+          x: X(cmd.x, cmd.y),
+          y: Y(cmd.x, cmd.y)
+        };
+      case "Z":
+        return cmd;
+    }
+  });
+}
+function countPathSegments(input) {
+  const out = { lines: 0, quads: 0, cubics: 0 };
+  for (const contour of pathToContours(input)) {
+    const segs = closeContour(contour);
+    for (const s of segs) {
+      if (s.length === 2) out.lines++;
+      else if (s.length === 3) out.quads++;
+      else out.cubics++;
+    }
+  }
+  return out;
+}
+function closeContour(contour, force = false) {
+  const segs = contour.segments;
+  if (segs.length === 0) return [];
+  if (!contour.closed && !force) return segs;
+  const first = segs[0][0];
+  const lastSeg = segs[segs.length - 1];
+  const last = lastSeg[lastSeg.length - 1];
+  return samePoint(first, last) ? segs : [...segs, [last, first]];
+}
+function bezierPathBounds(input) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  const path = toBezierPath(input);
+  let pen = null;
+  for (const contour of pathToContours(path)) {
+    for (const s of contour.segments) {
+      const b = segmentBounds(s);
+      minX = Math.min(minX, b.minX);
+      minY = Math.min(minY, b.minY);
+      maxX = Math.max(maxX, b.maxX);
+      maxY = Math.max(maxY, b.maxY);
+    }
+  }
+  for (const c of path) {
+    if (c.type === "M") pen = [c.x, c.y];
+    if (pen) {
+      minX = Math.min(minX, pen[0]);
+      minY = Math.min(minY, pen[1]);
+      maxX = Math.max(maxX, pen[0]);
+      maxY = Math.max(maxY, pen[1]);
+    }
+  }
+  return minX === Infinity ? null : { minX, minY, maxX, maxY };
+}
+function bezierPathSignedArea(input) {
+  let sum = 0;
+  for (const contour of pathToContours(input)) sum += contourSignedArea(closeContour(contour, true));
+  return sum;
+}
+function contourSignedArea(segs) {
+  let sum = 0;
+  for (const s of segs) sum += segmentAreaTerm(s);
+  return sum;
+}
+function bezierPathLength(input) {
+  let total = 0;
+  for (const contour of pathToContours(input)) for (const s of closeContour(contour)) total += segmentLength(s);
+  return total;
+}
+function bezierPathPointAtLength(input, length) {
+  const contours = pathToContours(input);
+  let remaining = Math.max(0, length);
+  let last = null;
+  for (let ci = 0; ci < contours.length; ci++) {
+    const segs = closeContour(contours[ci]);
+    for (let si = 0; si < segs.length; si++) {
+      const s = segs[si];
+      const len = segmentLength(s);
+      if (remaining <= len) {
+        const t = segmentParamAtLength(s, remaining, len);
+        const tangent2 = segmentTangent(s, t);
+        return { point: segmentPoint(s, t), tangent: tangent2, angle: Math.atan2(tangent2[1], tangent2[0]), contour: ci, segment: si, t };
+      }
+      remaining -= len;
+      const tangent = segmentTangent(s, 1);
+      last = { point: s[s.length - 1], tangent, angle: Math.atan2(tangent[1], tangent[0]), contour: ci, segment: si, t: 1 };
+    }
+  }
+  return last;
+}
+function trimSegments(segs, from, to, lengths) {
+  const lens = _nullishCoalesce(lengths, () => ( segs.map((s) => segmentLength(s))));
+  const out = [];
+  let at = 0;
+  for (let i = 0; i < segs.length; i++) {
+    const len = lens[i];
+    const s0 = at;
+    const s1 = at + len;
+    at = s1;
+    if (s1 <= from || s0 >= to || len <= 0) continue;
+    const t0 = from > s0 ? segmentParamAtLength(segs[i], from - s0, len) : 0;
+    const t1 = to < s1 ? segmentParamAtLength(segs[i], to - s0, len) : 1;
+    if (t1 > t0) out.push(subSegment(segs[i], t0, t1));
+  }
+  return out;
+}
+function solveMonotone(seg, axis, value) {
+  const a = seg[0][axis];
+  const b = seg[seg.length - 1][axis];
+  if (seg.length === 2) return b === a ? 0 : (value - a) / (b - a);
+  const increasing = b > a;
+  let lo = 0;
+  let hi = 1;
+  let t = b === a ? 0.5 : Math.max(0, Math.min(1, (value - a) / (b - a)));
+  for (let i = 0; i < 60; i++) {
+    const v = segmentPoint(seg, t)[axis] - value;
+    if (v === 0) return t;
+    if (v > 0 === increasing) hi = t;
+    else lo = t;
+    const d = segmentDerivative(seg, t)[axis];
+    let next = d !== 0 ? t - v / d : (lo + hi) / 2;
+    if (!(next > lo && next < hi)) next = (lo + hi) / 2;
+    if (Math.abs(next - t) < 1e-15) return next;
+    t = next;
+  }
+  return t;
+}
+function yMonotonePieces(segs) {
+  const out = [];
+  for (const s of segs) {
+    if (s.length === 2) {
+      out.push(s);
+      continue;
+    }
+    const ts = segmentExtrema(s, 1);
+    let prev = 0;
+    for (const t of [...ts, 1]) {
+      out.push(subSegment(s, prev, t));
+      prev = t;
+    }
+  }
+  return out;
+}
+function windingNumber(chains, point) {
+  const [px2, py] = point;
+  let winding = 0;
+  for (const chain of chains) {
+    for (const s of yMonotonePieces(chain)) {
+      const ay = s[0][1];
+      const by = s[s.length - 1][1];
+      let dir = 0;
+      if (ay <= py && by > py) dir = 1;
+      else if (by <= py && ay > py) dir = -1;
+      else continue;
+      let minX = Infinity;
+      let maxX = -Infinity;
+      for (const p of s) {
+        if (p[0] < minX) minX = p[0];
+        if (p[0] > maxX) maxX = p[0];
+      }
+      if (minX > px2) {
+        winding += dir;
+        continue;
+      }
+      if (maxX <= px2) continue;
+      const t = solveMonotone(s, 1, py);
+      if (segmentPoint(s, t)[0] > px2) winding += dir;
+    }
+  }
+  return winding;
+}
+function pointInBezierPath(input, point, fillRule = "nonzero") {
+  const chains = pathToContours(input).map((c) => closeContour(c, true));
+  const w = windingNumber(chains, point);
+  return fillRule === "evenodd" ? (w & 1) === 1 : w !== 0;
+}
+function distanceToBezierPath(input, point) {
+  const contours = Array.isArray(input) && input.length > 0 && input[0].segments ? input : pathToContours(input);
+  let best = Infinity;
+  for (const contour of contours) {
+    for (const s of closeContour(contour)) {
+      let minX = Infinity;
+      let minY = Infinity;
+      let maxX = -Infinity;
+      let maxY = -Infinity;
+      for (const p of s) {
+        minX = Math.min(minX, p[0]);
+        minY = Math.min(minY, p[1]);
+        maxX = Math.max(maxX, p[0]);
+        maxY = Math.max(maxY, p[1]);
+      }
+      const dx = Math.max(minX - point[0], 0, point[0] - maxX);
+      const dy = Math.max(minY - point[1], 0, point[1] - maxY);
+      if (Math.hypot(dx, dy) >= best) continue;
+      best = Math.min(best, segmentNearest(s, point).distance);
+    }
+    if (contour.segments.length === 0) continue;
+  }
+  return best;
+}
+function flattenChain(segs, tolerance) {
+  const out = [];
+  for (const s of segs) {
+    if (out.length === 0) out.push(s[0]);
+    if (s.length === 2) {
+      out.push(s[1]);
+      continue;
+    }
+    let dd = 0;
+    for (let i = 0; i + 2 < s.length; i++) {
+      dd = Math.max(dd, Math.hypot(s[i][0] - 2 * s[i + 1][0] + s[i + 2][0], s[i][1] - 2 * s[i + 1][1] + s[i + 2][1]));
+    }
+    const deg = s.length - 1;
+    const n = Math.max(1, Math.min(256, Math.ceil(Math.sqrt(deg * (deg - 1) * dd / (8 * tolerance)))));
+    for (let k = 1; k <= n; k++) out.push(segmentPoint(s, k / n));
+  }
+  if (out.length > 1 && samePoint(out[0], out[out.length - 1])) out.pop();
+  return out;
+}
+
+// src/canvas/pathops/boolean.ts
+var PathOpsError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "PathOpsError";
+  }
+};
+function isOperandObject(input) {
+  return !!input && typeof input === "object" && !Array.isArray(input) && "path" in input;
+}
+function normalizeOperand(input) {
+  const path = isOperandObject(input) ? input.path : input;
+  const fillRule = isOperandObject(input) ? _nullishCoalesce(input.fillRule, () => ( "nonzero")) : "nonzero";
+  const chains = [];
+  for (const contour of pathToContours(_nullishCoalesce(path, () => ( "")))) {
+    const chain = closeContour(contour, true);
+    if (chain.length === 0) continue;
+    for (const seg of chain) {
+      for (const p of seg) {
+        if (!Number.isFinite(p[0]) || !Number.isFinite(p[1])) throw new PathOpsError(NON_FINITE);
+      }
+    }
+    chains.push(chain);
+  }
+  return { chains, fillRule };
+}
+function scaleOf(operands) {
+  let max = 0;
+  for (const op of operands) {
+    for (const chain of op.chains) {
+      for (const seg of chain) {
+        for (const [x, y] of seg) max = Math.max(max, Math.abs(x), Math.abs(y));
+      }
+    }
+  }
+  return Math.max(1, max);
+}
+var VertexPool = (_class6 = class {
+  constructor(eps) {;_class6.prototype.__init15.call(this);_class6.prototype.__init16.call(this);
+    this.eps = eps;
+  }
+  
+  __init15() {this.vertices = []}
+  __init16() {this.cells = /* @__PURE__ */ new Map()}
+  get(x, y) {
+    const cx = Math.floor(x / this.eps);
+    const cy = Math.floor(y / this.eps);
+    let best = null;
+    let bestDist = Infinity;
+    for (let dx = -1; dx <= 1; dx++) {
+      for (let dy = -1; dy <= 1; dy++) {
+        const ids = this.cells.get(`${cx + dx},${cy + dy}`);
+        if (!ids) continue;
+        for (const id of ids) {
+          const v = this.vertices[id];
+          const d = Math.hypot(v.x - x, v.y - y);
+          if (d <= this.eps && d < bestDist) {
+            best = v;
+            bestDist = d;
+          }
+        }
+      }
+    }
+    if (best) return best;
+    const vertex = { id: this.vertices.length, x, y, p: [x, y] };
+    this.vertices.push(vertex);
+    const key = `${cx},${cy}`;
+    const bucket = this.cells.get(key);
+    if (bucket) bucket.push(vertex.id);
+    else this.cells.set(key, [vertex.id]);
+    return vertex;
+  }
+}, _class6);
+function hull(pts) {
+  let minX = Infinity;
+  let maxX = -Infinity;
+  let minY = Infinity;
+  let maxY = -Infinity;
+  for (const [x, y] of pts) {
+    if (x < minX) minX = x;
+    if (x > maxX) maxX = x;
+    if (y < minY) minY = y;
+    if (y > maxY) maxY = y;
+  }
+  return { minX, maxX, minY, maxY };
+}
+function snapEnds(pts, a, b) {
+  const n = pts.length;
+  if (n === 2) return [a, b];
+  const d0 = sub2(a, pts[0]);
+  const d1 = sub2(b, pts[n - 1]);
+  if (n === 3) {
+    return [a, [pts[1][0] + (d0[0] + d1[0]) / 2, pts[1][1] + (d0[1] + d1[1]) / 2], b];
+  }
+  return [a, [pts[1][0] + d0[0], pts[1][1] + d0[1]], [pts[2][0] + d1[0], pts[2][1] + d1[1]], b];
+}
+function makePiece(pts, a, b, operand, src, s0, s1) {
+  const snapped = snapEnds(pts, a.p, b.p);
+  return { pts: snapped, a, b, operand, src, s0, s1, dirty: true, ...hull(snapped) };
+}
+var NON_FINITE = "non-finite coordinates";
+function flatness(pts) {
+  if (pts.length === 2) return 0;
+  const a = pts[0];
+  const b = pts[pts.length - 1];
+  const chord = sub2(b, a);
+  const len = Math.hypot(chord[0], chord[1]);
+  let worst = 0;
+  for (let i = 1; i < pts.length - 1; i++) {
+    const v = sub2(pts[i], a);
+    const d = len > 0 ? Math.abs(cross(chord, v)) / len : Math.hypot(v[0], v[1]);
+    const along = len > 0 ? dot2(chord, v) / len : 0;
+    const over = Math.max(0, -along, along - len);
+    worst = Math.max(worst, d, over);
+  }
+  return worst;
+}
+function split2(pts) {
+  const n = pts.length;
+  const mid = (p, q) => [(p[0] + q[0]) / 2, (p[1] + q[1]) / 2];
+  if (n === 2) {
+    const m2 = mid(pts[0], pts[1]);
+    return [
+      [pts[0], m2],
+      [m2, pts[1]]
+    ];
+  }
+  if (n === 3) {
+    const a2 = mid(pts[0], pts[1]);
+    const b2 = mid(pts[1], pts[2]);
+    const m2 = mid(a2, b2);
+    return [
+      [pts[0], a2, m2],
+      [m2, b2, pts[2]]
+    ];
+  }
+  const a = mid(pts[0], pts[1]);
+  const b = mid(pts[1], pts[2]);
+  const c = mid(pts[2], pts[3]);
+  const ab = mid(a, b);
+  const bc = mid(b, c);
+  const m = mid(ab, bc);
+  return [
+    [pts[0], a, ab, m],
+    [m, bc, c, pts[3]]
+  ];
+}
+function closestSegmentPoints(a0, a1, b0, b1) {
+  const d1 = sub2(a1, a0);
+  const d2 = sub2(b1, b0);
+  const r = sub2(a0, b0);
+  const a = dot2(d1, d1);
+  const e = dot2(d2, d2);
+  const f = dot2(d2, r);
+  let s = 0;
+  let u = 0;
+  if (a <= 1e-300 && e <= 1e-300) return { s: 0, u: 0, d: dist2(a0, b0) };
+  if (a <= 1e-300) {
+    u = Math.max(0, Math.min(1, f / e));
+  } else {
+    const c = dot2(d1, r);
+    if (e <= 1e-300) {
+      s = Math.max(0, Math.min(1, -c / a));
+    } else {
+      const b = dot2(d1, d2);
+      const denom = a * e - b * b;
+      s = denom > 0 ? Math.max(0, Math.min(1, (b * f - c * e) / denom)) : 0;
+      u = (b * s + f) / e;
+      if (u < 0) {
+        u = 0;
+        s = Math.max(0, Math.min(1, -c / a));
+      } else if (u > 1) {
+        u = 1;
+        s = Math.max(0, Math.min(1, (b - c) / a));
+      }
+    }
+  }
+  const pa = [a0[0] + d1[0] * s, a0[1] + d1[1] * s];
+  const pb = [b0[0] + d2[0] * u, b0[1] + d2[1] * u];
+  return { s, u, d: dist2(pa, pb) };
+}
+function polish(P, Q, s, u) {
+  let best = { s, u, d: dist2(segmentPoint(P, s), segmentPoint(Q, u)) };
+  for (let i = 0; i < 10 && best.d > 0; i++) {
+    const f = sub2(segmentPoint(P, s), segmentPoint(Q, u));
+    const dp = segmentDerivative(P, s);
+    const dq = segmentDerivative(Q, u);
+    const det = cross(dp, [-dq[0], -dq[1]]);
+    if (!(Math.abs(det) > 1e-300)) break;
+    const ds = cross([-f[0], -f[1]], [-dq[0], -dq[1]]) / det;
+    const du = cross(dp, [-f[0], -f[1]]) / det;
+    s = Math.max(0, Math.min(1, s + ds));
+    u = Math.max(0, Math.min(1, u + du));
+    const d = dist2(segmentPoint(P, s), segmentPoint(Q, u));
+    if (d < best.d) best = { s, u, d };
+    else break;
+  }
+  return best;
+}
+function intersectSubdivided(P, p0, p1, Q, q0, q1, fullP, fullQ, ctx, out, depth) {
+  const hp = hull(P);
+  const hq = hull(Q);
+  const e = ctx.eps;
+  if (hp.minX > hq.maxX + e || hq.minX > hp.maxX + e || hp.minY > hq.maxY + e || hq.minY > hp.maxY + e) return;
+  const fp = flatness(P);
+  const fq = flatness(Q);
+  const flatTol = e * 0.5;
+  if (fp <= flatTol && fq <= flatTol || depth >= 52) {
+    if (++ctx.leaves > ctx.budget) throw new PathOpsError("curve intersection did not converge");
+    const a0 = P[0];
+    const a1 = P[P.length - 1];
+    const b0 = Q[0];
+    const b1 = Q[Q.length - 1];
+    const d1 = sub2(a1, a0);
+    const d2 = sub2(b1, b0);
+    const denom = cross(d1, d2);
+    let s = 0;
+    let u = 0;
+    let hit = false;
+    const l1 = Math.hypot(d1[0], d1[1]);
+    const l2 = Math.hypot(d2[0], d2[1]);
+    if (Math.abs(denom) > 1e-12 * l1 * l2) {
+      const r = sub2(b0, a0);
+      s = cross(r, d2) / denom;
+      u = cross(r, d1) / denom;
+      const ts = l1 > 0 ? e / l1 : 1;
+      const tu = l2 > 0 ? e / l2 : 1;
+      hit = s >= -ts && s <= 1 + ts && u >= -tu && u <= 1 + tu;
+    }
+    if (!hit) {
+      const c = closestSegmentPoints(a0, a1, b0, b1);
+      if (c.d > e) return;
+      s = c.s;
+      u = c.u;
+    }
+    s = Math.max(0, Math.min(1, s));
+    u = Math.max(0, Math.min(1, u));
+    const best = polish(fullP, fullQ, p0 + (p1 - p0) * s, q0 + (q1 - q0) * u);
+    if (best.d > e * 2) return;
+    const a = segmentPoint(fullP, best.s);
+    const b = segmentPoint(fullQ, best.u);
+    out.push({ tp: best.s, tq: best.u, point: [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2] });
+    return;
+  }
+  const splitP = fp > flatTol;
+  const splitQ = fq > flatTol;
+  const pm = (p0 + p1) / 2;
+  const qm = (q0 + q1) / 2;
+  if (splitP && splitQ) {
+    const [pa, pb] = split2(P);
+    const [qa, qb] = split2(Q);
+    intersectSubdivided(pa, p0, pm, qa, q0, qm, fullP, fullQ, ctx, out, depth + 1);
+    intersectSubdivided(pa, p0, pm, qb, qm, q1, fullP, fullQ, ctx, out, depth + 1);
+    intersectSubdivided(pb, pm, p1, qa, q0, qm, fullP, fullQ, ctx, out, depth + 1);
+    intersectSubdivided(pb, pm, p1, qb, qm, q1, fullP, fullQ, ctx, out, depth + 1);
+  } else if (splitP) {
+    const [pa, pb] = split2(P);
+    intersectSubdivided(pa, p0, pm, Q, q0, q1, fullP, fullQ, ctx, out, depth + 1);
+    intersectSubdivided(pb, pm, p1, Q, q0, q1, fullP, fullQ, ctx, out, depth + 1);
+  } else {
+    const [qa, qb] = split2(Q);
+    intersectSubdivided(P, p0, p1, qa, q0, qm, fullP, fullQ, ctx, out, depth + 1);
+    intersectSubdivided(P, p0, p1, qb, qm, q1, fullP, fullQ, ctx, out, depth + 1);
+  }
+}
+function nearestOn(piece, p, eps) {
+  if (p[0] < piece.minX - eps || p[0] > piece.maxX + eps || p[1] < piece.minY - eps || p[1] > piece.maxY + eps) return null;
+  return segmentNearest(piece.pts, p);
+}
+function staysClose(P, Q, e1, e2, tol) {
+  for (const f of [0.25, 0.5, 0.75]) {
+    const tp = e1.tp + (e2.tp - e1.tp) * f;
+    const q = segmentNearest(Q.pts, segmentPoint(P.pts, tp));
+    if (q.distance > tol) return false;
+  }
+  return true;
+}
+function pairEvents(P, Q, ctx) {
+  const eps = ctx.eps;
+  const anchors = [];
+  for (const [va, tp] of [
+    [P.a, 0],
+    [P.b, 1]
+  ]) {
+    if (va === Q.a) anchors.push({ tp, tq: 0, point: va.p, anchor: true, shared: true });
+    else if (va === Q.b) anchors.push({ tp, tq: 1, point: va.p, anchor: true, shared: true });
+  }
+  for (const [v, tq] of [
+    [Q.a, 0],
+    [Q.b, 1]
+  ]) {
+    if (v === P.a || v === P.b) continue;
+    const near = nearestOn(P, v.p, eps);
+    if (near && near.distance <= eps) anchors.push({ tp: near.t, tq, point: v.p, anchor: true });
+  }
+  for (const [v, tp] of [
+    [P.a, 0],
+    [P.b, 1]
+  ]) {
+    if (v === Q.a || v === Q.b) continue;
+    const near = nearestOn(Q, v.p, eps);
+    if (near && near.distance <= eps) anchors.push({ tp, tq: near.t, point: v.p, anchor: true });
+  }
+  if (anchors.length >= 2) {
+    const sorted = [...anchors].sort((x, y) => x.tp - y.tp);
+    const first = sorted[0];
+    const last = sorted[sorted.length - 1];
+    if (dist2(first.point, last.point) > eps && staysClose(P, Q, first, last, eps * 4)) {
+      return anchors.filter((a) => !a.shared);
+    }
+  }
+  const found = [];
+  if (P.pts.length === 2 && Q.pts.length === 2) {
+    const a0 = P.pts[0];
+    const d1 = sub2(P.pts[1], a0);
+    const b0 = Q.pts[0];
+    const d2 = sub2(Q.pts[1], b0);
+    const denom = cross(d1, d2);
+    const l1 = Math.hypot(d1[0], d1[1]);
+    const l2 = Math.hypot(d2[0], d2[1]);
+    if (Math.abs(denom) > 1e-12 * l1 * l2) {
+      const r = sub2(b0, a0);
+      const s = cross(r, d2) / denom;
+      const u = cross(r, d1) / denom;
+      const ts = eps / l1;
+      const tu = eps / l2;
+      if (s >= -ts && s <= 1 + ts && u >= -tu && u <= 1 + tu) {
+        const sc = Math.max(0, Math.min(1, s));
+        const uc = Math.max(0, Math.min(1, u));
+        found.push({ tp: sc, tq: uc, point: [a0[0] + d1[0] * sc, a0[1] + d1[1] * sc] });
+      }
+    }
+  } else {
+    ctx.leaves = 0;
+    intersectSubdivided(P.pts, 0, 1, Q.pts, 0, 1, P.pts, Q.pts, ctx, found, 0);
+  }
+  if (found.length === 0) return anchors.filter((a) => !a.shared);
+  const all = [...anchors, ...found].sort((x, y) => x.tp - y.tp || x.tq - y.tq);
+  const clusters = [];
+  for (const ev of all) {
+    const cluster = clusters[clusters.length - 1];
+    const prev = _optionalChain([cluster, 'optionalAccess', _75 => _75[cluster.length - 1]]);
+    if (prev && (dist2(prev.point, ev.point) <= eps * 2 || staysClose(P, Q, prev, ev, eps * 2))) cluster.push(ev);
+    else clusters.push([ev]);
+  }
+  const out = [];
+  for (const cluster of clusters) {
+    const shared = cluster.find((e) => e.shared);
+    if (shared) continue;
+    const anchor = cluster.find((e) => e.anchor);
+    out.push(_nullishCoalesce(anchor, () => ( cluster[Math.floor(cluster.length / 2)])));
+  }
+  return out;
+}
+function addSplit2(map, piece, t, v) {
+  if (v === piece.a || v === piece.b) return;
+  const list = map.get(piece);
+  if (list) list.push({ t, v });
+  else map.set(piece, [{ t, v }]);
+}
+function eventVertex(P, Q, ev, pool, eps) {
+  for (const v of [P.a, P.b, Q.a, Q.b]) if (dist2(v.p, ev.point) <= eps) return v;
+  return pool.get(ev.point[0], ev.point[1]);
+}
+function splitPass2(pieces, pool, ctx) {
+  const eps = ctx.eps;
+  const order = pieces.map((_, i) => i).sort((i, j) => pieces[i].minX - pieces[j].minX);
+  const splits = /* @__PURE__ */ new Map();
+  for (let oi = 0; oi < order.length; oi++) {
+    const P = pieces[order[oi]];
+    for (let oj = oi + 1; oj < order.length; oj++) {
+      const Q = pieces[order[oj]];
+      if (Q.minX > P.maxX + eps) break;
+      if (!P.dirty && !Q.dirty) continue;
+      if (Q.minY > P.maxY + eps || Q.maxY < P.minY - eps) continue;
+      if (P.a === Q.a && P.b === Q.b && P.pts.length === 2 && Q.pts.length === 2) continue;
+      if (P.a === Q.b && P.b === Q.a && P.pts.length === 2 && Q.pts.length === 2) continue;
+      for (const ev of pairEvents(P, Q, ctx)) {
+        const v = eventVertex(P, Q, ev, pool, eps);
+        addSplit2(splits, P, ev.tp, v);
+        addSplit2(splits, Q, ev.tq, v);
+      }
+    }
+  }
+  for (const p of pieces) p.dirty = false;
+  if (splits.size === 0) return { pieces, changed: false };
+  const out = [];
+  for (const piece of pieces) {
+    const list = splits.get(piece);
+    if (!list) {
+      out.push(piece);
+      continue;
+    }
+    list.sort((x, y) => x.t - y.t);
+    let prevT = 0;
+    let prevV = piece.a;
+    const range = piece.s1 - piece.s0;
+    const emit = (t, v) => {
+      if (v === prevV || t <= prevT) return;
+      const pts = subSegment(piece.pts, prevT, t);
+      out.push(makePiece(pts, prevV, v, piece.operand, piece.src, piece.s0 + range * prevT, piece.s0 + range * t));
+      prevT = t;
+      prevV = v;
+    };
+    const seen = /* @__PURE__ */ new Set();
+    for (const { t, v } of list) {
+      if (seen.has(v) || t <= 0 || t >= 1) continue;
+      seen.add(v);
+      emit(t, v);
+    }
+    if (prevV !== piece.b) {
+      const pts = subSegment(piece.pts, prevT, 1);
+      out.push(makePiece(pts, prevV, piece.b, piece.operand, piece.src, piece.s0 + range * prevT, piece.s1));
+    }
+  }
+  return { pieces: out, changed: true };
+}
+function buildArrangement(inputs, options) {
+  const operands = inputs.map(normalizeOperand);
+  const scale2 = scaleOf(operands);
+  const eps = options.epsilon && options.epsilon > 0 ? options.epsilon : 1e-9 * scale2;
+  const pool = new VertexPool(eps);
+  const sources = [];
+  let pieces = [];
+  operands.forEach((op, operand) => {
+    for (const chain of op.chains) {
+      for (const raw of chain) {
+        const straight = raw.length > 2 && isStraightSegment(raw, eps * 0.01);
+        const seg = straight ? [raw[0], raw[raw.length - 1]] : raw;
+        const src = sources.length;
+        sources.push({ seg, line: seg.length === 2 });
+        const ts = [0, ...monotoneParams(seg), 1];
+        for (let i = 0; i + 1 < ts.length; i++) {
+          const pts = subSegment(seg, ts[i], ts[i + 1]);
+          const a = pool.get(pts[0][0], pts[0][1]);
+          const b = pool.get(pts[pts.length - 1][0], pts[pts.length - 1][1]);
+          if (a === b) continue;
+          pieces.push(makePiece(pts, a, b, operand, src, ts[i], ts[i + 1]));
+        }
+      }
+    }
+  });
+  const ctx = { eps, leaves: 0, budget: _nullishCoalesce(options.subdivisionBudget, () => ( 2e4)) };
+  let settled = false;
+  for (let pass = 0; pass < 6; pass++) {
+    const result = splitPass2(pieces, pool, ctx);
+    pieces = result.pieces;
+    if (!result.changed) {
+      settled = true;
+      break;
+    }
+  }
+  if (!settled) throw new PathOpsError("intersections did not settle");
+  const count = operands.length;
+  const groups = /* @__PURE__ */ new Map();
+  const edges = [];
+  for (const piece of pieces) {
+    const forward = piece.a.id < piece.b.id;
+    const a = forward ? piece.a : piece.b;
+    const b = forward ? piece.b : piece.a;
+    const pts = forward ? piece.pts : [...piece.pts].reverse();
+    const key = `${a.id},${b.id}`;
+    const group = _nullishCoalesce(groups.get(key), () => ( []));
+    if (!groups.has(key)) groups.set(key, group);
+    const mid = segmentPoint(pts, 0.5);
+    let edge = group.find((e) => {
+      if (e.pts.length === 2 && pts.length === 2) return true;
+      return segmentNearest(e.pts, mid).distance <= eps * 4 && segmentNearest(pts, segmentPoint(e.pts, 0.5)).distance <= eps * 4;
+    });
+    if (!edge) {
+      edge = {
+        a,
+        b,
+        pts,
+        mult: new Array(count).fill(0),
+        src: piece.src,
+        sa: forward ? piece.s0 : piece.s1,
+        sb: forward ? piece.s1 : piece.s0,
+        ...hull(pts)
+      };
+      group.push(edge);
+      edges.push(edge);
+    }
+    edge.mult[piece.operand] += forward ? 1 : -1;
+  }
+  const live = edges.filter((e) => e.mult.some((m) => m !== 0));
+  const byY = new BandIndex(live, (e) => e.minY, (e) => e.maxY);
+  const byX = new BandIndex(live, (e) => e.minX, (e) => e.maxX);
+  const right = [];
+  const left = [];
+  for (let i = 0; i < live.length; i++) {
+    const edge = live[i];
+    const mid = segmentPoint(edge.pts, 0.5);
+    const tan = segmentTangent(edge.pts, 0.5);
+    const horizontal = Math.abs(tan[1]) < Math.abs(tan[0]);
+    const winding = new Array(count).fill(0);
+    const [mx, my] = mid;
+    for (const j of horizontal ? byX.at(mx) : byY.at(my)) {
+      if (j === i) continue;
+      const o = live[j];
+      let dir = 0;
+      if (!horizontal) {
+        if (o.maxX <= mx) continue;
+        const ay = o.a.y;
+        const by = o.b.y;
+        if (ay <= my && by > my) dir = 1;
+        else if (by <= my && ay > my) dir = -1;
+        else continue;
+        if (o.minX <= mx) {
+          const t = solveMonotone(o.pts, 1, my);
+          if (!(segmentPoint(o.pts, t)[0] > mx)) continue;
+        }
+      } else {
+        if (o.maxY <= my) continue;
+        const ax = o.a.x;
+        const bx = o.b.x;
+        if (bx < mx && mx <= ax) dir = 1;
+        else if (ax < mx && mx <= bx) dir = -1;
+        else continue;
+        if (o.minY <= my) {
+          const t = solveMonotone(o.pts, 0, mx);
+          if (!(segmentPoint(o.pts, t)[1] > my)) continue;
+        }
+      }
+      for (let k = 0; k < count; k++) if (o.mult[k] !== 0) winding[k] += dir * o.mult[k];
+    }
+    const sideIsRight = horizontal ? edge.b.x < edge.a.x : edge.b.y > edge.a.y;
+    const r = sideIsRight ? winding : winding.map((w, k) => w - edge.mult[k]);
+    right.push(r);
+    left.push(r.map((w, k) => w + edge.mult[k]));
+  }
+  return { edges: live, left, right, fillRules: operands.map((o) => o.fillRule), sources, eps, scale: scale2 };
+}
+var BandIndex = class {
+  
+  
+  
+  constructor(edges, lo, hi) {
+    let min = Infinity;
+    let max = -Infinity;
+    for (const e of edges) {
+      min = Math.min(min, lo(e));
+      max = Math.max(max, hi(e));
+    }
+    const count = Math.max(1, Math.min(4096, Math.ceil(Math.sqrt(edges.length) * 2)));
+    this.min = min;
+    this.size = max > min ? (max - min) / count : 1;
+    this.bands = Array.from({ length: count }, () => []);
+    edges.forEach((e, i) => {
+      const from = this.index(lo(e));
+      const to = this.index(hi(e));
+      for (let b = from; b <= to; b++) this.bands[b].push(i);
+    });
+  }
+  index(v) {
+    const k = Math.floor((v - this.min) / this.size);
+    return Math.max(0, Math.min(this.bands.length - 1, Number.isFinite(k) ? k : 0));
+  }
+  at(v) {
+    return _nullishCoalesce(this.bands[this.index(v)], () => ( []));
+  }
+};
+function insideFlags2(windings, fillRules) {
+  return windings.map((w, k) => fillRules[k] === "evenodd" ? (w & 1) === 1 : w !== 0);
+}
+var TWO_PI = Math.PI * 2;
+var TIE = 1e-3;
+function directed(edge, forward) {
+  const pts = forward ? edge.pts : [...edge.pts].reverse();
+  const out = segmentTangent(pts, 0);
+  const end = segmentTangent(pts, 1);
+  return {
+    from: forward ? edge.a : edge.b,
+    to: forward ? edge.b : edge.a,
+    pts,
+    src: edge.src,
+    sFrom: forward ? edge.sa : edge.sb,
+    sTo: forward ? edge.sb : edge.sa,
+    outAngle: Math.atan2(out[1], out[0]),
+    backAngle: Math.atan2(-end[1], -end[0]),
+    length: dist2(pts[0], pts[pts.length - 1]) + (pts.length > 2 ? flatness(pts) : 0)
+  };
+}
+function chordAngle(pts, t) {
+  const p = segmentPoint(pts, t);
+  return Math.atan2(p[1] - pts[0][1], p[0] - pts[0][0]);
+}
+function mod2pi(a) {
+  const r = a - Math.floor(a / TWO_PI) * TWO_PI;
+  return r >= TWO_PI ? 0 : r;
+}
+function traceRings2(edges, scale2) {
+  const outgoing = /* @__PURE__ */ new Map();
+  for (const e of edges) {
+    const list = outgoing.get(e.from.id);
+    if (list) list.push(e);
+    else outgoing.set(e.from.id, [e]);
+  }
+  const next = (incoming) => {
+    const candidates = _optionalChain([outgoing, 'access', _76 => _76.get, 'call', _77 => _77(incoming.to.id), 'optionalAccess', _78 => _78.filter, 'call', _79 => _79((c) => !used.has(c) || c === start)]);
+    if (!candidates || candidates.length === 0) return void 0;
+    if (candidates.length === 1) return candidates[0];
+    const turns = candidates.map((c) => mod2pi(incoming.backAngle - c.outAngle));
+    const tied = (x) => x < TIE || x > TWO_PI - TIE;
+    let ambiguous = turns.some(tied);
+    if (!ambiguous) {
+      const sorted = [...turns].sort((a, b) => a - b);
+      for (let i = 1; i < sorted.length; i++) if (sorted[i] - sorted[i - 1] < TIE) ambiguous = true;
+    }
+    if (ambiguous) {
+      const back = [...incoming.pts].reverse();
+      let delta = Math.min(incoming.length, ...candidates.map((c) => c.length));
+      delta = Math.min(delta * 0.25, scale2 * 0.02);
+      const frac = (e) => Math.min(1, Math.max(1e-6, delta / Math.max(e.length, 1e-300)));
+      const backChord = chordAngle(back, frac(incoming));
+      for (let i = 0; i < candidates.length; i++) {
+        turns[i] = mod2pi(backChord - chordAngle(candidates[i].pts, frac(candidates[i])));
+        if (turns[i] < 1e-12) turns[i] = TWO_PI;
+      }
+    } else {
+      for (let i = 0; i < turns.length; i++) if (turns[i] < 1e-15) turns[i] = TWO_PI;
+    }
+    let best = 0;
+    for (let i = 1; i < candidates.length; i++) if (turns[i] < turns[best]) best = i;
+    return candidates[best];
+  };
+  const used = /* @__PURE__ */ new Set();
+  const rings = [];
+  let start = null;
+  for (const first of edges) {
+    if (used.has(first)) continue;
+    start = first;
+    const ring = [];
+    let edge = first;
+    let guard = edges.length + 1;
+    let closed = false;
+    while (edge && guard-- > 0) {
+      used.add(edge);
+      ring.push(edge);
+      edge = next(edge);
+      if (edge === first) {
+        closed = true;
+        break;
+      }
+    }
+    if (!closed) throw new PathOpsError("result outline does not close");
+    rings.push(ring);
+  }
+  return rings;
+}
+function mergeable(a, b, sources, eps) {
+  if (a.src === b.src && Math.abs(a.sTo - b.sFrom) < 1e-9 && a.sTo - a.sFrom > 0 === b.sTo - b.sFrom > 0) return true;
+  if (a.pts.length === 2 && b.pts.length === 2) {
+    const p = a.pts[0];
+    const q = b.pts[1];
+    const m = a.pts[1];
+    const chord = sub2(q, p);
+    const len = Math.hypot(chord[0], chord[1]);
+    if (len === 0) return false;
+    const off = Math.abs(cross(chord, sub2(m, p))) / len;
+    const along = dot2(chord, sub2(m, p));
+    return off <= eps && along > 0 && along < len * len;
+  }
+  void sources;
+  return false;
+}
+function rebuildRing(ring, sources, eps) {
+  const n = ring.length;
+  let startIndex = 0;
+  for (let k = 0; k < n; k++) {
+    if (!mergeable(ring[(k + n - 1) % n], ring[k], sources, eps)) {
+      startIndex = k;
+      break;
+    }
+  }
+  const ordered = [...ring.slice(startIndex), ...ring.slice(0, startIndex)];
+  const out = [];
+  let i = 0;
+  while (i < ordered.length) {
+    const first = ordered[i];
+    let j = i + 1;
+    while (j < ordered.length && mergeable(ordered[j - 1], ordered[j], sources, eps)) j++;
+    const last = ordered[j - 1];
+    if (j - i === 1) {
+      out.push(first.pts);
+    } else if (first.pts.length === 2 && ordered.slice(i, j).every((e) => e.pts.length === 2)) {
+      out.push([first.from.p, last.to.p]);
+    } else {
+      const source = sources[first.src];
+      out.push(snapEnds(subSegment(source.seg, first.sFrom, last.sTo), first.from.p, last.to.p));
+    }
+    i = j;
+  }
+  return out;
+}
+function extractRings(arr, isInside) {
+  const kept = [];
+  arr.edges.forEach((edge, i) => {
+    const l = isInside(insideFlags2(arr.left[i], arr.fillRules));
+    const r = isInside(insideFlags2(arr.right[i], arr.fillRules));
+    if (l === r) return;
+    kept.push(directed(edge, l));
+  });
+  const rings = [];
+  const sliver = Math.max(arr.eps * 10, 1e-7 * arr.scale);
+  for (const ring of traceRings2(kept, arr.scale)) {
+    const segs = rebuildRing(ring, arr.sources, arr.eps);
+    const area = contourSignedArea(segs);
+    let perimeter = 0;
+    for (const s of segs) perimeter += s.length === 2 ? dist2(s[0], s[1]) : segmentLength(s, 0, 1, 1e-6);
+    if (!(perimeter > 0) || 2 * Math.abs(area) / perimeter < sliver) continue;
+    rings.push({ segs, area });
+  }
+  return rings;
+}
+function ringSample(ring) {
+  let best = ring.segs[0];
+  let bestLen = -1;
+  for (const s of ring.segs) {
+    const l = dist2(s[0], s[s.length - 1]);
+    if (l > bestLen) {
+      best = s;
+      bestLen = l;
+    }
+  }
+  return segmentPoint(best, 0.5);
+}
+function groupRings(rings) {
+  const outers = rings.filter((r) => r.area > 0).sort((a, b) => b.area - a.area);
+  const holes = rings.filter((r) => r.area < 0);
+  const groups = outers.map((o) => [o]);
+  for (const hole of holes) {
+    const sample = ringSample(hole);
+    for (let i = outers.length - 1; i >= 0; i--) {
+      if (outers[i].area >= -hole.area && windingNumber([outers[i].segs], sample) !== 0) {
+        groups[i].push(hole);
+        break;
+      }
+    }
+  }
+  return groups;
+}
+function ringsToPath2(rings) {
+  return contoursToPath(rings.map((r) => ({ segments: r.segs, closed: true })));
+}
+function predicate2(operation) {
+  switch (operation) {
+    case "union":
+      return (f) => f.some(Boolean);
+    case "intersection":
+      return (f) => f.length > 0 && f.every(Boolean);
+    case "difference":
+      return (f) => f[0] === true && !f.slice(1).some(Boolean);
+    case "xor":
+      return (f) => f.filter(Boolean).length % 2 === 1;
+  }
+}
+function flattenOperand(input, tolerance) {
+  const path = isOperandObject(input) ? input.path : input;
+  const fillRule = isOperandObject(input) ? _nullishCoalesce(input.fillRule, () => ( "nonzero")) : "nonzero";
+  const rings = pathToContours(_nullishCoalesce(path, () => ( ""))).map((c) => flattenChain(closeContour(c, true), tolerance)).filter((r) => r.length >= 3 && r.every((p) => Number.isFinite(p[0]) && Number.isFinite(p[1])));
+  return { rings, fillRule };
+}
+function multiToPath(multi, tolerance) {
+  if (multi.length === 0) return [];
+  return toBezierPath(polygonToSvgPath(multi, { curves: "fit", curveTolerance: tolerance, precision: 9 }));
+}
+function reasonOf(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function pathBoolean(operation, operands, options = {}) {
+  if (operands.length === 0) return { path: [], engine: "curve" };
+  try {
+    const arr = buildArrangement(operands, options);
+    return { path: ringsToPath2(extractRings(arr, predicate2(operation))), engine: "curve" };
+  } catch (error) {
+    const reason = reasonOf(error);
+    if (reason === NON_FINITE) return { path: [], engine: "curve", error: reason };
+    if (options.fallback === false) throw error;
+    _optionalChain([options, 'access', _80 => _80.onFallback, 'optionalCall', _81 => _81(reason)]);
+    const tolerance = _nullishCoalesce(options.fallbackTolerance, () => ( 0.05));
+    const multi = polygonBoolean(
+      operation,
+      operands.map((o) => flattenOperand(o, tolerance)),
+      { epsilon: options.epsilon }
+    );
+    return { path: multiToPath(multi, tolerance), engine: "polygon", fallbackReason: reason };
+  }
+}
+var unitePaths = (a, b, options) => pathBoolean("union", [a, b], options).path;
+var intersectPaths = (a, b, options) => pathBoolean("intersection", [a, b], options).path;
+var subtractPaths = (a, b, options) => pathBoolean("difference", [a, b], options).path;
+var excludePaths = (a, b, options) => pathBoolean("xor", [a, b], options).path;
+function dividePaths(operands, options = {}) {
+  if (operands.length === 0) return { pieces: [], engine: "curve" };
+  try {
+    const arr = buildArrangement(operands, options);
+    const signatures = /* @__PURE__ */ new Map();
+    const note = (windings) => {
+      const flags = insideFlags2(windings, arr.fillRules);
+      if (!flags.some(Boolean)) return;
+      const key = flags.map((f) => f ? "1" : "0").join("");
+      if (!signatures.has(key)) signatures.set(key, flags.flatMap((f, k) => f ? [k] : []));
+    };
+    arr.edges.forEach((_, i) => {
+      note(arr.left[i]);
+      note(arr.right[i]);
+    });
+    const pieces = [];
+    for (const key of [...signatures.keys()].sort()) {
+      const rings = extractRings(arr, (flags) => flags.map((f) => f ? "1" : "0").join("") === key);
+      const groups = groupRings(rings).sort((a, b) => b[0].area - a[0].area);
+      for (const group of groups) pieces.push({ path: ringsToPath2(group), operands: signatures.get(key) });
+    }
+    return { pieces, engine: "curve" };
+  } catch (error) {
+    const reason = reasonOf(error);
+    if (reason === NON_FINITE) return { pieces: [], engine: "curve", error: reason };
+    if (options.fallback === false) throw error;
+    _optionalChain([options, 'access', _82 => _82.onFallback, 'optionalCall', _83 => _83(reason)]);
+    const tolerance = _nullishCoalesce(options.fallbackTolerance, () => ( 0.05));
+    const pieces = dividePolygons(
+      operands.map((o) => flattenOperand(o, tolerance)),
+      { epsilon: options.epsilon }
+    ).map((p) => ({ path: multiToPath([p.polygon], tolerance), operands: p.operands }));
+    return { pieces, engine: "polygon", fallbackReason: reason };
+  }
+}
+function normalizeBezierPath(path, fillRule = "nonzero", options = {}) {
+  return pathBoolean("union", [{ path, fillRule }], options).path;
+}
+function bezierPathArea(path, fillRule = "nonzero", options = {}) {
+  const normalized = normalizeBezierPath(path, fillRule, options);
+  let sum = 0;
+  for (const contour of pathToContours(normalized)) sum += contourSignedArea(closeContour(contour, true));
+  return Math.abs(sum);
+}
+function pathBooleanRings(operation, operands, options = {}) {
+  const arr = buildArrangement(operands, options);
+  const rings = extractRings(arr, typeof operation === "function" ? operation : predicate2(operation));
+  const order = rings.map((_, i) => i).sort((a, b) => Math.abs(rings[a].area) - Math.abs(rings[b].area));
+  return rings.map((ring, i) => {
+    const sample = ringSample(ring);
+    let parent = -1;
+    for (const j of order) {
+      if (j === i || Math.abs(rings[j].area) <= Math.abs(ring.area)) continue;
+      if (windingNumber([rings[j].segs], sample) !== 0) {
+        parent = j;
+        break;
+      }
+    }
+    return { segments: ring.segs, area: ring.area, parent };
+  });
+}
+function nestedRingsToPath(rings, keep = () => true) {
+  const contours = [];
+  rings.forEach((r, i) => {
+    if (keep(i)) contours.push({ segments: r.segments, closed: true });
+  });
+  return contoursToPath(contours);
+}
+
+// src/canvas/pathops/stroke.ts
+var DEFAULT_TOLERANCE = 0.01;
+var normal = (t) => [-t[1], t[0]];
+function raise(seg) {
+  if (seg.length !== 3) return [...seg];
+  const [p0, p1, p2] = seg;
+  return [p0, [p0[0] + 2 / 3 * (p1[0] - p0[0]), p0[1] + 2 / 3 * (p1[1] - p0[1])], [p2[0] + 2 / 3 * (p1[0] - p2[0]), p2[1] + 2 / 3 * (p1[1] - p2[1])], p2];
+}
+function isDegenerate(seg, tol) {
+  return seg.every((p) => dist2(p, seg[0]) <= tol);
+}
+function offsetSegment(seg, d, tol, out, depth = 0) {
+  if (seg.length === 2) {
+    const n = normal(segmentTangent(seg, 0));
+    out.push([add2(seg[0], scale(n, d)), add2(seg[1], scale(n, d))]);
+    return;
+  }
+  const c = raise(seg);
+  const t0 = segmentTangent(c, 0);
+  const t1 = segmentTangent(c, 1);
+  const q0 = add2(c[0], scale(normal(t0), d));
+  const q3 = add2(c[3], scale(normal(t1), d));
+  const k0 = segmentCurvature(c, 0);
+  const k1 = segmentCurvature(c, 1);
+  const f0 = Number.isFinite(k0) ? 1 - d * k0 : 1;
+  const f1 = Number.isFinite(k1) ? 1 - d * k1 : 1;
+  const q1 = add2(q0, scale(sub2(c[1], c[0]), f0));
+  const q2 = add2(q3, scale(sub2(c[2], c[3]), f1));
+  const approx = [q0, q1, q2, q3];
+  if (depth < 10) {
+    let err = 0;
+    for (const t of [0.125, 0.25, 0.375, 0.5, 0.625, 0.75, 0.875]) {
+      const target = add2(segmentPoint(c, t), scale(normal(segmentTangent(c, t)), d));
+      err = Math.max(err, segmentNearest(approx, target).distance);
+      if (err > tol) break;
+    }
+    if (err <= tol) {
+      const m = segmentPoint(approx, 0.5);
+      const back = segmentNearest(c, m).distance;
+      err = Math.max(err, Math.abs(back - Math.abs(d)));
+    }
+    if (err > tol) {
+      const [a, b] = splitSegment(c, 0.5);
+      offsetSegment(a, d, tol, out, depth + 1);
+      offsetSegment(b, d, tol, out, depth + 1);
+      return;
+    }
+  }
+  out.push(approx);
+}
+function pushArc(out, center, radius, start, sweep, from, to) {
+  const n = Math.max(1, Math.ceil(Math.abs(sweep) / (Math.PI / 2) - 1e-9));
+  const step = sweep / n;
+  const k = 4 / 3 * Math.tan(step / 4);
+  let prev = from;
+  for (let i = 0; i < n; i++) {
+    const a0 = start + step * i;
+    const a1 = a0 + step;
+    const c0 = Math.cos(a0);
+    const s0 = Math.sin(a0);
+    const c1 = Math.cos(a1);
+    const s1 = Math.sin(a1);
+    const end = i === n - 1 ? to : [center[0] + radius * c1, center[1] + radius * s1];
+    out.push([
+      prev,
+      [center[0] + radius * (c0 - k * s0), center[1] + radius * (s0 + k * c0)],
+      [center[0] + radius * (c1 + k * s1), center[1] + radius * (s1 - k * c1)],
+      end
+    ]);
+    prev = end;
+  }
+}
+function lineTo(out, from, to) {
+  if (!samePoint(from, to)) out.push([from, to]);
+}
+function addJoin(out, p, tin, tout, d, style) {
+  const from = add2(p, scale(normal(tin), d));
+  const to = add2(p, scale(normal(tout), d));
+  const turn = cross(tin, tout);
+  const cos = dot2(tin, tout);
+  if (Math.abs(turn) < 1e-9 && cos > 0) {
+    lineTo(out, from, to);
+    return;
+  }
+  const reversal = Math.abs(turn) < 1e-9 && cos < 0;
+  const inner = !reversal && turn > 0 === d > 0;
+  if (inner) {
+    lineTo(out, from, p);
+    lineTo(out, p, to);
+    return;
+  }
+  const theta = reversal ? d > 0 ? -Math.PI : Math.PI : Math.atan2(turn, cos);
+  if (style.join === "round") {
+    const v = sub2(from, p);
+    pushArc(out, p, Math.abs(d), Math.atan2(v[1], v[0]), theta, from, to);
+    return;
+  }
+  if (style.join === "miter" && !reversal) {
+    const phi = Math.PI - Math.abs(theta);
+    const ratio = 1 / Math.max(Math.sin(phi / 2), 1e-12);
+    if (ratio <= style.miterLimit) {
+      const nin = normal(tin);
+      const nout = normal(tout);
+      const s = d / (1 + dot2(nin, nout));
+      const miter = add2(p, scale(add2(nin, nout), s));
+      lineTo(out, from, miter);
+      lineTo(out, miter, to);
+      return;
+    }
+  }
+  lineTo(out, from, to);
+}
+function offsetChain(segs, d, closed, style, tol) {
+  const out = [];
+  const pen = () => out.length > 0 ? out[out.length - 1][out[out.length - 1].length - 1] : null;
+  for (let i = 0; i < segs.length; i++) {
+    if (i > 0) addJoin(out, segs[i][0], segmentTangent(segs[i - 1], 1), segmentTangent(segs[i], 0), d, style);
+    const pieces = [];
+    offsetSegment(segs[i], d, tol, pieces);
+    for (const piece of pieces) {
+      const at = pen();
+      if (at && !samePoint(at, piece[0])) lineTo(out, at, piece[0]);
+      out.push(piece);
+    }
+  }
+  if (closed && segs.length > 0) {
+    const last = segs[segs.length - 1];
+    addJoin(out, segs[0][0], segmentTangent(last, 1), segmentTangent(segs[0], 0), d, style);
+    const at = pen();
+    if (at && out.length > 0 && !samePoint(at, out[0][0])) lineTo(out, at, out[0][0]);
+  }
+  return out;
+}
+function reverseChain(chain) {
+  return chain.map((s) => [...s].reverse()).reverse();
+}
+function addCap(out, p, t, h, cap) {
+  const n = normal(t);
+  const from = add2(p, scale(n, h));
+  const to = add2(p, scale(n, -h));
+  if (cap === "round") {
+    pushArc(out, p, h, Math.atan2(n[1], n[0]), -Math.PI, from, to);
+  } else if (cap === "square") {
+    const a = add2(from, scale(t, h));
+    const b = add2(to, scale(t, h));
+    lineTo(out, from, a);
+    lineTo(out, a, b);
+    lineTo(out, b, to);
+  } else {
+    lineTo(out, from, to);
+  }
+}
+function dotRings(p, t, h, cap) {
+  if (cap === "butt") return [];
+  const ring = [];
+  addCap(ring, p, t, h, cap);
+  addCap(ring, p, [-t[0], -t[1]], h, cap);
+  return [ring];
+}
+function strokeContour(contour, h, style, tol) {
+  const tiny = Math.max(1e-12, tol * 1e-6);
+  const all = contour.closed ? closeContour(contour) : contour.segments;
+  const segs = all.filter((s) => !isDegenerate(s, tiny));
+  if (segs.length === 0) {
+    const p = _optionalChain([contour, 'access', _84 => _84.segments, 'access', _85 => _85[0], 'optionalAccess', _86 => _86[0]]);
+    return p ? dotRings(p, [1, 0], h, style.cap) : [];
+  }
+  if (contour.closed) {
+    const left2 = offsetChain(segs, h, true, style, tol);
+    const right2 = offsetChain(segs, -h, true, style, tol);
+    return [left2, reverseChain(right2)];
+  }
+  const left = offsetChain(segs, h, false, style, tol);
+  const right = reverseChain(offsetChain(segs, -h, false, style, tol));
+  const ring = [...left];
+  const last = segs[segs.length - 1];
+  addCap(ring, last[last.length - 1], segmentTangent(last, 1), h, style.cap);
+  const joinTo = (p) => {
+    const at = ring[ring.length - 1][ring[ring.length - 1].length - 1];
+    lineTo(ring, at, p);
+  };
+  if (right.length > 0) joinTo(right[0][0]);
+  ring.push(...right);
+  const first = segs[0];
+  const t0 = segmentTangent(first, 0);
+  addCap(ring, first[0], [-t0[0], -t0[1]], h, style.cap);
+  if (ring.length > 0) joinTo(ring[0][0]);
+  return [ring];
+}
+function ringsToPath3(rings) {
+  return contoursToPath(rings.filter((r) => r.length > 0).map((segments) => ({ segments, closed: true })));
+}
+var MAX_DASHES = 2e5;
+var MIN_ENTRY = 1e-6;
+function dashContours(contours, pattern, offset = 0) {
+  if (pattern.length === 0 || pattern.some((v) => !Number.isFinite(v) || v < 0) || !Number.isFinite(offset)) return null;
+  if (!pattern.some((v) => v > MIN_ENTRY)) return null;
+  const pat = pattern.length % 2 === 1 ? [...pattern, ...pattern] : [...pattern];
+  const period = pat.reduce((s, v) => s + v, 0);
+  const chains = contours.map((c) => {
+    const segs = closeContour(c);
+    const lengths = segs.map((s) => segmentLength(s));
+    return { segs, lengths, total: lengths.reduce((s, v) => s + v, 0), closed: c.closed };
+  });
+  const totalLength = chains.reduce((s, c) => s + c.total, 0);
+  if (totalLength / period * pat.length > MAX_DASHES) return null;
+  let off = (offset % period + period) % period;
+  let ix0 = 0;
+  while (off > pat[ix0]) {
+    off -= pat[ix0];
+    ix0 = (ix0 + 1) % pat.length;
+  }
+  const out = { contours: [], dots: [] };
+  for (const chain of chains) {
+    if (chain.segs.length === 0 || !(chain.total > 0)) continue;
+    let ix = ix0;
+    let rem = pat[ix0] - off;
+    let pos = 0;
+    const dashes = [];
+    let guard = 0;
+    while (pos < chain.total && guard++ < MAX_DASHES * 2) {
+      const step = Math.min(rem, chain.total - pos);
+      const on = ix % 2 === 0;
+      if (on) dashes.push({ from: pos, to: pos + step });
+      pos += step;
+      rem -= step;
+      if (rem <= 1e-12) {
+        ix = (ix + 1) % pat.length;
+        rem = pat[ix];
+      }
+    }
+    if (chain.closed && dashes.length > 1) {
+      const first = dashes[0];
+      const last = dashes[dashes.length - 1];
+      if (first.from <= 1e-9 && last.to >= chain.total - 1e-9 && first.to > first.from && last.to > last.from) {
+        dashes.pop();
+        const tail = trimSegments(chain.segs, last.from, chain.total, chain.lengths);
+        const head = trimSegments(chain.segs, 0, first.to, chain.lengths);
+        dashes.shift();
+        out.contours.push({ segments: [...tail, ...head], closed: false });
+      }
+    }
+    for (const dash of dashes) {
+      if (dash.to - dash.from <= 1e-12) {
+        const at = locate(chain.segs, chain.lengths, dash.from);
+        out.dots.push(at);
+        continue;
+      }
+      const segments = trimSegments(chain.segs, dash.from, dash.to, chain.lengths);
+      if (segments.length > 0) out.contours.push({ segments, closed: false });
+    }
+  }
+  return out;
+}
+function locate(segs, lengths, at) {
+  let acc = 0;
+  for (let i = 0; i < segs.length; i++) {
+    if (at <= acc + lengths[i] || i === segs.length - 1) {
+      const piece = trimSegments([segs[i]], 0, Math.max(0, at - acc), [lengths[i]]);
+      const t = piece.length > 0 ? 1 : 0;
+      const point = piece.length > 0 ? piece[piece.length - 1][piece[piece.length - 1].length - 1] : segs[i][0];
+      const tangent = segmentTangent(piece.length > 0 ? piece[piece.length - 1] : segs[i], t);
+      return { point, tangent };
+    }
+    acc += lengths[i];
+  }
+  return { point: segs[0][0], tangent: segmentTangent(segs[0], 0) };
+}
+function deepPoint(rings) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const p of rings[0].flat()) {
+    minX = Math.min(minX, p[0]);
+    maxX = Math.max(maxX, p[0]);
+    minY = Math.min(minY, p[1]);
+    maxY = Math.max(maxY, p[1]);
+  }
+  const w = maxX - minX;
+  const h = maxY - minY;
+  if (!(w > 0 && h > 0)) return null;
+  const tolerance = Math.max(1e-6, 2e-3 * Math.min(w, h));
+  const polys = rings.map((r) => flattenChain(r, tolerance));
+  let best = null;
+  for (const f of [0.5, 0.3, 0.7, 0.15, 0.85]) {
+    const y = minY + h * f;
+    const xs = [];
+    for (const poly of polys) {
+      for (let i = 0; i < poly.length; i++) {
+        const a = poly[i];
+        const b = poly[(i + 1) % poly.length];
+        if (a[1] <= y !== b[1] <= y) xs.push(a[0] + (y - a[1]) / (b[1] - a[1]) * (b[0] - a[0]));
+      }
+    }
+    xs.sort((p, q) => p - q);
+    for (let i = 0; i + 1 < xs.length; i += 2) {
+      const span = xs[i + 1] - xs[i];
+      if (!best || span > best.span) best = { span, p: [(xs[i] + xs[i + 1]) / 2, y] };
+    }
+  }
+  return _nullishCoalesce(_optionalChain([best, 'optionalAccess', _87 => _87.p]), () => ( null));
+}
+function dropSpurious(rings, spurious) {
+  const children = rings.map(() => []);
+  rings.forEach((r, i) => {
+    if (r.parent >= 0) children[r.parent].push(i);
+  });
+  const marked = rings.map((r, i) => spurious([r.segments, ...children[i].map((c) => rings[c].segments)], r));
+  const hasMarkedAncestor = (i) => {
+    for (let k = i; k >= 0; k = rings[k].parent) if (marked[k]) return true;
+    return false;
+  };
+  return nestedRingsToPath(rings, (i) => !hasMarkedAncestor(i));
+}
+function mergeSmoothRuns(path, tolerance) {
+  const contours = pathToContours(path).map((contour) => {
+    const segs = closeContour(contour, true).map((s) => s.length === 3 ? raise(s) : [...s]);
+    const n = segs.length;
+    if (n < 2) return { segments: segs, closed: true };
+    const smooth = (a, b) => {
+      if (a.length !== 4 || b.length !== 4) return false;
+      const ta = segmentTangent(a, 1);
+      const tb = segmentTangent(b, 0);
+      return dot2(ta, tb) > 0.9998 && Math.abs(cross(ta, tb)) < 0.02;
+    };
+    let start = 0;
+    for (let k = 0; k < n; k++) {
+      if (!smooth(segs[(k + n - 1) % n], segs[k])) {
+        start = k;
+        break;
+      }
+    }
+    const ordered = [...segs.slice(start), ...segs.slice(0, start)];
+    const out = [];
+    let i = 0;
+    while (i < ordered.length) {
+      let current = ordered[i];
+      let j = i + 1;
+      while (j < ordered.length && smooth(ordered[j - 1], ordered[j])) {
+        const run = ordered.slice(i, j + 1);
+        const pts = [];
+        run.forEach((s, k) => {
+          for (let q = k === 0 ? 0 : 1; q <= 12; q++) pts.push(segmentPoint(s, q / 12));
+        });
+        const fit = fitCubicRun(pts, tolerance, segmentTangent(run[0], 0), segmentTangent(run[run.length - 1], 1));
+        if (fit.length !== 1) break;
+        const c = fit[0];
+        current = [run[0][0], c.p1, c.p2, run[run.length - 1][3]];
+        j++;
+      }
+      out.push(current);
+      i = j;
+    }
+    return { segments: out, closed: true };
+  });
+  return contoursToPath(contours);
+}
+function joinStyle(join, miterLimit) {
+  return {
+    join: _nullishCoalesce(join, () => ( "miter")),
+    miterLimit: miterLimit !== void 0 && Number.isFinite(miterLimit) ? Math.max(1, miterLimit) : 4
+  };
+}
+function strokeOutlineRings(input, options) {
+  const h = options.width / 2;
+  if (!(h > 0) || !Number.isFinite(h)) return [];
+  const tol = options.tolerance && options.tolerance > 0 ? options.tolerance : DEFAULT_TOLERANCE;
+  const style = { ...joinStyle(options.join, options.miterLimit), cap: _nullishCoalesce(options.cap, () => ( "butt")) };
+  let contours = pathToContours(input);
+  const rings = [];
+  if (options.dash && options.dash.length > 0) {
+    const dashed = dashContours(contours, options.dash, _nullishCoalesce(options.dashOffset, () => ( 0)));
+    if (dashed) {
+      contours = dashed.contours;
+      for (const dot3 of dashed.dots) rings.push(...dotRings(dot3.point, dot3.tangent, h, style.cap));
+    }
+  }
+  for (const contour of contours) rings.push(...strokeContour(contour, h, style, tol));
+  return ringsToPath3(rings);
+}
+function outlineStroke(input, options) {
+  const h = options.width / 2;
+  if (!(h > 0) || !Number.isFinite(h)) return [];
+  let source;
+  try {
+    source = contoursToPath(pathToContours(input));
+  } catch (e6) {
+    return [];
+  }
+  if (source.some((c) => c.type !== "Z" && Object.values(c).some((v) => typeof v === "number" && !Number.isFinite(v)))) return [];
+  const raw = strokeOutlineRings(source, options);
+  if (raw.length === 0) return [];
+  const tol = options.tolerance && options.tolerance > 0 ? options.tolerance : DEFAULT_TOLERANCE;
+  const sourceContours = pathToContours(source);
+  const operand = { path: raw, fillRule: "nonzero" };
+  try {
+    const rings = pathBooleanRings("union", [operand], options);
+    const cleaned = dropSpurious(rings, (face, ring) => {
+      if (ring.area >= 0) return false;
+      const p = deepPoint(face);
+      return !!p && distanceToBezierPath(sourceContours, p) < h * (1 - 1e-4) - 1e-6;
+    });
+    return mergeSmoothRuns(cleaned, tol);
+  } catch (e7) {
+    return pathBoolean("union", [operand], options).path;
+  }
+}
+function offsetPath(input, distance, options = {}) {
+  if (!Number.isFinite(distance)) return [];
+  const contours = pathToContours(input);
+  if (contours.some((c) => c.segments.some((s) => s.some((p) => !Number.isFinite(p[0]) || !Number.isFinite(p[1]))))) return [];
+  const closed = contours.filter((c) => c.closed && c.segments.length > 0);
+  const open = contours.filter((c) => !c.closed && c.segments.length > 0);
+  const fillRule = _nullishCoalesce(options.fillRule, () => ( "nonzero"));
+  const fill = { path: contoursToPath(closed), fillRule };
+  const d = Math.abs(distance);
+  const tol = options.tolerance && options.tolerance > 0 ? options.tolerance : DEFAULT_TOLERANCE;
+  if (d === 0) return pathBoolean("union", [fill], options).path;
+  const strokeOptions = { width: 2 * d, join: _nullishCoalesce(options.join, () => ( "miter")), miterLimit: options.miterLimit, cap: "butt", tolerance: tol };
+  const ring = { path: strokeOutlineRings(contoursToPath(closed), strokeOptions), fillRule: "nonzero" };
+  const openRing = {
+    path: distance > 0 ? strokeOutlineRings(contoursToPath(open), strokeOptions) : [],
+    fillRule: "nonzero"
+  };
+  const grow = distance > 0;
+  const operands = [fill, ring, openRing];
+  try {
+    const rings = pathBooleanRings(grow ? (m) => m[0] || m[1] || m[2] : (m) => m[0] && !m[1], operands, options);
+    const sourceContours = contours;
+    const cleaned = dropSpurious(rings, (face, r) => {
+      if (grow ? r.area >= 0 : r.area <= 0) return false;
+      const p = deepPoint(face);
+      return !!p && distanceToBezierPath(sourceContours, p) < d * (1 - 1e-4) - 1e-6;
+    });
+    return mergeSmoothRuns(cleaned, tol);
+  } catch (e8) {
+    return grow ? pathBoolean("union", operands, options).path : pathBoolean("difference", [fill, ring], options).path;
+  }
+}
+
+// src/canvas/shapeNodes.ts
+var SHAPE_DATA_KEY = "shape";
+var SHAPE_NODE_TYPE = "shape";
+var SHAPE_OPERATIONS = ["unite", "intersect", "subtract", "exclude", "divide"];
+var BOOLEAN_FOR = {
+  unite: "union",
+  intersect: "intersection",
+  subtract: "difference",
+  exclude: "xor"
+};
+function isShapeNode(node) {
+  return !!node && isShapeDescription(_optionalChain([node, 'access', _88 => _88.data, 'optionalAccess', _89 => _89[SHAPE_DATA_KEY]]));
+}
+function getNodeShape(node) {
+  const shape = _optionalChain([node, 'optionalAccess', _90 => _90.data, 'optionalAccess', _91 => _91[SHAPE_DATA_KEY]]);
+  return isShapeDescription(shape) ? shape : null;
+}
+function shapeNodeToPolygon(node, lookup, options = {}) {
+  const shape = getNodeShape(node);
+  if (!shape) return null;
+  const size = getNodeSize(node, options);
+  const origin = node.parentId && lookup ? getAbsolutePosition(node, lookup) : node.position;
+  const { rings, fillRule } = shapeToPolygon(shape, size, { tolerance: options.tolerance });
+  return {
+    rings: rings.map((ring) => ring.map(([x, y]) => [x + origin.x, y + origin.y])),
+    fillRule
+  };
+}
+function shapeToBezierPath(shape, size) {
+  const { width: w, height: h } = size;
+  if (!(w > 0) || !(h > 0)) return { path: [], fillRule: "nonzero" };
+  const svg = getShapeSvg({ ...shape, rotation: 0 }, size);
+  let path = toBezierPath(svg.d);
+  if (shape.kind === "path" && shape.viewBox) {
+    const vb = shape.viewBox;
+    if (vb.length === 4 && vb.every(Number.isFinite) && vb[2] > 0 && vb[3] > 0) {
+      const sx = w / vb[2];
+      const sy = h / vb[3];
+      path = transformBezierPath(path, [sx, 0, 0, sy, -vb[0] * sx, -vb[1] * sy]);
+    }
+  }
+  const deg = _nullishCoalesce(shape.rotation, () => ( 0));
+  if (deg && Number.isFinite(deg)) {
+    const rad = deg * Math.PI / 180;
+    const cos = Math.cos(rad);
+    const sin = Math.sin(rad);
+    const cx = w / 2;
+    const cy = h / 2;
+    const m = [cos, sin, -sin, cos, cx - cx * cos + cy * sin, cy - cx * sin - cy * cos];
+    path = transformBezierPath(path, m);
+  }
+  return { path, fillRule: svg.fillRule };
+}
+function shapeNodeToBezierPath(node, lookup, options = {}) {
+  const shape = getNodeShape(node);
+  if (!shape) return null;
+  const size = getNodeSize(node, options);
+  const origin = node.parentId && lookup ? getAbsolutePosition(node, lookup) : node.position;
+  const { path, fillRule } = shapeToBezierPath(shape, size);
+  return { path: transformBezierPath(path, [1, 0, 0, 1, origin.x, origin.y]), fillRule };
+}
+var idCounter = 0;
+function defaultId2(index) {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") return crypto.randomUUID();
+  idCounter += 1;
+  return `shape-${Date.now().toString(36)}-${idCounter}-${index}`;
+}
+function stackOrder(nodes, ids) {
+  return nodes.map((node, index) => ({ node, index, z: typeof node.zIndex === "number" ? node.zIndex : 0 })).filter((entry) => ids.has(entry.node.id)).sort((a, b) => a.z - b.z || a.index - b.index).map((entry) => entry.node);
+}
+function canCombineShapeNodes(nodes, ids) {
+  const idSet = new Set(ids);
+  const shapes = nodes.filter((n) => idSet.has(n.id) && isShapeNode(n));
+  if (shapes.some((n) => isLocked(n))) return { ok: false, reason: "locked" };
+  if (shapes.length < 2) return { ok: false, reason: "too-few" };
+  return { ok: true, shapeIds: shapes.map((n) => n.id) };
+}
+function combineShapeNodes(nodes, ids, operation, options = {}) {
+  const idList = [...ids];
+  const check = canCombineShapeNodes(nodes, idList);
+  if (!check.ok) return { ok: false, operation, reason: check.reason };
+  const lookup = createNodeLookup(nodes);
+  const shapeIds = new Set(check.shapeIds);
+  const ordered = stackOrder(nodes, shapeIds);
+  const parentIds = new Set(ordered.map((n) => _nullishCoalesce(n.parentId, () => ( ""))));
+  const sharedParent = parentIds.size === 1 ? ordered[0].parentId : void 0;
+  const parentOrigin = sharedParent && lookup.get(sharedParent) ? getAbsolutePosition(lookup.get(sharedParent), lookup) : { x: 0, y: 0 };
+  const pickSource = () => {
+    const style = _nullishCoalesce(options.styleFrom, () => ( "bottom"));
+    if (style === "top") return ordered[ordered.length - 1];
+    if (style === "first") {
+      const first = idList.find((id) => shapeIds.has(id));
+      return first && lookup.get(first) || ordered[0];
+    }
+    if (typeof style === "object") return shapeIds.has(style.id) && lookup.get(style.id) || ordered[0];
+    return ordered[0];
+  };
+  const createId = _nullishCoalesce(options.createId, () => ( defaultId2));
+  const buildOptions = {
+    precision: options.precision,
+    nodeType: options.nodeType,
+    select: options.select,
+    parentOrigin,
+    sharedParent
+  };
+  const engine = _nullishCoalesce(options.engine, () => ( (options.curves === "lines" ? "polygon" : "curve")));
+  const created = [];
+  let report = { engine: "curve" };
+  if (engine === "curve") {
+    const operands = ordered.map((node) => shapeNodeToBezierPath(node, lookup, options));
+    const pathOptions = { epsilon: options.epsilon, onFallback: options.onFallback, fallbackTolerance: options.tolerance };
+    if (operation === "divide") {
+      const result = dividePaths(operands, pathOptions);
+      report = result;
+      for (const piece of result.pieces) {
+        const source = ordered[piece.operands[piece.operands.length - 1]];
+        const node = buildPathNode(piece.path, source, createId(created.length), buildOptions);
+        if (node) created.push(node);
+      }
+    } else {
+      const result = pathBoolean(BOOLEAN_FOR[operation], operands, pathOptions);
+      report = result;
+      const node = buildPathNode(result.path, pickSource(), createId(0), buildOptions);
+      if (node) created.push(node);
+    }
+  } else {
+    report = { engine: "polygon" };
+    const operands = ordered.map((node) => shapeNodeToPolygon(node, lookup, options));
+    const write = (polygon) => toBezierPath(
+      polygonToSvgPath(polygon, {
+        precision: 9,
+        simplify: options.simplify,
+        curves: _nullishCoalesce(options.curves, () => ( "fit")),
+        curveTolerance: _nullishCoalesce(_nullishCoalesce(options.curveTolerance, () => ( options.tolerance)), () => ( 0.25)),
+        cornerAngleDeg: options.cornerAngleDeg
+      })
+    );
+    if (operation === "divide") {
+      for (const piece of dividePolygons(operands, { epsilon: options.epsilon })) {
+        const source = ordered[piece.operands[piece.operands.length - 1]];
+        const node = buildPathNode(write([piece.polygon]), source, createId(created.length), buildOptions);
+        if (node) created.push(node);
+      }
+    } else {
+      const result = polygonBoolean(BOOLEAN_FOR[operation], operands, { epsilon: options.epsilon });
+      const node = buildPathNode(write(result), pickSource(), createId(0), buildOptions);
+      if (node) created.push(node);
+    }
+  }
+  if (created.length === 0) return { ok: false, operation, reason: "empty" };
+  const done = {
+    ok: true,
+    operation,
+    removeIds: ordered.map((n) => n.id),
+    nodes: created,
+    engine: report.engine
+  };
+  if (report.fallbackReason) done.fallbackReason = report.fallbackReason;
+  return done;
+}
+function buildPathNode(path, source, id, options) {
+  const bounds = bezierPathBounds(path);
+  if (!bounds) return null;
+  const width = bounds.maxX - bounds.minX;
+  const height = bounds.maxY - bounds.minY;
+  if (!(width > 0) || !(height > 0)) return null;
+  const d = bezierPathToSvg(path, { precision: _nullishCoalesce(options.precision, () => ( 3)), offset: { x: -bounds.minX, y: -bounds.minY } });
+  if (!d) return null;
+  const sourceShape = getNodeShape(source);
+  const shape = {
+    kind: "path",
+    d,
+    viewBox: [0, 0, roundSize(width), roundSize(height)],
+    fillRule: "nonzero"
+  };
+  for (const key of ["fill", "stroke", "strokeWidth", "opacity"]) {
+    if (sourceShape[key] !== void 0) shape[key] = sourceShape[key];
+  }
+  for (const [key, value] of Object.entries(_nullishCoalesce(options.paint, () => ( {})))) {
+    if (value === null) delete shape[key];
+    else if (value !== void 0) shape[key] = value;
+  }
+  const {
+    [LOCKED_DATA_KEY]: _locked,
+    [LOCKED_PREVIOUS_FLAGS_KEY]: _previous,
+    ...data
+  } = _nullishCoalesce(source.data, () => ( {}));
+  const {
+    measured: _measured,
+    selected: _selected,
+    dragging: _dragging,
+    positionAbsolute: _positionAbsolute,
+    internals: _internals,
+    parentId: _parentId,
+    ...rest
+  } = source;
+  const node = {
+    ...rest,
+    id,
+    position: { x: bounds.minX - options.parentOrigin.x, y: bounds.minY - options.parentOrigin.y },
+    width,
+    height,
+    data: { ...data, [SHAPE_DATA_KEY]: shape }
+  };
+  if (options.sharedParent) node.parentId = options.sharedParent;
+  if (options.nodeType !== void 0) node.type = options.nodeType;
+  if (source.style) node.style = withStyleSize(source.style, { width, height });
+  if (options.select !== false) node.selected = true;
+  return node;
+}
+function roundSize(value) {
+  return Math.round(value * 1e3) / 1e3;
+}
+function applyShapeCombination(nodes, change, options = {}) {
+  const remove = new Set(change.removeIds);
+  const insertAt = nodes.findIndex((n) => remove.has(n.id));
+  const deselect = options.deselect !== false && change.nodes.some((n) => n.selected);
+  const out = [];
+  nodes.forEach((node, index) => {
+    if (index === insertAt) out.push(...change.nodes);
+    if (remove.has(node.id)) return;
+    out.push(deselect && node.selected ? { ...node, selected: false } : node);
+  });
+  if (insertAt === -1) out.push(...change.nodes);
+  return out;
+}
+function revertShapeCombination(nodes, change, previous) {
+  const created = new Set(change.nodes.map((n) => n.id));
+  const removed = new Set(change.removeIds);
+  const out = nodes.filter((n) => !created.has(n.id));
+  previous.forEach((node, index) => {
+    if (!removed.has(node.id) || out.some((n) => n.id === node.id)) return;
+    out.splice(Math.min(index, out.length), 0, node);
+  });
+  return out;
+}
+var INVISIBLE_PAINT = /* @__PURE__ */ new Set(["none", "transparent"]);
+function hasVisibleStroke(shape) {
+  if (!shape || typeof shape.stroke !== "string" || INVISIBLE_PAINT.has(shape.stroke.trim().toLowerCase())) return false;
+  const width = _nullishCoalesce(shape.strokeWidth, () => ( 1));
+  return Number.isFinite(width) && width > 0;
+}
+function hasVisibleFill(shape) {
+  return shape.fill === void 0 || !INVISIBLE_PAINT.has(String(shape.fill).trim().toLowerCase());
+}
+function shapeTargets(nodes, ids) {
+  const idSet = new Set(ids);
+  return nodes.filter((n) => idSet.has(n.id) && isShapeNode(n));
+}
+function canOffsetShapeNodes(nodes, ids) {
+  const shapes = shapeTargets(nodes, ids);
+  if (shapes.some((n) => isLocked(n))) return { ok: false, reason: "locked" };
+  if (shapes.length === 0) return { ok: false, reason: "no-shapes" };
+  return { ok: true, shapeIds: shapes.map((n) => n.id) };
+}
+function canOutlineShapeNodeStrokes(nodes, ids) {
+  const shapes = shapeTargets(nodes, ids);
+  if (shapes.some((n) => isLocked(n))) return { ok: false, reason: "locked" };
+  if (shapes.length === 0) return { ok: false, reason: "no-shapes" };
+  const stroked = shapes.filter((n) => hasVisibleStroke(getNodeShape(n)));
+  if (stroked.length === 0) return { ok: false, reason: "no-stroke" };
+  return { ok: true, shapeIds: stroked.map((n) => n.id) };
+}
+function editPlacement(node, lookup) {
+  const parent = node.parentId ? lookup.get(node.parentId) : void 0;
+  return {
+    parentOrigin: parent ? getAbsolutePosition(parent, lookup) : { x: 0, y: 0 },
+    sharedParent: parent ? node.parentId : void 0
+  };
+}
+function finishEdit(operation, replacements) {
+  if (replacements.length === 0) return { ok: false, operation, reason: "empty" };
+  return {
+    ok: true,
+    operation,
+    removeIds: replacements.map((r) => r.id),
+    nodes: replacements.flatMap((r) => r.nodes),
+    replacements
+  };
+}
+function offsetShapeNodes(nodes, ids, distance, options = {}) {
+  const operation = "offset";
+  if (!Number.isFinite(distance)) return { ok: false, operation, reason: "invalid" };
+  const check = canOffsetShapeNodes(nodes, ids);
+  if (!check.ok) return { ok: false, operation, reason: check.reason };
+  const lookup = createNodeLookup(nodes);
+  const createId = _nullishCoalesce(options.createId, () => ( defaultId2));
+  let index = 0;
+  const replacements = [];
+  for (const id of check.shapeIds) {
+    const node = lookup.get(id);
+    const outline = shapeNodeToBezierPath(node, lookup, options);
+    const path = offsetPath(outline.path, distance, {
+      join: options.join,
+      miterLimit: options.miterLimit,
+      fillRule: outline.fillRule,
+      tolerance: options.tolerance,
+      epsilon: options.epsilon,
+      onFallback: options.onFallback
+    });
+    const created = buildPathNode(path, node, createId(index), {
+      ...editPlacement(node, lookup),
+      precision: options.precision,
+      nodeType: options.nodeType,
+      select: options.select
+    });
+    if (!created) continue;
+    index++;
+    const original = { ...node, selected: false };
+    replacements.push({ id, nodes: options.keepOriginal ? [created, original] : [created] });
+  }
+  return finishEdit(operation, replacements);
+}
+function outlineShapeNodeStrokes(nodes, ids, options = {}) {
+  const operation = "outlineStroke";
+  if (options.width !== void 0 && !(Number.isFinite(options.width) && options.width > 0)) {
+    return { ok: false, operation, reason: "invalid" };
+  }
+  const check = canOutlineShapeNodeStrokes(nodes, ids);
+  if (!check.ok) return { ok: false, operation, reason: check.reason };
+  const lookup = createNodeLookup(nodes);
+  const createId = _nullishCoalesce(options.createId, () => ( defaultId2));
+  let index = 0;
+  const replacements = [];
+  for (const id of check.shapeIds) {
+    const node = lookup.get(id);
+    const shape = getNodeShape(node);
+    const outline = shapeNodeToBezierPath(node, lookup, options);
+    const path = outlineStroke(outline.path, {
+      width: _nullishCoalesce(_nullishCoalesce(options.width, () => ( shape.strokeWidth)), () => ( 1)),
+      join: options.join,
+      cap: options.cap,
+      miterLimit: options.miterLimit,
+      dash: options.dash,
+      dashOffset: options.dashOffset,
+      tolerance: options.tolerance,
+      epsilon: options.epsilon,
+      onFallback: options.onFallback
+    });
+    const created = buildPathNode(path, node, createId(index), {
+      ...editPlacement(node, lookup),
+      precision: options.precision,
+      nodeType: options.nodeType,
+      select: options.select,
+      paint: { fill: shape.stroke, stroke: null, strokeWidth: null }
+    });
+    if (!created) continue;
+    index++;
+    const replacement = [];
+    if (options.keepFill !== false && hasVisibleFill(shape)) {
+      const { stroke: _stroke, strokeWidth: _width, ...rest } = shape;
+      replacement.push({
+        ...node,
+        selected: options.select === false ? node.selected : false,
+        data: { ...node.data, [SHAPE_DATA_KEY]: rest }
+      });
+    }
+    replacement.push(created);
+    replacements.push({ id, nodes: replacement });
+  }
+  return finishEdit(operation, replacements);
+}
+function applyShapeReplacement(nodes, change, options = {}) {
+  const byId = new Map(change.replacements.map((r) => [r.id, r.nodes]));
+  const created = new Set(change.replacements.flatMap((r) => r.nodes.map((n) => n.id)));
+  const deselect = options.deselect !== false && change.replacements.some((r) => r.nodes.some((n) => n.selected));
+  const out = [];
+  for (const node of nodes) {
+    const replacement = byId.get(node.id);
+    if (replacement) {
+      out.push(...replacement);
+      continue;
+    }
+    if (created.has(node.id)) continue;
+    out.push(deselect && node.selected ? { ...node, selected: false } : node);
+  }
+  return out;
+}
+
+// src/canvas/resizeSnap.ts
+var RESIZE_HANDLES = [
+  "top-left",
+  "top",
+  "top-right",
+  "right",
+  "bottom-right",
+  "bottom",
+  "bottom-left",
+  "left"
+];
+function resizeHandleAxes(handle) {
+  const x = handle.includes("left") ? -1 : handle.includes("right") ? 1 : 0;
+  const y = handle.includes("top") ? -1 : handle.includes("bottom") ? 1 : 0;
+  return { x, y };
+}
+function inferResizeHandle(start, next, eps = 1e-6) {
+  const moved = (a, b) => Math.abs(a - b) > eps;
+  const left = moved(start.x, next.x);
+  const right = moved(start.x + start.width, next.x + next.width);
+  const top = moved(start.y, next.y);
+  const bottom = moved(start.y + start.height, next.y + next.height);
+  const h = left ? "left" : right ? "right" : "";
+  const v = top ? "top" : bottom ? "bottom" : "";
+  if (h && v) return `${v}-${h}`;
+  return h || v || null;
+}
+function within(axis, v, tolerance) {
+  const { values } = axis;
+  let lo = 0;
+  let hi = values.length;
+  while (lo < hi) {
+    const mid = lo + hi >>> 1;
+    if (values[mid] < v - tolerance) lo = mid + 1;
+    else hi = mid;
+  }
+  const out = [];
+  for (let i = lo; i < values.length && values[i] <= v + tolerance; i++) out.push(values[i]);
+  return out;
+}
+function matching(axis, v, eps) {
+  const { values, rects } = axis;
+  const out = [];
+  for (let i = 0; i < values.length; i++) if (Math.abs(values[i] - v) <= eps) out.push(rects[i]);
+  return out;
+}
+function snapResize(rect, handle, targets, options = {}) {
+  const index = Array.isArray(targets) ? createGuideIndex(targets) : targets;
+  const zoom = options.zoom && options.zoom > 0 ? options.zoom : 1;
+  const tolerance = (_nullishCoalesce(options.threshold, () => ( 6))) / zoom;
+  const eps = 0.5 / zoom;
+  const useEdges = options.edges !== false;
+  const useCentres = options.centres !== false;
+  const grid = _nullishCoalesce(options.gridSize, () => ( 0));
+  const axes = resizeHandleAxes(handle);
+  const unchanged = { rect: { ...rect }, guides: [], snappedX: false, snappedY: false, changed: false };
+  if (![rect.x, rect.y, rect.width, rect.height].every(Number.isFinite)) return unchanged;
+  const x0 = rect.x;
+  const x1 = rect.x + rect.width;
+  const y0 = rect.y;
+  const y1 = rect.y + rect.height;
+  const bestHit = (horizontal) => {
+    const dir = horizontal ? axes.x : axes.y;
+    if (dir === 0) return null;
+    const moving = horizontal ? dir < 0 ? x0 : x1 : dir < 0 ? y0 : y1;
+    const fixed = horizontal ? dir < 0 ? x1 : x0 : dir < 0 ? y1 : y0;
+    const min = _nullishCoalesce((horizontal ? options.minWidth : options.minHeight), () => ( 0));
+    const valid = (t) => {
+      const size = dir < 0 ? fixed - t : t - fixed;
+      return Number.isFinite(size) && size > 1e-9 && size >= min;
+    };
+    let best = null;
+    const consider = (values, kind) => {
+      for (const t of values) {
+        if (!valid(t)) continue;
+        if (!best || Math.abs(t - moving) < Math.abs(best.value - moving)) best = { value: t, kind };
+      }
+    };
+    if (useEdges) consider(within(horizontal ? index.edgeX : index.edgeY, moving, tolerance), "edge");
+    if (useCentres) consider(within(horizontal ? index.centreX : index.centreY, moving, tolerance), "centre");
+    if (!best && grid > 0) {
+      const origin = horizontal ? _nullishCoalesce(_optionalChain([options, 'access', _92 => _92.gridOrigin, 'optionalAccess', _93 => _93.x]), () => ( 0)) : _nullishCoalesce(_optionalChain([options, 'access', _94 => _94.gridOrigin, 'optionalAccess', _95 => _95.y]), () => ( 0));
+      consider([snapToGrid(moving, grid, origin)], "grid");
+    }
+    return best;
+  };
+  let nx0 = x0;
+  let nx1 = x1;
+  let ny0 = y0;
+  let ny1 = y1;
+  const setEdge = (horizontal, value) => {
+    const dir = horizontal ? axes.x : axes.y;
+    if (horizontal) {
+      if (dir < 0) nx0 = value;
+      else nx1 = value;
+    } else if (dir < 0) ny0 = value;
+    else ny1 = value;
+  };
+  let hitX = bestHit(true);
+  let hitY = bestHit(false);
+  const ratio = rect.height > 0 ? rect.width / rect.height : 0;
   if (options.keepAspectRatio && ratio > 0 && (hitX || hitY)) {
     if (axes.x !== 0 && axes.y !== 0) {
-      const dist2 = (h, horizontal) => h ? Math.abs(h.value - (horizontal ? axes.x < 0 ? x0 : x1 : axes.y < 0 ? y0 : y1)) : Infinity;
-      const useX = dist2(hitX, true) <= dist2(hitY, false);
+      const dist3 = (h, horizontal) => h ? Math.abs(h.value - (horizontal ? axes.x < 0 ? x0 : x1 : axes.y < 0 ? y0 : y1)) : Infinity;
+      const useX = dist3(hitX, true) <= dist3(hitY, false);
       if (useX && hitX) {
         setEdge(true, hitX.value);
         const height = (nx1 - nx0) / ratio;
@@ -3403,25 +5696,25 @@ function clampLayoutSize(value, min, max) {
 }
 var finite = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
 function getAutoLayout(node) {
-  const layout2 = _optionalChain([node, 'optionalAccess', _79 => _79.data, 'optionalAccess', _80 => _80[AUTO_LAYOUT_DATA_KEY]]);
+  const layout2 = _optionalChain([node, 'optionalAccess', _96 => _96.data, 'optionalAccess', _97 => _97[AUTO_LAYOUT_DATA_KEY]]);
   return layout2 && typeof layout2 === "object" && MODES.has(layout2.mode) ? layout2 : void 0;
 }
 function isAutoLayoutFrame(node) {
   return getAutoLayout(node) !== void 0;
 }
 function getChildLayout(node) {
-  const child = _optionalChain([node, 'optionalAccess', _81 => _81.data, 'optionalAccess', _82 => _82[CHILD_LAYOUT_DATA_KEY]]);
+  const child = _optionalChain([node, 'optionalAccess', _98 => _98.data, 'optionalAccess', _99 => _99[CHILD_LAYOUT_DATA_KEY]]);
   return child && typeof child === "object" ? child : {};
 }
 function getLayoutSizing(node, axis) {
-  const value = _nullishCoalesce(_optionalChain([getChildLayout, 'call', _83 => _83(node), 'access', _84 => _84.sizing, 'optionalAccess', _85 => _85[axis]]), () => ( _optionalChain([getAutoLayout, 'call', _86 => _86(node), 'optionalAccess', _87 => _87.sizing, 'optionalAccess', _88 => _88[axis]])));
+  const value = _nullishCoalesce(_optionalChain([getChildLayout, 'call', _100 => _100(node), 'access', _101 => _101.sizing, 'optionalAccess', _102 => _102[axis]]), () => ( _optionalChain([getAutoLayout, 'call', _103 => _103(node), 'optionalAccess', _104 => _104.sizing, 'optionalAccess', _105 => _105[axis]])));
   return value === "hug" || value === "fill" ? value : "fixed";
 }
 function limitsOf(node) {
   const child = getChildLayout(node);
   const layout2 = getAutoLayout(node);
-  const min = _nullishCoalesce(_nullishCoalesce(child.min, () => ( _optionalChain([layout2, 'optionalAccess', _89 => _89.min]))), () => ( {}));
-  const max = _nullishCoalesce(_nullishCoalesce(child.max, () => ( _optionalChain([layout2, 'optionalAccess', _90 => _90.max]))), () => ( {}));
+  const min = _nullishCoalesce(_nullishCoalesce(child.min, () => ( _optionalChain([layout2, 'optionalAccess', _106 => _106.min]))), () => ( {}));
+  const max = _nullishCoalesce(_nullishCoalesce(child.max, () => ( _optionalChain([layout2, 'optionalAccess', _107 => _107.max]))), () => ( {}));
   return { minW: min.width, maxW: max.width, minH: min.height, maxH: max.height };
 }
 function resolvePadding(padding) {
@@ -3433,21 +5726,21 @@ function resolvePadding(padding) {
   else sides = [0, 0, 0, 0];
   return sides.map((p) => Math.max(finite(p), 0));
 }
-var LayoutState = (_class6 = class {
-  __init15() {this.boxes = /* @__PURE__ */ new Map()}
+var LayoutState = (_class7 = class {
+  __init17() {this.boxes = /* @__PURE__ */ new Map()}
   
-  __init16() {this.visiting = /* @__PURE__ */ new Set()}
-  __init17() {this.original = /* @__PURE__ */ new Map()}
-  constructor(nodes, options = {}) {;_class6.prototype.__init15.call(this);_class6.prototype.__init16.call(this);_class6.prototype.__init17.call(this);
+  __init18() {this.visiting = /* @__PURE__ */ new Set()}
+  __init19() {this.original = /* @__PURE__ */ new Map()}
+  constructor(nodes, options = {}) {;_class7.prototype.__init17.call(this);_class7.prototype.__init18.call(this);_class7.prototype.__init19.call(this);
     this.measure = _nullishCoalesce(options.measure, () => ( {}));
     for (const node of nodes) {
-      const size = _nullishCoalesce(_optionalChain([this, 'access', _91 => _91.measure, 'access', _92 => _92.size, 'optionalCall', _93 => _93(node)]), () => ( getNodeSize(node, options.rectOptions)));
+      const size = _nullishCoalesce(_optionalChain([this, 'access', _108 => _108.measure, 'access', _109 => _109.size, 'optionalCall', _110 => _110(node)]), () => ( getNodeSize(node, options.rectOptions)));
       const box = {
         id: node.id,
         node,
         parent: node.parentId,
-        x: finite(_optionalChain([node, 'access', _94 => _94.position, 'optionalAccess', _95 => _95.x])),
-        y: finite(_optionalChain([node, 'access', _96 => _96.position, 'optionalAccess', _97 => _97.y])),
+        x: finite(_optionalChain([node, 'access', _111 => _111.position, 'optionalAccess', _112 => _112.x])),
+        y: finite(_optionalChain([node, 'access', _113 => _113.position, 'optionalAccess', _114 => _114.y])),
         w: finite(size.width),
         h: finite(size.height),
         kids: []
@@ -3456,7 +5749,7 @@ var LayoutState = (_class6 = class {
       this.original.set(node.id, { x: box.x, y: box.y, w: box.w, h: box.h });
     }
     for (const node of nodes) {
-      if (node.parentId && node.parentId !== node.id) _optionalChain([this, 'access', _98 => _98.boxes, 'access', _99 => _99.get, 'call', _100 => _100(node.parentId), 'optionalAccess', _101 => _101.kids, 'access', _102 => _102.push, 'call', _103 => _103(node.id)]);
+      if (node.parentId && node.parentId !== node.id) _optionalChain([this, 'access', _115 => _115.boxes, 'access', _116 => _116.get, 'call', _117 => _117(node.parentId), 'optionalAccess', _118 => _118.kids, 'access', _119 => _119.push, 'call', _120 => _120(node.id)]);
     }
   }
   updates() {
@@ -3484,7 +5777,7 @@ var LayoutState = (_class6 = class {
   ancestors(id) {
     const out = [];
     const seen = /* @__PURE__ */ new Set([id]);
-    let parent = _optionalChain([this, 'access', _104 => _104.boxes, 'access', _105 => _105.get, 'call', _106 => _106(id), 'optionalAccess', _107 => _107.parent]);
+    let parent = _optionalChain([this, 'access', _121 => _121.boxes, 'access', _122 => _122.get, 'call', _123 => _123(id), 'optionalAccess', _124 => _124.parent]);
     while (parent && !seen.has(parent) && this.boxes.has(parent)) {
       out.push(parent);
       seen.add(parent);
@@ -3492,7 +5785,7 @@ var LayoutState = (_class6 = class {
     }
     return out;
   }
-}, _class6);
+}, _class7);
 function setSize(s, id, w, h) {
   const b = s.boxes.get(id);
   if (!b) return;
@@ -3522,10 +5815,10 @@ function fitHugText(s, id) {
   if (getLayoutSizing(b.node, "width") === "hug") {
     const w = clampLayoutSize(natural.width, minW, maxW);
     const limited = Math.abs(w - natural.width) > EPS;
-    const h = limited ? _nullishCoalesce(_optionalChain([s, 'access', _108 => _108.measure, 'access', _109 => _109.textHeight, 'optionalCall', _110 => _110(b.node, w)]), () => ( natural.height)) : natural.height;
+    const h = limited ? _nullishCoalesce(_optionalChain([s, 'access', _125 => _125.measure, 'access', _126 => _126.textHeight, 'optionalCall', _127 => _127(b.node, w)]), () => ( natural.height)) : natural.height;
     setSize(s, id, w, h);
   } else if (getLayoutSizing(b.node, "height") === "hug") {
-    setSize(s, id, b.w, _nullishCoalesce(_optionalChain([s, 'access', _111 => _111.measure, 'access', _112 => _112.textHeight, 'optionalCall', _113 => _113(b.node, b.w)]), () => ( b.h)));
+    setSize(s, id, b.w, _nullishCoalesce(_optionalChain([s, 'access', _128 => _128.measure, 'access', _129 => _129.textHeight, 'optionalCall', _130 => _130(b.node, b.w)]), () => ( b.h)));
   }
 }
 function enforceLimits(s, id) {
@@ -3543,7 +5836,7 @@ function itemBaseline(s, id, depth) {
   const b = s.boxes.get(id);
   if (!b) return void 0;
   if (isText(s, b)) {
-    const v = _optionalChain([s, 'access', _114 => _114.measure, 'access', _115 => _115.textBaseline, 'optionalCall', _116 => _116(b.node)]);
+    const v = _optionalChain([s, 'access', _131 => _131.measure, 'access', _132 => _132.textBaseline, 'optionalCall', _133 => _133(b.node)]);
     return typeof v === "number" && Number.isFinite(v) ? v : void 0;
   }
   const layout2 = getAutoLayout(b.node);
@@ -3558,7 +5851,7 @@ function resizeChild(s, id, w, h) {
   const b = s.boxes.get(id);
   if (!b) return;
   if (isText(s, b) && getLayoutSizing(b.node, "height") === "hug") {
-    setSize(s, id, w, _nullishCoalesce(_optionalChain([s, 'access', _117 => _117.measure, 'access', _118 => _118.textHeight, 'optionalCall', _119 => _119(b.node, w)]), () => ( h)));
+    setSize(s, id, w, _nullishCoalesce(_optionalChain([s, 'access', _134 => _134.measure, 'access', _135 => _135.textHeight, 'optionalCall', _136 => _136(b.node, w)]), () => ( h)));
     return;
   }
   const ow = b.w;
@@ -3667,7 +5960,7 @@ function layoutFrameInner(s, frame) {
     const b = s.boxes.get(id);
     return horizontal ? [b.w, b.h] : [b.h, b.w];
   };
-  const resize = (it, main, cross) => resizeChild(s, it.id, horizontal ? main : cross, horizontal ? cross : main);
+  const resize = (it, main, cross2) => resizeChild(s, it.id, horizontal ? main : cross2, horizontal ? cross2 : main);
   if (!wraps) {
     for (const it of items) {
       if (!it.fillCross || it.fillMain) continue;
@@ -3681,13 +5974,13 @@ function layoutFrameInner(s, frame) {
     let used = 0;
     items.forEach((it, i) => {
       const sz = it.fillMain ? _nullishCoalesce(it.minMain, () => ( 0)) : it.main;
-      const add2 = cur.length === 0 ? sz : Math.max(gap, 0) + sz;
-      if (cur.length > 0 && used + add2 > innerMainFixed + 1e-6) {
+      const add3 = cur.length === 0 ? sz : Math.max(gap, 0) + sz;
+      if (cur.length > 0 && used + add3 > innerMainFixed + 1e-6) {
         lines.push(cur);
         cur = [];
         used = sz;
       } else {
-        used += add2;
+        used += add3;
       }
       cur.push(i);
     });
@@ -3703,8 +5996,8 @@ function layoutFrameInner(s, frame) {
   }
   for (const it of items) {
     if (!it.fillMain) continue;
-    const cross = it.fillCross && !wraps ? clampLayoutSize(innerCrossFixed, it.minCross, it.maxCross) : it.cross;
-    resize(it, it.main, cross);
+    const cross2 = it.fillCross && !wraps ? clampLayoutSize(innerCrossFixed, it.minCross, it.maxCross) : it.cross;
+    resize(it, it.main, cross2);
     it.cross = sizeOf(it.id)[1];
   }
   if (baseline) {
@@ -3718,8 +6011,8 @@ function layoutFrameInner(s, frame) {
     const inLine = line2.map((i) => items[i]);
     const mainUsed = inLine.reduce((sum, it) => sum + it.main, 0) + gaps;
     const allFill = inLine.every((it) => it.fillCross);
-    const cross = inLine.filter((it) => allFill || !it.fillCross).reduce((m, it) => Math.max(m, it.baseOff + it.cross), 0);
-    extents.push([mainUsed, cross]);
+    const cross2 = inLine.filter((it) => allFill || !it.fillCross).reduce((m, it) => Math.max(m, it.baseOff + it.cross), 0);
+    extents.push([mainUsed, cross2]);
   }
   const contentMain = extents.reduce((m, l) => Math.max(m, l[0]), 0);
   let crossGap = al.rowGap !== void 0 ? finite(al.rowGap) : gap;
@@ -3805,16 +6098,16 @@ function trackSpec(tracks, i) {
   return { sizing: t.sizing, value };
 }
 function cellRect(g, c) {
-  const x0 = _nullishCoalesce(_optionalChain([g, 'access', _120 => _120.columns, 'access', _121 => _121[c.column], 'optionalAccess', _122 => _122[0]]), () => ( 0));
-  const x1 = _nullishCoalesce(_optionalChain([g, 'access', _123 => _123.columns, 'access', _124 => _124[c.column + c.columnSpan - 1], 'optionalAccess', _125 => _125[1]]), () => ( x0));
-  const y0 = _nullishCoalesce(_optionalChain([g, 'access', _126 => _126.rows, 'access', _127 => _127[c.row], 'optionalAccess', _128 => _128[0]]), () => ( 0));
-  const y1 = _nullishCoalesce(_optionalChain([g, 'access', _129 => _129.rows, 'access', _130 => _130[c.row + c.rowSpan - 1], 'optionalAccess', _131 => _131[1]]), () => ( y0));
+  const x0 = _nullishCoalesce(_optionalChain([g, 'access', _137 => _137.columns, 'access', _138 => _138[c.column], 'optionalAccess', _139 => _139[0]]), () => ( 0));
+  const x1 = _nullishCoalesce(_optionalChain([g, 'access', _140 => _140.columns, 'access', _141 => _141[c.column + c.columnSpan - 1], 'optionalAccess', _142 => _142[1]]), () => ( x0));
+  const y0 = _nullishCoalesce(_optionalChain([g, 'access', _143 => _143.rows, 'access', _144 => _144[c.row], 'optionalAccess', _145 => _145[0]]), () => ( 0));
+  const y1 = _nullishCoalesce(_optionalChain([g, 'access', _146 => _146.rows, 'access', _147 => _147[c.row + c.rowSpan - 1], 'optionalAccess', _148 => _148[1]]), () => ( y0));
   return { x: x0, y: y0, width: Math.max(x1, x0) - x0, height: Math.max(y1, y0) - y0 };
 }
 var toIndex = (v) => typeof v === "number" && Number.isFinite(v) && v >= 0 ? Math.floor(v) : void 0;
 function gridPlace(s, al, kids) {
-  const cols = trackList(_optionalChain([al, 'access', _132 => _132.grid, 'optionalAccess', _133 => _133.columns]), 2).count;
-  const minRows = trackList(_optionalChain([al, 'access', _134 => _134.grid, 'optionalAccess', _135 => _135.rows]), 1).count;
+  const cols = trackList(_optionalChain([al, 'access', _149 => _149.grid, 'optionalAccess', _150 => _150.columns]), 2).count;
+  const minRows = trackList(_optionalChain([al, 'access', _151 => _151.grid, 'optionalAccess', _152 => _152.rows]), 1).count;
   const maxRows = Math.min(Math.max(Math.floor(MAX_GRID_CELLS / cols), 1), MAX_TRACKS);
   const occ = [];
   const free = (c, r, cs, rs) => {
@@ -3905,11 +6198,11 @@ function resolveTracks(tracks, content, avail) {
   let used = out.reduce((sum, v, i) => trackSpec(tracks, i).sizing === "fill" ? sum : sum + v, 0);
   while (flex.length > 0) {
     const total = flex.reduce((sum, i) => sum + fr(i), 0);
-    const unit2 = total > 1e-12 ? Math.max(avail - used, 0) / total : 0;
-    const open = flex.filter((i) => unit2 * fr(i) >= out[i]);
-    const frozen = flex.filter((i) => unit2 * fr(i) < out[i]);
+    const unit3 = total > 1e-12 ? Math.max(avail - used, 0) / total : 0;
+    const open = flex.filter((i) => unit3 * fr(i) >= out[i]);
+    const frozen = flex.filter((i) => unit3 * fr(i) < out[i]);
     if (frozen.length === 0) {
-      for (const i of open) out[i] = unit2 * fr(i);
+      for (const i of open) out[i] = unit3 * fr(i);
       break;
     }
     used += frozen.reduce((sum, i) => sum + out[i], 0);
@@ -3957,8 +6250,8 @@ function gridGeometryOf(s, frame) {
   const [pt, pr, pb, pl] = resolvePadding(al.padding);
   const kids = flowChildren(s, frame);
   const { cells, rows } = gridPlace(s, al, kids);
-  const colSpec = trackList(_optionalChain([al, 'access', _136 => _136.grid, 'optionalAccess', _137 => _137.columns]), 2);
-  const rowSpec = trackList(_optionalChain([al, 'access', _138 => _138.grid, 'optionalAccess', _139 => _139.rows]), 1);
+  const colSpec = trackList(_optionalChain([al, 'access', _153 => _153.grid, 'optionalAccess', _154 => _154.columns]), 2);
+  const rowSpec = trackList(_optionalChain([al, 'access', _155 => _155.grid, 'optionalAccess', _156 => _156.rows]), 1);
   const cols = colSpec.count;
   const gx = Math.max(finite(al.gap), 0);
   const gy = Math.max(al.rowGap !== void 0 ? finite(al.rowGap) : gx, 0);
@@ -4060,7 +6353,7 @@ function constrain(s, id, ow, oh) {
       let y1 = c.y + c.h;
       const dx = nw - ow;
       const dy = nh - oh;
-      switch (_nullishCoalesce(_optionalChain([child, 'access', _140 => _140.constraints, 'optionalAccess', _141 => _141.horizontal]), () => ( "left"))) {
+      switch (_nullishCoalesce(_optionalChain([child, 'access', _157 => _157.constraints, 'optionalAccess', _158 => _158.horizontal]), () => ( "left"))) {
         case "right":
           x0 += dx;
           x1 += dx;
@@ -4077,7 +6370,7 @@ function constrain(s, id, ow, oh) {
           x1 *= sx;
           break;
       }
-      switch (_nullishCoalesce(_optionalChain([child, 'access', _142 => _142.constraints, 'optionalAccess', _143 => _143.vertical]), () => ( "top"))) {
+      switch (_nullishCoalesce(_optionalChain([child, 'access', _159 => _159.constraints, 'optionalAccess', _160 => _160.vertical]), () => ( "top"))) {
         case "bottom":
           y0 += dy;
           y1 += dy;
@@ -4117,7 +6410,7 @@ function postOrder(s, nodes) {
   const visit = (id) => {
     if (seen.has(id)) return;
     seen.add(id);
-    for (const k of _nullishCoalesce(_optionalChain([s, 'access', _144 => _144.boxes, 'access', _145 => _145.get, 'call', _146 => _146(id), 'optionalAccess', _147 => _147.kids]), () => ( []))) visit(k);
+    for (const k of _nullishCoalesce(_optionalChain([s, 'access', _161 => _161.boxes, 'access', _162 => _162.get, 'call', _163 => _163(id), 'optionalAccess', _164 => _164.kids]), () => ( []))) visit(k);
     out.push(id);
   };
   const roots = nodes.filter((n) => !n.parentId || !s.boxes.has(n.parentId));
@@ -4156,7 +6449,7 @@ function getFlowChildren(nodes, frameId) {
 function getLayoutParent(nodes, id) {
   const lookup = createNodeLookup(nodes);
   const node = lookup.get(id);
-  if (!_optionalChain([node, 'optionalAccess', _148 => _148.parentId]) || getChildLayout(node).absolute) return void 0;
+  if (!_optionalChain([node, 'optionalAccess', _165 => _165.parentId]) || getChildLayout(node).absolute) return void 0;
   const parent = lookup.get(node.parentId);
   return isAutoLayoutFrame(parent) ? parent : void 0;
 }
@@ -4169,7 +6462,7 @@ function makeSizingCoherent(nodes, id, options = {}) {
     if (!targets.has(node.id)) return node;
     const parent = node.parentId ? lookup.get(node.parentId) : void 0;
     const flowParent = parent && isAutoLayoutFrame(parent) && !getChildLayout(node).absolute ? parent : void 0;
-    const canHug = isAutoLayoutFrame(node) || _optionalChain([options, 'access', _149 => _149.measure, 'optionalAccess', _150 => _150.textSize, 'optionalCall', _151 => _151(node)]) !== void 0;
+    const canHug = isAutoLayoutFrame(node) || _optionalChain([options, 'access', _166 => _166.measure, 'optionalAccess', _167 => _167.textSize, 'optionalCall', _168 => _168(node)]) !== void 0;
     const coherent = (axis) => {
       const sizing = getLayoutSizing(node, axis);
       if (sizing === "fill" && (!flowParent || getLayoutSizing(flowParent, axis) === "hug")) return "fixed";
@@ -4195,19 +6488,19 @@ function getAutoLayoutInsertTarget(nodes, frameId, point, options = {}) {
   if (!frame || !al) return void 0;
   const s = new LayoutState(nodes, options);
   const origin = getAbsolutePosition(frame, lookup);
-  const px = point.x - origin.x;
+  const px2 = point.x - origin.x;
   const py = point.y - origin.y;
   const siblings = flowChildren(s, frameId).filter((id) => id !== options.excludeId).map((id) => s.boxes.get(id));
   const horizontal = al.mode !== "vertical";
   const main = (b) => horizontal ? b.x : b.y;
   const mainSize = (b) => horizontal ? b.w : b.h;
-  const cross = (b) => horizontal ? b.y : b.x;
+  const cross2 = (b) => horizontal ? b.y : b.x;
   const crossSize = (b) => horizontal ? b.h : b.w;
-  const p = { x: px, y: py };
+  const p = { x: px2, y: py };
   const multiLine = al.mode === "grid" || !!al.wrap;
   let index = 0;
   for (const b of siblings) {
-    const before = multiLine ? cross(b) + crossSize(b) <= cross(p) || cross(b) <= cross(p) && main(b) + mainSize(b) / 2 < main(p) : main(b) + mainSize(b) / 2 < main(p);
+    const before = multiLine ? cross2(b) + crossSize(b) <= cross2(p) || cross2(b) <= cross2(p) && main(b) + mainSize(b) / 2 < main(p) : main(b) + mainSize(b) / 2 < main(p);
     if (before) index += 1;
   }
   const [pt, pr, pb, pl] = resolvePadding(al.padding);
@@ -4216,13 +6509,13 @@ function getAutoLayoutInsertTarget(nodes, frameId, point, options = {}) {
   const f = s.boxes.get(frameId);
   let guide;
   if (horizontal) {
-    const x = prev && next && Math.abs(cross(prev) - cross(next)) < 1e-6 ? (prev.x + prev.w + next.x) / 2 : prev ? prev.x + prev.w : next ? next.x : pl;
+    const x = prev && next && Math.abs(cross2(prev) - cross2(next)) < 1e-6 ? (prev.x + prev.w + next.x) / 2 : prev ? prev.x + prev.w : next ? next.x : pl;
     const ref = _nullishCoalesce(next, () => ( prev));
     const y1 = ref ? ref.y : pt;
     const y2 = ref ? ref.y + ref.h : f.h - pb;
     guide = { orientation: "vertical", kind: "edge", x1: origin.x + x, y1: origin.y + y1, x2: origin.x + x, y2: origin.y + y2 };
   } else {
-    const y = prev && next && Math.abs(cross(prev) - cross(next)) < 1e-6 ? (prev.y + prev.h + next.y) / 2 : prev ? prev.y + prev.h : next ? next.y : pt;
+    const y = prev && next && Math.abs(cross2(prev) - cross2(next)) < 1e-6 ? (prev.y + prev.h + next.y) / 2 : prev ? prev.y + prev.h : next ? next.y : pt;
     const ref = _nullishCoalesce(next, () => ( prev));
     const x1 = ref ? ref.x : pl;
     const x2 = ref ? ref.x + ref.w : f.w - pr;
@@ -4232,7 +6525,7 @@ function getAutoLayoutInsertTarget(nodes, frameId, point, options = {}) {
 }
 function moveLayoutChild(nodes, childId, index) {
   const child = nodes.find((n) => n.id === childId);
-  if (!_optionalChain([child, 'optionalAccess', _152 => _152.parentId])) return nodes;
+  if (!_optionalChain([child, 'optionalAccess', _169 => _169.parentId])) return nodes;
   const siblings = nodes.filter((n) => n.parentId === child.parentId && n.id !== child.parentId);
   const flow = siblings.filter((n) => n.hidden !== true && !getChildLayout(n).absolute && n.id !== childId);
   const clamped = Math.min(Math.max(Math.floor(Number.isFinite(index) ? index : 0), 0), flow.length);
@@ -4280,11 +6573,11 @@ function createCanvasArrangeController(options) {
   let resizeStart = null;
   let resizeIndex = null;
   let lastResized = null;
-  const selectedIds = (ids) => ids ? [...ids] : _nullishCoalesce(_optionalChain([options, 'access', _153 => _153.getSelectedIds, 'optionalCall', _154 => _154()]), () => ( options.getNodes().filter((n) => n.selected).map((n) => n.id)));
+  const selectedIds = (ids) => ids ? [...ids] : _nullishCoalesce(_optionalChain([options, 'access', _170 => _170.getSelectedIds, 'optionalCall', _171 => _171()]), () => ( options.getNodes().filter((n) => n.selected).map((n) => n.id)));
   const setGuides = (next) => {
     if (next.length === 0 && guides.length === 0) return;
     guides = next;
-    _optionalChain([options, 'access', _155 => _155.onGuidesChange, 'optionalCall', _156 => _156(guides)]);
+    _optionalChain([options, 'access', _172 => _172.onGuidesChange, 'optionalCall', _173 => _173(guides)]);
   };
   function apply(name, updates) {
     if (updates.length === 0) return updates;
@@ -4381,6 +6674,41 @@ function createCanvasArrangeController(options) {
     divide: (ids, o) => controller.combineShapes("divide", ids, o),
     /** Whether the shape operations can run on `ids` (default: the selection). */
     canCombineShapes: (ids) => canCombineShapeNodes(options.getNodes(), selectedIds(ids)).ok,
+    /**
+     * Offset Path: grows (`distance > 0`) or shrinks (`distance < 0`) every shape among
+     * `ids` (default: the selection) by `distance` flow units, keeping curves, as one
+     * undoable step. Refuses without changing anything when a shape is locked, no shape is
+     * selected or every result is empty.
+     */
+    offsetShapes(distance, ids, offsetOptions = {}) {
+      const before = options.getNodes();
+      const result = offsetShapeNodes(before, selectedIds(ids), distance, { ...rect(), ...offsetOptions });
+      if (!result.ok) return result;
+      const run = () => options.setNodes(applyShapeReplacement(options.getNodes(), result));
+      const undo = () => options.setNodes(revertShapeCombination(options.getNodes(), result, before));
+      if (options.history) options.history.execute({ name: "Offset Path", execute: run, undo });
+      else run();
+      return result;
+    },
+    /** Whether `offsetShapes` can run on `ids` (default: the selection). */
+    canOffsetShapes: (ids) => canOffsetShapeNodes(options.getNodes(), selectedIds(ids)).ok,
+    /**
+     * Outline Stroke: converts the strokes of the shapes among `ids` (default: the
+     * selection) to filled path shapes, as one undoable step. Refuses when a shape is
+     * locked or no selected shape has a visible stroke.
+     */
+    outlineStroke(ids, outlineOptions = {}) {
+      const before = options.getNodes();
+      const result = outlineShapeNodeStrokes(before, selectedIds(ids), { ...rect(), ...outlineOptions });
+      if (!result.ok) return result;
+      const run = () => options.setNodes(applyShapeReplacement(options.getNodes(), result));
+      const undo = () => options.setNodes(revertShapeCombination(options.getNodes(), result, before));
+      if (options.history) options.history.execute({ name: "Outline Stroke", execute: run, undo });
+      else run();
+      return result;
+    },
+    /** Whether `outlineStroke` can run on `ids` (default: the selection). */
+    canOutlineStroke: (ids) => canOutlineShapeNodeStrokes(options.getNodes(), selectedIds(ids)).ok,
     /**
      * Runs a shortcut action. Scene actions are not handled here (see the scenes store);
      * returns `false` for them and for unknown actions.
@@ -4452,7 +6780,7 @@ function createCanvasArrangeController(options) {
       const result = snapNodeDrag(options.getNodes(), list, {
         ...rect(),
         ...options.guides,
-        zoom: _nullishCoalesce(_optionalChain([options, 'access', _157 => _157.getZoom, 'optionalCall', _158 => _158()]), () => ( 1)),
+        zoom: _nullishCoalesce(_optionalChain([options, 'access', _174 => _174.getZoom, 'optionalCall', _175 => _175()]), () => ( 1)),
         index: dragIndex
       });
       lastSnapped = /* @__PURE__ */ new Map();
@@ -4490,7 +6818,7 @@ function createCanvasArrangeController(options) {
       const result = snapNodeDrag(nodes, ids, {
         ...rect(),
         ...options.guides,
-        zoom: _nullishCoalesce(_optionalChain([options, 'access', _159 => _159.getZoom, 'optionalCall', _160 => _160()]), () => ( 1)),
+        zoom: _nullishCoalesce(_optionalChain([options, 'access', _176 => _176.getZoom, 'optionalCall', _177 => _177()]), () => ( 1)),
         index: dragIndex
       });
       setGuides(result.guides);
@@ -4556,7 +6884,7 @@ function createCanvasArrangeController(options) {
         ...rect(),
         ...options.guides,
         ...options.resize,
-        zoom: _nullishCoalesce(_optionalChain([options, 'access', _161 => _161.getZoom, 'optionalCall', _162 => _162()]), () => ( 1)),
+        zoom: _nullishCoalesce(_optionalChain([options, 'access', _178 => _178.getZoom, 'optionalCall', _179 => _179()]), () => ( 1)),
         index: resizeIndex
       });
       lastResized = result.updates.length > 0 ? result : null;
@@ -4575,7 +6903,7 @@ function createCanvasArrangeController(options) {
       resizeIndex = null;
       lastResized = null;
       setGuides([]);
-      const update = _optionalChain([last, 'optionalAccess', _163 => _163.updates, 'access', _164 => _164[0]]);
+      const update = _optionalChain([last, 'optionalAccess', _180 => _180.updates, 'access', _181 => _181[0]]);
       if (!update) return;
       const node = options.getNodes().find((n) => n.id === update.id);
       if (!node) return;
@@ -4603,7 +6931,7 @@ function createCanvasArrangeController(options) {
         return changes.filter((c) => !isResizeChange(c));
       }
       if (dims.resizing === false) {
-        const last = _optionalChain([lastResized, 'optionalAccess', _165 => _165.updates, 'access', _166 => _166[0]]);
+        const last = _optionalChain([lastResized, 'optionalAccess', _182 => _182.updates, 'access', _183 => _183[0]]);
         lastResized = null;
         controller.endResize();
         if (!last || last.id !== id) return changes;
@@ -4617,7 +6945,7 @@ function createCanvasArrangeController(options) {
       const posChange = changes.find((c) => c.id === id && c.type === "position" && !!c.position);
       const parent = node.parentId ? lookup.get(node.parentId) : void 0;
       const origin = parent ? getResizingNodeRect(parent, lookup, rect()) : { x: 0, y: 0 };
-      const position = _nullishCoalesce(_optionalChain([posChange, 'optionalAccess', _167 => _167.position]), () => ( node.position));
+      const position = _nullishCoalesce(_optionalChain([posChange, 'optionalAccess', _184 => _184.position]), () => ( node.position));
       const proposed = {
         x: position.x + origin.x,
         y: position.y + origin.y,
@@ -4633,7 +6961,7 @@ function createCanvasArrangeController(options) {
         ...rect(),
         ...options.guides,
         ...options.resize,
-        zoom: _nullishCoalesce(_optionalChain([options, 'access', _168 => _168.getZoom, 'optionalCall', _169 => _169()]), () => ( 1)),
+        zoom: _nullishCoalesce(_optionalChain([options, 'access', _185 => _185.getZoom, 'optionalCall', _186 => _186()]), () => ( 1)),
         index: resizeIndex
       });
       setGuides(result.guides);
@@ -4814,7 +7142,7 @@ function createCanvasAutoLayoutController(options) {
   const setGuides = (next) => {
     if (next.length === 0 && guides.length === 0) return;
     guides = next;
-    _optionalChain([options, 'access', _170 => _170.onGuidesChange, 'optionalCall', _171 => _171(guides)]);
+    _optionalChain([options, 'access', _187 => _187.onGuidesChange, 'optionalCall', _188 => _188(guides)]);
   };
   function run(name, forward, backward, ids, extra = [], restore) {
     const before = options.getNodes();
@@ -4980,11 +7308,11 @@ function createCanvasAutoLayoutController(options) {
       const nodes = options.getNodes();
       const lookup = createNodeLookup(nodes);
       for (const c of changes) {
-        const id = _nullishCoalesce(c.id, () => ( _optionalChain([c, 'access', _172 => _172.item, 'optionalAccess', _173 => _173.id])));
+        const id = _nullishCoalesce(c.id, () => ( _optionalChain([c, 'access', _189 => _189.item, 'optionalAccess', _190 => _190.id])));
         if (c.type === "add" && c.item) {
           pendingIds.add(c.item.id);
         } else if (c.type === "remove" && id) {
-          const parent = _optionalChain([lookup, 'access', _174 => _174.get, 'call', _175 => _175(id), 'optionalAccess', _176 => _176.parentId]);
+          const parent = _optionalChain([lookup, 'access', _191 => _191.get, 'call', _192 => _192(id), 'optionalAccess', _193 => _193.parentId]);
           if (parent) pendingIds.add(parent);
           else pendingAll = true;
         } else if (c.type === "replace" && id) {
@@ -5071,6 +7399,511 @@ function restoreOrder(nodes, order) {
   return indexed.every((e, i) => e.n === nodes[i]) ? nodes : indexed.map((e) => e.n);
 }
 
+// src/canvas/tokenBindings.ts
+var TOKEN_BINDINGS_DATA_KEY = "tokenBindings";
+var TOKEN_MODES_DATA_KEY = "tokenModes";
+var kebab = (prop) => prop.replace(/[A-Z]/g, (c) => `-${c.toLowerCase()}`);
+function parseDeclarations(style) {
+  const parts = [];
+  let depth = 0;
+  let quote = "";
+  let start = 0;
+  for (let i = 0; i < style.length; i++) {
+    const ch = style[i];
+    if (quote) {
+      if (ch === "\\") i++;
+      else if (ch === quote) quote = "";
+    } else if (ch === '"' || ch === "'") quote = ch;
+    else if (ch === "(") depth++;
+    else if (ch === ")") depth = Math.max(0, depth - 1);
+    else if (ch === ";" && depth === 0) {
+      parts.push(style.slice(start, i));
+      start = i + 1;
+    }
+  }
+  parts.push(style.slice(start));
+  const out = [];
+  for (const part of parts) {
+    const colon = part.indexOf(":");
+    if (colon < 0) continue;
+    const name = part.slice(0, colon).trim();
+    if (name) out.push([name, part.slice(colon + 1).trim()]);
+  }
+  return out;
+}
+function readNodeStyleProperty(style, prop) {
+  if (!style) return void 0;
+  if (typeof style === "object") return style[prop];
+  const name = kebab(prop);
+  let found;
+  for (const [key, value] of parseDeclarations(style)) if (key.toLowerCase() === name) found = value;
+  return found;
+}
+function writeNodeStyleProperty(style, prop, value, unitless = false) {
+  if (typeof style === "string") {
+    const name = kebab(prop);
+    const text = value === void 0 ? void 0 : typeof value === "number" && !unitless ? `${value}px` : String(value);
+    const decls = [];
+    let placed = text === void 0;
+    for (const [key, current] of parseDeclarations(style)) {
+      if (key.toLowerCase() !== name) decls.push([key, current]);
+      else if (!placed) {
+        decls.push([name, text]);
+        placed = true;
+      }
+    }
+    if (!placed) decls.push([name, text]);
+    return decls.map(([k, v]) => `${k}: ${v}`).join("; ");
+  }
+  const next = { ..._nullishCoalesce(style, () => ( {})) };
+  if (value === void 0) delete next[prop];
+  else next[prop] = value;
+  return next;
+}
+function px(value) {
+  if (typeof value === "number") return Number.isFinite(value) ? value : void 0;
+  if (typeof value === "string") {
+    const n = parseFloat(value);
+    return Number.isFinite(n) ? n : void 0;
+  }
+  return void 0;
+}
+function withStyle(node, prop, value, unitless = false) {
+  const current = readNodeStyleProperty(node.style, prop);
+  const written = typeof node.style === "string" && typeof value === "number" && !unitless ? `${value}px` : value;
+  if (typeof node.style === "string" ? current === String(written) : current === value) return node;
+  return { ...node, style: writeNodeStyleProperty(node.style, prop, value, unitless) };
+}
+function shapeOf(node) {
+  const shape = _optionalChain([node, 'access', _194 => _194.data, 'optionalAccess', _195 => _195.shape]);
+  return isShapeDescription(shape) ? shape : null;
+}
+function withShape(node, key, value) {
+  const shape = shapeOf(node);
+  if (shape[key] === value) return node;
+  return { ...node, data: { ...node.data, shape: { ...shape, [key]: value } } };
+}
+var nonNegative = (v) => Math.max(0, v);
+function styleOrShape(key, styleProp, convert = (v) => v) {
+  return {
+    read(node) {
+      const shape = shapeOf(node);
+      if (shape) return shape[key];
+      const value = readNodeStyleProperty(node.style, styleProp(node));
+      return key === "strokeWidth" ? px(value) : value;
+    },
+    write(node, value) {
+      const v = convert(value);
+      if (shapeOf(node)) return withShape(node, key, v);
+      let next = withStyle(node, styleProp(node), v);
+      if (key === "strokeWidth" && readNodeStyleProperty(next.style, "borderStyle") === void 0) {
+        next = { ...next, style: writeNodeStyleProperty(next.style, "borderStyle", "solid") };
+      }
+      return next;
+    }
+  };
+}
+function backgroundProp(node) {
+  return readNodeStyleProperty(node.style, "backgroundColor") === void 0 && readNodeStyleProperty(node.style, "background") !== void 0 ? "background" : "backgroundColor";
+}
+function layoutProperty(key, label, read, write) {
+  return {
+    key,
+    label,
+    type: "number",
+    scope: "GAP",
+    appliesTo: (node) => getAutoLayout(node) !== void 0,
+    read: (node) => {
+      const layout2 = getAutoLayout(node);
+      return layout2 ? read(layout2) : void 0;
+    },
+    write: (node, value) => {
+      const layout2 = getAutoLayout(node);
+      if (!layout2 || read(layout2) === value) return node;
+      return { ...node, data: { ...node.data, [AUTO_LAYOUT_DATA_KEY]: write(layout2, value) } };
+    }
+  };
+}
+var SIDES = ["top", "right", "bottom", "left"];
+function paddingProperty(key, label, sides) {
+  return layoutProperty(
+    key,
+    label,
+    (layout2) => {
+      const p = resolvePadding(layout2.padding);
+      const values = sides.map((s) => p[SIDES.indexOf(s)]);
+      return values.every((v) => v === values[0]) ? values[0] : void 0;
+    },
+    (layout2, value) => {
+      const p = resolvePadding(layout2.padding);
+      const v = Math.max(0, value);
+      const padding = { top: p[0], right: p[1], bottom: p[2], left: p[3] };
+      for (const s of sides) padding[s] = v;
+      return { ...layout2, padding };
+    }
+  );
+}
+var CANVAS_TOKEN_PROPERTIES = [
+  {
+    key: "fill",
+    label: "Fill",
+    type: "color",
+    scope: (node) => shapeOf(node) ? "SHAPE_FILL" : node.type === "text" ? "TEXT_FILL" : "FRAME_FILL",
+    appliesTo: () => true,
+    ...styleOrShape("fill", backgroundProp)
+  },
+  {
+    key: "stroke",
+    label: "Stroke",
+    type: "color",
+    scope: "STROKE_COLOR",
+    appliesTo: () => true,
+    ...styleOrShape("stroke", () => "borderColor")
+  },
+  {
+    key: "strokeWidth",
+    label: "Stroke width",
+    type: "number",
+    scope: "STROKE_FLOAT",
+    appliesTo: () => true,
+    ...styleOrShape("strokeWidth", () => "borderWidth", nonNegative)
+  },
+  {
+    key: "opacity",
+    label: "Opacity",
+    type: "number",
+    scope: "OPACITY",
+    appliesTo: () => true,
+    // Opacity variables are percentages (figcraft / Figma): 40 → 0.4, clamped to 0–100.
+    read: (node) => {
+      const v = px(readNodeStyleProperty(node.style, "opacity"));
+      return v === void 0 ? void 0 : Math.round(v * 1e4) / 100;
+    },
+    write: (node, value) => withStyle(node, "opacity", Math.min(1, Math.max(0, value / 100)), true)
+  },
+  {
+    key: "cornerRadius",
+    label: "Corner radius",
+    type: "number",
+    scope: "CORNER_RADIUS",
+    appliesTo: (node) => {
+      const shape = shapeOf(node);
+      return !shape || shape.kind === "rect";
+    },
+    read: (node) => {
+      const shape = shapeOf(node);
+      if (shape) return typeof shape.cornerRadius === "number" ? shape.cornerRadius : void 0;
+      return px(readNodeStyleProperty(node.style, "borderRadius"));
+    },
+    write: (node, value) => {
+      const v = Math.max(0, value);
+      return shapeOf(node) ? withShape(node, "cornerRadius", v) : withStyle(node, "borderRadius", v);
+    }
+  },
+  layoutProperty("gap", "Gap", (l) => typeof l.gap === "number" ? l.gap : 0, (l, v) => ({ ...l, gap: v })),
+  layoutProperty("rowGap", "Row gap", (l) => typeof l.rowGap === "number" ? l.rowGap : void 0, (l, v) => ({ ...l, rowGap: v })),
+  paddingProperty("padding", "Padding", ["top", "right", "bottom", "left"]),
+  paddingProperty("paddingHorizontal", "Horizontal padding", ["left", "right"]),
+  paddingProperty("paddingVertical", "Vertical padding", ["top", "bottom"]),
+  paddingProperty("paddingTop", "Top padding", ["top"]),
+  paddingProperty("paddingRight", "Right padding", ["right"]),
+  paddingProperty("paddingBottom", "Bottom padding", ["bottom"]),
+  paddingProperty("paddingLeft", "Left padding", ["left"]),
+  {
+    key: "textColor",
+    label: "Text colour",
+    type: "color",
+    scope: "TEXT_FILL",
+    appliesTo: (node) => !shapeOf(node),
+    read: (node) => readNodeStyleProperty(node.style, "color"),
+    write: (node, value) => withStyle(node, "color", value)
+  },
+  {
+    key: "fontSize",
+    label: "Font size",
+    type: "number",
+    scope: "FONT_SIZE",
+    appliesTo: (node) => !shapeOf(node),
+    read: (node) => px(readNodeStyleProperty(node.style, "fontSize")),
+    write: (node, value) => withStyle(node, "fontSize", Math.max(0, value))
+  },
+  {
+    key: "visible",
+    label: "Visible",
+    type: "boolean",
+    appliesTo: () => true,
+    read: (node) => !node.hidden,
+    write: (node, value) => !node.hidden === value ? node : { ...node, hidden: !value }
+  }
+];
+var EMPTY = Object.freeze({});
+function stringRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return EMPTY;
+  const out = {};
+  for (const [k, v] of Object.entries(value)) if (typeof v === "string") out[k] = v;
+  return out;
+}
+function getNodeTokenBindings(node) {
+  return stringRecord(_optionalChain([node, 'optionalAccess', _196 => _196.data, 'optionalAccess', _197 => _197[TOKEN_BINDINGS_DATA_KEY]]));
+}
+function getNodeTokenModes(node) {
+  return stringRecord(_optionalChain([node, 'optionalAccess', _198 => _198.data, 'optionalAccess', _199 => _199[TOKEN_MODES_DATA_KEY]]));
+}
+function getCanvasTokenProperty(key, options = {}) {
+  return (_nullishCoalesce(options.properties, () => ( CANVAS_TOKEN_PROPERTIES))).find((p) => p.key === key);
+}
+function getBindableTokenProperties(node, options = {}) {
+  return (_nullishCoalesce(options.properties, () => ( CANVAS_TOKEN_PROPERTIES))).filter((p) => p.appliesTo(node));
+}
+function getTokenPropertyScope(property, node) {
+  return typeof property.scope === "function" ? property.scope(node) : property.scope;
+}
+function getTokensForProperty(state, property, node) {
+  const scope = getTokenPropertyScope(property, node);
+  return state.variables.filter((v) => v.type === property.type && _chunk4BVP64JJcjs.isTokenInScope.call(void 0, v, scope));
+}
+function lookupOf(nodes) {
+  return new Map(nodes.map((n) => [n.id, n]));
+}
+function validModes(state, modes, into) {
+  for (const [collectionId, modeId] of Object.entries(modes)) {
+    if (state) {
+      const collection = _chunk4BVP64JJcjs.getTokenCollection.call(void 0, state, collectionId);
+      if (!collection || !collection.modes.some((m) => m.id === modeId)) continue;
+    }
+    into[collectionId] = modeId;
+  }
+}
+function getEffectiveTokenModes(node, nodes, state, options = {}) {
+  const lookup = nodes instanceof Map ? nodes : lookupOf(nodes);
+  const chain = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (let at = node; at && !seen.has(at.id); at = at.parentId ? lookup.get(at.parentId) : void 0) {
+    seen.add(at.id);
+    chain.push(at);
+  }
+  const out = {};
+  if (options.modes) validModes(state, options.modes, out);
+  for (let i = chain.length - 1; i >= 0; i--) validModes(state, getNodeTokenModes(chain[i]), out);
+  return out;
+}
+function modesResolver(nodes, state, options) {
+  const lookup = lookupOf(nodes);
+  const memo = /* @__PURE__ */ new Map();
+  const root = {};
+  if (options.modes) validModes(state, options.modes, root);
+  const visiting = /* @__PURE__ */ new Set();
+  const modesOf = (node) => {
+    const cached = memo.get(node.id);
+    if (cached) return cached;
+    let base = root;
+    if (node.parentId && !visiting.has(node.id)) {
+      const parent = lookup.get(node.parentId);
+      if (parent) {
+        visiting.add(node.id);
+        base = modesOf(parent);
+        visiting.delete(node.id);
+      }
+    }
+    const own = getNodeTokenModes(node);
+    let result = base;
+    if (Object.keys(own).length > 0) {
+      result = { ...base };
+      validModes(state, own, result);
+    }
+    memo.set(node.id, result);
+    return result;
+  };
+  return { lookup, modesOf };
+}
+function applyBindings(node, state, modes, options, only) {
+  const bindings = getNodeTokenBindings(node);
+  let next = node;
+  for (const [key, variableId] of Object.entries(bindings)) {
+    if (only && !only.has(variableId)) continue;
+    const property = getCanvasTokenProperty(key, options);
+    if (!property || !property.appliesTo(next)) continue;
+    const resolved = _chunk4BVP64JJcjs.resolveToken.call(void 0, state, variableId, modes);
+    if (!resolved.ok || resolved.type !== property.type) continue;
+    next = property.write(next, resolved.value);
+  }
+  return next;
+}
+function resolveCanvasTokens(nodes, state, options = {}) {
+  const { modesOf } = modesResolver(nodes, state, options);
+  let changed = false;
+  const out = nodes.map((node) => {
+    if (Object.keys(getNodeTokenBindings(node)).length === 0) return node;
+    const next = applyBindings(node, state, modesOf(node), options);
+    if (next !== node) changed = true;
+    return next;
+  });
+  return changed ? out : nodes;
+}
+function inspectNodeTokens(node, nodes, state, options = {}) {
+  const modes = getEffectiveTokenModes(node, nodes, state, options);
+  const out = [];
+  for (const [key, variableId] of Object.entries(getNodeTokenBindings(node))) {
+    const property = getCanvasTokenProperty(key, options);
+    if (!property) continue;
+    out.push({ property, variableId, variable: _chunk4BVP64JJcjs.getTokenVariable.call(void 0, state, variableId), resolution: _chunk4BVP64JJcjs.resolveToken.call(void 0, state, variableId, modes) });
+  }
+  return out;
+}
+function setDataRecord(node, key, record) {
+  const data = { ...node.data };
+  if (Object.keys(record).length === 0) delete data[key];
+  else data[key] = record;
+  return { ...node, data };
+}
+function bindCanvasToken(nodes, ids, propertyKey, variableId, state, options = {}) {
+  const property = getCanvasTokenProperty(propertyKey, options);
+  if (!property) throw new (0, _chunk4BVP64JJcjs.TokenError)("not-found", `No bindable property \`${propertyKey}\``);
+  if (variableId !== null) {
+    const variable = _chunk4BVP64JJcjs.getTokenVariable.call(void 0, state, variableId);
+    if (!variable) throw new (0, _chunk4BVP64JJcjs.TokenError)("not-found", `No variable \`${variableId}\``);
+    if (variable.type !== property.type) {
+      throw new (0, _chunk4BVP64JJcjs.TokenError)("type-mismatch", `${property.label} takes a ${property.type} variable; \`${variable.name}\` is a ${variable.type}`);
+    }
+  }
+  const targets = new Set(ids);
+  let changed = false;
+  const bound = nodes.map((node) => {
+    if (!targets.has(node.id) || !property.appliesTo(node)) return node;
+    const bindings = { ...getNodeTokenBindings(node) };
+    if (variableId === null) {
+      if (!(propertyKey in bindings)) return node;
+      delete bindings[propertyKey];
+    } else {
+      if (bindings[propertyKey] === variableId) return node;
+      bindings[propertyKey] = variableId;
+    }
+    changed = true;
+    return setDataRecord(node, TOKEN_BINDINGS_DATA_KEY, bindings);
+  });
+  return changed ? resolveCanvasTokens(bound, state, options) : nodes;
+}
+function setCanvasTokenMode(nodes, ids, collectionId, modeId, state, options = {}) {
+  if (modeId !== null) {
+    const collection = _chunk4BVP64JJcjs.getTokenCollection.call(void 0, state, collectionId);
+    if (!collection) throw new (0, _chunk4BVP64JJcjs.TokenError)("not-found", `No collection \`${collectionId}\``);
+    if (!collection.modes.some((m) => m.id === modeId)) throw new (0, _chunk4BVP64JJcjs.TokenError)("not-found", `No mode \`${modeId}\` in \`${collection.name}\``);
+  }
+  const targets = new Set(ids);
+  let changed = false;
+  const next = nodes.map((node) => {
+    if (!targets.has(node.id)) return node;
+    const modes = { ...getNodeTokenModes(node) };
+    if (modeId === null) {
+      if (!(collectionId in modes)) return node;
+      delete modes[collectionId];
+    } else {
+      if (modes[collectionId] === modeId) return node;
+      modes[collectionId] = modeId;
+    }
+    changed = true;
+    return setDataRecord(node, TOKEN_MODES_DATA_KEY, modes);
+  });
+  return changed ? resolveCanvasTokens(next, state, options) : nodes;
+}
+function detachTokenBindings(nodes, state, variableIds, options = {}) {
+  const only = variableIds ? new Set(variableIds) : null;
+  const isDetached = (id) => only ? only.has(id) : !_chunk4BVP64JJcjs.getTokenVariable.call(void 0, state, id);
+  const { modesOf } = modesResolver(nodes, state, options);
+  let changed = false;
+  const out = nodes.map((node) => {
+    const bindings = getNodeTokenBindings(node);
+    const gone = Object.entries(bindings).filter(([, id]) => isDetached(id));
+    if (gone.length === 0) return node;
+    let next = applyBindings(node, state, modesOf(node), options, new Set(gone.map(([, id]) => id)));
+    const kept = { ...bindings };
+    for (const [key] of gone) delete kept[key];
+    next = setDataRecord(next, TOKEN_BINDINGS_DATA_KEY, kept);
+    changed = true;
+    return next;
+  });
+  return changed ? out : nodes;
+}
+function pruneCanvasTokenModes(nodes, state) {
+  let changed = false;
+  const out = nodes.map((node) => {
+    const modes = getNodeTokenModes(node);
+    const valid = {};
+    validModes(state, modes, valid);
+    if (Object.keys(valid).length === Object.keys(modes).length) return node;
+    changed = true;
+    return setDataRecord(node, TOKEN_MODES_DATA_KEY, valid);
+  });
+  return changed ? out : nodes;
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -5223,5 +8056,5 @@ function restoreOrder(nodes, order) {
 
 
 
-exports.AUTO_LAYOUT_DATA_KEY = AUTO_LAYOUT_DATA_KEY; exports.CHILD_LAYOUT_DATA_KEY = CHILD_LAYOUT_DATA_KEY; exports.CONNECTION_LINE_TYPES = CONNECTION_LINE_TYPES; exports.CanvasScenesStore = CanvasScenesStore; exports.DEFAULT_ARRANGE_SHORTCUTS = _chunk26BVFKHUcjs.DEFAULT_ARRANGE_SHORTCUTS; exports.DEFAULT_NODE_HEIGHT = _chunkWADCJ7A7cjs.DEFAULT_NODE_HEIGHT; exports.DEFAULT_NODE_WIDTH = _chunkWADCJ7A7cjs.DEFAULT_NODE_WIDTH; exports.DEFAULT_PLACEMENT_GAP = _chunkWADCJ7A7cjs.DEFAULT_PLACEMENT_GAP; exports.LOCKED_DATA_KEY = LOCKED_DATA_KEY; exports.LOCKED_PREVIOUS_FLAGS_KEY = LOCKED_PREVIOUS_FLAGS_KEY; exports.ManualClock = ManualClock; exports.RESIZE_HANDLES = RESIZE_HANDLES; exports.SHAPE_DATA_KEY = SHAPE_DATA_KEY; exports.SHAPE_KINDS = SHAPE_KINDS; exports.SHAPE_NODE_TYPE = SHAPE_NODE_TYPE; exports.SHAPE_OPERATIONS = SHAPE_OPERATIONS; exports.StreamingLayoutManager = StreamingLayoutManager; exports.alignNodes = alignNodes; exports.applyConstraints = applyConstraints; exports.applyNodeUpdates = applyNodeUpdates; exports.applyShapeCombination = applyShapeCombination; exports.blendLayout = blendLayout; exports.boundsOf = _chunkWADCJ7A7cjs.boundsOf; exports.calculateDagreReflowDisplacement = calculateDagreReflowDisplacement; exports.calculateDirectionalDisplacement = calculateDirectionalDisplacement; exports.canCombineShapeNodes = canCombineShapeNodes; exports.canvasHeight = canvasHeight; exports.centerNodes = _chunkWADCJ7A7cjs.centerNodes; exports.centre = _chunkWADCJ7A7cjs.centre; exports.clampLayoutSize = clampLayoutSize; exports.collectDescendantIds = collectDescendantIds; exports.combineShapeNodes = combineShapeNodes; exports.computeNodesBoundingBox = computeNodesBoundingBox; exports.computeSnapGuides = computeSnapGuides; exports.connectedOnly = connectedOnly; exports.createBezierTrajectory = createBezierTrajectory; exports.createCanvasArrangeController = createCanvasArrangeController; exports.createCanvasAutoLayoutController = createCanvasAutoLayoutController; exports.createCanvasScenesStore = createCanvasScenesStore; exports.createFanOutTrajectory = createFanOutTrajectory; exports.createGuideIndex = createGuideIndex; exports.createNodeGuideIndex = createNodeGuideIndex; exports.createNodeLookup = createNodeLookup; exports.cubicPointAt = cubicPointAt; exports.cubicsToPathData = cubicsToPathData; exports.defaultEasing = defaultEasing; exports.distributeNodes = distributeNodes; exports.dividePolygons = dividePolygons; exports.ensureLayout = _chunkWADCJ7A7cjs.ensureLayout; exports.estimateCanvasHeight = estimateCanvasHeight; exports.estimateNodeSize = _chunkWADCJ7A7cjs.estimateNodeSize; exports.findConnectorSnap = findConnectorSnap; exports.fitCubicRun = fitCubicRun; exports.fitCubics = fitCubics; exports.fitFreehandPath = fitFreehandPath; exports.fitPathData = fitPathData; exports.fitViewportToNodes = fitViewportToNodes; exports.fitViewportToRect = fitViewportToRect; exports.flattenSvgPath = flattenSvgPath; exports.flowSide = _chunkWADCJ7A7cjs.flowSide; exports.formatNumber = formatNumber2; exports.getAbsolutePosition = getAbsolutePosition; exports.getAutoLayout = getAutoLayout; exports.getAutoLayoutGrid = getAutoLayoutGrid; exports.getAutoLayoutInsertTarget = getAutoLayoutInsertTarget; exports.getCenteredNodePosition = _chunkWADCJ7A7cjs.getCenteredNodePosition; exports.getChildLayout = getChildLayout; exports.getFlowChildren = getFlowChildren; exports.getLayoutParent = getLayoutParent; exports.getLayoutSizing = getLayoutSizing; exports.getLayoutedNodes = _chunkWADCJ7A7cjs.getLayoutedNodes; exports.getNodeRect = getNodeRect; exports.getNodeShape = getNodeShape; exports.getNodeSize = getNodeSize; exports.getResizingNodeRect = getResizingNodeRect; exports.getShapeRenderData = getShapeRenderData; exports.getShapeSvg = getShapeSvg; exports.handlePoint = handlePoint; exports.inferResizeHandle = inferResizeHandle; exports.intersectPolygons = intersectPolygons; exports.invertNodeUpdates = invertNodeUpdates; exports.isAutoLayoutFrame = isAutoLayoutFrame; exports.isEventFromTextInput = isEventFromTextInput; exports.isLocked = isLocked; exports.isMeasureModifierHeld = isMeasureModifierHeld; exports.isShapeDescription = isShapeDescription; exports.isShapeNode = isShapeNode; exports.isStraightCubic = isStraightCubic; exports.isValidCanvasEdge = isValidCanvasEdge; exports.isValidCanvasNode = isValidCanvasNode; exports.isValidCanvasScene = isValidCanvasScene; exports.isValidUrl = isValidUrl; exports.layoutAll = layoutAll; exports.layoutBounds = layoutBounds; exports.layoutFrame = layoutFrame; exports.layoutUp = layoutUp; exports.layoutUpMany = layoutUpMany; exports.linearPositionTrajectory = linearPositionTrajectory; exports.linearTrajectory = linearTrajectory; exports.lockNodes = lockNodes; exports.makeSizingCoherent = makeSizingCoherent; exports.matchArrangeShortcut = _chunk26BVFKHUcjs.matchArrangeShortcut; exports.matchSize = matchSize; exports.measureBetween = measureBetween; exports.measureLabel = measureLabel; exports.measureSelection = measureSelection; exports.measureToLine = measureToLine; exports.mergeNodeUpdates = mergeNodeUpdates; exports.moveLayoutChild = moveLayoutChild; exports.multiPolygonArea = multiPolygonArea; exports.multiPolygonBounds = multiPolygonBounds; exports.nearestHandlePositions = nearestHandlePositions; exports.oppositePosition = oppositePosition; exports.overlaps = _chunkWADCJ7A7cjs.overlaps; exports.pageHidden = pageHidden; exports.parseCanvasClipboardData = parseCanvasClipboardData; exports.parseCanvasScenes = parseCanvasScenes; exports.parseSvgPath = parseSvgPath; exports.placeBeside = _chunkWADCJ7A7cjs.placeBeside; exports.pointInMultiPolygon = pointInMultiPolygon; exports.pointInRings = pointInRings; exports.polygonArea = polygonArea; exports.polygonBoolean = polygonBoolean; exports.polygonToSvgPath = polygonToSvgPath; exports.positionToSide = positionToSide; exports.readStyleSize = readStyleSize; exports.realClock = realClock; exports.relayoutUpdates = relayoutUpdates; exports.remapPastedNodes = remapPastedNodes; exports.reorderNodes = reorderNodes; exports.repositionNodesTo = repositionNodesTo; exports.resizeHandleAxes = resizeHandleAxes; exports.resolvePadding = resolvePadding; exports.revertShapeCombination = revertShapeCombination; exports.ringSignedArea = ringSignedArea; exports.runMultiNodeTransition = runMultiNodeTransition; exports.serializeCanvasNodes = serializeCanvasNodes; exports.shapeNodeToPolygon = shapeNodeToPolygon; exports.shapeToPolygon = shapeToPolygon; exports.sideToPosition = sideToPosition; exports.simplifyRing = simplifyRing; exports.snapNodeDrag = snapNodeDrag; exports.snapNodeResize = snapNodeResize; exports.snapResize = snapResize; exports.snapToGrid = snapToGrid; exports.subtractPolygons = subtractPolygons; exports.toggleLockNodes = toggleLockNodes; exports.unionPolygons = unionPolygons; exports.unlockNodes = unlockNodes; exports.withStyleOpacity = withStyleOpacity; exports.withStyleSize = withStyleSize; exports.xorPolygons = xorPolygons;
+exports.AUTO_LAYOUT_DATA_KEY = AUTO_LAYOUT_DATA_KEY; exports.CANVAS_TOKEN_PROPERTIES = CANVAS_TOKEN_PROPERTIES; exports.CHILD_LAYOUT_DATA_KEY = CHILD_LAYOUT_DATA_KEY; exports.CONNECTION_LINE_TYPES = CONNECTION_LINE_TYPES; exports.CanvasScenesStore = CanvasScenesStore; exports.DEFAULT_ARRANGE_SHORTCUTS = _chunk26BVFKHUcjs.DEFAULT_ARRANGE_SHORTCUTS; exports.DEFAULT_NODE_HEIGHT = _chunkWADCJ7A7cjs.DEFAULT_NODE_HEIGHT; exports.DEFAULT_NODE_WIDTH = _chunkWADCJ7A7cjs.DEFAULT_NODE_WIDTH; exports.DEFAULT_PLACEMENT_GAP = _chunkWADCJ7A7cjs.DEFAULT_PLACEMENT_GAP; exports.LOCKED_DATA_KEY = LOCKED_DATA_KEY; exports.LOCKED_PREVIOUS_FLAGS_KEY = LOCKED_PREVIOUS_FLAGS_KEY; exports.ManualClock = ManualClock; exports.PathOpsError = PathOpsError; exports.RESIZE_HANDLES = RESIZE_HANDLES; exports.SHAPE_DATA_KEY = SHAPE_DATA_KEY; exports.SHAPE_KINDS = SHAPE_KINDS; exports.SHAPE_NODE_TYPE = SHAPE_NODE_TYPE; exports.SHAPE_OPERATIONS = SHAPE_OPERATIONS; exports.StreamingLayoutManager = StreamingLayoutManager; exports.TOKEN_BINDINGS_DATA_KEY = TOKEN_BINDINGS_DATA_KEY; exports.TOKEN_MODES_DATA_KEY = TOKEN_MODES_DATA_KEY; exports.alignNodes = alignNodes; exports.applyConstraints = applyConstraints; exports.applyNodeUpdates = applyNodeUpdates; exports.applyShapeCombination = applyShapeCombination; exports.applyShapeReplacement = applyShapeReplacement; exports.arcToCubics = arcToCubics; exports.bezierPathArea = bezierPathArea; exports.bezierPathBounds = bezierPathBounds; exports.bezierPathLength = bezierPathLength; exports.bezierPathPointAtLength = bezierPathPointAtLength; exports.bezierPathSignedArea = bezierPathSignedArea; exports.bezierPathToSvg = bezierPathToSvg; exports.bindCanvasToken = bindCanvasToken; exports.blendLayout = blendLayout; exports.boundsOf = _chunkWADCJ7A7cjs.boundsOf; exports.calculateDagreReflowDisplacement = calculateDagreReflowDisplacement; exports.calculateDirectionalDisplacement = calculateDirectionalDisplacement; exports.canCombineShapeNodes = canCombineShapeNodes; exports.canOffsetShapeNodes = canOffsetShapeNodes; exports.canOutlineShapeNodeStrokes = canOutlineShapeNodeStrokes; exports.canvasHeight = canvasHeight; exports.centerNodes = _chunkWADCJ7A7cjs.centerNodes; exports.centre = _chunkWADCJ7A7cjs.centre; exports.clampLayoutSize = clampLayoutSize; exports.closeContour = closeContour; exports.collectDescendantIds = collectDescendantIds; exports.combineShapeNodes = combineShapeNodes; exports.computeNodesBoundingBox = computeNodesBoundingBox; exports.computeSnapGuides = computeSnapGuides; exports.connectedOnly = connectedOnly; exports.contourSignedArea = contourSignedArea; exports.contoursToPath = contoursToPath; exports.countPathSegments = countPathSegments; exports.createBezierTrajectory = createBezierTrajectory; exports.createCanvasArrangeController = createCanvasArrangeController; exports.createCanvasAutoLayoutController = createCanvasAutoLayoutController; exports.createCanvasScenesStore = createCanvasScenesStore; exports.createFanOutTrajectory = createFanOutTrajectory; exports.createGuideIndex = createGuideIndex; exports.createNodeGuideIndex = createNodeGuideIndex; exports.createNodeLookup = createNodeLookup; exports.cubicPointAt = cubicPointAt; exports.cubicsToPathData = cubicsToPathData; exports.dashContours = dashContours; exports.defaultEasing = defaultEasing; exports.detachTokenBindings = detachTokenBindings; exports.distanceToBezierPath = distanceToBezierPath; exports.distributeNodes = distributeNodes; exports.dividePaths = dividePaths; exports.dividePolygons = dividePolygons; exports.ensureLayout = _chunkWADCJ7A7cjs.ensureLayout; exports.estimateCanvasHeight = estimateCanvasHeight; exports.estimateNodeSize = _chunkWADCJ7A7cjs.estimateNodeSize; exports.excludePaths = excludePaths; exports.findConnectorSnap = findConnectorSnap; exports.fitCubicRun = fitCubicRun; exports.fitCubics = fitCubics; exports.fitFreehandPath = fitFreehandPath; exports.fitPathData = fitPathData; exports.fitViewportToNodes = fitViewportToNodes; exports.fitViewportToRect = fitViewportToRect; exports.flattenSvgPath = flattenSvgPath; exports.flowSide = _chunkWADCJ7A7cjs.flowSide; exports.formatNumber = formatNumber2; exports.getAbsolutePosition = getAbsolutePosition; exports.getAutoLayout = getAutoLayout; exports.getAutoLayoutGrid = getAutoLayoutGrid; exports.getAutoLayoutInsertTarget = getAutoLayoutInsertTarget; exports.getBindableTokenProperties = getBindableTokenProperties; exports.getCanvasTokenProperty = getCanvasTokenProperty; exports.getCenteredNodePosition = _chunkWADCJ7A7cjs.getCenteredNodePosition; exports.getChildLayout = getChildLayout; exports.getEffectiveTokenModes = getEffectiveTokenModes; exports.getFlowChildren = getFlowChildren; exports.getLayoutParent = getLayoutParent; exports.getLayoutSizing = getLayoutSizing; exports.getLayoutedNodes = _chunkWADCJ7A7cjs.getLayoutedNodes; exports.getNodeRect = getNodeRect; exports.getNodeShape = getNodeShape; exports.getNodeSize = getNodeSize; exports.getNodeTokenBindings = getNodeTokenBindings; exports.getNodeTokenModes = getNodeTokenModes; exports.getResizingNodeRect = getResizingNodeRect; exports.getShapeRenderData = getShapeRenderData; exports.getShapeSvg = getShapeSvg; exports.getTokenPropertyScope = getTokenPropertyScope; exports.getTokensForProperty = getTokensForProperty; exports.handlePoint = handlePoint; exports.hasVisibleStroke = hasVisibleStroke; exports.inferResizeHandle = inferResizeHandle; exports.inspectNodeTokens = inspectNodeTokens; exports.intersectPaths = intersectPaths; exports.intersectPolygons = intersectPolygons; exports.invertNodeUpdates = invertNodeUpdates; exports.isAutoLayoutFrame = isAutoLayoutFrame; exports.isEventFromTextInput = isEventFromTextInput; exports.isLocked = isLocked; exports.isMeasureModifierHeld = isMeasureModifierHeld; exports.isShapeDescription = isShapeDescription; exports.isShapeNode = isShapeNode; exports.isStraightCubic = isStraightCubic; exports.isValidCanvasEdge = isValidCanvasEdge; exports.isValidCanvasNode = isValidCanvasNode; exports.isValidCanvasScene = isValidCanvasScene; exports.isValidUrl = isValidUrl; exports.layoutAll = layoutAll; exports.layoutBounds = layoutBounds; exports.layoutFrame = layoutFrame; exports.layoutUp = layoutUp; exports.layoutUpMany = layoutUpMany; exports.linearPositionTrajectory = linearPositionTrajectory; exports.linearTrajectory = linearTrajectory; exports.lockNodes = lockNodes; exports.makeSizingCoherent = makeSizingCoherent; exports.matchArrangeShortcut = _chunk26BVFKHUcjs.matchArrangeShortcut; exports.matchSize = matchSize; exports.measureBetween = measureBetween; exports.measureLabel = measureLabel; exports.measureSelection = measureSelection; exports.measureToLine = measureToLine; exports.mergeNodeUpdates = mergeNodeUpdates; exports.moveLayoutChild = moveLayoutChild; exports.multiPolygonArea = multiPolygonArea; exports.multiPolygonBounds = multiPolygonBounds; exports.nearestHandlePositions = nearestHandlePositions; exports.normalizeBezierPath = normalizeBezierPath; exports.offsetPath = offsetPath; exports.offsetShapeNodes = offsetShapeNodes; exports.oppositePosition = oppositePosition; exports.outlineShapeNodeStrokes = outlineShapeNodeStrokes; exports.outlineStroke = outlineStroke; exports.overlaps = _chunkWADCJ7A7cjs.overlaps; exports.pageHidden = pageHidden; exports.parseCanvasClipboardData = parseCanvasClipboardData; exports.parseCanvasScenes = parseCanvasScenes; exports.parseSvgPath = parseSvgPath; exports.pathBoolean = pathBoolean; exports.pathToContours = pathToContours; exports.placeBeside = _chunkWADCJ7A7cjs.placeBeside; exports.pointInBezierPath = pointInBezierPath; exports.pointInMultiPolygon = pointInMultiPolygon; exports.pointInRings = pointInRings; exports.polygonArea = polygonArea; exports.polygonBoolean = polygonBoolean; exports.polygonToSvgPath = polygonToSvgPath; exports.positionToSide = positionToSide; exports.pruneCanvasTokenModes = pruneCanvasTokenModes; exports.readNodeStyleProperty = readNodeStyleProperty; exports.readStyleSize = readStyleSize; exports.realClock = realClock; exports.relayoutUpdates = relayoutUpdates; exports.remapPastedNodes = remapPastedNodes; exports.reorderNodes = reorderNodes; exports.repositionNodesTo = repositionNodesTo; exports.resizeHandleAxes = resizeHandleAxes; exports.resolveCanvasTokens = resolveCanvasTokens; exports.resolvePadding = resolvePadding; exports.revertShapeCombination = revertShapeCombination; exports.ringSignedArea = ringSignedArea; exports.runMultiNodeTransition = runMultiNodeTransition; exports.segmentBounds = segmentBounds; exports.segmentCurvature = segmentCurvature; exports.segmentDerivative = segmentDerivative; exports.segmentExtrema = segmentExtrema; exports.segmentLength = segmentLength; exports.segmentNearest = segmentNearest; exports.segmentParamAtLength = segmentParamAtLength; exports.segmentPoint = segmentPoint; exports.segmentTangent = segmentTangent; exports.serializeCanvasNodes = serializeCanvasNodes; exports.setCanvasTokenMode = setCanvasTokenMode; exports.shapeNodeToBezierPath = shapeNodeToBezierPath; exports.shapeNodeToPolygon = shapeNodeToPolygon; exports.shapeToBezierPath = shapeToBezierPath; exports.shapeToPolygon = shapeToPolygon; exports.sideToPosition = sideToPosition; exports.simplifyRing = simplifyRing; exports.snapNodeDrag = snapNodeDrag; exports.snapNodeResize = snapNodeResize; exports.snapResize = snapResize; exports.snapToGrid = snapToGrid; exports.splitSegment = splitSegment; exports.strokeOutlineRings = strokeOutlineRings; exports.subSegment = subSegment; exports.subtractPaths = subtractPaths; exports.subtractPolygons = subtractPolygons; exports.toBezierPath = toBezierPath; exports.toggleLockNodes = toggleLockNodes; exports.transformBezierPath = transformBezierPath; exports.trimSegments = trimSegments; exports.unionPolygons = unionPolygons; exports.unitePaths = unitePaths; exports.unlockNodes = unlockNodes; exports.windingNumber = windingNumber; exports.withStyleOpacity = withStyleOpacity; exports.withStyleSize = withStyleSize; exports.writeNodeStyleProperty = writeNodeStyleProperty; exports.xorPolygons = xorPolygons;
 //# sourceMappingURL=index.cjs.map