@infinit-canvas/react 0.1.0

package/dist/react-infinite-canvas.js

@@ -0,0 +1,4555 @@
+import { jsx as B, jsxs as It, Fragment as Le } from "react/jsx-runtime";
+import { useRef as V, useState as Gt, useMemo as St, useEffect as ut, useCallback as F, useContext as qe, createContext as Fn, memo as Zt, useLayoutEffect as kr } from "react";
+import { createPortal as Yn } from "react-dom";
+const Un = 160, qn = 60;
+function ho(t) {
+  return t && typeof t == "object" && "position" in t && "data" in t;
+}
+function yo(t) {
+  return t && typeof t == "object" && "source" in t && "target" in t;
+}
+function zr(t, e) {
+  const n = typeof t == "string" ? /* @__PURE__ */ new Set([t]) : new Set(Array.isArray(t) ? t.map((r) => r.id) : [t.id]);
+  return e.filter((r) => n.has(r.source) || n.has(r.target));
+}
+function go(t, e, n) {
+  const r = typeof t == "string" ? t : t.id, s = /* @__PURE__ */ new Set();
+  for (const o of n)
+    o.target === r && s.add(o.source);
+  return e.filter((o) => s.has(o.id));
+}
+function po(t, e, n) {
+  const r = typeof t == "string" ? t : t.id, s = /* @__PURE__ */ new Set();
+  for (const o of n)
+    o.source === r && s.add(o.target);
+  return e.filter((o) => s.has(o.id));
+}
+function Mn(t) {
+  if (!t.length) return { x: 0, y: 0, width: 0, height: 0 };
+  let e = 1 / 0, n = 1 / 0, r = -1 / 0, s = -1 / 0;
+  for (const o of t) {
+    const i = o.position.x, c = o.position.y, u = o.width || Un, l = o.height || qn;
+    i < e && (e = i), c < n && (n = c), i + u > r && (r = i + u), c + l > s && (s = c + l);
+  }
+  return { x: e, y: n, width: r - e, height: s - n };
+}
+function Rn(t, e, n, r = 0.1) {
+  const s = t.width * (1 + r * 2), o = t.height * (1 + r * 2), i = Math.min(e / s, n / o, 1), c = t.x + t.width / 2, u = t.y + t.height / 2;
+  return {
+    x: e / 2 - c * i,
+    y: n / 2 - u * i,
+    zoom: i
+  };
+}
+function Pn(t, e) {
+  return {
+    x: e[0] * Math.round(t.x / e[0]),
+    y: e[1] * Math.round(t.y / e[1])
+  };
+}
+function Tn(t, e) {
+  return {
+    x: Math.min(Math.max(t.x, e[0][0]), e[1][0]),
+    y: Math.min(Math.max(t.y, e[0][1]), e[1][1])
+  };
+}
+function jn(t) {
+  var e, n;
+  return {
+    width: t.width || ((e = t.measured) == null ? void 0 : e.width) || Un,
+    height: t.height || ((n = t.measured) == null ? void 0 : n.height) || qn
+  };
+}
+function xo(t, e, n = { x: 0, y: 0, zoom: 1 }, r = !1) {
+  const s = e.x, o = e.y, i = e.x + e.width, c = e.y + e.height;
+  return t.filter((u) => {
+    const { width: l, height: g } = jn(u), v = u.position.x, E = u.position.y, R = v + l, M = E + g;
+    return r ? v < i && R > s && E < c && M > o : v >= s && R <= i && E >= o && M <= c;
+  });
+}
+function mo(t) {
+  return { x: t.x, y: t.y, x2: t.x + t.width, y2: t.y + t.height };
+}
+function vo(t) {
+  return { x: t.x, y: t.y, width: t.x2 - t.x, height: t.y2 - t.y };
+}
+function wo(t, e) {
+  return {
+    x: Math.min(t.x, e.x),
+    y: Math.min(t.y, e.y),
+    x2: Math.max(t.x2, e.x2),
+    y2: Math.max(t.y2, e.y2)
+  };
+}
+function bo(t, e) {
+  const n = Math.max(0, Math.min(t.x + t.width, e.x + e.width) - Math.max(t.x, e.x)), r = Math.max(0, Math.min(t.y + t.height, e.y + e.height) - Math.max(t.y, e.y));
+  return n * r;
+}
+function Mo(t) {
+  const { width: e, height: n } = jn(t);
+  return { x: t.position.x, y: t.position.y, width: e, height: n };
+}
+const Gn = `var Ma = null, r = null, tr = 0, er = 0, g = { x: 0, y: 0, zoom: 1 }, O = [], B = [], P = [], G = !1, Ht = 40, Dt = !1, Br = "lines", Or = 1, lt = null, Pa = null, hr = null, E = 160, c = 60, ft = 8, ao = 5;
+function h(a) {
+  return a._absolutePosition || a.position;
+}
+function Vo(a, t, e, o, v) {
+  if (a.x !== void 0 && a.y !== void 0)
+    return { x: t + a.x, y: e + a.y };
+  var f = a.position || (a.type === "source" ? "right" : "left");
+  switch (f) {
+    case "top":
+      return { x: t + o / 2, y: e };
+    case "bottom":
+      return { x: t + o / 2, y: e + v };
+    case "left":
+      return { x: t, y: e + v / 2 };
+    case "right":
+      return { x: t + o, y: e + v / 2 };
+    default:
+      return { x: t + o, y: e + v / 2 };
+  }
+}
+function ho(a) {
+  var t = a.width || E, e = a.height || c;
+  return a.handles && a.handles.length > 0 ? a.handles.map(function(o) {
+    var v = Vo(o, h(a).x, h(a).y, t, e);
+    return { id: o.id || null, type: o.type, x: v.x, y: v.y, position: o.position };
+  }) : [
+    { id: null, type: "target", x: h(a).x, y: h(a).y + e / 2, position: "left" },
+    { id: null, type: "source", x: h(a).x + t, y: h(a).y + e / 2, position: "right" }
+  ];
+}
+var Ft = {}, Ka = !0;
+function Uo(a) {
+  Ka && (Ft = {}, Ka = !1);
+  var t = Ft[a.id];
+  return t || (t = ho(a), Ft[a.id] = t, t);
+}
+function it(a, t, e) {
+  for (var o = Uo(a), v = 0; v < o.length; v++)
+    if (o[v].type === t)
+      if (e) {
+        if (o[v].id === e) return o[v];
+      } else
+        return o[v];
+  var f = a.width || E, l = a.height || c;
+  return t === "source" ? { x: h(a).x + f, y: h(a).y + l / 2 } : { x: h(a).x, y: h(a).y + l / 2 };
+}
+var z = {};
+function Yt() {
+  z = {
+    grid: G ? "rgba(255,255,255,0.07)" : "rgba(0,0,0,0.07)",
+    origin: G ? "rgba(255,255,255,0.2)" : "rgba(0,0,0,0.15)",
+    cardBg: G ? "#2a2a28" : "#ffffff",
+    cardBorder: G ? "rgba(255,255,255,0.1)" : "rgba(0,0,0,0.1)",
+    cardShadow: G ? "rgba(0,0,0,0.3)" : "rgba(0,0,0,0.06)",
+    titleText: "rgba(255,255,255,0.9)",
+    bodyText: G ? "rgba(255,255,255,0.55)" : "rgba(0,0,0,0.5)",
+    coordText: G ? "rgba(255,255,255,0.25)" : "rgba(0,0,0,0.2)",
+    nodeBg: G ? "#1e1e2e" : "#ffffff",
+    nodeBorder: G ? "rgba(255,255,255,0.15)" : "rgba(0,0,0,0.15)",
+    nodeSelectedBorder: "#3b82f6",
+    nodeShadow: G ? "rgba(0,0,0,0.4)" : "rgba(0,0,0,0.08)",
+    nodeText: G ? "rgba(255,255,255,0.9)" : "rgba(0,0,0,0.85)",
+    edgeStroke: G ? "rgba(255,255,255,0.35)" : "rgba(0,0,0,0.3)",
+    edgeSelected: "#3b82f6",
+    edgeAnimated: "#3b82f6",
+    handleFill: "#ffffff",
+    handleBorder: "#3b82f6",
+    connectionLine: "#3b82f6"
+  }, xa = !0;
+}
+Yt();
+var Do = ["#534AB7", "#0F6E56", "#993C1D", "#185FA5"], Ga = 8, Fo = "500 11px system-ui, sans-serif", jo = "400 11px system-ui, sans-serif", Oo = "10px monospace", Xo = "500 13px system-ui, sans-serif", Ho = "400 11px system-ui, sans-serif", br = 400, Ia = {}, ht = !0;
+function Yo() {
+  Ia = {};
+  for (var a = 0; a < O.length; a++)
+    for (var t = O[a], e = Math.floor(t.x / br), o = Math.floor(t.y / br), v = Math.floor((t.x + t.w) / br), f = Math.floor((t.y + t.h) / br), l = e; l <= v; l++)
+      for (var y = o; y <= f; y++) {
+        var d = l + "," + y;
+        Ia[d] || (Ia[d] = []), Ia[d].push(a);
+      }
+  ht = !1;
+}
+function to(a, t, e, o) {
+  ht && Yo();
+  for (var v = {}, f = [], l = Math.floor(a / br), y = Math.floor(t / br), d = Math.floor(e / br), M = Math.floor(o / br), x = l; x <= d; x++)
+    for (var i = y; i <= M; i++) {
+      var n = x + "," + i, s = Ia[n];
+      if (s)
+        for (var u = 0; u < s.length; u++) {
+          var w = s[u];
+          v[w] || (v[w] = !0, f.push(w));
+        }
+    }
+  return f;
+}
+var Nr = 500, Za = {}, Xr = !0;
+function te() {
+  Za = {};
+  for (var a = 0; a < B.length; a++) {
+    var t = B[a];
+    if (!t.hidden)
+      for (var e = h(t), o = t.width || E, v = t.height || c, f = Math.floor(e.x / Nr), l = Math.floor(e.y / Nr), y = Math.floor((e.x + o) / Nr), d = Math.floor((e.y + v) / Nr), M = f; M <= y; M++)
+        for (var x = l; x <= d; x++) {
+          var i = M + "," + x;
+          Za[i] || (Za[i] = []), Za[i].push(a);
+        }
+  }
+  Xr = !1;
+}
+function no(a, t, e, o) {
+  Xr && te();
+  for (var v = {}, f = [], l = Math.floor(a / Nr), y = Math.floor(t / Nr), d = Math.floor(e / Nr), M = Math.floor(o / Nr), x = l; x <= d; x++)
+    for (var i = y; i <= M; i++) {
+      var n = x + "," + i, s = Za[n];
+      if (s)
+        for (var u = 0; u < s.length; u++) {
+          var w = s[u];
+          v[w] || (v[w] = !0, f.push(w));
+        }
+    }
+  return f;
+}
+var ka = {}, ya = !0;
+function ee() {
+  ka = {};
+  for (var a = 0; a < B.length; a++)
+    ka[B[a].id] = B[a];
+  ya = !1;
+}
+function eo(a) {
+  return ya && ee(), ka[a];
+}
+var Cr = {}, nt = !0;
+function po() {
+  Cr = {};
+  for (var a = 0; a < P.length; a++) {
+    var t = P[a];
+    Cr[t.source] || (Cr[t.source] = []), Cr[t.source].push(a), t.source !== t.target && (Cr[t.target] || (Cr[t.target] = []), Cr[t.target].push(a));
+  }
+  nt = !1;
+}
+var jr = null, uo = 0, so = 0, Mo = "", xa = !0;
+function rf(a) {
+  jr || (jr = new OffscreenCanvas(1, 1));
+  var t = Math.ceil(a), e = Math.ceil(a);
+  if (t < 2 || e < 2) return !1;
+  t > 512 && (t = 512), e > 512 && (e = 512), jr.width = t, jr.height = e, uo = t, so = a, Mo = Br, xa = !1;
+  var o = jr.getContext("2d");
+  o.clearRect(0, 0, t, e);
+  var v = lt || z.grid;
+  if (Br === "dots") {
+    o.fillStyle = v;
+    var f = Or * g.zoom;
+    o.beginPath(), o.arc(0, 0, f, 0, 6.2832), o.fill();
+  } else if (Br === "cross") {
+    o.strokeStyle = v, o.lineWidth = Or;
+    var l = 3 * g.zoom;
+    o.beginPath(), o.moveTo(-l, 0), o.lineTo(l, 0), o.moveTo(0, -l), o.lineTo(0, l), o.stroke();
+  } else
+    o.beginPath(), o.strokeStyle = v, o.lineWidth = Or * 0.5, o.moveTo(0.5, 0), o.lineTo(0.5, e), o.moveTo(0, 0.5), o.lineTo(t, 0.5), o.stroke();
+  return !0;
+}
+var oo = 0, jt = 0, fo = 0, vo = 0, pt = 0, Ja = !1;
+console.log("[worker] script loaded v2 - FRESH");
+self.postMessage({ type: "ping", data: { status: "alive" } });
+self.onmessage = function(a) {
+  try {
+    var t = a.data.type, e = a.data.data;
+    switch (t) {
+      case "init":
+        Ma = e.canvas, r = Ma.getContext("2d"), tr = e.width, er = e.height, Ma.width = tr, Ma.height = er, g = e.camera, O = e.cards || [], B = e.nodes || [], P = e.edges || [], G = e.dark, e.gridSize && (Ht = e.gridSize), e.edgeRouting !== void 0 && (ga = !!e.edgeRouting), Yt(), ht = !0, ya = !0, Xr = !0, Ka = !0, nt = !0, Ja = P.some(function(d) {
+          return d.animated;
+        }), console.log("[worker] init done — canvas:", tr, "x", er, "| cards:", O.length, "| nodes:", B.length, "| edges:", P.length, "| routing:", ga), ut(), self.postMessage({ type: "ready" }), Ja && lo();
+        break;
+      case "resize":
+        tr = e.width, er = e.height, Ma.width = tr, Ma.height = er, xa = !0, ut();
+        break;
+      case "camera":
+        g = e.camera, xa = !0, or();
+        break;
+      case "cards":
+        O = e.cards, ht = !0, or();
+        break;
+      case "nodes":
+        B = e.nodes, ya = !0, Xr = !0, Ka = !0, or(), vt(), self.postMessage({ type: "nodesProcessed", data: { nodeCount: B.length } });
+        break;
+      case "nodePositions":
+        ya && ee();
+        for (var o = e.updates, v = 0; v < o.length; v++) {
+          var f = o[v], l = ka[f.id];
+          l && (l.position = f.position, f._absolutePosition && (l._absolutePosition = f._absolutePosition), f.width !== void 0 && (l.width = f.width), f.height !== void 0 && (l.height = f.height), l.dragging = f.dragging, l.selected = f.selected);
+        }
+        Ka = !0, Xr = !0, or(), vt();
+        break;
+      case "edges":
+        P = e.edges, nt = !0, Ja = P.some(function(d) {
+          return d.animated;
+        }), Ja && lo(), or(), vt();
+        break;
+      case "theme":
+        G = e.dark, Yt(), or();
+        break;
+      case "connecting":
+        Pa = e, or();
+        break;
+      case "selectionBox":
+        hr = e, or();
+        break;
+      case "background":
+        e.variant && (Br = e.variant), e.gap && (Ht = e.gap), e.size && (Or = e.size), lt = e.color || null, xa = !0, or();
+        break;
+      case "edgeRouting":
+        if (ga = !!e.enabled, ga)
+          vt();
+        else {
+          for (var y = 0; y < P.length; y++)
+            P[y]._routedPoints = null;
+          or();
+        }
+        break;
+    }
+  } catch (d) {
+    console.error("[worker] error:", d);
+  }
+};
+function or() {
+  Dt || (Dt = !0, requestAnimationFrame(function() {
+    Dt = !1, ut();
+  }));
+}
+var Ot = !1;
+function lo() {
+  if (Ot) return;
+  Ot = !0;
+  function a() {
+    if (!Ja) {
+      Ot = !1;
+      return;
+    }
+    pt = (pt + 0.5) % 20, ut(), requestAnimationFrame(a);
+  }
+  requestAnimationFrame(a);
+}
+function io(a, t) {
+  var e = 6;
+  a.moveTo(t[0].x, t[0].y);
+  for (var o = 1; o < t.length - 1; o++) {
+    var v = t[o - 1], f = t[o], l = t[o + 1], y = Math.abs(f.x - v.x) + Math.abs(f.y - v.y), d = Math.abs(l.x - f.x) + Math.abs(l.y - f.y), M = Math.min(e, y / 2, d / 2);
+    if (M > 0.5) {
+      var x = f.x - v.x, i = f.y - v.y, n = l.x - f.x, s = l.y - f.y, u = Math.sqrt(x * x + i * i) || 1, w = Math.sqrt(n * n + s * s) || 1;
+      a.lineTo(f.x - x / u * M, f.y - i / u * M), a.quadraticCurveTo(f.x, f.y, f.x + n / w * M, f.y + s / w * M);
+    } else
+      a.lineTo(f.x, f.y);
+  }
+  a.lineTo(t[t.length - 1].x, t[t.length - 1].y);
+}
+function af(a) {
+  for (var t = 0, e = 1; e < a.length; e++)
+    t += Math.abs(a[e].x - a[e - 1].x) + Math.abs(a[e].y - a[e - 1].y);
+  for (var o = t / 2, v = 1; v < a.length; v++) {
+    var f = Math.abs(a[v].x - a[v - 1].x) + Math.abs(a[v].y - a[v - 1].y);
+    if (o <= f) {
+      var l = f > 0 ? o / f : 0;
+      return {
+        x: a[v - 1].x + (a[v].x - a[v - 1].x) * l,
+        y: a[v - 1].y + (a[v].y - a[v - 1].y) * l
+      };
+    }
+    o -= f;
+  }
+  return { x: a[0].x, y: a[0].y };
+}
+function re(a, t, e, o) {
+  var v = Math.abs(e - a), f = Math.max(50, v * 0.5), l = a + f, y = t, d = e - f, M = o;
+  return { cp1x: l, cp1y: y, cp2x: d, cp2y: M };
+}
+function tf(a, t, e, o) {
+  var v = re(a, t, e, o), f = 0.5, l = 1 - f, y = l * l * l * a + 3 * l * l * f * v.cp1x + 3 * l * f * f * v.cp2x + f * f * f * e, d = l * l * l * t + 3 * l * l * f * v.cp1y + 3 * l * f * f * v.cp2y + f * f * f * o;
+  return { x: y, y: d };
+}
+var ga = !0, ae = !1, Xt = !1;
+function go(a, t, e, o, v) {
+  Xr && te();
+  for (var f = Math.min(a, e) - 20, l = Math.min(t, o) - 20, y = Math.max(a, e) + 20, d = Math.max(t, o) + 20, M = no(f, l, y, d), x = [], i = 0; i < M.length; i++) {
+    var n = B[M[i]];
+    n.hidden || v[n.id] || n.type !== "group" && x.push(n);
+  }
+  return x;
+}
+function dr(a, t, e, o) {
+  for (var v = Math.min(a, t), f = Math.max(a, t), l = 0; l < o.length; l++) {
+    var y = o[l], d = h(y), M = y.width || E, x = y.height || c;
+    if (e > d.y && e < d.y + x && f > d.x && v < d.x + M) return y;
+  }
+  return null;
+}
+function Mr(a, t, e, o) {
+  for (var v = Math.min(t, e), f = Math.max(t, e), l = 0; l < o.length; l++) {
+    var y = o[l], d = h(y), M = y.width || E, x = y.height || c;
+    if (a > d.x && a < d.x + M && f > d.y && v < d.y + x) return y;
+  }
+  return null;
+}
+function ef() {
+  if (ga && !(!ae || P.length === 0 || B.length === 0)) {
+    ae = !1, ya && ee(), Xr && te();
+    for (var a = 20, t = !1, e = 0; e < P.length; e++) {
+      var o = P[e];
+      if (!o._customRendered) {
+        var v = o.type || "default";
+        if (!(v === "bezier" || v === "simplebezier" || v === "default")) {
+          var f = ka[o.source], l = ka[o.target];
+          if (!(!f || !l || f.hidden || l.hidden)) {
+            var y = it(f, "source", o.sourceHandle), d = it(l, "target", o.targetHandle), M = y.position || "right", x = d.position || "left", i = y.x, n = y.y, s = d.x, u = d.y, w = i, Q = n, W = s, $ = u;
+            M === "right" ? w += a : M === "left" ? w -= a : M === "bottom" ? Q += a : M === "top" && (Q -= a), x === "right" ? W += a : x === "left" ? W -= a : x === "bottom" ? $ += a : x === "top" && ($ -= a);
+            var gr = h(f), qr = h(l), Sr = f.width || E, Gr = f.height || c, Pr = l.width || E, Hr = l.height || c, Ir = {};
+            Ir[o.source] = !0, Ir[o.target] = !0;
+            var X = go(
+              Math.min(i, s) - Sr,
+              Math.min(n, u) - Gr,
+              Math.max(i, s) + Pr,
+              Math.max(n, u) + Hr,
+              Ir
+            );
+            X.push(f), X.push(l);
+            var Yr = M === "left" || M === "right", Ta = x === "left" || x === "right", C = null;
+            if (Yr && Ta) {
+              var L, fr = M === "right" && w < W, st = M === "left" && w > W;
+              if (fr || st) {
+                L = (w + W) / 2;
+                var ma = Mr(L, n, u, X);
+                if (ma) {
+                  var pr = h(ma), ra = ma.width || E;
+                  L = L < pr.x + ra / 2 ? pr.x - a : pr.x + ra + a;
+                }
+              } else
+                M === "right" ? L = Math.max(gr.x + Sr, qr.x + Pr) + a : L = Math.min(gr.x, qr.x) - a;
+              C = [{ x: i, y: n }, { x: w, y: n }, { x: L, y: n }, { x: L, y: u }, { x: W, y: u }, { x: s, y: u }];
+              var yr = dr(L, W, u, X);
+              if (yr) {
+                var aa = h(yr), ta = yr.height || c, ea = aa.y - a, Zr = aa.y + ta + a, Jr = Math.abs(n - ea) <= Math.abs(n - Zr) ? ea : Zr;
+                C = [{ x: i, y: n }, { x: w, y: n }, { x: L, y: n }, { x: L, y: Jr }, { x: W, y: Jr }, { x: W, y: u }, { x: s, y: u }];
+              }
+            } else if (!Yr && !Ta) {
+              var N, Qa = M === "bottom" && Q < $, Ra = M === "top" && Q > $;
+              if (Qa || Ra) {
+                N = (Q + $) / 2;
+                var xr = dr(i, s, N, X);
+                if (xr) {
+                  var kr = h(xr), oa = xr.height || c;
+                  N = N < kr.y + oa / 2 ? kr.y - a : kr.y + oa + a;
+                }
+              } else
+                M === "bottom" ? N = Math.max(gr.y + Gr, qr.y + Hr) + a : N = Math.min(gr.y, qr.y) - a;
+              C = [{ x: i, y: n }, { x: i, y: Q }, { x: i, y: N }, { x: s, y: N }, { x: s, y: $ }, { x: s, y: u }];
+              var Kr = Mr(s, N, $, X);
+              if (Kr) {
+                var fa = h(Kr), wa = Kr.height || c, va = fa.y - a, la = fa.y + wa + a, ia = Math.abs(N - va) <= Math.abs(N - la) ? va : la;
+                C = [{ x: i, y: n }, { x: i, y: Q }, { x: i, y: N }, { x: s, y: N }, { x: s, y: ia }, { x: W, y: ia }, { x: W, y: u }, { x: s, y: u }];
+              }
+            } else if (Yr) {
+              C = [{ x: i, y: n }, { x: w, y: n }, { x: s, y: n }, { x: s, y: $ }, { x: s, y: u }];
+              var Tr = Mr(s, n, $, X);
+              if (Tr) {
+                var V = h(Tr), mr = Tr.width || E, za = Math.abs(i - V.x + a) <= Math.abs(i - V.x - mr - a) ? V.x - a : V.x + mr + a;
+                C = [{ x: i, y: n }, { x: w, y: n }, { x: za, y: n }, { x: za, y: u }, { x: s, y: u }, { x: s, y: $ }, { x: s, y: u }];
+              }
+              var Qr = dr(w, s, n, X);
+              if (Qr) {
+                var Rr = h(Qr), ha = Qr.height || c, H = Math.abs(u - Rr.y + a) <= Math.abs(u - Rr.y - ha - a) ? Rr.y - a : Rr.y + ha + a;
+                C = [{ x: i, y: n }, { x: w, y: n }, { x: w, y: H }, { x: s, y: H }, { x: s, y: $ }, { x: s, y: u }];
+              }
+            } else {
+              C = [{ x: i, y: n }, { x: i, y: Q }, { x: i, y: u }, { x: W, y: u }, { x: s, y: u }];
+              var wr = dr(i, W, u, X);
+              if (wr) {
+                var na = h(wr), U = wr.height || c, zr = Math.abs(n - na.y + a) <= Math.abs(n - na.y - U - a) ? na.y - a : na.y + U + a;
+                C = [{ x: i, y: n }, { x: i, y: Q }, { x: i, y: zr }, { x: W, y: zr }, { x: W, y: u }, { x: s, y: u }];
+              }
+              var nr = Mr(i, Q, u, X);
+              if (nr) {
+                var vr = h(nr), ca = nr.width || E, _a = Math.abs(s - vr.x + a) <= Math.abs(s - vr.x - ca - a) ? vr.x - a : vr.x + ca + a;
+                C = [{ x: i, y: n }, { x: i, y: Q }, { x: _a, y: Q }, { x: _a, y: u }, { x: W, y: u }, { x: s, y: u }];
+              }
+            }
+            if (C) {
+              for (var $r = [C[0]], lr = 1; lr < C.length; lr++) {
+                var $a = $r[$r.length - 1];
+                (Math.abs(C[lr].x - $a.x) > 0.1 || Math.abs(C[lr].y - $a.y) > 0.1) && $r.push(C[lr]);
+              }
+              o._routedPoints = $r, t = !0;
+            }
+          }
+        }
+      }
+    }
+    t && or();
+  }
+}
+function vt() {
+  ga && (Xt || (Xt = !0, ae = !0, requestAnimationFrame(function() {
+    Xt = !1;
+    try {
+      ef();
+    } catch (a) {
+      console.error("[worker] async routing error:", a);
+    }
+  })));
+}
+function ut() {
+  if (r) {
+    var a = performance.now();
+    r.clearRect(0, 0, tr, er);
+    var t = Ht * g.zoom;
+    if (t > 2)
+      if (Br === "lines" && t >= 4 && t <= 512) {
+        if ((xa || so !== t || Mo !== Br) && rf(t), jr && uo > 0) {
+          var e = (g.x % t + t) % t, o = (g.y % t + t) % t;
+          r.save(), r.translate(e, o);
+          var v = r.createPattern(jr, "repeat");
+          v && (r.fillStyle = v, r.fillRect(-e, -o, tr, er)), r.restore();
+        }
+      } else {
+        var f = (g.x % t + t) % t, l = (g.y % t + t) % t, y = lt || z.grid;
+        if (Br === "dots") {
+          r.fillStyle = y;
+          for (var d = Or * g.zoom, M = f; M < tr; M += t)
+            for (var x = l; x < er; x += t)
+              r.beginPath(), r.arc(Math.round(M), Math.round(x), d, 0, 6.2832), r.fill();
+        } else if (Br === "cross") {
+          r.strokeStyle = y, r.lineWidth = Or;
+          var i = 3 * g.zoom;
+          r.beginPath();
+          for (var n = f; n < tr; n += t)
+            for (var s = l; s < er; s += t) {
+              var u = Math.round(n), w = Math.round(s);
+              r.moveTo(u - i, w), r.lineTo(u + i, w), r.moveTo(u, w - i), r.lineTo(u, w + i);
+            }
+          r.stroke();
+        } else {
+          var Q = lt || z.grid;
+          r.beginPath(), r.strokeStyle = Q, r.lineWidth = Or * 0.5;
+          for (var W = f; W < tr; W += t) {
+            var $ = Math.round(W) + 0.5;
+            r.moveTo($, 0), r.lineTo($, er);
+          }
+          for (var gr = l; gr < er; gr += t) {
+            var qr = Math.round(gr) + 0.5;
+            r.moveTo(0, qr), r.lineTo(tr, qr);
+          }
+          r.stroke();
+        }
+      }
+    r.beginPath(), r.arc(g.x, g.y, 4 * g.zoom, 0, 6.2832), r.fillStyle = z.origin, r.fill(), r.save(), r.translate(g.x, g.y), r.scale(g.zoom, g.zoom);
+    var Sr = 100, Gr = -g.x / g.zoom, Pr = -g.y / g.zoom, Hr = Gr + tr / g.zoom, Ir = Pr + er / g.zoom, X = Gr - Sr, Yr = Pr - Sr, Ta = Hr + Sr, C = Ir + Sr;
+    if (O.length > 0) {
+      var L = to(Gr, Pr, Hr, Ir), fr = L.length, st = g.zoom > 0.15, ma = g.zoom > 0.3, pr = g.zoom > 0.08 && fr < 200;
+      if (pr) {
+        r.shadowColor = z.cardShadow, r.shadowBlur = 6, r.shadowOffsetY = 2, r.fillStyle = z.cardBg, r.beginPath();
+        for (var ra = 0; ra < fr; ra++) {
+          var yr = O[L[ra]];
+          r.roundRect(yr.x, yr.y, yr.w, yr.h, Ga);
+        }
+        r.fill(), r.shadowColor = "transparent", r.shadowBlur = 0, r.shadowOffsetY = 0;
+      }
+      if (!pr) {
+        r.fillStyle = z.cardBg, r.beginPath();
+        for (var aa = 0; aa < fr; aa++) {
+          var ta = O[L[aa]];
+          r.roundRect(ta.x, ta.y, ta.w, ta.h, Ga);
+        }
+        r.fill();
+      }
+      r.strokeStyle = z.cardBorder, r.lineWidth = 0.5, r.beginPath();
+      for (var ea = 0; ea < fr; ea++) {
+        var Zr = O[L[ea]];
+        r.roundRect(Zr.x, Zr.y, Zr.w, Zr.h, Ga);
+      }
+      r.stroke();
+      for (var Jr = [{}, {}, {}, {}], N = 0; N < fr; N++) {
+        var Qa = L[N], Ra = Qa % 4;
+        Jr[Ra].items || (Jr[Ra].items = []), Jr[Ra].items.push(O[Qa]);
+      }
+      for (var xr = 0; xr < 4; xr++) {
+        var kr = Jr[xr].items;
+        if (!(!kr || kr.length === 0)) {
+          r.fillStyle = Do[xr], r.beginPath();
+          for (var oa = 0; oa < kr.length; oa++) {
+            var Kr = kr[oa];
+            r.roundRect(Kr.x, Kr.y, Kr.w, 30, [Ga, Ga, 0, 0]);
+          }
+          r.fill();
+        }
+      }
+      if (st) {
+        r.fillStyle = z.titleText, r.font = Fo;
+        for (var fa = 0; fa < fr; fa++) {
+          var wa = O[L[fa]];
+          r.fillText(wa.title, wa.x + 12, wa.y + 19);
+        }
+        r.fillStyle = z.bodyText, r.font = jo;
+        for (var va = 0; va < fr; va++) {
+          var la = O[L[va]];
+          r.fillText(la.body, la.x + 12, la.y + 52);
+        }
+        if (ma) {
+          r.fillStyle = z.coordText, r.font = Oo;
+          for (var ia = 0; ia < fr; ia++) {
+            var Tr = O[L[ia]];
+            r.fillText("(" + Tr.x + ", " + Tr.y + ")", Tr.x + 12, Tr.y + 75);
+          }
+        }
+      }
+    }
+    var V = [], mr = null;
+    if (B.length > 0)
+      if (mr = {}, B.length > 100)
+        for (var za = no(X, Yr, Ta, C), Qr = 0; Qr < za.length; Qr++) {
+          var Rr = B[za[Qr]];
+          mr[Rr.id] = !0, Rr._customRendered || V.push(Rr);
+        }
+      else
+        for (var ha = 0; ha < B.length; ha++) {
+          var H = B[ha];
+          if (!H.hidden) {
+            var wr = H.width || E, na = H.height || c;
+            h(H).x + wr < X || h(H).x > Ta || h(H).y + na < Yr || h(H).y > C || (mr[H.id] = !0, H._customRendered || V.push(H));
+          }
+        }
+    var U = V.length;
+    if (P.length > 0 && B.length > 0) {
+      let ot = function(Lr, ro) {
+        if (Lr.length) {
+          r.fillStyle = ro, r.beginPath();
+          for (var Ut = 0; Ut < Lr.length; Ut++) {
+            var j = Lr[Ut];
+            r.moveTo(j.x, j.y), r.lineTo(j.x - j.size * Math.cos(j.angle - 0.5236), j.y - j.size * Math.sin(j.angle - 0.5236)), r.lineTo(j.x - j.size * Math.cos(j.angle + 0.5236), j.y - j.size * Math.sin(j.angle + 0.5236)), r.closePath();
+          }
+          r.fill();
+        }
+      };
+      var of = ot;
+      nt && po();
+      var zr = null, nr = null, vr = null, ca = [], _a = [], $r = [], lr = [], $a = g.zoom > 0.3, yo = g.zoom > 0.05, ua;
+      if (mr && B.length > 100) {
+        var oe = {};
+        ua = [];
+        for (var xo in mr) {
+          var dt = Cr[xo];
+          if (dt)
+            for (var Mt = 0; Mt < dt.length; Mt++) {
+              var gt = dt[Mt];
+              oe[gt] || (oe[gt] = !0, ua.push(gt));
+            }
+        }
+      } else {
+        ua = [];
+        for (var yt = 0; yt < P.length; yt++) ua.push(yt);
+      }
+      for (var xt = 0; xt < ua.length; xt++) {
+        var D = P[ua[xt]], Vr = eo(D.source), Ur = eo(D.target);
+        if (!(!Vr || !Ur) && !(Vr.hidden || Ur.hidden) && !D._customRendered) {
+          var Va = it(Vr, "source", D.sourceHandle), Ua = it(Ur, "target", D.targetHandle), _ = Va.x, R = Va.y, T = Ua.x, m = Ua.y, ir = D.type || "default", fe = D.selected, ve = D.animated, q;
+          fe ? (nr || (nr = new Path2D()), q = nr) : ve ? (vr || (vr = new Path2D()), q = vr) : (zr || (zr = new Path2D()), q = zr);
+          var S = D._routedPoints;
+          if (S && S.length >= 2)
+            io(q, S);
+          else if (ir === "straight")
+            q.moveTo(_, R), q.lineTo(T, m);
+          else if (ir === "step" || ir === "smoothstep")
+            try {
+              var Y = Va.position || "right", sa = Ua.position || "left", k = 20, I = _, F = R, Z = T, p = m;
+              Y === "right" ? I += k : Y === "left" ? I -= k : Y === "bottom" ? F += k : Y === "top" && (F -= k), sa === "right" ? Z += k : sa === "left" ? Z -= k : sa === "bottom" ? p += k : sa === "top" && (p -= k);
+              var Da = h(Vr), Fa = h(Ur), Aa = Vr.width || E, Ea = Vr.height || c, le = Ur.width || E, ie = Ur.height || c, kt = Y === "left" || Y === "right", he = sa === "left" || sa === "right", Tt = {};
+              Tt[D.source] = !0, Tt[D.target] = !0;
+              var rr = go(
+                Math.min(_, T) - Aa,
+                Math.min(R, m) - Ea,
+                Math.max(_, T) + le,
+                Math.max(R, m) + ie,
+                Tt
+              );
+              rr.push(Vr), rr.push(Ur);
+              var b = [];
+              if (kt && he) {
+                var J, ko = Y === "right" && I < Z, To = Y === "left" && I > Z;
+                if (ko || To) {
+                  J = (I + Z) / 2;
+                  var mt = Mr(J, R, m, rr);
+                  if (mt) {
+                    var Rt = h(mt), wr = mt.width || E;
+                    J < Rt.x + wr / 2 ? J = Rt.x - k : J = Rt.x + wr + k;
+                  }
+                } else
+                  Y === "right" ? J = Math.max(Da.x + Aa, Fa.x + le) + k : J = Math.min(Da.x, Fa.x) - k;
+                b = [{ x: I, y: R }, { x: J, y: R }, { x: J, y: m }, { x: Z, y: m }];
+                var wt = dr(J, Z, m, rr);
+                if (wt) {
+                  var ne = h(wt), mo = wt.height || c, ue = ne.y - k, se = ne.y + mo + k, de = Math.abs(R - ue) <= Math.abs(R - se) ? ue : se;
+                  b = [
+                    { x: I, y: R },
+                    { x: J, y: R },
+                    { x: J, y: de },
+                    { x: Z, y: de },
+                    { x: Z, y: m }
+                  ];
+                }
+                var zt = dr(I, J, R, rr);
+                if (zt) {
+                  var Me = h(zt), Ro = zt.height || c, ge = Me.y - k, ye = Me.y + Ro + k, xe = Math.abs(m - ge) <= Math.abs(m - ye) ? ge : ye;
+                  b.splice(
+                    1,
+                    0,
+                    { x: I, y: xe },
+                    { x: J, y: xe }
+                  ), b = b.filter(function(Lr, ro) {
+                    return !(Math.abs(Lr.x - J) < 1 && Math.abs(Lr.y - R) < 1);
+                  }), b.splice(0, 0, { x: I, y: R });
+                }
+              } else if (!kt && !he) {
+                var K, wo = Y === "bottom" && F < p, zo = Y === "top" && F > p;
+                if (wo || zo) {
+                  K = (F + p) / 2;
+                  var ct = dr(_, T, K, rr);
+                  if (ct) {
+                    var _t = h(ct), ke = ct.height || c;
+                    K < _t.y + ke / 2 ? K = _t.y - k : K = _t.y + ke + k;
+                  }
+                } else
+                  Y === "bottom" ? K = Math.max(Da.y + Ea, Fa.y + ie) + k : K = Math.min(Da.y, Fa.y) - k;
+                b = [{ x: _, y: F }, { x: _, y: K }, { x: T, y: K }, { x: T, y: p }];
+                var At = Mr(_, F, K, rr);
+                if (At) {
+                  var Te = h(At), co = At.width || E, me = Te.x - k, Re = Te.x + co + k, we = Math.abs(T - me) <= Math.abs(T - Re) ? me : Re;
+                  b = [
+                    { x: _, y: F },
+                    { x: we, y: F },
+                    { x: we, y: K },
+                    { x: T, y: K },
+                    { x: T, y: p }
+                  ];
+                }
+                var Et = Mr(T, K, p, rr);
+                if (Et) {
+                  var ze = h(Et), _o = Et.height || c, ce = ze.y - k, _e = ze.y + _o + k, Ao = Math.abs(K - ce) <= Math.abs(K - _e) ? ce : _e;
+                  b.splice(
+                    b.length - 1,
+                    0,
+                    { x: Z, y: Ao }
+                  );
+                }
+              } else if (kt) {
+                b = [{ x: I, y: R }, { x: T, y: R }, { x: T, y: p }];
+                var Wt = Mr(T, R, p, rr);
+                if (Wt) {
+                  var Ae = h(Wt), Eo = Wt.width || E, Ee = Ae.x - k, We = Ae.x + Eo + k, Le = Math.abs(_ - Ee) <= Math.abs(_ - We) ? Ee : We;
+                  b = [{ x: I, y: R }, { x: Le, y: R }, { x: Le, y: m }, { x: T, y: m }, { x: T, y: p }];
+                }
+                var Lt = dr(I, T, R, rr);
+                if (Lt) {
+                  var Ce = h(Lt), Wo = Lt.height || c, Be = Ce.y - k, be = Ce.y + Wo + k, Ne = Math.abs(m - Be) <= Math.abs(m - be) ? Be : be;
+                  b = [{ x: I, y: R }, { x: I, y: Ne }, { x: T, y: Ne }, { x: T, y: p }];
+                }
+              } else {
+                b = [{ x: _, y: F }, { x: _, y: m }, { x: Z, y: m }];
+                var Ct = dr(_, Z, m, rr);
+                if (Ct) {
+                  var qe = h(Ct), Lo = Ct.height || c, Se = qe.y - k, Ge = qe.y + Lo + k, Pe = Math.abs(R - Se) <= Math.abs(R - Ge) ? Se : Ge;
+                  b = [{ x: _, y: F }, { x: _, y: Pe }, { x: Z, y: Pe }, { x: Z, y: m }];
+                }
+                var Bt = Mr(_, F, m, rr);
+                if (Bt) {
+                  var Ie = h(Bt), Co = Bt.width || E, Ze = Ie.x - k, Je = Ie.x + Co + k, Ke = Math.abs(T - Ze) <= Math.abs(T - Je) ? Ze : Je;
+                  b = [{ x: _, y: F }, { x: Ke, y: F }, { x: Ke, y: m }, { x: Z, y: m }];
+                }
+              }
+              for (var Dr = [{ x: _, y: R }], bt = 0; bt < b.length; bt++) Dr.push(b[bt]);
+              Dr.push({ x: T, y: m });
+              for (var ar = [Dr[0]], Wa = 1; Wa < Dr.length; Wa++) {
+                var La = ar[ar.length - 1];
+                (Math.abs(Dr[Wa].x - La.x) > 0.1 || Math.abs(Dr[Wa].y - La.y) > 0.1) && ar.push(Dr[Wa]);
+              }
+              var Qe = ir === "smoothstep" ? 8 : 0;
+              q.moveTo(ar[0].x, ar[0].y);
+              for (var ur = 1; ur < ar.length; ur++)
+                if (Qe > 0 && ur > 0 && ur < ar.length - 1) {
+                  var sr = ar[ur - 1], A = ar[ur], cr = ar[ur + 1];
+                  if (Math.abs(sr.x - A.x) < 0.5 && Math.abs(A.x - cr.x) < 0.5 || Math.abs(sr.y - A.y) < 0.5 && Math.abs(A.y - cr.y) < 0.5)
+                    q.lineTo(A.x, A.y);
+                  else {
+                    var ja = Math.min(Math.hypot(sr.x - A.x, sr.y - A.y) / 2, Math.hypot(A.x - cr.x, A.y - cr.y) / 2, Qe);
+                    Math.abs(sr.y - A.y) < 0.5 ? (q.lineTo(A.x + (sr.x < cr.x ? -1 : 1) * ja, A.y), q.quadraticCurveTo(A.x, A.y, A.x, A.y + (sr.y < cr.y ? 1 : -1) * ja)) : (q.lineTo(A.x, A.y + (sr.y < cr.y ? -1 : 1) * ja), q.quadraticCurveTo(A.x, A.y, A.x + (sr.x < cr.x ? 1 : -1) * ja, A.y));
+                  }
+                } else
+                  q.lineTo(ar[ur].x, ar[ur].y);
+            } catch (Lr) {
+              console.error("[worker] smoothstep error:", Lr, "edge:", D.id);
+            }
+          else {
+            var _r = Va.position || "right", Ar = Ua.position || "left", Er = 20, Ca = _, Oa = R, Ba = T, Xa = m;
+            _r === "right" ? Ca += Er : _r === "left" ? Ca -= Er : _r === "bottom" ? Oa += Er : _r === "top" && (Oa -= Er), Ar === "right" ? Ba += Er : Ar === "left" ? Ba -= Er : Ar === "bottom" ? Xa += Er : Ar === "top" && (Xa -= Er);
+            var Bo = Math.abs(Ba - Ca), Wr = Math.max(50, Bo * 0.5), bo = Ca + (_r === "left" ? -Wr : _r === "right" ? Wr : 0), No = Oa + (_r === "top" ? -Wr : _r === "bottom" ? Wr : 0), qo = Ba + (Ar === "left" ? -Wr : Ar === "right" ? Wr : 0), So = Xa + (Ar === "top" ? -Wr : Ar === "bottom" ? Wr : 0);
+            q.moveTo(_, R), q.lineTo(Ca, Oa), q.bezierCurveTo(bo, No, qo, So, Ba, Xa), q.lineTo(T, m);
+          }
+          if (yo) {
+            var Go = 8, ba;
+            if (S && S.length >= 2) {
+              var La = S[S.length - 1], $e = S[S.length - 2];
+              ba = Math.atan2(La.y - $e.y, La.x - $e.x);
+            } else if (ir === "straight")
+              ba = Math.atan2(m - R, T - _);
+            else if (ir === "step" || ir === "smoothstep")
+              ba = 0;
+            else {
+              var Ve = re(_, R, T, m);
+              ba = Math.atan2(m - Ve.cp2y, T - Ve.cp2x);
+            }
+            var Ue = S && S.length >= 2 ? S[S.length - 1] : { x: T, y: m }, Nt = { x: Ue.x, y: Ue.y, angle: ba, size: Go };
+            fe ? _a.push(Nt) : ve ? $r.push(Nt) : ca.push(Nt);
+          }
+          if ($a && D.label) {
+            var Na;
+            S && S.length >= 2 ? Na = af(S) : ir === "straight" || ir === "step" || ir === "smoothstep" ? Na = { x: (_ + T) / 2, y: (R + m) / 2 } : Na = tf(_, R, T, m), lr.push({ text: D.label, x: Na.x, y: Na.y });
+          }
+        }
+      }
+      if (zr && (r.strokeStyle = z.edgeStroke, r.lineWidth = 1.5, r.setLineDash([]), r.stroke(zr)), vr && (r.strokeStyle = z.edgeAnimated, r.lineWidth = 1.5, r.setLineDash([5, 5]), r.lineDashOffset = -pt, r.stroke(vr), r.setLineDash([])), nr && (r.strokeStyle = z.edgeSelected, r.lineWidth = 2.5, r.setLineDash([]), r.stroke(nr)), ot(ca, z.edgeStroke), ot($r, z.edgeAnimated), ot(_a, z.edgeSelected), lr.length > 0) {
+        r.font = Ho, r.textAlign = "center", r.textBaseline = "middle";
+        for (var qt = 0; qt < lr.length; qt++) {
+          var da = lr[qt], Po = r.measureText(da.text), De = Po.width + 12;
+          r.fillStyle = G ? "#2a2a2a" : "#ffffff", r.fillRect(da.x - De / 2, da.y - 9, De, 18), r.fillStyle = z.nodeText, r.fillText(da.text, da.x, da.y);
+        }
+        r.textAlign = "start", r.textBaseline = "alphabetic";
+      }
+    }
+    if (Pa) {
+      r.beginPath(), r.strokeStyle = z.connectionLine, r.lineWidth = 2, r.setLineDash([6, 4]);
+      var St = Pa._routedPoints;
+      if (St && St.length >= 2) {
+        var Fe = new Path2D();
+        io(Fe, St), r.stroke(Fe);
+      } else {
+        var Ha = Pa.from, Ya = Pa.to, pa = re(Ha.x, Ha.y, Ya.x, Ya.y);
+        r.moveTo(Ha.x, Ha.y), r.bezierCurveTo(pa.cp1x, pa.cp1y, pa.cp2x, pa.cp2y, Ya.x, Ya.y), r.stroke();
+      }
+      r.setLineDash([]);
+    }
+    if (hr) {
+      var je = Math.min(hr.startWorld.x, hr.endWorld.x), Oe = Math.min(hr.startWorld.y, hr.endWorld.y), Aa = Math.abs(hr.endWorld.x - hr.startWorld.x), Ea = Math.abs(hr.endWorld.y - hr.startWorld.y);
+      r.fillStyle = G ? "rgba(59,130,246,0.08)" : "rgba(59,130,246,0.06)", r.fillRect(je, Oe, Aa, Ea), r.strokeStyle = "#3b82f6", r.lineWidth = 1 / g.zoom, r.setLineDash([]), r.strokeRect(je, Oe, Aa, Ea);
+    }
+    if (U > 0) {
+      var Io = g.zoom > 0.12 && (g.zoom > 0.25 || U < 500), Xe = g.zoom > 0.08 && U < 200, Zo = g.zoom > 0.2 && U < 300;
+      if (Xe) {
+        r.shadowColor = z.nodeShadow, r.shadowBlur = 6, r.shadowOffsetY = 2, r.fillStyle = z.nodeBg, r.beginPath();
+        for (var Gt = 0; Gt < U; Gt++) {
+          var rt = V[Gt];
+          r.roundRect(h(rt).x, h(rt).y, rt.width || E, rt.height || c, ft);
+        }
+        r.fill(), r.shadowColor = "transparent", r.shadowBlur = 0, r.shadowOffsetY = 0;
+      }
+      if (!Xe) {
+        r.fillStyle = z.nodeBg, r.beginPath();
+        for (var Pt = 0; Pt < U; Pt++) {
+          var at = V[Pt];
+          r.roundRect(h(at).x, h(at).y, at.width || E, at.height || c, ft);
+        }
+        r.fill();
+      }
+      r.strokeStyle = z.nodeBorder, r.lineWidth = 1, r.beginPath();
+      for (var It = 0; It < U; It++) {
+        var qa = V[It];
+        qa.selected || r.roundRect(h(qa).x, h(qa).y, qa.width || E, qa.height || c, ft);
+      }
+      r.stroke();
+      var He = !1;
+      r.strokeStyle = z.nodeSelectedBorder, r.lineWidth = 2, r.beginPath();
+      for (var Zt = 0; Zt < U; Zt++) {
+        var Sa = V[Zt];
+        Sa.selected && (He = !0, r.roundRect(h(Sa).x, h(Sa).y, Sa.width || E, Sa.height || c, ft));
+      }
+      if (He && r.stroke(), Io) {
+        r.fillStyle = z.nodeText, r.font = Xo, r.textAlign = "center", r.textBaseline = "middle";
+        for (var Jt = 0; Jt < U; Jt++) {
+          var Fr = V[Jt];
+          if (!(!Fr.data || !Fr.data.label)) {
+            var Ye = Fr.width || E, Jo = Fr.height || c;
+            r.fillText(Fr.data.label, h(Fr).x + Ye / 2, h(Fr).y + Jo / 2, Ye - 24);
+          }
+        }
+        r.textAlign = "start", r.textBaseline = "alphabetic";
+      }
+      if (Zo) {
+        for (var Kt = [], Qt = 0; Qt < U; Qt++)
+          for (var pe = ho(V[Qt]), $t = 0; $t < pe.length; $t++)
+            Kt.push(pe[$t]);
+        r.fillStyle = z.handleFill, r.beginPath();
+        for (var Vt = 0; Vt < Kt.length; Vt++) {
+          var tt = Kt[Vt];
+          r.moveTo(tt.x + ao, tt.y), r.arc(tt.x, tt.y, ao, 0, 6.2832);
+        }
+        r.fill(), r.strokeStyle = z.handleBorder, r.lineWidth = 1.5, r.stroke();
+      }
+    }
+    r.restore();
+    var Ko = (performance.now() - a).toFixed(1);
+    jt++;
+    var et = performance.now();
+    if (et - oo >= 1e3 && (fo = jt, jt = 0, oo = et), et - vo >= 100) {
+      vo = et;
+      var Qo = Math.round(-g.x / g.zoom), $o = Math.round(-g.y / g.zoom);
+      self.postMessage({
+        type: "hud",
+        data: {
+          wx: Qo,
+          wy: $o,
+          zoom: g.zoom.toFixed(2),
+          renderMs: Ko,
+          fps: fo,
+          visible: O.length > 0 ? to(Gr, Pr, Hr, Ir).length : 0,
+          nodeCount: B.length,
+          visibleNodes: U,
+          edgeCount: P.length
+        }
+      });
+    }
+  }
+}
+`, Sn = typeof self < "u" && self.Blob && new Blob(["URL.revokeObjectURL(import.meta.url);", Gn], { type: "text/javascript;charset=utf-8" });
+function Er(t) {
+  let e;
+  try {
+    if (e = Sn && (self.URL || self.webkitURL).createObjectURL(Sn), !e) throw "";
+    const n = new Worker(e, {
+      type: "module",
+      name: t == null ? void 0 : t.name
+    });
+    return n.addEventListener("error", () => {
+      (self.URL || self.webkitURL).revokeObjectURL(e);
+    }), n;
+  } catch {
+    return new Worker(
+      "data:text/javascript;charset=utf-8," + encodeURIComponent(Gn),
+      {
+        type: "module",
+        name: t == null ? void 0 : t.name
+      }
+    );
+  }
+}
+const mn = /* @__PURE__ */ new WeakMap();
+function Cr(t, e) {
+  if (mn.has(t))
+    return mn.get(t);
+  const n = t.transferControlToOffscreen(), r = new Er();
+  r.onerror = (o) => console.error("[infinite-canvas] worker error:", o.message, o), r.postMessage({ type: "init", data: { ...e, canvas: n } }, [n]);
+  const s = { worker: r };
+  return mn.set(t, s), s;
+}
+const Vt = 160, jt = 60, Nr = 10;
+function Lr({
+  cards: t = [],
+  nodes: e = [],
+  edges: n = [],
+  onHudUpdate: r,
+  onNodesProcessed: s,
+  onNodesChange: o,
+  onEdgesChange: i,
+  onConnect: c,
+  onNodeClick: u,
+  onNodeDragStart: l,
+  onNodeDrag: g,
+  onNodeDragStop: v,
+  onEdgeClick: E,
+  onEdgeDoubleClick: R,
+  onEdgeMouseEnter: M,
+  onEdgeMouseMove: T,
+  onEdgeMouseLeave: k,
+  onEdgeContextMenu: z,
+  onNodeDoubleClick: W,
+  onNodeMouseEnter: D,
+  onNodeMouseMove: x,
+  onNodeMouseLeave: f,
+  onNodeContextMenu: p,
+  onPaneClick: y,
+  onPaneContextMenu: N,
+  onPaneMouseEnter: C,
+  onPaneMouseMove: P,
+  onPaneMouseLeave: b,
+  onSelectionChange: L,
+  onConnectStart: Y,
+  onConnectEnd: H,
+  onInit: dt,
+  onMoveStart: yt,
+  onMove: ft,
+  onMoveEnd: G,
+  onDelete: j,
+  onBeforeDelete: rt,
+  onError: at,
+  isValidConnection: ct,
+  dark: lt,
+  gridSize: Ct = 40,
+  zoomMin: et = 0.1,
+  zoomMax: ot = 4,
+  initialCamera: Nt = { x: 0, y: 0, zoom: 1 },
+  fitView: Rt = !1,
+  fitViewOptions: vt,
+  nodesDraggable: Lt = !0,
+  nodesConnectable: kt = !0,
+  elementsSelectable: $t = !0,
+  multiSelectionKeyCode: mt = "Shift",
+  selectionOnDrag: ne = !1,
+  selectionMode: Ie = "partial",
+  connectionMode: Bt = "loose",
+  connectionRadius: Qt = 20,
+  connectOnClick: Yt = !1,
+  snapToGrid: me = !1,
+  snapGrid: de = [15, 15],
+  deleteKeyCode: ve = ["Delete", "Backspace"],
+  panActivationKeyCode: we = " ",
+  panOnScroll: Ge = !1,
+  panOnScrollMode: $e = "free",
+  panOnScrollSpeed: Ze = 0.5,
+  zoomOnScroll: Qe = !0,
+  zoomOnDoubleClick: Ke = !0,
+  zoomOnPinch: Oe = !0,
+  preventScrolling: Pe = !0,
+  translateExtent: re,
+  nodeExtent: oe,
+  defaultEdgeOptions: be = {},
+  autoPanOnNodeDrag: dn = !0,
+  autoPanOnConnect: fn = !0,
+  autoPanSpeed: Kt = 5,
+  edgesReconnectable: Nn = !1,
+  elevateNodesOnSelect: hn = !1,
+  edgeRouting: fe = !0
+} = {}) {
+  const pt = V(null), Te = V(null), zt = V(null), gt = V({ ...Nt }), se = V([...t]), Z = V([...e]), Pt = V([...n]), yn = V(/* @__PURE__ */ new Map()), Se = V(!1), te = V(null), [gn, pn] = Gt(!1), _t = V(null), Wt = V(null), Me = V(null), ie = V(null), Ut = V(!1), Re = V(null), [Be, Je] = Gt({ x: Nt.x, y: Nt.y, zoom: Nt.zoom }), [Ve, ae] = Gt(null), Ot = St(() => /* @__PURE__ */ new Set(), []), he = St(() => /* @__PURE__ */ new Set(), []), ke = V(!1), Q = V({});
+  Q.current = {
+    onHudUpdate: r,
+    onNodesProcessed: s,
+    onNodesChange: o,
+    onEdgesChange: i,
+    onConnect: c,
+    onNodeClick: u,
+    onNodeDragStart: l,
+    onNodeDrag: g,
+    onNodeDragStop: v,
+    onEdgeClick: E,
+    onEdgeDoubleClick: R,
+    onEdgeMouseEnter: M,
+    onEdgeMouseMove: T,
+    onEdgeMouseLeave: k,
+    onEdgeContextMenu: z,
+    onNodeDoubleClick: W,
+    onNodeMouseEnter: D,
+    onNodeMouseMove: x,
+    onNodeMouseLeave: f,
+    onNodeContextMenu: p,
+    onPaneClick: y,
+    onPaneContextMenu: N,
+    onPaneMouseEnter: C,
+    onPaneMouseMove: P,
+    onPaneMouseLeave: b,
+    onSelectionChange: L,
+    onConnectStart: Y,
+    onConnectEnd: H,
+    onInit: dt,
+    onMoveStart: yt,
+    onMove: ft,
+    onMoveEnd: G,
+    onDelete: j,
+    onBeforeDelete: rt,
+    onError: at,
+    isValidConnection: ct
+  };
+  const wt = { get current() {
+    return Q.current.onNodesChange;
+  } }, Dt = { get current() {
+    return Q.current.onEdgesChange;
+  } }, ce = { get current() {
+    return Q.current.onConnect;
+  } }, De = { get current() {
+    return Q.current.onNodeClick;
+  } }, He = { get current() {
+    return Q.current.onNodeDragStart;
+  } }, Ae = { get current() {
+    return Q.current.onNodeDrag;
+  } }, _e = { get current() {
+    return Q.current.onNodeDragStop;
+  } }, le = { get current() {
+    return Q.current.onEdgeClick;
+  } }, We = { get current() {
+    return Q.current.onPaneClick;
+  } }, ye = { get current() {
+    return Q.current.onSelectionChange;
+  } }, ge = { get current() {
+    return Q.current.onHudUpdate;
+  } }, pe = { get current() {
+    return Q.current.onNodesProcessed;
+  } };
+  ut(() => {
+    const a = (d) => {
+      d.key === mt && (Ut.current = !0), d.key === we && (ke.current = !0);
+    }, m = (d) => {
+      d.key === mt && (Ut.current = !1), d.key === we && (ke.current = !1);
+    };
+    return window.addEventListener("keydown", a), window.addEventListener("keyup", m), () => {
+      window.removeEventListener("keydown", a), window.removeEventListener("keyup", m);
+    };
+  }, [mt, we]);
+  const Jt = F(() => {
+    var w;
+    const a = Z.current.filter((I) => I.selected), m = Pt.current.filter((I) => I.selected), d = { nodes: a, edges: m };
+    (w = ye.current) == null || w.call(ye, d);
+    for (const I of he) I(d);
+  }, [he]);
+  ut(() => {
+    var a;
+    se.current = [...t], (a = zt.current) == null || a.postMessage({ type: "cards", data: { cards: [...t] } });
+  }, [t]);
+  const ze = F((a) => {
+    const m = {};
+    for (const d of a) m[d.id] = d;
+    return a.map((d) => {
+      if (!d.parentId) return d;
+      const w = m[d.parentId];
+      if (!w) return d;
+      let I = d.position.x, $ = d.position.y, h = w;
+      for (; h; )
+        I += h.position.x, $ += h.position.y, h = h.parentId ? m[h.parentId] : null;
+      return { ...d, _absolutePosition: { x: I, y: $ } };
+    });
+  }, []), ee = V([]), K = F((a) => {
+    const m = yn.current;
+    if (!m || m.size === 0) return a;
+    const d = {};
+    for (const [, w] of m)
+      d[w.nodeId] || (d[w.nodeId] = []), d[w.nodeId].push({ id: w.id, type: w.type, position: w.position, x: w.x, y: w.y });
+    return a.map((w) => {
+      const I = d[w.id];
+      return I && I.length > 0 ? { ...w, handles: I } : w;
+    });
+  }, []), Ft = F(() => {
+    var m;
+    if (_t.current) return;
+    const a = K(ee.current);
+    (m = zt.current) == null || m.postMessage({ type: "nodes", data: { nodes: a } });
+  }, [K]);
+  ut(() => {
+    var d;
+    if (_t.current) {
+      const w = _t.current.id, I = /* @__PURE__ */ new Set([w, ..._t.current.selectedStarts.map((h) => h.id)]), $ = {};
+      for (const h of Z.current)
+        I.has(h.id) && ($[h.id] = { ...h.position });
+      Z.current = [...e];
+      for (const h of Z.current)
+        $[h.id] && (h.position = $[h.id]);
+      ee.current = ze(Z.current);
+      return;
+    }
+    Z.current = [...e];
+    const a = ze(e);
+    ee.current = a;
+    const m = K(a);
+    (d = zt.current) == null || d.postMessage({ type: "nodes", data: { nodes: m } });
+  }, [e, ze, K]), ut(() => {
+    var a;
+    Pt.current = [...n], (a = zt.current) == null || a.postMessage({ type: "edges", data: { edges: [...n] } });
+  }, [n]);
+  const st = F((a, m) => {
+    const d = pt.current;
+    if (!d) return { x: 0, y: 0 };
+    const w = d.getBoundingClientRect(), I = gt.current;
+    return {
+      x: (a - w.left - I.x) / I.zoom,
+      y: (m - w.top - I.y) / I.zoom
+    };
+  }, []), Tt = F((a, m) => {
+    const d = ee.current.length > 0 ? ee.current : Z.current;
+    let w = null;
+    for (let I = d.length - 1; I >= 0; I--) {
+      const $ = d[I];
+      if ($.hidden) continue;
+      const h = $._absolutePosition || $.position, A = $.width || Vt, S = $.height || jt;
+      if (a >= h.x && a <= h.x + A && m >= h.y && m <= h.y + S) {
+        if ($.type === "group") {
+          w || (w = $);
+          continue;
+        }
+        return $;
+      }
+    }
+    return w;
+  }, []), xe = F((a, m) => {
+    const d = m.width || Vt, w = m.height || jt;
+    if (a.x !== void 0 && a.y !== void 0)
+      return { x: m.position.x + a.x, y: m.position.y + a.y };
+    switch (a.position || (a.type === "source" ? "right" : "left")) {
+      case "top":
+        return { x: m.position.x + d / 2, y: m.position.y };
+      case "bottom":
+        return { x: m.position.x + d / 2, y: m.position.y + w };
+      case "left":
+        return { x: m.position.x, y: m.position.y + w / 2 };
+      case "right":
+        return { x: m.position.x + d, y: m.position.y + w / 2 };
+      default:
+        return { x: m.position.x + d, y: m.position.y + w / 2 };
+    }
+  }, []), Ee = F((a) => {
+    const m = a.width || Vt, d = a.height || jt;
+    return a.handles && a.handles.length > 0 ? a.handles.map((w) => {
+      const I = xe(w, a);
+      return { id: w.id || null, type: w.type, x: I.x, y: I.y };
+    }) : [
+      { id: null, type: "target", x: a.position.x, y: a.position.y + d / 2 },
+      { id: null, type: "source", x: a.position.x + m, y: a.position.y + d / 2 }
+    ];
+  }, [xe]), tn = F((a, m) => {
+    const d = Z.current, w = gt.current, I = Math.max(Nr, Qt) / w.zoom;
+    for (let $ = d.length - 1; $ >= 0; $--) {
+      const h = d[$];
+      if (h.hidden) continue;
+      const A = Ee(h);
+      for (const S of A)
+        if (Math.abs(a - S.x) < I && Math.abs(m - S.y) < I)
+          return { nodeId: h.id, handleId: S.id, type: S.type, x: S.x, y: S.y };
+    }
+    return null;
+  }, [Ee]), ue = F((a, m) => {
+    const w = 8 / gt.current.zoom;
+    for (let I = Pt.current.length - 1; I >= 0; I--) {
+      const $ = Pt.current[I], h = Z.current.find((bt) => bt.id === $.source), A = Z.current.find((bt) => bt.id === $.target);
+      if (!h || !A) continue;
+      const S = h.width || Vt, U = h.height || jt, _ = A.height || jt, O = h.position.x + S, it = h.position.y + U / 2, q = A.position.x, nt = A.position.y + _ / 2;
+      if (Ir(a, m, O, it, q, nt) < w) return $;
+    }
+    return null;
+  }, []);
+  ut(() => {
+    const a = Te.current, m = pt.current;
+    if (!a || !m) return;
+    const d = m.getBoundingClientRect(), w = lt !== void 0 ? lt : matchMedia("(prefers-color-scheme: dark)").matches, I = ze(Z.current);
+    ee.current = I;
+    const $ = K(I), { worker: h } = Cr(a, {
+      width: d.width,
+      height: d.height,
+      camera: gt.current,
+      cards: se.current,
+      nodes: $,
+      edges: Pt.current,
+      dark: w,
+      gridSize: Ct,
+      edgeRouting: fe
+    });
+    h.onmessage = (_) => {
+      var O, it;
+      _.data.type === "hud" && ((O = ge.current) == null || O.call(ge, _.data.data)), _.data.type === "ready" && pn(!0), _.data.type === "nodesProcessed" && ((it = pe.current) == null || it.call(pe, _.data.data));
+    }, zt.current = h;
+    const A = new ResizeObserver((_) => {
+      const { width: O, height: it } = _[0].contentRect;
+      h.postMessage({ type: "resize", data: { width: O, height: it } });
+    });
+    A.observe(m);
+    let S, U;
+    return lt === void 0 && (S = matchMedia("(prefers-color-scheme: dark)"), U = (_) => h.postMessage({ type: "theme", data: { dark: _.matches } }), S.addEventListener("change", U)), () => {
+      A.disconnect(), S && U && S.removeEventListener("change", U), zt.current = null;
+    };
+  }, []), ut(() => {
+    var a;
+    lt !== void 0 && ((a = zt.current) == null || a.postMessage({ type: "theme", data: { dark: lt } }));
+  }, [lt]), ut(() => {
+    var a;
+    (a = zt.current) == null || a.postMessage({ type: "edgeRouting", data: { enabled: fe } });
+  }, [fe]);
+  const Ln = V(0), Et = F((a = null) => {
+    var w, I, $;
+    const m = gt.current;
+    if (re) {
+      const h = pt.current;
+      if (h) {
+        const A = h.getBoundingClientRect(), S = -re[1][0] * m.zoom + A.width, U = -re[1][1] * m.zoom + A.height, _ = -re[0][0] * m.zoom, O = -re[0][1] * m.zoom;
+        m.x = Math.min(_, Math.max(S, m.x)), m.y = Math.min(O, Math.max(U, m.y));
+      }
+    }
+    (w = zt.current) == null || w.postMessage({ type: "camera", data: { camera: { ...m } } });
+    const d = { x: m.x, y: m.y, zoom: m.zoom };
+    ($ = (I = Q.current).onMove) == null || $.call(I, a, d);
+    for (const h of Ot) h(d);
+    cancelAnimationFrame(Ln.current), Ln.current = requestAnimationFrame(() => {
+      Je({ x: m.x, y: m.y, zoom: m.zoom });
+    });
+  }, [Ot, re]), Ce = F(() => {
+    var d, w;
+    const a = Wt.current, m = Me.current;
+    a && m ? ((d = zt.current) == null || d.postMessage({ type: "connecting", data: { from: a.startPos, to: m, _routedPoints: null } }), ae({ source: a.sourceId, sourceHandle: a.sourceHandle, target: null, targetHandle: null })) : ((w = zt.current) == null || w.postMessage({ type: "connecting", data: null }), ae(null));
+  }, []), Ne = F(() => {
+    var m, d;
+    const a = ie.current;
+    a ? (m = zt.current) == null || m.postMessage({ type: "selectionBox", data: a }) : (d = zt.current) == null || d.postMessage({ type: "selectionBox", data: null });
+  }, []), dr = F((a) => {
+    var I, $, h, A, S, U, _, O, it, q, nt, xt, bt, Ht, Xt, At;
+    const m = Z.current.length > 0, d = st(a.clientX, a.clientY), w = Ut.current;
+    if (m && kt) {
+      const X = tn(d.x, d.y);
+      if (Yt && Re.current && X) {
+        const J = Re.current;
+        if (X.nodeId !== J.nodeId) {
+          const qt = J.handleType === "target" ? { source: X.nodeId, target: J.nodeId, sourceHandle: X.handleId || null, targetHandle: J.handleId } : { source: J.nodeId, target: X.nodeId, sourceHandle: J.handleId, targetHandle: X.handleId || null };
+          (Q.current.isValidConnection ? Q.current.isValidConnection(qt) : !0) && ((I = ce.current) == null || I.call(ce, { ...qt, ...be }));
+        }
+        Re.current = null;
+        return;
+      }
+      if (Bt === "strict" ? X && X.type === "source" : X != null) {
+        if (Yt) {
+          Re.current = { nodeId: X.nodeId, handleId: X.handleId || null, handleType: X.type }, (h = ($ = Q.current).onConnectStart) == null || h.call($, a, { nodeId: X.nodeId, handleId: X.handleId, handleType: X.type });
+          return;
+        }
+        Wt.current = {
+          sourceId: X.nodeId,
+          sourceHandle: X.handleId || null,
+          sourceType: X.type,
+          startPos: { x: X.x, y: X.y }
+        }, Me.current = { x: d.x, y: d.y }, (A = pt.current) == null || A.setPointerCapture(a.pointerId), (U = (S = Q.current).onConnectStart) == null || U.call(S, a, { nodeId: X.nodeId, handleId: X.handleId, handleType: X.type }), Ce();
+        return;
+      }
+    }
+    if (m) {
+      const X = Tt(d.x, d.y);
+      if (X) {
+        if (wt.current && $t) {
+          const Mt = [];
+          if (w)
+            Mt.push({ id: X.id, type: "select", selected: !X.selected });
+          else if (!X.selected) {
+            for (const J of Z.current)
+              J.id === X.id ? Mt.push({ id: J.id, type: "select", selected: !0 }) : J.selected && Mt.push({ id: J.id, type: "select", selected: !1 });
+            if (Dt.current) {
+              const J = Pt.current.filter((tt) => tt.selected).map((tt) => ({ id: tt.id, type: "select", selected: !1 }));
+              J.length && Dt.current(J);
+            }
+          }
+          if (Mt.length) {
+            if (wt.current(Mt), hn && !w) {
+              const J = Z.current.findIndex((tt) => tt.id === X.id);
+              J >= 0 && J < Z.current.length - 1 && wt.current([
+                { id: X.id, type: "remove" },
+                { type: "add", item: { ...Z.current[J], selected: !0 } }
+              ]);
+            }
+            Jt();
+          }
+        }
+        if ((_ = De.current) == null || _.call(De, a, X), Lt) {
+          const Mt = w && X.selected;
+          let J = null;
+          if (X.parentId && X.extent === "parent") {
+            const tt = Z.current.find((qt) => qt.id === X.parentId);
+            if (tt) {
+              const qt = tt.width || Vt, Xe = tt.height || jt, en = X.width || ((O = X.measured) == null ? void 0 : O.width) || Vt, Fe = X.height || ((it = X.measured) == null ? void 0 : it.height) || jt;
+              J = { minX: 0, minY: 0, maxX: qt - en, maxY: Xe - Fe };
+            }
+          }
+          if (_t.current = {
+            id: X.id,
+            startPos: { ...X.position },
+            startMouse: { x: d.x, y: d.y },
+            parentClamp: J,
+            parentId: X.parentId || null,
+            selectedStarts: Mt ? Z.current.filter((tt) => tt.selected && tt.id !== X.id).map((tt) => {
+              var Xe, en;
+              let qt = null;
+              if (tt.parentId && tt.extent === "parent") {
+                const Fe = Z.current.find((xn) => xn.id === tt.parentId);
+                if (Fe) {
+                  const xn = Fe.width || Vt, br = Fe.height || jt, Mr = tt.width || ((Xe = tt.measured) == null ? void 0 : Xe.width) || Vt, Rr = tt.height || ((en = tt.measured) == null ? void 0 : en.height) || jt;
+                  qt = { minX: 0, minY: 0, maxX: xn - Mr, maxY: br - Rr };
+                }
+              }
+              return { id: tt.id, startPos: { ...tt.position }, parentClamp: qt, parentId: tt.parentId || null };
+            }) : []
+          }, (q = pt.current) == null || q.setPointerCapture(a.pointerId), (nt = He.current) == null || nt.call(He, a, X), wt.current) {
+            const tt = [{ id: X.id, type: "position", dragging: !0 }];
+            for (const qt of _t.current.selectedStarts)
+              tt.push({ id: qt.id, type: "position", dragging: !0 });
+            wt.current(tt);
+          }
+        }
+        return;
+      }
+    }
+    if (Pt.current.length > 0 && $t) {
+      const X = ue(d.x, d.y);
+      if (X) {
+        if (Dt.current) {
+          const Mt = [];
+          if (w)
+            Mt.push({ id: X.id, type: "select", selected: !X.selected });
+          else {
+            for (const J of Pt.current)
+              J.id === X.id ? Mt.push({ id: J.id, type: "select", selected: !0 }) : J.selected && Mt.push({ id: J.id, type: "select", selected: !1 });
+            if (wt.current) {
+              const J = Z.current.filter((tt) => tt.selected).map((tt) => ({ id: tt.id, type: "select", selected: !1 }));
+              J.length && wt.current(J);
+            }
+          }
+          Mt.length && (Dt.current(Mt), Jt());
+        }
+        (xt = le.current) == null || xt.call(le, a, X);
+        return;
+      }
+    }
+    if (!w) {
+      const X = Z.current.filter((J) => J.selected).map((J) => ({ id: J.id, type: "select", selected: !1 })), Mt = Pt.current.filter((J) => J.selected).map((J) => ({ id: J.id, type: "select", selected: !1 }));
+      X.length && wt.current && wt.current(X), Mt.length && Dt.current && Dt.current(Mt), (X.length || Mt.length) && Jt();
+    }
+    if ((bt = We.current) == null || bt.call(We, a), ne || w) {
+      ie.current = { startWorld: { ...d }, endWorld: { ...d } }, (Ht = pt.current) == null || Ht.setPointerCapture(a.pointerId), Ne();
+      return;
+    }
+    Se.current = !0, te.current = { x: a.clientX, y: a.clientY }, (Xt = pt.current) == null || Xt.classList.add("dragging"), (At = pt.current) == null || At.setPointerCapture(a.pointerId);
+  }, [st, Tt, tn, ue, Lt, kt, $t, ne, Ce, Ne, Jt]), fr = F((a) => {
+    var d, w;
+    if (Wt.current) {
+      if (Me.current = st(a.clientX, a.clientY), Ce(), fn) {
+        const I = pt.current;
+        if (I) {
+          const $ = I.getBoundingClientRect(), h = 40, A = a.clientX - $.left, S = a.clientY - $.top;
+          let U = 0, _ = 0;
+          A < h ? U = Kt : A > $.width - h && (U = -Kt), S < h ? _ = Kt : S > $.height - h && (_ = -Kt), (U || _) && (gt.current.x += U, gt.current.y += _, Et(a));
+        }
+      }
+      return;
+    }
+    if (ie.current) {
+      ie.current.endWorld = st(a.clientX, a.clientY), Ne();
+      const I = ie.current, $ = Math.min(I.startWorld.x, I.endWorld.x), h = Math.min(I.startWorld.y, I.endWorld.y), A = Math.max(I.startWorld.x, I.endWorld.x), S = Math.max(I.startWorld.y, I.endWorld.y);
+      if (wt.current) {
+        const U = [];
+        for (const _ of Z.current) {
+          if (_.hidden) continue;
+          const O = _.width || Vt, it = _.height || jt, q = Ie === "full" ? _.position.x >= $ && _.position.x + O <= A && _.position.y >= h && _.position.y + it <= S : _.position.x + O > $ && _.position.x < A && _.position.y + it > h && _.position.y < S;
+          q !== !!_.selected && U.push({ id: _.id, type: "select", selected: q });
+        }
+        U.length && wt.current(U);
+      }
+      return;
+    }
+    if (_t.current) {
+      const I = st(a.clientX, a.clientY), $ = _t.current, h = I.x - $.startMouse.x, A = I.y - $.startMouse.y;
+      let S = { x: $.startPos.x + h, y: $.startPos.y + A };
+      if (me && (S = Pn(S, de)), oe && (S = Tn(S, oe)), $.parentClamp) {
+        const q = $.parentClamp;
+        S = { x: Math.max(q.minX, Math.min(S.x, q.maxX)), y: Math.max(q.minY, Math.min(S.y, q.maxY)) };
+      }
+      const U = [{ id: $.id, position: S }];
+      for (const q of $.selectedStarts) {
+        let nt = { x: q.startPos.x + h, y: q.startPos.y + A };
+        if (me && (nt = Pn(nt, de)), oe && (nt = Tn(nt, oe)), q.parentClamp) {
+          const xt = q.parentClamp;
+          nt = { x: Math.max(xt.minX, Math.min(nt.x, xt.maxX)), y: Math.max(xt.minY, Math.min(nt.y, xt.maxY)) };
+        }
+        U.push({ id: q.id, position: nt });
+      }
+      const _ = [];
+      for (const q of U) {
+        const nt = Z.current.find((xt) => xt.id === q.id);
+        if (nt) {
+          nt.position = q.position, nt.dragging = !0;
+          let xt = q.position;
+          if (nt.parentId) {
+            let bt = Z.current.find((At) => At.id === nt.parentId), Ht = q.position.x, Xt = q.position.y;
+            for (; bt; )
+              Ht += bt.position.x, Xt += bt.position.y, bt = bt.parentId ? Z.current.find((At) => At.id === bt.parentId) : null;
+            xt = { x: Ht, y: Xt };
+          }
+          _.push({
+            id: q.id,
+            position: q.position,
+            _absolutePosition: xt,
+            width: nt.width,
+            height: nt.height,
+            dragging: !0,
+            selected: nt.selected
+          });
+        }
+      }
+      const O = new Set(U.map((q) => q.id));
+      for (const q of Z.current)
+        if (q.parentId && O.has(q.parentId) && !O.has(q.id)) {
+          let nt = Z.current.find((Ht) => Ht.id === q.parentId), xt = q.position.x, bt = q.position.y;
+          for (; nt; )
+            xt += nt.position.x, bt += nt.position.y, nt = nt.parentId ? Z.current.find((Ht) => Ht.id === nt.parentId) : null;
+          _.push({
+            id: q.id,
+            position: q.position,
+            _absolutePosition: { x: xt, y: bt },
+            width: q.width,
+            height: q.height,
+            dragging: !1,
+            selected: q.selected
+          });
+        }
+      if ((d = zt.current) == null || d.postMessage({ type: "nodePositions", data: { updates: _ } }), dn) {
+        const q = pt.current;
+        if (q) {
+          const nt = q.getBoundingClientRect(), xt = 40, bt = a.clientX - nt.left, Ht = a.clientY - nt.top;
+          let Xt = 0, At = 0;
+          bt < xt ? Xt = Kt : bt > nt.width - xt && (Xt = -Kt), Ht < xt ? At = Kt : Ht > nt.height - xt && (At = -Kt), (Xt || At) && (gt.current.x += Xt, gt.current.y += At, Et(a));
+        }
+      }
+      const it = Z.current.find((q) => q.id === $.id);
+      it && ((w = Ae.current) == null || w.call(Ae, a, it));
+      return;
+    }
+    if (!Se.current) return;
+    const m = gt.current;
+    m.x += a.clientX - te.current.x, m.y += a.clientY - te.current.y, te.current = { x: a.clientX, y: a.clientY }, Et();
+  }, [Et, st, Ce, Ne]), hr = F((a) => {
+    var m, d, w, I, $;
+    if (Wt.current) {
+      const h = st(a.clientX, a.clientY), A = tn(h.x, h.y);
+      if (A && A.nodeId !== Wt.current.sourceId && (Bt === "loose" || A.type === "target")) {
+        const _ = Wt.current.sourceType === "target" ? {
+          source: A.nodeId,
+          target: Wt.current.sourceId,
+          sourceHandle: A.handleId || null,
+          targetHandle: Wt.current.sourceHandle
+        } : {
+          source: Wt.current.sourceId,
+          target: A.nodeId,
+          sourceHandle: Wt.current.sourceHandle,
+          targetHandle: A.handleId || null
+        };
+        (Q.current.isValidConnection ? Q.current.isValidConnection(_) : !0) && ((m = ce.current) == null || m.call(ce, { ..._, ...be }));
+      }
+      (w = (d = Q.current).onConnectEnd) == null || w.call(d, a.nativeEvent || a), Wt.current = null, Me.current = null, Ce();
+      return;
+    }
+    if (ie.current) {
+      ie.current = null, Ne(), Jt();
+      return;
+    }
+    if (_t.current) {
+      const h = _t.current;
+      if (wt.current) {
+        const S = Z.current.find((_) => _.id === h.id), U = [{
+          id: h.id,
+          type: "position",
+          position: S ? { ...S.position } : void 0,
+          dragging: !1
+        }];
+        for (const _ of h.selectedStarts) {
+          const O = Z.current.find((it) => it.id === _.id);
+          U.push({
+            id: _.id,
+            type: "position",
+            position: O ? { ...O.position } : void 0,
+            dragging: !1
+          });
+        }
+        wt.current(U);
+      }
+      requestAnimationFrame(() => {
+        _t.current = null;
+      });
+      const A = Z.current.find((S) => S.id === h.id);
+      A && ((I = _e.current) == null || I.call(_e, a, A));
+      return;
+    }
+    Se.current = !1, ($ = pt.current) == null || $.classList.remove("dragging");
+  }, [st, tn, Ce, Ne, Jt]);
+  ut(() => {
+    const a = pt.current;
+    if (!a) return;
+    const m = (d) => {
+      Pe && d.preventDefault();
+      const w = gt.current;
+      if (Ge || ke.current) {
+        const S = Ze;
+        $e === "horizontal" ? w.x -= d.deltaY * S : ($e === "vertical" || (w.x -= d.deltaX * S), w.y -= d.deltaY * S), Et(d);
+        return;
+      }
+      if (!Qe) return;
+      const I = d.deltaY > 0 ? 0.92 : 1.08, $ = a.getBoundingClientRect(), h = d.clientX - $.left, A = d.clientY - $.top;
+      w.x = h - (h - w.x) * I, w.y = A - (A - w.y) * I, w.zoom = Math.min(ot, Math.max(et, w.zoom * I)), Et(d);
+    };
+    return a.addEventListener("wheel", m, { passive: !Pe }), () => a.removeEventListener("wheel", m);
+  }, [Et, et, ot, Ge, $e, Ze, Qe, Pe]), ut(() => {
+    if (!Oe) return;
+    const a = pt.current;
+    if (!a) return;
+    let m = 0, d = null;
+    const w = (h) => {
+      if (h.touches.length === 2) {
+        const A = h.touches[0].clientX - h.touches[1].clientX, S = h.touches[0].clientY - h.touches[1].clientY;
+        m = Math.hypot(A, S);
+        const U = a.getBoundingClientRect();
+        d = {
+          x: (h.touches[0].clientX + h.touches[1].clientX) / 2 - U.left,
+          y: (h.touches[0].clientY + h.touches[1].clientY) / 2 - U.top
+        }, h.preventDefault();
+      }
+    }, I = (h) => {
+      if (h.touches.length === 2 && m > 0) {
+        h.preventDefault();
+        const A = h.touches[0].clientX - h.touches[1].clientX, S = h.touches[0].clientY - h.touches[1].clientY, U = Math.hypot(A, S), _ = U / m;
+        m = U;
+        const O = gt.current, it = d.x, q = d.y;
+        O.x = it - (it - O.x) * _, O.y = q - (q - O.y) * _, O.zoom = Math.min(ot, Math.max(et, O.zoom * _)), Et(h);
+      }
+    }, $ = () => {
+      m = 0, d = null;
+    };
+    return a.addEventListener("touchstart", w, { passive: !1 }), a.addEventListener("touchmove", I, { passive: !1 }), a.addEventListener("touchend", $), () => {
+      a.removeEventListener("touchstart", w), a.removeEventListener("touchmove", I), a.removeEventListener("touchend", $);
+    };
+  }, [Oe, Et, et, ot]), ut(() => {
+    if (!Ke) return;
+    const a = pt.current;
+    if (!a) return;
+    const m = (d) => {
+      var _, O, it, q;
+      const w = st(d.clientX, d.clientY);
+      if (Tt(w.x, w.y)) {
+        (O = (_ = Q.current).onNodeDoubleClick) == null || O.call(_, d, Tt(w.x, w.y));
+        return;
+      }
+      const I = ue(w.x, w.y);
+      if (I) {
+        (q = (it = Q.current).onEdgeDoubleClick) == null || q.call(it, d, I);
+        return;
+      }
+      const $ = 1.5, h = a.getBoundingClientRect(), A = d.clientX - h.left, S = d.clientY - h.top, U = gt.current;
+      U.x = A - (A - U.x) * $, U.y = S - (S - U.y) * $, U.zoom = Math.min(ot, Math.max(et, U.zoom * $)), Et(d);
+    };
+    return a.addEventListener("dblclick", m), () => a.removeEventListener("dblclick", m);
+  }, [Ke, Et, et, ot, st, Tt, ue]), ut(() => {
+    const a = pt.current;
+    if (!a) return;
+    const m = (d) => {
+      var h, A, S, U, _, O;
+      const w = st(d.clientX, d.clientY), I = Tt(w.x, w.y);
+      if (I) {
+        (A = (h = Q.current).onNodeContextMenu) == null || A.call(h, d, I);
+        return;
+      }
+      const $ = ue(w.x, w.y);
+      if ($) {
+        (U = (S = Q.current).onEdgeContextMenu) == null || U.call(S, d, $);
+        return;
+      }
+      (O = (_ = Q.current).onPaneContextMenu) == null || O.call(_, d);
+    };
+    return a.addEventListener("contextmenu", m), () => a.removeEventListener("contextmenu", m);
+  }, [st, Tt, ue]), ut(() => {
+    const a = pt.current;
+    if (!a) return;
+    let m = null, d = null;
+    const w = (h) => {
+      var U, _, O, it, q, nt, xt, bt, Ht, Xt, At, X, Mt, J;
+      (_ = (U = Q.current).onPaneMouseMove) == null || _.call(U, h);
+      const A = st(h.clientX, h.clientY), S = Tt(A.x, A.y);
+      if (S !== m && (m && ((it = (O = Q.current).onNodeMouseLeave) == null || it.call(O, h, m)), S && ((nt = (q = Q.current).onNodeMouseEnter) == null || nt.call(q, h, S)), m = S), S && ((bt = (xt = Q.current).onNodeMouseMove) == null || bt.call(xt, h, S)), !S) {
+        const tt = ue(A.x, A.y);
+        tt !== d && (d && ((Xt = (Ht = Q.current).onEdgeMouseLeave) == null || Xt.call(Ht, h, d)), tt && ((X = (At = Q.current).onEdgeMouseEnter) == null || X.call(At, h, tt)), d = tt), tt && ((J = (Mt = Q.current).onEdgeMouseMove) == null || J.call(Mt, h, tt));
+      }
+    }, I = (h) => {
+      var A, S;
+      return (S = (A = Q.current).onPaneMouseEnter) == null ? void 0 : S.call(A, h);
+    }, $ = (h) => {
+      var A, S, U, _, O, it;
+      (S = (A = Q.current).onPaneMouseLeave) == null || S.call(A, h), m && ((_ = (U = Q.current).onNodeMouseLeave) == null || _.call(U, h, m), m = null), d && ((it = (O = Q.current).onEdgeMouseLeave) == null || it.call(O, h, d), d = null);
+    };
+    return a.addEventListener("mousemove", w), a.addEventListener("mouseenter", I), a.addEventListener("mouseleave", $), () => {
+      a.removeEventListener("mousemove", w), a.removeEventListener("mouseenter", I), a.removeEventListener("mouseleave", $);
+    };
+  }, [st, Tt, ue]), ut(() => {
+    const a = Array.isArray(ve) ? ve : [ve], m = async (d) => {
+      var w, I;
+      if (a.includes(d.key)) {
+        if (d.target.tagName === "INPUT" || d.target.tagName === "TEXTAREA" || d.target.isContentEditable) return;
+        const $ = Z.current.filter((S) => S.selected), h = Pt.current.filter((S) => S.selected);
+        if (!$.length && !h.length || Q.current.onBeforeDelete && !await Q.current.onBeforeDelete({ nodes: $, edges: h }))
+          return;
+        const A = new Set($.map((S) => S.id));
+        if ($.length && wt.current && (wt.current($.map((S) => ({ id: S.id, type: "remove" }))), Dt.current)) {
+          const S = Pt.current.filter((U) => A.has(U.source) || A.has(U.target));
+          S.length && Dt.current(S.map((U) => ({ id: U.id, type: "remove" })));
+        }
+        h.length && Dt.current && Dt.current(h.map((S) => ({ id: S.id, type: "remove" }))), (I = (w = Q.current).onDelete) == null || I.call(w, { nodes: $, edges: h });
+      }
+      if ((d.ctrlKey || d.metaKey) && d.key === "a") {
+        if (d.target.tagName === "INPUT" || d.target.tagName === "TEXTAREA") return;
+        if (d.preventDefault(), wt.current) {
+          const $ = Z.current.filter((h) => !h.selected).map((h) => ({ id: h.id, type: "select", selected: !0 }));
+          $.length && wt.current($);
+        }
+        if (Dt.current) {
+          const $ = Pt.current.filter((h) => !h.selected).map((h) => ({ id: h.id, type: "select", selected: !0 }));
+          $.length && Dt.current($);
+        }
+      }
+    };
+    return window.addEventListener("keydown", m), () => window.removeEventListener("keydown", m);
+  }, [ve]);
+  const In = V(!1);
+  ut(() => {
+    var a, m;
+    if (!In.current && zt.current) {
+      if (In.current = !0, Rt && Z.current.length > 0) {
+        const d = pt.current;
+        if (d) {
+          const w = d.getBoundingClientRect(), I = (vt == null ? void 0 : vt.padding) ?? 0.1, $ = Mn(Z.current), h = Rn($, w.width, w.height, I);
+          vt != null && vt.maxZoom && (h.zoom = Math.min(h.zoom, vt.maxZoom)), vt != null && vt.minZoom && (h.zoom = Math.max(h.zoom, vt.minZoom)), gt.current = h, Et();
+        }
+      }
+      (m = (a = Q.current).onInit) == null || m.call(a, {
+        getNodes: () => [...Z.current],
+        getEdges: () => [...Pt.current],
+        getViewport: () => ({ ...gt.current }),
+        fitView: (d = {}) => {
+          const w = pt.current;
+          if (!w || !Z.current.length) return;
+          const I = w.getBoundingClientRect(), $ = Mn(Z.current), h = Rn($, I.width, I.height, d.padding ?? 0.1);
+          gt.current = h, Et();
+        }
+      });
+    }
+  });
+  const yr = F(() => {
+    gt.current = { ...Nt }, Et();
+  }, [Et, Nt]), gr = F((a) => {
+    var m;
+    if (a)
+      se.current.push(a);
+    else {
+      const d = gt.current, w = pt.current;
+      if (!w) return;
+      const I = w.getBoundingClientRect(), $ = Math.round(-d.x / d.zoom + I.width / 2 / d.zoom), h = Math.round(-d.y / d.zoom + I.height / 2 / d.zoom);
+      se.current.push({
+        x: $ - 80,
+        y: h - 45,
+        w: 160,
+        h: 90,
+        title: "Note " + (se.current.length + 1),
+        body: "Added at viewport center"
+      });
+    }
+    (m = zt.current) == null || m.postMessage({ type: "cards", data: { cards: [...se.current] } });
+  }, []), pr = F((a) => {
+    if (a.id || (a.id = "node-" + Date.now()), !a.position) {
+      const m = gt.current, d = pt.current;
+      if (!d) return;
+      const w = d.getBoundingClientRect();
+      a.position = {
+        x: Math.round(-m.x / m.zoom + w.width / 2 / m.zoom) - Vt / 2,
+        y: Math.round(-m.y / m.zoom + w.height / 2 / m.zoom) - jt / 2
+      };
+    }
+    a.data || (a.data = { label: a.id }), wt.current && wt.current([{ type: "add", item: a }]);
+  }, []), xr = F(() => ({ ...gt.current }), []), mr = F((a) => {
+    gt.current = { ...gt.current, ...a }, Et();
+  }, [Et]), vr = F((a) => st(a.x, a.y), [st]), $n = n, wr = St(() => ({
+    wrapRef: pt,
+    canvasRef: Te,
+    workerRef: zt,
+    cameraRef: gt,
+    nodesRef: Z,
+    edgesRef: Pt,
+    handleRegistryRef: yn,
+    syncNodesToWorker: Ft,
+    onNodesChangeRef: wt,
+    onEdgesChangeRef: Dt,
+    sendCamera: Et,
+    screenToWorld: st,
+    viewportListeners: Ot,
+    selectionListeners: he,
+    zoomMin: et,
+    zoomMax: ot,
+    snapToGrid: me,
+    snapGrid: de,
+    nodeExtent: oe,
+    defaultEdgeOptions: be,
+    edgeRouting: fe,
+    resolvedNodesRef: ee,
+    get nodes() {
+      return e;
+    },
+    get edges() {
+      return n;
+    },
+    get routedEdges() {
+      return $n;
+    },
+    get viewport() {
+      return Be;
+    },
+    get connection() {
+      return Ve;
+    }
+  }), [e, n, $n, Be, Ve, Et, st, Ft, Ot, he, et, ot, me, de, oe, be, fe]);
+  return {
+    wrapRef: pt,
+    canvasRef: Te,
+    canvasReady: gn,
+    onPointerDown: dr,
+    onPointerMove: fr,
+    onPointerUp: hr,
+    resetView: yr,
+    addCard: gr,
+    addNode: pr,
+    getCamera: xr,
+    setCamera: mr,
+    screenToFlowPosition: vr,
+    store: wr
+  };
+}
+function Ir(t, e, n, r, s, o) {
+  const i = s - n, c = o - r, u = i * i + c * c;
+  if (u === 0) return Math.hypot(t - n, e - r);
+  let l = ((t - n) * i + (e - r) * c) / u;
+  return l = Math.max(0, Math.min(1, l)), Math.hypot(t - (n + l * i), e - (r + l * c));
+}
+const Zn = Fn(null);
+function ht() {
+  const t = qe(Zn);
+  if (!t)
+    throw new Error("useCanvasStore must be used within <InfiniteCanvas> or <InfiniteCanvasProvider>");
+  return t;
+}
+const je = Fn(null);
+function Ro() {
+  return qe(je);
+}
+function $r({ node: t, nodeType: e }) {
+  var v, E, R;
+  const n = ht(), r = V(null), s = t._absolutePosition || t.position, o = V(null);
+  ut(() => {
+    const M = r.current;
+    if (!M) return;
+    const T = new ResizeObserver((k) => {
+      var D, x, f, p;
+      const { width: z, height: W } = k[0].contentRect;
+      if (z > 0 && W > 0) {
+        const y = n.nodesRef.current.find((P) => P.id === t.id), N = (y == null ? void 0 : y.width) || ((D = y == null ? void 0 : y.measured) == null ? void 0 : D.width), C = (y == null ? void 0 : y.height) || ((x = y == null ? void 0 : y.measured) == null ? void 0 : x.height);
+        (Math.abs((N || 0) - z) > 1 || Math.abs((C || 0) - W) > 1) && ((p = (f = n.onNodesChangeRef).current) == null || p.call(f, [
+          { id: t.id, type: "dimensions", dimensions: { width: z, height: W }, setAttributes: !0 }
+        ]));
+      }
+    });
+    return T.observe(M), () => T.disconnect();
+  }, [t.id, n]);
+  const i = F((M) => {
+    var P, b;
+    if (M.stopPropagation(), n.onNodesChangeRef.current) {
+      const L = [];
+      if (M.shiftKey)
+        L.push({ id: t.id, type: "select", selected: !t.selected });
+      else
+        for (const H of n.nodesRef.current)
+          H.id === t.id && !H.selected ? L.push({ id: H.id, type: "select", selected: !0 }) : H.id !== t.id && H.selected && L.push({ id: H.id, type: "select", selected: !1 });
+      L.length && n.onNodesChangeRef.current(L);
+    }
+    const T = n.cameraRef.current, k = n.wrapRef.current;
+    if (!k) return;
+    const z = k.getBoundingClientRect(), W = (M.clientX - z.left - T.x) / T.zoom, D = (M.clientY - z.top - T.y) / T.zoom, f = M.shiftKey && t.selected ? n.nodesRef.current.filter((L) => L.selected && L.id !== t.id).map((L) => ({ id: L.id, startPos: { ...L.position } })) : [];
+    o.current = {
+      startPos: { ...t.position },
+      startMouse: { x: W, y: D },
+      selectedStarts: f
+    };
+    const p = [{ id: t.id, type: "position", dragging: !0 }];
+    for (const L of f)
+      p.push({ id: L.id, type: "position", dragging: !0 });
+    (b = (P = n.onNodesChangeRef).current) == null || b.call(P, p);
+    const y = r.current;
+    y && y.setPointerCapture(M.pointerId);
+    const N = (L) => {
+      var at, ct, lt, Ct;
+      if (!o.current) return;
+      const Y = n.cameraRef.current, H = k.getBoundingClientRect(), dt = (L.clientX - H.left - Y.x) / Y.zoom, yt = (L.clientY - H.top - Y.y) / Y.zoom, ft = dt - o.current.startMouse.x, G = yt - o.current.startMouse.y;
+      let j = { x: o.current.startPos.x + ft, y: o.current.startPos.y + G };
+      if (n.snapToGrid && n.snapGrid && (j = {
+        x: n.snapGrid[0] * Math.round(j.x / n.snapGrid[0]),
+        y: n.snapGrid[1] * Math.round(j.y / n.snapGrid[1])
+      }), t.parentId && t.extent === "parent") {
+        const et = n.nodesRef.current.find((ot) => ot.id === t.parentId);
+        if (et) {
+          const ot = et.width || 160, Nt = et.height || 60, Rt = t.width || ((at = t.measured) == null ? void 0 : at.width) || 160, vt = t.height || ((ct = t.measured) == null ? void 0 : ct.height) || 60;
+          j = {
+            x: Math.max(0, Math.min(j.x, ot - Rt)),
+            y: Math.max(0, Math.min(j.y, Nt - vt))
+          };
+        }
+      }
+      const rt = [{ id: t.id, type: "position", position: j, dragging: !0 }];
+      for (const et of o.current.selectedStarts) {
+        let ot = { x: et.startPos.x + ft, y: et.startPos.y + G };
+        n.snapToGrid && n.snapGrid && (ot = {
+          x: n.snapGrid[0] * Math.round(ot.x / n.snapGrid[0]),
+          y: n.snapGrid[1] * Math.round(ot.y / n.snapGrid[1])
+        }), rt.push({ id: et.id, type: "position", position: ot, dragging: !0 });
+      }
+      (Ct = (lt = n.onNodesChangeRef).current) == null || Ct.call(lt, rt);
+    }, C = (L) => {
+      var H, dt;
+      if (!o.current) return;
+      const Y = [{ id: t.id, type: "position", dragging: !1 }];
+      for (const yt of o.current.selectedStarts)
+        Y.push({ id: yt.id, type: "position", dragging: !1 });
+      (dt = (H = n.onNodesChangeRef).current) == null || dt.call(H, Y), o.current = null, y && y.releasePointerCapture(L.pointerId), y == null || y.removeEventListener("pointermove", N), y == null || y.removeEventListener("pointerup", C);
+    };
+    y == null || y.addEventListener("pointermove", N), y == null || y.addEventListener("pointerup", C);
+  }, [t, n]), c = F((M) => {
+    var x, f, p, y, N, C;
+    if (!t.selected) return;
+    const T = M.shiftKey ? 10 : 1;
+    let k = 0, z = 0;
+    switch (M.key) {
+      case "ArrowUp":
+        z = -T;
+        break;
+      case "ArrowDown":
+        z = T;
+        break;
+      case "ArrowLeft":
+        k = -T;
+        break;
+      case "ArrowRight":
+        k = T;
+        break;
+      case "Escape":
+        (f = (x = n.onNodesChangeRef).current) == null || f.call(x, [{ id: t.id, type: "select", selected: !1 }]);
+        return;
+      case "Delete":
+      case "Backspace":
+        t.deletable !== !1 && ((y = (p = n.onNodesChangeRef).current) == null || y.call(p, [{ id: t.id, type: "remove" }]));
+        return;
+      default:
+        return;
+    }
+    M.preventDefault();
+    const W = { x: t.position.x + k, y: t.position.y + z }, D = [{ id: t.id, type: "position", position: W }];
+    for (const P of n.nodesRef.current)
+      P.selected && P.id !== t.id && D.push({ id: P.id, type: "position", position: { x: P.position.x + k, y: P.position.y + z } });
+    (C = (N = n.onNodesChangeRef).current) == null || C.call(N, D);
+  }, [t, n]), u = t.width || ((v = t.measured) == null ? void 0 : v.width), l = t.height || ((E = t.measured) == null ? void 0 : E.height), g = !!(u && l);
+  return /* @__PURE__ */ B(je.Provider, { value: t.id, children: /* @__PURE__ */ B(
+    "div",
+    {
+      ref: r,
+      className: `ric-node-wrapper ${t.selected ? "selected" : ""} ${t.dragging ? "dragging" : ""}`,
+      style: {
+        position: "absolute",
+        left: s.x,
+        top: s.y,
+        zIndex: t.type === "group" ? 0 : t.zIndex || 1,
+        pointerEvents: t.type === "group" ? "none" : "all",
+        cursor: t.dragging ? "grabbing" : "grab",
+        visibility: g ? "visible" : "hidden",
+        userSelect: "none",
+        outline: "none"
+      },
+      "data-nodeid": t.id,
+      tabIndex: t.selectable !== !1 ? 0 : void 0,
+      role: "button",
+      "aria-label": `Node ${((R = t.data) == null ? void 0 : R.label) || t.id}`,
+      "aria-selected": !!t.selected,
+      onPointerDown: i,
+      onKeyDown: c,
+      children: /* @__PURE__ */ B(
+        e,
+        {
+          id: t.id,
+          data: t.data,
+          type: t.type,
+          selected: !!t.selected,
+          dragging: !!t.dragging,
+          draggable: t.draggable !== !1,
+          selectable: t.selectable !== !1,
+          deletable: t.deletable !== !1,
+          isConnectable: t.connectable !== !1,
+          zIndex: t.zIndex || 0,
+          positionAbsoluteX: s.x,
+          positionAbsoluteY: s.y,
+          width: u,
+          height: l,
+          sourcePosition: t.sourcePosition,
+          targetPosition: t.targetPosition,
+          parentId: t.parentId,
+          dragHandle: t.dragHandle
+        }
+      )
+    }
+  ) });
+}
+const Pr = Zt($r), Qn = 160, Kn = 60;
+function Bn(t, e, n, r) {
+  var c, u;
+  const s = t.width || ((c = t.measured) == null ? void 0 : c.width) || Qn, o = t.height || ((u = t.measured) == null ? void 0 : u.height) || Kn, i = t._absolutePosition || t.position;
+  if (t.handleBounds) {
+    const l = t.handleBounds[e] || [], g = n ? l.find((v) => v.id === n) : l[0];
+    if (g && g.x !== void 0 && g.y !== void 0) {
+      const v = g.position || (e === "source" ? "right" : "left");
+      return { x: i.x + g.x, y: i.y + g.y, position: v };
+    }
+  }
+  if (r) {
+    const l = `${t.id}__${n || e}`, g = r.get(l);
+    if (g && g.x !== void 0 && g.y !== void 0)
+      return { x: i.x + g.x, y: i.y + g.y, position: g.position || (e === "source" ? "right" : "left") };
+  }
+  if (t.handles && t.handles.length) {
+    for (const l of t.handles)
+      if (l.type === e && (!n || l.id === n)) {
+        if (l.x !== void 0 && l.y !== void 0)
+          return { x: i.x + l.x, y: i.y + l.y, position: l.position || (e === "source" ? "right" : "left") };
+        const g = l.position || (e === "source" ? "right" : "left");
+        switch (g) {
+          case "top":
+            return { x: i.x + s / 2, y: i.y, position: g };
+          case "bottom":
+            return { x: i.x + s / 2, y: i.y + o, position: g };
+          case "left":
+            return { x: i.x, y: i.y + o / 2, position: g };
+          default:
+            return { x: i.x + s, y: i.y + o / 2, position: g };
+        }
+      }
+  }
+  return e === "source" ? { x: i.x + s, y: i.y + o / 2, position: "right" } : { x: i.x, y: i.y + o / 2, position: "left" };
+}
+function Tr(t, e, n) {
+  return n === "left" ? t - e : n === "right" ? t + e : t;
+}
+function Sr(t, e, n) {
+  return n === "top" ? t - e : n === "bottom" ? t + e : t;
+}
+function Dn({ x: t, y: e, position: n, type: r, onPointerDown: s }) {
+  return /* @__PURE__ */ B(
+    "circle",
+    {
+      className: `ric-edge-anchor ric-edge-anchor-${r}`,
+      cx: Tr(t, 10, n),
+      cy: Sr(e, 10, n),
+      r: 10,
+      stroke: "transparent",
+      fill: "transparent",
+      style: { cursor: "move", pointerEvents: "stroke" },
+      onPointerDown: s
+    }
+  );
+}
+function Br({ edge: t, edgeType: e, nodes: n, reconnectable: r }) {
+  var x, f, p;
+  const s = ht(), [o, i] = Gt(null), c = F((y, N, C, P) => {
+    var ft;
+    N.stopPropagation(), N.preventDefault();
+    const b = s.wrapRef.current;
+    if (!b) return;
+    const L = y === "source" ? P : C, Y = y === "source" ? t.target : t.source;
+    (ft = s.workerRef.current) == null || ft.postMessage({
+      type: "connecting",
+      data: { from: { x: L.x, y: L.y }, to: { x: L.x, y: L.y } }
+    });
+    const H = b.getBoundingClientRect(), dt = (G) => {
+      var ct;
+      const j = s.cameraRef.current, rt = (G.clientX - H.left - j.x) / j.zoom, at = (G.clientY - H.top - j.y) / j.zoom;
+      (ct = s.workerRef.current) == null || ct.postMessage({
+        type: "connecting",
+        data: { from: { x: L.x, y: L.y }, to: { x: rt, y: at } }
+      });
+    }, yt = (G) => {
+      var ot, Nt, Rt, vt;
+      const j = s.cameraRef.current, rt = (G.clientX - H.left - j.x) / j.zoom, at = (G.clientY - H.top - j.y) / j.zoom, ct = 20 / j.zoom;
+      let lt = null, Ct = null;
+      const et = (ot = s.handleRegistryRef) == null ? void 0 : ot.current;
+      for (const Lt of s.nodesRef.current) {
+        if (Lt.hidden) continue;
+        const kt = Lt.width || Qn, $t = Lt.height || Kn, mt = Lt._absolutePosition || Lt.position, ne = [];
+        if (et)
+          for (const [, Bt] of et)
+            Bt.nodeId === Lt.id && ne.push(Bt);
+        const Ie = ne.length > 0 ? ne : Lt.handles || [
+          { type: "target", position: "left" },
+          { type: "source", position: "right" }
+        ];
+        for (const Bt of Ie) {
+          let Qt, Yt;
+          if (Bt.x !== void 0 && Bt.y !== void 0)
+            Qt = mt.x + Bt.x, Yt = mt.y + Bt.y;
+          else
+            switch (Bt.position || (Bt.type === "source" ? "right" : "left")) {
+              case "top":
+                Qt = mt.x + kt / 2, Yt = mt.y;
+                break;
+              case "bottom":
+                Qt = mt.x + kt / 2, Yt = mt.y + $t;
+                break;
+              case "left":
+                Qt = mt.x, Yt = mt.y + $t / 2;
+                break;
+              default:
+                Qt = mt.x + kt, Yt = mt.y + $t / 2;
+                break;
+            }
+          if (Math.abs(rt - Qt) < ct && Math.abs(at - Yt) < ct) {
+            lt = Lt, Ct = Bt.id || null;
+            break;
+          }
+        }
+        if (lt) break;
+      }
+      if (lt) {
+        const Lt = y === "source" ? { source: lt.id, target: Y, sourceHandle: Ct, targetHandle: t.targetHandle } : { source: Y, target: lt.id, sourceHandle: t.sourceHandle, targetHandle: Ct };
+        (Rt = (Nt = s.onEdgesChangeRef).current) == null || Rt.call(Nt, [
+          { id: t.id, type: "remove" },
+          { type: "add", item: { id: t.id, ...Lt } }
+        ]);
+      }
+      (vt = s.workerRef.current) == null || vt.postMessage({ type: "connecting", data: null }), b.removeEventListener("pointermove", dt), b.removeEventListener("pointerup", yt);
+    };
+    b.addEventListener("pointermove", dt), b.addEventListener("pointerup", yt);
+  }, [t, s]), u = n.find((y) => y.id === t.source), l = n.find((y) => y.id === t.target), g = u && !!(u.width || (x = u.measured) != null && x.width), v = l && !!(l.width || (f = l.measured) != null && f.width), E = (p = s.handleRegistryRef) == null ? void 0 : p.current, R = g ? Bn(u, "source", t.sourceHandle, E) : null, M = v ? Bn(l, "target", t.targetHandle, E) : null, T = t.type === "bezier" || t.type === "simplebezier" || t.type === "default", k = s.routedEdges || s.edges, z = k == null ? void 0 : k.find((y) => y.id === t.id), W = T ? null : (z == null ? void 0 : z._routedPoints) || t._routedPoints || null, D = r !== !1 && t.reconnectable !== !1;
+  return !R || !M ? null : /* @__PURE__ */ It(
+    "g",
+    {
+      className: `ric-edge-wrapper ${t.selected ? "selected" : ""}`,
+      "data-edgeid": t.id,
+      onMouseEnter: () => i(!0),
+      onMouseLeave: () => i(!1),
+      children: [
+        /* @__PURE__ */ B(
+          e,
+          {
+            id: t.id,
+            source: t.source,
+            target: t.target,
+            sourceX: R.x,
+            sourceY: R.y,
+            targetX: M.x,
+            targetY: M.y,
+            sourcePosition: R.position,
+            targetPosition: M.position,
+            sourceHandleId: t.sourceHandle,
+            targetHandleId: t.targetHandle,
+            data: t.data,
+            type: t.type,
+            selected: !!t.selected,
+            animated: !!t.animated,
+            label: t.label,
+            style: t.style,
+            selectable: t.selectable !== !1,
+            deletable: t.deletable !== !1,
+            routedPoints: W
+          }
+        ),
+        D && (o || t.selected) && /* @__PURE__ */ It(Le, { children: [
+          /* @__PURE__ */ B(
+            Dn,
+            {
+              x: R.x,
+              y: R.y,
+              position: R.position,
+              type: "source",
+              onPointerDown: (y) => c("source", y, R, M)
+            }
+          ),
+          /* @__PURE__ */ B(
+            Dn,
+            {
+              x: M.x,
+              y: M.y,
+              position: M.position,
+              type: "target",
+              onPointerDown: (y) => c("target", y, R, M)
+            }
+          )
+        ] })
+      ]
+    }
+  );
+}
+const Dr = Zt(Br);
+function On({ selectionKeyCode: t = "Shift", selectionMode: e = "partial" }) {
+  var T;
+  const n = ht(), [r, s] = Gt(null), o = V(null);
+  if (ut(() => {
+    const k = n.wrapRef.current;
+    if (!k) return;
+    let z = !1, W = null, D = !1;
+    const x = (C) => {
+      C.key === t && (D = !0);
+    }, f = (C) => {
+      C.key === t && (D = !1);
+    }, p = (C) => {
+      if (!D) return;
+      const P = C.target;
+      if (P.closest(".ric-node-wrapper") || P.closest(".ric-handle")) return;
+      z = !0;
+      const b = n.cameraRef.current, L = k.getBoundingClientRect(), Y = (C.clientX - L.left - b.x) / b.zoom, H = (C.clientY - L.top - b.y) / b.zoom;
+      W = { x: Y, y: H }, s({ startX: Y, startY: H, endX: Y, endY: H }), C.stopPropagation();
+    }, y = (C) => {
+      if (!z || !W) return;
+      const P = n.cameraRef.current, b = k.getBoundingClientRect(), L = (C.clientX - b.left - P.x) / P.zoom, Y = (C.clientY - b.top - P.y) / P.zoom;
+      s({ startX: W.x, startY: W.y, endX: L, endY: Y });
+    }, N = (C) => {
+      var yt, ft;
+      if (!z || !W) return;
+      z = !1;
+      const P = n.cameraRef.current, b = k.getBoundingClientRect(), L = (C.clientX - b.left - P.x) / P.zoom, Y = (C.clientY - b.top - P.y) / P.zoom, H = {
+        x: Math.min(W.x, L),
+        y: Math.min(W.y, Y),
+        width: Math.abs(L - W.x),
+        height: Math.abs(Y - W.y)
+      }, dt = [];
+      for (const G of n.nodesRef.current) {
+        const j = G._absolutePosition || G.position, rt = G.width || 160, at = G.height || 60;
+        let ct;
+        e === "full" ? ct = j.x >= H.x && j.y >= H.y && j.x + rt <= H.x + H.width && j.y + at <= H.y + H.height : ct = j.x + rt > H.x && j.x < H.x + H.width && j.y + at > H.y && j.y < H.y + H.height, dt.push({ id: G.id, type: "select", selected: ct });
+      }
+      dt.length && ((ft = (yt = n.onNodesChangeRef).current) == null || ft.call(yt, dt)), W = null, s(null);
+    };
+    return k.addEventListener("pointerdown", p, !0), k.addEventListener("pointermove", y), k.addEventListener("pointerup", N), window.addEventListener("keydown", x), window.addEventListener("keyup", f), () => {
+      k.removeEventListener("pointerdown", p, !0), k.removeEventListener("pointermove", y), k.removeEventListener("pointerup", N), window.removeEventListener("keydown", x), window.removeEventListener("keyup", f);
+    };
+  }, [n, t, e]), !r) return null;
+  const i = ((T = n.cameraRef) == null ? void 0 : T.current) || { x: 0, y: 0, zoom: 1 }, c = Math.min(r.startX, r.endX), u = Math.min(r.startY, r.endY), l = Math.abs(r.endX - r.startX), g = Math.abs(r.endY - r.startY), v = c * i.zoom + i.x, E = u * i.zoom + i.y, R = l * i.zoom, M = g * i.zoom;
+  return /* @__PURE__ */ B(
+    "div",
+    {
+      ref: o,
+      className: "ric-selection-box",
+      style: {
+        position: "absolute",
+        left: v,
+        top: E,
+        width: R,
+        height: M,
+        border: "1px dashed #3b82f6",
+        background: "rgba(59, 130, 246, 0.08)",
+        pointerEvents: "none",
+        zIndex: 100
+      }
+    }
+  );
+}
+On.displayName = "SelectionBox";
+const Hr = Zt(On);
+function Jn(t, e) {
+  var s, o, i, c;
+  const n = (s = t.handleRegistryRef) == null ? void 0 : s.current;
+  if (!n) return;
+  const r = { source: [], target: [] };
+  for (const [, u] of n)
+    if (u.nodeId === e) {
+      const l = { id: u.id, type: u.type, position: u.position, x: u.x, y: u.y, width: 8, height: 8 };
+      u.type === "source" ? r.source.push(l) : r.target.push(l);
+    }
+  (i = (o = t.onNodesChangeRef).current) == null || i.call(o, [
+    { id: e, type: "dimensions", handleBounds: r, setAttributes: !1 }
+  ]), (c = t.syncNodesToWorker) == null || c.call(t);
+}
+const vn = /* @__PURE__ */ new Set();
+function Hn(t, e) {
+  vn.has(e) || (vn.add(e), queueMicrotask(() => {
+    vn.delete(e), Jn(t, e);
+  }));
+}
+function Ar(t, e) {
+  const n = t.closest(".ric-node-wrapper");
+  if (!n) return null;
+  const r = n.getBoundingClientRect(), s = t.getBoundingClientRect(), o = e || 1;
+  return {
+    x: (s.left + s.width / 2 - r.left) / o,
+    y: (s.top + s.height / 2 - r.top) / o
+  };
+}
+function on({
+  type: t = "source",
+  position: e = t === "source" ? "right" : "left",
+  id: n,
+  isConnectable: r = !0,
+  isConnectableStart: s = !0,
+  isConnectableEnd: o = !0,
+  children: i,
+  className: c = "",
+  style: u = {},
+  onConnect: l,
+  ...g
+}) {
+  const v = qe(je), E = ht(), R = V(null), M = V(E);
+  M.current = E;
+  const T = F(() => {
+    var C, P, b;
+    const D = R.current;
+    if (!D || !v) return;
+    const x = M.current, f = (C = x.handleRegistryRef) == null ? void 0 : C.current;
+    if (!f) return;
+    const p = `${v}__${n || t}`, y = (b = (P = x.cameraRef) == null ? void 0 : P.current) == null ? void 0 : b.zoom, N = Ar(D, y);
+    if (N) {
+      const L = { nodeId: v, id: n || null, type: t, position: e, x: N.x, y: N.y };
+      f.set(p, L);
+    }
+  }, [v, n, t, e]);
+  kr(() => {
+    T();
+  }, [T]), ut(() => {
+    if (!v) return;
+    const D = M.current;
+    Hn(D, v);
+    const x = R.current, f = x == null ? void 0 : x.closest(".ric-node-wrapper"), p = new ResizeObserver(() => {
+      T(), Hn(M.current, v);
+    });
+    return f && p.observe(f), () => {
+      var P;
+      p.disconnect();
+      const y = M.current, N = (P = y.handleRegistryRef) == null ? void 0 : P.current, C = `${v}__${n || t}`;
+      N == null || N.delete(C), Jn(y, v);
+    };
+  }, [v, n, t, e, T]);
+  const k = F(() => {
+    var b;
+    const D = M.current, x = D.nodesRef.current.find((L) => L.id === v);
+    if (!x) return null;
+    const f = x._absolutePosition || x.position, p = (b = D.handleRegistryRef) == null ? void 0 : b.current, y = `${v}__${n || t}`, N = p == null ? void 0 : p.get(y);
+    if (N && N.x !== void 0 && N.y !== void 0)
+      return { x: f.x + N.x, y: f.y + N.y };
+    const C = x.width || 160, P = x.height || 60;
+    switch (e) {
+      case "top":
+        return { x: f.x + C / 2, y: f.y };
+      case "bottom":
+        return { x: f.x + C / 2, y: f.y + P };
+      case "left":
+        return { x: f.x, y: f.y + P / 2 };
+      default:
+        return { x: f.x + C, y: f.y + P / 2 };
+    }
+  }, [v, n, t, e]), z = F((D) => {
+    var Y;
+    if (!r || !s) return;
+    D.stopPropagation(), D.preventDefault();
+    const x = M.current, f = x.cameraRef.current, p = x.wrapRef.current;
+    if (!p) return;
+    const y = p.getBoundingClientRect(), N = k();
+    if (!N) return;
+    const C = N.x, P = N.y;
+    (Y = x.workerRef.current) == null || Y.postMessage({
+      type: "connecting",
+      data: { from: { x: C, y: P }, to: { x: C, y: P } }
+    }), p.setPointerCapture(D.pointerId);
+    const b = (H) => {
+      var ft;
+      const dt = (H.clientX - y.left - f.x) / f.zoom, yt = (H.clientY - y.top - f.y) / f.zoom;
+      (ft = x.workerRef.current) == null || ft.postMessage({
+        type: "connecting",
+        data: { from: { x: C, y: P }, to: { x: dt, y: yt } }
+      });
+    }, L = (H) => {
+      var at, ct, lt, Ct;
+      const dt = (H.clientX - y.left - f.x) / f.zoom, yt = (H.clientY - y.top - f.y) / f.zoom, ft = 20 / f.zoom;
+      let G = null, j = null;
+      const rt = (at = x.handleRegistryRef) == null ? void 0 : at.current;
+      for (const et of x.nodesRef.current) {
+        if (et.id === v || et.hidden) continue;
+        const ot = et.width || 160, Nt = et.height || 60, Rt = et._absolutePosition || et.position, vt = [];
+        if (rt)
+          for (const [, kt] of rt)
+            kt.nodeId === et.id && vt.push(kt);
+        const Lt = vt.length > 0 ? vt : et.handles || [
+          { type: "target", position: "left" },
+          { type: "source", position: "right" }
+        ];
+        for (const kt of Lt) {
+          let $t, mt;
+          if (kt.x !== void 0 && kt.y !== void 0)
+            $t = Rt.x + kt.x, mt = Rt.y + kt.y;
+          else
+            switch (kt.position || (kt.type === "source" ? "right" : "left")) {
+              case "top":
+                $t = Rt.x + ot / 2, mt = Rt.y;
+                break;
+              case "bottom":
+                $t = Rt.x + ot / 2, mt = Rt.y + Nt;
+                break;
+              case "left":
+                $t = Rt.x, mt = Rt.y + Nt / 2;
+                break;
+              default:
+                $t = Rt.x + ot, mt = Rt.y + Nt / 2;
+                break;
+            }
+          if (Math.abs(dt - $t) < ft && Math.abs(yt - mt) < ft) {
+            G = et, j = kt.id || null;
+            break;
+          }
+        }
+        if (G) break;
+      }
+      if (G) {
+        const et = {
+          source: t === "source" ? v : G.id,
+          target: t === "source" ? G.id : v,
+          sourceHandle: t === "source" ? n || null : j,
+          targetHandle: t === "source" ? j : n || null
+        };
+        (lt = (ct = x.onEdgesChangeRef) == null ? void 0 : ct.current) == null || lt.call(ct, [{ type: "add", item: { id: `e-${et.source}-${et.target}`, ...et } }]);
+      }
+      (Ct = x.workerRef.current) == null || Ct.postMessage({ type: "connecting", data: null }), p.removeEventListener("pointermove", b), p.removeEventListener("pointerup", L);
+    };
+    p.addEventListener("pointermove", b), p.addEventListener("pointerup", L);
+  }, [v, n, t, e, r, s, k]), W = {
+    top: { top: 0, left: "50%", transform: "translate(-50%, -50%)" },
+    bottom: { bottom: 0, left: "50%", transform: "translate(-50%, 50%)" },
+    left: { top: "50%", left: 0, transform: "translate(-50%, -50%)" },
+    right: { top: "50%", right: 0, transform: "translate(50%, -50%)" }
+  }[e] || {};
+  return /* @__PURE__ */ B(
+    "div",
+    {
+      ref: R,
+      className: `ric-handle ric-handle-${e} ric-handle-${t} ${c}`,
+      "data-handleid": n || null,
+      "data-nodeid": v,
+      "data-handlepos": e,
+      "data-handletype": t,
+      onPointerDown: z,
+      style: {
+        position: "absolute",
+        width: 8,
+        height: 8,
+        borderRadius: "50%",
+        background: "#1a192b",
+        border: "none",
+        zIndex: 10,
+        cursor: r ? "crosshair" : "default",
+        boxSizing: "border-box",
+        ...W,
+        ...u
+      },
+      ...g,
+      children: i
+    }
+  );
+}
+function ko({
+  data: t,
+  isConnectable: e,
+  selected: n,
+  targetPosition: r = "left",
+  sourcePosition: s = "right",
+  hideSourceHandle: o = !1,
+  hideTargetHandle: i = !1
+}) {
+  return /* @__PURE__ */ It(
+    "div",
+    {
+      className: `ric-default-node${n ? " selected" : ""}`,
+      style: {
+        background: "#fff",
+        border: "1px solid #1a192b",
+        borderRadius: 3,
+        padding: "10px",
+        minWidth: 150,
+        fontSize: 12,
+        fontFamily: "inherit",
+        boxShadow: n ? "0 0 0 0.5px #1a192b" : "none"
+      },
+      children: [
+        !i && /* @__PURE__ */ B(on, { type: "target", position: r, isConnectable: e }),
+        /* @__PURE__ */ B("div", { className: "ric-node-content", children: t == null ? void 0 : t.label }),
+        !o && /* @__PURE__ */ B(on, { type: "source", position: s, isConnectable: e })
+      ]
+    }
+  );
+}
+function _r({
+  data: t,
+  isConnectable: e,
+  selected: n,
+  sourcePosition: r = "right",
+  hideSourceHandle: s = !1
+}) {
+  return /* @__PURE__ */ It(
+    "div",
+    {
+      className: `ric-input-node${n ? " selected" : ""}`,
+      style: {
+        background: "#fff",
+        border: "1px solid #1a192b",
+        borderBottom: "2px solid #0041d0",
+        borderRadius: 3,
+        padding: "10px",
+        minWidth: 150,
+        fontSize: 12,
+        fontFamily: "inherit",
+        boxShadow: n ? "0 0 0 0.5px #1a192b" : "none"
+      },
+      children: [
+        /* @__PURE__ */ B("div", { className: "ric-node-content", children: t == null ? void 0 : t.label }),
+        !s && /* @__PURE__ */ B(on, { type: "source", position: r, isConnectable: e })
+      ]
+    }
+  );
+}
+function Wr({
+  data: t,
+  isConnectable: e,
+  selected: n,
+  targetPosition: r = "left",
+  hideTargetHandle: s = !1
+}) {
+  return /* @__PURE__ */ It(
+    "div",
+    {
+      className: `ric-output-node${n ? " selected" : ""}`,
+      style: {
+        background: "#fff",
+        border: "1px solid #1a192b",
+        borderTop: "2px solid #ff0072",
+        borderRadius: 3,
+        padding: "10px",
+        minWidth: 150,
+        fontSize: 12,
+        fontFamily: "inherit",
+        boxShadow: n ? "0 0 0 0.5px #1a192b" : "none"
+      },
+      children: [
+        !s && /* @__PURE__ */ B(on, { type: "target", position: r, isConnectable: e }),
+        /* @__PURE__ */ B("div", { className: "ric-node-content", children: t == null ? void 0 : t.label })
+      ]
+    }
+  );
+}
+function Xr({ data: t, selected: e, width: n, height: r }) {
+  return /* @__PURE__ */ B(
+    "div",
+    {
+      className: `ric-group-node${e ? " selected" : ""}`,
+      style: {
+        width: n || 300,
+        height: r || 200,
+        background: "rgba(240, 240, 240, 0.25)",
+        border: e ? "2px solid #3b82f6" : "1px dashed #ccc",
+        borderRadius: 8,
+        padding: 8,
+        boxSizing: "border-box"
+      },
+      children: (t == null ? void 0 : t.label) && /* @__PURE__ */ B(
+        "div",
+        {
+          style: {
+            fontSize: 11,
+            fontWeight: 600,
+            color: "#888",
+            userSelect: "none"
+          },
+          children: t.label
+        }
+      )
+    }
+  );
+}
+function Vn({
+  x: t,
+  y: e,
+  label: n,
+  labelStyle: r,
+  labelShowBg: s = !0,
+  labelBgStyle: o,
+  labelBgPadding: i = [2, 4],
+  labelBgBorderRadius: c = 2,
+  children: u,
+  className: l = "",
+  ...g
+}) {
+  const [v, E] = Gt({ x: 1, y: 0, width: 0, height: 0 }), R = V(null);
+  return ut(() => {
+    if (R.current) {
+      const M = R.current.getBBox();
+      E({
+        x: M.x,
+        y: M.y,
+        width: M.width,
+        height: M.height
+      });
+    }
+  }, [n]), n ? /* @__PURE__ */ It(
+    "g",
+    {
+      transform: `translate(${t - v.width / 2} ${e - v.height / 2})`,
+      className: `ric-edge-textwrapper ${l}`,
+      visibility: v.width ? "visible" : "hidden",
+      ...g,
+      children: [
+        s && /* @__PURE__ */ B(
+          "rect",
+          {
+            width: v.width + 2 * i[0],
+            x: -i[0],
+            y: -i[1],
+            height: v.height + 2 * i[1],
+            className: "ric-edge-textbg",
+            style: o,
+            rx: c,
+            ry: c
+          }
+        ),
+        /* @__PURE__ */ B(
+          "text",
+          {
+            className: "ric-edge-text",
+            y: v.height / 2,
+            dy: "0.3em",
+            ref: R,
+            style: r,
+            children: n
+          }
+        ),
+        u
+      ]
+    }
+  ) : null;
+}
+Vn.displayName = "EdgeText";
+const Fr = Zt(Vn);
+function An(t) {
+  return t != null && t !== "" && !isNaN(Number(t));
+}
+function un({
+  id: t,
+  path: e,
+  labelX: n,
+  labelY: r,
+  label: s,
+  labelStyle: o,
+  labelShowBg: i,
+  labelBgStyle: c,
+  labelBgPadding: u,
+  labelBgBorderRadius: l,
+  interactionWidth: g = 20,
+  style: v,
+  markerEnd: E,
+  markerStart: R,
+  className: M = "",
+  ...T
+}) {
+  return /* @__PURE__ */ It(Le, { children: [
+    /* @__PURE__ */ B(
+      "path",
+      {
+        id: t,
+        d: e,
+        fill: "none",
+        stroke: "#b1b1b7",
+        strokeWidth: 1.5,
+        className: `ric-edge-path ${M}`,
+        style: v,
+        markerEnd: E,
+        markerStart: R,
+        ...T
+      }
+    ),
+    g ? /* @__PURE__ */ B(
+      "path",
+      {
+        d: e,
+        fill: "none",
+        strokeOpacity: 0,
+        strokeWidth: g,
+        className: "ric-edge-interaction",
+        style: { pointerEvents: "stroke" }
+      }
+    ) : null,
+    s && An(n) && An(r) ? /* @__PURE__ */ B(
+      Fr,
+      {
+        x: n,
+        y: r,
+        label: s,
+        labelStyle: o,
+        labelShowBg: i,
+        labelBgStyle: c,
+        labelBgPadding: u,
+        labelBgBorderRadius: l
+      }
+    ) : null
+  ] });
+}
+const Ye = 20;
+function _n(t, e, n) {
+  switch (n) {
+    case "right":
+      return { x: t + Ye, y: e };
+    case "left":
+      return { x: t - Ye, y: e };
+    case "bottom":
+      return { x: t, y: e + Ye };
+    case "top":
+      return { x: t, y: e - Ye };
+    default:
+      return { x: t + Ye, y: e };
+  }
+}
+const tr = Zt(function({
+  id: e,
+  sourceX: n,
+  sourceY: r,
+  targetX: s,
+  targetY: o,
+  sourcePosition: i = "bottom",
+  targetPosition: c = "top",
+  label: u,
+  labelStyle: l,
+  labelShowBg: g,
+  labelBgStyle: v,
+  labelBgPadding: E,
+  labelBgBorderRadius: R,
+  style: M,
+  markerEnd: T,
+  markerStart: k,
+  interactionWidth: z
+}) {
+  let W, D, x;
+  const f = _n(n, r, i), p = _n(s, o, c), y = Math.abs(p.x - f.x), N = Math.max(50, y * 0.5);
+  let C, P, b, L;
+  switch (i) {
+    case "left":
+      C = f.x - N, P = f.y;
+      break;
+    case "top":
+      C = f.x, P = f.y - N;
+      break;
+    case "bottom":
+      C = f.x, P = f.y + N;
+      break;
+    default:
+      C = f.x + N, P = f.y;
+      break;
+  }
+  switch (c) {
+    case "right":
+      b = p.x + N, L = p.y;
+      break;
+    case "top":
+      b = p.x, L = p.y - N;
+      break;
+    case "bottom":
+      b = p.x, L = p.y + N;
+      break;
+    default:
+      b = p.x - N, L = p.y;
+      break;
+  }
+  W = `M ${n},${r} L ${f.x},${f.y} C ${C},${P} ${b},${L} ${p.x},${p.y} L ${s},${o}`;
+  const Y = 0.5, H = 0.5;
+  return D = H * H * H * f.x + 3 * H * H * Y * C + 3 * H * Y * Y * b + Y * Y * Y * p.x, x = H * H * H * f.y + 3 * H * H * Y * P + 3 * H * Y * Y * L + Y * Y * Y * p.y, /* @__PURE__ */ B(
+    un,
+    {
+      id: e,
+      path: W,
+      labelX: D,
+      labelY: x,
+      label: u,
+      labelStyle: l,
+      labelShowBg: g,
+      labelBgStyle: v,
+      labelBgPadding: E,
+      labelBgBorderRadius: R,
+      style: M,
+      markerEnd: T,
+      markerStart: k,
+      interactionWidth: z
+    }
+  );
+});
+tr.displayName = "BezierEdge";
+function er({ sourceX: t, sourceY: e, targetX: n, targetY: r }) {
+  const s = `M ${t},${e}L ${n},${r}`, o = (t + n) / 2, i = (e + r) / 2;
+  return [s, o, i, 0, 0];
+}
+function nr({
+  sourceX: t,
+  sourceY: e,
+  targetX: n,
+  targetY: r,
+  sourcePosition: s = "right",
+  targetPosition: o = "left",
+  curvature: i = 0.25
+}) {
+  const c = Math.abs(n - t), u = Math.abs(r - e), l = Math.sqrt(c * c + u * u), g = Math.max(l * i, 50);
+  let v, E, R, M;
+  switch (s) {
+    case "top":
+      v = t, E = e - g;
+      break;
+    case "bottom":
+      v = t, E = e + g;
+      break;
+    case "left":
+      v = t - g, E = e;
+      break;
+    default:
+      v = t + g, E = e;
+      break;
+  }
+  switch (o) {
+    case "top":
+      R = n, M = r - g;
+      break;
+    case "bottom":
+      R = n, M = r + g;
+      break;
+    case "right":
+      R = n + g, M = r;
+      break;
+    default:
+      R = n - g, M = r;
+      break;
+  }
+  const T = `M ${t},${e} C ${v},${E} ${R},${M} ${n},${r}`, k = 0.5, z = 1 - k, W = z * z * z * t + 3 * z * z * k * v + 3 * z * k * k * R + k * k * k * n, D = z * z * z * e + 3 * z * z * k * E + 3 * z * k * k * M + k * k * k * r;
+  return [T, W, D, 0, 0];
+}
+function rr({ sourceX: t, sourceY: e, targetX: n, targetY: r }) {
+  const s = Math.abs(n - t), o = Math.max(s * 0.5, 50), i = t + o, c = n - o, u = `M ${t},${e} C ${i},${e} ${c},${r} ${n},${r}`, l = 0.5, g = 0.5, v = g * g * g * t + 3 * g * g * l * i + 3 * g * l * l * c + l * l * l * n, E = g * g * g * e + 3 * g * g * l * e + 3 * g * l * l * r + l * l * l * r;
+  return [u, v, E, 0, 0];
+}
+function kn({
+  sourceX: t,
+  sourceY: e,
+  targetX: n,
+  targetY: r,
+  sourcePosition: s = "right",
+  targetPosition: o = "left",
+  borderRadius: i = 5,
+  offset: c = 20
+}) {
+  const u = s === "left" || s === "right", l = Math.min(i, Math.abs(n - t) / 2, Math.abs(r - e) / 2);
+  if (u) {
+    if (Math.abs(r - e) < 1)
+      return [`M ${t},${e} L ${n},${r}`, (t + n) / 2, e, 0, 0];
+    const R = (t + n) / 2, M = r > e ? 1 : -1;
+    return [`M ${t},${e} L ${R - l},${e} Q ${R},${e} ${R},${e + M * l} L ${R},${r - M * l} Q ${R},${r} ${R + (n > R ? l : -l)},${r} L ${n},${r}`, R, (e + r) / 2, 0, 0];
+  }
+  const g = (e + r) / 2, v = n > t ? 1 : -1;
+  return [`M ${t},${e} L ${t},${g - l} Q ${t},${g} ${t + v * l},${g} L ${n - v * l},${g} Q ${n},${g} ${n},${g + (r > g ? l : -l)} L ${n},${r}`, (t + n) / 2, g, 0, 0];
+}
+function zo({ sourceX: t, sourceY: e, targetX: n, targetY: r }) {
+  const [, s, o] = nr({ sourceX: t, sourceY: e, targetX: n, targetY: r });
+  return [s, o, 0, 0];
+}
+function Eo({ sourceX: t, sourceY: e, targetX: n, targetY: r }) {
+  return [(t + n) / 2, (e + r) / 2, 0, 0];
+}
+function Co(t, e, n) {
+  const r = n.filter((o) => o.id !== t.id), s = {
+    ...t,
+    id: t.id,
+    source: e.source,
+    target: e.target,
+    sourceHandle: e.sourceHandle ?? t.sourceHandle,
+    targetHandle: e.targetHandle ?? t.targetHandle
+  };
+  return r.push(s), r;
+}
+const sn = 160, an = 60, Ue = 20, nn = 12, cn = 20;
+function Wn(t, e, n) {
+  var i, c;
+  const r = t.width || ((i = t.measured) == null ? void 0 : i.width) || sn, s = t.height || ((c = t.measured) == null ? void 0 : c.height) || an, o = t._absolutePosition || t.position;
+  if (t.handles && t.handles.length > 0) {
+    for (const u of t.handles)
+      if (u.type === e && (!n || u.id === n)) {
+        if (u.x !== void 0 && u.y !== void 0)
+          return { x: o.x + u.x, y: o.y + u.y, dir: u.position || (e === "source" ? "right" : "left") };
+        switch (u.position || (e === "source" ? "right" : "left")) {
+          case "top":
+            return { x: o.x + r / 2, y: o.y, dir: "top" };
+          case "bottom":
+            return { x: o.x + r / 2, y: o.y + s, dir: "bottom" };
+          case "left":
+            return { x: o.x, y: o.y + s / 2, dir: "left" };
+          default:
+            return { x: o.x + r, y: o.y + s / 2, dir: "right" };
+        }
+      }
+  }
+  return e === "source" ? { x: o.x + r, y: o.y + s / 2, dir: "right" } : { x: o.x, y: o.y + s / 2, dir: "left" };
+}
+function ln(t, e) {
+  switch (t.dir) {
+    case "right":
+      return { x: t.x + e, y: t.y, dir: t.dir };
+    case "left":
+      return { x: t.x - e, y: t.y, dir: t.dir };
+    case "bottom":
+      return { x: t.x, y: t.y + e, dir: t.dir };
+    case "top":
+      return { x: t.x, y: t.y - e, dir: t.dir };
+    default:
+      return { x: t.x + e, y: t.y, dir: t.dir };
+  }
+}
+function Yr(t, e, n, r, s, o, i, c) {
+  const u = Math.min(t, n), l = Math.max(t, n), g = Math.min(e, r), v = Math.max(e, r);
+  if (l <= s || u >= s + i || v <= o || g >= o + c) return !1;
+  const E = 0.5;
+  if (t > s + E && t < s + i - E && e > o + E && e < o + c - E || n > s + E && n < s + i - E && r > o + E && r < o + c - E) return !0;
+  const R = (t + n) / 2, M = (e + r) / 2;
+  if (R > s + E && R < s + i - E && M > o + E && M < o + c - E) return !0;
+  const T = [[s, o], [s + i, o], [s + i, o + c], [s, o + c]];
+  for (let k = 0; k < 4; k++)
+    if (Ur(t, e, n, r, T[k][0], T[k][1], T[(k + 1) % 4][0], T[(k + 1) % 4][1])) return !0;
+  return !1;
+}
+function Ur(t, e, n, r, s, o, i, c) {
+  const u = (i - s) * (e - o) - (c - o) * (t - s), l = (i - s) * (r - o) - (c - o) * (n - s), g = (n - t) * (o - e) - (r - e) * (s - t), v = (n - t) * (c - e) - (r - e) * (i - t);
+  return (u > 0 && l < 0 || u < 0 && l > 0) && (g > 0 && v < 0 || g < 0 && v > 0);
+}
+function zn(t, e, n, r, s) {
+  for (let o = 0; o < s.length; o++) {
+    const i = s[o];
+    if (Yr(t, e, n, r, i.x, i.y, i.w, i.h)) return !1;
+  }
+  return !0;
+}
+function qr(t, e, n) {
+  for (let r = 0; r < n.length; r++) {
+    const s = n[r];
+    if (t > s.x && t < s.x + s.w && e > s.y && e < s.y + s.h) return !0;
+  }
+  return !1;
+}
+function or(t, e) {
+  var r, s;
+  const n = [];
+  for (let o = 0; o < t.length; o++) {
+    const i = t[o];
+    if (i.hidden || e && e.has(i.id) || i.type === "group") continue;
+    const c = i._absolutePosition || i.position, u = i.width || ((r = i.measured) == null ? void 0 : r.width) || sn, l = i.height || ((s = i.measured) == null ? void 0 : s.height) || an;
+    n.push({
+      id: i.id,
+      x: c.x - Ue,
+      y: c.y - Ue,
+      w: u + 2 * Ue,
+      h: l + 2 * Ue
+    });
+  }
+  return n;
+}
+function sr(t, e, n) {
+  if (zn(t.x, t.y, e.x, e.y, n))
+    return null;
+  const r = /* @__PURE__ */ new Set(), s = /* @__PURE__ */ new Set();
+  r.add(t.x), r.add(e.x), s.add(t.y), s.add(e.y);
+  const o = Ue + 5;
+  t.dir === "right" ? r.add(t.x + o) : t.dir === "left" ? r.add(t.x - o) : t.dir === "top" ? s.add(t.y - o) : t.dir === "bottom" && s.add(t.y + o), e.dir === "right" ? r.add(e.x + o) : e.dir === "left" ? r.add(e.x - o) : e.dir === "top" ? s.add(e.y - o) : e.dir === "bottom" && s.add(e.y + o);
+  for (let b = 0; b < n.length; b++) {
+    const L = n[b];
+    r.add(L.x), r.add(L.x + L.w), s.add(L.y), s.add(L.y + L.h);
+  }
+  const i = [...r].sort((b, L) => b - L), c = [...s].sort((b, L) => b - L), u = /* @__PURE__ */ new Map(), l = /* @__PURE__ */ new Map();
+  for (let b = 0; b < i.length; b++) u.set(i[b], b);
+  for (let b = 0; b < c.length; b++) l.set(c[b], b);
+  const g = i.length, v = c.length, E = (b, L) => L * g + b, R = u.get(t.x), M = l.get(t.y), T = u.get(e.x), k = l.get(e.y);
+  if (R === void 0 || M === void 0 || T === void 0 || k === void 0) return null;
+  const z = E(R, M), W = E(T, k), D = new Float64Array(g * v).fill(1 / 0), x = new Float64Array(g * v).fill(1 / 0), f = new Int32Array(g * v).fill(-1), p = new Int8Array(g * v).fill(-1), y = new Uint8Array(g * v);
+  D[z] = 0, x[z] = Math.abs(i[T] - t.x) + Math.abs(c[k] - t.y);
+  const N = [z], C = 15, P = [[1, 0], [-1, 0], [0, 1], [0, -1]];
+  for (; N.length > 0; ) {
+    let b = 0;
+    for (let G = 1; G < N.length; G++)
+      x[N[G]] < x[N[b]] && (b = G);
+    const L = N[b];
+    if (N[b] = N[N.length - 1], N.pop(), L === W) {
+      const G = [];
+      let j = W;
+      for (; j !== -1 && j !== z; ) {
+        const rt = j / g | 0, at = j % g;
+        G.unshift({ x: i[at], y: c[rt] }), j = f[j];
+      }
+      return G.unshift({ x: t.x, y: t.y }), jr(G, n);
+    }
+    if (y[L]) continue;
+    y[L] = 1;
+    const Y = L / g | 0, H = L % g, dt = i[H], yt = c[Y], ft = p[L];
+    for (let G = 0; G < 4; G++) {
+      const j = H + P[G][0], rt = Y + P[G][1];
+      if (j < 0 || j >= g || rt < 0 || rt >= v) continue;
+      const at = E(j, rt);
+      if (y[at]) continue;
+      const ct = i[j], lt = c[rt];
+      if (qr(ct, lt, n) || !zn(dt, yt, ct, lt, n)) continue;
+      const Ct = Math.abs(ct - dt) + Math.abs(lt - yt), et = ft >= 0 && ft !== G ? C : 0, ot = D[L] + Ct + et;
+      ot < D[at] && (f[at] = L, p[at] = G, D[at] = ot, x[at] = ot + Math.abs(i[T] - ct) + Math.abs(c[k] - lt), N.push(at));
+    }
+  }
+  return null;
+}
+function jr(t, e) {
+  if (!t || t.length <= 2) return t;
+  const n = [t[0]];
+  for (let r = 1; r < t.length - 1; r++) {
+    const s = n[n.length - 1], o = t[r], i = t[r + 1], c = Math.abs(s.x - o.x) < 0.5 && Math.abs(o.x - i.x) < 0.5, u = Math.abs(s.y - o.y) < 0.5 && Math.abs(o.y - i.y) < 0.5;
+    (c || u) && zn(s.x, s.y, i.x, i.y, e) || n.push(o);
+  }
+  return n.push(t[t.length - 1]), n;
+}
+function Gr(t) {
+  const e = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map();
+  for (const s of t) {
+    const o = s._routedPoints;
+    if (!(!o || o.length < 2))
+      for (let i = 0; i < o.length - 1; i++) {
+        const c = o[i], u = o[i + 1];
+        if (Math.abs(c.y - u.y) < 0.5) {
+          const l = Math.round(c.y * 10) / 10;
+          e.has(l) || e.set(l, []), e.get(l).push({ edgeId: s.id, segIdx: i, x1: Math.min(c.x, u.x), x2: Math.max(c.x, u.x) });
+        } else if (Math.abs(c.x - u.x) < 0.5) {
+          const l = Math.round(c.x * 10) / 10;
+          n.has(l) || n.set(l, []), n.get(l).push({ edgeId: s.id, segIdx: i, y1: Math.min(c.y, u.y), y2: Math.max(c.y, u.y) });
+        }
+      }
+  }
+  const r = /* @__PURE__ */ new Map();
+  for (const s of t)
+    s._routedPoints && r.set(s.id, s._routedPoints.map((o) => ({ ...o })));
+  for (const [, s] of e) {
+    if (s.length < 2) continue;
+    const o = Xn(s, "x1", "x2");
+    for (const i of o) {
+      if (i.length < 2) continue;
+      const c = (i.length - 1) * nn / 2;
+      for (let u = 0; u < i.length; u++) {
+        const l = i[u], g = -c + u * nn, v = r.get(l.edgeId);
+        v && (v[l.segIdx].y += g, v[l.segIdx + 1].y += g);
+      }
+    }
+  }
+  for (const [, s] of n) {
+    if (s.length < 2) continue;
+    const o = Xn(s, "y1", "y2");
+    for (const i of o) {
+      if (i.length < 2) continue;
+      const c = (i.length - 1) * nn / 2;
+      for (let u = 0; u < i.length; u++) {
+        const l = i[u], g = -c + u * nn, v = r.get(l.edgeId);
+        v && (v[l.segIdx].x += g, v[l.segIdx + 1].x += g);
+      }
+    }
+  }
+  return t.map((s) => {
+    const o = r.get(s.id);
+    return o ? { ...s, _routedPoints: o } : s;
+  });
+}
+function Xn(t, e, n) {
+  if (t.length < 2) return [];
+  const r = [...t].sort((i, c) => i[e] - c[e]), s = [];
+  let o = [r[0]];
+  for (let i = 1; i < r.length; i++) {
+    const c = o[o.length - 1];
+    r[i][e] < c[n] ? o.push(r[i]) : (o.length > 1 && s.push(o), o = [r[i]]);
+  }
+  return o.length > 1 && s.push(o), s;
+}
+function En(t, e = 6, n = !1) {
+  if (!t || t.length < 2) return null;
+  if (n) return Zr(t);
+  const r = e;
+  let s = `M ${t[0].x},${t[0].y}`;
+  for (let o = 1; o < t.length - 1; o++) {
+    const i = t[o - 1], c = t[o], u = t[o + 1], l = Math.abs(c.x - i.x) + Math.abs(c.y - i.y), g = Math.abs(u.x - c.x) + Math.abs(u.y - c.y), v = Math.min(r, l / 2, g / 2);
+    if (v > 0.5) {
+      const E = c.x - i.x, R = c.y - i.y, M = u.x - c.x, T = u.y - c.y, k = Math.sqrt(E * E + R * R) || 1, z = Math.sqrt(M * M + T * T) || 1;
+      s += ` L ${c.x - E / k * v},${c.y - R / k * v}`, s += ` Q ${c.x},${c.y} ${c.x + M / z * v},${c.y + T / z * v}`;
+    } else
+      s += ` L ${c.x},${c.y}`;
+  }
+  return s += ` L ${t[t.length - 1].x},${t[t.length - 1].y}`, s;
+}
+function Zr(t) {
+  if (t.length === 2)
+    return `M ${t[0].x},${t[0].y} L ${t[1].x},${t[1].y}`;
+  if (t.length === 3)
+    return `M ${t[0].x},${t[0].y} Q ${t[1].x},${t[1].y} ${t[2].x},${t[2].y}`;
+  const e = 0.3;
+  let n = `M ${t[0].x},${t[0].y}`;
+  for (let r = 0; r < t.length - 1; r++) {
+    const s = t[r === 0 ? 0 : r - 1], o = t[r], i = t[r + 1], c = t[r + 2 < t.length ? r + 2 : t.length - 1], u = o.x + (i.x - s.x) * e, l = o.y + (i.y - s.y) * e, g = i.x - (c.x - o.x) * e, v = i.y - (c.y - o.y) * e;
+    n += ` C ${u},${l} ${g},${v} ${i.x},${i.y}`;
+  }
+  return n;
+}
+function Cn(t) {
+  if (!t || t.length < 2) return { x: 0, y: 0 };
+  let e = 0;
+  for (let r = 1; r < t.length; r++)
+    e += Math.abs(t[r].x - t[r - 1].x) + Math.abs(t[r].y - t[r - 1].y);
+  let n = e / 2;
+  for (let r = 1; r < t.length; r++) {
+    const s = Math.abs(t[r].x - t[r - 1].x) + Math.abs(t[r].y - t[r - 1].y);
+    if (n <= s) {
+      const o = s > 0 ? n / s : 0;
+      return {
+        x: t[r - 1].x + (t[r].x - t[r - 1].x) * o,
+        y: t[r - 1].y + (t[r].y - t[r - 1].y) * o
+      };
+    }
+    n -= s;
+  }
+  return { x: t[0].x, y: t[0].y };
+}
+function No(t, e) {
+  if (!t || !e || t.length === 0 || e.length === 0) return e;
+  const n = {};
+  for (const o of t) n[o.id] = o;
+  const r = or(t, null), s = e.map((o) => {
+    var p, y, N, C;
+    const i = o.type || "default";
+    if (i === "bezier" || i === "simplebezier" || i === "default") return o;
+    const c = n[o.source], u = n[o.target];
+    if (!c || !u || c.hidden || u.hidden) return o;
+    const l = Wn(c, "source", o.sourceHandle), g = Wn(u, "target", o.targetHandle), v = ln(l, cn), E = ln(g, cn), R = 5, M = r.filter((P) => P.id !== o.source && P.id !== o.target), T = c._absolutePosition || c.position, k = c.width || ((p = c.measured) == null ? void 0 : p.width) || sn, z = c.height || ((y = c.measured) == null ? void 0 : y.height) || an;
+    M.push({ id: o.source, x: T.x - R, y: T.y - R, w: k + 2 * R, h: z + 2 * R });
+    const W = u._absolutePosition || u.position, D = u.width || ((N = u.measured) == null ? void 0 : N.width) || sn, x = u.height || ((C = u.measured) == null ? void 0 : C.height) || an;
+    if (M.push({ id: o.target, x: W.x - R, y: W.y - R, w: D + 2 * R, h: x + 2 * R }), M.length === 0) return o;
+    const f = sr(v, E, M);
+    return f && f.length >= 2 ? (f.unshift({ x: l.x, y: l.y }), f.push({ x: g.x, y: g.y }), { ...o, _routedPoints: f }) : o;
+  });
+  return Gr(s);
+}
+function Lo(t, e, n, r, s, o, i, c) {
+  const u = or(i, c ? new Set(c) : null);
+  if (u.length === 0) return null;
+  const l = { x: t, y: e, dir: s || "right" }, g = { x: n, y: r, dir: o || "left" }, v = ln(l, cn), E = ln(g, cn), R = sr(v, E, u);
+  return R && R.length >= 2 ? (R.unshift({ x: l.x, y: l.y }), R.push({ x: g.x, y: g.y }), R) : null;
+}
+const ir = Zt(function({
+  id: e,
+  sourceX: n,
+  sourceY: r,
+  targetX: s,
+  targetY: o,
+  label: i,
+  labelStyle: c,
+  labelShowBg: u,
+  labelBgStyle: l,
+  labelBgPadding: g,
+  labelBgBorderRadius: v,
+  style: E,
+  markerEnd: R,
+  markerStart: M,
+  interactionWidth: T,
+  routedPoints: k
+}) {
+  let z, W, D;
+  if (k && k.length >= 2) {
+    z = En(k);
+    const x = Cn(k);
+    W = x.x, D = x.y;
+  } else
+    [z, W, D] = er({ sourceX: n, sourceY: r, targetX: s, targetY: o });
+  return /* @__PURE__ */ B(
+    un,
+    {
+      id: e,
+      path: z,
+      labelX: W,
+      labelY: D,
+      label: i,
+      labelStyle: c,
+      labelShowBg: u,
+      labelBgStyle: l,
+      labelBgPadding: g,
+      labelBgBorderRadius: v,
+      style: E,
+      markerEnd: R,
+      markerStart: M,
+      interactionWidth: T
+    }
+  );
+});
+ir.displayName = "StraightEdge";
+const ar = Zt(function({
+  id: e,
+  sourceX: n,
+  sourceY: r,
+  targetX: s,
+  targetY: o,
+  sourcePosition: i = "bottom",
+  targetPosition: c = "top",
+  label: u,
+  labelStyle: l,
+  labelShowBg: g,
+  labelBgStyle: v,
+  labelBgPadding: E,
+  labelBgBorderRadius: R,
+  style: M,
+  markerEnd: T,
+  markerStart: k,
+  pathOptions: z,
+  interactionWidth: W,
+  routedPoints: D
+}) {
+  let x, f, p;
+  if (D && D.length >= 2) {
+    x = En(D);
+    const y = Cn(D);
+    f = y.x, p = y.y;
+  } else
+    [x, f, p] = kn({
+      sourceX: n,
+      sourceY: r,
+      sourcePosition: i,
+      targetX: s,
+      targetY: o,
+      targetPosition: c,
+      borderRadius: z == null ? void 0 : z.borderRadius,
+      offset: z == null ? void 0 : z.offset
+    });
+  return /* @__PURE__ */ B(
+    un,
+    {
+      id: e,
+      path: x,
+      labelX: f,
+      labelY: p,
+      label: u,
+      labelStyle: l,
+      labelShowBg: g,
+      labelBgStyle: v,
+      labelBgPadding: E,
+      labelBgBorderRadius: R,
+      style: M,
+      markerEnd: T,
+      markerStart: k,
+      interactionWidth: W
+    }
+  );
+});
+ar.displayName = "SmoothStepEdge";
+const Qr = Zt(function({ id: e, ...n }) {
+  var s;
+  const r = St(
+    () => {
+      var o;
+      return { borderRadius: 0, offset: (o = n.pathOptions) == null ? void 0 : o.offset };
+    },
+    [(s = n.pathOptions) == null ? void 0 : s.offset]
+  );
+  return /* @__PURE__ */ B(ar, { ...n, id: e, pathOptions: r });
+});
+Qr.displayName = "StepEdge";
+const cr = Zt(function({
+  id: e,
+  sourceX: n,
+  sourceY: r,
+  targetX: s,
+  targetY: o,
+  sourcePosition: i,
+  targetPosition: c,
+  label: u,
+  labelStyle: l,
+  labelShowBg: g,
+  labelBgStyle: v,
+  labelBgPadding: E,
+  labelBgBorderRadius: R,
+  style: M,
+  markerEnd: T,
+  markerStart: k,
+  interactionWidth: z,
+  routedPoints: W
+}) {
+  let D, x, f;
+  if (W && W.length >= 2) {
+    D = En(W);
+    const p = Cn(W);
+    x = p.x, f = p.y;
+  } else
+    [D, x, f] = rr({
+      sourceX: n,
+      sourceY: r,
+      targetX: s,
+      targetY: o
+    });
+  return /* @__PURE__ */ B(
+    un,
+    {
+      id: e,
+      path: D,
+      labelX: x,
+      labelY: f,
+      label: u,
+      labelStyle: l,
+      labelShowBg: g,
+      labelBgStyle: v,
+      labelBgPadding: E,
+      labelBgBorderRadius: R,
+      style: M,
+      markerEnd: T,
+      markerStart: k,
+      interactionWidth: z
+    }
+  );
+});
+cr.displayName = "SimpleBezierEdge";
+const Kr = {
+  input: _r,
+  output: Wr,
+  group: Xr
+}, Or = {
+  // smoothstep/step are handled by the canvas worker directly (not React SVG)
+  bezier: tr,
+  straight: ir,
+  simplebezier: cr
+};
+function Io({
+  // Data
+  cards: t,
+  nodes: e = [],
+  edges: n = [],
+  // Custom types
+  nodeTypes: r,
+  edgeTypes: s,
+  // Appearance
+  dark: o,
+  gridSize: i,
+  width: c = "100%",
+  height: u = "420px",
+  className: l = "",
+  style: g = {},
+  // Zoom/Camera
+  zoomMin: v,
+  zoomMax: E,
+  initialCamera: R,
+  fitView: M,
+  fitViewOptions: T,
+  // Node/Edge callbacks
+  onNodesChange: k,
+  onEdgesChange: z,
+  onConnect: W,
+  onConnectStart: D,
+  onConnectEnd: x,
+  onNodeClick: f,
+  onNodeDoubleClick: p,
+  onNodeMouseEnter: y,
+  onNodeMouseMove: N,
+  onNodeMouseLeave: C,
+  onNodeContextMenu: P,
+  onNodeDragStart: b,
+  onNodeDrag: L,
+  onNodeDragStop: Y,
+  onEdgeClick: H,
+  onEdgeDoubleClick: dt,
+  onEdgeMouseEnter: yt,
+  onEdgeMouseMove: ft,
+  onEdgeMouseLeave: G,
+  onEdgeContextMenu: j,
+  onPaneClick: rt,
+  onPaneContextMenu: at,
+  onPaneMouseEnter: ct,
+  onPaneMouseMove: lt,
+  onPaneMouseLeave: Ct,
+  onSelectionChange: et,
+  onInit: ot,
+  onMoveStart: Nt,
+  onMove: Rt,
+  onMoveEnd: vt,
+  onDelete: Lt,
+  onBeforeDelete: kt,
+  onError: $t,
+  // Drag and drop
+  onDragOver: mt,
+  onDrop: ne,
+  onDragEnter: Ie,
+  onDragLeave: Bt,
+  // Behavior
+  nodesDraggable: Qt,
+  nodesConnectable: Yt,
+  elementsSelectable: me,
+  multiSelectionKeyCode: de,
+  selectionOnDrag: ve,
+  selectionMode: we,
+  connectionMode: Ge,
+  connectionRadius: $e,
+  connectOnClick: Ze,
+  isValidConnection: Qe,
+  defaultEdgeOptions: Ke,
+  snapToGrid: Oe,
+  snapGrid: Pe,
+  deleteKeyCode: re,
+  panActivationKeyCode: oe,
+  panOnScroll: be,
+  panOnScrollMode: dn,
+  panOnScrollSpeed: fn,
+  zoomOnScroll: Kt,
+  zoomOnDoubleClick: Nn,
+  zoomOnPinch: hn,
+  preventScrolling: fe,
+  translateExtent: pt,
+  nodeExtent: Te,
+  autoPanOnNodeDrag: zt,
+  autoPanOnConnect: gt,
+  autoPanSpeed: se,
+  edgesReconnectable: Z,
+  elevateNodesOnSelect: Pt,
+  elevateEdgesOnSelect: yn,
+  // Edge routing (obstacle avoidance)
+  edgeRouting: Se = !0,
+  // HUD
+  onHudUpdate: te,
+  onNodesProcessed: gn,
+  showHud: pn = !0,
+  showHint: _t = !0,
+  hintText: Wt = "Drag to pan · Scroll to zoom",
+  children: Me,
+  ...ie
+}) {
+  const [Ut, Re] = Gt({ wx: 0, wy: 0, zoom: "1.00" }), Be = V(null), Je = V(null), Ve = F(
+    (K) => {
+      Re(K), te == null || te(K);
+    },
+    [te]
+  ), ae = St(() => ({ ...Kr, ...r }), [r]), Ot = St(() => ({ ...Or, ...s }), [s]), he = St(() => {
+    const K = e.filter((Ft) => Ft.type && ae[Ft.type]);
+    return K.sort((Ft, st) => {
+      const Tt = Ft.type === "group" || !Ft.parentId && K.some((Ee) => Ee.parentId === Ft.id), xe = st.type === "group" || !st.parentId && K.some((Ee) => Ee.parentId === st.id);
+      return Tt && !xe ? -1 : !Tt && xe ? 1 : 0;
+    });
+  }, [e, ae]), ke = St(() => n.filter((K) => K.type && Ot[K.type]), [n, Ot]), Q = St(() => e.map((K) => K.type && ae[K.type] ? { ...K, _customRendered: !0 } : K), [e, ae]), wt = St(() => n.map((K) => K.type && Ot[K.type] ? { ...K, _customRendered: !0 } : K), [n, Ot]), {
+    wrapRef: Dt,
+    canvasRef: ce,
+    canvasReady: De,
+    onPointerDown: He,
+    onPointerMove: Ae,
+    onPointerUp: _e,
+    store: le
+  } = Lr({
+    cards: t,
+    nodes: Q,
+    edges: wt,
+    dark: o,
+    gridSize: i,
+    zoomMin: v,
+    zoomMax: E,
+    initialCamera: R,
+    fitView: M,
+    fitViewOptions: T,
+    onHudUpdate: Ve,
+    onNodesProcessed: gn,
+    onNodesChange: k,
+    onEdgesChange: z,
+    onConnect: W,
+    onConnectStart: D,
+    onConnectEnd: x,
+    onNodeClick: f,
+    onNodeDoubleClick: p,
+    onNodeMouseEnter: y,
+    onNodeMouseMove: N,
+    onNodeMouseLeave: C,
+    onNodeContextMenu: P,
+    onNodeDragStart: b,
+    onNodeDrag: L,
+    onNodeDragStop: Y,
+    onEdgeClick: H,
+    onEdgeDoubleClick: dt,
+    onEdgeMouseEnter: yt,
+    onEdgeMouseMove: ft,
+    onEdgeMouseLeave: G,
+    onEdgeContextMenu: j,
+    onPaneClick: rt,
+    onPaneContextMenu: at,
+    onPaneMouseEnter: ct,
+    onPaneMouseMove: lt,
+    onPaneMouseLeave: Ct,
+    onSelectionChange: et,
+    onInit: ot,
+    onMoveStart: Nt,
+    onMove: Rt,
+    onMoveEnd: vt,
+    onDelete: Lt,
+    onBeforeDelete: kt,
+    onError: $t,
+    nodesDraggable: Qt,
+    nodesConnectable: Yt,
+    elementsSelectable: me,
+    multiSelectionKeyCode: de,
+    selectionOnDrag: ve,
+    selectionMode: we,
+    connectionMode: Ge,
+    connectionRadius: $e,
+    connectOnClick: Ze,
+    isValidConnection: Qe,
+    defaultEdgeOptions: Ke,
+    snapToGrid: Oe,
+    snapGrid: Pe,
+    deleteKeyCode: re,
+    panActivationKeyCode: oe,
+    panOnScroll: be,
+    panOnScrollMode: dn,
+    panOnScrollSpeed: fn,
+    zoomOnScroll: Kt,
+    zoomOnDoubleClick: Nn,
+    zoomOnPinch: hn,
+    preventScrolling: fe,
+    translateExtent: pt,
+    nodeExtent: Te,
+    autoPanOnNodeDrag: zt,
+    autoPanOnConnect: gt,
+    autoPanSpeed: se,
+    edgesReconnectable: Z,
+    elevateNodesOnSelect: Pt,
+    edgeRouting: Se
+  }), We = St(() => ({
+    ...le,
+    edgeLabelContainerRef: Be,
+    viewportPortalRef: Je,
+    // Override nodes/edges getters to return ALL nodes (canvas + custom)
+    get nodes() {
+      return e;
+    },
+    get edges() {
+      return n;
+    }
+  }), [le, e, n]), ye = V(null), ge = V(null), pe = V(null), Jt = V(null);
+  ut(() => {
+    let K;
+    const Ft = () => {
+      const st = le.cameraRef.current, Tt = `translate(${st.x}px, ${st.y}px) scale(${st.zoom})`, xe = `translate(${st.x}, ${st.y}) scale(${st.zoom})`;
+      ye.current && (ye.current.style.transform = Tt), ge.current && ge.current.setAttribute("transform", xe), pe.current && (pe.current.style.transform = Tt), Jt.current && (Jt.current.style.transform = Tt), K = requestAnimationFrame(Ft);
+    };
+    return K = requestAnimationFrame(Ft), () => cancelAnimationFrame(K);
+  }, [le]);
+  const ze = he.length > 0, ee = ke.length > 0;
+  return /* @__PURE__ */ B(Zn.Provider, { value: We, children: /* @__PURE__ */ It(
+    "div",
+    {
+      ref: Dt,
+      className: `ric-wrap ${l}`,
+      style: { width: c, height: u, ...g },
+      onPointerDown: He,
+      onPointerMove: Ae,
+      onPointerUp: _e,
+      onDragOver: mt,
+      onDrop: ne,
+      onDragEnter: Ie,
+      onDragLeave: Bt,
+      tabIndex: 0,
+      children: [
+        /* @__PURE__ */ B("canvas", { ref: ce, className: "ric-canvas" }),
+        !De && /* @__PURE__ */ B("div", { className: "ric-loader", children: /* @__PURE__ */ B("div", { className: "ric-spinner" }) }),
+        ee && /* @__PURE__ */ B(
+          "svg",
+          {
+            className: "ric-edges-overlay",
+            style: {
+              position: "absolute",
+              top: 0,
+              left: 0,
+              width: "100%",
+              height: "100%",
+              pointerEvents: "none",
+              overflow: "visible"
+            },
+            children: /* @__PURE__ */ B("g", { ref: ge, children: ke.map((K) => /* @__PURE__ */ B(
+              Dr,
+              {
+                edge: K,
+                edgeType: Ot[K.type],
+                nodes: e,
+                reconnectable: Z
+              },
+              K.id
+            )) })
+          }
+        ),
+        ze && /* @__PURE__ */ B(
+          "div",
+          {
+            ref: ye,
+            className: "ric-nodes-overlay",
+            style: {
+              position: "absolute",
+              top: 0,
+              left: 0,
+              width: 0,
+              height: 0,
+              transformOrigin: "0 0",
+              pointerEvents: "none",
+              zIndex: 10
+            },
+            children: he.map((K) => /* @__PURE__ */ B(
+              Pr,
+              {
+                node: K,
+                nodeType: ae[K.type]
+              },
+              K.id
+            ))
+          }
+        ),
+        /* @__PURE__ */ B(
+          "div",
+          {
+            ref: (K) => {
+              Be.current = K, pe.current = K;
+            },
+            className: "ric-edge-labels",
+            style: {
+              position: "absolute",
+              top: 0,
+              left: 0,
+              width: 0,
+              height: 0,
+              transformOrigin: "0 0",
+              pointerEvents: "none",
+              zIndex: 5
+            }
+          }
+        ),
+        /* @__PURE__ */ B(
+          "div",
+          {
+            ref: (K) => {
+              Je.current = K, Jt.current = K;
+            },
+            className: "ric-viewport-portal",
+            style: {
+              position: "absolute",
+              top: 0,
+              left: 0,
+              width: 0,
+              height: 0,
+              transformOrigin: "0 0",
+              pointerEvents: "none",
+              zIndex: 6
+            }
+          }
+        ),
+        _t && /* @__PURE__ */ B("div", { className: "ric-hint", children: Wt }),
+        pn && /* @__PURE__ */ It("div", { className: "ric-info", children: [
+          "world: (",
+          Ut.wx,
+          ", ",
+          Ut.wy,
+          ")   zoom: ",
+          Ut.zoom,
+          "x",
+          Ut.nodeCount > 0 && /* @__PURE__ */ It(Le, { children: [
+            "   nodes: ",
+            Ut.nodeCount
+          ] }),
+          Ut.edgeCount > 0 && /* @__PURE__ */ It(Le, { children: [
+            "   edges: ",
+            Ut.edgeCount
+          ] })
+        ] }),
+        /* @__PURE__ */ B(
+          Hr,
+          {
+            selectionKeyCode: de || "Shift",
+            selectionMode: we || "partial"
+          }
+        ),
+        Me
+      ]
+    }
+  ) });
+}
+function $o({ children: t }) {
+  return t;
+}
+function lr(t, e) {
+  const n = [], r = /* @__PURE__ */ new Map(), s = [];
+  for (const o of t)
+    if (o.type === "add")
+      s.push(o);
+    else if (o.type === "remove" || o.type === "replace")
+      r.set(o.id, [o]);
+    else {
+      const i = r.get(o.id);
+      i ? i.push(o) : r.set(o.id, [o]);
+    }
+  for (const o of e) {
+    const i = r.get(o.id);
+    if (!i) {
+      n.push(o);
+      continue;
+    }
+    if (i[0].type === "remove") continue;
+    if (i[0].type === "replace") {
+      n.push({ ...i[0].item });
+      continue;
+    }
+    const c = { ...o };
+    for (const u of i)
+      Jr(u, c);
+    n.push(c);
+  }
+  for (const o of s)
+    o.index !== void 0 ? n.splice(o.index, 0, { ...o.item }) : n.push({ ...o.item });
+  return n;
+}
+function Jr(t, e) {
+  switch (t.type) {
+    case "select":
+      e.selected = t.selected;
+      break;
+    case "position":
+      t.position !== void 0 && (e.position = t.position), t.dragging !== void 0 && (e.dragging = t.dragging);
+      break;
+    case "dimensions":
+      t.dimensions !== void 0 && (e.measured = { ...t.dimensions }, (t.setAttributes === !0 || t.setAttributes === "width") && (e.width = t.dimensions.width), (t.setAttributes === !0 || t.setAttributes === "height") && (e.height = t.dimensions.height)), t.handleBounds !== void 0 && (e.handleBounds = t.handleBounds);
+      break;
+  }
+}
+function Vr(t, e) {
+  return lr(t, e);
+}
+function to(t, e) {
+  return lr(t, e);
+}
+function Po(t, e) {
+  return !t.source || !t.target ? (console.warn("addEdge: source and target are required"), e) : e.some(
+    (r) => r.source === t.source && r.target === t.target && (r.sourceHandle || null) === (t.sourceHandle || null) && (r.targetHandle || null) === (t.targetHandle || null)
+  ) ? e : [...e, {
+    id: t.id || `e-${t.source}-${t.target}`,
+    ...t
+  }];
+}
+function To(t) {
+  const [e, n] = Gt(t), r = F(
+    (s) => n((o) => Vr(s, o)),
+    []
+  );
+  return [e, n, r];
+}
+function So(t) {
+  const [e, n] = Gt(t), r = F(
+    (s) => n((o) => to(s, o)),
+    []
+  );
+  return [e, n, r];
+}
+function eo() {
+  const t = ht(), e = F(() => [...t.nodesRef.current], [t]), n = F(() => [...t.edgesRef.current], [t]), r = F((x) => t.nodesRef.current.find((f) => f.id === x), [t]), s = F((x) => t.edgesRef.current.find((f) => f.id === x), [t]), o = F((x) => {
+    var f, p, y, N;
+    if (typeof x == "function") {
+      const C = x(t.nodesRef.current);
+      (p = (f = t.onNodesChangeRef).current) == null || p.call(f, [
+        ...t.nodesRef.current.map((P) => ({ id: P.id, type: "remove" })),
+        ...C.map((P) => ({ type: "add", item: P }))
+      ]);
+    } else
+      (N = (y = t.onNodesChangeRef).current) == null || N.call(y, [
+        ...t.nodesRef.current.map((C) => ({ id: C.id, type: "remove" })),
+        ...x.map((C) => ({ type: "add", item: C }))
+      ]);
+  }, [t]), i = F((x) => {
+    var f, p, y, N;
+    if (typeof x == "function") {
+      const C = x(t.edgesRef.current);
+      (p = (f = t.onEdgesChangeRef).current) == null || p.call(f, [
+        ...t.edgesRef.current.map((P) => ({ id: P.id, type: "remove" })),
+        ...C.map((P) => ({ type: "add", item: P }))
+      ]);
+    } else
+      (N = (y = t.onEdgesChangeRef).current) == null || N.call(y, [
+        ...t.edgesRef.current.map((C) => ({ id: C.id, type: "remove" })),
+        ...x.map((C) => ({ type: "add", item: C }))
+      ]);
+  }, [t]), c = F((x) => {
+    var p, y;
+    const f = Array.isArray(x) ? x : [x];
+    (y = (p = t.onNodesChangeRef).current) == null || y.call(p, f.map((N) => ({ type: "add", item: N })));
+  }, [t]), u = F((x) => {
+    var p, y;
+    const f = Array.isArray(x) ? x : [x];
+    (y = (p = t.onEdgesChangeRef).current) == null || y.call(p, f.map((N) => ({ type: "add", item: N })));
+  }, [t]), l = F(({ nodes: x = [], edges: f = [] }) => {
+    if (x.length && t.onNodesChangeRef.current) {
+      t.onNodesChangeRef.current(x.map((y) => ({ id: y.id, type: "remove" })));
+      const p = zr(x, t.edgesRef.current);
+      p.length && t.onEdgesChangeRef.current && t.onEdgesChangeRef.current(p.map((y) => ({ id: y.id, type: "remove" })));
+    }
+    f.length && t.onEdgesChangeRef.current && t.onEdgesChangeRef.current(f.map((p) => ({ id: p.id, type: "remove" })));
+  }, [t]), g = F(() => {
+    const x = t.cameraRef.current;
+    return { x: x.x, y: x.y, zoom: x.zoom };
+  }, [t]), v = F((x, f) => {
+    t.cameraRef.current = {
+      x: x.x ?? t.cameraRef.current.x,
+      y: x.y ?? t.cameraRef.current.y,
+      zoom: x.zoom ?? t.cameraRef.current.zoom
+    }, t.sendCamera();
+  }, [t]), E = F(() => t.cameraRef.current.zoom, [t]), R = F((x) => {
+    const f = t.cameraRef.current, p = t.wrapRef.current;
+    if (!p) return;
+    const y = p.getBoundingClientRect(), N = y.width / 2, C = y.height / 2, P = 1.2;
+    f.x = N - (N - f.x) * P, f.y = C - (C - f.y) * P, f.zoom = Math.min(t.zoomMax, f.zoom * P), t.sendCamera();
+  }, [t]), M = F((x) => {
+    const f = t.cameraRef.current, p = t.wrapRef.current;
+    if (!p) return;
+    const y = p.getBoundingClientRect(), N = y.width / 2, C = y.height / 2, P = 1 / 1.2;
+    f.x = N - (N - f.x) * P, f.y = C - (C - f.y) * P, f.zoom = Math.max(t.zoomMin, f.zoom * P), t.sendCamera();
+  }, [t]), T = F((x) => {
+    const f = t.cameraRef.current, p = t.wrapRef.current;
+    if (!p) return;
+    const y = p.getBoundingClientRect(), N = y.width / 2, C = y.height / 2, P = x / f.zoom;
+    f.x = N - (N - f.x) * P, f.y = C - (C - f.y) * P, f.zoom = Math.min(t.zoomMax, Math.max(t.zoomMin, x)), t.sendCamera();
+  }, [t]), k = F((x = {}) => {
+    const f = t.nodesRef.current;
+    if (!f.length) return;
+    const p = t.wrapRef.current;
+    if (!p) return;
+    const y = p.getBoundingClientRect(), N = x.padding ?? 0.1, C = x.nodes ? f.filter((L) => x.nodes.some((Y) => Y.id === L.id)) : f;
+    if (!C.length) return;
+    const P = Mn(C), b = Rn(P, y.width, y.height, N);
+    x.maxZoom && (b.zoom = Math.min(b.zoom, x.maxZoom)), x.minZoom && (b.zoom = Math.max(b.zoom, x.minZoom)), t.cameraRef.current = b, t.sendCamera();
+  }, [t]), z = F((x, f, p = {}) => {
+    const y = t.wrapRef.current;
+    if (!y) return;
+    const N = y.getBoundingClientRect(), C = p.zoom ?? t.cameraRef.current.zoom;
+    t.cameraRef.current = {
+      x: N.width / 2 - x * C,
+      y: N.height / 2 - f * C,
+      zoom: C
+    }, t.sendCamera();
+  }, [t]), W = F((x) => t.screenToWorld(x.x, x.y), [t]), D = F((x) => {
+    const f = t.cameraRef.current, p = t.wrapRef.current;
+    if (!p) return { x: 0, y: 0 };
+    const y = p.getBoundingClientRect();
+    return {
+      x: x.x * f.zoom + f.x + y.left,
+      y: x.y * f.zoom + f.y + y.top
+    };
+  }, [t]);
+  return {
+    getNodes: e,
+    getEdges: n,
+    getNode: r,
+    getEdge: s,
+    setNodes: o,
+    setEdges: i,
+    addNodes: c,
+    addEdges: u,
+    deleteElements: l,
+    getViewport: g,
+    setViewport: v,
+    getZoom: E,
+    zoomIn: R,
+    zoomOut: M,
+    zoomTo: T,
+    fitView: k,
+    setCenter: z,
+    screenToFlowPosition: W,
+    flowToScreenPosition: D
+  };
+}
+function Bo() {
+  return ht().nodes;
+}
+function Do() {
+  return ht().edges;
+}
+function Ho() {
+  return ht().viewport;
+}
+function Ao() {
+  return ht().connection;
+}
+function _o(t) {
+  const e = ht(), n = Array.isArray(t) ? t : [t];
+  return St(() => n.map((r) => {
+    const s = e.nodes.find((o) => o.id === r);
+    return s ? { id: s.id, type: s.type, data: s.data } : null;
+  }).filter(Boolean), [e.nodes, ...n]);
+}
+function Wo(t) {
+  const e = ht();
+  return St(() => e.edges.filter((n) => n.source === t || n.target === t), [e.edges, t]);
+}
+function Xo({ nodeId: t, type: e, handleId: n }) {
+  const r = ht();
+  return St(() => r.edges.filter((s) => e === "source" ? s.source === t && (n ? s.sourceHandle === n : !0) : s.target === t && (n ? s.targetHandle === n : !0)), [r.edges, t, e, n]);
+}
+function Fo({ onChange: t, onStart: e, onEnd: n }) {
+  const r = ht(), s = V(t), o = V(e), i = V(n);
+  ut(() => {
+    s.current = t;
+  }, [t]), ut(() => {
+    o.current = e;
+  }, [e]), ut(() => {
+    i.current = n;
+  }, [n]), ut(() => {
+    const c = (u) => {
+      var l;
+      (l = s.current) == null || l.call(s, { x: u.x, y: u.y, zoom: u.zoom });
+    };
+    return r.viewportListeners.add(c), () => r.viewportListeners.delete(c);
+  }, [r]);
+}
+function Yo({ onChange: t }) {
+  const e = ht(), n = V(t);
+  ut(() => {
+    n.current = t;
+  }, [t]), ut(() => {
+    const r = (s) => {
+      var o;
+      (o = n.current) == null || o.call(n, s);
+    };
+    return e.selectionListeners.add(r), () => e.selectionListeners.delete(r);
+  }, [e]);
+}
+function Uo(t) {
+  const [e, n] = Gt(!1), r = Array.isArray(t) ? t : [t];
+  return ut(() => {
+    const s = (i) => {
+      r.includes(i.key) && n(!0);
+    }, o = (i) => {
+      r.includes(i.key) && n(!1);
+    };
+    return window.addEventListener("keydown", s), window.addEventListener("keyup", o), () => {
+      window.removeEventListener("keydown", s), window.removeEventListener("keyup", o);
+    };
+  }, [r.join(",")]), e;
+}
+function qo() {
+  const t = ht();
+  return F((e) => {
+    var n;
+    (n = t.workerRef.current) == null || n.postMessage({
+      type: "nodes",
+      data: { nodes: [...t.nodesRef.current] }
+    });
+  }, [t]);
+}
+function jo(t = {}) {
+  return ht().nodes.length > 0;
+}
+function Go(t) {
+  const e = ht();
+  return St(() => e.nodes.find((n) => n.id === t) || void 0, [e.nodes, t]);
+}
+function Zo(t) {
+  const e = ht();
+  return typeof t == "function" ? t(e) : e;
+}
+function Qo() {
+  const t = ht();
+  return St(() => ({
+    getState: () => t,
+    setState: () => {
+      console.warn("[infinite-canvas] setState on storeApi is not supported. Use onNodesChange/onEdgesChange instead.");
+    }
+  }), [t]);
+}
+const wn = 160, bn = 60;
+function Ko({
+  width: t = 200,
+  height: e = 150,
+  nodeColor: n = "#3b82f6",
+  nodeStrokeColor: r = "#fff",
+  maskColor: s = "rgba(0,0,0,0.1)",
+  style: o = {},
+  className: i = ""
+}) {
+  const c = ht(), u = V(null), l = V(null), g = F(() => {
+    const v = u.current;
+    if (!v) return;
+    const E = v.getContext("2d"), R = window.devicePixelRatio || 1;
+    v.width = t * R, v.height = e * R, E.scale(R, R), E.clearRect(0, 0, t, e);
+    const M = c.nodesRef.current;
+    if (!M.length) return;
+    let T = 1 / 0, k = 1 / 0, z = -1 / 0, W = -1 / 0;
+    for (const b of M) {
+      const L = b.width || wn, Y = b.height || bn;
+      b.position.x < T && (T = b.position.x), b.position.y < k && (k = b.position.y), b.position.x + L > z && (z = b.position.x + L), b.position.y + Y > W && (W = b.position.y + Y);
+    }
+    const D = 40;
+    T -= D, k -= D, z += D, W += D;
+    const x = z - T, f = W - k, p = Math.min(t / x, e / f), y = (t - x * p) / 2, N = (e - f * p) / 2;
+    for (const b of M) {
+      if (b.hidden) continue;
+      const L = b.width || wn, Y = b.height || bn, H = (b.position.x - T) * p + y, dt = (b.position.y - k) * p + N, yt = L * p, ft = Y * p;
+      E.fillStyle = b.selected ? "#f59e0b" : typeof n == "function" ? n(b) : n, E.fillRect(H, dt, Math.max(yt, 2), Math.max(ft, 2));
+    }
+    const C = c.cameraRef.current, P = c.wrapRef.current;
+    if (P) {
+      const b = P.getBoundingClientRect(), L = -C.x / C.zoom, Y = -C.y / C.zoom, H = b.width / C.zoom, dt = b.height / C.zoom;
+      E.fillStyle = s, E.fillRect(0, 0, t, e);
+      const yt = (L - T) * p + y, ft = (Y - k) * p + N, G = H * p, j = dt * p;
+      E.clearRect(yt, ft, G, j);
+      for (const rt of M) {
+        if (rt.hidden) continue;
+        const at = rt.width || wn, ct = rt.height || bn, lt = (rt.position.x - T) * p + y, Ct = (rt.position.y - k) * p + N;
+        E.fillStyle = rt.selected ? "#f59e0b" : typeof n == "function" ? n(rt) : n, E.fillRect(lt, Ct, Math.max(at * p, 2), Math.max(ct * p, 2));
+      }
+      E.strokeStyle = "#3b82f6", E.lineWidth = 1.5, E.strokeRect(yt, ft, G, j);
+    }
+  }, [c, t, e, n, r, s]);
+  return ut(() => {
+    let v = !0;
+    function E() {
+      v && (g(), l.current = requestAnimationFrame(E));
+    }
+    const R = setInterval(() => {
+      cancelAnimationFrame(l.current), l.current = requestAnimationFrame(E);
+    }, 66);
+    return g(), () => {
+      v = !1, clearInterval(R), cancelAnimationFrame(l.current);
+    };
+  }, [g]), /* @__PURE__ */ B(
+    "canvas",
+    {
+      ref: u,
+      className: `ric-minimap ${i}`,
+      style: {
+        position: "absolute",
+        bottom: 30,
+        right: 10,
+        width: t,
+        height: e,
+        borderRadius: 4,
+        border: "1px solid rgba(0,0,0,0.1)",
+        background: "rgba(255,255,255,0.9)",
+        pointerEvents: "none",
+        ...o
+      }
+    }
+  );
+}
+function no() {
+  return /* @__PURE__ */ It("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", width: "16", height: "16", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+    /* @__PURE__ */ B("line", { x1: "12", y1: "5", x2: "12", y2: "19" }),
+    /* @__PURE__ */ B("line", { x1: "5", y1: "12", x2: "19", y2: "12" })
+  ] });
+}
+function ro() {
+  return /* @__PURE__ */ B("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", width: "16", height: "16", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: /* @__PURE__ */ B("line", { x1: "5", y1: "12", x2: "19", y2: "12" }) });
+}
+function oo() {
+  return /* @__PURE__ */ B("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", width: "16", height: "16", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: /* @__PURE__ */ B("path", { d: "M15 3h6v6M9 21H3v-6M21 3l-7 7M3 21l7-7" }) });
+}
+function so() {
+  return /* @__PURE__ */ It("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", width: "16", height: "16", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+    /* @__PURE__ */ B("rect", { x: "3", y: "11", width: "18", height: "11", rx: "2" }),
+    /* @__PURE__ */ B("path", { d: "M7 11V7a5 5 0 0 1 10 0v4" })
+  ] });
+}
+function io() {
+  return /* @__PURE__ */ It("svg", { xmlns: "http://www.w3.org/2000/svg", viewBox: "0 0 24 24", width: "16", height: "16", fill: "none", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round", children: [
+    /* @__PURE__ */ B("rect", { x: "3", y: "11", width: "18", height: "11", rx: "2" }),
+    /* @__PURE__ */ B("path", { d: "M7 11V7a5 5 0 0 1 9.9-1" })
+  ] });
+}
+function rn({ children: t, className: e = "", ...n }) {
+  return /* @__PURE__ */ B(
+    "button",
+    {
+      className: `ric-controls-button ${e}`,
+      style: co,
+      ...n,
+      children: t
+    }
+  );
+}
+function ao({
+  showZoom: t = !0,
+  showFitView: e = !0,
+  showInteractive: n = !1,
+  fitViewOptions: r,
+  onZoomIn: s,
+  onZoomOut: o,
+  onFitView: i,
+  onInteractiveChange: c,
+  position: u = "bottom-left",
+  orientation: l = "vertical",
+  style: g = {},
+  className: v = "",
+  "aria-label": E = "Canvas controls",
+  children: R
+}) {
+  const M = ht(), { zoomIn: T, zoomOut: k, fitView: z, getZoom: W } = eo(), [D, x] = Gt(!0), f = W() <= M.zoomMin, p = W() >= M.zoomMax, y = F(() => {
+    T(), s == null || s();
+  }, [T, s]), N = F(() => {
+    k(), o == null || o();
+  }, [k, o]), C = F(() => {
+    z(r || { padding: 0.1 }), i == null || i();
+  }, [z, r, i]), P = F(() => {
+    const L = !D;
+    x(L), c == null || c(L);
+  }, [D, c]), b = {
+    "top-left": { top: 10, left: 10 },
+    "top-right": { top: 10, right: 10 },
+    "top-center": { top: 10, left: "50%", transform: "translateX(-50%)" },
+    "bottom-left": { bottom: 30, left: 10 },
+    "bottom-right": { bottom: 30, right: 10 },
+    "bottom-center": { bottom: 30, left: "50%", transform: "translateX(-50%)" }
+  }[u] || { bottom: 30, left: 10 };
+  return /* @__PURE__ */ It(
+    "div",
+    {
+      className: `ric-controls ${v}`,
+      style: {
+        position: "absolute",
+        display: "flex",
+        flexDirection: l === "horizontal" ? "row" : "column",
+        gap: 2,
+        zIndex: 5,
+        ...b,
+        ...g
+      },
+      role: "toolbar",
+      "aria-label": E,
+      children: [
+        t && /* @__PURE__ */ It(Le, { children: [
+          /* @__PURE__ */ B(
+            rn,
+            {
+              onClick: y,
+              disabled: p,
+              title: "Zoom in",
+              "aria-label": "Zoom in",
+              className: "ric-controls-zoomin",
+              children: /* @__PURE__ */ B(no, {})
+            }
+          ),
+          /* @__PURE__ */ B(
+            rn,
+            {
+              onClick: N,
+              disabled: f,
+              title: "Zoom out",
+              "aria-label": "Zoom out",
+              className: "ric-controls-zoomout",
+              children: /* @__PURE__ */ B(ro, {})
+            }
+          )
+        ] }),
+        e && /* @__PURE__ */ B(
+          rn,
+          {
+            onClick: C,
+            title: "Fit view",
+            "aria-label": "Fit view",
+            className: "ric-controls-fitview",
+            children: /* @__PURE__ */ B(oo, {})
+          }
+        ),
+        n && /* @__PURE__ */ B(
+          rn,
+          {
+            onClick: P,
+            title: D ? "Lock interactivity" : "Unlock interactivity",
+            "aria-label": D ? "Lock interactivity" : "Unlock interactivity",
+            className: "ric-controls-interactive",
+            children: D ? /* @__PURE__ */ B(io, {}) : /* @__PURE__ */ B(so, {})
+          }
+        ),
+        R
+      ]
+    }
+  );
+}
+const co = {
+  width: 28,
+  height: 28,
+  display: "flex",
+  alignItems: "center",
+  justifyContent: "center",
+  border: "1px solid rgba(0,0,0,0.12)",
+  borderRadius: 4,
+  background: "#fff",
+  cursor: "pointer",
+  fontSize: 16,
+  lineHeight: 1,
+  color: "#333",
+  padding: 0
+}, Oo = Zt(ao);
+function Jo({
+  variant: t = "lines",
+  gap: e = 40,
+  size: n = 1,
+  color: r,
+  style: s = {},
+  className: o = ""
+}) {
+  const i = ht();
+  return i.workerRef.current && i.workerRef.current.postMessage({
+    type: "background",
+    data: { variant: t, gap: e, size: n, color: r }
+  }), null;
+}
+function Vo({
+  position: t = "top-left",
+  style: e = {},
+  className: n = "",
+  children: r
+}) {
+  const s = {
+    "top-left": { top: 10, left: 10 },
+    "top-right": { top: 10, right: 10 },
+    "top-center": { top: 10, left: "50%", transform: "translateX(-50%)" },
+    "bottom-left": { bottom: 10, left: 10 },
+    "bottom-right": { bottom: 10, right: 10 },
+    "bottom-center": { bottom: 10, left: "50%", transform: "translateX(-50%)" }
+  }[t] || { top: 10, left: 10 };
+  return /* @__PURE__ */ B(
+    "div",
+    {
+      className: `ric-panel ${n}`,
+      style: {
+        position: "absolute",
+        zIndex: 5,
+        pointerEvents: "all",
+        ...s,
+        ...e
+      },
+      onPointerDown: (o) => o.stopPropagation(),
+      children: r
+    }
+  );
+}
+function ts({
+  minWidth: t = 10,
+  minHeight: e = 10,
+  maxWidth: n = 1 / 0,
+  maxHeight: r = 1 / 0,
+  isVisible: s = !0,
+  handleStyle: o = {},
+  lineStyle: i = {},
+  color: c = "#3b82f6",
+  onResizeStart: u,
+  onResize: l,
+  onResizeEnd: g
+}) {
+  const v = qe(je), E = ht(), R = V(null), M = F((z, W) => {
+    z.stopPropagation(), z.preventDefault();
+    const D = E.nodesRef.current.find((p) => p.id === v);
+    if (!D) return;
+    R.current = {
+      direction: W,
+      startX: z.clientX,
+      startY: z.clientY,
+      width: D.width || 160,
+      height: D.height || 60
+    }, u == null || u(z, { width: R.current.width, height: R.current.height });
+    const x = (p) => {
+      var Y, H;
+      if (!R.current) return;
+      const y = R.current, N = E.cameraRef.current, C = (p.clientX - y.startX) / N.zoom, P = (p.clientY - y.startY) / N.zoom;
+      let b = y.width, L = y.height;
+      y.direction.includes("e") && (b = Math.min(n, Math.max(t, y.width + C))), y.direction.includes("w") && (b = Math.min(n, Math.max(t, y.width - C))), y.direction.includes("s") && (L = Math.min(r, Math.max(e, y.height + P))), y.direction.includes("n") && (L = Math.min(r, Math.max(e, y.height - P))), (H = (Y = E.onNodesChangeRef).current) == null || H.call(Y, [
+        { id: v, type: "dimensions", dimensions: { width: b, height: L }, setAttributes: !0 }
+      ]), l == null || l(p, { width: b, height: L });
+    }, f = (p) => {
+      R.current = null, g == null || g(p, {}), window.removeEventListener("pointermove", x), window.removeEventListener("pointerup", f);
+    };
+    window.addEventListener("pointermove", x), window.addEventListener("pointerup", f);
+  }, [v, E, t, e, n, r, u, l, g]);
+  if (!s) return null;
+  const T = 8, k = {
+    position: "absolute",
+    width: T,
+    height: T,
+    background: c,
+    border: "1px solid #fff",
+    borderRadius: 2,
+    zIndex: 20,
+    ...o
+  };
+  return /* @__PURE__ */ It(Le, { children: [
+    /* @__PURE__ */ B(
+      "div",
+      {
+        style: { ...k, bottom: -T / 2, right: -T / 2, cursor: "nwse-resize" },
+        onPointerDown: (z) => M(z, "se")
+      }
+    ),
+    /* @__PURE__ */ B(
+      "div",
+      {
+        style: { ...k, bottom: -T / 2, left: -T / 2, cursor: "nesw-resize" },
+        onPointerDown: (z) => M(z, "sw")
+      }
+    ),
+    /* @__PURE__ */ B(
+      "div",
+      {
+        style: { ...k, top: -T / 2, right: -T / 2, cursor: "nesw-resize" },
+        onPointerDown: (z) => M(z, "ne")
+      }
+    ),
+    /* @__PURE__ */ B(
+      "div",
+      {
+        style: { ...k, top: -T / 2, left: -T / 2, cursor: "nwse-resize" },
+        onPointerDown: (z) => M(z, "nw")
+      }
+    ),
+    /* @__PURE__ */ B(
+      "div",
+      {
+        style: { ...k, top: "50%", right: -T / 2, cursor: "ew-resize", transform: "translateY(-50%)" },
+        onPointerDown: (z) => M(z, "e")
+      }
+    ),
+    /* @__PURE__ */ B(
+      "div",
+      {
+        style: { ...k, top: "50%", left: -T / 2, cursor: "ew-resize", transform: "translateY(-50%)" },
+        onPointerDown: (z) => M(z, "w")
+      }
+    ),
+    /* @__PURE__ */ B(
+      "div",
+      {
+        style: { ...k, left: "50%", top: -T / 2, cursor: "ns-resize", transform: "translateX(-50%)" },
+        onPointerDown: (z) => M(z, "n")
+      }
+    ),
+    /* @__PURE__ */ B(
+      "div",
+      {
+        style: { ...k, left: "50%", bottom: -T / 2, cursor: "ns-resize", transform: "translateX(-50%)" },
+        onPointerDown: (z) => M(z, "s")
+      }
+    )
+  ] });
+}
+function es({
+  isVisible: t,
+  position: e = "top",
+  offset: n = 10,
+  align: r = "center",
+  children: s,
+  style: o = {},
+  className: i = ""
+}) {
+  const c = qe(je), l = ht().nodes.find((E) => E.id === c);
+  if (!(t !== void 0 ? t : l == null ? void 0 : l.selected)) return null;
+  const v = {
+    top: { bottom: "100%", left: r === "start" ? 0 : r === "end" ? void 0 : "50%", right: r === "end" ? 0 : void 0, transform: r === "center" ? "translateX(-50%)" : void 0, marginBottom: n },
+    bottom: { top: "100%", left: r === "start" ? 0 : r === "end" ? void 0 : "50%", right: r === "end" ? 0 : void 0, transform: r === "center" ? "translateX(-50%)" : void 0, marginTop: n },
+    left: { right: "100%", top: r === "start" ? 0 : r === "end" ? void 0 : "50%", bottom: r === "end" ? 0 : void 0, transform: r === "center" ? "translateY(-50%)" : void 0, marginRight: n },
+    right: { left: "100%", top: r === "start" ? 0 : r === "end" ? void 0 : "50%", bottom: r === "end" ? 0 : void 0, transform: r === "center" ? "translateY(-50%)" : void 0, marginLeft: n }
+  }[e] || {};
+  return /* @__PURE__ */ B(
+    "div",
+    {
+      className: `ric-node-toolbar ${i}`,
+      style: {
+        position: "absolute",
+        zIndex: 1e3,
+        pointerEvents: "all",
+        ...v,
+        ...o
+      },
+      onPointerDown: (E) => E.stopPropagation(),
+      children: s
+    }
+  );
+}
+function ns({
+  isVisible: t = !1,
+  x: e = 0,
+  y: n = 0,
+  alignX: r = "center",
+  alignY: s = "center",
+  children: o,
+  style: i = {},
+  className: c = ""
+}) {
+  if (!t) return null;
+  const u = r === "center" ? "-50%" : r === "right" ? "-100%" : "0", l = s === "center" ? "-50%" : s === "bottom" ? "-100%" : "0";
+  return /* @__PURE__ */ B(
+    "div",
+    {
+      className: `ric-edge-toolbar ${c}`,
+      style: {
+        position: "absolute",
+        left: e,
+        top: n,
+        transform: `translate(${u}, ${l})`,
+        zIndex: 1e3,
+        pointerEvents: "all",
+        ...i
+      },
+      children: o
+    }
+  );
+}
+function rs({ children: t }) {
+  var r;
+  const n = (r = ht().edgeLabelContainerRef) == null ? void 0 : r.current;
+  return n ? Yn(t, n) : null;
+}
+function os({ children: t }) {
+  var r;
+  const n = (r = ht().viewportPortalRef) == null ? void 0 : r.current;
+  return n ? Yn(t, n) : null;
+}
+function ur({
+  fromX: t,
+  fromY: e,
+  toX: n,
+  toY: r,
+  fromPosition: s = "right",
+  toPosition: o = "left",
+  connectionLineType: i = "default",
+  connectionLineStyle: c,
+  connectionLineComponent: u
+}) {
+  if (u)
+    return /* @__PURE__ */ B(
+      u,
+      {
+        fromX: t,
+        fromY: e,
+        toX: n,
+        toY: r,
+        fromPosition: s,
+        toPosition: o
+      }
+    );
+  let l;
+  switch (i) {
+    case "straight":
+      [l] = er({ sourceX: t, sourceY: e, targetX: n, targetY: r });
+      break;
+    case "step":
+      [l] = kn({
+        sourceX: t,
+        sourceY: e,
+        targetX: n,
+        targetY: r,
+        sourcePosition: s,
+        targetPosition: o,
+        borderRadius: 0
+      });
+      break;
+    case "smoothstep":
+      [l] = kn({
+        sourceX: t,
+        sourceY: e,
+        targetX: n,
+        targetY: r,
+        sourcePosition: s,
+        targetPosition: o
+      });
+      break;
+    case "simplebezier":
+      [l] = rr({ sourceX: t, sourceY: e, targetX: n, targetY: r });
+      break;
+    default:
+      [l] = nr({
+        sourceX: t,
+        sourceY: e,
+        targetX: n,
+        targetY: r,
+        sourcePosition: s,
+        targetPosition: o
+      });
+      break;
+  }
+  return /* @__PURE__ */ B(
+    "path",
+    {
+      d: l,
+      fill: "none",
+      className: "ric-connection-line",
+      stroke: "#b1b1b7",
+      strokeWidth: 1.5,
+      style: c
+    }
+  );
+}
+ur.displayName = "ConnectionLine";
+const ss = Zt(ur);
+export {
+  Jo as Background,
+  un as BaseEdge,
+  tr as BezierEdge,
+  ss as ConnectionLine,
+  rn as ControlButton,
+  Oo as Controls,
+  ko as DefaultNode,
+  rs as EdgeLabelRenderer,
+  Fr as EdgeText,
+  ns as EdgeToolbar,
+  Xr as GroupNode,
+  on as Handle,
+  Io as InfiniteCanvas,
+  $o as InfiniteCanvasProvider,
+  _r as InputNode,
+  Ko as MiniMap,
+  ts as NodeResizer,
+  es as NodeToolbar,
+  Wr as OutputNode,
+  Vo as Panel,
+  Hr as SelectionBox,
+  cr as SimpleBezierEdge,
+  ar as SmoothStepEdge,
+  Qr as StepEdge,
+  ir as StraightEdge,
+  os as ViewportPortal,
+  Po as addEdge,
+  to as applyEdgeChanges,
+  Vr as applyNodeChanges,
+  vo as boxToRect,
+  or as buildObstacles,
+  Tn as clampPosition,
+  No as computeRoutedEdges,
+  zo as getBezierEdgeCenter,
+  nr as getBezierPath,
+  wo as getBoundsOfBoxes,
+  zr as getConnectedEdges,
+  Eo as getEdgeCenter,
+  go as getIncomers,
+  jn as getNodeDimensions,
+  Mn as getNodesBounds,
+  xo as getNodesInside,
+  po as getOutgoers,
+  bo as getOverlappingArea,
+  Cn as getRoutedLabelPosition,
+  rr as getSimpleBezierPath,
+  kn as getSmoothStepPath,
+  er as getStraightPath,
+  Rn as getViewportForBounds,
+  yo as isEdge,
+  ho as isNode,
+  Mo as nodeToRect,
+  Co as reconnectEdge,
+  mo as rectToBox,
+  Lo as routeSinglePath,
+  En as routedPointsToPath,
+  Pn as snapPosition,
+  Ao as useConnection,
+  Do as useEdges,
+  So as useEdgesState,
+  Xo as useHandleConnections,
+  Lr as useInfiniteCanvas,
+  Go as useInternalNode,
+  Uo as useKeyPress,
+  Wo as useNodeConnections,
+  Ro as useNodeId,
+  Bo as useNodes,
+  _o as useNodesData,
+  jo as useNodesInitialized,
+  To as useNodesState,
+  Yo as useOnSelectionChange,
+  Fo as useOnViewportChange,
+  eo as useReactFlow,
+  Zo as useStore,
+  Qo as useStoreApi,
+  qo as useUpdateNodeInternals,
+  Ho as useViewport
+};