@pixerate/editor 0.23.0 → 0.25.0

package/dist/canvas/index.js

@@ -2,6 +2,13 @@ import {
   DEFAULT_ARRANGE_SHORTCUTS,
   matchArrangeShortcut
 } from "../chunk-7DWMJCAT.js";
+import {
+  TokenError,
+  getTokenCollection,
+  getTokenVariable,
+  isTokenInScope,
+  resolveToken
+} from "../chunk-HRMEDT2L.js";
 import {
   DEFAULT_NODE_HEIGHT,
   DEFAULT_NODE_WIDTH,
@@ -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
     };
   };
@@ -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;
@@ -1577,10 +1584,10 @@ var CanvasScenesStore = class {
     return this.update(id, { name });
   }
   /** Moves a scene to `toIndex` (clamped). */
-  move(id, toIndex) {
+  move(id, toIndex2) {
     const from = this.scenes.findIndex((s) => s.id === id);
     if (from === -1) return;
-    const to = Math.max(0, Math.min(this.scenes.length - 1, Math.trunc(toIndex)));
+    const to = Math.max(0, Math.min(this.scenes.length - 1, Math.trunc(toIndex2)));
     if (from === to) return;
     const scenes = [...this.scenes];
     const [scene] = scenes.splice(from, 1);
@@ -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,253 +3043,2539 @@ 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(node.data?.[SHAPE_DATA_KEY]);
-}
-function getNodeShape(node) {
-  const shape = node?.data?.[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 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) => 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 = 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 = 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: options.curves ?? "fit",
-      curveTolerance: 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
-    } = 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 };
+  return { minX, minY, maxX, maxY };
 }
-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);
+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 };
   }
+  return best;
+}
+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 = lo; i < values.length && values[i] <= v + tolerance; i++) out.push(values[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 matching(axis, v, eps) {
-  const { values, rects } = axis;
+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 = [];
-  for (let i = 0; i < values.length; i++) if (Math.abs(values[i] - v) <= eps) out.push(rects[i]);
+  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;
+    }
+  };
+  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 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 = (options.threshold ?? 6) / zoom;
-  const eps = 0.5 / zoom;
-  const useEdges = options.edges !== false;
-  const useCentres = options.centres !== false;
-  const grid = 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 = (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 ? options.gridOrigin?.x ?? 0 : options.gridOrigin?.y ?? 0;
-      consider([snapToGrid(moving, grid, origin)], "grid");
+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);
     }
