dishui 0.0.65 → 0.0.66

package/dist/components/pro/Flow/FlowCanvas.js

@@ -1,1676 +1,1640 @@
-import { useFlowContext as Sn } from "./context/FlowContext.js";
-import { useFlowUI as zn } from "./context/FlowUIContext.js";
-import { usePixiApp as Cn } from "./hooks/usePixiApp.js";
-import { useViewport as En } from "./hooks/useViewport.js";
-import { GridRenderer as Nn } from "./canvas/GridRenderer.js";
-import { SelectionOverlay as Tn } from "./canvas/SelectionOverlay.js";
-import { shapeDrawers as ln } from "./nodes/shapes.js";
-import { findClosestHandleWorld as Ft, getHandlePositions as Mt, handleWorldPos as Bt } from "./nodes/NodeHandles.js";
-import { distToSegment as Ge, generateId as kn, isPointInNode as Vt, rectsOverlap as Dn } from "./nodes/nodeUtils.js";
-import { NodeRenderer as Hn } from "./nodes/NodeRenderer.js";
-import { buildEdgePath as mn, linearizeSegments as vn, resolveEdgeEndpoints as St } from "./edges/edgePaths.js";
-import { EdgeRenderer as Pn } from "./edges/EdgeRenderer.js";
-import { LineRenderer as An } from "./lines/LineRenderer.js";
-import { FreehandTool as Ln } from "./lines/FreehandTool.js";
-import { GeometricLineTool as Gn } from "./lines/GeometricLineTool.js";
-import { computeAlignmentSnap as ve } from "./hooks/useAlignmentGuides.js";
-import { AlignmentGuidesRenderer as Wn } from "./canvas/AlignmentGuides.js";
-import { getDocumentSlides as Yn, nextAnimIndex as Xn } from "./nodes/animAnchors.js";
-import { useDeleteSelection as _n } from "./hooks/useDeleteSelection.js";
-import { useCallback as ae, useEffect as Rt, useRef as v, useState as un } from "react";
-import { jsx as qt, jsxs as Ie } from "react/jsx-runtime";
-import { Graphics as le } from "pixi.js";
-var On = {
-  nw: "nwse-resize",
-  ne: "nesw-resize",
-  se: "nwse-resize",
-  sw: "nesw-resize"
-}, ue = typeof window < "u" && typeof window.matchMedia == "function" && window.matchMedia("(pointer: coarse)").matches, fn = ue ? 2 : 1;
-function Q(A, R, D) {
-  return Math.min(R * fn / A, D * fn);
+import { useFlowContext as e } from "./context/FlowContext.js";
+import { useFlowUI as t } from "./context/FlowUIContext.js";
+import { usePixiApp as n } from "./hooks/usePixiApp.js";
+import { useViewport as r } from "./hooks/useViewport.js";
+import { GridRenderer as i } from "./canvas/GridRenderer.js";
+import { SelectionOverlay as a } from "./canvas/SelectionOverlay.js";
+import { shapeDrawers as o } from "./nodes/shapes.js";
+import { findClosestHandleWorld as s, getHandlePositions as c, handleWorldPos as l } from "./nodes/NodeHandles.js";
+import { distToSegment as u, generateId as d, isPointInNode as f, rectsOverlap as p } from "./nodes/nodeUtils.js";
+import { NodeRenderer as m } from "./nodes/NodeRenderer.js";
+import { buildEdgePath as h, linearizeSegments as g, resolveEdgeEndpoints as _ } from "./edges/edgePaths.js";
+import { EdgeRenderer as v } from "./edges/EdgeRenderer.js";
+import { LineRenderer as ee } from "./lines/LineRenderer.js";
+import { FreehandTool as te } from "./lines/FreehandTool.js";
+import { GeometricLineTool as ne } from "./lines/GeometricLineTool.js";
+import { computeAlignmentSnap as re } from "./hooks/useAlignmentGuides.js";
+import { AlignmentGuidesRenderer as ie } from "./canvas/AlignmentGuides.js";
+import { getDocumentSlides as ae, nextAnimIndex as oe } from "./nodes/animAnchors.js";
+import { useDeleteSelection as se } from "./hooks/useDeleteSelection.js";
+import { useCallback as y, useEffect as b, useRef as x, useState as S } from "react";
+import { jsx as C, jsxs as w } from "react/jsx-runtime";
+import { Graphics as ce } from "pixi.js";
+//#region src/components/pro/Flow/FlowCanvas.tsx
+var le = {
+	nw: "nwse-resize",
+	ne: "nesw-resize",
+	se: "nwse-resize",
+	sw: "nesw-resize"
+}, ue = typeof window < "u" && typeof window.matchMedia == "function" && window.matchMedia("(pointer: coarse)").matches, T = ue ? 2 : 1;
+function E(e, t, n) {
+	return Math.min(t * T / e, n * T);
 }
-var In = 26;
-function hn(A, R) {
-  return {
-    x: A.position.x + A.width / 2,
-    y: A.position.y - In / R
-  };
+var de = 26;
+function fe(e, t) {
+	return {
+		x: e.position.x + e.width / 2,
+		y: e.position.y - de / t
+	};
 }
-function Zt(A, R, D) {
-  return !D || !(R > 0) ? A : Math.round(A / R) * R;
+function pe(e, t, n) {
+	return !n || !(t > 0) ? e : Math.round(e / t) * t;
 }
-function yn(A, R, D) {
-  const { x: U, y: P } = R.position, L = R.width, Y = R.height, T = [
-    [
-      "nw",
-      U,
-      P
-    ],
-    [
-      "ne",
-      U + L,
-      P
-    ],
-    [
-      "se",
-      U + L,
-      P + Y
-    ],
-    [
-      "sw",
-      U,
-      P + Y
-    ]
-  ];
-  let M = null, B = D;
-  for (const [j, ut, ot] of T) {
-    const $ = Math.hypot(A.x - ut, A.y - ot);
-    $ < B && (B = $, M = j);
-  }
-  return M;
+function me(e, t, n) {
+	let { x: r, y: i } = t.position, a = t.width, o = t.height, s = [
+		[
+			"nw",
+			r,
+			i
+		],
+		[
+			"ne",
+			r + a,
+			i
+		],
+		[
+			"se",
+			r + a,
+			i + o
+		],
+		[
+			"sw",
+			r,
+			i + o
+		]
+	], c = null, l = n;
+	for (let [t, n, r] of s) {
+		let i = Math.hypot(e.x - n, e.y - r);
+		i < l && (l = i, c = t);
+	}
+	return c;
 }
-function pn(A, R, D, U, P) {
-  let L = null, Y = P;
-  for (const T of D) {
-    const M = St(T, U);
-    if (!M) continue;
-    const B = Math.hypot(A - M.sx, R - M.sy);
-    B < Y && (Y = B, L = {
-      edgeId: T.id,
-      end: "source",
-      worldX: M.sx,
-      worldY: M.sy
-    });
-    const j = Math.hypot(A - M.tx, R - M.ty);
-    j < Y && (Y = j, L = {
-      edgeId: T.id,
-      end: "target",
-      worldX: M.tx,
-      worldY: M.ty
-    });
-  }
-  return L;
+function he(e, t, n, r, i) {
+	let a = null, o = i;
+	for (let i of n) {
+		let n = _(i, r);
+		if (!n) continue;
+		let s = Math.hypot(e - n.sx, t - n.sy);
+		s < o && (o = s, a = {
+			edgeId: i.id,
+			end: "source",
+			worldX: n.sx,
+			worldY: n.sy
+		});
+		let c = Math.hypot(e - n.tx, t - n.ty);
+		c < o && (o = c, a = {
+			edgeId: i.id,
+			end: "target",
+			worldX: n.tx,
+			worldY: n.ty
+		});
+	}
+	return a;
 }
-function xn(A, R, D, U) {
-  let P = null, L = U;
-  for (const Y of D) {
-    const T = Y.data.waypoints;
-    if (T)
-      for (let M = 0; M < T.length; M++) {
-        const B = Math.hypot(A - T[M].x, R - T[M].y);
-        B < L && (L = B, P = {
-          edgeId: Y.id,
-          waypointIndex: M,
-          wx: T[M].x,
-          wy: T[M].y
-        });
-      }
-  }
-  return P;
+function ge(e, t, n, r) {
+	let i = null, a = r;
+	for (let r of n) {
+		let n = r.data.waypoints;
+		if (n) for (let o = 0; o < n.length; o++) {
+			let s = Math.hypot(e - n[o].x, t - n[o].y);
+			s < a && (a = s, i = {
+				edgeId: r.id,
+				waypointIndex: o,
+				wx: n[o].x,
+				wy: n[o].y
+			});
+		}
+	}
+	return i;
 }
-function gn(A, R, D, U, P) {
-  let L = null, Y = P;
-  for (const T of D) {
-    if (T.type !== "simplebezier") continue;
-    const M = St(T, U);
-    if (!M) continue;
-    const B = T.data.waypoints ?? [], j = [
-      {
-        x: M.sx,
-        y: M.sy
-      },
-      ...B,
-      {
-        x: M.tx,
-        y: M.ty
-      }
-    ], ut = T.data.bezierControls, ot = j.length - 2;
-    for (let $ = 0; $ <= ot; $++) {
-      const et = j[$], st = j[$ + 1], zt = ut?.[$], fe = Math.hypot(st.x - et.x, st.y - et.y), wt = Math.max(30, fe * 0.3), he = zt?.c1x ?? ($ === 0 ? et.x + M.snx * wt : et.x + (st.x - et.x) * 0.4), ye = zt?.c1y ?? ($ === 0 ? et.y + M.sny * wt : et.y), Kt = zt?.c2x ?? ($ === ot ? st.x + M.tnx * wt : st.x - (st.x - et.x) * 0.4), Ut = zt?.c2y ?? ($ === ot ? st.y + M.tny * wt : st.y), Ct = Math.hypot(A - he, R - ye);
-      Ct < Y && (Y = Ct, L = {
-        edgeId: T.id,
-        segmentIndex: $,
-        controlEnd: "c1",
-        wx: he,
-        wy: ye
-      });
-      const Et = Math.hypot(A - Kt, R - Ut);
-      Et < Y && (Y = Et, L = {
-        edgeId: T.id,
-        segmentIndex: $,
-        controlEnd: "c2",
-        wx: Kt,
-        wy: Ut
-      });
-    }
-  }
-  return L;
+function _e(e, t, n, r, i) {
+	let a = null, o = i;
+	for (let i of n) {
+		if (i.type !== "simplebezier") continue;
+		let n = _(i, r);
+		if (!n) continue;
+		let s = i.data.waypoints ?? [], c = [
+			{
+				x: n.sx,
+				y: n.sy
+			},
+			...s,
+			{
+				x: n.tx,
+				y: n.ty
+			}
+		], l = i.data.bezierControls, u = c.length - 2;
+		for (let r = 0; r <= u; r++) {
+			let s = c[r], d = c[r + 1], f = l?.[r], p = Math.hypot(d.x - s.x, d.y - s.y), m = Math.max(30, p * .3), h = f?.c1x ?? (r === 0 ? s.x + n.snx * m : s.x + (d.x - s.x) * .4), g = f?.c1y ?? (r === 0 ? s.y + n.sny * m : s.y), _ = f?.c2x ?? (r === u ? d.x + n.tnx * m : d.x - (d.x - s.x) * .4), v = f?.c2y ?? (r === u ? d.y + n.tny * m : d.y), ee = Math.hypot(e - h, t - g);
+			ee < o && (o = ee, a = {
+				edgeId: i.id,
+				segmentIndex: r,
+				controlEnd: "c1",
+				wx: h,
+				wy: g
+			});
+			let te = Math.hypot(e - _, t - v);
+			te < o && (o = te, a = {
+				edgeId: i.id,
+				segmentIndex: r,
+				controlEnd: "c2",
+				wx: _,
+				wy: v
+			});
+		}
+	}
+	return a;
 }
-function Fn(A, R, D, U) {
-  const P = St(D, U);
-  if (!P) return 0;
-  const L = D.data.waypoints ?? [], Y = [
-    {
-      x: P.sx,
-      y: P.sy
-    },
-    ...L,
-    {
-      x: P.tx,
-      y: P.ty
-    }
-  ];
-  let T = 1 / 0, M = 0;
-  for (let B = 0; B < Y.length - 1; B++) {
-    const j = Ge(A, R, Y[B].x, Y[B].y, Y[B + 1].x, Y[B + 1].y);
-    j < T && (T = j, M = B);
-  }
-  return M;
+function ve(e, t, n, r) {
+	let i = _(n, r);
+	if (!i) return 0;
+	let a = n.data.waypoints ?? [], o = [
+		{
+			x: i.sx,
+			y: i.sy
+		},
+		...a,
+		{
+			x: i.tx,
+			y: i.ty
+		}
+	], s = Infinity, c = 0;
+	for (let n = 0; n < o.length - 1; n++) {
+		let r = u(e, t, o[n].x, o[n].y, o[n + 1].x, o[n + 1].y);
+		r < s && (s = r, c = n);
+	}
+	return c;
 }
-function Bn(A, R, D, U, P = 24) {
-  let { x: L, y: Y, w: T, h: M } = { ...A };
-  const B = R === "nw" || R === "sw", j = R === "ne" || R === "se", ut = R === "nw" || R === "ne", ot = R === "sw" || R === "se";
-  return B && (L += D, T -= D), j && (T += D), ut && (Y += U, M -= U), ot && (M += U), T < P && (B && (L = A.x + A.w - P), T = P), M < P && (ut && (Y = A.y + A.h - P), M = P), {
-    x: L,
-    y: Y,
-    w: T,
-    h: M
-  };
+function ye(e, t, n, r, i = 24) {
+	let { x: a, y: o, w: s, h: c } = { ...e }, l = t === "nw" || t === "sw", u = t === "ne" || t === "se", d = t === "nw" || t === "ne", f = t === "sw" || t === "se";
+	return l && (a += n, s -= n), u && (s += n), d && (o += r, c -= r), f && (c += r), s < i && (l && (a = e.x + e.w - i), s = i), c < i && (d && (o = e.y + e.h - i), c = i), {
+		x: a,
+		y: o,
+		w: s,
+		h: c
+	};
 }
-function Le(A, R, D, U, P) {
-  const L = St(D, U);
-  if (!L) return !1;
-  const Y = mn(D.type, L, D.data.waypoints, D.data.bezierControls), T = vn(Y);
-  for (let M = 0; M < T.length - 1; M++) if (Ge(A, R, T[M].x, T[M].y, T[M + 1].x, T[M + 1].y) < P) return !0;
-  return !1;
+function be(e, t, n, r, i) {
+	let a = _(n, r);
+	if (!a) return !1;
+	let o = h(n.type, a, n.data.waypoints, n.data.bezierControls), s = g(o);
+	for (let n = 0; n < s.length - 1; n++) if (u(e, t, s[n].x, s[n].y, s[n + 1].x, s[n + 1].y) < i) return !0;
+	return !1;
 }
-function wn(A, R, D, U) {
-  const P = D.points;
-  for (let L = 0; L < P.length - 1; L++) if (Ge(A, R, P[L].x, P[L].y, P[L + 1].x, P[L + 1].y) < U) return !0;
-  return !1;
+function xe(e, t, n, r) {
+	let i = n.points;
+	for (let n = 0; n < i.length - 1; n++) if (u(e, t, i[n].x, i[n].y, i[n + 1].x, i[n + 1].y) < r) return !0;
+	return !1;
 }
-function yr({ onPixiReady: A }) {
-  const R = v(null), D = v(null), U = v(13751771), P = ae((f) => {
-    U.current = f.gridDot, D.current && (D.current.dotColor = f.gridDot);
-  }, []), { pixiRef: L, readyRef: Y } = Cn(R, P), { setViewportInternal: T, viewportReqRef: M, viewport: B, autoFocus: j, showGrid: ut, showAnchors: ot, gridSize: $, toolMode: et, edgeType: st, focusOnRect: zt, setFocusOnRect: fe, pendingPlacement: wt, setPendingPlacement: he, setContextMenu: ye, beginNodeDrag: Kt, endNodeDrag: Ut, presentation: Ct, editingNodeId: Et, setEditingNodeId: $t, readOnly: We, placementSnap: Ye } = zn(), { currentCanvas: be, selection: Xe, setSelection: xt, setDoc: tt, currentCanvasId: Me, pushCanvas: bn, doc: _e } = Sn(), Oe = _n(), Fe = v(Oe);
-  Fe.current = Oe;
-  const Be = v(null), jt = v(We);
-  jt.current = We;
-  const Jt = v(Ye);
-  Jt.current = Ye;
-  const Nt = v($);
-  Nt.current = $;
-  const Tt = v(null), pe = v(null), xe = v(null), ge = v(null), Re = v(null), Se = v(null), kt = v(null), Qt = v(null), te = v(null), we = v(null), Lt = v([]), Gt = v(null), Wt = v(null), ft = v(null), ee = v(null), Ve = v({
-    time: 0,
-    wx: 0,
-    wy: 0
-  }), Yt = v({
-    time: 0,
-    wx: 0,
-    wy: 0
-  }), qe = v(0), ne = v(null), Ze = v({
-    x: 0,
-    y: 0
-  }), Ke = ot || Ct ? be : {
-    ...be,
-    nodes: be.nodes.filter((f) => f.type !== "animAnchor")
-  }, X = v(Ke);
-  X.current = Ke;
-  const Z = v(Me);
-  Z.current = Me;
-  const re = v(Xe);
-  re.current = Xe;
-  const Ue = v(_e);
-  Ue.current = _e;
-  const oe = v(et);
-  oe.current = et;
-  const se = v(j);
-  se.current = j;
-  const ce = v(zt);
-  ce.current = zt;
-  const $e = v(st);
-  $e.current = st;
-  const je = v(ot);
-  je.current = ot;
-  const Dt = v(Ct);
-  Dt.current = Ct;
-  const ie = v(wt);
-  ie.current = wt;
-  const ze = v(Kt);
-  ze.current = Kt;
-  const Ht = v(Ut);
-  Ht.current = Ut;
-  const ct = v(null), nt = v(null), rt = v(null), ht = v(null), it = v(null), mt = v(null), gt = v(null), vt = v(null), Ce = v(B), Ee = v(0), Mn = ae((f) => {
-    Ce.current = f, Ee.current || (Ee.current = requestAnimationFrame(() => {
-      Ee.current = 0, T(Ce.current);
-    }));
-  }, [T]), { vmRef: V, screenToWorld: Je } = En(L, Mn), dt = v(Je);
-  dt.current = Je;
-  const [yt, Ne] = un(null), [Te, ke] = un(null), De = v(yt);
-  De.current = yt;
-  const me = v(() => {
-  });
-  me.current = (f, G, O) => {
-    $t(f === "node" ? G : null), Ne({
-      kind: f,
-      id: G,
-      value: O
-    });
-  };
-  const Qe = ae((f) => {
-    const G = De.current;
-    G && (tt((O) => {
-      const W = Z.current, K = O.canvases[W];
-      if (!K) return O;
-      let q = K;
-      if (G.kind === "node") q = {
-        ...K,
-        nodes: K.nodes.map((F) => F.id === G.id ? {
-          ...F,
-          data: {
-            ...F.data,
-            label: f
-          }
-        } : F)
-      };
-      else if (G.kind === "edge") q = {
-        ...K,
-        edges: K.edges.map((F) => F.id === G.id ? {
-          ...F,
-          data: {
-            ...F.data,
-            labelText: f
-          }
-        } : F)
-      };
-      else return O;
-      return {
-        ...O,
-        canvases: {
-          ...O.canvases,
-          [W]: q
-        }
-      };
-    }), Ne(null), $t(null), ke(null));
-  }, [tt, $t]), Rn = ae(() => {
-    Ne(null), $t(null), ke(null);
-  }, [$t]);
-  Rt(() => {
-    if (!Et || De.current?.id === Et) return;
-    const f = X.current.nodes.find((G) => G.id === Et);
-    f && me.current("node", f.id, f.data.label);
-  }, [Et]), Rt(() => {
-    if (!yt) return;
-    const f = V.current;
-    if (!f) return;
-    const G = X.current;
-    let O = null;
-    if (yt.kind === "node") {
-      const W = G.nodes.find((K) => K.id === yt.id);
-      W && (O = {
-        x: W.position.x + W.width / 2,
-        y: W.position.y + W.height / 2
-      });
-    } else if (yt.kind === "edge") {
-      const W = G.edges.find((q) => q.id === yt.id), K = /* @__PURE__ */ new Map();
-      for (const q of G.nodes) K.set(q.id, q);
-      if (W) {
-        const q = St(W, K);
-        if (q) {
-          const F = mn(W.type, q, W.data.waypoints, W.data.bezierControls), at = vn(F), lt = at[Math.floor(at.length / 2)] ?? {
-            x: (q.sx + q.tx) / 2,
-            y: (q.sy + q.ty) / 2
-          };
-          O = {
-            x: lt.x,
-            y: lt.y
-          };
-        }
-      }
-    }
-    if (O) {
-      const W = f.worldToScreen(O.x, O.y);
-      ke({
-        x: W.x,
-        y: W.y
-      });
-    }
-  }, [yt, V]);
-  const tn = v(0);
-  Rt(() => {
-    M.current !== tn.current && (tn.current = M.current, Ce.current = B, V.current?.setState(B));
-  }, [
-    B,
-    V,
-    M
-  ]), Rt(() => {
-    fe((f, G, O, W, K) => {
-      const q = V.current, F = R.current;
-      if (!q || !F) return;
-      const at = F.clientWidth || 800, lt = F.clientHeight || 600, It = Math.max(0, K?.padding ?? 60), Xt = Math.max(1, at - It * 2), bt = Math.max(1, lt - It * 2), Pt = K?.preserveZoom ? q.state.zoom : Math.min(Xt / Math.max(O, 1), bt / Math.max(W, 1), K?.maxZoom ?? 2), At = f + O / 2, pt = G + W / 2, de = at / 2 - At * Pt, Pe = lt / 2 - pt * Pt;
-      q.animateTo({
-        x: de,
-        y: Pe,
-        zoom: Pt
-      }, K?.duration ?? 350);
-    });
-  }, [fe, V]);
-  const en = ae((f) => {
-    tt((G) => {
-      const O = G.canvases[Z.current];
-      return O ? {
-        ...G,
-        canvases: {
-          ...G.canvases,
-          [Z.current]: {
-            ...O,
-            lines: [...O.lines, f]
-          }
-        }
-      } : G;
-    });
-  }, [tt, Me]), He = v(en);
-  return He.current = en, Rt(() => {
-    const f = L.current;
-    if (!f || f.destroyed) return;
-    let G = !1, O = null, W = null, K = null;
-    const q = () => {
-      if (G) return;
-      if (!Y.current) {
-        setTimeout(q, 30);
-        return;
-      }
-      D.current = new Nn(f.app.stage, $, ut), D.current.dotColor = U.current, Tt.current = new Tn(f.app.stage), pe.current = new Hn(f.world), xe.current = new Pn(f.world), ge.current = new An(f.world);
-      const F = new le();
-      F.label = "connect-line", F.visible = !1, f.world.addChild(F), mt.current = F;
-      const at = new le();
-      at.label = "transform-handles", f.app.stage.addChild(at), Qt.current = at;
-      const lt = new le();
-      lt.label = "handle-hover", f.world.addChild(lt), te.current = lt;
-      const It = new le();
-      It.label = "edge-edit-handles", f.world.addChild(It), ee.current = It;
-      const Xt = new le();
-      Xt.label = "ghost-placement", Xt.alpha = 0.5, f.world.addChild(Xt), ne.current = Xt, we.current = new Wn(f.world), Re.current = new Ln(f.app.stage, f.world, {
-        onLineComplete: (g) => He.current(g),
-        screenToWorld: (g, c) => dt.current(g, c)
-      }), Se.current = new Gn(f.app.stage, f.world, {
-        onLineComplete: (g) => He.current(g),
-        screenToWorld: (g, c) => dt.current(g, c)
-      }), A?.(f);
-      const bt = f.app.stage;
-      bt.on("pointerdown", (g) => {
-        if (R.current?.focus({ preventScroll: !0 }), V.current?.multiTouchActive || V.current?.isPanning || V.current?.isSpaceHeld || g.button !== 0) return;
-        const c = oe.current;
-        if (c === "pan") {
-          V.current?.startPan(g.global.x, g.global.y);
-          return;
-        }
-        if (c === "freehand" || c === "line" || c === "polyline" || c === "arrow") return;
-        const i = dt.current(g.global.x, g.global.y), p = X.current.nodes, H = X.current.edges, N = X.current.lines, z = re.current, C = g.metaKey || g.ctrlKey || g.shiftKey, k = V.current?.state.zoom ?? 1;
-        if (ie.current) return;
-        const o = Date.now(), x = Ve.current, l = o - x.time < 350 && Math.hypot(i.x - x.wx, i.y - x.wy) < 8 / k;
-        if (Ve.current = {
-          time: o,
-          wx: i.x,
-          wy: i.y
-        }, z.nodeIds.size === 1 && !C && c === "select" && !jt.current) {
-          const t = p.find((r) => r.id === [...z.nodeIds][0]);
-          if (t) {
-            const r = hn(t, k);
-            if (Math.hypot(i.x - r.x, i.y - r.y) < Q(k, 12, 24)) {
-              ht.current = {
-                active: !0,
-                nodeId: t.id,
-                cx: t.position.x + t.width / 2,
-                cy: t.position.y + t.height / 2,
-                startPointerAngle: Math.atan2(i.y - (t.position.y + t.height / 2), i.x - (t.position.x + t.width / 2)),
-                startRotation: t.data.rotation ?? 0
-              }, ze.current();
-              return;
-            }
-          }
-        }
-        if (z.nodeIds.size === 1 && !C && c === "select") {
-          const t = p.find((r) => r.id === [...z.nodeIds][0]);
-          if (t) {
-            const r = yn(i, t, Q(k, 10, 16));
-            if (r) {
-              const a = /* @__PURE__ */ new Map(), d = /* @__PURE__ */ new Map(), n = t.type === "geometryGroup", s = n || t.type === "flowGroup" || t.data.isGroup, m = t.position.x, h = t.position.y, I = t.width, S = t.height;
-              for (const u of p)
-                u.id !== t.id && (u.parentId === t.id ? a.set(u.id, {
-                  x: u.position.x,
-                  y: u.position.y,
-                  w: u.width,
-                  h: u.height
-                }) : n && u.position.x >= m && u.position.y >= h && u.position.x + u.width <= m + I && u.position.y + u.height <= h + S && a.set(u.id, {
-                  x: u.position.x,
-                  y: u.position.y,
-                  w: u.width,
-                  h: u.height
-                }));
-              if (s)
-                for (const u of X.current.lines) u.parentId === t.id ? d.set(u.id, u.points.map((b) => ({ ...b }))) : n && u.points.length > 0 && u.points.every((b) => b.x >= m && b.x <= m + I && b.y >= h && b.y <= h + S) && d.set(u.id, u.points.map((b) => ({ ...b })));
-              gt.current = {
-                active: !0,
-                nodeId: t.id,
-                handle: r,
-                startWorld: i,
-                startBounds: {
-                  x: t.position.x,
-                  y: t.position.y,
-                  w: t.width,
-                  h: t.height
-                },
-                childStarts: a,
-                childLineStarts: d.size > 0 ? d : void 0
-              };
-              return;
-            }
-          }
-        }
-        let e = null;
-        for (let t = p.length - 1; t >= 0; t--) if (Vt(i.x, i.y, p[t])) {
-          e = p[t];
-          break;
-        }
-        if (e?.parentId) {
-          const t = p.find((r) => r.id === e.parentId);
-          t && (e = t);
-        }
-        ue && (kt.current = e ? e.parentId ? p.find((t) => t.id === e.parentId)?.id ?? e.id : e.id : null, Gt.current = null, Wt.current = null);
-        let w = !1;
-        if (e && c === "select" && (w = Math.min(i.x - e.position.x, e.position.x + e.width - i.x, i.y - e.position.y, e.position.y + e.height - i.y) > Math.min(14, Math.min(e.width, e.height) * 0.3)), (c === "select" || c === "connect") && (e || ue) && !w) {
-          const t = e ? [e] : p, r = Q(k, 14, 20);
-          let a = null, d = null, n = 1 / 0;
-          for (const s of t) {
-            const m = Mt(s.width, s.height), h = Ft(m, s, i.x, i.y, r);
-            if (!h) continue;
-            const I = Bt(h, s), S = Math.hypot(i.x - I.x, i.y - I.y);
-            S < n && (n = S, a = s, d = h);
-          }
-          if (a && d) {
-            rt.current = {
-              active: !0,
-              sourceNodeId: a.id,
-              sourceHandleId: d.id
-            };
-            return;
-          }
-        }
-        if ((c === "select" || c === "connect") && !C && z.edgeIds.size > 0) {
-          const t = /* @__PURE__ */ new Map();
-          for (const d of p) t.set(d.id, d);
-          const r = H.filter((d) => z.edgeIds.has(d.id)), a = pn(i.x, i.y, r, t, Q(k, 14, 20));
-          if (a) {
-            const d = H.find((n) => n.id === a.edgeId);
-            if (d) {
-              const n = a.end === "source" ? "target" : "source";
-              it.current = {
-                active: !0,
-                edgeId: d.id,
-                movingEnd: a.end,
-                fixedNodeId: n === "source" ? d.source : d.target,
-                fixedHandleId: n === "source" ? d.sourceHandle : d.targetHandle
-              };
-              return;
-            }
-          }
-        }
-        if (c === "select" && z.edgeIds.size > 0 && !e) {
-          const t = /* @__PURE__ */ new Map();
-          for (const s of p) t.set(s.id, s);
-          const r = H.filter((s) => z.edgeIds.has(s.id)), a = Q(k, 10, 14), d = gn(i.x, i.y, r, t, a);
-          if (d) {
-            ft.current = {
-              active: !0,
-              edgeId: d.edgeId,
-              type: d.controlEnd === "c1" ? "bezierC1" : "bezierC2",
-              index: d.segmentIndex
-            };
-            return;
-          }
-          const n = xn(i.x, i.y, r, a);
-          if (n) {
-            if (l) {
-              tt((s) => {
-                const m = s.canvases[Z.current];
-                return m ? {
-                  ...s,
-                  canvases: {
-                    ...s.canvases,
-                    [Z.current]: {
-                      ...m,
-                      edges: m.edges.map((h) => {
-                        if (h.id !== n.edgeId) return h;
-                        const I = [...h.data.waypoints ?? []];
-                        I.splice(n.waypointIndex, 1);
-                        const S = {
-                          ...h.data,
-                          waypoints: I.length > 0 ? I : void 0
-                        };
-                        if (h.type === "simplebezier" && h.data.bezierControls) {
-                          const u = [...h.data.bezierControls];
-                          u.splice(n.waypointIndex, 2, null), S.bezierControls = u.some((b) => b !== null) ? u : void 0;
-                        }
-                        return {
-                          ...h,
-                          data: S
-                        };
-                      })
-                    }
-                  }
-                } : s;
-              });
-              return;
-            }
-            ft.current = {
-              active: !0,
-              edgeId: n.edgeId,
-              type: "waypoint",
-              index: n.waypointIndex
-            };
-            return;
-          }
-          if (l) {
-            for (const s of r) if (Le(i.x, i.y, s, t, Q(k, 8, 12))) {
-              const m = Fn(i.x, i.y, s, t), h = {
-                x: i.x,
-                y: i.y
-              };
-              tt((I) => {
-                const S = I.canvases[Z.current];
-                return S ? {
-                  ...I,
-                  canvases: {
-                    ...I.canvases,
-                    [Z.current]: {
-                      ...S,
-                      edges: S.edges.map((u) => {
-                        if (u.id !== s.id) return u;
-                        const b = [...u.data.waypoints ?? []];
-                        b.splice(m, 0, h);
-                        const _ = {
-                          ...u.data,
-                          waypoints: b
-                        };
-                        if (u.type === "simplebezier" && u.data.bezierControls) {
-                          const J = [...u.data.bezierControls];
-                          for (; J.length < (u.data.waypoints ?? []).length + 1; ) J.push(null);
-                          J.splice(m, 1, null, null), _.bezierControls = J;
-                        }
-                        return {
-                          ...u,
-                          data: _
-                        };
-                      })
-                    }
-                  }
-                } : I;
-              }), ft.current = {
-                active: !0,
-                edgeId: s.id,
-                type: "waypoint",
-                index: m
-              };
-              return;
-            }
-          }
-        }
-        if (e && (c === "select" || c === "connect")) {
-          !C && !z.nodeIds.has(e.id) ? xt({
-            nodeIds: /* @__PURE__ */ new Set([e.id]),
-            edgeIds: /* @__PURE__ */ new Set(),
-            lineIds: /* @__PURE__ */ new Set()
-          }) : C && xt((n) => {
-            const s = new Set(n.nodeIds);
-            return s.has(e.id) ? s.delete(e.id) : s.add(e.id), {
-              nodeIds: s,
-              edgeIds: /* @__PURE__ */ new Set(),
-              lineIds: /* @__PURE__ */ new Set()
-            };
-          }), se.current && ce.current(e.position.x, e.position.y, e.width, e.height, {
-            padding: 80,
-            preserveZoom: !0,
-            duration: 280
-          });
-          const t = z.nodeIds.has(e.id) ? new Set(z.nodeIds) : /* @__PURE__ */ new Set([e.id]);
-          C && !z.nodeIds.has(e.id) && t.add(e.id);
-          const r = /* @__PURE__ */ new Set();
-          for (const n of [...t]) {
-            const s = p.find((b) => b.id === n);
-            if (!s || s.type !== "flowGroup" && s.type !== "geometryGroup" && !s.data.isGroup) continue;
-            const m = s.type === "geometryGroup", h = s.position.x, I = s.position.y, S = s.width, u = s.height;
-            for (const b of p)
-              if (!(t.has(b.id) || b.id === n)) {
-                if (b.parentId === n) {
-                  t.add(b.id);
-                  continue;
-                }
-                m && b.position.x >= h && b.position.y >= I && b.position.x + b.width <= h + S && b.position.y + b.height <= I + u && t.add(b.id);
-              }
-            for (const b of X.current.lines) b.parentId === n && r.add(b.id);
-            if (m) for (const b of X.current.lines)
-              r.has(b.id) || b.points.length > 0 && b.points.every((_) => _.x >= h && _.x <= h + S && _.y >= I && _.y <= I + u) && r.add(b.id);
-          }
-          const a = /* @__PURE__ */ new Map();
-          for (const n of p) t.has(n.id) && a.set(n.id, { ...n.position });
-          const d = /* @__PURE__ */ new Map();
-          if (r.size > 0)
-            for (const n of X.current.lines) r.has(n.id) && d.set(n.id, n.points.map((s) => ({ ...s })));
-          ct.current = {
-            active: !0,
-            nodeIds: t,
-            lineIds: r.size > 0 ? r : void 0,
-            startWorld: i,
-            nodeStarts: a,
-            linePointStarts: d.size > 0 ? d : void 0
-          }, ze.current();
-          return;
-        }
-        const y = /* @__PURE__ */ new Map();
-        for (const t of p) y.set(t.id, t);
-        const E = Q(k, 8, 12);
-        for (const t of H) if (Le(i.x, i.y, t, y, E)) {
-          if (xt(C ? (r) => {
-            const a = new Set(r.edgeIds);
-            return a.has(t.id) ? a.delete(t.id) : a.add(t.id), {
-              ...r,
-              edgeIds: a
-            };
-          } : {
-            nodeIds: /* @__PURE__ */ new Set(),
-            edgeIds: /* @__PURE__ */ new Set([t.id]),
-            lineIds: /* @__PURE__ */ new Set()
-          }), se.current) {
-            const r = y.get(t.source), a = y.get(t.target);
-            if (r && a) {
-              const d = Math.min(r.position.x, a.position.x), n = Math.min(r.position.y, a.position.y), s = Math.max(r.position.x + r.width, a.position.x + a.width), m = Math.max(r.position.y + r.height, a.position.y + a.height);
-              ce.current(d, n, s - d, m - n, {
-                padding: 80,
-                preserveZoom: !0,
-                duration: 280
-              });
-            }
-          }
-          return;
-        }
-        for (const t of N) if (wn(i.x, i.y, t, E)) {
-          const r = z.lineIds.has(t.id);
-          if (C ? xt((n) => {
-            const s = new Set(n.lineIds);
-            return s.has(t.id) ? s.delete(t.id) : s.add(t.id), {
-              ...n,
-              lineIds: s
-            };
-          }) : r || xt({
-            nodeIds: /* @__PURE__ */ new Set(),
-            edgeIds: /* @__PURE__ */ new Set(),
-            lineIds: /* @__PURE__ */ new Set([t.id])
-          }), se.current && t.points.length > 0) {
-            const n = t.points.map((u) => u.x), s = t.points.map((u) => u.y), m = Math.min(...n), h = Math.min(...s), I = Math.max(...n), S = Math.max(...s);
-            ce.current(m, h, Math.max(1, I - m), Math.max(1, S - h), {
-              padding: 80,
-              preserveZoom: !0,
-              duration: 280
-            });
-          }
-          const a = r ? new Set(z.lineIds) : /* @__PURE__ */ new Set([t.id]), d = /* @__PURE__ */ new Map();
-          for (const n of N) a.has(n.id) && d.set(n.id, n.points.map((s) => ({ ...s })));
-          vt.current = {
-            active: !0,
-            lineIds: a,
-            startWorld: i,
-            pointStarts: d
-          };
-          return;
-        }
-        C || xt({
-          nodeIds: /* @__PURE__ */ new Set(),
-          edgeIds: /* @__PURE__ */ new Set(),
-          lineIds: /* @__PURE__ */ new Set()
-        }), c === "select" && (nt.current = {
-          active: !0,
-          startScreen: {
-            x: g.global.x,
-            y: g.global.y
-          }
-        });
-      }), bt.on("globalpointermove", (g) => {
-        const c = dt.current(g.global.x, g.global.y);
-        if (Ze.current = c, V.current?.multiTouchActive) return;
-        const i = oe.current;
-        if (i === "freehand" || i === "line" || i === "polyline" || i === "arrow") return;
-        const p = X.current.nodes, H = X.current.edges, N = V.current?.state.zoom ?? 1, z = !ct.current?.active && !rt.current?.active && !gt.current?.active && !it.current?.active && !ft.current?.active && !vt.current?.active && !ht.current?.active;
-        let C = null;
-        for (let o = p.length - 1; o >= 0; o--) if (Vt(c.x, c.y, p[o])) {
-          const x = p[o];
-          C = x.parentId ? p.find((l) => l.id === x.parentId)?.id ?? x.id : x.id;
-          break;
-        }
-        if (kt.current = C, z && (i === "select" || i === "connect")) {
-          const o = /* @__PURE__ */ new Map();
-          for (const y of p) o.set(y.id, y);
-          const x = re.current, l = x.edgeIds.size > 0 ? H.filter((y) => x.edgeIds.has(y.id)) : [], e = l.length > 0 ? pn(c.x, c.y, l, o, Q(N, 12, 18)) : null;
-          Wt.current = e;
-          let w = null;
-          if (C) {
-            const y = p.find((E) => E.id === C);
-            if (y) {
-              const E = Mt(y.width, y.height), t = Ft(E, y, c.x, c.y, Q(N, 14, 20));
-              if (t) {
-                const r = Bt(t, y);
-                w = {
-                  nodeId: y.id,
-                  handleId: t.id,
-                  wx: r.x,
-                  wy: r.y
-                };
-              }
-            }
-          }
-          Gt.current = w;
-        }
-        const k = R.current;
-        if (k && z) {
-          const o = re.current;
-          let x = "";
-          if (Wt.current) x = "crosshair";
-          else if (Gt.current) x = "crosshair";
-          else if (o.edgeIds.size > 0 && i === "select") {
-            const l = H.filter((y) => o.edgeIds.has(y.id)), e = /* @__PURE__ */ new Map();
-            for (const y of p) e.set(y.id, y);
-            const w = Q(N, 10, 14);
-            (xn(c.x, c.y, l, w) || gn(c.x, c.y, l, e, w)) && (x = "grab");
-          }
-          if (!x && o.nodeIds.size === 1 && i === "select") {
-            const l = p.find((e) => e.id === [...o.nodeIds][0]);
-            if (l) {
-              const e = yn(c, l, Q(N, 10, 16));
-              if (e) x = On[e];
-              else if (!jt.current) {
-                const w = hn(l, N);
-                Math.hypot(c.x - w.x, c.y - w.y) < Q(N, 12, 24) && (x = "grab");
-              }
-            }
-          }
-          if (!x && i === "select") {
-            const l = X.current.lines, e = Q(N, 8, 12);
-            for (const w of l) if (wn(c.x, c.y, w, e)) {
-              x = "move";
-              break;
-            }
-          }
-          k.style.cursor = x;
-        }
-        if (gt.current?.active) {
-          const o = gt.current, x = c.x - o.startWorld.x, l = c.y - o.startWorld.y, e = Bn(o.startBounds, o.handle, x, l), w = X.current.nodes, y = {
-            id: o.nodeId,
-            type: "shapeRect",
-            position: {
-              x: e.x,
-              y: e.y
-            },
-            width: e.w,
-            height: e.h,
-            data: {}
-          }, E = ve([y], w);
-          if (e.x += E.dx, e.y += E.dy, (o.handle === "ne" || o.handle === "se") && (e.w += E.dx), (o.handle === "se" || o.handle === "sw") && (e.h += E.dy), Lt.current = E.guides, Jt.current && Nt.current > 0 && E.guides.length === 0) {
-            const s = Nt.current;
-            (o.handle === "nw" || o.handle === "sw") && (e.x = Math.round(e.x / s) * s), (o.handle === "nw" || o.handle === "ne") && (e.y = Math.round(e.y / s) * s), (o.handle === "ne" || o.handle === "se") && (e.w = Math.round((e.x + e.w) / s) * s - e.x), (o.handle === "se" || o.handle === "sw") && (e.h = Math.round((e.y + e.h) / s) * s - e.y);
-          }
-          const t = o.startBounds, r = Math.max(e.w, 24), a = Math.max(e.h, 24), d = t.w > 0 ? r / t.w : 1, n = t.h > 0 ? a / t.h : 1;
-          tt((s) => {
-            const m = s.canvases[Z.current];
-            return m ? {
-              ...s,
-              canvases: {
-                ...s.canvases,
-                [Z.current]: {
-                  ...m,
-                  nodes: m.nodes.map((h) => {
-                    if (h.id === o.nodeId) return {
-                      ...h,
-                      position: {
-                        x: e.x,
-                        y: e.y
-                      },
-                      width: r,
-                      height: a
-                    };
-                    const I = o.childStarts.get(h.id);
-                    return I ? {
-                      ...h,
-                      position: {
-                        x: e.x + (I.x - t.x) * d,
-                        y: e.y + (I.y - t.y) * n
-                      },
-                      width: Math.max(I.w * d, 24),
-                      height: Math.max(I.h * n, 24)
-                    } : h;
-                  }),
-                  lines: o.childLineStarts ? m.lines.map((h) => {
-                    const I = o.childLineStarts.get(h.id);
-                    return I ? {
-                      ...h,
-                      points: I.map((S) => ({
-                        x: e.x + (S.x - t.x) * d,
-                        y: e.y + (S.y - t.y) * n
-                      }))
-                    } : h;
-                  }) : m.lines
-                }
-              }
-            } : s;
-          });
-          return;
-        }
-        if (ht.current?.active) {
-          const o = ht.current, x = (Math.atan2(c.y - o.cy, c.x - o.cx) - o.startPointerAngle) * 180 / Math.PI;
-          let l = ((o.startRotation + x) % 360 + 360) % 360;
-          if (g.shiftKey) l = Math.round(l / 15) * 15 % 360;
-          else {
-            const e = Math.round(l / 45) * 45;
-            Math.abs(l - e) < 4 && (l = (e % 360 + 360) % 360);
-          }
-          tt((e) => {
-            const w = e.canvases[Z.current];
-            return w ? {
-              ...e,
-              canvases: {
-                ...e.canvases,
-                [Z.current]: {
-                  ...w,
-                  nodes: w.nodes.map((y) => y.id === o.nodeId ? {
-                    ...y,
-                    data: {
-                      ...y.data,
-                      rotation: l
-                    }
-                  } : y)
-                }
-              }
-            } : e;
-          }), R.current && (R.current.style.cursor = "grabbing");
-          return;
-        }
-        if (ft.current?.active) {
-          const o = ft.current, x = X.current.nodes, l = /* @__PURE__ */ new Map();
-          for (const e of x) l.set(e.id, e);
-          tt((e) => {
-            const w = e.canvases[Z.current];
-            return w ? {
-              ...e,
-              canvases: {
-                ...e.canvases,
-                [Z.current]: {
-                  ...w,
-                  edges: w.edges.map((y) => {
-                    if (y.id !== o.edgeId) return y;
-                    if (o.type === "waypoint") {
-                      const Ot = [...y.data.waypoints ?? []];
-                      return o.index < Ot.length && (Ot[o.index] = {
-                        x: c.x,
-                        y: c.y
-                      }), {
-                        ...y,
-                        data: {
-                          ...y.data,
-                          waypoints: Ot
-                        }
-                      };
-                    }
-                    const E = St(y, l);
-                    if (!E) return y;
-                    const t = y.data.waypoints ?? [], r = [
-                      {
-                        x: E.sx,
-                        y: E.sy
-                      },
-                      ...t,
-                      {
-                        x: E.tx,
-                        y: E.ty
-                      }
-                    ], a = r.length - 1, d = [...y.data.bezierControls ?? []];
-                    for (; d.length < a; ) d.push(null);
-                    const n = o.index;
-                    if (n >= a) return y;
-                    const s = r[n], m = r[n + 1], h = d[n], I = Math.hypot(m.x - s.x, m.y - s.y), S = Math.max(30, I * 0.3), u = a - 1, b = n === 0 ? s.x + E.snx * S : s.x + (m.x - s.x) * 0.4, _ = n === 0 ? s.y + E.sny * S : s.y, J = n === u ? m.x + E.tnx * S : m.x - (m.x - s.x) * 0.4, _t = n === u ? m.y + E.tny * S : m.y;
-                    return o.type === "bezierC1" ? d[n] = {
-                      c1x: c.x,
-                      c1y: c.y,
-                      c2x: h?.c2x ?? J,
-                      c2y: h?.c2y ?? _t
-                    } : d[n] = {
-                      c1x: h?.c1x ?? b,
-                      c1y: h?.c1y ?? _,
-                      c2x: c.x,
-                      c2y: c.y
-                    }, {
-                      ...y,
-                      data: {
-                        ...y.data,
-                        bezierControls: d
-                      }
-                    };
-                  })
-                }
-              }
-            } : e;
-          });
-          return;
-        }
-        if (vt.current?.active) {
-          const o = vt.current, x = c.x - o.startWorld.x, l = c.y - o.startWorld.y;
-          tt((e) => {
-            const w = e.canvases[Z.current];
-            return w ? {
-              ...e,
-              canvases: {
-                ...e.canvases,
-                [Z.current]: {
-                  ...w,
-                  lines: w.lines.map((y) => {
-                    const E = o.pointStarts.get(y.id);
-                    return E ? {
-                      ...y,
-                      points: E.map((t) => ({
-                        x: t.x + x,
-                        y: t.y + l
-                      }))
-                    } : y;
-                  })
-                }
-              }
-            } : e;
-          });
-          return;
-        }
-        if (ct.current?.active) {
-          const o = ct.current, x = c.x - o.startWorld.x, l = c.y - o.startWorld.y;
-          let e = x, w = l;
-          if (Jt.current && Nt.current > 0 && o.nodeIds.size > 0) {
-            const r = Nt.current, a = o.nodeStarts.values().next().value;
-            a && (e = Zt(a.x + x, r, !0) - a.x, w = Zt(a.y + l, r, !0) - a.y);
-          }
-          const y = X.current.nodes, E = y.filter((r) => o.nodeIds.has(r.id)).map((r) => {
-            const a = o.nodeStarts.get(r.id);
-            return {
-              ...r,
-              position: {
-                x: a.x + e,
-                y: a.y + w
-              }
-            };
-          }), t = ve(E, y);
-          e += t.dx, w += t.dy, Lt.current = t.guides, tt((r) => {
-            const a = r.canvases[Z.current];
-            return a ? {
-              ...r,
-              canvases: {
-                ...r.canvases,
-                [Z.current]: {
-                  ...a,
-                  nodes: a.nodes.map((d) => {
-                    const n = o.nodeStarts.get(d.id);
-                    return n ? {
-                      ...d,
-                      position: {
-                        x: n.x + e,
-                        y: n.y + w
-                      }
-                    } : d;
-                  }),
-                  lines: o.linePointStarts ? a.lines.map((d) => {
-                    const n = o.linePointStarts.get(d.id);
-                    return n ? {
-                      ...d,
-                      points: n.map((s) => ({
-                        x: s.x + e,
-                        y: s.y + w
-                      }))
-                    } : d;
-                  }) : a.lines
-                }
-              }
-            } : r;
-          });
-          return;
-        }
-        if (nt.current?.active && Tt.current) {
-          const o = Math.min(nt.current.startScreen.x, g.global.x), x = Math.min(nt.current.startScreen.y, g.global.y), l = Math.abs(g.global.x - nt.current.startScreen.x), e = Math.abs(g.global.y - nt.current.startScreen.y);
-          Tt.current.showMarquee(o, x, l, e);
-        }
-        if (rt.current?.active && mt.current) {
-          const o = X.current.nodes.find((x) => x.id === rt.current.sourceNodeId);
-          if (o) {
-            const x = Mt(o.width, o.height).find((l) => l.id === rt.current.sourceHandleId);
-            if (x) {
-              const l = Bt(x, o), e = l.x, w = l.y;
-              let y = c.x, E = c.y;
-              const t = kt.current;
-              if (t && t !== rt.current.sourceNodeId) {
-                const a = X.current.nodes.find((d) => d.id === t);
-                if (a) {
-                  const d = Mt(a.width, a.height), n = Ft(d, a, c.x, c.y, 1 / 0);
-                  if (n) {
-                    const s = Bt(n, a);
-                    y = s.x, E = s.y;
-                  }
-                }
-              }
-              const r = mt.current;
-              r.clear(), r.moveTo(e, w).lineTo(y, E).stroke({
-                color: 3900150,
-                width: 2,
-                alpha: 0.6
-              }), r.visible = !0;
-            }
-          }
-        }
-        if (it.current?.active && mt.current && !mt.current.destroyed) {
-          const o = it.current, x = X.current.nodes.find((l) => l.id === o.fixedNodeId);
-          if (x) {
-            const l = Mt(x.width, x.height).find((d) => d.id === o.fixedHandleId), e = l ? Bt(l, x) : {
-              x: x.position.x + x.width / 2,
-              y: x.position.y + x.height / 2
-            }, w = e.x, y = e.y;
-            let E = c.x, t = c.y;
-            const r = kt.current;
-            if (r && r !== o.fixedNodeId) {
-              const d = X.current.nodes.find((n) => n.id === r);
-              if (d) {
-                const n = Mt(d.width, d.height), s = Ft(n, d, c.x, c.y, 1 / 0);
-                if (s) {
-                  const m = Bt(s, d);
-                  E = m.x, t = m.y;
-                }
-              }
-            }
-            const a = mt.current;
-            a.clear(), a.moveTo(w, y).lineTo(E, t).stroke({
-              color: 16347926,
-              width: 2,
-              alpha: 0.7
-            }), a.visible = !0;
-          }
-        }
-      });
-      const Pt = () => {
-        Lt.current = [];
-        try {
-          we.current?.clear();
-        } catch {
-        }
-        try {
-          const g = mt.current;
-          g && !g.destroyed && (g.clear(), g.visible = !1);
-        } catch {
-        }
-        R.current && (R.current.style.cursor = "");
-      };
-      bt.on("pointerup", (g) => {
-        if (Pt(), ht.current?.active) {
-          ht.current = null, Ht.current();
-          return;
-        }
-        if (ft.current?.active) {
-          ft.current = null;
-          return;
-        }
-        if (gt.current?.active) {
-          gt.current = null;
-          return;
-        }
-        if (vt.current?.active) {
-          vt.current = null;
-          return;
-        }
-        if (ct.current?.active && (ct.current = null, Ht.current()), nt.current?.active) {
-          const c = dt.current(nt.current.startScreen.x, nt.current.startScreen.y), i = dt.current(g.global.x, g.global.y), p = Math.min(c.x, i.x), H = Math.min(c.y, i.y), N = Math.abs(i.x - c.x), z = Math.abs(i.y - c.y);
-          if (N > 4 && z > 4) {
-            const C = X.current.nodes.filter((o) => Dn(p, H, N, z, o.position.x, o.position.y, o.width, o.height)), k = X.current.lines.filter((o) => o.points.length === 0 ? !1 : o.points.every((x) => x.x >= p && x.x <= p + N && x.y >= H && x.y <= H + z));
-            xt({
-              nodeIds: new Set(C.map((o) => o.id)),
-              edgeIds: /* @__PURE__ */ new Set(),
-              lineIds: new Set(k.map((o) => o.id))
-            });
-          }
-          nt.current = null, Tt.current?.hideMarquee();
-        }
-        if (it.current?.active) {
-          const c = it.current.edgeId, i = it.current.movingEnd, p = it.current.fixedNodeId;
-          it.current = null;
-          const H = dt.current(g.global.x, g.global.y), N = X.current.nodes, z = ue ? Q(V.current?.state.zoom ?? 1, 12, 24) : 0;
-          let C = null;
-          for (let k = N.length - 1; k >= 0; k--) if (Vt(H.x, H.y, N[k], z) && N[k].id !== p) {
-            C = N[k];
-            break;
-          }
-          if (C) {
-            const k = C.id, o = Mt(C.width, C.height), x = Ft(o, C, H.x, H.y, 1 / 0)?.id;
-            tt((l) => {
-              const e = l.canvases[Z.current];
-              return e ? {
-                ...l,
-                canvases: {
-                  ...l.canvases,
-                  [Z.current]: {
-                    ...e,
-                    edges: e.edges.map((w) => w.id !== c ? w : i === "source" ? {
-                      ...w,
-                      source: k,
-                      sourceHandle: x
-                    } : {
-                      ...w,
-                      target: k,
-                      targetHandle: x
-                    })
-                  }
-                }
-              } : l;
-            });
-          }
-          return;
-        }
-        if (rt.current?.active) {
-          const c = rt.current.sourceNodeId, i = rt.current.sourceHandleId;
-          rt.current = null;
-          const p = dt.current(g.global.x, g.global.y), H = X.current.nodes, N = ue ? Q(V.current?.state.zoom ?? 1, 12, 24) : 0;
-          let z = null;
-          for (let C = H.length - 1; C >= 0; C--) if (Vt(p.x, p.y, H[C], N) && H[C].id !== c) {
-            z = H[C];
-            break;
-          }
-          if (z) {
-            const C = z.id, k = Mt(z.width, z.height), o = Ft(k, z, p.x, p.y, 1 / 0)?.id, x = `edge_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 6)}`, l = $e.current;
-            tt((e) => {
-              const w = e.canvases[Z.current];
-              return !w || w.edges.some((y) => y.source === c && y.target === C && y.sourceHandle === i && y.targetHandle === o) ? e : {
-                ...e,
-                canvases: {
-                  ...e.canvases,
-                  [Z.current]: {
-                    ...w,
-                    edges: [...w.edges, {
-                      id: x,
-                      source: c,
-                      target: C,
-                      sourceHandle: i,
-                      targetHandle: o,
-                      type: l,
-                      data: {
-                        strokeColor: "theme:base-content",
-                        strokeWidth: 2,
-                        lineStyle: "solid",
-                        markerEnd: "arrowclosed"
-                      }
-                    }]
-                  }
-                }
-              };
-            });
-          }
-        }
-      }), bt.on("pointerupoutside", () => {
-        Pt(), ct.current?.active && Ht.current(), ht.current?.active && Ht.current(), ct.current = null, ht.current = null, gt.current = null, nt.current = null, it.current = null, rt.current = null, ft.current = null, vt.current = null, kt.current = null, Gt.current = null, Wt.current = null, Tt.current?.hideMarquee();
-      });
-      const At = R.current;
-      let pt = null;
-      const de = (g) => {
-        const c = At.getBoundingClientRect(), i = g[0].clientX, p = g[0].clientY, H = g[1].clientX, N = g[1].clientY;
-        return {
-          dist: Math.hypot(H - i, N - p),
-          midX: (i + H) / 2 - c.left,
-          midY: (p + N) / 2 - c.top
-        };
-      }, Pe = () => {
-        Pt(), ct.current?.active && Ht.current(), ht.current?.active && Ht.current(), ct.current = null, ht.current = null, gt.current = null, nt.current = null, it.current = null, rt.current = null, ft.current = null, vt.current = null, kt.current = null, Gt.current = null, Wt.current = null, Tt.current?.hideMarquee(), V.current?.cancelPan();
-      }, nn = (g) => {
-        if (g.touches.length < 2) return;
-        const c = V.current;
-        c && (c.multiTouchActive = !0, Pe(), pt = de(g.touches), g.preventDefault());
-      }, rn = (g) => {
-        if (!pt || g.touches.length < 2) return;
-        g.preventDefault();
-        const c = V.current;
-        if (!c) return;
-        const i = de(g.touches), p = i.dist / Math.max(1, pt.dist);
-        Number.isFinite(p) && p > 0 && c.zoomAt(i.midX, i.midY, p), c.setState({
-          x: c.state.x + (i.midX - pt.midX),
-          y: c.state.y + (i.midY - pt.midY)
-        }), pt = i;
-      }, Ae = (g) => {
-        if (g.touches.length >= 2) {
-          pt = de(g.touches);
-          return;
-        }
-        if (pt = null, g.touches.length === 0) {
-          const c = V.current;
-          c && (c.multiTouchActive = !1), qe.current = performance.now() + 350;
-        }
-      };
-      At?.addEventListener("touchstart", nn, { passive: !1 }), At?.addEventListener("touchmove", rn, { passive: !1 }), At?.addEventListener("touchend", Ae), At?.addEventListener("touchcancel", Ae), O = nn, W = rn, K = Ae, bt.on("rightclick", (g) => {
-        if (g.preventDefault?.(), V.current?.didRightPan) return;
-        const c = dt.current(g.global.x, g.global.y), i = X.current.nodes;
-        let p = null;
-        for (let C = i.length - 1; C >= 0; C--) if (Vt(c.x, c.y, i[C])) {
-          p = i[C].id;
-          break;
-        }
-        const H = g.nativeEvent, N = H?.clientX ?? g.global.x, z = H?.clientY ?? g.global.y;
-        ye({
-          x: N,
-          y: z,
-          nodeId: p
-        });
-      }), bt.on("pointertap", (g) => {
-        if (V.current?.multiTouchActive || performance.now() < qe.current || g.button !== 0) return;
-        const c = Date.now(), i = dt.current(g.global.x, g.global.y), p = ie.current;
-        if (p) {
-          const C = kn("node"), k = Nt.current, o = Jt.current, x = Zt(i.x - p.width / 2, k, o), l = Zt(i.y - p.height / 2, k, o), e = {
-            id: "__ghost__",
-            type: p.type,
-            position: {
-              x,
-              y: l
-            },
-            width: p.width,
-            height: p.height,
-            data: {}
-          }, w = ve([e], X.current.nodes), y = x + w.dx, E = l + w.dy;
-          tt((t) => {
-            const r = t.canvases[Z.current];
-            if (!r) return t;
-            const a = {};
-            p.type === "animAnchor" && (a.animIndex = Xn(t));
-            const d = Math.max(0, ...r.nodes.map((n) => n.zIndex ?? 0), ...r.lines.map((n) => n.zIndex ?? 0));
-            return {
-              ...t,
-              canvases: {
-                ...t.canvases,
-                [Z.current]: {
-                  ...r,
-                  nodes: [...r.nodes, {
-                    id: C,
-                    type: p.type,
-                    position: {
-                      x: y,
-                      y: E
-                    },
-                    width: p.width,
-                    height: p.height,
-                    zIndex: d + 1,
-                    data: {
-                      ...p.data,
-                      ...a
-                    }
-                  }]
-                }
-              }
-            };
-          }), xt({
-            nodeIds: /* @__PURE__ */ new Set([C]),
-            edgeIds: /* @__PURE__ */ new Set(),
-            lineIds: /* @__PURE__ */ new Set()
-          }), se.current && window.setTimeout(() => {
-            ce.current(y, E, p.width, p.height, {
-              padding: 80,
-              preserveZoom: !0,
-              duration: 280
-            });
-          }, 0), Yt.current = {
-            time: 0,
-            wx: 0,
-            wy: 0
-          };
-          return;
-        }
-        const H = Yt.current, N = i.x - H.wx, z = i.y - H.wy;
-        if (c - H.time < 400 && Math.abs(N) < 10 && Math.abs(z) < 10) {
-          const C = X.current.nodes;
-          for (let l = C.length - 1; l >= 0; l--) if (Vt(i.x, i.y, C[l])) {
-            const e = C[l], w = e.data.childCanvasId;
-            if (w) {
-              bn(w), Yt.current = {
-                time: 0,
-                wx: 0,
-                wy: 0
-              };
-              return;
-            }
-            me.current("node", e.id, e.data.label ?? ""), Yt.current = {
-              time: 0,
-              wx: 0,
-              wy: 0
-            };
-            return;
-          }
-          const k = X.current.edges, o = /* @__PURE__ */ new Map();
-          for (const l of C) o.set(l.id, l);
-          const x = V.current?.state.zoom ?? 1;
-          for (let l = k.length - 1; l >= 0; l--) if (Le(i.x, i.y, k[l], o, Q(x, 8, 12))) {
-            me.current("edge", k[l].id, k[l].data.labelText ?? ""), Yt.current = {
-              time: 0,
-              wx: 0,
-              wy: 0
-            };
-            return;
-          }
-        }
-        Yt.current = {
-          time: c,
-          wx: i.x,
-          wy: i.y
-        };
-      });
-      let on = !1;
-      f.app.ticker.add((g) => {
-        if (f.destroyed) return;
-        const c = g.deltaMS, i = f.app.screen, p = V.current?.state ?? {
-          x: 0,
-          y: 0,
-          zoom: 1
-        };
-        D.current?.update(p, i.width, i.height);
-        const H = V.current?.isPanning ?? !1;
-        H !== on && (on = H, R.current && (R.current.style.cursor = H ? "grabbing" : ""));
-        const N = X.current, z = re.current, C = Yn(Ue.current), k = /* @__PURE__ */ new Map();
-        C.forEach((t, r) => k.set(t.node.id, r + 1)), pe.current?.advanceAnimation(c);
-        const o = Dt.current ? C[Dt.current.current] : void 0;
-        pe.current?.sync(N.nodes, z.nodeIds, kt.current, k, {
-          showAnchors: je.current,
-          presentation: Dt.current !== null,
-          presentationAnchorId: o?.node.id,
-          presentationAnchorVisible: Dt.current?.showAnchor ?? !1
-        });
-        const x = /* @__PURE__ */ new Map();
-        for (const t of N.nodes) x.set(t.id, t);
-        xe.current?.advanceAnimation(c), xe.current?.sync(N.edges, x, z.edgeIds, null, { presentation: Dt.current !== null }), ge.current?.advanceAnimation(c), ge.current?.sync(N.lines, z.lineIds), we.current?.update(Lt.current, i.width, i.height, p);
-        const l = Be.current;
-        if (l) {
-          const t = (z.nodeIds.size > 0 || z.edgeIds.size > 0 || z.lineIds.size > 0) && !jt.current && !Dt.current && !ie.current;
-          let r = !t;
-          if (t) {
-            let a = 1 / 0, d = 1 / 0, n = -1 / 0, s = -1 / 0;
-            const m = (h, I, S, u) => {
-              a = Math.min(a, h), d = Math.min(d, I), n = Math.max(n, h + S), s = Math.max(s, I + u);
-            };
-            for (const h of N.nodes) z.nodeIds.has(h.id) && m(h.position.x, h.position.y, h.width, h.height);
-            for (const h of N.edges) {
-              if (!z.edgeIds.has(h.id)) continue;
-              const I = x.get(h.source), S = x.get(h.target);
-              I && m(I.position.x, I.position.y, I.width, I.height), S && m(S.position.x, S.position.y, S.width, S.height);
-            }
-            for (const h of N.lines)
-              if (z.lineIds.has(h.id))
-                for (const I of h.points) m(I.x, I.y, 0, 0);
-            if (a === 1 / 0) r = !0;
-            else {
-              const h = p.zoom, I = 66, S = 30, u = 6;
-              let b = n * h + p.x + 8, _ = d * h + p.y - S - 6;
-              b + I > i.width - u && (b = Math.max(u, i.width - I - u)), _ < u && (_ = d * h + p.y + u), _ + S > i.height - u && (_ = Math.max(u, i.height - S - u)), l.style.display = "flex", l.style.left = `${Math.round(b)}px`, l.style.top = `${Math.round(_)}px`;
-            }
-          }
-          r && l.style.display !== "none" && (l.style.display = "none");
-        }
-        const e = te.current;
-        if (e) {
-          e.clear();
-          const t = Gt.current;
-          t && (e.circle(t.wx, t.wy, 10).fill({
-            color: 3900150,
-            alpha: 0.12
-          }).stroke({
-            color: 3900150,
-            width: 1.5,
-            alpha: 0.5
-          }), e.circle(t.wx, t.wy, 4).fill({
-            color: 3900150,
-            alpha: 0.9
-          }));
-          const r = Wt.current;
-          r && !t && (e.circle(r.worldX, r.worldY, 10).fill({
-            color: 16347926,
-            alpha: 0.12
-          }).stroke({
-            color: 16347926,
-            width: 1.5,
-            alpha: 0.5
-          }), e.circle(r.worldX, r.worldY, 4).fill({
-            color: 16347926,
-            alpha: 0.9
-          }));
-        }
-        const w = ne.current;
-        if (w) {
-          w.clear();
-          const t = ie.current;
-          if (t) {
-            const r = Ze.current, a = Nt.current, d = Jt.current, n = Zt(r.x - t.width / 2, a, d), s = Zt(r.y - t.height / 2, a, d), m = {
-              id: "__ghost__",
-              type: t.type,
-              position: {
-                x: n,
-                y: s
-              },
-              width: t.width,
-              height: t.height,
-              data: {}
-            }, h = ve([m], N.nodes);
-            Lt.current = h.guides, w.position.set(n + h.dx, s + h.dy), (ln[t.type] ?? ln.shapeRect)(w, {
-              width: t.width,
-              height: t.height,
-              fill: "#3b82f6",
-              stroke: "#3b82f6",
-              strokeWidth: 1.5,
-              borderStyle: t.data.borderStyle
-            });
-          } else
-            w.position.set(0, 0), !ct.current?.active && !gt.current?.active && (Lt.current = []);
-        }
-        const y = ee.current;
-        if (y && (y.clear(), z.edgeIds.size > 0 && oe.current === "select")) {
-          const t = 1 / p.zoom;
-          for (const r of N.edges) {
-            if (!z.edgeIds.has(r.id)) continue;
-            const a = St(r, x);
-            a && (y.circle(a.sx, a.sy, 5 * t).fill({ color: 16777215 }).stroke({
-              color: 16347926,
-              width: 1.5 * t
-            }), y.circle(a.tx, a.ty, 5 * t).fill({ color: 16777215 }).stroke({
-              color: 16347926,
-              width: 1.5 * t
-            }));
-            const d = r.data.waypoints;
-            if (d) for (const n of d) y.circle(n.x, n.y, 5 * t).fill({ color: 16777215 }).stroke({
-              color: 3900150,
-              width: 1.5 * t
-            });
-            if (r.type === "simplebezier") {
-              const n = St(r, x);
-              if (!n) continue;
-              const s = d ?? [], m = [
-                {
-                  x: n.sx,
-                  y: n.sy
-                },
-                ...s,
-                {
-                  x: n.tx,
-                  y: n.ty
-                }
-              ], h = r.data.bezierControls, I = m.length - 2;
-              for (let S = 0; S <= I; S++) {
-                const u = m[S], b = m[S + 1], _ = h?.[S], J = Math.hypot(b.x - u.x, b.y - u.y), _t = Math.max(30, J * 0.3), Ot = _?.c1x ?? (S === 0 ? u.x + n.snx * _t : u.x + (b.x - u.x) * 0.4), sn = _?.c1y ?? (S === 0 ? u.y + n.sny * _t : u.y), cn = _?.c2x ?? (S === I ? b.x + n.tnx * _t : b.x - (b.x - u.x) * 0.4), dn = _?.c2y ?? (S === I ? b.y + n.tny * _t : b.y);
-                y.moveTo(u.x, u.y).lineTo(Ot, sn).stroke({
-                  color: 10265519,
-                  width: 1 * t
-                }), y.moveTo(b.x, b.y).lineTo(cn, dn).stroke({
-                  color: 10265519,
-                  width: 1 * t
-                });
-                const an = 4 * t;
-                y.circle(Ot, sn, an).fill({ color: 16777215 }).stroke({
-                  color: 3900150,
-                  width: 1.5 * t
-                }), y.circle(cn, dn, an).fill({ color: 16777215 }).stroke({
-                  color: 3900150,
-                  width: 1.5 * t
-                });
-              }
-            }
-          }
-        }
-        const E = Qt.current;
-        if (E && (E.clear(), z.nodeIds.size === 1 && oe.current === "select")) {
-          const t = [...z.nodeIds][0], r = N.nodes.find((a) => a.id === t);
-          if (r) {
-            const a = p.zoom, d = r.position.x * a + p.x, n = r.position.y * a + p.y, s = r.width * a, m = r.height * a;
-            E.rect(d, n, s, m).stroke({
-              color: 3900150,
-              width: 1.5
-            });
-            const h = 7, I = h / 2, S = [
-              [d, n],
-              [d + s, n],
-              [d + s, n + m],
-              [d, n + m]
-            ];
-            for (const [_, J] of S) E.rect(_ - I, J - I, h, h).fill({ color: 16777215 }).stroke({
-              color: 3900150,
-              width: 1.5
-            });
-            const u = 4, b = [
-              [d + s / 2, n],
-              [d + s, n + m / 2],
-              [d + s / 2, n + m],
-              [d, n + m / 2]
-            ];
-            for (const [_, J] of b) E.circle(_, J, u).fill({
-              color: 3900150,
-              alpha: 0.9
-            });
-            if (!jt.current) {
-              const _ = d + s / 2, J = n - In;
-              E.moveTo(_, n).lineTo(_, J).stroke({
-                color: 3900150,
-                width: 1.5,
-                alpha: 0.85
-              }), E.circle(_, J, 6).fill({ color: 16777215 }).stroke({
-                color: 3900150,
-                width: 1.5
-              }), E.circle(_, J, 2.5).fill({ color: 3900150 });
-            }
-          }
-        }
-      });
-    };
-    return q(), () => {
-      if (G = !0, f && !f.destroyed) try {
-        f.app.stage.removeAllListeners();
-      } catch {
-      }
-      const F = R.current;
-      O && F?.removeEventListener("touchstart", O), W && F?.removeEventListener("touchmove", W), K && (F?.removeEventListener("touchend", K), F?.removeEventListener("touchcancel", K)), D.current?.destroy(), Tt.current?.destroy(), pe.current?.destroy(), xe.current?.destroy(), ge.current?.destroy(), Re.current?.destroy(), Se.current?.destroy(), mt.current?.destroy(), Qt.current && (Qt.current.destroy(), Qt.current = null), te.current && (te.current.destroy(), te.current = null), ee.current && (ee.current.destroy(), ee.current = null), ne.current && (ne.current.destroy(), ne.current = null), we.current?.destroy();
-    };
-  }, [L.current]), Rt(() => {
-    const f = Re.current, G = Se.current;
-    if (!(!f || !G))
-      switch (f.deactivate(), G.deactivate(), et) {
-        case "freehand":
-          f.activate();
-          break;
-        case "line":
-          G.activate("straight");
-          break;
-        case "polyline":
-          G.activate("polyline");
-          break;
-        case "arrow":
-          G.activate("arrow");
-      }
-  }, [et]), Rt(() => {
-    D.current && (D.current.visible = ut, D.current.gridSize = $);
-  }, [ut, $]), Rt(() => {
-    const f = R.current;
-    if (!f) return;
-    const G = 1e-3, O = (W) => {
-      W.preventDefault();
-      const K = V.current;
-      if (!K) return;
-      const q = f.getBoundingClientRect(), F = W.clientX - q.left, at = W.clientY - q.top, lt = W.ctrlKey ? 3 : 1, It = -W.deltaY * G * lt;
-      K.zoomAt(F, at, 1 + It);
-    };
-    return f.addEventListener("wheel", O, { passive: !1 }), () => f.removeEventListener("wheel", O);
-  }, [V]), /* @__PURE__ */ Ie("div", {
-    style: {
-      position: "relative",
-      width: "100%",
-      height: "100%"
-    },
-    children: [
-      /* @__PURE__ */ qt("div", {
-        ref: R,
-        className: "flow-canvas-wrapper",
-        tabIndex: -1,
-        onContextMenu: (f) => f.preventDefault()
-      }),
-      yt && Te && /* @__PURE__ */ qt("input", {
-        className: "flow-label-editor",
-        autoFocus: !0,
-        defaultValue: yt.value,
-        style: {
-          left: Te.x,
-          top: Te.y
-        },
-        onFocus: (f) => f.currentTarget.select(),
-        onKeyDown: (f) => {
-          f.key === "Enter" ? (f.preventDefault(), Qe(f.target.value)) : f.key === "Escape" && (f.preventDefault(), Rn()), f.stopPropagation();
-        },
-        onBlur: (f) => Qe(f.target.value),
-        onPointerDown: (f) => f.stopPropagation()
-      }),
-      wt && !Ct && /* @__PURE__ */ Ie("button", {
-        type: "button",
-        className: "flow-esc-button",
-        onClick: () => he(null),
-        title: "取消连续放置 (Esc)",
-        children: [/* @__PURE__ */ qt("span", {
-          "aria-hidden": !0,
-          children: "⎋"
-        }), " 取消放置 (ESC)"]
-      }),
-      /* @__PURE__ */ Ie("button", {
-        ref: Be,
-        type: "button",
-        className: "flow-delete-button",
-        style: { display: "none" },
-        onClick: () => Fe.current(),
-        title: "删除所选 (Delete)",
-        "aria-label": "删除所选",
-        children: [/* @__PURE__ */ Ie("svg", {
-          width: "12",
-          height: "12",
-          viewBox: "0 0 24 24",
-          fill: "none",
-          stroke: "currentColor",
-          strokeWidth: "2.5",
-          strokeLinecap: "round",
-          strokeLinejoin: "round",
-          "aria-hidden": !0,
-          children: [
-            /* @__PURE__ */ qt("path", { d: "M3 6h18" }),
-            /* @__PURE__ */ qt("path", { d: "M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6" }),
-            /* @__PURE__ */ qt("path", { d: "M8 6V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2" })
-          ]
-        }), "删除"]
-      })
-    ]
-  });
+function D({ onPixiReady: u }) {
+	let T = x(null), D = x(null), Se = x(13751771), Ce = y((e) => {
+		Se.current = e.gridDot, D.current && (D.current.dotColor = e.gridDot);
+	}, []), { pixiRef: O, readyRef: we } = n(T, Ce), { setViewportInternal: Te, viewportReqRef: Ee, viewport: k, autoFocus: De, showGrid: Oe, showAnchors: A, gridSize: ke, toolMode: j, edgeType: Ae, focusOnRect: je, setFocusOnRect: Me, pendingPlacement: Ne, setPendingPlacement: Pe, setContextMenu: Fe, beginNodeDrag: Ie, endNodeDrag: Le, presentation: Re, editingNodeId: ze, setEditingNodeId: Be, readOnly: Ve, placementSnap: He } = t(), { currentCanvas: Ue, selection: We, setSelection: M, setDoc: N, currentCanvasId: Ge, pushCanvas: Ke, doc: qe } = e(), Je = se(), Ye = x(Je);
+	Ye.current = Je;
+	let Xe = x(null), Ze = x(Ve);
+	Ze.current = Ve;
+	let Qe = x(He);
+	Qe.current = He;
+	let P = x(ke);
+	P.current = ke;
+	let F = x(null), $e = x(null), et = x(null), tt = x(null), nt = x(null), rt = x(null), I = x(null), it = x(null), at = x(null), ot = x(null), L = x([]), st = x(null), ct = x(null), R = x(null), lt = x(null), ut = x({
+		time: 0,
+		wx: 0,
+		wy: 0
+	}), dt = x({
+		time: 0,
+		wx: 0,
+		wy: 0
+	}), ft = x(0), pt = x(null), mt = x({
+		x: 0,
+		y: 0
+	}), ht = A || Re ? Ue : {
+		...Ue,
+		nodes: Ue.nodes.filter((e) => e.type !== "animAnchor")
+	}, z = x(ht);
+	z.current = ht;
+	let B = x(Ge);
+	B.current = Ge;
+	let gt = x(We);
+	gt.current = We;
+	let _t = x(qe);
+	_t.current = qe;
+	let vt = x(j);
+	vt.current = j;
+	let yt = x(De);
+	yt.current = De;
+	let bt = x(je);
+	bt.current = je;
+	let xt = x(Ae);
+	xt.current = Ae;
+	let St = x(A);
+	St.current = A;
+	let V = x(Re);
+	V.current = Re;
+	let Ct = x(Ne);
+	Ct.current = Ne;
+	let wt = x(Ie);
+	wt.current = Ie;
+	let H = x(Le);
+	H.current = Le;
+	let U = x(null), W = x(null), G = x(null), K = x(null), q = x(null), J = x(null), Y = x(null), X = x(null), Tt = x(k), Et = x(0), Dt = y((e) => {
+		Tt.current = e, Et.current ||= requestAnimationFrame(() => {
+			Et.current = 0, Te(Tt.current);
+		});
+	}, [Te]), { vmRef: Z, screenToWorld: Ot } = r(O, Dt), Q = x(Ot);
+	Q.current = Ot;
+	let [$, kt] = S(null), [At, jt] = S(null), Mt = x($);
+	Mt.current = $;
+	let Nt = x(() => {});
+	Nt.current = (e, t, n) => {
+		Be(e === "node" ? t : null), kt({
+			kind: e,
+			id: t,
+			value: n
+		});
+	};
+	let Pt = y((e) => {
+		let t = Mt.current;
+		t && (N((n) => {
+			let r = B.current, i = n.canvases[r];
+			if (!i) return n;
+			let a = i;
+			if (t.kind === "node") a = {
+				...i,
+				nodes: i.nodes.map((n) => n.id === t.id ? {
+					...n,
+					data: {
+						...n.data,
+						label: e
+					}
+				} : n)
+			};
+			else if (t.kind === "edge") a = {
+				...i,
+				edges: i.edges.map((n) => n.id === t.id ? {
+					...n,
+					data: {
+						...n.data,
+						labelText: e
+					}
+				} : n)
+			};
+			else return n;
+			return {
+				...n,
+				canvases: {
+					...n.canvases,
+					[r]: a
+				}
+			};
+		}), kt(null), Be(null), jt(null));
+	}, [N, Be]), Ft = y(() => {
+		kt(null), Be(null), jt(null);
+	}, [Be]);
+	b(() => {
+		if (!ze || Mt.current?.id === ze) return;
+		let e = z.current.nodes.find((e) => e.id === ze);
+		e && Nt.current("node", e.id, e.data.label);
+	}, [ze]), b(() => {
+		if (!$) return;
+		let e = Z.current;
+		if (!e) return;
+		let t = z.current, n = null;
+		if ($.kind === "node") {
+			let e = t.nodes.find((e) => e.id === $.id);
+			e && (n = {
+				x: e.position.x + e.width / 2,
+				y: e.position.y + e.height / 2
+			});
+		} else if ($.kind === "edge") {
+			let e = t.edges.find((e) => e.id === $.id), r = /* @__PURE__ */ new Map();
+			for (let e of t.nodes) r.set(e.id, e);
+			if (e) {
+				let t = _(e, r);
+				if (t) {
+					let r = h(e.type, t, e.data.waypoints, e.data.bezierControls), i = g(r), a = i[Math.floor(i.length / 2)] ?? {
+						x: (t.sx + t.tx) / 2,
+						y: (t.sy + t.ty) / 2
+					};
+					n = {
+						x: a.x,
+						y: a.y
+					};
+				}
+			}
+		}
+		if (n) {
+			let t = e.worldToScreen(n.x, n.y);
+			jt({
+				x: t.x,
+				y: t.y
+			});
+		}
+	}, [$, Z]);
+	let It = x(0);
+	b(() => {
+		Ee.current !== It.current && (It.current = Ee.current, Tt.current = k, Z.current?.setState(k));
+	}, [
+		k,
+		Z,
+		Ee
+	]), b(() => {
+		Me((e, t, n, r, i) => {
+			let a = Z.current, o = T.current;
+			if (!a || !o) return;
+			let s = o.clientWidth || 800, c = o.clientHeight || 600, l = Math.max(0, i?.padding ?? 60), u = Math.max(1, s - l * 2), d = Math.max(1, c - l * 2), f = i?.preserveZoom ? a.state.zoom : Math.min(u / Math.max(n, 1), d / Math.max(r, 1), i?.maxZoom ?? 2), p = e + n / 2, m = t + r / 2, h = s / 2 - p * f, g = c / 2 - m * f;
+			a.animateTo({
+				x: h,
+				y: g,
+				zoom: f
+			}, i?.duration ?? 350);
+		});
+	}, [Me, Z]);
+	let Lt = y((e) => {
+		N((t) => {
+			let n = t.canvases[B.current];
+			return n ? {
+				...t,
+				canvases: {
+					...t.canvases,
+					[B.current]: {
+						...n,
+						lines: [...n.lines, e]
+					}
+				}
+			} : t;
+		});
+	}, [N, Ge]), Rt = x(Lt);
+	return Rt.current = Lt, b(() => {
+		let e = O.current;
+		if (!e || e.destroyed) return;
+		let t = !1, n = null, r = null, h = null, g = () => {
+			if (t) return;
+			if (!we.current) {
+				setTimeout(g, 30);
+				return;
+			}
+			D.current = new i(e.app.stage, ke, Oe), D.current.dotColor = Se.current, F.current = new a(e.app.stage), $e.current = new m(e.world), et.current = new v(e.world), tt.current = new ee(e.world);
+			let se = new ce();
+			se.label = "connect-line", se.visible = !1, e.world.addChild(se), J.current = se;
+			let y = new ce();
+			y.label = "transform-handles", e.app.stage.addChild(y), it.current = y;
+			let b = new ce();
+			b.label = "handle-hover", e.world.addChild(b), at.current = b;
+			let x = new ce();
+			x.label = "edge-edit-handles", e.world.addChild(x), lt.current = x;
+			let S = new ce();
+			S.label = "ghost-placement", S.alpha = .5, e.world.addChild(S), pt.current = S, ot.current = new ie(e.world), nt.current = new te(e.app.stage, e.world, {
+				onLineComplete: (e) => Rt.current(e),
+				screenToWorld: (e, t) => Q.current(e, t)
+			}), rt.current = new ne(e.app.stage, e.world, {
+				onLineComplete: (e) => Rt.current(e),
+				screenToWorld: (e, t) => Q.current(e, t)
+			}), u?.(e);
+			let C = e.app.stage;
+			C.on("pointerdown", (e) => {
+				if (T.current?.focus({ preventScroll: !0 }), Z.current?.multiTouchActive || Z.current?.isPanning || Z.current?.isSpaceHeld || e.button !== 0) return;
+				let t = vt.current;
+				if (t === "pan") {
+					Z.current?.startPan(e.global.x, e.global.y);
+					return;
+				}
+				if (t === "freehand" || t === "line" || t === "polyline" || t === "arrow") return;
+				let n = Q.current(e.global.x, e.global.y), r = z.current.nodes, i = z.current.edges, a = z.current.lines, o = gt.current, u = e.metaKey || e.ctrlKey || e.shiftKey, d = Z.current?.state.zoom ?? 1;
+				if (Ct.current) return;
+				let p = Date.now(), m = ut.current, h = p - m.time < 350 && Math.hypot(n.x - m.wx, n.y - m.wy) < 8 / d;
+				if (ut.current = {
+					time: p,
+					wx: n.x,
+					wy: n.y
+				}, o.nodeIds.size === 1 && !u && t === "select" && !Ze.current) {
+					let e = r.find((e) => e.id === [...o.nodeIds][0]);
+					if (e) {
+						let t = fe(e, d);
+						if (Math.hypot(n.x - t.x, n.y - t.y) < E(d, 12, 24)) {
+							K.current = {
+								active: !0,
+								nodeId: e.id,
+								cx: e.position.x + e.width / 2,
+								cy: e.position.y + e.height / 2,
+								startPointerAngle: Math.atan2(n.y - (e.position.y + e.height / 2), n.x - (e.position.x + e.width / 2)),
+								startRotation: e.data.rotation ?? 0
+							}, wt.current();
+							return;
+						}
+					}
+				}
+				if (o.nodeIds.size === 1 && !u && t === "select") {
+					let e = r.find((e) => e.id === [...o.nodeIds][0]);
+					if (e) {
+						let t = me(n, e, E(d, 10, 16));
+						if (t) {
+							let i = /* @__PURE__ */ new Map(), a = /* @__PURE__ */ new Map(), o = e.type === "geometryGroup", s = o || e.type === "flowGroup" || e.data.isGroup, c = e.position.x, l = e.position.y, u = e.width, d = e.height;
+							for (let t of r) t.id !== e.id && (t.parentId === e.id || o && t.position.x >= c && t.position.y >= l && t.position.x + t.width <= c + u && t.position.y + t.height <= l + d) && i.set(t.id, {
+								x: t.position.x,
+								y: t.position.y,
+								w: t.width,
+								h: t.height
+							});
+							if (s) for (let t of z.current.lines) (t.parentId === e.id || o && t.points.length > 0 && t.points.every((e) => e.x >= c && e.x <= c + u && e.y >= l && e.y <= l + d)) && a.set(t.id, t.points.map((e) => ({ ...e })));
+							Y.current = {
+								active: !0,
+								nodeId: e.id,
+								handle: t,
+								startWorld: n,
+								startBounds: {
+									x: e.position.x,
+									y: e.position.y,
+									w: e.width,
+									h: e.height
+								},
+								childStarts: i,
+								childLineStarts: a.size > 0 ? a : void 0
+							};
+							return;
+						}
+					}
+				}
+				let g = null;
+				for (let e = r.length - 1; e >= 0; e--) if (f(n.x, n.y, r[e])) {
+					g = r[e];
+					break;
+				}
+				if (g?.parentId) {
+					let e = r.find((e) => e.id === g.parentId);
+					e && (g = e);
+				}
+				ue && (I.current = g ? g.parentId ? r.find((e) => e.id === g.parentId)?.id ?? g.id : g.id : null, st.current = null, ct.current = null);
+				let _ = !1;
+				if (g && t === "select" && (_ = Math.min(n.x - g.position.x, g.position.x + g.width - n.x, n.y - g.position.y, g.position.y + g.height - n.y) > Math.min(14, Math.min(g.width, g.height) * .3)), (t === "select" || t === "connect") && (g || ue) && !_) {
+					let e = g ? [g] : r, t = E(d, 14, 20), i = null, a = null, o = Infinity;
+					for (let r of e) {
+						let e = c(r.width, r.height), u = s(e, r, n.x, n.y, t);
+						if (!u) continue;
+						let d = l(u, r), f = Math.hypot(n.x - d.x, n.y - d.y);
+						f < o && (o = f, i = r, a = u);
+					}
+					if (i && a) {
+						G.current = {
+							active: !0,
+							sourceNodeId: i.id,
+							sourceHandleId: a.id
+						};
+						return;
+					}
+				}
+				if ((t === "select" || t === "connect") && !u && o.edgeIds.size > 0) {
+					let e = /* @__PURE__ */ new Map();
+					for (let t of r) e.set(t.id, t);
+					let t = i.filter((e) => o.edgeIds.has(e.id)), a = he(n.x, n.y, t, e, E(d, 14, 20));
+					if (a) {
+						let e = i.find((e) => e.id === a.edgeId);
+						if (e) {
+							let t = a.end === "source" ? "target" : "source";
+							q.current = {
+								active: !0,
+								edgeId: e.id,
+								movingEnd: a.end,
+								fixedNodeId: t === "source" ? e.source : e.target,
+								fixedHandleId: t === "source" ? e.sourceHandle : e.targetHandle
+							};
+							return;
+						}
+					}
+				}
+				if (t === "select" && o.edgeIds.size > 0 && !g) {
+					let e = /* @__PURE__ */ new Map();
+					for (let t of r) e.set(t.id, t);
+					let t = i.filter((e) => o.edgeIds.has(e.id)), a = E(d, 10, 14), s = _e(n.x, n.y, t, e, a);
+					if (s) {
+						R.current = {
+							active: !0,
+							edgeId: s.edgeId,
+							type: s.controlEnd === "c1" ? "bezierC1" : "bezierC2",
+							index: s.segmentIndex
+						};
+						return;
+					}
+					let c = ge(n.x, n.y, t, a);
+					if (c) {
+						if (h) {
+							N((e) => {
+								let t = e.canvases[B.current];
+								return t ? {
+									...e,
+									canvases: {
+										...e.canvases,
+										[B.current]: {
+											...t,
+											edges: t.edges.map((e) => {
+												if (e.id !== c.edgeId) return e;
+												let t = [...e.data.waypoints ?? []];
+												t.splice(c.waypointIndex, 1);
+												let n = {
+													...e.data,
+													waypoints: t.length > 0 ? t : void 0
+												};
+												if (e.type === "simplebezier" && e.data.bezierControls) {
+													let t = [...e.data.bezierControls];
+													t.splice(c.waypointIndex, 2, null), n.bezierControls = t.some((e) => e !== null) ? t : void 0;
+												}
+												return {
+													...e,
+													data: n
+												};
+											})
+										}
+									}
+								} : e;
+							});
+							return;
+						}
+						R.current = {
+							active: !0,
+							edgeId: c.edgeId,
+							type: "waypoint",
+							index: c.waypointIndex
+						};
+						return;
+					}
+					if (h) {
+						for (let r of t) if (be(n.x, n.y, r, e, E(d, 8, 12))) {
+							let t = ve(n.x, n.y, r, e), i = {
+								x: n.x,
+								y: n.y
+							};
+							N((e) => {
+								let n = e.canvases[B.current];
+								return n ? {
+									...e,
+									canvases: {
+										...e.canvases,
+										[B.current]: {
+											...n,
+											edges: n.edges.map((e) => {
+												if (e.id !== r.id) return e;
+												let n = [...e.data.waypoints ?? []];
+												n.splice(t, 0, i);
+												let a = {
+													...e.data,
+													waypoints: n
+												};
+												if (e.type === "simplebezier" && e.data.bezierControls) {
+													let n = [...e.data.bezierControls];
+													for (; n.length < (e.data.waypoints ?? []).length + 1;) n.push(null);
+													n.splice(t, 1, null, null), a.bezierControls = n;
+												}
+												return {
+													...e,
+													data: a
+												};
+											})
+										}
+									}
+								} : e;
+							}), R.current = {
+								active: !0,
+								edgeId: r.id,
+								type: "waypoint",
+								index: t
+							};
+							return;
+						}
+					}
+				}
+				if (g && (t === "select" || t === "connect")) {
+					!u && !o.nodeIds.has(g.id) ? M({
+						nodeIds: /* @__PURE__ */ new Set([g.id]),
+						edgeIds: /* @__PURE__ */ new Set(),
+						lineIds: /* @__PURE__ */ new Set()
+					}) : u && M((e) => {
+						let t = new Set(e.nodeIds);
+						return t.has(g.id) ? t.delete(g.id) : t.add(g.id), {
+							nodeIds: t,
+							edgeIds: /* @__PURE__ */ new Set(),
+							lineIds: /* @__PURE__ */ new Set()
+						};
+					}), yt.current && bt.current(g.position.x, g.position.y, g.width, g.height, {
+						padding: 80,
+						preserveZoom: !0,
+						duration: 280
+					});
+					let e = o.nodeIds.has(g.id) ? new Set(o.nodeIds) : /* @__PURE__ */ new Set([g.id]);
+					u && !o.nodeIds.has(g.id) && e.add(g.id);
+					let t = /* @__PURE__ */ new Set();
+					for (let n of e) {
+						let i = r.find((e) => e.id === n);
+						if (!i || i.type !== "flowGroup" && i.type !== "geometryGroup" && !i.data.isGroup) continue;
+						let a = i.type === "geometryGroup", o = i.position.x, s = i.position.y, c = i.width, l = i.height;
+						for (let t of r) if (!(e.has(t.id) || t.id === n)) {
+							if (t.parentId === n) {
+								e.add(t.id);
+								continue;
+							}
+							a && t.position.x >= o && t.position.y >= s && t.position.x + t.width <= o + c && t.position.y + t.height <= s + l && e.add(t.id);
+						}
+						for (let e of z.current.lines) e.parentId === n && t.add(e.id);
+						if (a) for (let e of z.current.lines) t.has(e.id) || e.points.length > 0 && e.points.every((e) => e.x >= o && e.x <= o + c && e.y >= s && e.y <= s + l) && t.add(e.id);
+					}
+					let i = /* @__PURE__ */ new Map();
+					for (let t of r) e.has(t.id) && i.set(t.id, { ...t.position });
+					let a = /* @__PURE__ */ new Map();
+					if (t.size > 0) for (let e of z.current.lines) t.has(e.id) && a.set(e.id, e.points.map((e) => ({ ...e })));
+					U.current = {
+						active: !0,
+						nodeIds: e,
+						lineIds: t.size > 0 ? t : void 0,
+						startWorld: n,
+						nodeStarts: i,
+						linePointStarts: a.size > 0 ? a : void 0
+					}, wt.current();
+					return;
+				}
+				let v = /* @__PURE__ */ new Map();
+				for (let e of r) v.set(e.id, e);
+				let ee = E(d, 8, 12);
+				for (let e of i) if (be(n.x, n.y, e, v, ee)) {
+					if (M(u ? (t) => {
+						let n = new Set(t.edgeIds);
+						return n.has(e.id) ? n.delete(e.id) : n.add(e.id), {
+							...t,
+							edgeIds: n
+						};
+					} : {
+						nodeIds: /* @__PURE__ */ new Set(),
+						edgeIds: /* @__PURE__ */ new Set([e.id]),
+						lineIds: /* @__PURE__ */ new Set()
+					}), yt.current) {
+						let t = v.get(e.source), n = v.get(e.target);
+						if (t && n) {
+							let e = Math.min(t.position.x, n.position.x), r = Math.min(t.position.y, n.position.y), i = Math.max(t.position.x + t.width, n.position.x + n.width), a = Math.max(t.position.y + t.height, n.position.y + n.height);
+							bt.current(e, r, i - e, a - r, {
+								padding: 80,
+								preserveZoom: !0,
+								duration: 280
+							});
+						}
+					}
+					return;
+				}
+				for (let e of a) if (xe(n.x, n.y, e, ee)) {
+					let t = o.lineIds.has(e.id);
+					if (u ? M((t) => {
+						let n = new Set(t.lineIds);
+						return n.has(e.id) ? n.delete(e.id) : n.add(e.id), {
+							...t,
+							lineIds: n
+						};
+					}) : t || M({
+						nodeIds: /* @__PURE__ */ new Set(),
+						edgeIds: /* @__PURE__ */ new Set(),
+						lineIds: /* @__PURE__ */ new Set([e.id])
+					}), yt.current && e.points.length > 0) {
+						let t = e.points.map((e) => e.x), n = e.points.map((e) => e.y), r = Math.min(...t), i = Math.min(...n), a = Math.max(...t), o = Math.max(...n);
+						bt.current(r, i, Math.max(1, a - r), Math.max(1, o - i), {
+							padding: 80,
+							preserveZoom: !0,
+							duration: 280
+						});
+					}
+					let r = t ? new Set(o.lineIds) : /* @__PURE__ */ new Set([e.id]), i = /* @__PURE__ */ new Map();
+					for (let e of a) r.has(e.id) && i.set(e.id, e.points.map((e) => ({ ...e })));
+					X.current = {
+						active: !0,
+						lineIds: r,
+						startWorld: n,
+						pointStarts: i
+					};
+					return;
+				}
+				u || M({
+					nodeIds: /* @__PURE__ */ new Set(),
+					edgeIds: /* @__PURE__ */ new Set(),
+					lineIds: /* @__PURE__ */ new Set()
+				}), t === "select" && (W.current = {
+					active: !0,
+					startScreen: {
+						x: e.global.x,
+						y: e.global.y
+					}
+				});
+			}), C.on("globalpointermove", (e) => {
+				let t = Q.current(e.global.x, e.global.y);
+				if (mt.current = t, Z.current?.multiTouchActive) return;
+				let n = vt.current;
+				if (n === "freehand" || n === "line" || n === "polyline" || n === "arrow") return;
+				let r = z.current.nodes, i = z.current.edges, a = Z.current?.state.zoom ?? 1, o = !U.current?.active && !G.current?.active && !Y.current?.active && !q.current?.active && !R.current?.active && !X.current?.active && !K.current?.active, u = null;
+				for (let e = r.length - 1; e >= 0; e--) if (f(t.x, t.y, r[e])) {
+					let t = r[e];
+					u = t.parentId ? r.find((e) => e.id === t.parentId)?.id ?? t.id : t.id;
+					break;
+				}
+				if (I.current = u, o && (n === "select" || n === "connect")) {
+					let e = /* @__PURE__ */ new Map();
+					for (let t of r) e.set(t.id, t);
+					let n = gt.current, o = n.edgeIds.size > 0 ? i.filter((e) => n.edgeIds.has(e.id)) : [], d = o.length > 0 ? he(t.x, t.y, o, e, E(a, 12, 18)) : null;
+					ct.current = d;
+					let f = null;
+					if (u) {
+						let e = r.find((e) => e.id === u);
+						if (e) {
+							let n = c(e.width, e.height), r = s(n, e, t.x, t.y, E(a, 14, 20));
+							if (r) {
+								let t = l(r, e);
+								f = {
+									nodeId: e.id,
+									handleId: r.id,
+									wx: t.x,
+									wy: t.y
+								};
+							}
+						}
+					}
+					st.current = f;
+				}
+				let d = T.current;
+				if (d && o) {
+					let e = gt.current, o = "";
+					if (ct.current) o = "crosshair";
+					else if (st.current) o = "crosshair";
+					else if (e.edgeIds.size > 0 && n === "select") {
+						let n = i.filter((t) => e.edgeIds.has(t.id)), s = /* @__PURE__ */ new Map();
+						for (let e of r) s.set(e.id, e);
+						let c = E(a, 10, 14);
+						(ge(t.x, t.y, n, c) || _e(t.x, t.y, n, s, c)) && (o = "grab");
+					}
+					if (!o && e.nodeIds.size === 1 && n === "select") {
+						let n = r.find((t) => t.id === [...e.nodeIds][0]);
+						if (n) {
+							let e = me(t, n, E(a, 10, 16));
+							if (e) o = le[e];
+							else if (!Ze.current) {
+								let e = fe(n, a);
+								Math.hypot(t.x - e.x, t.y - e.y) < E(a, 12, 24) && (o = "grab");
+							}
+						}
+					}
+					if (!o && n === "select") {
+						let e = z.current.lines, n = E(a, 8, 12);
+						for (let r of e) if (xe(t.x, t.y, r, n)) {
+							o = "move";
+							break;
+						}
+					}
+					d.style.cursor = o;
+				}
+				if (Y.current?.active) {
+					let e = Y.current, n = t.x - e.startWorld.x, r = t.y - e.startWorld.y, i = ye(e.startBounds, e.handle, n, r), a = z.current.nodes, o = {
+						id: e.nodeId,
+						type: "shapeRect",
+						position: {
+							x: i.x,
+							y: i.y
+						},
+						width: i.w,
+						height: i.h,
+						data: {}
+					}, s = re([o], a);
+					if (i.x += s.dx, i.y += s.dy, (e.handle === "ne" || e.handle === "se") && (i.w += s.dx), (e.handle === "se" || e.handle === "sw") && (i.h += s.dy), L.current = s.guides, Qe.current && P.current > 0 && s.guides.length === 0) {
+						let t = P.current;
+						(e.handle === "nw" || e.handle === "sw") && (i.x = Math.round(i.x / t) * t), (e.handle === "nw" || e.handle === "ne") && (i.y = Math.round(i.y / t) * t), (e.handle === "ne" || e.handle === "se") && (i.w = Math.round((i.x + i.w) / t) * t - i.x), (e.handle === "se" || e.handle === "sw") && (i.h = Math.round((i.y + i.h) / t) * t - i.y);
+					}
+					let c = e.startBounds, l = Math.max(i.w, 24), u = Math.max(i.h, 24), d = c.w > 0 ? l / c.w : 1, f = c.h > 0 ? u / c.h : 1;
+					N((t) => {
+						let n = t.canvases[B.current];
+						return n ? {
+							...t,
+							canvases: {
+								...t.canvases,
+								[B.current]: {
+									...n,
+									nodes: n.nodes.map((t) => {
+										if (t.id === e.nodeId) return {
+											...t,
+											position: {
+												x: i.x,
+												y: i.y
+											},
+											width: l,
+											height: u
+										};
+										let n = e.childStarts.get(t.id);
+										return n ? {
+											...t,
+											position: {
+												x: i.x + (n.x - c.x) * d,
+												y: i.y + (n.y - c.y) * f
+											},
+											width: Math.max(n.w * d, 24),
+											height: Math.max(n.h * f, 24)
+										} : t;
+									}),
+									lines: e.childLineStarts ? n.lines.map((t) => {
+										let n = e.childLineStarts.get(t.id);
+										return n ? {
+											...t,
+											points: n.map((e) => ({
+												x: i.x + (e.x - c.x) * d,
+												y: i.y + (e.y - c.y) * f
+											}))
+										} : t;
+									}) : n.lines
+								}
+							}
+						} : t;
+					});
+					return;
+				}
+				if (K.current?.active) {
+					let n = K.current, r = (Math.atan2(t.y - n.cy, t.x - n.cx) - n.startPointerAngle) * 180 / Math.PI, i = ((n.startRotation + r) % 360 + 360) % 360;
+					if (e.shiftKey) i = Math.round(i / 15) * 15 % 360;
+					else {
+						let e = Math.round(i / 45) * 45;
+						Math.abs(i - e) < 4 && (i = (e % 360 + 360) % 360);
+					}
+					N((e) => {
+						let t = e.canvases[B.current];
+						return t ? {
+							...e,
+							canvases: {
+								...e.canvases,
+								[B.current]: {
+									...t,
+									nodes: t.nodes.map((e) => e.id === n.nodeId ? {
+										...e,
+										data: {
+											...e.data,
+											rotation: i
+										}
+									} : e)
+								}
+							}
+						} : e;
+					}), T.current && (T.current.style.cursor = "grabbing");
+					return;
+				}
+				if (R.current?.active) {
+					let e = R.current, n = z.current.nodes, r = /* @__PURE__ */ new Map();
+					for (let e of n) r.set(e.id, e);
+					N((n) => {
+						let i = n.canvases[B.current];
+						return i ? {
+							...n,
+							canvases: {
+								...n.canvases,
+								[B.current]: {
+									...i,
+									edges: i.edges.map((n) => {
+										if (n.id !== e.edgeId) return n;
+										if (e.type === "waypoint") {
+											let r = [...n.data.waypoints ?? []];
+											return e.index < r.length && (r[e.index] = {
+												x: t.x,
+												y: t.y
+											}), {
+												...n,
+												data: {
+													...n.data,
+													waypoints: r
+												}
+											};
+										}
+										let i = _(n, r);
+										if (!i) return n;
+										let a = n.data.waypoints ?? [], o = [
+											{
+												x: i.sx,
+												y: i.sy
+											},
+											...a,
+											{
+												x: i.tx,
+												y: i.ty
+											}
+										], s = o.length - 1, c = [...n.data.bezierControls ?? []];
+										for (; c.length < s;) c.push(null);
+										let l = e.index;
+										if (l >= s) return n;
+										let u = o[l], d = o[l + 1], f = c[l], p = Math.hypot(d.x - u.x, d.y - u.y), m = Math.max(30, p * .3), h = s - 1, g = l === 0 ? u.x + i.snx * m : u.x + (d.x - u.x) * .4, v = l === 0 ? u.y + i.sny * m : u.y, ee = l === h ? d.x + i.tnx * m : d.x - (d.x - u.x) * .4, te = l === h ? d.y + i.tny * m : d.y;
+										return c[l] = e.type === "bezierC1" ? {
+											c1x: t.x,
+											c1y: t.y,
+											c2x: f?.c2x ?? ee,
+											c2y: f?.c2y ?? te
+										} : {
+											c1x: f?.c1x ?? g,
+											c1y: f?.c1y ?? v,
+											c2x: t.x,
+											c2y: t.y
+										}, {
+											...n,
+											data: {
+												...n.data,
+												bezierControls: c
+											}
+										};
+									})
+								}
+							}
+						} : n;
+					});
+					return;
+				}
+				if (X.current?.active) {
+					let e = X.current, n = t.x - e.startWorld.x, r = t.y - e.startWorld.y;
+					N((t) => {
+						let i = t.canvases[B.current];
+						return i ? {
+							...t,
+							canvases: {
+								...t.canvases,
+								[B.current]: {
+									...i,
+									lines: i.lines.map((t) => {
+										let i = e.pointStarts.get(t.id);
+										return i ? {
+											...t,
+											points: i.map((e) => ({
+												x: e.x + n,
+												y: e.y + r
+											}))
+										} : t;
+									})
+								}
+							}
+						} : t;
+					});
+					return;
+				}
+				if (U.current?.active) {
+					let e = U.current, n = t.x - e.startWorld.x, r = t.y - e.startWorld.y, i = n, a = r;
+					if (Qe.current && P.current > 0 && e.nodeIds.size > 0) {
+						let t = P.current, o = e.nodeStarts.values().next().value;
+						o && (i = pe(o.x + n, t, !0) - o.x, a = pe(o.y + r, t, !0) - o.y);
+					}
+					let o = z.current.nodes, s = o.filter((t) => e.nodeIds.has(t.id)).map((t) => {
+						let n = e.nodeStarts.get(t.id);
+						return {
+							...t,
+							position: {
+								x: n.x + i,
+								y: n.y + a
+							}
+						};
+					}), c = re(s, o);
+					i += c.dx, a += c.dy, L.current = c.guides, N((t) => {
+						let n = t.canvases[B.current];
+						return n ? {
+							...t,
+							canvases: {
+								...t.canvases,
+								[B.current]: {
+									...n,
+									nodes: n.nodes.map((t) => {
+										let n = e.nodeStarts.get(t.id);
+										return n ? {
+											...t,
+											position: {
+												x: n.x + i,
+												y: n.y + a
+											}
+										} : t;
+									}),
+									lines: e.linePointStarts ? n.lines.map((t) => {
+										let n = e.linePointStarts.get(t.id);
+										return n ? {
+											...t,
+											points: n.map((e) => ({
+												x: e.x + i,
+												y: e.y + a
+											}))
+										} : t;
+									}) : n.lines
+								}
+							}
+						} : t;
+					});
+					return;
+				}
+				if (W.current?.active && F.current) {
+					let t = Math.min(W.current.startScreen.x, e.global.x), n = Math.min(W.current.startScreen.y, e.global.y), r = Math.abs(e.global.x - W.current.startScreen.x), i = Math.abs(e.global.y - W.current.startScreen.y);
+					F.current.showMarquee(t, n, r, i);
+				}
+				if (G.current?.active && J.current) {
+					let e = z.current.nodes.find((e) => e.id === G.current.sourceNodeId);
+					if (e) {
+						let n = c(e.width, e.height).find((e) => e.id === G.current.sourceHandleId);
+						if (n) {
+							let r = l(n, e), i = r.x, a = r.y, o = t.x, u = t.y, d = I.current;
+							if (d && d !== G.current.sourceNodeId) {
+								let e = z.current.nodes.find((e) => e.id === d);
+								if (e) {
+									let n = c(e.width, e.height), r = s(n, e, t.x, t.y, Infinity);
+									if (r) {
+										let t = l(r, e);
+										o = t.x, u = t.y;
+									}
+								}
+							}
+							let f = J.current;
+							f.clear(), f.moveTo(i, a).lineTo(o, u).stroke({
+								color: 3900150,
+								width: 2,
+								alpha: .6
+							}), f.visible = !0;
+						}
+					}
+				}
+				if (q.current?.active && J.current && !J.current.destroyed) {
+					let e = q.current, n = z.current.nodes.find((t) => t.id === e.fixedNodeId);
+					if (n) {
+						let r = c(n.width, n.height).find((t) => t.id === e.fixedHandleId), i = r ? l(r, n) : {
+							x: n.position.x + n.width / 2,
+							y: n.position.y + n.height / 2
+						}, a = i.x, o = i.y, u = t.x, d = t.y, f = I.current;
+						if (f && f !== e.fixedNodeId) {
+							let e = z.current.nodes.find((e) => e.id === f);
+							if (e) {
+								let n = c(e.width, e.height), r = s(n, e, t.x, t.y, Infinity);
+								if (r) {
+									let t = l(r, e);
+									u = t.x, d = t.y;
+								}
+							}
+						}
+						let p = J.current;
+						p.clear(), p.moveTo(a, o).lineTo(u, d).stroke({
+							color: 16347926,
+							width: 2,
+							alpha: .7
+						}), p.visible = !0;
+					}
+				}
+			});
+			let w = () => {
+				L.current = [];
+				try {
+					ot.current?.clear();
+				} catch {}
+				try {
+					let e = J.current;
+					e && !e.destroyed && (e.clear(), e.visible = !1);
+				} catch {}
+				T.current && (T.current.style.cursor = "");
+			};
+			C.on("pointerup", (e) => {
+				if (w(), K.current?.active) {
+					K.current = null, H.current();
+					return;
+				}
+				if (R.current?.active) {
+					R.current = null;
+					return;
+				}
+				if (Y.current?.active) {
+					Y.current = null;
+					return;
+				}
+				if (X.current?.active) {
+					X.current = null;
+					return;
+				}
+				if (U.current?.active && (U.current = null, H.current()), W.current?.active) {
+					let t = Q.current(W.current.startScreen.x, W.current.startScreen.y), n = Q.current(e.global.x, e.global.y), r = Math.min(t.x, n.x), i = Math.min(t.y, n.y), a = Math.abs(n.x - t.x), o = Math.abs(n.y - t.y);
+					if (a > 4 && o > 4) {
+						let e = z.current.nodes.filter((e) => p(r, i, a, o, e.position.x, e.position.y, e.width, e.height)), t = z.current.lines.filter((e) => e.points.length !== 0 && e.points.every((e) => e.x >= r && e.x <= r + a && e.y >= i && e.y <= i + o));
+						M({
+							nodeIds: new Set(e.map((e) => e.id)),
+							edgeIds: /* @__PURE__ */ new Set(),
+							lineIds: new Set(t.map((e) => e.id))
+						});
+					}
+					W.current = null, F.current?.hideMarquee();
+				}
+				if (q.current?.active) {
+					let t = q.current.edgeId, n = q.current.movingEnd, r = q.current.fixedNodeId;
+					q.current = null;
+					let i = Q.current(e.global.x, e.global.y), a = z.current.nodes, o = ue ? E(Z.current?.state.zoom ?? 1, 12, 24) : 0, l = null;
+					for (let e = a.length - 1; e >= 0; e--) if (f(i.x, i.y, a[e], o) && a[e].id !== r) {
+						l = a[e];
+						break;
+					}
+					if (l) {
+						let e = l.id, r = c(l.width, l.height), a = s(r, l, i.x, i.y, Infinity)?.id;
+						N((r) => {
+							let i = r.canvases[B.current];
+							return i ? {
+								...r,
+								canvases: {
+									...r.canvases,
+									[B.current]: {
+										...i,
+										edges: i.edges.map((r) => r.id === t ? n === "source" ? {
+											...r,
+											source: e,
+											sourceHandle: a
+										} : {
+											...r,
+											target: e,
+											targetHandle: a
+										} : r)
+									}
+								}
+							} : r;
+						});
+					}
+					return;
+				}
+				if (G.current?.active) {
+					let t = G.current.sourceNodeId, n = G.current.sourceHandleId;
+					G.current = null;
+					let r = Q.current(e.global.x, e.global.y), i = z.current.nodes, a = ue ? E(Z.current?.state.zoom ?? 1, 12, 24) : 0, o = null;
+					for (let e = i.length - 1; e >= 0; e--) if (f(r.x, r.y, i[e], a) && i[e].id !== t) {
+						o = i[e];
+						break;
+					}
+					if (o) {
+						let e = o.id, i = c(o.width, o.height), a = s(i, o, r.x, r.y, Infinity)?.id, l = `edge_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 6)}`, u = xt.current;
+						N((r) => {
+							let i = r.canvases[B.current];
+							return !i || i.edges.some((r) => r.source === t && r.target === e && r.sourceHandle === n && r.targetHandle === a) ? r : {
+								...r,
+								canvases: {
+									...r.canvases,
+									[B.current]: {
+										...i,
+										edges: [...i.edges, {
+											id: l,
+											source: t,
+											target: e,
+											sourceHandle: n,
+											targetHandle: a,
+											type: u,
+											data: {
+												strokeColor: "theme:base-content",
+												strokeWidth: 2,
+												lineStyle: "solid",
+												markerEnd: "arrowclosed"
+											}
+										}]
+									}
+								}
+							};
+						});
+					}
+				}
+			}), C.on("pointerupoutside", () => {
+				w(), U.current?.active && H.current(), K.current?.active && H.current(), U.current = null, K.current = null, Y.current = null, W.current = null, q.current = null, G.current = null, R.current = null, X.current = null, I.current = null, st.current = null, ct.current = null, F.current?.hideMarquee();
+			});
+			let Ce = T.current, O = null, Te = (e) => {
+				let t = Ce.getBoundingClientRect(), n = e[0].clientX, r = e[0].clientY, i = e[1].clientX, a = e[1].clientY;
+				return {
+					dist: Math.hypot(i - n, a - r),
+					midX: (n + i) / 2 - t.left,
+					midY: (r + a) / 2 - t.top
+				};
+			}, Ee = () => {
+				w(), U.current?.active && H.current(), K.current?.active && H.current(), U.current = null, K.current = null, Y.current = null, W.current = null, q.current = null, G.current = null, R.current = null, X.current = null, I.current = null, st.current = null, ct.current = null, F.current?.hideMarquee(), Z.current?.cancelPan();
+			}, k = (e) => {
+				if (e.touches.length < 2) return;
+				let t = Z.current;
+				t && (t.multiTouchActive = !0, Ee(), O = Te(e.touches), e.preventDefault());
+			}, De = (e) => {
+				if (!O || e.touches.length < 2) return;
+				e.preventDefault();
+				let t = Z.current;
+				if (!t) return;
+				let n = Te(e.touches), r = n.dist / Math.max(1, O.dist);
+				Number.isFinite(r) && r > 0 && t.zoomAt(n.midX, n.midY, r), t.setState({
+					x: t.state.x + (n.midX - O.midX),
+					y: t.state.y + (n.midY - O.midY)
+				}), O = n;
+			}, A = (e) => {
+				if (e.touches.length >= 2) {
+					O = Te(e.touches);
+					return;
+				}
+				if (O = null, e.touches.length === 0) {
+					let e = Z.current;
+					e && (e.multiTouchActive = !1), ft.current = performance.now() + 350;
+				}
+			};
+			Ce?.addEventListener("touchstart", k, { passive: !1 }), Ce?.addEventListener("touchmove", De, { passive: !1 }), Ce?.addEventListener("touchend", A), Ce?.addEventListener("touchcancel", A), n = k, r = De, h = A, C.on("rightclick", (e) => {
+				if (e.preventDefault?.(), Z.current?.didRightPan) return;
+				let t = Q.current(e.global.x, e.global.y), n = z.current.nodes, r = null;
+				for (let e = n.length - 1; e >= 0; e--) if (f(t.x, t.y, n[e])) {
+					r = n[e].id;
+					break;
+				}
+				let i = e.nativeEvent, a = i?.clientX ?? e.global.x, o = i?.clientY ?? e.global.y;
+				Fe({
+					x: a,
+					y: o,
+					nodeId: r
+				});
+			}), C.on("pointertap", (e) => {
+				if (Z.current?.multiTouchActive || performance.now() < ft.current || e.button !== 0) return;
+				let t = Date.now(), n = Q.current(e.global.x, e.global.y), r = Ct.current;
+				if (r) {
+					let e = d("node"), t = P.current, i = Qe.current, a = pe(n.x - r.width / 2, t, i), o = pe(n.y - r.height / 2, t, i), s = {
+						id: "__ghost__",
+						type: r.type,
+						position: {
+							x: a,
+							y: o
+						},
+						width: r.width,
+						height: r.height,
+						data: {}
+					}, c = re([s], z.current.nodes), l = a + c.dx, u = o + c.dy;
+					N((t) => {
+						let n = t.canvases[B.current];
+						if (!n) return t;
+						let i = {};
+						r.type === "animAnchor" && (i.animIndex = oe(t));
+						let a = Math.max(0, ...n.nodes.map((e) => e.zIndex ?? 0), ...n.lines.map((e) => e.zIndex ?? 0));
+						return {
+							...t,
+							canvases: {
+								...t.canvases,
+								[B.current]: {
+									...n,
+									nodes: [...n.nodes, {
+										id: e,
+										type: r.type,
+										position: {
+											x: l,
+											y: u
+										},
+										width: r.width,
+										height: r.height,
+										zIndex: a + 1,
+										data: {
+											...r.data,
+											...i
+										}
+									}]
+								}
+							}
+						};
+					}), M({
+						nodeIds: /* @__PURE__ */ new Set([e]),
+						edgeIds: /* @__PURE__ */ new Set(),
+						lineIds: /* @__PURE__ */ new Set()
+					}), yt.current && window.setTimeout(() => {
+						bt.current(l, u, r.width, r.height, {
+							padding: 80,
+							preserveZoom: !0,
+							duration: 280
+						});
+					}, 0), dt.current = {
+						time: 0,
+						wx: 0,
+						wy: 0
+					};
+					return;
+				}
+				let i = dt.current, a = n.x - i.wx, o = n.y - i.wy;
+				if (t - i.time < 400 && Math.abs(a) < 10 && Math.abs(o) < 10) {
+					let e = z.current.nodes;
+					for (let t = e.length - 1; t >= 0; t--) if (f(n.x, n.y, e[t])) {
+						let n = e[t], r = n.data.childCanvasId;
+						if (r) {
+							Ke(r), dt.current = {
+								time: 0,
+								wx: 0,
+								wy: 0
+							};
+							return;
+						}
+						Nt.current("node", n.id, n.data.label ?? ""), dt.current = {
+							time: 0,
+							wx: 0,
+							wy: 0
+						};
+						return;
+					}
+					let t = z.current.edges, r = /* @__PURE__ */ new Map();
+					for (let t of e) r.set(t.id, t);
+					let i = Z.current?.state.zoom ?? 1;
+					for (let e = t.length - 1; e >= 0; e--) if (be(n.x, n.y, t[e], r, E(i, 8, 12))) {
+						Nt.current("edge", t[e].id, t[e].data.labelText ?? ""), dt.current = {
+							time: 0,
+							wx: 0,
+							wy: 0
+						};
+						return;
+					}
+				}
+				dt.current = {
+					time: t,
+					wx: n.x,
+					wy: n.y
+				};
+			});
+			let j = !1;
+			e.app.ticker.add((t) => {
+				if (e.destroyed) return;
+				let n = t.deltaMS, r = e.app.screen, i = Z.current?.state ?? {
+					x: 0,
+					y: 0,
+					zoom: 1
+				};
+				D.current?.update(i, r.width, r.height);
+				let a = Z.current?.isPanning ?? !1;
+				a !== j && (j = a, T.current && (T.current.style.cursor = a ? "grabbing" : ""));
+				let s = z.current, c = gt.current, l = ae(_t.current), u = /* @__PURE__ */ new Map();
+				l.forEach((e, t) => u.set(e.node.id, t + 1)), $e.current?.advanceAnimation(n);
+				let d = V.current ? l[V.current.current] : void 0;
+				$e.current?.sync(s.nodes, c.nodeIds, I.current, u, {
+					showAnchors: St.current,
+					presentation: V.current !== null,
+					presentationAnchorId: d?.node.id,
+					presentationAnchorVisible: V.current?.showAnchor ?? !1
+				});
+				let f = /* @__PURE__ */ new Map();
+				for (let e of s.nodes) f.set(e.id, e);
+				et.current?.advanceAnimation(n), et.current?.sync(s.edges, f, c.edgeIds, null, { presentation: V.current !== null }), tt.current?.advanceAnimation(n), tt.current?.sync(s.lines, c.lineIds), ot.current?.update(L.current, r.width, r.height, i);
+				let p = Xe.current;
+				if (p) {
+					let e = (c.nodeIds.size > 0 || c.edgeIds.size > 0 || c.lineIds.size > 0) && !Ze.current && !V.current && !Ct.current, t = !e;
+					if (e) {
+						let e = Infinity, n = Infinity, a = -Infinity, o = -Infinity, l = (t, r, i, s) => {
+							e = Math.min(e, t), n = Math.min(n, r), a = Math.max(a, t + i), o = Math.max(o, r + s);
+						};
+						for (let e of s.nodes) c.nodeIds.has(e.id) && l(e.position.x, e.position.y, e.width, e.height);
+						for (let e of s.edges) {
+							if (!c.edgeIds.has(e.id)) continue;
+							let t = f.get(e.source), n = f.get(e.target);
+							t && l(t.position.x, t.position.y, t.width, t.height), n && l(n.position.x, n.position.y, n.width, n.height);
+						}
+						for (let e of s.lines) if (c.lineIds.has(e.id)) for (let t of e.points) l(t.x, t.y, 0, 0);
+						if (e === Infinity) t = !0;
+						else {
+							let e = i.zoom, t = a * e + i.x + 8, o = n * e + i.y - 30 - 6;
+							t + 66 > r.width - 6 && (t = Math.max(6, r.width - 66 - 6)), o < 6 && (o = n * e + i.y + 6), o + 30 > r.height - 6 && (o = Math.max(6, r.height - 30 - 6)), p.style.display = "flex", p.style.left = `${Math.round(t)}px`, p.style.top = `${Math.round(o)}px`;
+						}
+					}
+					t && p.style.display !== "none" && (p.style.display = "none");
+				}
+				let m = at.current;
+				if (m) {
+					m.clear();
+					let e = st.current;
+					e && (m.circle(e.wx, e.wy, 10).fill({
+						color: 3900150,
+						alpha: .12
+					}).stroke({
+						color: 3900150,
+						width: 1.5,
+						alpha: .5
+					}), m.circle(e.wx, e.wy, 4).fill({
+						color: 3900150,
+						alpha: .9
+					}));
+					let t = ct.current;
+					t && !e && (m.circle(t.worldX, t.worldY, 10).fill({
+						color: 16347926,
+						alpha: .12
+					}).stroke({
+						color: 16347926,
+						width: 1.5,
+						alpha: .5
+					}), m.circle(t.worldX, t.worldY, 4).fill({
+						color: 16347926,
+						alpha: .9
+					}));
+				}
+				let h = pt.current;
+				if (h) {
+					h.clear();
+					let e = Ct.current;
+					if (e) {
+						let t = mt.current, n = P.current, r = Qe.current, i = pe(t.x - e.width / 2, n, r), a = pe(t.y - e.height / 2, n, r), c = {
+							id: "__ghost__",
+							type: e.type,
+							position: {
+								x: i,
+								y: a
+							},
+							width: e.width,
+							height: e.height,
+							data: {}
+						}, l = re([c], s.nodes);
+						L.current = l.guides, h.position.set(i + l.dx, a + l.dy), (o[e.type] ?? o.shapeRect)(h, {
+							width: e.width,
+							height: e.height,
+							fill: "#3b82f6",
+							stroke: "#3b82f6",
+							strokeWidth: 1.5,
+							borderStyle: e.data.borderStyle
+						});
+					} else h.position.set(0, 0), !U.current?.active && !Y.current?.active && (L.current = []);
+				}
+				let g = lt.current;
+				if (g && (g.clear(), c.edgeIds.size > 0 && vt.current === "select")) {
+					let e = 1 / i.zoom;
+					for (let t of s.edges) {
+						if (!c.edgeIds.has(t.id)) continue;
+						let n = _(t, f);
+						n && (g.circle(n.sx, n.sy, 5 * e).fill({ color: 16777215 }).stroke({
+							color: 16347926,
+							width: 1.5 * e
+						}), g.circle(n.tx, n.ty, 5 * e).fill({ color: 16777215 }).stroke({
+							color: 16347926,
+							width: 1.5 * e
+						}));
+						let r = t.data.waypoints;
+						if (r) for (let t of r) g.circle(t.x, t.y, 5 * e).fill({ color: 16777215 }).stroke({
+							color: 3900150,
+							width: 1.5 * e
+						});
+						if (t.type === "simplebezier") {
+							let n = _(t, f);
+							if (!n) continue;
+							let i = r ?? [], a = [
+								{
+									x: n.sx,
+									y: n.sy
+								},
+								...i,
+								{
+									x: n.tx,
+									y: n.ty
+								}
+							], o = t.data.bezierControls, s = a.length - 2;
+							for (let t = 0; t <= s; t++) {
+								let r = a[t], i = a[t + 1], c = o?.[t], l = Math.hypot(i.x - r.x, i.y - r.y), u = Math.max(30, l * .3), d = c?.c1x ?? (t === 0 ? r.x + n.snx * u : r.x + (i.x - r.x) * .4), f = c?.c1y ?? (t === 0 ? r.y + n.sny * u : r.y), p = c?.c2x ?? (t === s ? i.x + n.tnx * u : i.x - (i.x - r.x) * .4), m = c?.c2y ?? (t === s ? i.y + n.tny * u : i.y);
+								g.moveTo(r.x, r.y).lineTo(d, f).stroke({
+									color: 10265519,
+									width: 1 * e
+								}), g.moveTo(i.x, i.y).lineTo(p, m).stroke({
+									color: 10265519,
+									width: 1 * e
+								});
+								let h = 4 * e;
+								g.circle(d, f, h).fill({ color: 16777215 }).stroke({
+									color: 3900150,
+									width: 1.5 * e
+								}), g.circle(p, m, h).fill({ color: 16777215 }).stroke({
+									color: 3900150,
+									width: 1.5 * e
+								});
+							}
+						}
+					}
+				}
+				let v = it.current;
+				if (v && (v.clear(), c.nodeIds.size === 1 && vt.current === "select")) {
+					let e = [...c.nodeIds][0], t = s.nodes.find((t) => t.id === e);
+					if (t) {
+						let e = i.zoom, n = t.position.x * e + i.x, r = t.position.y * e + i.y, a = t.width * e, o = t.height * e;
+						v.rect(n, r, a, o).stroke({
+							color: 3900150,
+							width: 1.5
+						});
+						let s = 7 / 2, c = [
+							[n, r],
+							[n + a, r],
+							[n + a, r + o],
+							[n, r + o]
+						];
+						for (let [e, t] of c) v.rect(e - s, t - s, 7, 7).fill({ color: 16777215 }).stroke({
+							color: 3900150,
+							width: 1.5
+						});
+						let l = [
+							[n + a / 2, r],
+							[n + a, r + o / 2],
+							[n + a / 2, r + o],
+							[n, r + o / 2]
+						];
+						for (let [e, t] of l) v.circle(e, t, 4).fill({
+							color: 3900150,
+							alpha: .9
+						});
+						if (!Ze.current) {
+							let e = n + a / 2, t = r - de;
+							v.moveTo(e, r).lineTo(e, t).stroke({
+								color: 3900150,
+								width: 1.5,
+								alpha: .85
+							}), v.circle(e, t, 6).fill({ color: 16777215 }).stroke({
+								color: 3900150,
+								width: 1.5
+							}), v.circle(e, t, 2.5).fill({ color: 3900150 });
+						}
+					}
+				}
+			});
+		};
+		return g(), () => {
+			if (t = !0, e && !e.destroyed) try {
+				e.app.stage.removeAllListeners();
+			} catch {}
+			let i = T.current;
+			n && i?.removeEventListener("touchstart", n), r && i?.removeEventListener("touchmove", r), h && (i?.removeEventListener("touchend", h), i?.removeEventListener("touchcancel", h));
+			let a = (e) => {
+				try {
+					e?.destroy();
+				} catch {}
+			};
+			a(D.current), a(F.current), a($e.current), a(et.current), a(tt.current), a(nt.current), a(rt.current), a(J.current), a(it.current), it.current = null, a(at.current), at.current = null, a(lt.current), lt.current = null, a(pt.current), pt.current = null, a(ot.current);
+		};
+	}, [O.current]), b(() => {
+		let e = nt.current, t = rt.current;
+		if (e && t) switch (e.deactivate(), t.deactivate(), j) {
+			case "freehand":
+				e.activate();
+				break;
+			case "line":
+				t.activate("straight");
+				break;
+			case "polyline":
+				t.activate("polyline");
+				break;
+			case "arrow": t.activate("arrow");
+		}
+	}, [j]), b(() => {
+		D.current && (D.current.visible = Oe, D.current.gridSize = ke);
+	}, [Oe, ke]), b(() => {
+		let e = T.current;
+		if (!e) return;
+		let t = (t) => {
+			t.preventDefault();
+			let n = Z.current;
+			if (!n) return;
+			let r = e.getBoundingClientRect(), i = t.clientX - r.left, a = t.clientY - r.top, o = t.ctrlKey ? 3 : 1, s = -t.deltaY * .001 * o;
+			n.zoomAt(i, a, 1 + s);
+		};
+		return e.addEventListener("wheel", t, { passive: !1 }), () => e.removeEventListener("wheel", t);
+	}, [Z]), /* @__PURE__ */ w("div", {
+		style: {
+			position: "relative",
+			width: "100%",
+			height: "100%"
+		},
+		children: [
+			/* @__PURE__ */ C("div", {
+				ref: T,
+				className: "flow-canvas-wrapper",
+				tabIndex: -1,
+				onContextMenu: (e) => e.preventDefault()
+			}),
+			$ && At && /* @__PURE__ */ C("input", {
+				className: "flow-label-editor",
+				autoFocus: !0,
+				defaultValue: $.value,
+				style: {
+					left: At.x,
+					top: At.y
+				},
+				onFocus: (e) => e.currentTarget.select(),
+				onKeyDown: (e) => {
+					e.key === "Enter" ? (e.preventDefault(), Pt(e.target.value)) : e.key === "Escape" && (e.preventDefault(), Ft()), e.stopPropagation();
+				},
+				onBlur: (e) => Pt(e.target.value),
+				onPointerDown: (e) => e.stopPropagation()
+			}),
+			Ne && !Re && /* @__PURE__ */ w("button", {
+				type: "button",
+				className: "flow-esc-button",
+				onClick: () => Pe(null),
+				title: "取消连续放置 (Esc)",
+				children: [/* @__PURE__ */ C("span", {
+					"aria-hidden": !0,
+					children: "⎋"
+				}), " 取消放置 (ESC)"]
+			}),
+			/* @__PURE__ */ w("button", {
+				ref: Xe,
+				type: "button",
+				className: "flow-delete-button",
+				style: { display: "none" },
+				onClick: () => Ye.current(),
+				title: "删除所选 (Delete)",
+				"aria-label": "删除所选",
+				children: [/* @__PURE__ */ w("svg", {
+					width: "12",
+					height: "12",
+					viewBox: "0 0 24 24",
+					fill: "none",
+					stroke: "currentColor",
+					strokeWidth: "2.5",
+					strokeLinecap: "round",
+					strokeLinejoin: "round",
+					"aria-hidden": !0,
+					children: [
+						/* @__PURE__ */ C("path", { d: "M3 6h18" }),
+						/* @__PURE__ */ C("path", { d: "M19 6v14a2 2 0 0 1-2 2H7a2 2 0 0 1-2-2V6" }),
+						/* @__PURE__ */ C("path", { d: "M8 6V4a2 2 0 0 1 2-2h4a2 2 0 0 1 2 2v2" })
+					]
+				}), "删除"]
+			})
+		]
+	});
 }
-export {
-  yr as default
-};
+//#endregion
+export { D as default };
 
 //# sourceMappingURL=FlowCanvas.js.map