@graph-render/react 1.0.1

package/dist/index.js

@@ -0,0 +1,2509 @@
+import { LayoutType as Me, EdgeType as vr, LayoutDirection as tr } from "@graph-render/types";
+import { EdgeType as ei, LayoutDirection as ri, LayoutType as ni, NodeSide as ii } from "@graph-render/types";
+import re, { useState as Et, useMemo as k, useCallback as K, useRef as pt, useEffect as te, useLayoutEffect as an, useId as cn, useImperativeHandle as un } from "react";
+import { groupEdgesByTarget as ln, sortEdgesBySourcePosition as fn, fromTypedNxGraph as dn, layoutNodes as er, routeEdges as xr, buildEdgePath as hn, normalizeGraphConfig as pn, DEFAULT_THEME as wr } from "@graph-render/core";
+import { buildEdgePath as si, fromNxGraph as ai, layoutNodes as ci, renderGraphToSvg as ui, routeEdges as li } from "@graph-render/core";
+var rr = { exports: {} }, fe = {};
+/**
+ * @license React
+ * react-jsx-runtime.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var br;
+function mn() {
+  if (br) return fe;
+  br = 1;
+  var e = re, r = Symbol.for("react.element"), s = Symbol.for("react.fragment"), i = Object.prototype.hasOwnProperty, o = e.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED.ReactCurrentOwner, c = { key: !0, ref: !0, __self: !0, __source: !0 };
+  function h(u, w, T) {
+    var v, m = {}, g = null, I = null;
+    T !== void 0 && (g = "" + T), w.key !== void 0 && (g = "" + w.key), w.ref !== void 0 && (I = w.ref);
+    for (v in w) i.call(w, v) && !c.hasOwnProperty(v) && (m[v] = w[v]);
+    if (u && u.defaultProps) for (v in w = u.defaultProps, w) m[v] === void 0 && (m[v] = w[v]);
+    return { $$typeof: r, type: u, key: g, ref: I, props: m, _owner: o.current };
+  }
+  return fe.Fragment = s, fe.jsx = h, fe.jsxs = h, fe;
+}
+var de = {};
+/**
+ * @license React
+ * react-jsx-runtime.development.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var Ir;
+function yn() {
+  return Ir || (Ir = 1, process.env.NODE_ENV !== "production" && function() {
+    var e = re, r = Symbol.for("react.element"), s = Symbol.for("react.portal"), i = Symbol.for("react.fragment"), o = Symbol.for("react.strict_mode"), c = Symbol.for("react.profiler"), h = Symbol.for("react.provider"), u = Symbol.for("react.context"), w = Symbol.for("react.forward_ref"), T = Symbol.for("react.suspense"), v = Symbol.for("react.suspense_list"), m = Symbol.for("react.memo"), g = Symbol.for("react.lazy"), I = Symbol.for("react.offscreen"), l = Symbol.iterator, L = "@@iterator";
+    function X(t) {
+      if (t === null || typeof t != "object")
+        return null;
+      var a = l && t[l] || t[L];
+      return typeof a == "function" ? a : null;
+    }
+    var y = e.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
+    function E(t) {
+      {
+        for (var a = arguments.length, f = new Array(a > 1 ? a - 1 : 0), R = 1; R < a; R++)
+          f[R - 1] = arguments[R];
+        _("error", t, f);
+      }
+    }
+    function _(t, a, f) {
+      {
+        var R = y.ReactDebugCurrentFrame, M = R.getStackAddendum();
+        M !== "" && (a += "%s", f = f.concat([M]));
+        var W = f.map(function(z) {
+          return String(z);
+        });
+        W.unshift("Warning: " + a), Function.prototype.apply.call(console[t], console, W);
+      }
+    }
+    var x = !1, G = !1, ut = !1, rt = !1, S = !1, D;
+    D = Symbol.for("react.module.reference");
+    function H(t) {
+      return !!(typeof t == "string" || typeof t == "function" || t === i || t === c || S || t === o || t === T || t === v || rt || t === I || x || G || ut || typeof t == "object" && t !== null && (t.$$typeof === g || t.$$typeof === m || t.$$typeof === h || t.$$typeof === u || t.$$typeof === w || // This needs to include all possible module reference object
+      // types supported by any Flight configuration anywhere since
+      // we don't know which Flight build this will end up being used
+      // with.
+      t.$$typeof === D || t.getModuleId !== void 0));
+    }
+    function it(t, a, f) {
+      var R = t.displayName;
+      if (R)
+        return R;
+      var M = a.displayName || a.name || "";
+      return M !== "" ? f + "(" + M + ")" : f;
+    }
+    function q(t) {
+      return t.displayName || "Context";
+    }
+    function V(t) {
+      if (t == null)
+        return null;
+      if (typeof t.tag == "number" && E("Received an unexpected object in getComponentNameFromType(). This is likely a bug in React. Please file an issue."), typeof t == "function")
+        return t.displayName || t.name || null;
+      if (typeof t == "string")
+        return t;
+      switch (t) {
+        case i:
+          return "Fragment";
+        case s:
+          return "Portal";
+        case c:
+          return "Profiler";
+        case o:
+          return "StrictMode";
+        case T:
+          return "Suspense";
+        case v:
+          return "SuspenseList";
+      }
+      if (typeof t == "object")
+        switch (t.$$typeof) {
+          case u:
+            var a = t;
+            return q(a) + ".Consumer";
+          case h:
+            var f = t;
+            return q(f._context) + ".Provider";
+          case w:
+            return it(t, t.render, "ForwardRef");
+          case m:
+            var R = t.displayName || null;
+            return R !== null ? R : V(t.type) || "Memo";
+          case g: {
+            var M = t, W = M._payload, z = M._init;
+            try {
+              return V(z(W));
+            } catch {
+              return null;
+            }
+          }
+        }
+      return null;
+    }
+    var at = Object.assign, O = 0, A, Y, J, dt, jt, vt, _t;
+    function Ft() {
+    }
+    Ft.__reactDisabledLog = !0;
+    function Kt() {
+      {
+        if (O === 0) {
+          A = console.log, Y = console.info, J = console.warn, dt = console.error, jt = console.group, vt = console.groupCollapsed, _t = console.groupEnd;
+          var t = {
+            configurable: !0,
+            enumerable: !0,
+            value: Ft,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            info: t,
+            log: t,
+            warn: t,
+            error: t,
+            group: t,
+            groupCollapsed: t,
+            groupEnd: t
+          });
+        }
+        O++;
+      }
+    }
+    function ot() {
+      {
+        if (O--, O === 0) {
+          var t = {
+            configurable: !0,
+            enumerable: !0,
+            writable: !0
+          };
+          Object.defineProperties(console, {
+            log: at({}, t, {
+              value: A
+            }),
+            info: at({}, t, {
+              value: Y
+            }),
+            warn: at({}, t, {
+              value: J
+            }),
+            error: at({}, t, {
+              value: dt
+            }),
+            group: at({}, t, {
+              value: jt
+            }),
+            groupCollapsed: at({}, t, {
+              value: vt
+            }),
+            groupEnd: at({}, t, {
+              value: _t
+            })
+          });
+        }
+        O < 0 && E("disabledDepth fell below zero. This is a bug in React. Please file an issue.");
+      }
+    }
+    var Q = y.ReactCurrentDispatcher, Lt;
+    function Tt(t, a, f) {
+      {
+        if (Lt === void 0)
+          try {
+            throw Error();
+          } catch (M) {
+            var R = M.stack.trim().match(/\n( *(at )?)/);
+            Lt = R && R[1] || "";
+          }
+        return `
+` + Lt + t;
+      }
+    }
+    var mt = !1, Gt;
+    {
+      var De = typeof WeakMap == "function" ? WeakMap : Map;
+      Gt = new De();
+    }
+    function me(t, a) {
+      if (!t || mt)
+        return "";
+      {
+        var f = Gt.get(t);
+        if (f !== void 0)
+          return f;
+      }
+      var R;
+      mt = !0;
+      var M = Error.prepareStackTrace;
+      Error.prepareStackTrace = void 0;
+      var W;
+      W = Q.current, Q.current = null, Kt();
+      try {
+        if (a) {
+          var z = function() {
+            throw Error();
+          };
+          if (Object.defineProperty(z.prototype, "props", {
+            set: function() {
+              throw Error();
+            }
+          }), typeof Reflect == "object" && Reflect.construct) {
+            try {
+              Reflect.construct(z, []);
+            } catch (C) {
+              R = C;
+            }
+            Reflect.construct(t, [], z);
+          } else {
+            try {
+              z.call();
+            } catch (C) {
+              R = C;
+            }
+            t.call(z.prototype);
+          }
+        } else {
+          try {
+            throw Error();
+          } catch (C) {
+            R = C;
+          }
+          t();
+        }
+      } catch (C) {
+        if (C && R && typeof C.stack == "string") {
+          for (var j = C.stack.split(`
+`), nt = R.stack.split(`
+`), B = j.length - 1, Z = nt.length - 1; B >= 1 && Z >= 0 && j[B] !== nt[Z]; )
+            Z--;
+          for (; B >= 1 && Z >= 0; B--, Z--)
+            if (j[B] !== nt[Z]) {
+              if (B !== 1 || Z !== 1)
+                do
+                  if (B--, Z--, Z < 0 || j[B] !== nt[Z]) {
+                    var ft = `
+` + j[B].replace(" at new ", " at ");
+                    return t.displayName && ft.includes("<anonymous>") && (ft = ft.replace("<anonymous>", t.displayName)), typeof t == "function" && Gt.set(t, ft), ft;
+                  }
+                while (B >= 1 && Z >= 0);
+              break;
+            }
+        }
+      } finally {
+        mt = !1, Q.current = W, ot(), Error.prepareStackTrace = M;
+      }
+      var $ = t ? t.displayName || t.name : "", tt = $ ? Tt($) : "";
+      return typeof t == "function" && Gt.set(t, tt), tt;
+    }
+    function ne(t, a, f) {
+      return me(t, !1);
+    }
+    function ie(t) {
+      var a = t.prototype;
+      return !!(a && a.isReactComponent);
+    }
+    function ct(t, a, f) {
+      if (t == null)
+        return "";
+      if (typeof t == "function")
+        return me(t, ie(t));
+      if (typeof t == "string")
+        return Tt(t);
+      switch (t) {
+        case T:
+          return Tt("Suspense");
+        case v:
+          return Tt("SuspenseList");
+      }
+      if (typeof t == "object")
+        switch (t.$$typeof) {
+          case w:
+            return ne(t.render);
+          case m:
+            return ct(t.type, a, f);
+          case g: {
+            var R = t, M = R._payload, W = R._init;
+            try {
+              return ct(W(M), a, f);
+            } catch {
+            }
+          }
+        }
+      return "";
+    }
+    var Pt = Object.prototype.hasOwnProperty, Yt = {}, Rt = y.ReactDebugCurrentFrame;
+    function yt(t) {
+      if (t) {
+        var a = t._owner, f = ct(t.type, t._source, a ? a.type : null);
+        Rt.setExtraStackFrame(f);
+      } else
+        Rt.setExtraStackFrame(null);
+    }
+    function ze(t, a, f, R, M) {
+      {
+        var W = Function.call.bind(Pt);
+        for (var z in t)
+          if (W(t, z)) {
+            var j = void 0;
+            try {
+              if (typeof t[z] != "function") {
+                var nt = Error((R || "React class") + ": " + f + " type `" + z + "` is invalid; it must be a function, usually from the `prop-types` package, but received `" + typeof t[z] + "`.This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.");
+                throw nt.name = "Invariant Violation", nt;
+              }
+              j = t[z](a, z, R, f, null, "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED");
+            } catch (B) {
+              j = B;
+            }
+            j && !(j instanceof Error) && (yt(M), E("%s: type specification of %s `%s` is invalid; the type checker function must return `null` or an `Error` but returned a %s. You may have forgotten to pass an argument to the type checker creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and shape all require an argument).", R || "React class", f, z, typeof j), yt(null)), j instanceof Error && !(j.message in Yt) && (Yt[j.message] = !0, yt(M), E("Failed %s type: %s", f, j.message), yt(null));
+          }
+      }
+    }
+    var ye = Array.isArray;
+    function lt(t) {
+      return ye(t);
+    }
+    function ht(t) {
+      {
+        var a = typeof Symbol == "function" && Symbol.toStringTag, f = a && t[Symbol.toStringTag] || t.constructor.name || "Object";
+        return f;
+      }
+    }
+    function ge(t) {
+      try {
+        return Wt(t), !1;
+      } catch {
+        return !0;
+      }
+    }
+    function Wt(t) {
+      return "" + t;
+    }
+    function oe(t) {
+      if (ge(t))
+        return E("The provided key is an unsupported type %s. This value must be coerced to a string before before using it here.", ht(t)), Wt(t);
+    }
+    var ve = y.ReactCurrentOwner, se = {
+      key: !0,
+      ref: !0,
+      __self: !0,
+      __source: !0
+    }, xe, we;
+    function Ne(t) {
+      if (Pt.call(t, "ref")) {
+        var a = Object.getOwnPropertyDescriptor(t, "ref").get;
+        if (a && a.isReactWarning)
+          return !1;
+      }
+      return t.ref !== void 0;
+    }
+    function kt(t) {
+      if (Pt.call(t, "key")) {
+        var a = Object.getOwnPropertyDescriptor(t, "key").get;
+        if (a && a.isReactWarning)
+          return !1;
+      }
+      return t.key !== void 0;
+    }
+    function ae(t, a) {
+      typeof t.ref == "string" && ve.current;
+    }
+    function be(t, a) {
+      {
+        var f = function() {
+          xe || (xe = !0, E("%s: `key` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", a));
+        };
+        f.isReactWarning = !0, Object.defineProperty(t, "key", {
+          get: f,
+          configurable: !0
+        });
+      }
+    }
+    function Ie(t, a) {
+      {
+        var f = function() {
+          we || (we = !0, E("%s: `ref` is not a prop. Trying to access it will result in `undefined` being returned. If you need to access the same value within the child component, you should pass it as a different prop. (https://reactjs.org/link/special-props)", a));
+        };
+        f.isReactWarning = !0, Object.defineProperty(t, "ref", {
+          get: f,
+          configurable: !0
+        });
+      }
+    }
+    var xt = function(t, a, f, R, M, W, z) {
+      var j = {
+        // This tag allows us to uniquely identify this as a React Element
+        $$typeof: r,
+        // Built-in properties that belong on the element
+        type: t,
+        key: a,
+        ref: f,
+        props: z,
+        // Record the component responsible for creating this element.
+        _owner: W
+      };
+      return j._store = {}, Object.defineProperty(j._store, "validated", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !0,
+        value: !1
+      }), Object.defineProperty(j, "_self", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: R
+      }), Object.defineProperty(j, "_source", {
+        configurable: !1,
+        enumerable: !1,
+        writable: !1,
+        value: M
+      }), Object.freeze && (Object.freeze(j.props), Object.freeze(j)), j;
+    };
+    function wt(t, a, f, R, M) {
+      {
+        var W, z = {}, j = null, nt = null;
+        f !== void 0 && (oe(f), j = "" + f), kt(a) && (oe(a.key), j = "" + a.key), Ne(a) && (nt = a.ref, ae(a, M));
+        for (W in a)
+          Pt.call(a, W) && !se.hasOwnProperty(W) && (z[W] = a[W]);
+        if (t && t.defaultProps) {
+          var B = t.defaultProps;
+          for (W in B)
+            z[W] === void 0 && (z[W] = B[W]);
+        }
+        if (j || nt) {
+          var Z = typeof t == "function" ? t.displayName || t.name || "Unknown" : t;
+          j && be(z, Z), nt && Ie(z, Z);
+        }
+        return xt(t, j, nt, M, R, ve.current, z);
+      }
+    }
+    var bt = y.ReactCurrentOwner, Ot = y.ReactDebugCurrentFrame;
+    function Dt(t) {
+      if (t) {
+        var a = t._owner, f = ct(t.type, t._source, a ? a.type : null);
+        Ot.setExtraStackFrame(f);
+      } else
+        Ot.setExtraStackFrame(null);
+    }
+    var $t;
+    $t = !1;
+    function b(t) {
+      return typeof t == "object" && t !== null && t.$$typeof === r;
+    }
+    function gt() {
+      {
+        if (bt.current) {
+          var t = V(bt.current.type);
+          if (t)
+            return `
+
+Check the render method of \`` + t + "`.";
+        }
+        return "";
+      }
+    }
+    function Ee(t) {
+      return "";
+    }
+    var Xt = {};
+    function _e(t) {
+      {
+        var a = gt();
+        if (!a) {
+          var f = typeof t == "string" ? t : t.displayName || t.name;
+          f && (a = `
+
+Check the top-level render call using <` + f + ">.");
+        }
+        return a;
+      }
+    }
+    function Te(t, a) {
+      {
+        if (!t._store || t._store.validated || t.key != null)
+          return;
+        t._store.validated = !0;
+        var f = _e(a);
+        if (Xt[f])
+          return;
+        Xt[f] = !0;
+        var R = "";
+        t && t._owner && t._owner !== bt.current && (R = " It was passed a child from " + V(t._owner.type) + "."), Dt(t), E('Each child in a list should have a unique "key" prop.%s%s See https://reactjs.org/link/warning-keys for more information.', f, R), Dt(null);
+      }
+    }
+    function Pe(t, a) {
+      {
+        if (typeof t != "object")
+          return;
+        if (lt(t))
+          for (var f = 0; f < t.length; f++) {
+            var R = t[f];
+            b(R) && Te(R, a);
+          }
+        else if (b(t))
+          t._store && (t._store.validated = !0);
+        else if (t) {
+          var M = X(t);
+          if (typeof M == "function" && M !== t.entries)
+            for (var W = M.call(t), z; !(z = W.next()).done; )
+              b(z.value) && Te(z.value, a);
+        }
+      }
+    }
+    function Fe(t) {
+      {
+        var a = t.type;
+        if (a == null || typeof a == "string")
+          return;
+        var f;
+        if (typeof a == "function")
+          f = a.propTypes;
+        else if (typeof a == "object" && (a.$$typeof === w || // Note: Memo only checks outer props here.
+        // Inner props are checked in the reconciler.
+        a.$$typeof === m))
+          f = a.propTypes;
+        else
+          return;
+        if (f) {
+          var R = V(a);
+          ze(f, t.props, "prop", R, t);
+        } else if (a.PropTypes !== void 0 && !$t) {
+          $t = !0;
+          var M = V(a);
+          E("Component %s declared `PropTypes` instead of `propTypes`. Did you misspell the property assignment?", M || "Unknown");
+        }
+        typeof a.getDefaultProps == "function" && !a.getDefaultProps.isReactClassApproved && E("getDefaultProps is only used on classic React.createClass definitions. Use a static property named `defaultProps` instead.");
+      }
+    }
+    function Ye(t) {
+      {
+        for (var a = Object.keys(t.props), f = 0; f < a.length; f++) {
+          var R = a[f];
+          if (R !== "children" && R !== "key") {
+            Dt(t), E("Invalid prop `%s` supplied to `React.Fragment`. React.Fragment can only have `key` and `children` props.", R), Dt(null);
+            break;
+          }
+        }
+        t.ref !== null && (Dt(t), E("Invalid attribute `ref` supplied to `React.Fragment`."), Dt(null));
+      }
+    }
+    var Bt = {};
+    function ce(t, a, f, R, M, W) {
+      {
+        var z = H(t);
+        if (!z) {
+          var j = "";
+          (t === void 0 || typeof t == "object" && t !== null && Object.keys(t).length === 0) && (j += " You likely forgot to export your component from the file it's defined in, or you might have mixed up default and named imports.");
+          var nt = Ee();
+          nt ? j += nt : j += gt();
+          var B;
+          t === null ? B = "null" : lt(t) ? B = "array" : t !== void 0 && t.$$typeof === r ? (B = "<" + (V(t.type) || "Unknown") + " />", j = " Did you accidentally export a JSX literal instead of a component?") : B = typeof t, E("React.jsx: type is invalid -- expected a string (for built-in components) or a class/function (for composite components) but got: %s.%s", B, j);
+        }
+        var Z = wt(t, a, f, M, W);
+        if (Z == null)
+          return Z;
+        if (z) {
+          var ft = a.children;
+          if (ft !== void 0)
+            if (R)
+              if (lt(ft)) {
+                for (var $ = 0; $ < ft.length; $++)
+                  Pe(ft[$], t);
+                Object.freeze && Object.freeze(ft);
+              } else
+                E("React.jsx: Static children should always be an array. You are likely explicitly calling React.jsxs or React.jsxDEV. Use the Babel transform instead.");
+            else
+              Pe(ft, t);
+        }
+        if (Pt.call(a, "key")) {
+          var tt = V(t), C = Object.keys(a).filter(function($e) {
+            return $e !== "key";
+          }), Vt = C.length > 0 ? "{key: someKey, " + C.join(": ..., ") + ": ...}" : "{key: someKey}";
+          if (!Bt[tt + Vt]) {
+            var We = C.length > 0 ? "{" + C.join(": ..., ") + ": ...}" : "{}";
+            E(`A props object containing a "key" prop is being spread into JSX:
+  let props = %s;
+  <%s {...props} />
+React keys must be passed directly to JSX without using spread:
+  let props = %s;
+  <%s key={someKey} {...props} />`, Vt, tt, We, tt), Bt[tt + Vt] = !0;
+          }
+        }
+        return t === i ? Ye(Z) : Fe(Z), Z;
+      }
+    }
+    function Re(t, a, f) {
+      return ce(t, a, f, !0);
+    }
+    function Se(t, a, f) {
+      return ce(t, a, f, !1);
+    }
+    var Le = Se, F = Re;
+    de.Fragment = i, de.jsx = Le, de.jsxs = F;
+  }()), de;
+}
+process.env.NODE_ENV === "production" ? rr.exports = mn() : rr.exports = yn();
+var N = rr.exports;
+function Ue(e) {
+  return e.trim().toLowerCase();
+}
+function gn(e) {
+  const r = /* @__PURE__ */ new Map();
+  return e.forEach((s) => {
+    const i = s.meta;
+    if (!i)
+      return;
+    const o = i.pathKeys, h = (Array.isArray(o) ? o : []).map((u) => typeof u == "string" ? u : typeof u == "object" && u !== null && "name" in u && typeof u.name == "string" ? u.name : null).filter((u) => typeof u == "string").map((u) => u.trim()).filter((u) => u.length > 0);
+    h.length && r.set(s.id, h);
+  }), r;
+}
+function vn(e) {
+  const {
+    startNodeId: r,
+    sourceIndex: s,
+    pathKey: i,
+    incomingEdgesByTarget: o,
+    pathKeysByNode: c,
+    maxNodes: h = 500
+  } = e, u = /* @__PURE__ */ new Set([r]), w = /* @__PURE__ */ new Set(), T = /* @__PURE__ */ new Set([`${r}|${s ?? ""}|${i ?? ""}`]), v = [
+    { nodeId: r, sourceIndex: s ?? null, pathKey: i }
+  ];
+  for (; v.length && !(u.size >= h); ) {
+    const m = v.pop();
+    if (!m)
+      continue;
+    const g = o.get(m.nodeId) ?? [], I = m.pathKey ? Ue(m.pathKey) : null;
+    let l = [];
+    I && c && (l = g.filter((L) => (c.get(L.source) ?? []).some((y) => Ue(y) === I))), l.length || (m.sourceIndex == null ? l = g : g[m.sourceIndex] && (l = [g[m.sourceIndex]])), l.forEach((L) => {
+      if (w.has(L.id))
+        return;
+      w.add(L.id), u.add(L.source);
+      const X = (c == null ? void 0 : c.get(L.source)) ?? [], y = I ? X.findIndex((x) => Ue(x) === I) : m.sourceIndex, E = typeof y == "number" && y >= 0 ? y : m.sourceIndex, _ = `${L.source}|${E ?? ""}|${m.pathKey ?? ""}`;
+      T.has(_) || (T.add(_), v.push({
+        nodeId: L.source,
+        sourceIndex: E,
+        pathKey: m.pathKey
+      }));
+    });
+  }
+  return { nodes: u, edges: w };
+}
+function xn(e, r, s) {
+  const [i, o] = Et(null), [c, h] = Et(null), [u, w] = Et(null), T = k(
+    () => new Map(r.map((y) => [y.id, y])),
+    [r]
+  ), v = k(() => {
+    const y = /* @__PURE__ */ new Map();
+    return r.forEach((E) => {
+      y.set(E.source, [...y.get(E.source) ?? [], E]), E.target !== E.source && y.set(E.target, [...y.get(E.target) ?? [], E]);
+    }), y;
+  }, [r]), m = k(() => {
+    const y = /* @__PURE__ */ new Map();
+    return e.forEach((E) => y.set(E.id, E.position)), y;
+  }, [e]), g = k(
+    () => gn(e),
+    [e]
+  ), I = k(() => {
+    const y = ln(r);
+    return y.forEach((E, _) => {
+      y.set(_, fn(E, m));
+    }), y;
+  }, [r, m]), l = k(() => u ? vn({
+    startNodeId: u.nodeId,
+    sourceIndex: u.sourceIndex,
+    pathKey: u.pathKey,
+    incomingEdgesByTarget: I,
+    pathKeysByNode: g
+  }) : null, [u, I, g]), L = k(() => {
+    if (!s && !l) return null;
+    const y = /* @__PURE__ */ new Map(), E = () => {
+      l && l.nodes.forEach((_) => {
+        const x = y.get(_) ?? { in: !1, out: !1 };
+        y.set(_, { ...x, in: !0, out: !0 });
+      });
+    };
+    if (u)
+      E();
+    else {
+      if (s) {
+        if (i) {
+          const _ = T.get(i);
+          if (_) {
+            const x = (G, ut) => {
+              const rt = y.get(G) ?? { in: !1, out: !1 };
+              y.set(G, { ...rt, [ut]: !0 });
+            };
+            _.type === "undirected" ? (x(_.source, "in"), x(_.source, "out"), x(_.target, "in"), x(_.target, "out")) : (x(_.source, "out"), x(_.target, "in"));
+          }
+        } else if (c) {
+          const _ = (x, G) => {
+            const ut = y.get(x) ?? { in: !1, out: !1 };
+            y.set(x, { ...ut, [G]: !0 });
+          };
+          (v.get(c) ?? []).forEach((x) => {
+            const G = x.type === "undirected";
+            (x.source === c || x.target === c) && (G ? (_(x.source, "in"), _(x.source, "out"), _(x.target, "in"), _(x.target, "out")) : (_(x.source, "out"), _(x.target, "in")));
+          }), _(c, "in"), _(c, "out");
+        }
+      }
+      E();
+    }
+    return y.size ? y : null;
+  }, [
+    T,
+    v,
+    s,
+    i,
+    c,
+    l,
+    u
+  ]), X = k(() => {
+    const y = /* @__PURE__ */ new Set();
+    if (u && l ? l.edges.forEach((x) => y.add(x)) : (s && (i ? y.add(i) : c && (v.get(c) ?? []).forEach((x) => {
+      (x.source === c || x.target === c) && y.add(x.id);
+    })), l && l.edges.forEach((x) => y.add(x))), !y.size) return r;
+    const E = [], _ = [];
+    return r.forEach((x) => {
+      y.has(x.id) ? E.push(x) : _.push(x);
+    }), [..._, ...E];
+  }, [
+    v,
+    s,
+    i,
+    c,
+    r,
+    l,
+    u
+  ]);
+  return {
+    hoveredEdgeId: i,
+    setHoveredEdgeId: o,
+    hoveredNodeId: c,
+    setHoveredNodeId: h,
+    focusedPath: u,
+    setFocusedPath: w,
+    pathHighlight: l,
+    hoveredNodeStates: L,
+    edgesForRender: X
+  };
+}
+const wn = ({
+  collapsedNodeIds: e,
+  defaultCollapsedNodeIds: r,
+  onCollapsedNodeIdsChange: s
+}) => {
+  const [i, o] = Et(
+    r ?? []
+  ), [c, h] = Et([]), u = e ?? i, w = k(() => new Set(u), [u]), T = k(
+    () => new Set(c),
+    [c]
+  ), v = K(
+    (m) => {
+      const I = typeof m == "function" ? m(u) : m;
+      e == null && o(I), s == null || s(I);
+    },
+    [u, e, s]
+  );
+  return {
+    collapsedIds: u,
+    collapsedNodeSet: w,
+    pendingExpansionNodeSet: T,
+    updateCollapsedNodeIds: v,
+    setPendingExpansionNodeIds: h
+  };
+}, bn = ({
+  nodes: e,
+  edges: r,
+  collapsedIds: s,
+  hiddenNodeIds: i,
+  searchQuery: o,
+  hideUnmatchedSearch: c = !1,
+  searchPredicate: h,
+  highlightedNodeIds: u,
+  highlightedEdgeIds: w,
+  highlightStrategy: T,
+  onSearchResultsChange: v
+}) => {
+  const m = pt(v);
+  m.current = v;
+  const g = k(() => {
+    const S = o == null ? void 0 : o.trim().toLowerCase();
+    return S ? e.filter((D) => {
+      if (h)
+        try {
+          return h(D, S);
+        } catch {
+          return !1;
+        }
+      const H = typeof D.label == "string" || typeof D.label == "number" ? String(D.label) : D.id;
+      return D.id.toLowerCase().includes(S) || H.toLowerCase().includes(S);
+    }).map((D) => D.id) : [];
+  }, [e, h, o]), I = k(
+    () => new Set(g),
+    [g]
+  ), l = k(() => {
+    const S = o == null ? void 0 : o.trim().toLowerCase();
+    return S ? r.filter((D) => {
+      const H = D.label != null ? String(D.label).toLowerCase() : "";
+      return I.has(D.source) || I.has(D.target) || H.includes(S);
+    }).map((D) => D.id) : [];
+  }, [r, I, o]), L = k(() => o != null && o.trim() ? (() => {
+    try {
+      return (T == null ? void 0 : T({
+        nodes: e,
+        edges: r,
+        query: o,
+        matchedNodeIds: g,
+        matchedEdgeIds: l
+      })) ?? { nodeIds: [], edgeIds: [] };
+    } catch {
+      return { nodeIds: [], edgeIds: [] };
+    }
+  })() : { nodeIds: [], edgeIds: [] }, [r, T, e, l, g, o]), X = k(
+    () => /* @__PURE__ */ new Set([
+      ...g,
+      ...L.nodeIds ?? [],
+      ...u ?? []
+    ]),
+    [L.nodeIds, u, g]
+  ), y = k(
+    () => /* @__PURE__ */ new Set([
+      ...l,
+      ...L.edgeIds ?? [],
+      ...w ?? []
+    ]),
+    [L.edgeIds, w, l]
+  );
+  te(() => {
+    var S;
+    (S = m.current) == null || S.call(m, {
+      nodeIds: g,
+      edgeIds: l
+    });
+  }, [l, g]);
+  const E = k(() => {
+    const S = new Set(i ?? []);
+    return c && (o != null && o.trim()) && e.forEach((D) => {
+      X.has(D.id) || S.add(D.id);
+    }), S;
+  }, [X, i, c, e, o]), _ = k(() => {
+    const S = /* @__PURE__ */ new Map();
+    return r.forEach((D) => {
+      S.set(D.source, [...S.get(D.source) ?? [], D.target]);
+    }), S;
+  }, [r]), x = k(() => {
+    const S = new Set(E);
+    return s.forEach((D) => {
+      const H = [..._.get(D) ?? []];
+      for (; H.length; ) {
+        const it = H.pop();
+        !it || S.has(it) || (S.add(it), H.push(..._.get(it) ?? []));
+      }
+    }), S;
+  }, [s, E, _]), G = k(
+    () => e.filter((S) => !x.has(S.id)),
+    [x, e]
+  ), ut = k(
+    () => r.filter(
+      (S) => !x.has(S.source) && !x.has(S.target)
+    ),
+    [x, r]
+  );
+  return {
+    effectiveHighlightedNodeSet: X,
+    effectiveHighlightedEdgeSet: y,
+    visibleNodes: G,
+    visibleEdges: ut,
+    childNodeIdsByParent: _
+  };
+}, Mr = (e) => !!(e && Number.isFinite(e.x) && Number.isFinite(e.y)), he = (e, r, s) => {
+  const i = new Set(r.map((c) => c.id));
+  if (e.length !== r.length)
+    throw new Error(
+      `${s} must return ${r.length} nodes, received ${e.length}.`
+    );
+  const o = /* @__PURE__ */ new Set();
+  e.forEach((c) => {
+    if (!i.has(c.id))
+      throw new Error(`${s} returned unknown node id "${c.id}".`);
+    if (o.has(c.id))
+      throw new Error(`${s} returned duplicate node id "${c.id}".`);
+    if (!Mr(c.position))
+      throw new Error(`${s} returned a non-finite position for node "${c.id}".`);
+    o.add(c.id);
+  });
+}, pe = (e, r, s) => {
+  const i = /* @__PURE__ */ new Set();
+  e.forEach((o) => {
+    if (i.has(o.id))
+      throw new Error(`${s} returned duplicate edge id "${o.id}".`);
+    if (!r.has(o.source) || !r.has(o.target))
+      throw new Error(
+        `${s} returned edge "${o.id}" with unknown endpoint(s): ${o.source} -> ${o.target}.`
+      );
+    if (!Array.isArray(o.points) || o.points.length < 2)
+      throw new Error(`${s} returned edge "${o.id}" without a valid point path.`);
+    o.points.forEach((c, h) => {
+      if (!Mr(c))
+        throw new Error(
+          `${s} returned a non-finite point at index ${h} for edge "${o.id}".`
+        );
+    }), i.add(o.id);
+  });
+}, Nt = (e) => e instanceof Error ? e : new Error(String(e)), Er = (e) => er({
+  ...e,
+  layout: Me.Centered
+}), _r = (e, r) => {
+  const s = new Map(e.map((i) => [i.id, i]));
+  return r.flatMap((i) => {
+    var v, m, g, I;
+    const o = s.get(i.source), c = s.get(i.target);
+    if (!o || !c)
+      return [];
+    const h = ((v = o.size) == null ? void 0 : v.width) ?? 0, u = ((m = o.size) == null ? void 0 : m.height) ?? 0, w = ((g = c.size) == null ? void 0 : g.width) ?? 0, T = ((I = c.size) == null ? void 0 : I.height) ?? 0;
+    if (o.id === c.id) {
+      const l = o.position.x + h, L = o.position.y;
+      return [
+        {
+          ...i,
+          type: i.type ?? vr.Directed,
+          points: [
+            { x: l - Math.min(h * 0.25, 18), y: L + Math.min(u * 0.35, 18) },
+            { x: l + 28, y: L - 20 },
+            { x: l + 36, y: L + u / 2 },
+            { x: l - Math.min(h * 0.25, 18), y: L + u * 0.8 }
+          ]
+        }
+      ];
+    }
+    return [
+      {
+        ...i,
+        type: i.type ?? vr.Directed,
+        points: [
+          {
+            x: o.position.x + h / 2,
+            y: o.position.y + u / 2
+          },
+          {
+            x: c.position.x + w / 2,
+            y: c.position.y + T / 2
+          }
+        ]
+      }
+    ];
+  });
+}, In = ({
+  graph: e,
+  config: r,
+  mergedTheme: s,
+  collapsedIds: i,
+  hiddenNodeIds: o,
+  searchQuery: c,
+  hideUnmatchedSearch: h = !1,
+  searchPredicate: u,
+  highlightedNodeIds: w,
+  highlightedEdgeIds: T,
+  highlightStrategy: v,
+  onSearchResultsChange: m,
+  layoutNodesOverride: g,
+  routeEdgesOverride: I,
+  onError: l
+}) => {
+  const [L, X] = Et({}), { nodes: y, edges: E } = k(
+    () => dn(e, r.defaultEdgeType),
+    [r.defaultEdgeType, e]
+  ), _ = k(
+    () => y.map((O) => ({
+      ...O,
+      measuredSize: L[O.id] ?? O.measuredSize
+    })),
+    [L, y]
+  );
+  te(() => {
+    const O = new Set(y.map((A) => A.id));
+    X((A) => {
+      const Y = Object.entries(A).filter(([J]) => O.has(J));
+      return Y.length === Object.keys(A).length ? A : Object.fromEntries(Y);
+    });
+  }, [y]);
+  const x = k(
+    () => E.map((O) => ({
+      ...O,
+      type: O.type ?? r.defaultEdgeType
+    })),
+    [r.defaultEdgeType, E]
+  ), {
+    effectiveHighlightedNodeSet: G,
+    effectiveHighlightedEdgeSet: ut,
+    visibleNodes: rt,
+    visibleEdges: S,
+    childNodeIdsByParent: D
+  } = bn({
+    nodes: _,
+    edges: x,
+    collapsedIds: i,
+    hiddenNodeIds: o,
+    searchQuery: c,
+    hideUnmatchedSearch: h,
+    searchPredicate: u,
+    highlightedNodeIds: w,
+    highlightedEdgeIds: T,
+    highlightStrategy: v,
+    onSearchResultsChange: m
+  }), H = k(
+    () => ({
+      nodes: rt,
+      edges: S,
+      theme: s,
+      padding: r.padding,
+      layout: r.layout,
+      width: r.width,
+      height: r.height,
+      layoutDirection: r.layoutDirection,
+      nodeSizing: r.nodeSizing,
+      fixedNodeSize: r.fixedNodeSize,
+      labelMeasurementPaddingX: r.labelMeasurementPaddingX,
+      labelMeasurementPaddingY: r.labelMeasurementPaddingY,
+      labelMeasurementCharWidth: r.labelMeasurementCharWidth,
+      labelMeasurementLineHeight: r.labelMeasurementLineHeight
+    }),
+    [r, s, S, rt]
+  ), it = K(
+    (O, A) => {
+      r.nodeSizing === "measured" && X((Y) => {
+        const J = Y[O];
+        return J && J.width === A.width && J.height === A.height ? Y : {
+          ...Y,
+          [O]: A
+        };
+      });
+    },
+    [r.nodeSizing]
+  ), q = k(
+    () => {
+      if (!g)
+        try {
+          const O = er(H);
+          return he(O, rt, "layout"), O;
+        } catch (O) {
+          l == null || l(Nt(O), {
+            graph: e,
+            phase: "layout"
+          });
+          try {
+            const A = Er(H);
+            return he(A, rt, "layout"), A;
+          } catch (A) {
+            const Y = Nt(A);
+            throw l == null || l(Y, {
+              graph: e,
+              phase: "layout"
+            }), Y;
+          }
+        }
+      try {
+        const O = g(H);
+        return he(O, rt, "layout override"), O;
+      } catch (O) {
+        l == null || l(Nt(O), {
+          graph: e,
+          phase: "layout-override"
+        });
+        try {
+          const A = er(H);
+          return he(A, rt, "layout"), A;
+        } catch (A) {
+          l == null || l(Nt(A), { graph: e, phase: "layout" });
+          try {
+            const Y = Er(H);
+            return he(Y, rt, "layout"), Y;
+          } catch (Y) {
+            const J = Nt(Y);
+            throw l == null || l(J, { graph: e, phase: "layout" }), J;
+          }
+        }
+      }
+    },
+    [e, g, H, l, rt]
+  ), V = k(
+    () => ({
+      arrowPadding: r.arrowPadding,
+      straight: !r.curveEdges || r.routingStyle === "orthogonal",
+      layoutDirection: r.layoutDirection,
+      forceRightToLeft: r.forceRightToLeft,
+      routingStyle: r.routingStyle,
+      edgeSeparation: r.edgeSeparation,
+      selfLoopRadius: r.selfLoopRadius
+    }),
+    [r]
+  ), at = k(
+    () => {
+      const O = new Set(q.map((A) => A.id));
+      if (!I)
+        try {
+          const A = xr(q, S, V);
+          return pe(A, O, "routing"), A;
+        } catch (A) {
+          l == null || l(Nt(A), {
+            graph: e,
+            phase: "routing"
+          });
+          const Y = _r(q, S);
+          return pe(Y, O, "routing"), Y;
+        }
+      try {
+        const A = I(q, S, V);
+        return pe(A, O, "routing override"), A;
+      } catch (A) {
+        l == null || l(Nt(A), {
+          graph: e,
+          phase: "routing-override"
+        });
+        try {
+          const Y = xr(q, S, V);
+          return pe(Y, O, "routing"), Y;
+        } catch (Y) {
+          l == null || l(Nt(Y), { graph: e, phase: "routing" });
+          const J = _r(q, S);
+          return pe(J, O, "routing"), J;
+        }
+      }
+    },
+    [
+      V,
+      e,
+      l,
+      q,
+      I,
+      S
+    ]
+  );
+  return {
+    childNodeIdsByParent: D,
+    effectiveHighlightedEdgeSet: ut,
+    effectiveHighlightedNodeSet: G,
+    handleNodeMeasure: it,
+    positionedEdges: at,
+    positionedNodes: q,
+    visibleEdges: S,
+    visibleNodesWithMeasuredSize: rt
+  };
+}, Tr = (e) => Object.prototype.toString.call(e) === "[object Object]", nr = (e, r, s) => {
+  if (Object.is(e, r))
+    return !0;
+  if (typeof e == "function" || typeof r == "function" || !e || !r || typeof e != "object" || typeof r != "object")
+    return !1;
+  const i = s.get(e);
+  if (i != null && i.has(r))
+    return !0;
+  if (Array.isArray(e) || Array.isArray(r)) {
+    if (!Array.isArray(e) || !Array.isArray(r) || e.length !== r.length)
+      return !1;
+    i ? i.add(r) : s.set(e, new WeakSet([r]));
+    for (let h = 0; h < e.length; h += 1)
+      if (!nr(e[h], r[h], s))
+        return !1;
+    return !0;
+  }
+  if (!Tr(e) || !Tr(r))
+    return !1;
+  i ? i.add(r) : s.set(e, new WeakSet([r]));
+  const o = Object.keys(e), c = Object.keys(r);
+  if (o.length !== c.length)
+    return !1;
+  for (const h of o)
+    if (!(h in r) || !nr(e[h], r[h], s))
+      return !1;
+  return !0;
+};
+function En(e) {
+  const r = pt(null);
+  return (r.current === null || !nr(r.current, e, /* @__PURE__ */ new WeakMap())) && (r.current = e), r.current;
+}
+const _n = 180, Tn = 24, Ar = (e) => {
+  var r;
+  return ((r = e.size) == null ? void 0 : r.width) ?? _n;
+}, He = (e) => e.position.x + Ar(e) / 2, jr = (e, r = Tn) => {
+  const s = [...e].sort((o, c) => He(o) - He(c)), i = [];
+  return s.forEach((o) => {
+    const c = He(o), h = Ar(o), u = i[i.length - 1];
+    if (!u) {
+      i.push({ centerX: c, avgWidth: h, nodes: [o] });
+      return;
+    }
+    const w = Math.max(r, Math.min(u.avgWidth, h) * 0.35);
+    if (Math.abs(c - u.centerX) > w) {
+      i.push({ centerX: c, avgWidth: h, nodes: [o] });
+      return;
+    }
+    u.nodes.push(o);
+    const T = u.nodes.length;
+    u.centerX = (u.centerX * (T - 1) + c) / T, u.avgWidth = (u.avgWidth * (T - 1) + h) / T;
+  }), i.map((o) => ({
+    centerX: o.centerX,
+    nodes: [...o.nodes].sort((c, h) => c.position.y - h.position.y)
+  }));
+}, Dr = 180, zr = 72, Ae = (e, r, s) => Math.min(Math.max(e, r), s), Pn = (e) => e.length ? e.reduce(
+  (s, i) => {
+    var v, m;
+    const o = ((v = i.size) == null ? void 0 : v.width) ?? Dr, c = ((m = i.size) == null ? void 0 : m.height) ?? zr, h = Math.min(s.minX, i.position.x), u = Math.min(s.minY, i.position.y), w = Math.max(s.maxX, i.position.x + o), T = Math.max(s.maxY, i.position.y + c);
+    return {
+      minX: h,
+      minY: u,
+      maxX: w,
+      maxY: T,
+      width: w - h,
+      height: T - u
+    };
+  },
+  {
+    minX: Number.POSITIVE_INFINITY,
+    minY: Number.POSITIVE_INFINITY,
+    maxX: Number.NEGATIVE_INFINITY,
+    maxY: Number.NEGATIVE_INFINITY,
+    width: 0,
+    height: 0
+  }
+) : null, Rn = (e, r, s, i, o, c) => {
+  if (!e || r <= 0 || s <= 0)
+    return { x: 0, y: 0, zoom: 1 };
+  const h = Math.max(e.width, 1), u = Math.max(e.height, 1), w = Math.max(r - i * 2, 1), T = Math.max(s - i * 2, 1), v = Ae(
+    Math.min(w / h, T / u),
+    o,
+    c
+  );
+  return {
+    x: i + (w - h * v) / 2 - e.minX * v,
+    y: i + (T - u * v) / 2 - e.minY * v,
+    zoom: v
+  };
+}, Sn = (e, r, s, i) => {
+  var w, T;
+  const o = ((w = e.size) == null ? void 0 : w.width) ?? Dr, c = ((T = e.size) == null ? void 0 : T.height) ?? zr, h = e.position.x + o / 2, u = e.position.y + c / 2;
+  return {
+    x: r / 2 - h * i,
+    y: s / 2 - u * i,
+    zoom: i
+  };
+}, Ln = re.memo(function({
+  edge: r,
+  color: s,
+  width: i,
+  curveEdges: o,
+  curveStrength: c,
+  markerEnd: h,
+  isHovered: u,
+  isSelected: w,
+  hoverColor: T,
+  selectionColor: v,
+  labelColor: m,
+  selectionMarker: g,
+  hoverMarker: I,
+  hoverEnabled: l,
+  hoverStrokeWidth: L,
+  selectedStrokeWidth: X,
+  hitStrokeWidth: y,
+  onHoverChange: E,
+  onClick: _
+}) {
+  const x = hn(r, o, c);
+  if (!x) return null;
+  const G = u ? T : w ? v ?? T : s, ut = u ? L ?? i : w ? X ?? i + 1 : i, rt = u ? I ?? g ?? h : w ? g ?? h : h, S = r.label != null && r.labelPosition ? String(r.label) : null;
+  return /* @__PURE__ */ N.jsxs(N.Fragment, { children: [
+    /* @__PURE__ */ N.jsx(
+      "path",
+      {
+        d: x,
+        stroke: "transparent",
+        strokeWidth: y ?? i + 8,
+        fill: "none",
+        pointerEvents: "stroke",
+        "data-graph-edge-interactive": "true",
+        onMouseEnter: () => l && (E == null ? void 0 : E(!0)),
+        onMouseLeave: () => l && (E == null ? void 0 : E(!1)),
+        onClick: _
+      }
+    ),
+    /* @__PURE__ */ N.jsx(
+      "path",
+      {
+        d: x,
+        stroke: G,
+        strokeWidth: ut,
+        fill: "none",
+        markerEnd: r.type === "directed" ? rt : void 0,
+        pointerEvents: "none"
+      }
+    ),
+    S && r.labelPosition ? /* @__PURE__ */ N.jsx(
+      "text",
+      {
+        x: r.labelPosition.x,
+        y: r.labelPosition.y - 6,
+        textAnchor: "middle",
+        fontSize: 12,
+        fontWeight: 600,
+        fill: m ?? "#334155",
+        pointerEvents: "none",
+        children: S
+      }
+    ) : null
+  ] });
+}), kn = 64, ee = 20, Pr = 8, On = 12, Mn = 7, An = 48, jn = 12, Dn = 700;
+function Nr(e) {
+  const r = Math.min(Array.from(e).length, An);
+  return Math.max(
+    kn,
+    r * Mn + On * 2
+  );
+}
+function Fr(e, r, s, i, o = !1) {
+  const c = jr(e), h = c.map((g) => g.centerX);
+  if (!h.length)
+    return { orderedXs: [], orderedLabels: [] };
+  const w = c.map((g) => g.nodes.length).map((g) => {
+    const I = g * 2;
+    return I <= 2 ? "Final" : `1/${I}`;
+  }), T = i && i.length ? i : o ? w : [], v = r === Me.Tree && s === tr.RTL ? [...h].reverse() : h, m = r === Me.Tree && s === tr.RTL ? [...T].reverse() : T;
+  return { orderedXs: v, orderedLabels: m };
+}
+function zn({
+  positionedNodes: e,
+  layout: r,
+  layoutDirection: s,
+  labels: i,
+  autoLabels: o,
+  labelOffset: c,
+  pillBackground: h = "#eef1f6",
+  pillBorderColor: u = "#d7dbe3",
+  pillTextColor: w = "#3f434b"
+}) {
+  const { orderedXs: T, orderedLabels: v } = Fr(
+    e,
+    r,
+    s,
+    i,
+    o
+  );
+  if (!T.length || !v.length) return null;
+  const g = e.reduce(
+    (I, l) => Math.min(I, l.position.y),
+    Number.POSITIVE_INFINITY
+  ) - c;
+  return /* @__PURE__ */ N.jsx("g", { "aria-label": "labels", children: T.map((I, l) => {
+    const L = v[l] ?? "", X = Nr(L), y = I;
+    return /* @__PURE__ */ N.jsxs(
+      "g",
+      {
+        transform: `translate(${y - X / 2}, ${g - ee + 6})`,
+        children: [
+          /* @__PURE__ */ N.jsx(
+            "rect",
+            {
+              width: X,
+              height: ee,
+              rx: Pr,
+              ry: Pr,
+              fill: h,
+              stroke: u,
+              strokeWidth: 1
+            }
+          ),
+          /* @__PURE__ */ N.jsx(
+            "text",
+            {
+              x: X / 2,
+              y: ee / 2 + 4,
+              fill: w,
+              fontSize: jn,
+              fontWeight: Dn,
+              textAnchor: "middle",
+              children: L
+            }
+          )
+        ]
+      },
+      `col-${I}`
+    );
+  }) });
+}
+const Nn = typeof window > "u" ? te : an, Yr = re.memo(
+  ({
+    node: e,
+    Vertex: r,
+    isSelected: s,
+    isFocused: i,
+    selectionColor: o,
+    isHighlighted: c,
+    activePathKey: h,
+    activePathNodeIds: u,
+    highlightColor: w,
+    nodeBorderColor: T,
+    nodeBorderWidth: v,
+    hoverNodeBorderColor: m,
+    hoverNodeBothColor: g,
+    hoverNodeInColor: I,
+    hoverNodeOutColor: l,
+    hoverNodeHighlight: L,
+    hoveredNodeStates: X,
+    onNodeMeasure: y,
+    onNodeFocus: E,
+    onNodeClick: _,
+    onNodeDoubleClick: x,
+    onNodeMouseEnter: G,
+    onNodeMouseLeave: ut,
+    onPathHover: rt,
+    onPathLeave: S
+  }) => {
+    var Ft, Kt;
+    const D = pt(null), H = ((Ft = e.size) == null ? void 0 : Ft.width) ?? 180, it = ((Kt = e.size) == null ? void 0 : Kt.height) ?? 72, q = 8, V = X == null ? void 0 : X.get(e.id), at = (V == null ? void 0 : V.in) ?? !1, O = (V == null ? void 0 : V.out) ?? !1, A = at && O, Y = at || O, J = !!T && v > 0 || s;
+    let dt = T;
+    s ? dt = o : c ? dt = w : J ? L && (A ? dt = g : O ? dt = l : at ? dt = I : Y && (dt = m)) : dt = "none";
+    let jt = 0;
+    s || c ? jt = 1 : J && (jt = L && Y ? 1 : 0.4), Nn(() => {
+      if (!D.current || !y)
+        return;
+      const ot = () => {
+        H > 0 && it > 0 && y(e.id, { width: Math.ceil(H), height: Math.ceil(it) });
+      }, Q = requestAnimationFrame(() => {
+        var Lt, Tt;
+        try {
+          if (typeof ((Lt = D.current) == null ? void 0 : Lt.getBBox) != "function") {
+            ot();
+            return;
+          }
+          const mt = (Tt = D.current) == null ? void 0 : Tt.getBBox();
+          if (mt && mt.width > 0 && mt.height > 0) {
+            y(e.id, {
+              width: Math.ceil(mt.width),
+              height: Math.ceil(mt.height)
+            });
+            return;
+          }
+        } catch {
+          ot();
+        }
+        ot();
+      });
+      return () => cancelAnimationFrame(Q);
+    }, [e.id, e.label, e.meta, y, H, it]);
+    const vt = s || c ? Math.max(2, v) : J ? v : 0, _t = i ? Math.max(2, vt || 2) : 0;
+    return /* @__PURE__ */ N.jsxs(
+      "g",
+      {
+        ref: D,
+        transform: `translate(${e.position.x}, ${e.position.y})`,
+        "data-graph-node-interactive": "true",
+        role: "button",
+        tabIndex: 0,
+        "aria-selected": s,
+        onMouseDown: (ot) => {
+          ot.preventDefault();
+        },
+        onFocus: () => E == null ? void 0 : E(e.id),
+        onClick: () => _ == null ? void 0 : _(e),
+        onDoubleClick: () => x == null ? void 0 : x(e),
+        onMouseEnter: () => G(e.id),
+        onMouseLeave: ut,
+        onKeyDown: (ot) => {
+          (ot.key === "Enter" || ot.key === " ") && (ot.preventDefault(), _ == null || _(e));
+        },
+        children: [
+          /* @__PURE__ */ N.jsx(
+            "rect",
+            {
+              x: 0,
+              y: 0,
+              width: H,
+              height: it,
+              rx: q,
+              ry: q,
+              fill: "none",
+              stroke: dt,
+              strokeOpacity: jt,
+              strokeWidth: vt,
+              pointerEvents: "none"
+            }
+          ),
+          i ? /* @__PURE__ */ N.jsx(
+            "rect",
+            {
+              x: -3,
+              y: -3,
+              width: H + 6,
+              height: it + 6,
+              rx: q + 2,
+              ry: q + 2,
+              fill: "none",
+              stroke: o,
+              strokeOpacity: 0.7,
+              strokeWidth: _t,
+              strokeDasharray: "4 3",
+              pointerEvents: "none"
+            }
+          ) : null,
+          /* @__PURE__ */ N.jsx(
+            r,
+            {
+              node: e,
+              isSelected: s,
+              isHovered: Y,
+              isHoveredIn: at,
+              isHoveredOut: O,
+              isHoveredBoth: A,
+              activePathKey: h,
+              activePathNodeIds: u,
+              hoverInColor: I,
+              hoverOutColor: l,
+              hoverBothColor: g,
+              onPathHover: (ot, Q) => ot !== null && rt(e.id, ot, (Q == null ? void 0 : Q.pathKey) ?? (Q == null ? void 0 : Q.playerKey)),
+              onPathLeave: S
+            }
+          )
+        ]
+      }
+    );
+  }
+);
+Yr.displayName = "GraphNode";
+const Ke = { x: 0, y: 0, zoom: 1 }, Ge = { nodeIds: [], edgeIds: [] }, Wr = 0.25, $r = 2.5, Fn = 0.12, Yn = "#f59e0b", Wn = "top-left", Ht = 26, ir = 34, Xr = 8, Ve = 48, Ze = 20, $n = 8, qe = (e, r, s) => ({
+  x: Number.isFinite(e.x) ? e.x : 0,
+  y: Number.isFinite(e.y) ? e.y : 0,
+  zoom: Ae(Number.isFinite(e.zoom) ? e.zoom : 1, r, s)
+}), Xn = (e, r) => {
+  const s = Number.isFinite(e) && e > 0 ? e : Wr, i = Number.isFinite(r) && r > 0 ? r : $r;
+  return s <= i ? { minZoom: s, maxZoom: i } : { minZoom: i, maxZoom: s };
+}, Je = (e) => e instanceof Error ? e : new Error(String(e)), Rr = (e, r, s) => s === "single" ? e.length === 1 && e[0] === r ? [] : [r] : e.includes(r) ? e.filter((i) => i !== r) : [...e, r], Bn = (e, r, s) => {
+  const i = 2 * Ht + 2 * ir + Xr * 3, o = 12;
+  switch (s) {
+    case "top-right":
+      return { x: e - i - o, y: o };
+    case "bottom-left":
+      return { x: o, y: r - Ht - o };
+    case "bottom-right":
+      return {
+        x: e - i - o,
+        y: r - Ht - o
+      };
+    case "top-left":
+    default:
+      return { x: o, y: o };
+  }
+}, Sr = (e, r) => Math.hypot(e.x - r.x, e.y - r.y), Lr = (e, r) => ({
+  x: (e.x + r.x) / 2,
+  y: (e.y + r.y) / 2
+}), kr = (e) => ({
+  x: Math.min(e.startX, e.endX),
+  y: Math.min(e.startY, e.endY),
+  width: Math.abs(e.endX - e.startX),
+  height: Math.abs(e.endY - e.startY)
+}), Or = (e, r, s) => e >= s.x && e <= s.x + s.width && r >= s.y && r <= s.y + s.height, Cn = (e, r) => ({
+  minX: e.minX - r,
+  minY: e.minY - r,
+  maxX: e.maxX + r,
+  maxY: e.maxY + r,
+  width: e.width + r * 2,
+  height: e.height + r * 2
+}), je = (e, r) => {
+  if (!e)
+    return r;
+  if (!r)
+    return e;
+  const s = Math.min(e.minX, r.minX), i = Math.min(e.minY, r.minY), o = Math.max(e.maxX, r.maxX), c = Math.max(e.maxY, r.maxY);
+  return {
+    minX: s,
+    minY: i,
+    maxX: o,
+    maxY: c,
+    width: o - s,
+    height: c - i
+  };
+}, Un = (e, r, s, i, o, c) => {
+  if (!e.length || !o && !(i && i.length))
+    return null;
+  const h = jr(e);
+  if (!h.length)
+    return null;
+  const u = r === Me.Tree && s === tr.RTL ? [...h].reverse() : h, { orderedLabels: w } = Fr(
+    e,
+    r,
+    s,
+    i,
+    o
+  ), v = e.reduce(
+    (m, g) => Math.min(m, g.position.y),
+    Number.POSITIVE_INFINITY
+  ) - c - ee + 6;
+  return u.reduce((m, g, I) => {
+    const l = Nr(w[I] ?? ""), L = {
+      minX: g.centerX - l / 2,
+      minY: v,
+      maxX: g.centerX + l / 2,
+      maxY: v + ee,
+      width: l,
+      height: ee
+    };
+    return je(m, L);
+  }, null);
+}, Hn = (e) => e.reduce((r, s) => {
+  if (!s.labelPosition)
+    return r;
+  const i = {
+    minX: s.labelPosition.x - Ve / 2,
+    minY: s.labelPosition.y - Ze / 2,
+    maxX: s.labelPosition.x + Ve / 2,
+    maxY: s.labelPosition.y + Ze / 2,
+    width: Ve,
+    height: Ze
+  };
+  return je(r, i);
+}, null), Qe = (e, r, s) => {
+  if (!e)
+    return { x: r, y: s };
+  const i = e.getBoundingClientRect();
+  return {
+    x: r - i.left,
+    y: s - i.top
+  };
+}, Kn = (e, r, s) => {
+  var u, w, T, v, m, g;
+  const i = {
+    x: e.position.x + (((u = e.size) == null ? void 0 : u.width) ?? 0) / 2,
+    y: e.position.y + (((w = e.size) == null ? void 0 : w.height) ?? 0) / 2
+  }, o = r.filter((I) => {
+    var L, X;
+    if (I.id === e.id)
+      return !1;
+    const l = {
+      x: I.position.x + (((L = I.size) == null ? void 0 : L.width) ?? 0) / 2,
+      y: I.position.y + (((X = I.size) == null ? void 0 : X.height) ?? 0) / 2
+    };
+    return s === "left" ? l.x < i.x : s === "right" ? l.x > i.x : s === "up" ? l.y < i.y : l.y > i.y;
+  });
+  if (!o.length)
+    return null;
+  let c = o[0], h = Math.hypot(
+    c.position.x + (((T = c.size) == null ? void 0 : T.width) ?? 0) / 2 - i.x,
+    c.position.y + (((v = c.size) == null ? void 0 : v.height) ?? 0) / 2 - i.y
+  );
+  for (let I = 1; I < o.length; I++) {
+    const l = o[I], L = Math.hypot(
+      l.position.x + (((m = l.size) == null ? void 0 : m.width) ?? 0) / 2 - i.x,
+      l.position.y + (((g = l.size) == null ? void 0 : g.height) ?? 0) / 2 - i.y
+    );
+    L < h && (c = l, h = L);
+  }
+  return c;
+}, Gn = ({
+  graph: e,
+  vertexComponent: r,
+  edgeComponent: s = Ln,
+  config: i,
+  viewport: o,
+  defaultViewport: c,
+  onViewportChange: h,
+  fitViewOnMount: u = !1,
+  fitViewPadding: w = 32,
+  minZoom: T = Wr,
+  maxZoom: v = $r,
+  zoomStep: m = Fn,
+  panEnabled: g = !0,
+  zoomEnabled: I = !0,
+  pinchZoomEnabled: l = !0,
+  keyboardNavigation: L = !0,
+  showControls: X = !1,
+  controlsPosition: y = Wn,
+  marqueeSelectionEnabled: E = !0,
+  focusedNodeId: _,
+  defaultFocusedNodeId: x = null,
+  onFocusedNodeChange: G,
+  collapsedNodeIds: ut,
+  defaultCollapsedNodeIds: rt,
+  onCollapsedNodeIdsChange: S,
+  toggleCollapseOnNodeDoubleClick: D = !0,
+  hiddenNodeIds: H,
+  onNodeExpand: it,
+  onNodeCollapse: q,
+  searchQuery: V,
+  hideUnmatchedSearch: at = !1,
+  searchPredicate: O,
+  highlightedNodeIds: A,
+  highlightedEdgeIds: Y,
+  highlightColor: J = "#f59e0b",
+  highlightStrategy: dt,
+  onSearchResultsChange: jt,
+  selectedNodeIds: vt,
+  selectedEdgeIds: _t,
+  defaultSelectedNodeIds: Ft,
+  defaultSelectedEdgeIds: Kt,
+  onSelectionChange: ot,
+  selectionMode: Q = "single",
+  nodeSelectionEnabled: Lt = !0,
+  edgeSelectionEnabled: Tt = !0,
+  selectionColor: mt = Yn,
+  edgeSelectionColor: Gt,
+  layoutNodesOverride: De,
+  routeEdgesOverride: me,
+  renderBackground: ne,
+  renderOverlay: ie,
+  onError: ct,
+  onNodeHoverChange: Pt,
+  onEdgeHoverChange: Yt,
+  onNodeClick: Rt,
+  onEdgeClick: yt
+}, ze) => {
+  const ye = k(() => Xn(T, v), [T, v]), lt = ye.minZoom, ht = ye.maxZoom, ge = En(i), Wt = cn().replace(/:/g, "-"), [oe, ve] = Et(
+    () => qe({ ...Ke, ...c ?? {} }, lt, ht)
+  ), [se, xe] = Et({
+    nodeIds: Ft ?? [],
+    edgeIds: Kt ?? []
+  }), [we, Ne] = Et(
+    x
+  ), [kt, ae] = Et(null), [be, Ie] = Et(!1), xt = pt({
+    active: !1,
+    startX: 0,
+    startY: 0,
+    originX: 0,
+    originY: 0
+  }), wt = pt(/* @__PURE__ */ new Map()), bt = pt({
+    active: !1,
+    startDistance: 0,
+    startZoom: 1,
+    worldX: 0,
+    worldY: 0
+  }), Ot = pt(null), Dt = pt(null), $t = pt(!1), b = k(() => pn(ge), [ge]), gt = b.theme, Ee = gt.edgeColor ?? wr.edgeColor, Xt = gt.edgeWidth ?? wr.edgeWidth, _e = Gt ?? mt, Te = b.hoverNodeBorderColor ?? b.hoverEdgeColor, Pe = b.hoverNodeBothColor ?? b.hoverEdgeColor, Fe = gt.nodeBorderColor, Ye = gt.nodeBorderWidth ?? 0, Bt = b.showArrows, ce = `${Wt}-arrow`, Re = `${Wt}-arrow-hover`, Se = `${Wt}-arrow-hover-in`, Le = `${Wt}-arrow-selected`, F = k(
+    () => qe(o ?? oe, lt, ht),
+    [o, oe, ht, lt]
+  ), t = pt(F);
+  t.current = F;
+  const a = pt(h);
+  a.current = h;
+  const f = k(
+    () => ({
+      nodeIds: vt ?? se.nodeIds,
+      edgeIds: _t ?? se.edgeIds
+    }),
+    [vt, _t, se]
+  ), R = pt(f);
+  R.current = f;
+  const M = _ !== void 0 ? _ : we, {
+    collapsedIds: W,
+    collapsedNodeSet: z,
+    pendingExpansionNodeSet: j,
+    updateCollapsedNodeIds: nt,
+    setPendingExpansionNodeIds: B
+  } = wn({
+    collapsedNodeIds: ut,
+    defaultCollapsedNodeIds: rt,
+    onCollapsedNodeIdsChange: S
+  }), Z = k(() => new Set(f.nodeIds), [f.nodeIds]), ft = k(() => new Set(f.edgeIds), [f.edgeIds]), $ = K(
+    (n) => {
+      var U;
+      const d = t.current, p = typeof n == "function" ? n(d) : n, P = qe({ ...d, ...p }, lt, ht);
+      return o || ve(P), (U = a.current) == null || U.call(a, P), P;
+    },
+    // viewport and onViewportChange are intentionally excluded: both are read
+    // via refs so the callback stays stable across renders.
+    [o, ht, lt]
+  ), tt = K(
+    (n) => {
+      const d = R.current, p = typeof n == "function" ? n(d) : n;
+      (vt == null || _t == null) && xe((P) => ({
+        nodeIds: vt == null ? p.nodeIds : P.nodeIds,
+        edgeIds: _t == null ? p.edgeIds : P.edgeIds
+      })), ot == null || ot(p);
+    },
+    [ot, _t, vt]
+  ), C = K(
+    (n) => {
+      _ === void 0 && Ne(n), G == null || G(n);
+    },
+    [_, G]
+  ), {
+    childNodeIdsByParent: Vt,
+    effectiveHighlightedEdgeSet: We,
+    effectiveHighlightedNodeSet: $e,
+    handleNodeMeasure: Cr,
+    positionedEdges: Mt,
+    positionedNodes: st,
+    visibleEdges: or,
+    visibleNodesWithMeasuredSize: sr
+  } = In({
+    graph: e,
+    config: b,
+    mergedTheme: gt,
+    collapsedIds: W,
+    hiddenNodeIds: H,
+    searchQuery: V,
+    hideUnmatchedSearch: at,
+    searchPredicate: O,
+    highlightedNodeIds: A,
+    highlightedEdgeIds: Y,
+    highlightStrategy: dt,
+    onSearchResultsChange: jt,
+    layoutNodesOverride: De,
+    routeEdgesOverride: me,
+    onError: ct
+  }), Ur = K(
+    (n) => {
+      if (!(!D || !((Vt.get(n.id) ?? []).length > 0) || j.has(n.id)))
+        if (z.has(n.id))
+          try {
+            const p = it == null ? void 0 : it(n.id);
+            if (p && typeof p == "object" && "then" in p) {
+              B(
+                (P) => P.includes(n.id) ? P : [...P, n.id]
+              ), Promise.resolve(p).then(() => {
+                nt((P) => P.filter((U) => U !== n.id));
+              }).catch((P) => {
+                ct == null || ct(Je(P), { graph: e, phase: "interaction" });
+              }).finally(() => {
+                B(
+                  (P) => P.filter((U) => U !== n.id)
+                );
+              });
+              return;
+            }
+            nt((P) => P.filter((U) => U !== n.id));
+          } catch (p) {
+            ct == null || ct(Je(p), { graph: e, phase: "interaction" });
+          }
+        else {
+          nt((p) => [...p, n.id]);
+          try {
+            q == null || q(n.id);
+          } catch (p) {
+            ct == null || ct(Je(p), { graph: e, phase: "interaction" });
+          }
+        }
+    },
+    [
+      Vt,
+      z,
+      e,
+      ct,
+      q,
+      it,
+      j,
+      B,
+      D,
+      nt
+    ]
+  );
+  te(() => {
+    const n = new Set(sr.map((p) => p.id)), d = new Set(or.map((p) => p.id));
+    (f.nodeIds.some((p) => !n.has(p)) || f.edgeIds.some((p) => !d.has(p))) && tt({
+      nodeIds: f.nodeIds.filter((p) => n.has(p)),
+      edgeIds: f.edgeIds.filter((p) => d.has(p))
+    }), M && !n.has(M) && C(null);
+  }, [
+    M,
+    f,
+    C,
+    tt,
+    or,
+    sr
+  ]);
+  const It = k(
+    () => new Map(st.map((n) => [n.id, n])),
+    [st]
+  ), ar = k(
+    () => new Map(Mt.map((n) => [n.id, n])),
+    [Mt]
+  ), cr = k(() => Pn(st), [st]), ur = k(() => {
+    const n = je(
+      je(
+        cr,
+        Un(
+          st,
+          b.layout,
+          b.layoutDirection,
+          b.labels,
+          b.autoLabels,
+          b.labelOffset
+        )
+      ),
+      Hn(Mt)
+    );
+    return n && Cn(n, $n);
+  }, [
+    b.autoLabels,
+    b.labelOffset,
+    b.labels,
+    b.layout,
+    b.layoutDirection,
+    cr,
+    Mt,
+    st
+  ]), ke = K(() => {
+    var P;
+    const n = Ot.current;
+    if (!n)
+      return { width: b.width, height: b.height };
+    const p = ((P = n.parentElement) == null ? void 0 : P.getBoundingClientRect()) ?? n.getBoundingClientRect();
+    return {
+      width: p.width || b.width,
+      height: p.height || b.height
+    };
+  }, [b.height, b.width]), Ct = K(
+    (n = w) => {
+      const { width: d, height: p } = ke();
+      $(
+        Rn(ur, d, p, n, lt, ht)
+      );
+    },
+    [ur, w, ke, ht, lt, $]
+  ), Oe = K(
+    (n) => {
+      const d = It.get(n);
+      if (!d)
+        return;
+      const { width: p, height: P } = ke();
+      $(Sn(d, p, P, F.zoom));
+    },
+    [ke, It, $, F.zoom]
+  );
+  un(
+    ze,
+    () => ({
+      fitView: Ct,
+      centerOnNode: Oe,
+      zoomIn: () => $((n) => ({ zoom: n.zoom + m })),
+      zoomOut: () => $((n) => ({ zoom: n.zoom - m })),
+      zoomTo: (n) => $({ zoom: n }),
+      resetViewport: () => $(Ke),
+      getViewport: () => F,
+      setViewport: $,
+      clearSelection: () => tt(Ge)
+    }),
+    [Oe, Ct, tt, $, F, m]
+  ), te(() => {
+    $t.current = !1;
+  }, [e]), te(() => {
+    !u || $t.current || st.length === 0 || ($t.current = !0, Ct());
+  }, [Ct, u, st.length]);
+  const {
+    hoveredEdgeId: lr,
+    setHoveredEdgeId: fr,
+    hoveredNodeId: Ut,
+    setHoveredNodeId: Zt,
+    focusedPath: Xe,
+    setFocusedPath: At,
+    pathHighlight: qt,
+    hoveredNodeStates: Hr,
+    edgesForRender: Kr
+  } = xn(st, Mt, b.hoverHighlight), dr = pt(Ut);
+  dr.current = Ut;
+  const hr = k(
+    () => ({
+      graph: e,
+      nodes: st,
+      edges: Mt,
+      config: b,
+      viewport: F,
+      selection: f
+    }),
+    [b, e, Mt, st, f, F]
+  ), Jt = K(
+    (n, d, p = "pointer") => {
+      Pt == null || Pt(n, d, {
+        viewport: F,
+        selection: f,
+        trigger: p
+      });
+    },
+    [Pt, f, F]
+  ), pr = K(
+    (n, d, p = "pointer") => {
+      Yt == null || Yt(n, d, {
+        viewport: F,
+        selection: f,
+        trigger: p
+      });
+    },
+    [Yt, f, F]
+  ), Be = K(
+    (n) => {
+      if (!Lt) {
+        C(n.id), Rt == null || Rt(n);
+        return;
+      }
+      tt((d) => ({
+        nodeIds: Rr(d.nodeIds, n.id, Q),
+        edgeIds: Q === "single" ? [] : d.edgeIds
+      })), C(n.id), Rt == null || Rt(n);
+    },
+    [Lt, Rt, Q, C, tt]
+  ), Gr = K(
+    (n) => {
+      if (!Tt) {
+        yt == null || yt(n);
+        return;
+      }
+      tt((d) => ({
+        nodeIds: Q === "single" ? [] : d.nodeIds,
+        edgeIds: Rr(d.edgeIds, n.id, Q)
+      })), yt == null || yt(n);
+    },
+    [Tt, yt, Q, tt]
+  ), Vr = K(
+    (n) => {
+      var U, St;
+      const d = n.target, p = !!d.closest('[data-graph-node-interactive="true"], [data-graph-edge-interactive="true"]'), P = Qe(Ot.current, n.clientX, n.clientY);
+      if (!p && Q === "multiple" && E && n.shiftKey) {
+        ae({
+          startX: P.x,
+          startY: P.y,
+          endX: P.x,
+          endY: P.y
+        }), xt.current.active = !1;
+        return;
+      }
+      if (n.pointerType === "touch" && (wt.current.set(n.pointerId, P), l && I && wt.current.size === 2)) {
+        const [zt, et] = Array.from(wt.current.values()), Qt = Lr(zt, et);
+        bt.current = {
+          active: !0,
+          startDistance: Sr(zt, et),
+          startZoom: F.zoom,
+          worldX: (Qt.x - F.x) / F.zoom,
+          worldY: (Qt.y - F.y) / F.zoom
+        }, xt.current.active = !1, (U = d.setPointerCapture) == null || U.call(d, n.pointerId);
+        return;
+      }
+      !g || n.button !== 0 || p || (xt.current = {
+        active: !0,
+        startX: P.x,
+        startY: P.y,
+        originX: F.x,
+        originY: F.y
+      }, Ie(!0), (St = d.setPointerCapture) == null || St.call(d, n.pointerId));
+    },
+    [E, g, l, Q, F, I]
+  ), Zr = K(
+    (n) => {
+      const d = Qe(Ot.current, n.clientX, n.clientY);
+      if (n.pointerType === "touch" && wt.current.has(n.pointerId) && (wt.current.set(n.pointerId, d), bt.current.active && wt.current.size >= 2)) {
+        const [p, P] = Array.from(wt.current.values()), U = Lr(p, P), St = Sr(p, P), zt = Ae(
+          bt.current.startZoom * (St / Math.max(1, bt.current.startDistance)),
+          lt,
+          ht
+        );
+        $({
+          zoom: zt,
+          x: U.x - bt.current.worldX * zt,
+          y: U.y - bt.current.worldY * zt
+        });
+        return;
+      }
+      if (kt) {
+        ae(
+          (p) => p && {
+            ...p,
+            endX: d.x,
+            endY: d.y
+          }
+        );
+        return;
+      }
+      !g || !xt.current.active || $({
+        x: xt.current.originX + (d.x - xt.current.startX),
+        y: xt.current.originY + (d.y - xt.current.startY)
+      });
+    },
+    [g, ht, lt, kt, $]
+  ), mr = K(
+    (n) => {
+      var d, p;
+      if (wt.current.delete(n.pointerId), wt.current.size < 2 && (bt.current.active = !1), kt) {
+        const P = kr(kt), U = {
+          x: (P.x - F.x) / F.zoom,
+          y: (P.y - F.y) / F.zoom,
+          width: P.width / F.zoom,
+          height: P.height / F.zoom
+        }, St = st.filter((et) => {
+          var le, gr;
+          const Qt = ((le = et.size) == null ? void 0 : le.width) ?? 0, Ce = ((gr = et.size) == null ? void 0 : gr.height) ?? 0;
+          return !(et.position.x + Qt < U.x || et.position.x > U.x + U.width || et.position.y + Ce < U.y || et.position.y > U.y + U.height);
+        }).map((et) => et.id), zt = Mt.filter((et) => {
+          const Qt = et.points.some(
+            (le) => Or(le.x, le.y, U)
+          ), Ce = !!et.labelPosition && Or(et.labelPosition.x, et.labelPosition.y, U);
+          return Qt || Ce;
+        }).map((et) => et.id);
+        tt((et) => ({
+          nodeIds: Array.from(/* @__PURE__ */ new Set([...et.nodeIds, ...St])),
+          edgeIds: Array.from(/* @__PURE__ */ new Set([...et.edgeIds, ...zt]))
+        })), ae(null);
+      }
+      xt.current.active = !1, Ie(!1), (p = (d = n.target).releasePointerCapture) == null || p.call(d, n.pointerId);
+    },
+    [Mt, st, kt, tt, F]
+  ), qr = K(
+    (n) => {
+      if (!I || !Ot.current)
+        return;
+      n.preventDefault();
+      const d = Qe(Ot.current, n.clientX, n.clientY), p = t.current, P = (d.x - p.x) / p.zoom, U = (d.y - p.y) / p.zoom, St = Ae(
+        p.zoom + (n.deltaY < 0 ? m : -m),
+        lt,
+        ht
+      );
+      $({
+        zoom: St,
+        x: d.x - P * St,
+        y: d.y - U * St
+      });
+    },
+    [ht, lt, $, I, m]
+  ), Jr = K(
+    (n) => {
+      if (L)
+        switch (n.key) {
+          case "+":
+          case "=":
+            n.preventDefault(), $((d) => ({ zoom: d.zoom + m }));
+            break;
+          case "-":
+          case "_":
+            n.preventDefault(), $((d) => ({ zoom: d.zoom - m }));
+            break;
+          case "0":
+            n.preventDefault(), Ct();
+            break;
+          case "ArrowLeft":
+          case "ArrowRight":
+          case "ArrowUp":
+          case "ArrowDown": {
+            if (n.preventDefault(), M) {
+              const d = It.get(M);
+              if (d) {
+                const p = n.key === "ArrowLeft" ? "left" : n.key === "ArrowRight" ? "right" : n.key === "ArrowUp" ? "up" : "down", P = Kn(d, st, p);
+                P && (C(P.id), Oe(P.id));
+                break;
+              }
+            }
+            $((d) => n.key === "ArrowLeft" ? { x: d.x + 32 } : n.key === "ArrowRight" ? { x: d.x - 32 } : n.key === "ArrowUp" ? { y: d.y + 32 } : { y: d.y - 32 });
+            break;
+          }
+          case "Enter":
+          case " ": {
+            if (!M)
+              break;
+            n.preventDefault();
+            const d = It.get(M);
+            d && Be(d);
+            break;
+          }
+          case "Escape":
+            n.preventDefault(), At(null), tt(Ge), C(null);
+            break;
+        }
+    },
+    [
+      Oe,
+      Ct,
+      M,
+      Be,
+      L,
+      It,
+      st,
+      At,
+      C,
+      tt,
+      $,
+      m
+    ]
+  ), Qr = K(
+    (n) => {
+      Zt(n);
+      const d = It.get(n);
+      d && Jt(d, !0);
+    },
+    [Jt, It, Zt]
+  ), tn = K(() => {
+    const n = dr.current;
+    if (n) {
+      const d = It.get(n);
+      d && Jt(d, !1);
+    }
+    Zt(null), At(null);
+  }, [Jt, It, At, Zt]), en = K(
+    (n, d, p) => {
+      At({ nodeId: n, sourceIndex: d, pathKey: p });
+      const P = It.get(n);
+      P && Jt(P, !0, "path");
+    },
+    [Jt, It, At]
+  ), rn = K(() => {
+    At(null);
+  }, [At]), nn = K(
+    (n, d) => {
+      const p = ar.get(n);
+      p && pr(p, d), b.hoverHighlight && (fr(d ? n : null), d && Zt(null));
+    },
+    [b.hoverHighlight, pr, ar, fr, Zt]
+  ), on = k(
+    () => ({
+      background: gt.background,
+      fontFamily: gt.fontFamily,
+      cursor: be ? "grabbing" : g ? "grab" : "default",
+      outline: "none",
+      touchAction: g || I ? "none" : "auto",
+      overflow: "hidden",
+      userSelect: "none"
+    }),
+    [be, gt.background, gt.fontFamily, g, I]
+  ), yr = k(
+    () => Bn(b.width, b.height, y),
+    [b.height, b.width, y]
+  ), ue = kt ? kr(kt) : null, sn = X ? /* @__PURE__ */ N.jsx(
+    "g",
+    {
+      "aria-label": "viewport-controls",
+      transform: `translate(${yr.x}, ${yr.y})`,
+      children: [
+        {
+          key: "zoom-in",
+          label: "+",
+          width: Ht,
+          onClick: () => $((n) => ({ zoom: n.zoom + m }))
+        },
+        {
+          key: "zoom-out",
+          label: "−",
+          width: Ht,
+          onClick: () => $((n) => ({ zoom: n.zoom - m }))
+        },
+        {
+          key: "fit-view",
+          label: "Fit",
+          width: ir,
+          onClick: () => Ct()
+        },
+        {
+          key: "reset-view",
+          label: "1:1",
+          width: ir,
+          onClick: () => $(Ke)
+        }
+      ].reduce(
+        (n, d) => ({
+          x: n.x + d.width + Xr,
+          controls: [...n.controls, { ...d, x: n.x }]
+        }),
+        { x: 0, controls: [] }
+      ).controls.map((n) => /* @__PURE__ */ N.jsxs(
+        "g",
+        {
+          transform: `translate(${n.x}, 0)`,
+          role: "button",
+          tabIndex: 0,
+          onClick: (d) => {
+            d.stopPropagation(), n.onClick();
+          },
+          onKeyDown: (d) => {
+            (d.key === "Enter" || d.key === " ") && (d.preventDefault(), d.stopPropagation(), n.onClick());
+          },
+          children: [
+            /* @__PURE__ */ N.jsx(
+              "rect",
+              {
+                width: n.width,
+                height: Ht,
+                rx: 7,
+                ry: 7,
+                fill: "rgba(255,255,255,0.92)",
+                stroke: "rgba(15,23,42,0.18)"
+              }
+            ),
+            /* @__PURE__ */ N.jsx(
+              "text",
+              {
+                x: n.width / 2,
+                y: Ht / 2 + 4,
+                textAnchor: "middle",
+                fontSize: n.label.length > 1 ? 10 : 16,
+                fontWeight: 700,
+                fill: "#0f172a",
+                children: n.label
+              }
+            )
+          ]
+        },
+        n.key
+      ))
+    }
+  ) : null;
+  return /* @__PURE__ */ N.jsxs(
+    "svg",
+    {
+      ref: Ot,
+      width: b.width,
+      height: b.height,
+      role: "figure",
+      "aria-label": "Graph",
+      tabIndex: 0,
+      style: on,
+      onClick: (n) => {
+        n.target === n.currentTarget && (tt(Ge), At(null), C(null));
+      },
+      onPointerDown: Vr,
+      onPointerMove: Zr,
+      onPointerUp: mr,
+      onPointerLeave: mr,
+      onWheel: qr,
+      onKeyDown: Jr,
+      children: [
+        Bt ? /* @__PURE__ */ N.jsxs("defs", { children: [
+          /* @__PURE__ */ N.jsx(
+            "marker",
+            {
+              id: ce,
+              viewBox: "0 0 10 10",
+              refX: "6",
+              refY: "5",
+              markerWidth: "6",
+              markerHeight: "6",
+              orient: "auto-start-reverse",
+              children: /* @__PURE__ */ N.jsx("path", { d: "M 0 0 L 10 5 L 0 10 z", fill: Ee })
+            }
+          ),
+          /* @__PURE__ */ N.jsx(
+            "marker",
+            {
+              id: Re,
+              viewBox: "0 0 10 10",
+              refX: "6",
+              refY: "5",
+              markerWidth: "6",
+              markerHeight: "6",
+              orient: "auto-start-reverse",
+              children: /* @__PURE__ */ N.jsx("path", { d: "M 0 0 L 10 5 L 0 10 z", fill: b.hoverEdgeColor })
+            }
+          ),
+          /* @__PURE__ */ N.jsx(
+            "marker",
+            {
+              id: Se,
+              viewBox: "0 0 10 10",
+              refX: "6",
+              refY: "5",
+              markerWidth: "6",
+              markerHeight: "6",
+              orient: "auto-start-reverse",
+              children: /* @__PURE__ */ N.jsx("path", { d: "M 0 0 L 10 5 L 0 10 z", fill: b.hoverNodeOutColor })
+            }
+          ),
+          /* @__PURE__ */ N.jsx(
+            "marker",
+            {
+              id: Le,
+              viewBox: "0 0 10 10",
+              refX: "6",
+              refY: "5",
+              markerWidth: "6",
+              markerHeight: "6",
+              orient: "auto-start-reverse",
+              children: /* @__PURE__ */ N.jsx("path", { d: "M 0 0 L 10 5 L 0 10 z", fill: _e })
+            }
+          )
+        ] }) : null,
+        /* @__PURE__ */ N.jsx("g", { transform: `translate(${F.x}, ${F.y}) scale(${F.zoom})`, children: /* @__PURE__ */ N.jsxs("g", { ref: Dt, children: [
+          ne == null ? void 0 : ne(hr),
+          /* @__PURE__ */ N.jsx(
+            zn,
+            {
+              positionedNodes: st,
+              layout: b.layout,
+              layoutDirection: b.layoutDirection,
+              labels: b.labels,
+              autoLabels: b.autoLabels,
+              labelOffset: b.labelOffset,
+              pillBackground: b.labelPillBackground,
+              pillBorderColor: b.labelPillBorderColor,
+              pillTextColor: b.labelPillTextColor
+            }
+          ),
+          /* @__PURE__ */ N.jsx("g", { "aria-label": "edges", children: Kr.map((n) => {
+            const d = b.hoverHighlight && (lr === n.id || Ut && (n.source === Ut || n.target === Ut)) || (qt == null ? void 0 : qt.edges.has(n.id)), p = Ut && !lr && n.type !== "undirected" && n.target === Ut;
+            return /* @__PURE__ */ N.jsx(
+              s,
+              {
+                edge: n,
+                color: Ee,
+                width: Xt,
+                curveEdges: b.curveEdges && b.routingStyle !== "orthogonal",
+                curveStrength: b.curveStrength,
+                markerEnd: Bt ? `url(#${ce})` : void 0,
+                isHovered: d,
+                isSelected: ft.has(n.id) || We.has(n.id),
+                hoverColor: p ? b.hoverNodeOutColor : b.hoverEdgeColor,
+                selectionColor: ft.has(n.id) ? _e : J,
+                labelColor: b.edgeLabelColor,
+                selectionMarker: Bt ? `url(#${Le})` : void 0,
+                hoverMarker: Bt ? p ? `url(#${Se})` : `url(#${Re})` : void 0,
+                hoverEnabled: b.hoverHighlight,
+                hitStrokeWidth: Xt + 8,
+                hoverStrokeWidth: Xt + 1.5,
+                selectedStrokeWidth: Xt + 1.5,
+                onHoverChange: (P) => nn(n.id, P),
+                onClick: () => Gr(n)
+              },
+              n.id
+            );
+          }) }),
+          /* @__PURE__ */ N.jsx("g", { "aria-label": "nodes", children: st.map((n) => /* @__PURE__ */ N.jsx(
+            Yr,
+            {
+              node: n,
+              Vertex: r,
+              isSelected: Z.has(n.id),
+              isFocused: M === n.id,
+              isHighlighted: $e.has(n.id),
+              activePathKey: Xe == null ? void 0 : Xe.pathKey,
+              activePathNodeIds: qt == null ? void 0 : qt.nodes,
+              highlightColor: J,
+              selectionColor: mt,
+              nodeBorderColor: Fe,
+              nodeBorderWidth: Ye,
+              hoverNodeBorderColor: Te,
+              hoverNodeBothColor: Pe,
+              hoverNodeInColor: b.hoverNodeInColor,
+              hoverNodeOutColor: b.hoverNodeOutColor,
+              hoverNodeHighlight: b.hoverNodeHighlight,
+              hoveredNodeStates: Hr ?? void 0,
+              onNodeMeasure: Cr,
+              onNodeFocus: C,
+              onNodeClick: Be,
+              onNodeDoubleClick: Ur,
+              onNodeMouseEnter: Qr,
+              onNodeMouseLeave: tn,
+              onPathHover: en,
+              onPathLeave: rn
+            },
+            n.id
+          )) }),
+          ie == null ? void 0 : ie(hr)
+        ] }) }),
+        ue ? /* @__PURE__ */ N.jsx(
+          "rect",
+          {
+            x: ue.x,
+            y: ue.y,
+            width: ue.width,
+            height: ue.height,
+            fill: "rgba(59, 130, 246, 0.12)",
+            stroke: "rgba(59, 130, 246, 0.8)",
+            strokeDasharray: "6 4",
+            pointerEvents: "none"
+          }
+        ) : null,
+        sn
+      ]
+    }
+  );
+}, Br = re.memo(
+  re.forwardRef(Gn)
+);
+Br.displayName = "Graph";
+const Jn = Br;
+export {
+  Ln as EdgePath,
+  ei as EdgeType,
+  Jn as Graph,
+  ri as LayoutDirection,
+  ni as LayoutType,
+  ii as NodeSide,
+  si as buildEdgePath,
+  ai as fromNxGraph,
+  jr as groupPositionedNodesByColumn,
+  ci as layoutNodes,
+  ui as renderGraphToSvg,
+  li as routeEdges
+};