@pixerate/editor 0.21.0 → 0.23.0

package/dist/canvas/index.js

@@ -1,3 +1,7 @@
+import {
+  DEFAULT_ARRANGE_SHORTCUTS,
+  matchArrangeShortcut
+} from "../chunk-7DWMJCAT.js";
 import {
   DEFAULT_NODE_HEIGHT,
   DEFAULT_NODE_WIDTH,
@@ -1073,6 +1077,10 @@ function invertNodeUpdates(nodes, updates) {
 }
 
 // src/canvas/guides.ts
+function snapToGrid(value, spacing, origin = 0) {
+  if (!(spacing > 0) || !Number.isFinite(spacing)) return value;
+  return Math.round((value - origin) / spacing) * spacing + origin;
+}
 function buildAxis(entries) {
   entries.sort((a, b) => a.value - b.value);
   return {
@@ -1229,8 +1237,10 @@ function computeSnapGuides(moving, targets, options = {}) {
   };
   const sx = snapAxis(true);
   const sy = snapAxis(false);
-  const dx = sx.delta ?? 0;
-  const dy = sy.delta ?? 0;
+  const grid = options.gridSize ?? 0;
+  const gridDelta = (v, origin) => snapToGrid(v, grid, origin) - v;
+  const dx = sx.delta ?? (grid > 0 ? gridDelta(moving.x, options.gridOrigin?.x ?? 0) : 0);
+  const dy = sy.delta ?? (grid > 0 ? gridDelta(moving.y, options.gridOrigin?.y ?? 0) : 0);
   const snapped = { x: moving.x + dx, y: moving.y + dy, width: moving.width, height: moving.height };
   const guides = [];
   const alignmentGuides = (horizontal) => {
@@ -1244,12 +1254,12 @@ function computeSnapGuides(moving, targets, options = {}) {
     if (useCentres) {
       lines.push({ value: start + size / 2, kind: "centre", axis: horizontal ? index.centreX : index.centreY });
     }
-    for (const line of lines) {
-      const aligned = matches(line.axis, line.value, eps);
+    for (const line2 of lines) {
+      const aligned = matches(line2.axis, line2.value, eps);
       if (aligned.length === 0) continue;
       const span = boundsOf([snapped, ...aligned]);
       guides.push(
-        horizontal ? { orientation: "vertical", kind: line.kind, x1: line.value, y1: span.y, x2: line.value, y2: span.y + span.height } : { orientation: "horizontal", kind: line.kind, x1: span.x, y1: line.value, x2: span.x + span.width, y2: line.value }
+        horizontal ? { orientation: "vertical", kind: line2.kind, x1: line2.value, y1: span.y, x2: line2.value, y2: span.y + span.height } : { orientation: "horizontal", kind: line2.kind, x1: span.x, y1: line2.value, x2: span.x + span.width, y2: line2.value }
       );
     }
   };
@@ -1390,16 +1400,16 @@ function findConnectorSnap(pointer, targets, options = {}) {
     if (pointer.x < rect.x - radius || pointer.x > rect.x + rect.width + radius || pointer.y < rect.y - radius || pointer.y > rect.y + rect.height + radius) {
       continue;
     }
-    const inside = pointer.x >= rect.x && pointer.x <= rect.x + rect.width && pointer.y >= rect.y && pointer.y <= rect.y + rect.height;
+    const inside2 = pointer.x >= rect.x && pointer.x <= rect.x + rect.width && pointer.y >= rect.y && pointer.y <= rect.y + rect.height;
     for (const position of target.positions ?? all) {
       const point = options.mode === "edge" ? closestPointOnSide(rect, position, pointer) : handlePoint(rect, position);
       const sidePoint = closestPointOnSide(rect, position, pointer);
       const rank = Math.hypot(pointer.x - sidePoint.x, pointer.y - sidePoint.y);
       const distance = Math.hypot(pointer.x - point.x, pointer.y - point.y);
-      if (!inside && rank > radius) continue;
-      const better = !best || inside && !best.inside || inside === best.inside && rank < best.rank;
+      if (!inside2 && rank > radius) continue;
+      const better = !best || inside2 && !best.inside || inside2 === best.inside && rank < best.rank;
       if (better) {
-        best = { nodeId: target.id, position, side: positionToSide(position), point, distance, inside, rank };
+        best = { nodeId: target.id, position, side: positionToSide(position), point, distance, inside: inside2, rank };
       }
     }
   }
@@ -1662,47 +1672,1720 @@ function fitViewportToNodes(nodes, size, ids, options = {}) {
   return bounds ? fitViewportToRect(bounds, size, options) : null;
 }
 
-// src/canvas/arrangeShortcuts.ts
-var DEFAULT_ARRANGE_SHORTCUTS = [
-  { action: "alignLeft", code: "KeyA", alt: true, label: "Alt+A" },
-  { action: "alignCenter", code: "KeyH", alt: true, label: "Alt+H" },
-  { action: "alignRight", code: "KeyD", alt: true, label: "Alt+D" },
-  { action: "alignTop", code: "KeyW", alt: true, label: "Alt+W" },
-  { action: "alignMiddle", code: "KeyV", alt: true, label: "Alt+V" },
-  { action: "alignBottom", code: "KeyS", alt: true, label: "Alt+S" },
-  { action: "distributeHorizontal", code: "KeyH", alt: true, shift: true, label: "Alt+Shift+H" },
-  { action: "distributeVertical", code: "KeyV", alt: true, shift: true, label: "Alt+Shift+V" },
-  { action: "lock", code: "KeyL", mod: true, label: "Mod+L" },
-  { action: "unlock", code: "KeyL", mod: true, alt: true, label: "Mod+Alt+L" },
-  { action: "bringForward", code: "BracketRight", mod: true, label: "Mod+]" },
-  { action: "sendBackward", code: "BracketLeft", mod: true, label: "Mod+[" },
-  { action: "bringToFront", code: "BracketRight", mod: true, alt: true, label: "Mod+Alt+]" },
-  { action: "sendToBack", code: "BracketLeft", mod: true, alt: true, label: "Mod+Alt+[" },
-  { action: "nextScene", code: "PageDown", label: "PageDown" },
-  { action: "previousScene", code: "PageUp", label: "PageUp" }
-];
-var KEY_TO_CODE = {
-  "]": "BracketRight",
-  "[": "BracketLeft",
-  PageDown: "PageDown",
-  PageUp: "PageUp"
+// src/canvas/polygonBoolean.ts
+function ringSignedArea(ring) {
+  let sum = 0;
+  const n = ring.length;
+  for (let i = 0; i < n; i++) {
+    const [x1, y1] = ring[i];
+    const [x2, y2] = ring[(i + 1) % n];
+    sum += x1 * y2 - x2 * y1;
+  }
+  return sum / 2;
+}
+function polygonArea(polygon) {
+  if (polygon.length === 0) return 0;
+  let area = Math.abs(ringSignedArea(polygon[0]));
+  for (let i = 1; i < polygon.length; i++) area -= Math.abs(ringSignedArea(polygon[i]));
+  return area;
+}
+function multiPolygonArea(multi) {
+  let total = 0;
+  for (const polygon of multi) total += polygonArea(polygon);
+  return total;
+}
+function multiPolygonBounds(input) {
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  const visit = (ring) => {
+    for (const [x, y] of ring) {
+      if (x < minX) minX = x;
+      if (y < minY) minY = y;
+      if (x > maxX) maxX = x;
+      if (y > maxY) maxY = y;
+    }
+  };
+  for (const item of input) {
+    if (item.length > 0 && Array.isArray(item[0]) && Array.isArray(item[0][0])) {
+      for (const ring of item) visit(ring);
+    } else {
+      visit(item);
+    }
+  }
+  return minX === Infinity ? null : { minX, minY, maxX, maxY };
+}
+function pointInRings(point, rings, fillRule = "nonzero") {
+  const [px, py] = point;
+  let winding = 0;
+  for (const ring of rings) {
+    const n = ring.length;
+    for (let i = 0; i < n; i++) {
+      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++;
+      } else if (by <= py && ay > py) {
+        if (ax + (py - ay) / (by - ay) * (bx - ax) > px) winding--;
+      }
+    }
+  }
+  return fillRule === "evenodd" ? (winding & 1) === 1 : winding !== 0;
+}
+function pointInMultiPolygon(point, multi) {
+  return multi.some((polygon) => pointInRings(point, polygon, "evenodd"));
+}
+function cleanRing(ring) {
+  const out = [];
+  for (const p of ring) {
+    if (!Number.isFinite(p[0]) || !Number.isFinite(p[1])) continue;
+    const last = out[out.length - 1];
+    if (last && last[0] === p[0] && last[1] === p[1]) continue;
+    out.push([p[0], p[1]]);
+  }
+  while (out.length > 1) {
+    const first = out[0];
+    const last = out[out.length - 1];
+    if (first[0] === last[0] && first[1] === last[1]) out.pop();
+    else break;
+  }
+  return out;
+}
+function isOperand(input) {
+  return !Array.isArray(input) && typeof input === "object" && input !== null && Array.isArray(input.rings);
+}
+function normalizeInput(input) {
+  if (isOperand(input)) {
+    return {
+      rings: input.rings.map(cleanRing).filter((r) => r.length >= 3),
+      fillRule: input.fillRule ?? "nonzero"
+    };
+  }
+  const rings = [];
+  for (const polygon of input ?? []) {
+    polygon.forEach((raw, index) => {
+      const ring = cleanRing(raw);
+      if (ring.length < 3) return;
+      const area = ringSignedArea(ring);
+      if (area === 0) return;
+      const wantPositive = index === 0;
+      rings.push(area > 0 === wantPositive ? ring : ring.reverse());
+    });
+  }
+  return { rings, fillRule: "nonzero" };
+}
+var PointPool = 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 };
+    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 eventCode(event) {
-  if (event.code) return event.code;
-  if (KEY_TO_CODE[event.key]) return KEY_TO_CODE[event.key];
-  if (/^[a-z]$/i.test(event.key)) return `Key${event.key.toUpperCase()}`;
-  return event.key;
+function project(a, b, p) {
+  const dx = b.x - a.x;
+  const dy = b.y - a.y;
+  const len2 = dx * dx + dy * dy;
+  const t = len2 === 0 ? 0 : ((p.x - a.x) * dx + (p.y - a.y) * dy) / len2;
+  const cx = a.x + t * dx;
+  const cy = a.y + t * dy;
+  return { t, dist: Math.hypot(p.x - cx, p.y - cy) };
+}
+function addSplit(splits, t, v) {
+  const { a, b } = splits.segment;
+  if (v.id === a.id || v.id === b.id) return;
+  if (!splits.points.has(v.id)) splits.points.set(v.id, { t, v });
+}
+function splitPass(segments, pool, eps) {
+  const order = segments.map((s, i) => ({
+    i,
+    minX: Math.min(s.a.x, s.b.x),
+    maxX: Math.max(s.a.x, s.b.x),
+    minY: Math.min(s.a.y, s.b.y),
+    maxY: Math.max(s.a.y, s.b.y)
+  })).sort((p, q) => p.minX - q.minX);
+  const splits = segments.map((segment) => ({ segment, points: /* @__PURE__ */ new Map() }));
+  for (let oi = 0; oi < order.length; oi++) {
+    const bi = order[oi];
+    const s1 = segments[bi.i];
+    for (let oj = oi + 1; oj < order.length; oj++) {
+      const bj = order[oj];
+      if (bj.minX > bi.maxX + eps) break;
+      if (bj.minY > bi.maxY + eps || bj.maxY < bi.minY - eps) continue;
+      const s2 = segments[bj.i];
+      const sharedA = s1.a.id === s2.a.id || s1.a.id === s2.b.id;
+      const sharedB = s1.b.id === s2.a.id || s1.b.id === s2.b.id;
+      if (sharedA && sharedB) continue;
+      let touched = false;
+      for (const [seg, other, split] of [
+        [s1, s2, splits[bi.i]],
+        [s2, s1, splits[bj.i]]
+      ]) {
+        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 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) {
+            addSplit(split, t2, p);
+            touched = true;
+          }
+        }
+      }
+      if (touched) continue;
+      const d1x = s1.b.x - s1.a.x;
+      const d1y = s1.b.y - s1.a.y;
+      const d2x = s2.b.x - s2.a.x;
+      const d2y = s2.b.y - s2.a.y;
+      const denom = d1x * d2y - d1y * d2x;
+      const len1 = Math.hypot(d1x, d1y);
+      const len2 = Math.hypot(d2x, d2y);
+      if (Math.abs(denom) <= 1e-12 * len1 * len2) continue;
+      const ex = s2.a.x - s1.a.x;
+      const ey = s2.a.y - s1.a.y;
+      const t = (ex * d2y - ey * d2x) / denom;
+      const u = (ex * d1y - ey * d1x) / denom;
+      const tolT = eps / len1;
+      const tolU = eps / len2;
+      if (t < -tolT || t > 1 + tolT || u < -tolU || u > 1 + tolU) continue;
+      if (sharedA || sharedB) continue;
+      const v = pool.get(s1.a.x + t * d1x, s1.a.y + t * d1y);
+      addSplit(splits[bi.i], project(s1.a, s1.b, v).t, v);
+      addSplit(splits[bj.i], project(s2.a, s2.b, v).t, v);
+    }
+  }
+  let changed = false;
+  const out = [];
+  for (const { segment, points } of splits) {
+    if (points.size === 0) {
+      out.push(segment);
+      continue;
+    }
+    changed = true;
+    const ordered = [...points.values()].sort((p, q) => p.t - q.t);
+    let prev = segment.a;
+    for (const { v } of ordered) {
+      if (v.id !== prev.id) out.push({ a: prev, b: v, operand: segment.operand });
+      prev = v;
+    }
+    if (prev.id !== segment.b.id) out.push({ a: prev, b: segment.b, operand: segment.operand });
+  }
+  return { segments: out, changed };
 }
-function matchArrangeShortcut(event, bindings = DEFAULT_ARRANGE_SHORTCUTS) {
-  if (isEventFromTextInput(event)) return null;
-  const code = eventCode(event);
-  const mod = event.metaKey || event.ctrlKey;
-  for (const binding of bindings) {
-    if (binding.code === code && !!binding.mod === mod && !!binding.alt === event.altKey && !!binding.shift === event.shiftKey) {
-      return binding.action;
+function defaultEpsilon(operands) {
+  let max = 0;
+  for (const op of operands) {
+    for (const ring of op.rings) {
+      for (const [x, y] of ring) {
+        const m = Math.max(Math.abs(x), Math.abs(y));
+        if (m > max) max = m;
+      }
     }
   }
-  return null;
+  return Math.max(1e-9, max * 1e-9);
+}
+function buildOverlay(inputs, options) {
+  const operands = inputs.map(normalizeInput);
+  const eps = options.epsilon && options.epsilon > 0 ? options.epsilon : defaultEpsilon(operands);
+  const pool = new PointPool(eps);
+  let segments = [];
+  operands.forEach((op, operand) => {
+    for (const ring of op.rings) {
+      const verts = ring.map(([x, y]) => pool.get(x, y));
+      for (let i = 0; i < verts.length; i++) {
+        const a = verts[i];
+        const b = verts[(i + 1) % verts.length];
+        if (a.id !== b.id) segments.push({ a, b, operand });
+      }
+    }
+  });
+  for (let pass = 0; pass < 8; pass++) {
+    const result = splitPass(segments, pool, eps);
+    segments = result.segments;
+    if (!result.changed) break;
+  }
+  const count = operands.length;
+  const byKey = /* @__PURE__ */ new Map();
+  for (const s of segments) {
+    const forward = s.a.id < s.b.id;
+    const a = forward ? s.a : s.b;
+    const b = forward ? s.b : s.a;
+    const key = `${a.id},${b.id}`;
+    let edge = byKey.get(key);
+    if (!edge) {
+      edge = { a, b, mult: new Array(count).fill(0) };
+      byKey.set(key, edge);
+    }
+    edge.mult[s.operand] += forward ? 1 : -1;
+  }
+  const edges = [...byKey.values()].filter((e) => e.mult.some((m) => m !== 0));
+  const right = [];
+  const left = [];
+  for (let i = 0; i < edges.length; i++) {
+    const edge = edges[i];
+    const horizontal = Math.abs(edge.b.y - edge.a.y) < Math.abs(edge.b.x - edge.a.x);
+    const tx = (v) => horizontal ? v.y : v.x;
+    const ty = (v) => horizontal ? -v.x : v.y;
+    const ax = tx(edge.a);
+    const ay = ty(edge.a);
+    const bx = tx(edge.b);
+    const by = ty(edge.b);
+    const mx = (ax + bx) / 2;
+    const my = (ay + by) / 2;
+    const winding = new Array(count).fill(0);
+    for (let j = 0; j < edges.length; j++) {
+      if (j === i) continue;
+      const other = edges[j];
+      const oax = tx(other.a);
+      const oay = ty(other.a);
+      const obx = tx(other.b);
+      const oby = ty(other.b);
+      let dir = 0;
+      if (oay <= my && oby > my) dir = 1;
+      else if (oby <= my && oay > my) dir = -1;
+      else continue;
+      const x = oax + (my - oay) / (oby - oay) * (obx - oax);
+      if (x <= mx) continue;
+      for (let k = 0; k < count; k++) {
+        if (other.mult[k] !== 0) winding[k] += dir * other.mult[k];
+      }
+    }
+    const sideIsRight = by > ay;
+    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, right, left, fillRules: operands.map((o) => o.fillRule), eps };
+}
+function insideFlags(windings, fillRules) {
+  return windings.map((w, k) => fillRules[k] === "evenodd" ? (w & 1) === 1 : w !== 0);
+}
+function traceRings(directed) {
+  const outgoing = /* @__PURE__ */ new Map();
+  for (const e of directed) {
+    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 next = (incoming) => {
+    const candidates = outgoing.get(incoming.to.id);
+    if (!candidates) return void 0;
+    const back = Math.atan2(incoming.from.y - incoming.to.y, incoming.from.x - incoming.to.x);
+    let best;
+    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;
+      if (turn < bestTurn) {
+        bestTurn = turn;
+        best = c;
+      }
+    }
+    return best;
+  };
+  const used = /* @__PURE__ */ new Set();
+  const rings = [];
+  for (const start of directed) {
+    if (used.has(start)) continue;
+    const ring = [];
+    let edge = start;
+    let guard = directed.length + 1;
+    while (edge && !used.has(edge) && guard-- > 0) {
+      used.add(edge);
+      ring.push(edge.from);
+      edge = next(edge);
+    }
+    if (ring.length >= 3) rings.push(ring);
+  }
+  return rings;
+}
+function removeCollinear(ring, eps) {
+  let points = ring;
+  let changed = true;
+  while (changed && points.length > 3) {
+    changed = false;
+    const out = [];
+    const n = points.length;
+    for (let i = 0; i < n; i++) {
+      const prev = out.length > 0 ? out[out.length - 1] : points[(i - 1 + n) % n];
+      const cur = points[i];
+      const nxt = points[(i + 1) % n];
+      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) {
+        changed = true;
+        continue;
+      }
+      out.push(cur);
+    }
+    if (out.length < 3) return out;
+    points = out;
+  }
+  return points;
+}
+function assemble(rings, eps) {
+  const outers = [];
+  const holes = [];
+  const minArea = eps * eps;
+  for (const vertices of rings) {
+    const ring = removeCollinear(
+      vertices.map((v) => [v.x, v.y]),
+      eps
+    );
+    if (ring.length < 3) continue;
+    const area = ringSignedArea(ring);
+    if (Math.abs(area) <= minArea) continue;
+    (area > 0 ? outers : holes).push({ ring, area: Math.abs(area) });
+  }
+  outers.sort((a, b) => b.area - a.area);
+  const polygons = outers.map((o) => [o.ring]);
+  for (const hole of holes) {
+    const [p, q] = [hole.ring[0], hole.ring[1]];
+    const sample = [(p[0] + q[0]) / 2, (p[1] + q[1]) / 2];
+    let owner = -1;
+    for (let i = outers.length - 1; i >= 0; i--) {
+      if (outers[i].area >= hole.area && pointInRings(sample, [outers[i].ring], "evenodd")) {
+        owner = i;
+        break;
+      }
+    }
+    if (owner >= 0) polygons[owner].push(hole.ring);
+  }
+  return polygons;
+}
+function extract(overlay, isInside) {
+  const directed = [];
+  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) });
+  });
+  return assemble(traceRings(directed), overlay.eps);
+}
+function predicate(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 polygonBoolean(operation, operands, options = {}) {
+  if (operands.length === 0) return [];
+  return extract(buildOverlay(operands, options), predicate(operation));
+}
+var unionPolygons = (a, b, options) => polygonBoolean("union", [a, b], options);
+var intersectPolygons = (a, b, options) => polygonBoolean("intersection", [a, b], options);
+var subtractPolygons = (a, b, options) => polygonBoolean("difference", [a, b], options);
+var xorPolygons = (a, b, options) => polygonBoolean("xor", [a, b], options);
+function dividePolygons(operands, options = {}) {
+  if (operands.length === 0) return [];
+  const overlay = buildOverlay(operands, options);
+  const signatures = /* @__PURE__ */ new Map();
+  const note = (windings) => {
+    const flags = insideFlags(windings, overlay.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] : []));
+  };
+  overlay.edges.forEach((_, i) => {
+    note(overlay.left[i]);
+    note(overlay.right[i]);
+  });
+  const pieces = [];
+  const keys = [...signatures.keys()].sort();
+  for (const key of keys) {
+    const polygons = extract(overlay, (flags) => flags.map((f) => f ? "1" : "0").join("") === key);
+    polygons.sort((a, b) => polygonArea(b) - polygonArea(a));
+    for (const polygon of polygons) pieces.push({ polygon, operands: signatures.get(key) });
+  }
+  return pieces;
+}
+
+// src/canvas/curveFit.ts
+function formatNumber(value, precision) {
+  const factor = 10 ** precision;
+  const rounded = Math.round(value * factor) / factor;
+  return Object.is(rounded, -0) ? "0" : String(rounded);
+}
+var MAX_REPARAM = 6;
+var sub = (a, b) => [a[0] - b[0], a[1] - b[1]];
+var add = (a, v, s = 1) => [a[0] + v[0] * s, a[1] + v[1] * s];
+var dot = (a, b) => a[0] * b[0] + a[1] * b[1];
+var dist = (a, b) => Math.hypot(a[0] - b[0], a[1] - b[1]);
+function unit(v) {
+  const l = Math.hypot(v[0], v[1]);
+  return l > 1e-12 && Number.isFinite(l) ? [v[0] / l, v[1] / l] : null;
+}
+function evalCubic(c, t) {
+  const s = 1 - t;
+  const b0 = s * s * s;
+  const b1 = 3 * s * s * t;
+  const b2 = 3 * s * t * t;
+  const b3 = t * t * t;
+  return [
+    b0 * c.p0[0] + b1 * c.p1[0] + b2 * c.p2[0] + b3 * c.p3[0],
+    b0 * c.p0[1] + b1 * c.p1[1] + b2 * c.p2[1] + b3 * c.p3[1]
+  ];
+}
+function cubicPointAt(c, t) {
+  return evalCubic(c, t);
+}
+function dedup(points) {
+  const out = [];
+  for (const p of points) {
+    if (!Number.isFinite(p[0]) || !Number.isFinite(p[1])) continue;
+    if (out.length === 0 || dist(out[out.length - 1], p) > 1e-12) out.push(p);
+  }
+  return out;
+}
+function chordParams(pts) {
+  const u = [0];
+  let acc = 0;
+  for (let i = 1; i < pts.length; i++) {
+    acc += dist(pts[i - 1], pts[i]);
+    u.push(acc);
+  }
+  return acc > 0 ? u.map((x) => x / acc) : u;
+}
+function generate(pts, u, t0, t1) {
+  const p0 = pts[0];
+  const p3 = pts[pts.length - 1];
+  const dirIn = [-t1[0], -t1[1]];
+  let c00 = 0;
+  let c01 = 0;
+  let c11 = 0;
+  let x0 = 0;
+  let x1 = 0;
+  for (let i = 0; i < pts.length; i++) {
+    const t = u[i];
+    const s = 1 - t;
+    const b0 = s * s * s;
+    const b1 = 3 * s * s * t;
+    const b2 = 3 * s * t * t;
+    const b3 = t * t * t;
+    const a0 = [t0[0] * b1, t0[1] * b1];
+    const a1 = [dirIn[0] * b2, dirIn[1] * b2];
+    c00 += dot(a0, a0);
+    c01 += dot(a0, a1);
+    c11 += dot(a1, a1);
+    const tmp = [
+      pts[i][0] - (p0[0] * (b0 + b1) + p3[0] * (b2 + b3)),
+      pts[i][1] - (p0[1] * (b0 + b1) + p3[1] * (b2 + b3))
+    ];
+    x0 += dot(a0, tmp);
+    x1 += dot(a1, tmp);
+  }
+  const det = c00 * c11 - c01 * c01;
+  const seg = dist(p0, p3);
+  const eps = 1e-6 * seg;
+  let al = seg / 3;
+  let ar = seg / 3;
+  if (Math.abs(det) > 1e-12) {
+    al = (x0 * c11 - x1 * c01) / det;
+    ar = (c00 * x1 - c01 * x0) / det;
+  }
+  if (!Number.isFinite(al) || !Number.isFinite(ar) || al < eps || ar < eps) {
+    al = seg / 3;
+    ar = seg / 3;
+  }
+  const cap = seg * 4 + 1e-9;
+  al = Math.min(al, cap);
+  ar = Math.min(ar, cap);
+  return { p0, p1: add(p0, t0, al), p2: add(p3, dirIn, ar), p3 };
+}
+function maxError(pts, c, u) {
+  let e = 0;
+  let idx = pts.length >> 1;
+  for (let i = 0; i < pts.length; i++) {
+    const d = dist(evalCubic(c, u[i]), pts[i]);
+    if (d > e) {
+      e = d;
+      idx = i;
+    }
+  }
+  return [e, idx];
+}
+function newton(c, p, t) {
+  const s = 1 - t;
+  const q = evalCubic(c, t);
+  const d1 = [
+    3 * (s * s * (c.p1[0] - c.p0[0]) + 2 * s * t * (c.p2[0] - c.p1[0]) + t * t * (c.p3[0] - c.p2[0])),
+    3 * (s * s * (c.p1[1] - c.p0[1]) + 2 * s * t * (c.p2[1] - c.p1[1]) + t * t * (c.p3[1] - c.p2[1]))
+  ];
+  const d2 = [
+    6 * (s * (c.p2[0] - 2 * c.p1[0] + c.p0[0]) + t * (c.p3[0] - 2 * c.p2[0] + c.p1[0])),
+    6 * (s * (c.p2[1] - 2 * c.p1[1] + c.p0[1]) + t * (c.p3[1] - 2 * c.p2[1] + c.p1[1]))
+  ];
+  const diff = [q[0] - p[0], q[1] - p[1]];
+  const num = dot(diff, d1);
+  const den = dot(d1, d1) + dot(diff, d2);
+  if (Math.abs(den) < 1e-12) return t;
+  const nt = t - num / den;
+  return Number.isFinite(nt) ? Math.min(1, Math.max(0, nt)) : t;
+}
+function fitSingleFrom(pts, u, t0, t1) {
+  let best = generate(pts, u, t0, t1);
+  let [bestErr, bestSplit] = maxError(pts, best, u);
+  const params = u.slice();
+  for (let round = 0; round < MAX_REPARAM; round++) {
+    for (let i = 0; i < params.length; i++) params[i] = newton(best, pts[i], params[i]);
+    const c = generate(pts, params, t0, t1);
+    const [e, s] = maxError(pts, c, params);
+    if (e < bestErr) {
+      best = c;
+      bestErr = e;
+      bestSplit = s;
+    } else break;
+  }
+  return [best, bestErr, bestSplit];
+}
+function fitRec(pts, t0, t1, tol, out, depth) {
+  const n = pts.length;
+  if (n === 2) {
+    const d = dist(pts[0], pts[1]) / 3;
+    out.push({ p0: pts[0], p1: add(pts[0], t0, d), p2: add(pts[1], t1, -d), p3: pts[1] });
+    return;
+  }
+  const [c, err, splitAt] = fitSingleFrom(pts, chordParams(pts), t0, t1);
+  if (err <= tol || depth > 40) {
+    out.push(c);
+    return;
+  }
+  const split = Math.min(n - 2, Math.max(1, splitAt));
+  const tc = unit(sub(pts[split + 1], pts[split - 1])) ?? t0;
+  fitRec(pts.slice(0, split + 1), t0, tc, tol, out, depth + 1);
+  fitRec(pts.slice(split), tc, t1, tol, out, depth + 1);
+}
+function tangentFrom(a, b, c) {
+  const chord = unit(sub(b, a));
+  if (!c) return chord;
+  const d1 = dist(a, b);
+  const d2 = dist(b, c);
+  if (!(d1 > 0) || !(d2 > 0)) return chord;
+  const ka = -(2 * d1 + d2) / (d1 * (d1 + d2));
+  const kb = (d1 + d2) / (d1 * d2);
+  const kc = -d1 / (d2 * (d1 + d2));
+  const est = unit([ka * a[0] + kb * b[0] + kc * c[0], ka * a[1] + kb * b[1] + kc * c[1]]);
+  return est && chord && dot(est, chord) > Math.cos(Math.PI / 4) ? est : chord;
+}
+function fitCubicRun(points, tolerance, t0, t1) {
+  const pts = dedup(points);
+  const out = [];
+  if (pts.length < 2) return out;
+  const n = pts.length;
+  const start = (t0 && unit([t0[0], t0[1]])) ?? tangentFrom(pts[0], pts[1], pts[2]) ?? [1, 0];
+  const back = tangentFrom(pts[n - 1], pts[n - 2], pts[n - 3]);
+  const end = (t1 && unit([t1[0], t1[1]])) ?? (back ? [-back[0], -back[1]] : [1, 0]);
+  fitRec(pts, start, end, Math.max(tolerance, 1e-9), out, 0);
+  return out;
+}
+function turnDeg(a, b, c) {
+  const u = unit(sub(b, a));
+  const v = unit(sub(c, b));
+  if (!u || !v) return 0;
+  return Math.acos(Math.min(1, Math.max(-1, dot(u, v)))) * 180 / Math.PI;
+}
+function findCorners(pts, closed, cornerAngle, span) {
+  const n = pts.length;
+  const at = (i) => pts[closed ? (i % n + n) % n : i];
+  const reach = (i, step) => {
+    for (let k = 1; k < (closed ? n : Infinity); k++) {
+      const j = i + step * k;
+      if (!closed && (j < 0 || j >= n)) return k > 1 ? j - step : null;
+      if (dist(at(j), pts[i]) >= span) return j;
+    }
+    return null;
+  };
+  const turns = new Float64Array(n);
+  const windows = [];
+  for (let i = 0; i < n; i++) {
+    windows.push([i, i]);
+    if (!closed && (i === 0 || i === n - 1)) continue;
+    const prev = reach(i, -1);
+    const next = reach(i, 1);
+    if (prev === null || next === null) continue;
+    windows[i] = [prev, next];
+    turns[i] = turnDeg(at(prev), pts[i], at(next));
+  }
+  const corners = [];
+  for (let i = 0; i < n; i++) {
+    if (!(turns[i] > cornerAngle)) continue;
+    const [lo, hi] = windows[i];
+    let sharpest = true;
+    for (let j = lo; j <= hi && sharpest; j++) {
+      const k = closed ? (j % n + n) % n : j;
+      if (k === i || dist(pts[k], pts[i]) >= span) continue;
+      if (turns[k] > turns[i] || turns[k] === turns[i] && k < i) sharpest = false;
+    }
+    if (sharpest) corners.push(i);
+  }
+  return corners;
+}
+function densify(run) {
+  if (run.length < 3) return run;
+  const lengths = [];
+  for (let i = 1; i < run.length; i++) lengths.push(dist(run[i - 1], run[i]));
+  const sorted = [...lengths].sort((a, b) => a - b);
+  const median = sorted[sorted.length >> 1];
+  if (!(median > 0)) return run;
+  const out = [run[0]];
+  for (let i = 1; i < run.length; i++) {
+    const len = lengths[i - 1];
+    if (len > 2 * median) {
+      const steps = Math.min(64, Math.ceil(len / median));
+      const a = run[i - 1];
+      const b = run[i];
+      for (let k = 1; k < steps; k++) {
+        const t = k / steps;
+        out.push([a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t]);
+      }
+    }
+    out.push(run[i]);
+  }
+  return out;
+}
+function fitCubics(points, tolerance, options = {}) {
+  let pts = dedup(points);
+  const closed = options.closed === true;
+  if (closed && pts.length > 1 && dist(pts[0], pts[pts.length - 1]) <= 1e-12) pts = pts.slice(0, -1);
+  if (pts.length < 2) return [];
+  const tol = Math.max(tolerance, 1e-6);
+  const cornerAngle = options.cornerAngleDeg ?? 30;
+  const n = pts.length;
+  const span = 4 * tol;
+  if (!closed || n < 3) {
+    const corners2 = [0, ...n > 2 ? findCorners(pts, false, cornerAngle, span) : [], n - 1];
+    const out2 = [];
+    for (let k = 1; k < corners2.length; k++) {
+      const run = pts.slice(corners2[k - 1], corners2[k] + 1);
+      out2.push(...fitCubicRun(densify(run), tol));
+    }
+    if (closed && n === 2) out2.push(...fitCubicRun([pts[1], pts[0]], tol));
+    return out2;
+  }
+  const corners = findCorners(pts, true, cornerAngle, span);
+  if (corners.length === 0) {
+    const ring = [...pts, pts[0]];
+    const t = unit(sub(pts[1], pts[n - 1])) ?? [1, 0];
+    return fitCubicRun(densify(ring), tol, t, t);
+  }
+  const out = [];
+  for (let k = 0; k < corners.length; k++) {
+    const from = corners[k];
+    const to = corners[(k + 1) % corners.length];
+    const run = [];
+    for (let i = from; ; i = (i + 1) % n) {
+      run.push(pts[i]);
+      if (run.length > 1 && i === to) break;
+    }
+    out.push(...fitCubicRun(densify(run), tol));
+  }
+  return out;
+}
+function isStraightCubic(c, tol) {
+  const chord = sub(c.p3, c.p0);
+  const len = Math.hypot(chord[0], chord[1]);
+  if (len < 1e-12) return dist(c.p1, c.p0) <= tol && dist(c.p2, c.p0) <= tol;
+  const dir = [chord[0] / len, chord[1] / len];
+  return [c.p1, c.p2].every((h) => {
+    const v = sub(h, c.p0);
+    const along = dot(v, dir);
+    const across = Math.abs(v[0] * dir[1] - v[1] * dir[0]);
+    return across <= tol && along >= -tol && along <= len + tol;
+  });
+}
+function cubicsToPathData(segments, options = {}) {
+  if (segments.length === 0) return "";
+  const f = (n) => formatNumber(n, options.precision ?? 3);
+  const dx = options.offset?.x ?? 0;
+  const dy = options.offset?.y ?? 0;
+  const pt = (p) => `${f(p[0] + dx)} ${f(p[1] + dy)}`;
+  const straight = options.straightTolerance ?? 1e-3;
+  let d = `M${pt(segments[0].p0)}`;
+  segments.forEach((c, i) => {
+    const last = options.closed && i === segments.length - 1;
+    if (isStraightCubic(c, straight)) {
+      if (!last) d += `L${pt(c.p3)}`;
+    } else d += `C${pt(c.p1)} ${pt(c.p2)} ${pt(c.p3)}`;
+  });
+  return options.closed ? `${d}Z` : d;
+}
+function polylineToPathData(points, closed, options) {
+  if (points.length < 2) return "";
+  const f = (n) => formatNumber(n, options.precision ?? 3);
+  const dx = options.offset?.x ?? 0;
+  const dy = options.offset?.y ?? 0;
+  let d = `M${f(points[0][0] + dx)} ${f(points[0][1] + dy)}`;
+  for (let i = 1; i < points.length; i++) d += `L${f(points[i][0] + dx)} ${f(points[i][1] + dy)}`;
+  return closed ? `${d}Z` : d;
+}
+function fitPathData(ring, options = {}) {
+  const closed = options.closed ?? true;
+  const tolerance = options.tolerance ?? 0.5;
+  const pts = dedup(ring);
+  const segments = fitCubics(pts, tolerance, { ...options, closed });
+  if (segments.length === 0) return "";
+  const edges = closed ? pts.length : pts.length - 1;
+  if (options.noWorse !== false) {
+    const straight = segments.filter((c) => isStraightCubic(c, tolerance * 0.02)).length;
+    if (segments.length >= edges && straight === segments.length) return polylineToPathData(pts, closed, options);
+    if (segments.length > edges) return polylineToPathData(pts, closed, options);
+  }
+  return cubicsToPathData(segments, {
+    precision: options.precision,
+    offset: options.offset,
+    closed,
+    straightTolerance: tolerance * 0.02
+  });
+}
+function fitFreehandPath(points, options = {}) {
+  return fitPathData(points, { tolerance: 1, ...options, closed: false });
+}
+
+// src/canvas/shapeGeometry.ts
+var SHAPE_KINDS = ["rect", "ellipse", "polygon", "star", "path"];
+function isShapeDescription(value) {
+  if (!value || typeof value !== "object") return false;
+  const kind = value.kind;
+  if (!SHAPE_KINDS.includes(kind)) return false;
+  return kind !== "path" || typeof value.d === "string";
+}
+var PARAM_COUNTS = { m: 2, l: 2, h: 1, v: 1, c: 6, s: 4, q: 4, t: 2, a: 7, z: 0 };
+var PathScanner = class {
+  constructor(text) {
+    this.text = text;
+  }
+  text;
+  pos = 0;
+  skip() {
+    while (this.pos < this.text.length && /[\s,]/.test(this.text[this.pos])) this.pos++;
+  }
+  /** The next command letter, or `null` when a number (or the end) follows. */
+  command() {
+    this.skip();
+    const ch = this.text[this.pos];
+    if (ch && /[MmLlHhVvCcSsQqTtAaZz]/.test(ch)) {
+      this.pos++;
+      return ch;
+    }
+    return null;
+  }
+  done() {
+    this.skip();
+    return this.pos >= this.text.length;
+  }
+  number() {
+    this.skip();
+    const match = /^[+-]?(?:\d+\.?\d*|\.\d+)(?:[eE][+-]?\d+)?/.exec(this.text.slice(this.pos, this.pos + 64));
+    if (!match) return null;
+    this.pos += match[0].length;
+    const value = Number(match[0]);
+    return Number.isFinite(value) ? value : null;
+  }
+  flag() {
+    this.skip();
+    const ch = this.text[this.pos];
+    if (ch === "0" || ch === "1") {
+      this.pos++;
+      return ch === "1" ? 1 : 0;
+    }
+    return null;
+  }
+};
+function parseSvgPath(d) {
+  const scanner = new PathScanner(d ?? "");
+  const commands = [];
+  let cx = 0;
+  let cy = 0;
+  let startX = 0;
+  let startY = 0;
+  let lastControl = null;
+  let command = "";
+  while (!scanner.done()) {
+    const letter = scanner.command();
+    if (letter) {
+      command = letter;
+      if (command === "z" || command === "Z") {
+        commands.push({ type: "Z" });
+        cx = startX;
+        cy = startY;
+        lastControl = null;
+        continue;
+      }
+    } else if (!command || command === "z" || command === "Z") {
+      break;
+    }
+    const lower = command.toLowerCase();
+    const count = PARAM_COUNTS[lower];
+    const args = [];
+    for (let k = 0; k < count; k++) {
+      const value = lower === "a" && (k === 3 || k === 4) ? scanner.flag() : scanner.number();
+      if (value === null) return commands;
+      args.push(value);
+    }
+    const rel = command !== command.toUpperCase();
+    const ox = rel ? cx : 0;
+    const oy = rel ? cy : 0;
+    switch (lower) {
+      case "m": {
+        cx = args[0] + ox;
+        cy = args[1] + oy;
+        startX = cx;
+        startY = cy;
+        commands.push({ type: "M", x: cx, y: cy });
+        lastControl = null;
+        command = rel ? "l" : "L";
+        break;
+      }
+      case "l":
+        cx = args[0] + ox;
+        cy = args[1] + oy;
+        commands.push({ type: "L", x: cx, y: cy });
+        lastControl = null;
+        break;
+      case "h":
+        cx = args[0] + (rel ? cx : 0);
+        commands.push({ type: "L", x: cx, y: cy });
+        lastControl = null;
+        break;
+      case "v":
+        cy = args[0] + (rel ? cy : 0);
+        commands.push({ type: "L", x: cx, y: cy });
+        lastControl = null;
+        break;
+      case "c": {
+        const c = {
+          type: "C",
+          x1: args[0] + ox,
+          y1: args[1] + oy,
+          x2: args[2] + ox,
+          y2: args[3] + oy,
+          x: args[4] + ox,
+          y: args[5] + oy
+        };
+        commands.push(c);
+        lastControl = { x: c.x2, y: c.y2, type: "C" };
+        cx = c.x;
+        cy = c.y;
+        break;
+      }
+      case "s": {
+        const x1 = lastControl?.type === "C" ? 2 * cx - lastControl.x : cx;
+        const y1 = lastControl?.type === "C" ? 2 * cy - lastControl.y : cy;
+        const c = {
+          type: "C",
+          x1,
+          y1,
+          x2: args[0] + ox,
+          y2: args[1] + oy,
+          x: args[2] + ox,
+          y: args[3] + oy
+        };
+        commands.push(c);
+        lastControl = { x: c.x2, y: c.y2, type: "C" };
+        cx = c.x;
+        cy = c.y;
+        break;
+      }
+      case "q": {
+        const c = { type: "Q", x1: args[0] + ox, y1: args[1] + oy, x: args[2] + ox, y: args[3] + oy };
+        commands.push(c);
+        lastControl = { x: c.x1, y: c.y1, type: "Q" };
+        cx = c.x;
+        cy = c.y;
+        break;
+      }
+      case "t": {
+        const x1 = lastControl?.type === "Q" ? 2 * cx - lastControl.x : cx;
+        const y1 = lastControl?.type === "Q" ? 2 * cy - lastControl.y : cy;
+        const c = { type: "Q", x1, y1, x: args[0] + ox, y: args[1] + oy };
+        commands.push(c);
+        lastControl = { x: x1, y: y1, type: "Q" };
+        cx = c.x;
+        cy = c.y;
+        break;
+      }
+      case "a": {
+        const c = {
+          type: "A",
+          rx: Math.abs(args[0]),
+          ry: Math.abs(args[1]),
+          rotation: args[2],
+          largeArc: args[3] !== 0,
+          sweep: args[4] !== 0,
+          x: args[5] + ox,
+          y: args[6] + oy
+        };
+        commands.push(c);
+        lastControl = null;
+        cx = c.x;
+        cy = c.y;
+        break;
+      }
+    }
+  }
+  return commands;
+}
+function segmentCount(curvature, tolerance, max) {
+  if (!(curvature > 0)) return 1;
+  return Math.max(1, Math.min(max, Math.ceil(Math.sqrt(curvature / tolerance))));
+}
+function flattenCubic(out, p0, x1, y1, x2, y2, x, y, tolerance, max) {
+  const dd = Math.max(
+    Math.hypot(p0[0] - 2 * x1 + x2, p0[1] - 2 * y1 + y2),
+    Math.hypot(x1 - 2 * x2 + x, y1 - 2 * y2 + y)
+  );
+  const n = segmentCount(6 * dd / 8, tolerance, max);
+  for (let k = 1; k <= n; k++) {
+    const t = k / n;
+    const mt = 1 - t;
+    const a = mt * mt * mt;
+    const b = 3 * mt * mt * t;
+    const c = 3 * mt * t * t;
+    const e = t * t * t;
+    out.push([a * p0[0] + b * x1 + c * x2 + e * x, a * p0[1] + b * y1 + c * y2 + e * y]);
+  }
+}
+function flattenQuadratic(out, p0, x1, y1, x, y, tolerance, max) {
+  const dd = Math.hypot(p0[0] - 2 * x1 + x, p0[1] - 2 * y1 + y);
+  const n = segmentCount(2 * dd / 8, tolerance, max);
+  for (let k = 1; k <= n; k++) {
+    const t = k / n;
+    const mt = 1 - t;
+    out.push([mt * mt * p0[0] + 2 * mt * t * x1 + t * t * x, mt * mt * p0[1] + 2 * mt * t * y1 + t * t * y]);
+  }
+}
+function arcSteps(radius, sweep, tolerance, max) {
+  if (radius <= tolerance) return Math.max(1, Math.ceil(Math.abs(sweep) / (Math.PI / 2)));
+  const step = 2 * Math.acos(1 - tolerance / radius);
+  return Math.max(1, Math.min(max, Math.ceil(Math.abs(sweep) / step)));
+}
+function flattenArc(out, p0, cmd, tolerance, max) {
+  const [x0, y0] = p0;
+  let { rx, ry } = cmd;
+  const { x, y } = cmd;
+  if (x0 === x && y0 === y) return;
+  if (rx === 0 || ry === 0) {
+    out.push([x, y]);
+    return;
+  }
+  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) => {
+    const a = Math.atan2(ux * vy - uy * vx, ux * vx + uy * vy);
+    return a;
+  };
+  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 = arcSteps(Math.max(rx, ry), delta, tolerance, max);
+  for (let k = 1; k < n; k++) {
+    const t = theta1 + delta * k / n;
+    const ex = rx * Math.cos(t);
+    const ey = ry * Math.sin(t);
+    out.push([cos * ex - sin * ey + cx, sin * ex + cos * ey + cy]);
+  }
+  out.push([x, y]);
+}
+function flattenSvgPath(d, options = {}) {
+  const tolerance = options.tolerance && options.tolerance > 0 ? options.tolerance : 0.25;
+  const max = options.maxSegments ?? 512;
+  const commands = typeof d === "string" ? parseSvgPath(d) : d;
+  const rings = [];
+  let current = [];
+  let start = [0, 0];
+  const flush = () => {
+    if (current.length >= 3) rings.push(current);
+    current = [];
+  };
+  const last = () => current[current.length - 1] ?? start;
+  for (const cmd of commands) {
+    switch (cmd.type) {
+      case "M":
+        flush();
+        start = [cmd.x, cmd.y];
+        current = [start];
+        break;
+      case "L":
+        if (current.length === 0) current = [start];
+        current.push([cmd.x, cmd.y]);
+        break;
+      case "C":
+        if (current.length === 0) current = [start];
+        flattenCubic(current, last(), cmd.x1, cmd.y1, cmd.x2, cmd.y2, cmd.x, cmd.y, tolerance, max);
+        break;
+      case "Q":
+        if (current.length === 0) current = [start];
+        flattenQuadratic(current, last(), cmd.x1, cmd.y1, cmd.x, cmd.y, tolerance, max);
+        break;
+      case "A":
+        if (current.length === 0) current = [start];
+        flattenArc(current, last(), cmd, tolerance, max);
+        break;
+      case "Z":
+        flush();
+        break;
+    }
+  }
+  flush();
+  return rings.map(dedupeRing).filter((r) => r.length >= 3);
+}
+function dedupeRing(ring) {
+  const out = [];
+  for (const p of ring) {
+    const prev = out[out.length - 1];
+    if (!prev || prev[0] !== p[0] || prev[1] !== p[1]) out.push(p);
+  }
+  while (out.length > 1 && out[0][0] === out[out.length - 1][0] && out[0][1] === out[out.length - 1][1]) out.pop();
+  return out;
+}
+function cornerRadii(shape, width, height) {
+  const raw = shape.cornerRadius ?? 0;
+  let radii = (typeof raw === "number" ? [raw, raw, raw, raw] : [...raw]).map(
+    (r) => Number.isFinite(r) && r > 0 ? r : 0
+  );
+  const factor = Math.min(
+    1,
+    width / Math.max(radii[0] + radii[1], 1e-12),
+    height / Math.max(radii[1] + radii[2], 1e-12),
+    width / Math.max(radii[2] + radii[3], 1e-12),
+    height / Math.max(radii[3] + radii[0], 1e-12)
+  );
+  if (factor < 1) radii = radii.map((r) => r * factor);
+  return radii;
+}
+function polygonVertices(count, inner, width, height) {
+  const raw = [];
+  const total = inner === null ? count : count * 2;
+  for (let k = 0; k < total; k++) {
+    const angle = -Math.PI / 2 + k * 2 * Math.PI / total;
+    const r = inner !== null && k % 2 === 1 ? inner : 1;
+    raw.push([r * Math.cos(angle), r * Math.sin(angle)]);
+  }
+  let minX = Infinity;
+  let minY = Infinity;
+  let maxX = -Infinity;
+  let maxY = -Infinity;
+  for (const [x, y] of raw) {
+    minX = Math.min(minX, x);
+    minY = Math.min(minY, y);
+    maxX = Math.max(maxX, x);
+    maxY = Math.max(maxY, y);
+  }
+  const sx = width / (maxX - minX || 1);
+  const sy = height / (maxY - minY || 1);
+  return raw.map(([x, y]) => [(x - minX) * sx, (y - minY) * sy]);
+}
+function rotationTransform(shape, size) {
+  const deg = shape.rotation ?? 0;
+  if (!deg || !Number.isFinite(deg)) return null;
+  const rad = deg * Math.PI / 180;
+  const cos = Math.cos(rad);
+  const sin = Math.sin(rad);
+  const cx = size.width / 2;
+  const cy = size.height / 2;
+  return ([x, y]) => [cx + (x - cx) * cos - (y - cy) * sin, cy + (x - cx) * sin + (y - cy) * cos];
+}
+function getShapeSvg(shape, size) {
+  const { width: w, height: h } = size;
+  const f = (n) => formatNumber2(n, 3);
+  const transforms = [];
+  if (shape.rotation) transforms.push(`rotate(${f(shape.rotation)} ${f(w / 2)} ${f(h / 2)})`);
+  let d = "";
+  let fillRule = "nonzero";
+  switch (shape.kind) {
+    case "rect": {
+      const [tl, tr, br, bl] = cornerRadii(shape, w, h);
+      if (tl + tr + br + bl === 0) {
+        d = `M0 0H${f(w)}V${f(h)}H0Z`;
+      } else {
+        const arc = (r, x, y) => r > 0 ? `A${f(r)} ${f(r)} 0 0 1 ${f(x)} ${f(y)}` : "";
+        d = `M${f(tl)} 0H${f(w - tr)}${arc(tr, w, tr)}V${f(h - br)}${arc(br, w - br, h)}H${f(bl)}${arc(bl, 0, h - bl)}V${f(tl)}${arc(tl, tl, 0)}Z`;
+      }
+      break;
+    }
+    case "ellipse": {
+      const rx = w / 2;
+      const ry = h / 2;
+      d = `M0 ${f(ry)}A${f(rx)} ${f(ry)} 0 1 1 ${f(w)} ${f(ry)}A${f(rx)} ${f(ry)} 0 1 1 0 ${f(ry)}Z`;
+      break;
+    }
+    case "polygon":
+    case "star": {
+      const points = shape.kind === "polygon" ? polygonVertices(Math.max(3, Math.floor(shape.sides ?? 6)), null, w, h) : polygonVertices(Math.max(3, Math.floor(shape.points ?? 5)), clampRatio(shape.innerRadius), w, h);
+      d = ringsToPath([points], f);
+      break;
+    }
+    case "path": {
+      d = shape.d;
+      fillRule = shape.fillRule ?? "nonzero";
+      const vb = validViewBox(shape.viewBox);
+      if (vb) {
+        transforms.push(
+          `scale(${f(w / vb[2])} ${f(h / vb[3])})`,
+          `translate(${f(-vb[0])} ${f(-vb[1])})`
+        );
+      }
+      break;
+    }
+  }
+  return transforms.length > 0 ? { d, transform: transforms.join(" "), fillRule } : { d, fillRule };
+}
+function getShapeRenderData(shape, size = {}) {
+  const vb = shape.kind === "path" ? validViewBox(shape.viewBox) : null;
+  const width = size.width && size.width > 0 ? size.width : vb ? vb[2] : 100;
+  const height = size.height && size.height > 0 ? size.height : vb ? vb[3] : 100;
+  const svg = getShapeSvg(shape, { width, height });
+  const data = {
+    viewBox: `0 0 ${formatNumber2(width, 3)} ${formatNumber2(height, 3)}`,
+    width,
+    height,
+    d: svg.d,
+    fillRule: svg.fillRule,
+    fill: shape.fill ?? "currentColor",
+    stroke: shape.stroke ?? "none",
+    strokeWidth: shape.strokeWidth ?? 1
+  };
+  if (svg.transform) data.transform = svg.transform;
+  if (shape.opacity !== void 0) data.opacity = shape.opacity;
+  return data;
+}
+function clampRatio(value) {
+  if (value === void 0 || !Number.isFinite(value)) return 0.5;
+  return Math.min(1, Math.max(0.01, value));
+}
+function validViewBox(vb) {
+  if (!vb || vb.length !== 4 || !vb.every(Number.isFinite) || vb[2] <= 0 || vb[3] <= 0) return null;
+  return vb;
+}
+function shapeToPolygon(shape, size, options = {}) {
+  const { width: w, height: h } = size;
+  if (!(w > 0) || !(h > 0)) return { rings: [], fillRule: "nonzero" };
+  let rings;
+  let fillRule = "nonzero";
+  if (shape.kind === "path") {
+    fillRule = shape.fillRule ?? "nonzero";
+    const vb = validViewBox(shape.viewBox);
+    if (vb) {
+      const sx = w / vb[2];
+      const sy = h / vb[3];
+      const tolerance = (options.tolerance ?? 0.25) / Math.max(sx, sy);
+      rings = flattenSvgPath(shape.d, { ...options, tolerance }).map(
+        (ring) => ring.map(([x, y]) => [(x - vb[0]) * sx, (y - vb[1]) * sy])
+      );
+    } else {
+      rings = flattenSvgPath(shape.d, options);
+    }
+  } else {
+    const { d } = getShapeSvg({ ...shape, rotation: 0 }, size);
+    rings = flattenSvgPath(d, options);
+  }
+  const rotate = rotationTransform(shape, size);
+  if (rotate) rings = rings.map((ring) => ring.map(rotate));
+  return { rings, fillRule };
+}
+function formatNumber2(value, precision = 3) {
+  const factor = 10 ** precision;
+  const rounded = Math.round(value * factor) / factor;
+  return Object.is(rounded, -0) ? "0" : String(rounded);
+}
+function ringsToPath(rings, f) {
+  let d = "";
+  for (const ring of rings) {
+    if (ring.length < 2) continue;
+    d += `M${f(ring[0][0])} ${f(ring[0][1])}`;
+    for (let i = 1; i < ring.length; i++) d += `L${f(ring[i][0])} ${f(ring[i][1])}`;
+    d += "Z";
+  }
+  return d;
+}
+function segmentDistance(p, a, b) {
+  const dx = b[0] - a[0];
+  const dy = b[1] - a[1];
+  const len2 = dx * dx + dy * dy;
+  if (len2 === 0) return Math.hypot(p[0] - a[0], p[1] - a[1]);
+  const t = Math.max(0, Math.min(1, ((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / len2));
+  return Math.hypot(p[0] - (a[0] + t * dx), p[1] - (a[1] + t * dy));
+}
+function rdp(points, tolerance) {
+  if (points.length <= 2) return points;
+  const keep = new Uint8Array(points.length);
+  keep[0] = 1;
+  keep[points.length - 1] = 1;
+  const stack = [[0, points.length - 1]];
+  while (stack.length) {
+    const [s, e] = stack.pop();
+    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;
+        index = i;
+      }
+    }
+    if (index !== -1 && maxDist > tolerance) {
+      keep[index] = 1;
+      stack.push([s, index], [index, e]);
+    }
+  }
+  return points.filter((_, i) => keep[i]);
+}
+function simplifyRing(ring, tolerance) {
+  if (ring.length <= 3 || !(tolerance > 0)) return [...ring];
+  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;
+      far = i;
+    }
+  }
+  const first = rdp(ring.slice(0, far + 1), tolerance);
+  const second = rdp([...ring.slice(far), ring[0]], tolerance);
+  const out = [...first.slice(0, -1), ...second.slice(0, -1)];
+  return out.length >= 3 ? out : [];
+}
+function polygonToSvgPath(input, options = {}) {
+  const precision = options.precision ?? 3;
+  const f = (n) => formatNumber2(n, precision);
+  const dx = options.offset?.x ?? 0;
+  const dy = options.offset?.y ?? 0;
+  const rings = [];
+  const fit = options.curves === "fit";
+  let fitted = "";
+  for (const item of input) {
+    const list = item.length > 0 && Array.isArray(item[0]) && Array.isArray(item[0][0]) ? item : [item];
+    for (const ring of list) {
+      let r = ring;
+      if (options.simplify && options.simplify > 0) r = simplifyRing(r, options.simplify);
+      if (r.length < 3) continue;
+      if (fit) {
+        fitted += fitPathData(r, {
+          tolerance: options.curveTolerance ?? 0.25,
+          cornerAngleDeg: options.cornerAngleDeg,
+          precision,
+          offset: { x: dx, y: dy }
+        });
+        continue;
+      }
+      rings.push(dx || dy ? r.map(([x, y]) => [x + dx, y + dy]) : r);
+    }
+  }
+  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;
+}
+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
+  };
+}
+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 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];
+    }
+    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];
+    }
+    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 };
+}
+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;
+}
+
+// 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;
+  let ny0 = y0;
+  let ny1 = y1;
+  const setEdge = (horizontal, value) => {
+    const dir = horizontal ? axes.x : axes.y;
+    if (horizontal) {
+      if (dir < 0) nx0 = value;
+      else nx1 = value;
+    } else if (dir < 0) ny0 = value;
+    else ny1 = value;
+  };
+  let hitX = bestHit(true);
+  let hitY = bestHit(false);
+  const ratio = rect.height > 0 ? rect.width / rect.height : 0;
+  if (options.keepAspectRatio && ratio > 0 && (hitX || hitY)) {
+    if (axes.x !== 0 && axes.y !== 0) {
+      const dist2 = (h, horizontal) => h ? Math.abs(h.value - (horizontal ? axes.x < 0 ? x0 : x1 : axes.y < 0 ? y0 : y1)) : Infinity;
+      const useX = dist2(hitX, true) <= dist2(hitY, false);
+      if (useX && hitX) {
+        setEdge(true, hitX.value);
+        const height = (nx1 - nx0) / ratio;
+        if (axes.y < 0) ny0 = ny1 - height;
+        else ny1 = ny0 + height;
+        hitY = null;
+      } else if (hitY) {
+        setEdge(false, hitY.value);
+        const width = (ny1 - ny0) * ratio;
+        if (axes.x < 0) nx0 = nx1 - width;
+        else nx1 = nx0 + width;
+        hitX = null;
+      }
+      const min = (v) => v ?? 0;
+      if (nx1 - nx0 < min(options.minWidth) || ny1 - ny0 < min(options.minHeight) || !(nx1 > nx0 && ny1 > ny0)) {
+        return unchanged;
+      }
+    } else if (axes.x !== 0 && hitX) {
+      setEdge(true, hitX.value);
+      const height = (nx1 - nx0) / ratio;
+      const cy = (y0 + y1) / 2;
+      ny0 = cy - height / 2;
+      ny1 = cy + height / 2;
+    } else if (axes.y !== 0 && hitY) {
+      setEdge(false, hitY.value);
+      const width = (ny1 - ny0) * ratio;
+      const cx = (x0 + x1) / 2;
+      nx0 = cx - width / 2;
+      nx1 = cx + width / 2;
+    }
+  } else {
+    if (hitX) setEdge(true, hitX.value);
+    if (hitY) setEdge(false, hitY.value);
+  }
+  const out = { x: nx0, y: ny0, width: nx1 - nx0, height: ny1 - ny0 };
+  const guides = [];
+  const guideFor = (horizontal, hit) => {
+    if (!hit || hit.kind === "grid") return;
+    const axis = hit.kind === "edge" ? horizontal ? index.edgeX : index.edgeY : horizontal ? index.centreX : index.centreY;
+    const aligned = matching(axis, hit.value, eps);
+    const span = boundsOf([out, ...aligned]);
+    guides.push(
+      horizontal ? { orientation: "vertical", kind: hit.kind, x1: hit.value, y1: span.y, x2: hit.value, y2: span.y + span.height } : { orientation: "horizontal", kind: hit.kind, x1: span.x, y1: hit.value, x2: span.x + span.width, y2: hit.value }
+    );
+  };
+  guideFor(true, hitX);
+  guideFor(false, hitY);
+  const changed = out.x !== rect.x || out.y !== rect.y || out.width !== rect.width || out.height !== rect.height;
+  return {
+    rect: out,
+    guides,
+    snappedX: !!hitX && hitX.kind !== "grid",
+    snappedY: !!hitY && hitY.kind !== "grid",
+    changed
+  };
+}
+function snapNodeResize(nodes, id, rect, handle, options = {}) {
+  const lookup = createNodeLookup(nodes);
+  const node = lookup.get(id);
+  if (!node || isLocked(node)) {
+    return { rect: { ...rect }, guides: [], snappedX: false, snappedY: false, changed: false, updates: [] };
+  }
+  const index = options.index ?? createNodeGuideIndex(nodes, [id], options);
+  const result = snapResize(rect, handle, index, options);
+  if (!result.changed) return { ...result, updates: [] };
+  const parent = node.parentId ? lookup.get(node.parentId) : void 0;
+  const origin = parent ? getAbsolutePosition(parent, lookup) : { x: 0, y: 0 };
+  return {
+    ...result,
+    updates: [
+      {
+        id,
+        position: { x: result.rect.x - origin.x, y: result.rect.y - origin.y },
+        width: result.rect.width,
+        height: result.rect.height
+      }
+    ]
+  };
+}
+function getResizingNodeRect(node, lookup, options = {}) {
+  const { x, y } = node.parentId ? getAbsolutePosition(node, lookup) : node.position;
+  const size = getNodeSize(node, options);
+  return { x, y, width: node.width ?? size.width, height: node.height ?? size.height };
 }
 
 // src/canvas/arrangeController.ts