-    return best;
+    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 = options.precision ?? 3;
+  const dx = options.offset?.x ?? 0;
+  const dy = options.offset?.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 = 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) ? input.fillRule ?? "nonzero" : "nonzero";
+  const chains = [];
+  for (const contour of pathToContours(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 = class {
+  constructor(eps) {
+    this.eps = eps;
+  }
+  eps;
+  vertices = [];
+  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;
+  }
+};
+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 = cluster?.[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(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: 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 = 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 {
+  bands;
+  min;
+  size;
+  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 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 = outgoing.get(incoming.to.id)?.filter((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) ? input.fillRule ?? "nonzero" : "nonzero";
+  const rings = pathToContours(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;
+    options.onFallback?.(reason);
+    const tolerance = 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;
+    options.onFallback?.(reason);
+    const tolerance = 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 = contour.segments[0]?.[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 best?.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: 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: options.cap ?? "butt" };
+  let contours = pathToContours(input);
+  const rings = [];
+  if (options.dash && options.dash.length > 0) {
+    const dashed = dashContours(contours, options.dash, 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 {
+    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 {
+    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 = 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: 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 {
+    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(node.data?.[SHAPE_DATA_KEY]);
+}
+function getNodeShape(node) {
+  const shape = node?.data?.[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 = 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) => 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 = 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 = options.createId ?? defaultId2;
+  const buildOptions = {
+    precision: options.precision,
+    nodeType: options.nodeType,
+    select: options.select,
+    parentOrigin,
+    sharedParent
+  };
+  const engine = 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: options.curves ?? "fit",
+        curveTolerance: 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: 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(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
+  } = 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 = 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 = 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 = 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: 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 = (options.threshold ?? 6) / zoom;
+  const eps = 0.5 / zoom;
+  const useEdges = options.edges !== false;
+  const useCentres = options.centres !== false;
+  const grid = 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 = (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 ? options.gridOrigin?.x ?? 0 : options.gridOrigin?.y ?? 0;
+      consider([snapToGrid(moving, grid, origin)], "grid");
+    }
+    return best;
   };
   let nx0 = x0;
   let nx1 = x1;
@@ -3301,8 +5594,8 @@ function snapResize(rect, handle, targets, options = {}) {
   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;
@@ -3359,33 +5652,915 @@ function snapResize(rect, handle, targets, options = {}) {
     changed
   };
 }
-function snapNodeResize(nodes, id, rect, handle, options = {}) {
-  const lookup = createNodeLookup(nodes);
-  const node = lookup.get(id);
-  if (!node || isLocked(node)) {
-    return { rect: { ...rect }, guides: [], snappedX: false, snappedY: false, changed: false, updates: [] };
+function snapNodeResize(nodes, id, rect, handle, options = {}) {
+  const lookup = createNodeLookup(nodes);
+  const node = lookup.get(id);
+  if (!node || isLocked(node)) {
+    return { rect: { ...rect }, guides: [], snappedX: false, snappedY: false, changed: false, updates: [] };
+  }
+  const index = options.index ?? createNodeGuideIndex(nodes, [id], options);
+  const result = snapResize(rect, handle, index, options);
+  if (!result.changed) return { ...result, updates: [] };
+  const parent = node.parentId ? lookup.get(node.parentId) : void 0;
+  const origin = parent ? getAbsolutePosition(parent, lookup) : { x: 0, y: 0 };
+  return {
+    ...result,
+    updates: [
+      {
+        id,
+        position: { x: result.rect.x - origin.x, y: result.rect.y - origin.y },
+        width: result.rect.width,
+        height: result.rect.height
+      }
+    ]
+  };
+}
+function getResizingNodeRect(node, lookup, options = {}) {
+  const { x, y } = node.parentId ? getAbsolutePosition(node, lookup) : node.position;
+  const size = getNodeSize(node, options);
+  return { x, y, width: node.width ?? size.width, height: node.height ?? size.height };
+}
+
+// src/canvas/autoLayout.ts
+var AUTO_LAYOUT_DATA_KEY = "layout";
+var CHILD_LAYOUT_DATA_KEY = "childLayout";
+var MODES = /* @__PURE__ */ new Set(["horizontal", "vertical", "grid"]);
+var EPS = 1e-6;
+var MAX_TRACKS = 1e3;
+var MAX_GRID_CELLS = 1e6;
+function clampLayoutSize(value, min, max) {
+  let v = Number.isFinite(value) ? Math.max(value, 0) : 0;
+  if (typeof max === "number" && Number.isFinite(max)) v = Math.min(v, max);
+  if (typeof min === "number" && Number.isFinite(min)) v = Math.max(v, min);
+  return v;
+}
+var finite = (v) => typeof v === "number" && Number.isFinite(v) ? v : 0;
+function getAutoLayout(node) {
+  const layout2 = node?.data?.[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 = node?.data?.[CHILD_LAYOUT_DATA_KEY];
+  return child && typeof child === "object" ? child : {};
+}
+function getLayoutSizing(node, axis) {
+  const value = getChildLayout(node).sizing?.[axis] ?? getAutoLayout(node)?.sizing?.[axis];
+  return value === "hug" || value === "fill" ? value : "fixed";
+}
+function limitsOf(node) {
+  const child = getChildLayout(node);
+  const layout2 = getAutoLayout(node);
+  const min = child.min ?? layout2?.min ?? {};
+  const max = child.max ?? layout2?.max ?? {};
+  return { minW: min.width, maxW: max.width, minH: min.height, maxH: max.height };
+}
+function resolvePadding(padding) {
+  let sides;
+  if (typeof padding === "number") sides = [padding, padding, padding, padding];
+  else if (Array.isArray(padding)) {
+    sides = padding.length === 2 ? [padding[0], padding[1], padding[0], padding[1]] : [padding[0], padding[1], padding[2], padding[3]];
+  } else if (padding && typeof padding === "object") sides = [padding.top, padding.right, padding.bottom, padding.left];
+  else sides = [0, 0, 0, 0];
+  return sides.map((p) => Math.max(finite(p), 0));
+}
+var LayoutState = class {
+  boxes = /* @__PURE__ */ new Map();
+  measure;
+  visiting = /* @__PURE__ */ new Set();
+  original = /* @__PURE__ */ new Map();
+  constructor(nodes, options = {}) {
+    this.measure = options.measure ?? {};
+    for (const node of nodes) {
+      const size = this.measure.size?.(node) ?? getNodeSize(node, options.rectOptions);
+      const box = {
+        id: node.id,
+        node,
+        parent: node.parentId,
+        x: finite(node.position?.x),
+        y: finite(node.position?.y),
+        w: finite(size.width),
+        h: finite(size.height),
+        kids: []
+      };
+      this.boxes.set(node.id, box);
+      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) this.boxes.get(node.parentId)?.kids.push(node.id);
+    }
+  }
+  updates() {
+    const out = [];
+    for (const [id, box] of this.boxes) {
+      const o = this.original.get(id);
+      const update = { id };
+      if (Math.abs(box.x - o.x) > EPS || Math.abs(box.y - o.y) > EPS) update.position = { x: box.x, y: box.y };
+      if (Math.abs(box.w - o.w) > EPS) update.width = box.w;
+      if (Math.abs(box.h - o.h) > EPS) update.height = box.h;
+      if (update.position || update.width !== void 0 || update.height !== void 0) out.push(update);
+    }
+    return out;
+  }
+  /** Runs `fn` for `id` unless it is already on the stack (guards `parentId` cycles). */
+  guard(id, fn) {
+    if (this.visiting.has(id)) return;
+    this.visiting.add(id);
+    try {
+      fn();
+    } finally {
+      this.visiting.delete(id);
+    }
+  }
+  ancestors(id) {
+    const out = [];
+    const seen = /* @__PURE__ */ new Set([id]);
+    let parent = this.boxes.get(id)?.parent;
+    while (parent && !seen.has(parent) && this.boxes.has(parent)) {
+      out.push(parent);
+      seen.add(parent);
+      parent = this.boxes.get(parent).parent;
+    }
+    return out;
+  }
+};
+function setSize(s, id, w, h) {
+  const b = s.boxes.get(id);
+  if (!b) return;
+  b.w = Number.isFinite(w) ? Math.max(w, 0) : b.w;
+  b.h = Number.isFinite(h) ? Math.max(h, 0) : b.h;
+}
+function place(s, id, x, y) {
+  const b = s.boxes.get(id);
+  if (!b) return;
+  b.x = x;
+  b.y = y;
+}
+var isText = (s, b) => !!s.measure.textSize && s.measure.textSize(b.node) !== void 0;
+function flowChildren(s, frame) {
+  const f = s.boxes.get(frame);
+  if (!f) return [];
+  return f.kids.filter((k) => {
+    const n = s.boxes.get(k).node;
+    return n.hidden !== true && !getChildLayout(n).absolute;
+  });
+}
+function fitHugText(s, id) {
+  const b = s.boxes.get(id);
+  if (!b || !isText(s, b)) return;
+  const natural = s.measure.textSize(b.node);
+  const { minW, maxW } = limitsOf(b.node);
+  if (getLayoutSizing(b.node, "width") === "hug") {
+    const w = clampLayoutSize(natural.width, minW, maxW);
+    const limited = Math.abs(w - natural.width) > EPS;
+    const h = limited ? s.measure.textHeight?.(b.node, w) ?? natural.height : natural.height;
+    setSize(s, id, w, h);
+  } else if (getLayoutSizing(b.node, "height") === "hug") {
+    setSize(s, id, b.w, s.measure.textHeight?.(b.node, b.w) ?? b.h);
+  }
+}
+function enforceLimits(s, id) {
+  const b = s.boxes.get(id);
+  if (!b) return;
+  const { minW, maxW, minH, maxH } = limitsOf(b.node);
+  if (minW === void 0 && maxW === void 0 && minH === void 0 && maxH === void 0) return;
+  const nw = clampLayoutSize(b.w, minW, maxW);
+  const nh = clampLayoutSize(b.h, minH, maxH);
+  if (Math.abs(nw - b.w) < 1e-9 && Math.abs(nh - b.h) < 1e-9) return;
+  if (isText(s, b)) setSize(s, id, nw, nh);
+  else resizeChild(s, id, nw, nh);
+}
+function itemBaseline(s, id, depth) {
+  const b = s.boxes.get(id);
+  if (!b) return void 0;
+  if (isText(s, b)) {
+    const v = s.measure.textBaseline?.(b.node);
+    return typeof v === "number" && Number.isFinite(v) ? v : void 0;
+  }
+  const layout2 = getAutoLayout(b.node);
+  if (!layout2 || layout2.mode === "grid" || depth >= 32) return void 0;
+  for (const k of flowChildren(s, id)) {
+    const base = itemBaseline(s, k, depth + 1);
+    if (base !== void 0) return s.boxes.get(k).y + base;
+  }
+  return void 0;
+}
+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, s.measure.textHeight?.(b.node, w) ?? h);
+    return;
+  }
+  const ow = b.w;
+  const oh = b.h;
+  setSize(s, id, w, h);
+  if (b.kids.length > 0) constrain(s, id, ow, oh);
+  if (getAutoLayout(b.node)) layout(s, id);
+}
+function mainOffsets(align, inner, total, n, gap) {
+  const gaps = gap * Math.max(n - 1, 0);
+  const free = inner - total;
+  const k = Math.max(n, 1);
+  switch (align) {
+    case "center":
+      return [(free - gaps) / 2, gap];
+    case "end":
+      return [free - gaps, gap];
+    case "space-between":
+      return [0, n > 1 ? Math.max(free / (n - 1), 0) : 0];
+    case "space-around": {
+      const g = Math.max(free / k, 0);
+      return [g / 2, g];
+    }
+    case "space-evenly": {
+      const g = Math.max(free / (k + 1), 0);
+      return [g, g];
+    }
+    default:
+      return [0, gap];
+  }
+}
+function distribute(items, open, free) {
+  free = Math.max(free, 0);
+  while (open.length > 0) {
+    const share = free / open.length;
+    const sized = open.map((i) => [i, clampLayoutSize(share, items[i].minMain, items[i].maxMain)]);
+    const violation = sized.reduce((sum, [, v]) => sum + (v - share), 0);
+    const frozen = (v) => Math.abs(violation) < 1e-9 || violation > 0 && v > share + 1e-9 || violation < 0 && v < share - 1e-9;
+    for (const [i, v] of sized) {
+      if (frozen(v)) {
+        items[i].main = v;
+        free -= v;
+      }
+    }
+    free = Math.max(free, 0);
+    open = sized.filter(([, v]) => !frozen(v)).map(([i]) => i);
+  }
+}
+function layout(s, frame) {
+  s.guard(frame, () => layoutFrameInner(s, frame));
+}
+function layoutFrameInner(s, frame) {
+  const f = s.boxes.get(frame);
+  const al = f && getAutoLayout(f.node);
+  if (!f || !al) return;
+  const horizontal = al.mode !== "vertical";
+  const hugW = getLayoutSizing(f.node, "width") === "hug";
+  const hugH = getLayoutSizing(f.node, "height") === "hug";
+  const ow = f.w;
+  const oh = f.h;
+  const fl = limitsOf(f.node);
+  const [pt, pr, pb, pl] = resolvePadding(al.padding);
+  const fw = Math.max(clampLayoutSize(ow, fl.minW, fl.maxW), pl + pr);
+  const fh = Math.max(clampLayoutSize(oh, fl.minH, fl.maxH), pt + pb);
+  const kids = flowChildren(s, frame);
+  for (const c of kids) {
+    fitHugText(s, c);
+    enforceLimits(s, c);
+  }
+  if (al.mode === "grid") {
+    layoutGrid(s, frame, al);
+    return;
+  }
+  const innerMainFixed = horizontal ? fw - pl - pr : fh - pt - pb;
+  const innerCrossFixed = horizontal ? fh - pt - pb : fw - pl - pr;
+  const hugMain = horizontal ? hugW : hugH;
+  const hugCross = horizontal ? hugH : hugW;
+  const alignCross = al.alignCross ?? "start";
+  const baseline = horizontal && alignCross === "baseline";
+  const stretch = alignCross === "stretch";
+  const items = [];
+  for (const c of kids) {
+    const b = s.boxes.get(c);
+    const lim = limitsOf(b.node);
+    const sm = getLayoutSizing(b.node, horizontal ? "width" : "height");
+    const sc = getLayoutSizing(b.node, horizontal ? "height" : "width");
+    items.push({
+      id: c,
+      main: horizontal ? b.w : b.h,
+      cross: horizontal ? b.h : b.w,
+      // Fill needs room to fill: on an axis the frame hugs it reads as fixed.
+      fillMain: sm === "fill" && !hugMain,
+      fillCross: (sc === "fill" || stretch && sc !== "hug") && !hugCross,
+      minMain: horizontal ? lim.minW : lim.minH,
+      maxMain: horizontal ? lim.maxW : lim.maxH,
+      minCross: horizontal ? lim.minH : lim.minW,
+      maxCross: horizontal ? lim.maxH : lim.maxW,
+      baseOff: 0
+    });
+  }
+  const gap = finite(al.gap);
+  const alignMain = al.alignMain ?? "start";
+  const autoGap = alignMain === "space-between" || alignMain === "space-around" || alignMain === "space-evenly";
+  const wraps = !!al.wrap && !hugMain;
+  const sizeOf = (id) => {
+    const b = s.boxes.get(id);
+    return horizontal ? [b.w, b.h] : [b.h, b.w];
+  };
+  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;
+      resize(it, it.main, clampLayoutSize(innerCrossFixed, it.minCross, it.maxCross));
+      it.main = sizeOf(it.id)[0];
+    }
+  }
+  const lines = [];
+  if (wraps) {
+    let cur = [];
+    let used = 0;
+    items.forEach((it, i) => {
+      const sz = it.fillMain ? it.minMain ?? 0 : it.main;
+      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 += add3;
+      }
+      cur.push(i);
+    });
+    if (cur.length > 0) lines.push(cur);
+  } else {
+    lines.push(items.map((_, i) => i));
+  }
+  for (const line2 of lines) {
+    const fixed = line2.filter((i) => !items[i].fillMain).reduce((sum, i) => sum + items[i].main, 0);
+    const gaps = gap * Math.max(line2.length - 1, 0);
+    const fills = line2.filter((i) => items[i].fillMain);
+    if (fills.length > 0) distribute(items, fills, innerMainFixed - fixed - (autoGap ? 0 : gaps));
+  }
+  for (const it of items) {
+    if (!it.fillMain) continue;
+    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) {
+    for (const it of items) if (!it.fillCross) it.baseline = itemBaseline(s, it.id, 0);
+  }
+  const extents = [];
+  for (const line2 of lines) {
+    const gaps = gap * Math.max(line2.length - 1, 0);
+    const lineBase = line2.reduce((m, i) => Math.max(m, items[i].baseline ?? 0), 0);
+    for (const i of line2) items[i].baseOff = items[i].baseline !== void 0 ? lineBase - items[i].baseline : 0;
+    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 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;
+  const contentCross = extents.reduce((sum, l) => sum + l[1], 0) + crossGap * Math.max(lines.length - 1, 0);
+  let nw = fw;
+  let nh = fh;
+  if (hugMain) {
+    const v = contentMain + (horizontal ? pl + pr : pt + pb);
+    if (horizontal) nw = v;
+    else nh = v;
+  }
+  if (hugCross) {
+    const v = contentCross + (horizontal ? pt + pb : pl + pr);
+    if (horizontal) nh = v;
+    else nw = v;
+  }
+  nw = Math.max(clampLayoutSize(nw, fl.minW, fl.maxW), pl + pr);
+  nh = Math.max(clampLayoutSize(nh, fl.minH, fl.maxH), pt + pb);
+  setSize(s, frame, nw, nh);
+  constrain(s, frame, ow, oh);
+  const innerMain = horizontal ? nw - pl - pr : nh - pt - pb;
+  const innerCross = horizontal ? nh - pt - pb : nw - pl - pr;
+  let crossPos = horizontal ? pt : pl;
+  const single = lines.length === 1;
+  if (lines.length > 1) {
+    const linesCross = extents.reduce((sum, l) => sum + l[1], 0);
+    const between = lines.length - 1;
+    const spread = (innerCross - linesCross) / between;
+    const spaceBetween = al.alignContent === "space-between";
+    if (spaceBetween && spread > 0) {
+      crossGap = spread;
+    } else {
+      if (spaceBetween) crossGap = 0;
+      const free = innerCross - linesCross - crossGap * between;
+      if (free > 0 && items.every((it) => it.fillCross)) {
+        const extra = free / lines.length;
+        for (const l of extents) l[1] += extra;
+      } else if (Number.isFinite(free)) {
+        crossPos += alignCross === "center" ? free / 2 : alignCross === "end" ? free : 0;
+      }
+    }
+  }
+  lines.forEach((line2, li) => {
+    const [used, ownCross] = extents[li];
+    const lineCross = single ? innerCross : ownCross;
+    const total = used - gap * Math.max(line2.length - 1, 0);
+    let [pos, step] = mainOffsets(alignMain, innerMain, total, line2.length, gap);
+    pos += horizontal ? pl : pt;
+    for (const i of line2) {
+      const it = items[i];
+      const crossSize = it.fillCross ? clampLayoutSize(lineCross, it.minCross, it.maxCross) : it.cross;
+      let off = 0;
+      if (alignCross === "baseline") off = it.baseOff;
+      else if (alignCross === "center") off = (lineCross - crossSize) / 2;
+      else if (alignCross === "end") off = lineCross - crossSize;
+      if (it.fillCross && wraps) resize(it, it.main, crossSize);
+      const x = horizontal ? pos : crossPos + off;
+      const y = horizontal ? crossPos + off : pos;
+      place(s, it.id, finite(x), finite(y));
+      pos += it.main + step;
+    }
+    crossPos += lineCross + crossGap;
+  });
+}
+function parseTrack(track) {
+  if (typeof track === "number") return { sizing: "fixed", value: track };
+  if (track === "hug") return { sizing: "hug", value: 0 };
+  if (typeof track === "string") {
+    const match = /^\s*(-?\d*\.?\d+)\s*fr\s*$/i.exec(track);
+    if (match) return { sizing: "fill", value: Number(match[1]) };
+  }
+  if (track && typeof track === "object" && "fr" in track) return { sizing: "fill", value: track.fr };
+  return { sizing: "fill", value: 1 };
+}
+function trackList(spec, fallback) {
+  if (Array.isArray(spec)) return { count: Math.min(Math.max(spec.length, 1), MAX_TRACKS), tracks: spec.map(parseTrack) };
+  const n = typeof spec === "number" && Number.isFinite(spec) ? Math.floor(spec) : fallback;
+  return { count: Math.min(Math.max(n, 1), MAX_TRACKS), tracks: [] };
+}
+function trackSpec(tracks, i) {
+  const t = tracks[i] ?? { sizing: "fill", value: 1 };
+  const value = Number.isFinite(t.value) ? Math.min(Math.max(t.value, 0), 1e6) : 0;
+  return { sizing: t.sizing, value };
+}
+function cellRect(g, c) {
+  const x0 = g.columns[c.column]?.[0] ?? 0;
+  const x1 = g.columns[c.column + c.columnSpan - 1]?.[1] ?? x0;
+  const y0 = g.rows[c.row]?.[0] ?? 0;
+  const y1 = g.rows[c.row + c.rowSpan - 1]?.[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(al.grid?.columns, 2).count;
+  const minRows = trackList(al.grid?.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) => {
+    for (let ri = r; ri < r + rs; ri++) {
+      const row = occ[ri];
+      if (!row) continue;
+      for (let ci = c; ci < c + cs; ci++) if (row[ci]) return false;
+    }
+    return true;
+  };
+  const mark = (c, r, cs, rs) => {
+    while (occ.length < r + rs) occ.push(new Array(cols).fill(false));
+    for (let ri = r; ri < r + rs; ri++) for (let ci = c; ci < c + cs; ci++) occ[ri][ci] = true;
+  };
+  const spans = (id) => {
+    const area = getChildLayout(s.boxes.get(id).node).gridArea ?? {};
+    const cs = Math.min(Math.max(toIndex(area.columnSpan) ?? 1, 1), cols);
+    const rs = Math.min(Math.max(toIndex(area.rowSpan) ?? 1, 1), maxRows);
+    const col = toIndex(area.column);
+    const row = toIndex(area.row);
+    return {
+      col: col === void 0 ? void 0 : Math.min(col, cols - cs),
+      row: row === void 0 ? void 0 : Math.min(row, maxRows - rs),
+      cs,
+      rs
+    };
+  };
+  const placed = new Array(kids.length).fill(void 0);
+  kids.forEach((id, i) => {
+    const { col, row, cs, rs } = spans(id);
+    if (col !== void 0 && row !== void 0) {
+      mark(col, row, cs, rs);
+      placed[i] = { id, column: col, row, columnSpan: cs, rowSpan: rs };
+    }
+  });
+  let cursor = [0, 0];
+  kids.forEach((id, i) => {
+    if (placed[i]) return;
+    const { col, row, cs, rs } = spans(id);
+    const lastRow = maxRows - rs;
+    let c = 0;
+    let r = 0;
+    if (col !== void 0) {
+      r = lastRow;
+      for (let ri = 0; ri <= lastRow; ri++) if (free(col, ri, cs, rs)) {
+        r = ri;
+        break;
+      }
+      c = col;
+    } else if (row !== void 0) {
+      r = row;
+      for (let ci = 0; ci <= cols - cs; ci++) if (free(ci, row, cs, rs)) {
+        c = ci;
+        break;
+      }
+    } else {
+      let [rr, cc] = cursor;
+      let found;
+      while (rr <= lastRow) {
+        if (cc + cs <= cols && free(cc, rr, cs, rs)) {
+          found = [cc, rr];
+          break;
+        }
+        cc += 1;
+        if (cc + cs > cols) {
+          cc = 0;
+          rr += 1;
+        }
+      }
+      [c, r] = found ?? [0, lastRow];
+      cursor = [r, c + cs];
+    }
+    mark(c, r, cs, rs);
+    placed[i] = { id, column: c, row: r, columnSpan: cs, rowSpan: rs };
+  });
+  const cells = placed.filter((c) => !!c);
+  const rows = Math.max(cells.reduce((m, c) => Math.max(m, c.row + c.rowSpan), 0), minRows);
+  return { cells, rows: Math.min(rows, MAX_TRACKS) };
+}
+function resolveTracks(tracks, content, avail) {
+  const out = content.map((c, i) => {
+    const t = trackSpec(tracks, i);
+    return t.sizing === "fixed" ? t.value : c;
+  });
+  if (avail === void 0) return out;
+  const fr = (i) => trackSpec(tracks, i).value;
+  let flex = out.map((_, i) => i).filter((i) => trackSpec(tracks, i).sizing === "fill");
+  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 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] = unit3 * fr(i);
+      break;
+    }
+    used += frozen.reduce((sum, i) => sum + out[i], 0);
+    flex = open;
+  }
+  return out;
+}
+function trackContent(cells, sizes, tracks, n, gap, columns, hug) {
+  const byContent = (i) => trackSpec(tracks, i).sizing !== "fixed";
+  const content = Array.from({ length: n }, (_, i) => {
+    const t = trackSpec(tracks, i);
+    return t.sizing === "fixed" ? t.value : 0;
+  });
+  const span = (c) => columns ? [c.column, c.columnSpan] : [c.row, c.rowSpan];
+  cells.forEach((c, k) => {
+    const [start, len] = span(c);
+    if (len === 1 && byContent(start) && start < n) content[start] = Math.max(content[start], sizes[k]);
+  });
+  cells.forEach((c, k) => {
+    const [start, len] = span(c);
+    if (len < 2) return;
+    const range = Array.from({ length: len }, (_, j) => start + j).filter((i) => i < n);
+    if (!hug && range.some((i) => trackSpec(tracks, i).sizing === "fill")) return;
+    const have = range.reduce((sum, i) => sum + content[i], 0) + gap * (len - 1);
+    const grow = range.filter(byContent);
+    if (sizes[k] > have && grow.length > 0) {
+      const extra = (sizes[k] - have) / grow.length;
+      for (const i of grow) content[i] += extra;
+    }
+  });
+  return content;
+}
+function trackRanges(start, sizes, gap) {
+  let x = start;
+  return sizes.map((size) => {
+    const r = [x, x + size];
+    x += size + gap;
+    return r;
+  });
+}
+function gridGeometryOf(s, frame) {
+  const f = s.boxes.get(frame);
+  const al = f && getAutoLayout(f.node);
+  if (!f || !al || al.mode !== "grid") return void 0;
+  const [pt, pr, pb, pl] = resolvePadding(al.padding);
+  const kids = flowChildren(s, frame);
+  const { cells, rows } = gridPlace(s, al, kids);
+  const colSpec = trackList(al.grid?.columns, 2);
+  const rowSpec = trackList(al.grid?.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);
+  const hugW = getLayoutSizing(f.node, "width") === "hug";
+  const hugH = getLayoutSizing(f.node, "height") === "hug";
+  const ws = [];
+  const hs = [];
+  for (const c of cells) {
+    const b = s.boxes.get(c.id);
+    const lim2 = limitsOf(b.node);
+    ws.push(getLayoutSizing(b.node, "width") === "fill" && !hugW ? lim2.minW ?? 0 : b.w);
+    hs.push(getLayoutSizing(b.node, "height") === "fill" && !hugH ? lim2.minH ?? 0 : b.h);
+  }
+  const colContent = trackContent(cells, ws, colSpec.tracks, cols, gx, true, hugW);
+  const rowContent = trackContent(cells, hs, rowSpec.tracks, rows, gy, false, hugH);
+  const gapsW = gx * Math.max(cols - 1, 0);
+  const gapsH = gy * Math.max(rows - 1, 0);
+  const colW = resolveTracks(colSpec.tracks, colContent, hugW ? void 0 : finite(f.w) - pl - pr - gapsW);
+  const rowH = resolveTracks(rowSpec.tracks, rowContent, hugH ? void 0 : finite(f.h) - pt - pb - gapsH);
+  const lim = limitsOf(f.node);
+  const width = hugW ? colW.reduce((a, b) => a + b, 0) + gapsW + pl + pr : finite(f.w);
+  const height = hugH ? rowH.reduce((a, b) => a + b, 0) + gapsH + pt + pb : finite(f.h);
+  return {
+    columns: trackRanges(pl, colW, gx),
+    rows: trackRanges(pt, rowH, gy),
+    cells,
+    width: Math.max(clampLayoutSize(width, lim.minW, lim.maxW), pl + pr),
+    height: Math.max(clampLayoutSize(height, lim.minH, lim.maxH), pt + pb)
+  };
+}
+function layoutGrid(s, frame, al) {
+  const f = s.boxes.get(frame);
+  const fw = f.w;
+  const fh = f.h;
+  const hugW = getLayoutSizing(f.node, "width") === "hug";
+  const hugH = getLayoutSizing(f.node, "height") === "hug";
+  const lim = limitsOf(f.node);
+  const [pt, pr, pb, pl] = resolvePadding(al.padding);
+  setSize(
+    s,
+    frame,
+    hugW ? fw : Math.max(clampLayoutSize(fw, lim.minW, lim.maxW), pl + pr),
+    hugH ? fh : Math.max(clampLayoutSize(fh, lim.minH, lim.maxH), pt + pb)
+  );
+  let g = gridGeometryOf(s, frame);
+  if (!g) return;
+  let widened = false;
+  for (const c of g.cells) {
+    const b = s.boxes.get(c.id);
+    if (getLayoutSizing(b.node, "width") === "fill" && !hugW) {
+      const l = limitsOf(b.node);
+      resizeChild(s, c.id, clampLayoutSize(cellRect(g, c).width, l.minW, l.maxW), b.h);
+      widened = true;
+    }
   }
-  const index = options.index ?? createNodeGuideIndex(nodes, [id], options);
-  const result = snapResize(rect, handle, index, options);
-  if (!result.changed) return { ...result, updates: [] };
-  const parent = node.parentId ? lookup.get(node.parentId) : void 0;
-  const origin = parent ? getAbsolutePosition(parent, lookup) : { x: 0, y: 0 };
-  return {
-    ...result,
-    updates: [
-      {
-        id,
-        position: { x: result.rect.x - origin.x, y: result.rect.y - origin.y },
-        width: result.rect.width,
-        height: result.rect.height
+  if (widened) g = gridGeometryOf(s, frame) ?? g;
+  setSize(s, frame, g.width, g.height);
+  constrain(s, frame, fw, fh);
+  const frameX = al.alignMain === "center" ? "center" : al.alignMain === "end" ? "end" : "start";
+  const frameY = al.alignCross === "center" ? "center" : al.alignCross === "end" ? "end" : "start";
+  const offset = (a, free) => a === "center" ? free / 2 : a === "end" ? free : 0;
+  for (const c of g.cells) {
+    const cell = cellRect(g, c);
+    const b = s.boxes.get(c.id);
+    const l = limitsOf(b.node);
+    const area = getChildLayout(b.node).gridArea ?? {};
+    const fillW = getLayoutSizing(b.node, "width") === "fill" && !hugW;
+    const fillH = getLayoutSizing(b.node, "height") === "fill" && !hugH;
+    if (fillW || fillH) {
+      resizeChild(
+        s,
+        c.id,
+        fillW ? clampLayoutSize(cell.width, l.minW, l.maxW) : b.w,
+        fillH ? clampLayoutSize(cell.height, l.minH, l.maxH) : b.h
+      );
+    }
+    const ox = offset(area.alignX ?? frameX, cell.width - b.w);
+    const oy = offset(area.alignY ?? frameY, cell.height - b.h);
+    place(s, c.id, finite(cell.x + ox), finite(cell.y + oy));
+  }
+}
+function constrain(s, id, ow, oh) {
+  const f = s.boxes.get(id);
+  if (!f) return;
+  const nw = f.w;
+  const nh = f.h;
+  if (Math.abs(nw - ow) < 1e-9 && Math.abs(nh - oh) < 1e-9) return;
+  const absoluteOnly = !!getAutoLayout(f.node);
+  const sx = ow > 1e-9 ? nw / ow : 1;
+  const sy = oh > 1e-9 ? nh / oh : 1;
+  s.guard(`constrain:${id}`, () => {
+    for (const k of f.kids) {
+      const c = s.boxes.get(k);
+      const child = getChildLayout(c.node);
+      if (absoluteOnly && !child.absolute) continue;
+      let x0 = c.x;
+      let x1 = c.x + c.w;
+      let y0 = c.y;
+      let y1 = c.y + c.h;
+      const dx = nw - ow;
+      const dy = nh - oh;
+      switch (child.constraints?.horizontal ?? "left") {
+        case "right":
+          x0 += dx;
+          x1 += dx;
+          break;
+        case "leftRight":
+          x1 += dx;
+          break;
+        case "center":
+          x0 += dx / 2;
+          x1 += dx / 2;
+          break;
+        case "scale":
+          x0 *= sx;
+          x1 *= sx;
+          break;
       }
-    ]
+      switch (child.constraints?.vertical ?? "top") {
+        case "bottom":
+          y0 += dy;
+          y1 += dy;
+          break;
+        case "topBottom":
+          y1 += dy;
+          break;
+        case "center":
+          y0 += dy / 2;
+          y1 += dy / 2;
+          break;
+        case "scale":
+          y0 *= sy;
+          y1 *= sy;
+          break;
+      }
+      const cw = c.w;
+      const ch = c.h;
+      const resized = Math.abs(x1 - x0 - cw) > 1e-9 || Math.abs(y1 - y0 - ch) > 1e-9;
+      place(s, k, finite(x0), finite(y0));
+      if (resized) {
+        setSize(s, k, x1 - x0, y1 - y0);
+        if (c.kids.length > 0) constrain(s, k, cw, ch);
+        if (getAutoLayout(c.node)) layout(s, k);
+      }
+    }
+  });
+}
+function layoutFrame(nodes, frameId, options = {}) {
+  const s = new LayoutState(nodes, options);
+  layout(s, frameId);
+  return s.updates();
+}
+function postOrder(s, nodes) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (id) => {
+    if (seen.has(id)) return;
+    seen.add(id);
+    for (const k of s.boxes.get(id)?.kids ?? []) visit(k);
+    out.push(id);
   };
+  const roots = nodes.filter((n) => !n.parentId || !s.boxes.has(n.parentId));
+  for (const r of roots) visit(r.id);
+  for (const n of nodes) visit(n.id);
+  return out;
 }
-function getResizingNodeRect(node, lookup, options = {}) {
-  const { x, y } = node.parentId ? getAbsolutePosition(node, lookup) : node.position;
-  const size = getNodeSize(node, options);
-  return { x, y, width: node.width ?? size.width, height: node.height ?? size.height };
+function layoutAll(nodes, options = {}) {
+  const s = new LayoutState(nodes, options);
+  for (const id of postOrder(s, nodes)) if (getAutoLayout(s.boxes.get(id).node)) layout(s, id);
+  return s.updates();
+}
+function layoutUp(nodes, changedId, options = {}) {
+  return layoutUpMany(nodes, [changedId], options);
+}
+function layoutUpMany(nodes, changedIds, options = {}) {
+  const s = new LayoutState(nodes, options);
+  const chains = [...new Set(changedIds)].filter((id) => s.boxes.has(id)).map((id) => [id, ...s.ancestors(id)]);
+  const depth = /* @__PURE__ */ new Map();
+  for (const chain of chains) chain.forEach((id, i) => depth.set(id, Math.max(depth.get(id) ?? 0, chain.length - 1 - i)));
+  const order = [...depth.keys()].sort((a, b) => depth.get(b) - depth.get(a));
+  for (const id of order) if (getAutoLayout(s.boxes.get(id).node)) layout(s, id);
+  return s.updates();
+}
+function applyConstraints(nodes, parentId, previousSize, options = {}) {
+  const s = new LayoutState(nodes, options);
+  constrain(s, parentId, previousSize.width, previousSize.height);
+  return s.updates();
+}
+function getAutoLayoutGrid(nodes, frameId, options = {}) {
+  return gridGeometryOf(new LayoutState(nodes, options), frameId);
+}
+function getFlowChildren(nodes, frameId) {
+  return nodes.filter((n) => n.parentId === frameId && n.id !== frameId && n.hidden !== true && !getChildLayout(n).absolute).map((n) => n.id);
+}
+function getLayoutParent(nodes, id) {
+  const lookup = createNodeLookup(nodes);
+  const node = lookup.get(id);
+  if (!node?.parentId || getChildLayout(node).absolute) return void 0;
+  const parent = lookup.get(node.parentId);
+  return isAutoLayoutFrame(parent) ? parent : void 0;
+}
+function makeSizingCoherent(nodes, id, options = {}) {
+  const lookup = createNodeLookup(nodes);
+  const targets = /* @__PURE__ */ new Set([id, ...nodes.filter((n) => n.parentId === id).map((n) => n.id)]);
+  if (!lookup.has(id)) return nodes;
+  let changed = false;
+  const next = nodes.map((node) => {
+    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) || options.measure?.textSize?.(node) !== void 0;
+    const coherent = (axis) => {
+      const sizing = getLayoutSizing(node, axis);
+      if (sizing === "fill" && (!flowParent || getLayoutSizing(flowParent, axis) === "hug")) return "fixed";
+      if (sizing === "hug" && !canHug) return "fixed";
+      return sizing;
+    };
+    const width = coherent("width");
+    const height = coherent("height");
+    if (width === getLayoutSizing(node, "width") && height === getLayoutSizing(node, "height")) return node;
+    changed = true;
+    const child = getChildLayout(node);
+    return {
+      ...node,
+      data: { ...node.data, [CHILD_LAYOUT_DATA_KEY]: { ...child, sizing: { ...child.sizing, width, height } } }
+    };
+  });
+  return changed ? next : nodes;
+}
+function getAutoLayoutInsertTarget(nodes, frameId, point, options = {}) {
+  const lookup = createNodeLookup(nodes);
+  const frame = lookup.get(frameId);
+  const al = getAutoLayout(frame);
+  if (!frame || !al) return void 0;
+  const s = new LayoutState(nodes, options);
+  const origin = getAbsolutePosition(frame, lookup);
+  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 cross2 = (b) => horizontal ? b.y : b.x;
+  const crossSize = (b) => horizontal ? b.h : b.w;
+  const p = { x: px2, y: py };
+  const multiLine = al.mode === "grid" || !!al.wrap;
+  let index = 0;
+  for (const b of siblings) {
+    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);
+  const prev = siblings[index - 1];
+  const next = siblings[index];
+  const f = s.boxes.get(frameId);
+  let guide;
+  if (horizontal) {
+    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 = 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(cross2(prev) - cross2(next)) < 1e-6 ? (prev.y + prev.h + next.y) / 2 : prev ? prev.y + prev.h : next ? next.y : pt;
+    const ref = next ?? prev;
+    const x1 = ref ? ref.x : pl;
+    const x2 = ref ? ref.x + ref.w : f.w - pr;
+    guide = { orientation: "horizontal", kind: "edge", x1: origin.x + x1, y1: origin.y + y, x2: origin.x + x2, y2: origin.y + y };
+  }
+  return { frameId, index, guide };
+}
+function moveLayoutChild(nodes, childId, index) {
+  const child = nodes.find((n) => n.id === childId);
+  if (!child?.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);
+  const order = siblings.filter((n) => n.id !== childId);
+  const anchor = flow[clamped];
+  const at = anchor ? order.indexOf(anchor) : flow.length > 0 ? order.indexOf(flow[flow.length - 1]) + 1 : order.length;
+  order.splice(at, 0, child);
+  if (order.every((n, i) => n === siblings[i])) return nodes;
+  let k = 0;
+  const parentId = child.parentId;
+  const placed = nodes.map((n) => n.parentId === parentId && n.id !== parentId ? order[k++] : n);
+  return parentsFirst(placed);
+}
+function parentsFirst(nodes) {
+  const ids = new Set(nodes.map((n) => n.id));
+  const pending = /* @__PURE__ */ new Map();
+  const done = /* @__PURE__ */ new Set();
+  const out = [];
+  const emit = (n) => {
+    out.push(n);
+    done.add(n.id);
+    const waiting = pending.get(n.id);
+    if (waiting) {
+      pending.delete(n.id);
+      for (const w of waiting) emit(w);
+    }
+  };
+  for (const n of nodes) {
+    if (n.parentId && ids.has(n.parentId) && !done.has(n.parentId) && n.parentId !== n.id) {
+      if (!pending.has(n.parentId)) pending.set(n.parentId, []);
+      pending.get(n.parentId).push(n);
+    } else emit(n);
+  }
+  for (const waiting of pending.values()) for (const n of waiting) if (!done.has(n.id)) emit(n);
+  return out;
 }
 
 // src/canvas/arrangeController.ts
@@ -3406,6 +6581,16 @@ function createCanvasArrangeController(options) {
   };
   function apply(name, updates) {
     if (updates.length === 0) return updates;
+    if (options.autoLayout) {
+      const layoutOptions = options.autoLayout === true ? { rectOptions: options.rectOptions } : options.autoLayout;
+      const moved = applyNodeUpdates(options.getNodes(), updates);
+      const layout2 = layoutUpMany(moved, updates.map((u) => u.id), layoutOptions);
+      if (layout2.length > 0) {
+        const byId = /* @__PURE__ */ new Map();
+        for (const u of [...updates, ...layout2]) byId.set(u.id, { ...byId.get(u.id), ...u });
+        updates = [...byId.values()];
+      }
+    }
     const inverse = invertNodeUpdates(options.getNodes(), updates);
     const run = (u) => options.setNodes(applyNodeUpdates(options.getNodes(), u));
     if (options.history) {
@@ -3489,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.
@@ -3784,7 +7004,7 @@ function createCanvasArrangeController(options) {
 }
 
 // src/canvas/measure.ts
-var EPS = 1e-6;
+var EPS2 = 1e-6;
 function measureLabel(distance) {
   const v = Math.round(Math.abs(distance) * 100) / 100;
   return Object.is(v, -0) ? "0" : String(v);
@@ -3796,13 +7016,13 @@ function line(kind, x1, y1, x2, y2) {
 }
 function measured(out, x1, y1, x2, y2) {
   const d = Math.hypot(x2 - x1, y2 - y1);
-  if (d > EPS && Number.isFinite(d)) out.push({ ...line("measure", x1, y1, x2, y2), label: measureLabel(d) });
+  if (d > EPS2 && Number.isFinite(d)) out.push({ ...line("measure", x1, y1, x2, y2), label: measureLabel(d) });
 }
 function extension(out, x1, y1, x2, y2) {
-  if (Math.hypot(x2 - x1, y2 - y1) > EPS) out.push(line("extension", x1, y1, x2, y2));
+  if (Math.hypot(x2 - x1, y2 - y1) > EPS2) out.push(line("extension", x1, y1, x2, y2));
 }
 function contains(outer, inner) {
-  return outer.x0 <= inner.x0 + EPS && outer.y0 <= inner.y0 + EPS && outer.x1 >= inner.x1 - EPS && outer.y1 >= inner.y1 - EPS;
+  return outer.x0 <= inner.x0 + EPS2 && outer.y0 <= inner.y0 + EPS2 && outer.x1 >= inner.x1 - EPS2 && outer.y1 >= inner.y1 - EPS2;
 }
 function overlapMid(a0, a1, b0, b1) {
   const lo = Math.max(a0, b0);
@@ -3899,7 +7119,727 @@ function isMeasureModifierHeld(event) {
   if (event.type === "keyup" && event.key === "Alt") return false;
   return event.altKey === true || event.type === "keydown" && event.key === "Alt";
 }
+
+// src/canvas/autoLayoutController.ts
+function mergeNodeUpdates(...lists) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const list of lists) for (const u of list) byId.set(u.id, { ...byId.get(u.id), ...u });
+  return [...byId.values()];
+}
+function relayoutUpdates(nodes, ids, options = {}) {
+  return layoutUpMany(nodes, ids, options);
+}
+function createCanvasAutoLayoutController(options) {
+  const layoutOptions = () => ({ measure: options.measure, rectOptions: options.rectOptions });
+  const enabled = () => options.enabled !== false;
+  const pendingIds = /* @__PURE__ */ new Set();
+  const pendingResizes = /* @__PURE__ */ new Map();
+  const resizeStarts = /* @__PURE__ */ new Map();
+  let pendingAll = false;
+  const dragStarts = /* @__PURE__ */ new Map();
+  const pendingDrops = /* @__PURE__ */ new Set();
+  let guides = [];
+  const setGuides = (next) => {
+    if (next.length === 0 && guides.length === 0) return;
+    guides = next;
+    options.onGuidesChange?.(guides);
+  };
+  function run(name, forward, backward, ids, extra = [], restore) {
+    const before = options.getNodes();
+    const structural = forward(before);
+    const withExtra = applyNodeUpdates(structural, extra);
+    const layout2 = enabled() || name === "Auto Layout" ? relayoutUpdates(withExtra, ids(withExtra), layoutOptions()) : [];
+    const updates = mergeNodeUpdates(extra, layout2);
+    if (structural === before && updates.length === 0) return updates;
+    let inverse = invertNodeUpdates(structural, updates);
+    if (restore) {
+      inverse = mergeNodeUpdates(inverse, [{ id: restore.id, position: { ...restore.position } }]);
+    }
+    const execute = () => options.setNodes(applyNodeUpdates(forward(options.getNodes()), updates));
+    const undo = () => options.setNodes(backward(applyNodeUpdates(options.getNodes(), inverse)));
+    if (options.history) options.history.execute({ name, execute, undo });
+    else execute();
+    return updates;
+  }
+  const identity = (nodes) => nodes;
+  const controller = {
+    /** Drop marker of the active reorder drag (flow coordinates); empty otherwise. */
+    get guides() {
+      return guides;
+    },
+    /**
+     * Lays out frame `frameId` and its auto layout ancestors (default: every frame) as one
+     * (optionally undoable) step. Returns the updates.
+     */
+    applyAutoLayout(frameId) {
+      if (frameId === void 0) {
+        const updates = layoutAll(options.getNodes(), layoutOptions());
+        return run("Auto Layout", identity, identity, () => [], updates);
+      }
+      return run("Auto Layout", identity, identity, () => [frameId]);
+    },
+    /** Updates that relayout around `ids` on the current nodes, without applying them. */
+    layoutUpdates(ids) {
+      return relayoutUpdates(options.getNodes(), ids, layoutOptions());
+    },
+    /**
+     * Applies the relayout around `ids` (frames, or nodes inside frames) directly, not
+     * recorded in history: auto layout is derived state, re-run after any change.
+     */
+    relayout(ids) {
+      const updates = relayoutUpdates(options.getNodes(), ids, layoutOptions());
+      if (updates.length > 0) options.setNodes(applyNodeUpdates(options.getNodes(), updates));
+      return updates;
+    },
+    /**
+     * Adds `node` (into the frame named by its `parentId`, at flow `index` when given) and
+     * lays out its frame, as one step.
+     */
+    addNode(node, addOptions = {}) {
+      const forward = (nodes) => {
+        if (nodes.some((n) => n.id === node.id)) return nodes;
+        let next = [...nodes, node];
+        if (addOptions.index !== void 0 && node.parentId) next = moveLayoutChild(next, node.id, addOptions.index);
+        return next;
+      };
+      const backward = (nodes) => nodes.filter((n) => n.id !== node.id);
+      return run("Add Node", forward, backward, () => [node.id]);
+    },
+    /** Removes nodes (and their descendants) and lays out the frames they leave, as one step. */
+    removeNodes(ids) {
+      const before = options.getNodes();
+      const remove = new Set(ids);
+      let grew = true;
+      while (grew) {
+        grew = false;
+        for (const n of before) {
+          if (n.parentId && remove.has(n.parentId) && !remove.has(n.id)) {
+            remove.add(n.id);
+            grew = true;
+          }
+        }
+      }
+      const removed = before.map((n, i) => [i, n]).filter(([, n]) => remove.has(n.id));
+      if (removed.length === 0) return [];
+      const parents = [...new Set(removed.map(([, n]) => n.parentId).filter((p) => !!p && !remove.has(p)))];
+      const forward = (nodes) => nodes.filter((n) => !remove.has(n.id));
+      const backward = (nodes) => {
+        const next = [...nodes];
+        for (const [i, n] of removed) next.splice(Math.min(i, next.length), 0, n);
+        return next;
+      };
+      return run("Delete", forward, backward, () => parents);
+    },
+    /**
+     * Resizes node `id` (its children follow their constraints) and lays out around it,
+     * as one step.
+     */
+    resizeNode(id, size) {
+      const nodes = options.getNodes();
+      const node = nodes.find((n) => n.id === id);
+      if (!node) return [];
+      const old = getNodeSize(node, options.rectOptions);
+      const update = { id };
+      if (size.width !== void 0) update.width = size.width;
+      if (size.height !== void 0) update.height = size.height;
+      const resized = applyNodeUpdates(nodes, [update]);
+      const constrained = mergeNodeUpdates([update], applyConstraints(resized, id, old, layoutOptions()));
+      return run("Resize", identity, identity, () => [id], constrained);
+    },
+    /** Moves flow child `childId` to flow index `index` in its frame and lays it out, as one step. */
+    moveChild(childId, index) {
+      const before = options.getNodes();
+      const order = before.map((n) => n.id);
+      const forward = (nodes) => moveLayoutChild(nodes, childId, index);
+      const backward = (nodes) => restoreOrder(nodes, order);
+      if (forward(before) === before) return [];
+      return run("Reorder", forward, backward, () => [childId]);
+    },
+    /** Where flow child `id` would drop if released at `point` (default: its centre). */
+    getInsertTarget(id, point) {
+      const nodes = options.getNodes();
+      const frame = getLayoutParent(nodes, id);
+      if (!frame) return void 0;
+      const lookup = createNodeLookup(nodes);
+      const rect = getNodeRect(lookup.get(id), lookup, options.rectOptions);
+      const at = point ?? { x: rect.x + rect.width / 2, y: rect.y + rect.height / 2 };
+      return getAutoLayoutInsertTarget(nodes, frame.id, at, { ...layoutOptions(), excludeId: id });
+    },
+    /** Records the start position of a reorder drag. Optional: `dragReorder` records it lazily. */
+    beginReorderDrag(id) {
+      const node = options.getNodes().find((n) => n.id === id);
+      if (node && getLayoutParent(options.getNodes(), id)) dragStarts.set(id, { ...node.position });
+    },
+    /**
+     * While flow child `id` is dragged (as currently positioned in `getNodes()`): updates the
+     * drop marker. Returns the insert target.
+     */
+    dragReorder(id, point) {
+      if (options.dragReorder === false) return void 0;
+      if (!dragStarts.has(id)) controller.beginReorderDrag(id);
+      const target = controller.getInsertTarget(id, point);
+      setGuides(target ? [target.guide] : []);
+      return target;
+    },
+    /**
+     * Ends a reorder drag: moves `id` to the slot under `point` (default: its centre) and lays
+     * the frame out, as one undoable step whose undo puts the node back where the drag began.
+     */
+    endReorderDrag(id, point) {
+      setGuides([]);
+      const start = dragStarts.get(id);
+      dragStarts.delete(id);
+      if (options.dragReorder === false || !getLayoutParent(options.getNodes(), id)) return [];
+      const target = controller.getInsertTarget(id, point);
+      if (!target) return [];
+      const before = options.getNodes();
+      const order = before.map((n) => n.id);
+      const forward = (nodes) => moveLayoutChild(nodes, id, target.index);
+      const backward = (nodes) => restoreOrder(nodes, order);
+      return run("Reorder", forward, backward, () => [id], [], start && { id, position: start });
+    },
+    /**
+     * Notes a batch of React Flow / SvelteFlow style node changes (before or after they are
+     * applied) so `flush` can relayout: dimension changes (measured sizes, resize ends),
+     * added and removed nodes, and position changes of flow children (reorder drags).
+     * Returns the changes unchanged.
+     */
+    noteChanges(changes) {
+      const nodes = options.getNodes();
+      const lookup = createNodeLookup(nodes);
+      for (const c of changes) {
+        const id = c.id ?? c.item?.id;
+        if (c.type === "add" && c.item) {
+          pendingIds.add(c.item.id);
+        } else if (c.type === "remove" && id) {
+          const parent = lookup.get(id)?.parentId;
+          if (parent) pendingIds.add(parent);
+          else pendingAll = true;
+        } else if (c.type === "replace" && id) {
+          pendingIds.add(id);
+        } else if (c.type === "dimensions" && id) {
+          const node = lookup.get(id);
+          if (c.resizing === true) {
+            if (node && !resizeStarts.has(id)) resizeStarts.set(id, getNodeSize(node, options.rectOptions));
+            continue;
+          }
+          const start = resizeStarts.get(id);
+          resizeStarts.delete(id);
+          if (start) pendingResizes.set(id, start);
+          pendingIds.add(id);
+        } else if (c.type === "position" && id && options.dragReorder !== false) {
+          if (!getLayoutParent(nodes, id)) continue;
+          if (c.dragging === true) {
+            if (!dragStarts.has(id)) {
+              const node = lookup.get(id);
+              if (node) dragStarts.set(id, { ...node.position });
+            }
+          } else if (c.dragging === false || dragStarts.has(id)) {
+            pendingDrops.add(id);
+          }
+        }
+      }
+      return changes;
+    },
+    /**
+     * Notes nodes that were already removed (e.g. SvelteFlow's `ondelete`), so `flush`
+     * relayouts the frames they left. The nodes must still carry their `parentId`.
+     */
+    noteRemoved(removed) {
+      const gone = /* @__PURE__ */ new Set();
+      const list = [...removed];
+      for (const n of list) gone.add(n.id);
+      for (const n of list) if (n.parentId && !gone.has(n.parentId)) pendingIds.add(n.parentId);
+    },
+    /** Whether `noteChanges` left work for `flush`. */
+    get hasPending() {
+      return pendingAll || pendingIds.size > 0 || pendingResizes.size > 0 || pendingDrops.size > 0 || dragStarts.size > 0;
+    },
+    /**
+     * Applies the work noted by `noteChanges` to the current nodes: drop markers while
+     * dragging, committed reorders on drop (undoable), and a relayout (not recorded) for
+     * size, add and remove changes. Call it once the changes are applied.
+     */
+    flush() {
+      let applied = [];
+      for (const id of pendingDrops) applied = mergeNodeUpdates(applied, controller.endReorderDrag(id));
+      pendingDrops.clear();
+      for (const id of dragStarts.keys()) controller.dragReorder(id);
+      if (!enabled()) {
+        pendingIds.clear();
+        pendingResizes.clear();
+        pendingAll = false;
+        return applied;
+      }
+      let nodes = options.getNodes();
+      let updates = [];
+      for (const [id, previous] of pendingResizes) {
+        if (!nodes.some((n) => n.id === id)) continue;
+        const constrained = applyConstraints(nodes, id, previous, layoutOptions());
+        nodes = applyNodeUpdates(nodes, constrained);
+        updates = mergeNodeUpdates(updates, constrained);
+      }
+      const layout2 = pendingAll ? layoutAll(nodes, layoutOptions()) : relayoutUpdates(nodes, [...pendingIds].filter((id) => nodes.some((n) => n.id === id)), layoutOptions());
+      updates = mergeNodeUpdates(updates, layout2);
+      pendingIds.clear();
+      pendingResizes.clear();
+      pendingAll = false;
+      if (updates.length > 0) options.setNodes(applyNodeUpdates(options.getNodes(), updates));
+      return mergeNodeUpdates(applied, updates);
+    },
+    /** Whether `id` is an auto layout frame. */
+    isFrame: (id) => isAutoLayoutFrame(options.getNodes().find((n) => n.id === id))
+  };
+  return controller;
+}
+function restoreOrder(nodes, order) {
+  const rank = new Map(order.map((id, i) => [id, i]));
+  const indexed = nodes.map((n, i) => ({ n, r: rank.get(n.id) ?? order.length + i }));
+  indexed.sort((a, b) => a.r - b.r);
+  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 = { ...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 = node.data?.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(node?.data?.[TOKEN_BINDINGS_DATA_KEY]);
+}
+function getNodeTokenModes(node) {
+  return stringRecord(node?.data?.[TOKEN_MODES_DATA_KEY]);
+}
+function getCanvasTokenProperty(key, options = {}) {
+  return (options.properties ?? CANVAS_TOKEN_PROPERTIES).find((p) => p.key === key);
+}
+function getBindableTokenProperties(node, options = {}) {
+  return (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 && isTokenInScope(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 = getTokenCollection(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 = resolveToken(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: getTokenVariable(state, variableId), resolution: resolveToken(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 TokenError("not-found", `No bindable property \`${propertyKey}\``);
+  if (variableId !== null) {
+    const variable = getTokenVariable(state, variableId);
+    if (!variable) throw new TokenError("not-found", `No variable \`${variableId}\``);
+    if (variable.type !== property.type) {
+      throw new 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 = getTokenCollection(state, collectionId);
+    if (!collection) throw new TokenError("not-found", `No collection \`${collectionId}\``);
+    if (!collection.modes.some((m) => m.id === modeId)) throw new 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) : !getTokenVariable(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;
+}
 export {
+  AUTO_LAYOUT_DATA_KEY,
+  CANVAS_TOKEN_PROPERTIES,
+  CHILD_LAYOUT_DATA_KEY,
   CONNECTION_LINE_TYPES,
   CanvasScenesStore,
   DEFAULT_ARRANGE_SHORTCUTS,
@@ -3909,30 +7849,51 @@ export {
   LOCKED_DATA_KEY,
   LOCKED_PREVIOUS_FLAGS_KEY,
   ManualClock,
+  PathOpsError,
   RESIZE_HANDLES,
   SHAPE_DATA_KEY,
   SHAPE_KINDS,
   SHAPE_NODE_TYPE,
   SHAPE_OPERATIONS,
   StreamingLayoutManager,
+  TOKEN_BINDINGS_DATA_KEY,
+  TOKEN_MODES_DATA_KEY,
   alignNodes,
+  applyConstraints,
   applyNodeUpdates,
   applyShapeCombination,
+  applyShapeReplacement,
+  arcToCubics,
+  bezierPathArea,
+  bezierPathBounds,
+  bezierPathLength,
+  bezierPathPointAtLength,
+  bezierPathSignedArea,
+  bezierPathToSvg,
+  bindCanvasToken,
   blendLayout,
   boundsOf,
   calculateDagreReflowDisplacement,
   calculateDirectionalDisplacement,
   canCombineShapeNodes,
+  canOffsetShapeNodes,
+  canOutlineShapeNodeStrokes,
   canvasHeight,
   centerNodes,
   centre,
+  clampLayoutSize,
+  closeContour,
   collectDescendantIds,
   combineShapeNodes,
   computeNodesBoundingBox,
   computeSnapGuides,
   connectedOnly,
+  contourSignedArea,
+  contoursToPath,
+  countPathSegments,
   createBezierTrajectory,
   createCanvasArrangeController,
+  createCanvasAutoLayoutController,
   createCanvasScenesStore,
   createFanOutTrajectory,
   createGuideIndex,
@@ -3940,12 +7901,17 @@ export {
   createNodeLookup,
   cubicPointAt,
   cubicsToPathData,
+  dashContours,
   defaultEasing,
+  detachTokenBindings,
+  distanceToBezierPath,
   distributeNodes,
+  dividePaths,
   dividePolygons,
   ensureLayout,
   estimateCanvasHeight,
   estimateNodeSize,
+  excludePaths,
   findConnectorSnap,
   fitCubicRun,
   fitCubics,
@@ -3957,18 +7923,36 @@ export {
   flowSide,
   formatNumber2 as formatNumber,
   getAbsolutePosition,
+  getAutoLayout,
+  getAutoLayoutGrid,
+  getAutoLayoutInsertTarget,
+  getBindableTokenProperties,
+  getCanvasTokenProperty,
   getCenteredNodePosition,
+  getChildLayout,
+  getEffectiveTokenModes,
+  getFlowChildren,
+  getLayoutParent,
+  getLayoutSizing,
   getLayoutedNodes,
   getNodeRect,
   getNodeShape,
   getNodeSize,
+  getNodeTokenBindings,
+  getNodeTokenModes,
   getResizingNodeRect,
   getShapeRenderData,
   getShapeSvg,
+  getTokenPropertyScope,
+  getTokensForProperty,
   handlePoint,
+  hasVisibleStroke,
   inferResizeHandle,
+  inspectNodeTokens,
+  intersectPaths,
   intersectPolygons,
   invertNodeUpdates,
+  isAutoLayoutFrame,
   isEventFromTextInput,
   isLocked,
   isMeasureModifierHeld,
@@ -3979,43 +7963,75 @@ export {
   isValidCanvasNode,
   isValidCanvasScene,
   isValidUrl,
+  layoutAll,
   layoutBounds,
+  layoutFrame,
+  layoutUp,
+  layoutUpMany,
   linearPositionTrajectory,
   linearTrajectory,
   lockNodes,
+  makeSizingCoherent,
   matchArrangeShortcut,
   matchSize,
   measureBetween,
   measureLabel,
   measureSelection,
   measureToLine,
+  mergeNodeUpdates,
+  moveLayoutChild,
   multiPolygonArea,
   multiPolygonBounds,
   nearestHandlePositions,
+  normalizeBezierPath,
+  offsetPath,
+  offsetShapeNodes,
   oppositePosition,
+  outlineShapeNodeStrokes,
+  outlineStroke,
   overlaps,
   pageHidden,
   parseCanvasClipboardData,
   parseCanvasScenes,
   parseSvgPath,
+  pathBoolean,
+  pathToContours,
   placeBeside,
+  pointInBezierPath,
   pointInMultiPolygon,
   pointInRings,
   polygonArea,
   polygonBoolean,
   polygonToSvgPath,
   positionToSide,
+  pruneCanvasTokenModes,
+  readNodeStyleProperty,
   readStyleSize,
   realClock,
+  relayoutUpdates,
   remapPastedNodes,
   reorderNodes,
   repositionNodesTo,
   resizeHandleAxes,
+  resolveCanvasTokens,
+  resolvePadding,
   revertShapeCombination,
   ringSignedArea,
   runMultiNodeTransition,
+  segmentBounds,
+  segmentCurvature,
+  segmentDerivative,
+  segmentExtrema,
+  segmentLength,
+  segmentNearest,
+  segmentParamAtLength,
+  segmentPoint,
+  segmentTangent,
   serializeCanvasNodes,
+  setCanvasTokenMode,
+  shapeNodeToBezierPath,
   shapeNodeToPolygon,
+  shapeToBezierPath,
   shapeToPolygon,
   sideToPosition,
   simplifyRing,
@@ -4023,12 +8039,22 @@ export {
   snapNodeResize,
   snapResize,
   snapToGrid,
+  splitSegment,
+  strokeOutlineRings,
+  subSegment,
+  subtractPaths,
   subtractPolygons,
+  toBezierPath,
   toggleLockNodes,
+  transformBezierPath,
+  trimSegments,
   unionPolygons,
+  unitePaths,
   unlockNodes,
+  windingNumber,
   withStyleOpacity,
   withStyleSize,
+  writeNodeStyleProperty,
   xorPolygons
 };
 //# sourceMappingURL=index.js.map