dishui 0.0.57 → 0.0.59

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

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