@@ -1710,6 +3393,11 @@ function createCanvasArrangeController(options) {
   let guides = [];
   let dragIndex = null;
   let dragKey = "";
+  let lastSnapped = /* @__PURE__ */ new Map();
+  let resizeId = null;
+  let resizeStart = null;
+  let resizeIndex = null;
+  let lastResized = null;
   const selectedIds = (ids) => ids ? [...ids] : options.getSelectedIds?.() ?? options.getNodes().filter((n) => n.selected).map((n) => n.id);
   const setGuides = (next) => {
     if (next.length === 0 && guides.length === 0) return;
@@ -1777,6 +3465,30 @@ function createCanvasArrangeController(options) {
       return anyUnlocked ? controller.lock(list) : controller.unlock(list);
     },
     isLocked: (id) => isLocked(options.getNodes().find((n) => n.id === id)),
+    /**
+     * Freeform shape operation (Unite / Intersect / Subtract / Exclude / Divide) on the
+     * shape nodes among `ids` (default: the selection). Replaces them with the result as
+     * one undoable step. Refuses without changing anything when a selected shape is
+     * locked, fewer than two shapes are selected, or the result is empty.
+     */
+    combineShapes(operation, ids, combineOptions = {}) {
+      const before = options.getNodes();
+      const result = combineShapeNodes(before, selectedIds(ids), operation, { ...rect(), ...combineOptions });
+      if (!result.ok) return result;
+      const name = `${operation[0].toUpperCase()}${operation.slice(1)} Shapes`;
+      const run = () => options.setNodes(applyShapeCombination(options.getNodes(), result));
+      const undo = () => options.setNodes(revertShapeCombination(options.getNodes(), result, before));
+      if (options.history) options.history.execute({ name, execute: run, undo });
+      else run();
+      return result;
+    },
+    unite: (ids, o) => controller.combineShapes("unite", ids, o),
+    intersect: (ids, o) => controller.combineShapes("intersect", ids, o),
+    subtract: (ids, o) => controller.combineShapes("subtract", ids, o),
+    exclude: (ids, o) => controller.combineShapes("exclude", ids, o),
+    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,
     /**
      * Runs a shortcut action. Scene actions are not handled here (see the scenes store);
      * returns `false` for them and for unknown actions.
@@ -1851,8 +3563,10 @@ function createCanvasArrangeController(options) {
         zoom: options.getZoom?.() ?? 1,
         index: dragIndex
       });
+      lastSnapped = /* @__PURE__ */ new Map();
       if (result.updates.length > 0) {
         options.setNodes(applyNodeUpdates(options.getNodes(), result.updates));
+        for (const u of result.updates) if (u.position) lastSnapped.set(u.id, u.position);
       }
       setGuides(result.guides);
       return result;
@@ -1863,10 +3577,17 @@ function createCanvasArrangeController(options) {
      * A batch without a dragging position change ends the drag and clears the guides.
      */
     snapPositionChanges(changes) {
-      const dragging = changes.filter((c) => c.type === "position" && c.position && c.dragging);
+      const dragging = changes.filter(
+        (c) => c.type === "position" && typeof c.id === "string" && !!c.position && !!c.dragging
+      );
       if (dragging.length === 0) {
-        if (changes.some((c) => c.type === "position" && c.dragging === false)) controller.endDrag();
-        return changes;
+        if (!changes.some((c) => c.type === "position" && c.dragging === false)) return changes;
+        const snapped = lastSnapped;
+        lastSnapped = /* @__PURE__ */ new Map();
+        controller.endDrag();
+        const keep = (c) => c.type === "position" && c.dragging === false && !!c.position && c.id !== void 0 && snapped.has(c.id);
+        if (!changes.some(keep)) return changes;
+        return changes.map((c) => keep(c) ? { ...c, position: snapped.get(c.id) } : c);
       }
       if (options.snapping === false) return changes;
       const ids = dragging.map((c) => c.id);
@@ -1882,22 +3603,302 @@ function createCanvasArrangeController(options) {
       });
       setGuides(result.guides);
       const { x: dx, y: dy } = result.offset;
+      lastSnapped = /* @__PURE__ */ new Map();
       if (dx === 0 && dy === 0) return changes;
       const parents = new Map(nodes.map((n) => [n.id, n.parentId]));
       const shift = new Set(ids.filter((id) => !proposed.has(parents.get(id) ?? "")));
-      return changes.map(
-        (c) => c.type === "position" && c.position && c.dragging && shift.has(c.id) ? { ...c, position: { x: c.position.x + dx, y: c.position.y + dy } } : c
+      return changes.map((c) => {
+        if (!(c.type === "position" && c.position && c.dragging && c.id !== void 0 && shift.has(c.id))) return c;
+        const position = { x: c.position.x + dx, y: c.position.y + dy };
+        lastSnapped.set(c.id, position);
+        return { ...c, position };
+      });
+    },
+    /**
+     * Starts resize snapping for node `id`: records its box (to tell which handle is
+     * dragged) and caches the snap targets. Optional: `resize` starts lazily.
+     */
+    beginResize(id) {
+      const nodes = options.getNodes();
+      const lookup = createNodeLookup(nodes);
+      const node = lookup.get(id);
+      resizeId = id;
+      resizeStart = node ? getResizingNodeRect(node, lookup, rect()) : null;
+      resizeIndex = createNodeGuideIndex(nodes, [id], rect());
+      lastResized = null;
+    },
+    /**
+     * Snaps node `id` as currently sized in `getNodes()` (call it after the flow wrote the
+     * new size, e.g. SvelteFlow's `NodeResizer` `onResize`, deferred by a microtask) and
+     * writes the snapped box back through `setNodes` (not recorded in history). `handle`
+     * defaults to the one inferred from the edges that moved since `beginResize`. A locked
+     * node is restored to its starting box.
+     */
+    resize(id, handle) {
+      if (resizeId !== id) controller.beginResize(id);
+      const nodes = options.getNodes();
+      const lookup = createNodeLookup(nodes);
+      const node = lookup.get(id);
+      if (!node || !resizeStart) return null;
+      const proposed = getResizingNodeRect(node, lookup, rect());
+      if (isLocked(node)) {
+        const start = resizeStart;
+        const parent = node.parentId ? lookup.get(node.parentId) : void 0;
+        const origin = parent ? getResizingNodeRect(parent, lookup, rect()) : { x: 0, y: 0 };
+        if (proposed.x !== start.x || proposed.y !== start.y || proposed.width !== start.width || proposed.height !== start.height) {
+          options.setNodes(
+            applyNodeUpdates(nodes, [
+              { id, position: { x: start.x - origin.x, y: start.y - origin.y }, width: start.width, height: start.height }
+            ])
+          );
+        }
+        return null;
+      }
+      if ((options.resizeSnapping ?? options.snapping) === false) return null;
+      const h = handle ?? inferResizeHandle(resizeStart, proposed);
+      if (!h) {
+        setGuides([]);
+        return null;
+      }
+      const result = snapNodeResize(nodes, id, proposed, h, {
+        ...rect(),
+        ...options.guides,
+        ...options.resize,
+        zoom: options.getZoom?.() ?? 1,
+        index: resizeIndex
+      });
+      lastResized = result.updates.length > 0 ? result : null;
+      if (result.updates.length > 0) options.setNodes(applyNodeUpdates(nodes, result.updates));
+      setGuides(result.guides);
+      return result;
+    },
+    /**
+     * Ends resize snapping: clears guides and re-applies the last snapped box if the flow
+     * wrote the raw pointer size afterwards.
+     */
+    endResize() {
+      const last = lastResized;
+      resizeId = null;
+      resizeStart = null;
+      resizeIndex = null;
+      lastResized = null;
+      setGuides([]);
+      const update = last?.updates[0];
+      if (!update) return;
+      const node = options.getNodes().find((n) => n.id === update.id);
+      if (!node) return;
+      const drift = node.position.x !== update.position.x || node.position.y !== update.position.y || node.width !== update.width || node.height !== update.height;
+      if (drift) options.setNodes(applyNodeUpdates(options.getNodes(), [update]));
+    },
+    /**
+     * React Flow style: snaps the `dimensions` (and matching `position`) changes a
+     * `NodeResizer` emits in an `onNodesChange` batch and updates `guides`. The resize-end
+     * change (`resizing: false`) carries the raw pointer size, so the last snapped size is
+     * kept. Resize changes of locked nodes are dropped. Returns the (possibly new) changes.
+     */
+    snapResizeChanges(changes) {
+      const dims = changes.find(
+        (c) => c.type === "dimensions" && typeof c.id === "string" && !!c.dimensions && typeof c.resizing === "boolean"
       );
+      if (!dims) return changes;
+      const id = dims.id;
+      const nodes = options.getNodes();
+      const lookup = createNodeLookup(nodes);
+      const node = lookup.get(id);
+      const isResizeChange = (c) => c.id === id && (c.type === "dimensions" || c.type === "position");
+      if (node && isLocked(node)) {
+        if (dims.resizing === false) controller.endResize();
+        return changes.filter((c) => !isResizeChange(c));
+      }
+      if (dims.resizing === false) {
+        const last = lastResized?.updates[0];
+        lastResized = null;
+        controller.endResize();
+        if (!last || last.id !== id) return changes;
+        return changes.map(
+          (c) => c === dims ? { ...c, dimensions: { width: last.width, height: last.height } } : c
+        );
+      }
+      if (!node || (options.resizeSnapping ?? options.snapping) === false) return changes;
+      if (resizeId !== id) controller.beginResize(id);
+      if (!resizeStart) return changes;
+      const posChange = changes.find((c) => c.id === id && c.type === "position" && !!c.position);
+      const parent = node.parentId ? lookup.get(node.parentId) : void 0;
+      const origin = parent ? getResizingNodeRect(parent, lookup, rect()) : { x: 0, y: 0 };
+      const position = posChange?.position ?? node.position;
+      const proposed = {
+        x: position.x + origin.x,
+        y: position.y + origin.y,
+        width: dims.dimensions.width,
+        height: dims.dimensions.height
+      };
+      const handle = inferResizeHandle(resizeStart, proposed);
+      if (!handle) {
+        setGuides([]);
+        return changes;
+      }
+      const result = snapNodeResize(nodes, id, proposed, handle, {
+        ...rect(),
+        ...options.guides,
+        ...options.resize,
+        zoom: options.getZoom?.() ?? 1,
+        index: resizeIndex
+      });
+      setGuides(result.guides);
+      const update = result.updates[0];
+      lastResized = update ? result : null;
+      if (!update) return changes;
+      const next = changes.map((c) => {
+        if (c === dims) return { ...c, dimensions: { width: update.width, height: update.height } };
+        if (c === posChange) return { ...c, position: update.position };
+        return c;
+      });
+      if (!posChange && (update.position.x !== node.position.x || update.position.y !== node.position.y)) {
+        next.push({ id, type: "position", position: update.position });
+      }
+      return next;
     },
-    /** Clears guides and the cached snap targets. */
+    /**
+     * Clears guides and the cached snap targets. Call it from the flow's drag-stop
+     * handler: flow libraries write the raw pointer position when a drag ends, so the
+     * last snapped positions from `drag` are written back here.
+     */
     endDrag() {
+      const snapped = lastSnapped;
       dragIndex = null;
       dragKey = "";
+      lastSnapped = /* @__PURE__ */ new Map();
       setGuides([]);
+      if (snapped.size === 0) return;
+      const nodes = options.getNodes();
+      const drift = nodes.some((n) => {
+        const p = snapped.get(n.id);
+        return !!p && (n.position.x !== p.x || n.position.y !== p.y);
+      });
+      if (drift) {
+        options.setNodes(applyNodeUpdates(nodes, [...snapped].map(([id, position]) => ({ id, position }))));
+      }
     }
   };
   return controller;
 }
+
+// src/canvas/measure.ts
+var EPS = 1e-6;
+function measureLabel(distance) {
+  const v = Math.round(Math.abs(distance) * 100) / 100;
+  return Object.is(v, -0) ? "0" : String(v);
+}
+var toBox = (r) => ({ x0: r.x, y0: r.y, x1: r.x + r.width, y1: r.y + r.height });
+var finiteBox = (b) => [b.x0, b.y0, b.x1, b.y1].every(Number.isFinite);
+function line(kind, x1, y1, x2, y2) {
+  return { orientation: x1 === x2 ? "vertical" : "horizontal", kind, x1, y1, x2, y2 };
+}
+function measured(out, x1, y1, x2, y2) {
+  const d = Math.hypot(x2 - x1, y2 - y1);
+  if (d > EPS && Number.isFinite(d)) out.push({ ...line("measure", x1, y1, x2, y2), label: measureLabel(d) });
+}
+function extension(out, x1, y1, x2, y2) {
+  if (Math.hypot(x2 - x1, y2 - y1) > EPS) out.push(line("extension", x1, y1, x2, y2));
+}
+function contains(outer, inner) {
+  return outer.x0 <= inner.x0 + EPS && outer.y0 <= inner.y0 + EPS && outer.x1 >= inner.x1 - EPS && outer.y1 >= inner.y1 - EPS;
+}
+function overlapMid(a0, a1, b0, b1) {
+  const lo = Math.max(a0, b0);
+  const hi = Math.min(a1, b1);
+  return lo <= hi ? (lo + hi) / 2 : null;
+}
+function inside(out, inner, outer) {
+  const cx = (inner.x0 + inner.x1) / 2;
+  const cy = (inner.y0 + inner.y1) / 2;
+  measured(out, outer.x0, cy, inner.x0, cy);
+  measured(out, inner.x1, cy, outer.x1, cy);
+  measured(out, cx, outer.y0, cx, inner.y0);
+  measured(out, cx, inner.y1, cx, outer.y1);
+}
+function measureBetween(a, b) {
+  const out = [];
+  const A = toBox(a);
+  const B = toBox(b);
+  if (!finiteBox(A) || !finiteBox(B)) return out;
+  if (contains(B, A)) {
+    inside(out, A, B);
+    return out;
+  }
+  if (contains(A, B)) {
+    inside(out, B, A);
+    return out;
+  }
+  const ox = overlapMid(A.x0, A.x1, B.x0, B.x1);
+  const oy = overlapMid(A.y0, A.y1, B.y0, B.y1);
+  const overlapping = A.x0 < B.x1 && B.x0 < A.x1 && A.y0 < B.y1 && B.y0 < A.y1;
+  if (overlapping && ox !== null && oy !== null) {
+    measured(out, A.x0, oy, B.x0, oy);
+    measured(out, A.x1, oy, B.x1, oy);
+    measured(out, ox, A.y0, ox, B.y0);
+    measured(out, ox, A.y1, ox, B.y1);
+    return out;
+  }
+  const cx = (A.x0 + A.x1) / 2;
+  const cy = (A.y0 + A.y1) / 2;
+  const gapX = B.x0 >= A.x1 ? [A.x1, B.x0] : B.x1 <= A.x0 ? [A.x0, B.x1] : null;
+  if (gapX) {
+    const [from, to] = gapX;
+    const y = oy ?? cy;
+    measured(out, from, y, to, y);
+    if (oy === null) extension(out, to, y, to, y < B.y0 ? B.y0 : B.y1);
+  }
+  const gapY = B.y0 >= A.y1 ? [A.y1, B.y0] : B.y1 <= A.y0 ? [A.y0, B.y1] : null;
+  if (gapY) {
+    const [from, to] = gapY;
+    const x = ox ?? cx;
+    measured(out, x, from, x, to);
+    if (ox === null) extension(out, x, to, x < B.x0 ? B.x0 : B.x1, to);
+  }
+  return out;
+}
+function measureToLine(a, orientation, at) {
+  const out = [];
+  const A = toBox(a);
+  if (!finiteBox(A) || !Number.isFinite(at)) return out;
+  const vertical = orientation === "vertical";
+  const cx = (A.x0 + A.x1) / 2;
+  const cy = (A.y0 + A.y1) / 2;
+  const [lo, hi] = vertical ? [A.x0, A.x1] : [A.y0, A.y1];
+  const seg = (from, to) => vertical ? measured(out, from, cy, to, cy) : measured(out, cx, from, cx, to);
+  if (at >= hi) seg(hi, at);
+  else if (at <= lo) seg(at, lo);
+  else {
+    seg(lo, at);
+    seg(at, hi);
+  }
+  return out;
+}
+function measureSelection(nodes, selectedIds, hoveredId, options = {}) {
+  const none = (selection2 = null) => ({ guides: [], target: null, selection: selection2 });
+  const lookup = createNodeLookup(nodes);
+  const selected = [...new Set(selectedIds)].map((id) => lookup.get(id)).filter((n) => !!n && n.hidden !== true);
+  if (selected.length === 0) return none();
+  const selection = boundsOf(selected.map((n) => getNodeRect(n, lookup, options)));
+  if (!selection) return none();
+  const selectedSet = new Set(selected.map((n) => n.id));
+  let targetId = hoveredId ?? null;
+  if (targetId === null || selectedSet.has(targetId)) {
+    const parentId = selected[0].parentId;
+    const sameParent = selected.every((n) => n.parentId === parentId);
+    targetId = parentId && sameParent && !selectedSet.has(parentId) ? parentId : null;
+  }
+  const target = targetId !== null ? lookup.get(targetId) : void 0;
+  if (!target || target.hidden === true) return none(selection);
+  const rect = getNodeRect(target, lookup, options);
+  return { guides: measureBetween(selection, rect), target: rect, selection };
+}
+function isMeasureModifierHeld(event) {
+  if (!event) return false;
+  if (event.type === "keyup" && event.key === "Alt") return false;
+  return event.altKey === true || event.type === "keydown" && event.key === "Alt";
+}
 export {
   CONNECTION_LINE_TYPES,
   CanvasScenesStore,
@@ -1908,17 +3909,25 @@ export {
   LOCKED_DATA_KEY,
   LOCKED_PREVIOUS_FLAGS_KEY,
   ManualClock,
+  RESIZE_HANDLES,
+  SHAPE_DATA_KEY,
+  SHAPE_KINDS,
+  SHAPE_NODE_TYPE,
+  SHAPE_OPERATIONS,
   StreamingLayoutManager,
   alignNodes,
   applyNodeUpdates,
+  applyShapeCombination,
   blendLayout,
   boundsOf,
   calculateDagreReflowDisplacement,
   calculateDirectionalDisplacement,
+  canCombineShapeNodes,
   canvasHeight,
   centerNodes,
   centre,
   collectDescendantIds,
+  combineShapeNodes,
   computeNodesBoundingBox,
   computeSnapGuides,
   connectedOnly,
@@ -1929,24 +3938,43 @@ export {
   createGuideIndex,
   createNodeGuideIndex,
   createNodeLookup,
+  cubicPointAt,
+  cubicsToPathData,
   defaultEasing,
   distributeNodes,
+  dividePolygons,
   ensureLayout,
   estimateCanvasHeight,
   estimateNodeSize,
   findConnectorSnap,
+  fitCubicRun,
+  fitCubics,
+  fitFreehandPath,
+  fitPathData,
   fitViewportToNodes,
   fitViewportToRect,
+  flattenSvgPath,
   flowSide,
+  formatNumber2 as formatNumber,
   getAbsolutePosition,
   getCenteredNodePosition,
   getLayoutedNodes,
   getNodeRect,
+  getNodeShape,
   getNodeSize,
+  getResizingNodeRect,
+  getShapeRenderData,
+  getShapeSvg,
   handlePoint,
+  inferResizeHandle,
+  intersectPolygons,
   invertNodeUpdates,
   isEventFromTextInput,
   isLocked,
+  isMeasureModifierHeld,
+  isShapeDescription,
+  isShapeNode,
+  isStraightCubic,
   isValidCanvasEdge,
   isValidCanvasNode,
   isValidCanvasScene,
@@ -1957,26 +3985,50 @@ export {
   lockNodes,
   matchArrangeShortcut,
   matchSize,
+  measureBetween,
+  measureLabel,
+  measureSelection,
+  measureToLine,
+  multiPolygonArea,
+  multiPolygonBounds,
   nearestHandlePositions,
   oppositePosition,
   overlaps,
   pageHidden,
   parseCanvasClipboardData,
   parseCanvasScenes,
+  parseSvgPath,
   placeBeside,
+  pointInMultiPolygon,
+  pointInRings,
+  polygonArea,
+  polygonBoolean,
+  polygonToSvgPath,
   positionToSide,
   readStyleSize,
   realClock,
   remapPastedNodes,
   reorderNodes,
   repositionNodesTo,
+  resizeHandleAxes,
+  revertShapeCombination,
+  ringSignedArea,
   runMultiNodeTransition,
   serializeCanvasNodes,
+  shapeNodeToPolygon,
+  shapeToPolygon,
   sideToPosition,
+  simplifyRing,
   snapNodeDrag,
+  snapNodeResize,
+  snapResize,
+  snapToGrid,
+  subtractPolygons,
   toggleLockNodes,
+  unionPolygons,
   unlockNodes,
   withStyleOpacity,
-  withStyleSize
+  withStyleSize,
+  xorPolygons
 };
 //# sourceMappingURL=index.js.map