@pixerate/editor 0.24.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;
@@ -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;
@@ -3667,7 +5960,7 @@ function layoutFrameInner(s, frame) {
     const b = s.boxes.get(id);
     return horizontal ? [b.w, b.h] : [b.h, b.w];
   };
-  const resize = (it, main, cross) => resizeChild(s, it.id, horizontal ? main : cross, horizontal ? cross : main);
+  const resize = (it, main, cross2) => resizeChild(s, it.id, horizontal ? main : cross2, horizontal ? cross2 : main);
   if (!wraps) {
     for (const it of items) {
       if (!it.fillCross || it.fillMain) continue;
@@ -3681,13 +5974,13 @@ function layoutFrameInner(s, frame) {
     let used = 0;
     items.forEach((it, i) => {
       const sz = it.fillMain ? it.minMain ?? 0 : it.main;
-      const add2 = cur.length === 0 ? sz : Math.max(gap, 0) + sz;
-      if (cur.length > 0 && used + add2 > innerMainFixed + 1e-6) {
+      const add3 = cur.length === 0 ? sz : Math.max(gap, 0) + sz;
+      if (cur.length > 0 && used + add3 > innerMainFixed + 1e-6) {
         lines.push(cur);
         cur = [];
         used = sz;
       } else {
-        used += add2;
+        used += add3;
       }
       cur.push(i);
     });
@@ -3703,8 +5996,8 @@ function layoutFrameInner(s, frame) {
   }
   for (const it of items) {
     if (!it.fillMain) continue;
-    const cross = it.fillCross && !wraps ? clampLayoutSize(innerCrossFixed, it.minCross, it.maxCross) : it.cross;
-    resize(it, it.main, cross);
+    const cross2 = it.fillCross && !wraps ? clampLayoutSize(innerCrossFixed, it.minCross, it.maxCross) : it.cross;
+    resize(it, it.main, cross2);
     it.cross = sizeOf(it.id)[1];
   }
   if (baseline) {
@@ -3718,8 +6011,8 @@ function layoutFrameInner(s, frame) {
     const inLine = line2.map((i) => items[i]);
     const mainUsed = inLine.reduce((sum, it) => sum + it.main, 0) + gaps;
     const allFill = inLine.every((it) => it.fillCross);
-    const cross = inLine.filter((it) => allFill || !it.fillCross).reduce((m, it) => Math.max(m, it.baseOff + it.cross), 0);
-    extents.push([mainUsed, cross]);
+    const cross2 = inLine.filter((it) => allFill || !it.fillCross).reduce((m, it) => Math.max(m, it.baseOff + it.cross), 0);
+    extents.push([mainUsed, cross2]);
   }
   const contentMain = extents.reduce((m, l) => Math.max(m, l[0]), 0);
   let crossGap = al.rowGap !== void 0 ? finite(al.rowGap) : gap;
@@ -3905,11 +6198,11 @@ function resolveTracks(tracks, content, avail) {
   let used = out.reduce((sum, v, i) => trackSpec(tracks, i).sizing === "fill" ? sum : sum + v, 0);
   while (flex.length > 0) {
     const total = flex.reduce((sum, i) => sum + fr(i), 0);
-    const unit2 = total > 1e-12 ? Math.max(avail - used, 0) / total : 0;
-    const open = flex.filter((i) => unit2 * fr(i) >= out[i]);
-    const frozen = flex.filter((i) => unit2 * fr(i) < out[i]);
+    const unit3 = total > 1e-12 ? Math.max(avail - used, 0) / total : 0;
+    const open = flex.filter((i) => unit3 * fr(i) >= out[i]);
+    const frozen = flex.filter((i) => unit3 * fr(i) < out[i]);
     if (frozen.length === 0) {
-      for (const i of open) out[i] = unit2 * fr(i);
+      for (const i of open) out[i] = unit3 * fr(i);
       break;
     }
     used += frozen.reduce((sum, i) => sum + out[i], 0);
@@ -4195,19 +6488,19 @@ function getAutoLayoutInsertTarget(nodes, frameId, point, options = {}) {
   if (!frame || !al) return void 0;
   const s = new LayoutState(nodes, options);
   const origin = getAbsolutePosition(frame, lookup);
-  const px = point.x - origin.x;
+  const px2 = point.x - origin.x;
   const py = point.y - origin.y;
   const siblings = flowChildren(s, frameId).filter((id) => id !== options.excludeId).map((id) => s.boxes.get(id));
   const horizontal = al.mode !== "vertical";
   const main = (b) => horizontal ? b.x : b.y;
   const mainSize = (b) => horizontal ? b.w : b.h;
-  const cross = (b) => horizontal ? b.y : b.x;
+  const cross2 = (b) => horizontal ? b.y : b.x;
   const crossSize = (b) => horizontal ? b.h : b.w;
-  const p = { x: px, y: py };
+  const p = { x: px2, y: py };
   const multiLine = al.mode === "grid" || !!al.wrap;
   let index = 0;
   for (const b of siblings) {
-    const before = multiLine ? cross(b) + crossSize(b) <= cross(p) || cross(b) <= cross(p) && main(b) + mainSize(b) / 2 < main(p) : main(b) + mainSize(b) / 2 < main(p);
+    const before = multiLine ? cross2(b) + crossSize(b) <= cross2(p) || cross2(b) <= cross2(p) && main(b) + mainSize(b) / 2 < main(p) : main(b) + mainSize(b) / 2 < main(p);
     if (before) index += 1;
   }
   const [pt, pr, pb, pl] = resolvePadding(al.padding);
@@ -4216,13 +6509,13 @@ function getAutoLayoutInsertTarget(nodes, frameId, point, options = {}) {
   const f = s.boxes.get(frameId);
   let guide;
   if (horizontal) {
-    const x = prev && next && Math.abs(cross(prev) - cross(next)) < 1e-6 ? (prev.x + prev.w + next.x) / 2 : prev ? prev.x + prev.w : next ? next.x : pl;
+    const x = prev && next && Math.abs(cross2(prev) - cross2(next)) < 1e-6 ? (prev.x + prev.w + next.x) / 2 : prev ? prev.x + prev.w : next ? next.x : pl;
     const ref = next ?? prev;
     const y1 = ref ? ref.y : pt;
     const y2 = ref ? ref.y + ref.h : f.h - pb;
     guide = { orientation: "vertical", kind: "edge", x1: origin.x + x, y1: origin.y + y1, x2: origin.x + x, y2: origin.y + y2 };
   } else {
-    const y = prev && next && Math.abs(cross(prev) - cross(next)) < 1e-6 ? (prev.y + prev.h + next.y) / 2 : prev ? prev.y + prev.h : next ? next.y : pt;
+    const y = prev && next && Math.abs(cross2(prev) - cross2(next)) < 1e-6 ? (prev.y + prev.h + next.y) / 2 : prev ? prev.y + prev.h : next ? next.y : pt;
     const ref = next ?? prev;
     const x1 = ref ? ref.x : pl;
     const x2 = ref ? ref.x + ref.w : f.w - pr;
@@ -4381,6 +6674,41 @@ function createCanvasArrangeController(options) {
     divide: (ids, o) => controller.combineShapes("divide", ids, o),
     /** Whether the shape operations can run on `ids` (default: the selection). */
     canCombineShapes: (ids) => canCombineShapeNodes(options.getNodes(), selectedIds(ids)).ok,
+    /**
+     * Offset Path: grows (`distance > 0`) or shrinks (`distance < 0`) every shape among
+     * `ids` (default: the selection) by `distance` flow units, keeping curves, as one
+     * undoable step. Refuses without changing anything when a shape is locked, no shape is
+     * selected or every result is empty.
+     */
+    offsetShapes(distance, ids, offsetOptions = {}) {
+      const before = options.getNodes();
+      const result = offsetShapeNodes(before, selectedIds(ids), distance, { ...rect(), ...offsetOptions });
+      if (!result.ok) return result;
+      const run = () => options.setNodes(applyShapeReplacement(options.getNodes(), result));
+      const undo = () => options.setNodes(revertShapeCombination(options.getNodes(), result, before));
+      if (options.history) options.history.execute({ name: "Offset Path", execute: run, undo });
+      else run();
+      return result;
+    },
+    /** Whether `offsetShapes` can run on `ids` (default: the selection). */
+    canOffsetShapes: (ids) => canOffsetShapeNodes(options.getNodes(), selectedIds(ids)).ok,
+    /**
+     * Outline Stroke: converts the strokes of the shapes among `ids` (default: the
+     * selection) to filled path shapes, as one undoable step. Refuses when a shape is
+     * locked or no selected shape has a visible stroke.
+     */
+    outlineStroke(ids, outlineOptions = {}) {
+      const before = options.getNodes();
+      const result = outlineShapeNodeStrokes(before, selectedIds(ids), { ...rect(), ...outlineOptions });
+      if (!result.ok) return result;
+      const run = () => options.setNodes(applyShapeReplacement(options.getNodes(), result));
+      const undo = () => options.setNodes(revertShapeCombination(options.getNodes(), result, before));
+      if (options.history) options.history.execute({ name: "Outline Stroke", execute: run, undo });
+      else run();
+      return result;
+    },
+    /** Whether `outlineStroke` can run on `ids` (default: the selection). */
+    canOutlineStroke: (ids) => canOutlineShapeNodeStrokes(options.getNodes(), selectedIds(ids)).ok,
     /**
      * Runs a shortcut action. Scene actions are not handled here (see the scenes store);
      * returns `false` for them and for unknown actions.
@@ -5070,8 +7398,447 @@ function restoreOrder(nodes, order) {
   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,
@@ -5082,30 +7849,48 @@ 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,
@@ -5116,12 +7901,17 @@ export {
   createNodeLookup,
   cubicPointAt,
   cubicsToPathData,
+  dashContours,
   defaultEasing,
+  detachTokenBindings,
+  distanceToBezierPath,
   distributeNodes,
+  dividePaths,
   dividePolygons,
   ensureLayout,
   estimateCanvasHeight,
   estimateNodeSize,
+  excludePaths,
   findConnectorSnap,
   fitCubicRun,
   fitCubics,
@@ -5136,8 +7926,11 @@ export {
   getAutoLayout,
   getAutoLayoutGrid,
   getAutoLayoutInsertTarget,
+  getBindableTokenProperties,
+  getCanvasTokenProperty,
   getCenteredNodePosition,
   getChildLayout,
+  getEffectiveTokenModes,
   getFlowChildren,
   getLayoutParent,
   getLayoutSizing,
@@ -5145,11 +7938,18 @@ export {
   getNodeRect,
   getNodeShape,
   getNodeSize,
+  getNodeTokenBindings,
+  getNodeTokenModes,
   getResizingNodeRect,
   getShapeRenderData,
   getShapeSvg,
+  getTokenPropertyScope,
+  getTokensForProperty,
   handlePoint,
+  hasVisibleStroke,
   inferResizeHandle,
+  inspectNodeTokens,
+  intersectPaths,
   intersectPolygons,
   invertNodeUpdates,
   isAutoLayoutFrame,
@@ -5183,19 +7983,29 @@ export {
   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,
@@ -5203,12 +8013,25 @@ export {
   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,
@@ -5216,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