dishui 0.0.45 → 0.0.46

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

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