@pixerate/editor 0.22.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,49 +1672,6 @@ 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"
-};
-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 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;
-    }
-  }
-  return null;
-}
-
 // src/canvas/polygonBoolean.ts
 function ringSignedArea(ring) {
   let sum = 0;
@@ -1885,9 +1852,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 } = project(seg.a, seg.b, p);
+          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 (dist <= eps && t2 * len > eps && (1 - t2) * len > eps) {
+          if (dist2 <= eps && t2 * len > eps && (1 - t2) * len > eps) {
             addSplit(split, t2, p);
             touched = true;
           }
@@ -2077,8 +2044,8 @@ function removeCollinear(ring, eps) {
       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 dot = (cur[0] - prev[0]) * dx + (cur[1] - prev[1]) * dy;
-      if (len > 0 && Math.abs(cross) / len <= eps && dot > 0 && dot < len * len) {
+      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;
       }
@@ -2174,6 +2141,347 @@ function dividePolygons(operands, options = {}) {
   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) {
@@ -2540,7 +2848,7 @@ function rotationTransform(shape, size) {
 }
 function getShapeSvg(shape, size) {
   const { width: w, height: h } = size;
-  const f = (n) => formatNumber(n, 3);
+  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 = "";
@@ -2589,7 +2897,7 @@ function getShapeRenderData(shape, size = {}) {
   const height = size.height && size.height > 0 ? size.height : vb ? vb[3] : 100;
   const svg = getShapeSvg(shape, { width, height });
   const data = {
-    viewBox: `0 0 ${formatNumber(width, 3)} ${formatNumber(height, 3)}`,
+    viewBox: `0 0 ${formatNumber2(width, 3)} ${formatNumber2(height, 3)}`,
     width,
     height,
     d: svg.d,
@@ -2636,7 +2944,7 @@ function shapeToPolygon(shape, size, options = {}) {
   if (rotate) rings = rings.map((ring) => ring.map(rotate));
   return { rings, fillRule };
 }
-function formatNumber(value, precision = 3) {
+function formatNumber2(value, precision = 3) {
   const factor = 10 ** precision;
   const rounded = Math.round(value * factor) / factor;
   return Object.is(rounded, -0) ? "0" : String(rounded);
@@ -2670,9 +2978,9 @@ function rdp(points, tolerance) {
     let maxDist = -1;
     let index = -1;
     for (let i = s + 1; i < e; i++) {
-      const dist = segmentDistance(points[i], points[s], points[e]);
-      if (dist > maxDist) {
-        maxDist = dist;
+      const dist2 = segmentDistance(points[i], points[s], points[e]);
+      if (dist2 > maxDist) {
+        maxDist = dist2;
         index = i;
       }
     }
@@ -2688,9 +2996,9 @@ function simplifyRing(ring, tolerance) {
   let far = 0;
   let farDist = -1;
   for (let i = 1; i < ring.length; i++) {
-    const dist = Math.hypot(ring[i][0] - ring[0][0], ring[i][1] - ring[0][1]);
-    if (dist > farDist) {
-      farDist = dist;
+    const dist2 = Math.hypot(ring[i][0] - ring[0][0], ring[i][1] - ring[0][1]);
+    if (dist2 > farDist) {
+      farDist = dist2;
       far = i;
     }
   }
@@ -2701,20 +3009,31 @@ function simplifyRing(ring, tolerance) {
 }
 function polygonToSvgPath(input, options = {}) {
   const precision = options.precision ?? 3;
-  const f = (n) => formatNumber(n, precision);
+  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 ringsToPath(rings, f);
+  return fit ? fitted : ringsToPath(rings, f);
 }
 
 // src/canvas/shapeNodes.ts
@@ -2792,7 +3111,10 @@ function combineShapeNodes(nodes, ids, operation, options = {}) {
     const d = polygonToSvgPath(polygon, {
       precision: options.precision,
       simplify: options.simplify,
-      offset: { x: -bounds.minX, y: -bounds.minY }
+      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);
@@ -2876,12 +3198,206 @@ function revertShapeCombination(nodes, change, previous) {
   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
 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;
@@ -3098,6 +3614,150 @@ function createCanvasArrangeController(options) {
         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. Call it from the flow's drag-stop
      * handler: flow libraries write the raw pointer position when a drag ends, so the
@@ -3122,6 +3782,123 @@ function createCanvasArrangeController(options) {
   };
   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,
@@ -3132,6 +3909,7 @@ export {
   LOCKED_DATA_KEY,
   LOCKED_PREVIOUS_FLAGS_KEY,
   ManualClock,
+  RESIZE_HANDLES,
   SHAPE_DATA_KEY,
   SHAPE_KINDS,
   SHAPE_NODE_TYPE,
@@ -3160,6 +3938,8 @@ export {
   createGuideIndex,
   createNodeGuideIndex,
   createNodeLookup,
+  cubicPointAt,
+  cubicsToPathData,
   defaultEasing,
   distributeNodes,
   dividePolygons,
@@ -3167,26 +3947,34 @@ export {
   estimateCanvasHeight,
   estimateNodeSize,
   findConnectorSnap,
+  fitCubicRun,
+  fitCubics,
+  fitFreehandPath,
+  fitPathData,
   fitViewportToNodes,
   fitViewportToRect,
   flattenSvgPath,
   flowSide,
-  formatNumber,
+  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,
@@ -3197,6 +3985,10 @@ export {
   lockNodes,
   matchArrangeShortcut,
   matchSize,
+  measureBetween,
+  measureLabel,
+  measureSelection,
+  measureToLine,
   multiPolygonArea,
   multiPolygonBounds,
   nearestHandlePositions,
@@ -3218,6 +4010,7 @@ export {
   remapPastedNodes,
   reorderNodes,
   repositionNodesTo,
+  resizeHandleAxes,
   revertShapeCombination,
   ringSignedArea,
   runMultiNodeTransition,
@@ -3227,6 +4020,9 @@ export {
   sideToPosition,
   simplifyRing,
   snapNodeDrag,
+  snapNodeResize,
+  snapResize,
+  snapToGrid,
   subtractPolygons,
   toggleLockNodes,
   unionPolygons,