dishui 0.0.62 → 0.0.65

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

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