force-3d-graph 1.0.0

package/dist/force-3d-graph.js

@@ -0,0 +1,2625 @@
+var ot = Object.defineProperty;
+var nt = (c, e, o) => e in c ? ot(c, e, { enumerable: !0, configurable: !0, writable: !0, value: o }) : c[e] = o;
+var r = (c, e, o) => nt(c, typeof e != "symbol" ? e + "" : e, o);
+import * as p from "three";
+import { EventDispatcher as it, Vector3 as N, MOUSE as H, TOUCH as K, Spherical as Ne, Quaternion as ze, Vector2 as S, Ray as st, Plane as at, MathUtils as rt } from "three";
+const O = {
+  backgroundColor: 657930,
+  cameraPosition: { x: 0, y: 0, z: 80 },
+  cameraFov: 75,
+  repulsionStrength: 100,
+  attractionStrength: 0.01,
+  damping: 0.9,
+  useBarnesHut: !1,
+  // Auto-enabled for large graphs
+  barnesHutTheta: 0.5,
+  defaultNodeColor: 4886754,
+  nodeRadius: 2,
+  nodeSegments: 32,
+  enableLOD: !0,
+  lodDistances: [50, 100, 200],
+  lodSegments: [32, 16, 8],
+  edgeColor: 8947848,
+  edgeOpacity: 0.4,
+  enableEdgeCulling: !0,
+  showPanel: !0,
+  targetFPS: 60,
+  maxVisibleNodes: 1e4
+};
+var _ = /* @__PURE__ */ ((c) => (c[c.HIGH = 0] = "HIGH", c[c.MEDIUM = 1] = "MEDIUM", c[c.LOW = 2] = "LOW", c))(_ || {});
+function lt() {
+  const c = document.createElement("div");
+  return c.id = "force-graph-3d-container", c.style.cssText = `
+    width: 100%;
+    height: 100%;
+    position: absolute;
+    top: 0;
+    left: 0;
+    overflow: hidden;
+  `, document.body.appendChild(c), c;
+}
+function ct(c) {
+  return c && c instanceof HTMLElement ? c : (console.warn("[ForceGraph3D] No container provided, creating one automatically"), lt());
+}
+function Se(c) {
+  const e = c.getBoundingClientRect();
+  return {
+    width: e.width || window.innerWidth,
+    height: e.height || window.innerHeight
+  };
+}
+function Ie(c) {
+  if (!c || typeof c != "object")
+    return console.warn("[ForceGraph3D] Invalid node: must be an object"), !1;
+  const e = c;
+  return typeof e.id != "string" || e.id.trim() === "" ? (console.warn("[ForceGraph3D] Invalid node: id must be a non-empty string"), !1) : typeof e.label != "string" ? (console.warn("[ForceGraph3D] Invalid node: label must be a string"), !1) : e.color !== void 0 && typeof e.color != "number" ? (console.warn("[ForceGraph3D] Invalid node: color must be a number (hex)"), !1) : e.position !== void 0 && !dt(e.position) ? (console.warn("[ForceGraph3D] Invalid node: position must have x, y, z numbers"), !1) : !0;
+}
+function Re(c) {
+  if (!c || typeof c != "object")
+    return console.warn("[ForceGraph3D] Invalid edge: must be an object"), !1;
+  const e = c;
+  return typeof e.source != "string" || e.source.trim() === "" ? (console.warn("[ForceGraph3D] Invalid edge: source must be a non-empty string"), !1) : typeof e.target != "string" || e.target.trim() === "" ? (console.warn("[ForceGraph3D] Invalid edge: target must be a non-empty string"), !1) : !0;
+}
+function ht(c) {
+  return typeof c != "string" || c.trim() === "" ? (console.warn("[ForceGraph3D] Invalid node ID: must be a non-empty string"), !1) : !0;
+}
+function dt(c) {
+  if (!c || typeof c != "object") return !1;
+  const e = c;
+  return typeof e.x == "number" && typeof e.y == "number" && typeof e.z == "number";
+}
+function I(c, e) {
+  return c === e ? `${c}-${e}` : c < e ? `${c}-${e}` : `${e}-${c}`;
+}
+const Pe = { type: "change" }, ae = { type: "start" }, Te = { type: "end" }, Z = new st(), Oe = new at(), pt = Math.cos(70 * rt.DEG2RAD);
+class gt extends it {
+  constructor(e, o) {
+    super(), this.object = e, this.domElement = o, this.domElement.style.touchAction = "none", this.enabled = !0, this.target = new N(), this.cursor = new N(), this.minDistance = 0, this.maxDistance = 1 / 0, this.minZoom = 0, this.maxZoom = 1 / 0, this.minTargetRadius = 0, this.maxTargetRadius = 1 / 0, this.minPolarAngle = 0, this.maxPolarAngle = Math.PI, this.minAzimuthAngle = -1 / 0, this.maxAzimuthAngle = 1 / 0, this.enableDamping = !1, this.dampingFactor = 0.05, this.enableZoom = !0, this.zoomSpeed = 1, this.enableRotate = !0, this.rotateSpeed = 1, this.enablePan = !0, this.panSpeed = 1, this.screenSpacePanning = !0, this.keyPanSpeed = 7, this.zoomToCursor = !1, this.autoRotate = !1, this.autoRotateSpeed = 2, this.keys = { LEFT: "ArrowLeft", UP: "ArrowUp", RIGHT: "ArrowRight", BOTTOM: "ArrowDown" }, this.mouseButtons = { LEFT: H.ROTATE, MIDDLE: H.DOLLY, RIGHT: H.PAN }, this.touches = { ONE: K.ROTATE, TWO: K.DOLLY_PAN }, this.target0 = this.target.clone(), this.position0 = this.object.position.clone(), this.zoom0 = this.object.zoom, this._domElementKeyEvents = null, this.getPolarAngle = function() {
+      return l.phi;
+    }, this.getAzimuthalAngle = function() {
+      return l.theta;
+    }, this.getDistance = function() {
+      return this.object.position.distanceTo(this.target);
+    }, this.listenToKeyEvents = function(s) {
+      s.addEventListener("keydown", ie), this._domElementKeyEvents = s;
+    }, this.stopListenToKeyEvents = function() {
+      this._domElementKeyEvents.removeEventListener("keydown", ie), this._domElementKeyEvents = null;
+    }, this.saveState = function() {
+      t.target0.copy(t.target), t.position0.copy(t.object.position), t.zoom0 = t.object.zoom;
+    }, this.reset = function() {
+      t.target.copy(t.target0), t.object.position.copy(t.position0), t.object.zoom = t.zoom0, t.object.updateProjectionMatrix(), t.dispatchEvent(Pe), t.update(), i = n.NONE;
+    }, this.update = function() {
+      const s = new N(), h = new ze().setFromUnitVectors(e.up, new N(0, 1, 0)), m = h.clone().invert(), b = new N(), E = new ze(), F = new N(), z = 2 * Math.PI;
+      return function(tt = null) {
+        const Ce = t.object.position;
+        s.copy(Ce).sub(t.target), s.applyQuaternion(h), l.setFromVector3(s), t.autoRotate && i === n.NONE && G(Ae(tt)), t.enableDamping ? (l.theta += d.theta * t.dampingFactor, l.phi += d.phi * t.dampingFactor) : (l.theta += d.theta, l.phi += d.phi);
+        let P = t.minAzimuthAngle, T = t.maxAzimuthAngle;
+        isFinite(P) && isFinite(T) && (P < -Math.PI ? P += z : P > Math.PI && (P -= z), T < -Math.PI ? T += z : T > Math.PI && (T -= z), P <= T ? l.theta = Math.max(P, Math.min(T, l.theta)) : l.theta = l.theta > (P + T) / 2 ? Math.max(P, l.theta) : Math.min(T, l.theta)), l.phi = Math.max(t.minPolarAngle, Math.min(t.maxPolarAngle, l.phi)), l.makeSafe(), t.enableDamping === !0 ? t.target.addScaledVector(u, t.dampingFactor) : t.target.add(u), t.target.sub(t.cursor), t.target.clampLength(t.minTargetRadius, t.maxTargetRadius), t.target.add(t.cursor), t.zoomToCursor && U || t.object.isOrthographicCamera ? l.radius = oe(l.radius) : l.radius = oe(l.radius * g), s.setFromSpherical(l), s.applyQuaternion(m), Ce.copy(t.target).add(s), t.object.lookAt(t.target), t.enableDamping === !0 ? (d.theta *= 1 - t.dampingFactor, d.phi *= 1 - t.dampingFactor, u.multiplyScalar(1 - t.dampingFactor)) : (d.set(0, 0, 0), u.set(0, 0, 0));
+        let se = !1;
+        if (t.zoomToCursor && U) {
+          let Y = null;
+          if (t.object.isPerspectiveCamera) {
+            const B = s.length();
+            Y = oe(B * g);
+            const q = B - Y;
+            t.object.position.addScaledVector(re, q), t.object.updateMatrixWorld();
+          } else if (t.object.isOrthographicCamera) {
+            const B = new N(L.x, L.y, 0);
+            B.unproject(t.object), t.object.zoom = Math.max(t.minZoom, Math.min(t.maxZoom, t.object.zoom / g)), t.object.updateProjectionMatrix(), se = !0;
+            const q = new N(L.x, L.y, 0);
+            q.unproject(t.object), t.object.position.sub(q).add(B), t.object.updateMatrixWorld(), Y = s.length();
+          } else
+            console.warn("WARNING: OrbitControls.js encountered an unknown camera type - zoom to cursor disabled."), t.zoomToCursor = !1;
+          Y !== null && (this.screenSpacePanning ? t.target.set(0, 0, -1).transformDirection(t.object.matrix).multiplyScalar(Y).add(t.object.position) : (Z.origin.copy(t.object.position), Z.direction.set(0, 0, -1).transformDirection(t.object.matrix), Math.abs(t.object.up.dot(Z.direction)) < pt ? e.lookAt(t.target) : (Oe.setFromNormalAndCoplanarPoint(t.object.up, t.target), Z.intersectPlane(Oe, t.target))));
+        } else t.object.isOrthographicCamera && (t.object.zoom = Math.max(t.minZoom, Math.min(t.maxZoom, t.object.zoom / g)), t.object.updateProjectionMatrix(), se = !0);
+        return g = 1, U = !1, se || b.distanceToSquared(t.object.position) > a || 8 * (1 - E.dot(t.object.quaternion)) > a || F.distanceToSquared(t.target) > 0 ? (t.dispatchEvent(Pe), b.copy(t.object.position), E.copy(t.object.quaternion), F.copy(t.target), !0) : !1;
+      };
+    }(), this.dispose = function() {
+      t.domElement.removeEventListener("contextmenu", Ee), t.domElement.removeEventListener("pointerdown", be), t.domElement.removeEventListener("pointercancel", $), t.domElement.removeEventListener("wheel", ve), t.domElement.removeEventListener("pointermove", ne), t.domElement.removeEventListener("pointerup", $), t._domElementKeyEvents !== null && (t._domElementKeyEvents.removeEventListener("keydown", ie), t._domElementKeyEvents = null);
+    };
+    const t = this, n = {
+      NONE: -1,
+      ROTATE: 0,
+      DOLLY: 1,
+      PAN: 2,
+      TOUCH_ROTATE: 3,
+      TOUCH_PAN: 4,
+      TOUCH_DOLLY_PAN: 5,
+      TOUCH_DOLLY_ROTATE: 6
+    };
+    let i = n.NONE;
+    const a = 1e-6, l = new Ne(), d = new Ne();
+    let g = 1;
+    const u = new N(), x = new S(), v = new S(), y = new S(), f = new S(), M = new S(), C = new S(), R = new S(), A = new S(), k = new S(), re = new N(), L = new S();
+    let U = !1;
+    const w = [], V = {};
+    let J = !1;
+    function Ae(s) {
+      return s !== null ? 2 * Math.PI / 60 * t.autoRotateSpeed * s : 2 * Math.PI / 60 / 60 * t.autoRotateSpeed;
+    }
+    function X(s) {
+      const h = Math.abs(s * 0.01);
+      return Math.pow(0.95, t.zoomSpeed * h);
+    }
+    function G(s) {
+      d.theta -= s;
+    }
+    function W(s) {
+      d.phi -= s;
+    }
+    const le = function() {
+      const s = new N();
+      return function(m, b) {
+        s.setFromMatrixColumn(b, 0), s.multiplyScalar(-m), u.add(s);
+      };
+    }(), ce = function() {
+      const s = new N();
+      return function(m, b) {
+        t.screenSpacePanning === !0 ? s.setFromMatrixColumn(b, 1) : (s.setFromMatrixColumn(b, 0), s.crossVectors(t.object.up, s)), s.multiplyScalar(m), u.add(s);
+      };
+    }(), j = function() {
+      const s = new N();
+      return function(m, b) {
+        const E = t.domElement;
+        if (t.object.isPerspectiveCamera) {
+          const F = t.object.position;
+          s.copy(F).sub(t.target);
+          let z = s.length();
+          z *= Math.tan(t.object.fov / 2 * Math.PI / 180), le(2 * m * z / E.clientHeight, t.object.matrix), ce(2 * b * z / E.clientHeight, t.object.matrix);
+        } else t.object.isOrthographicCamera ? (le(m * (t.object.right - t.object.left) / t.object.zoom / E.clientWidth, t.object.matrix), ce(b * (t.object.top - t.object.bottom) / t.object.zoom / E.clientHeight, t.object.matrix)) : (console.warn("WARNING: OrbitControls.js encountered an unknown camera type - pan disabled."), t.enablePan = !1);
+      };
+    }();
+    function ee(s) {
+      t.object.isPerspectiveCamera || t.object.isOrthographicCamera ? g /= s : (console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled."), t.enableZoom = !1);
+    }
+    function he(s) {
+      t.object.isPerspectiveCamera || t.object.isOrthographicCamera ? g *= s : (console.warn("WARNING: OrbitControls.js encountered an unknown camera type - dolly/zoom disabled."), t.enableZoom = !1);
+    }
+    function te(s, h) {
+      if (!t.zoomToCursor)
+        return;
+      U = !0;
+      const m = t.domElement.getBoundingClientRect(), b = s - m.left, E = h - m.top, F = m.width, z = m.height;
+      L.x = b / F * 2 - 1, L.y = -(E / z) * 2 + 1, re.set(L.x, L.y, 1).unproject(t.object).sub(t.object.position).normalize();
+    }
+    function oe(s) {
+      return Math.max(t.minDistance, Math.min(t.maxDistance, s));
+    }
+    function de(s) {
+      x.set(s.clientX, s.clientY);
+    }
+    function je(s) {
+      te(s.clientX, s.clientX), R.set(s.clientX, s.clientY);
+    }
+    function pe(s) {
+      f.set(s.clientX, s.clientY);
+    }
+    function De(s) {
+      v.set(s.clientX, s.clientY), y.subVectors(v, x).multiplyScalar(t.rotateSpeed);
+      const h = t.domElement;
+      G(2 * Math.PI * y.x / h.clientHeight), W(2 * Math.PI * y.y / h.clientHeight), x.copy(v), t.update();
+    }
+    function He(s) {
+      A.set(s.clientX, s.clientY), k.subVectors(A, R), k.y > 0 ? ee(X(k.y)) : k.y < 0 && he(X(k.y)), R.copy(A), t.update();
+    }
+    function Ke(s) {
+      M.set(s.clientX, s.clientY), C.subVectors(M, f).multiplyScalar(t.panSpeed), j(C.x, C.y), f.copy(M), t.update();
+    }
+    function Ge(s) {
+      te(s.clientX, s.clientY), s.deltaY < 0 ? he(X(s.deltaY)) : s.deltaY > 0 && ee(X(s.deltaY)), t.update();
+    }
+    function $e(s) {
+      let h = !1;
+      switch (s.code) {
+        case t.keys.UP:
+          s.ctrlKey || s.metaKey || s.shiftKey ? W(2 * Math.PI * t.rotateSpeed / t.domElement.clientHeight) : j(0, t.keyPanSpeed), h = !0;
+          break;
+        case t.keys.BOTTOM:
+          s.ctrlKey || s.metaKey || s.shiftKey ? W(-2 * Math.PI * t.rotateSpeed / t.domElement.clientHeight) : j(0, -t.keyPanSpeed), h = !0;
+          break;
+        case t.keys.LEFT:
+          s.ctrlKey || s.metaKey || s.shiftKey ? G(2 * Math.PI * t.rotateSpeed / t.domElement.clientHeight) : j(t.keyPanSpeed, 0), h = !0;
+          break;
+        case t.keys.RIGHT:
+          s.ctrlKey || s.metaKey || s.shiftKey ? G(-2 * Math.PI * t.rotateSpeed / t.domElement.clientHeight) : j(-t.keyPanSpeed, 0), h = !0;
+          break;
+      }
+      h && (s.preventDefault(), t.update());
+    }
+    function ge(s) {
+      if (w.length === 1)
+        x.set(s.pageX, s.pageY);
+      else {
+        const h = D(s), m = 0.5 * (s.pageX + h.x), b = 0.5 * (s.pageY + h.y);
+        x.set(m, b);
+      }
+    }
+    function ue(s) {
+      if (w.length === 1)
+        f.set(s.pageX, s.pageY);
+      else {
+        const h = D(s), m = 0.5 * (s.pageX + h.x), b = 0.5 * (s.pageY + h.y);
+        f.set(m, b);
+      }
+    }
+    function me(s) {
+      const h = D(s), m = s.pageX - h.x, b = s.pageY - h.y, E = Math.sqrt(m * m + b * b);
+      R.set(0, E);
+    }
+    function Ye(s) {
+      t.enableZoom && me(s), t.enablePan && ue(s);
+    }
+    function Be(s) {
+      t.enableZoom && me(s), t.enableRotate && ge(s);
+    }
+    function fe(s) {
+      if (w.length == 1)
+        v.set(s.pageX, s.pageY);
+      else {
+        const m = D(s), b = 0.5 * (s.pageX + m.x), E = 0.5 * (s.pageY + m.y);
+        v.set(b, E);
+      }
+      y.subVectors(v, x).multiplyScalar(t.rotateSpeed);
+      const h = t.domElement;
+      G(2 * Math.PI * y.x / h.clientHeight), W(2 * Math.PI * y.y / h.clientHeight), x.copy(v);
+    }
+    function ye(s) {
+      if (w.length === 1)
+        M.set(s.pageX, s.pageY);
+      else {
+        const h = D(s), m = 0.5 * (s.pageX + h.x), b = 0.5 * (s.pageY + h.y);
+        M.set(m, b);
+      }
+      C.subVectors(M, f).multiplyScalar(t.panSpeed), j(C.x, C.y), f.copy(M);
+    }
+    function xe(s) {
+      const h = D(s), m = s.pageX - h.x, b = s.pageY - h.y, E = Math.sqrt(m * m + b * b);
+      A.set(0, E), k.set(0, Math.pow(A.y / R.y, t.zoomSpeed)), ee(k.y), R.copy(A);
+      const F = (s.pageX + h.x) * 0.5, z = (s.pageY + h.y) * 0.5;
+      te(F, z);
+    }
+    function _e(s) {
+      t.enableZoom && xe(s), t.enablePan && ye(s);
+    }
+    function Ue(s) {
+      t.enableZoom && xe(s), t.enableRotate && fe(s);
+    }
+    function be(s) {
+      t.enabled !== !1 && (w.length === 0 && (t.domElement.setPointerCapture(s.pointerId), t.domElement.addEventListener("pointermove", ne), t.domElement.addEventListener("pointerup", $)), Je(s), s.pointerType === "touch" ? Ze(s) : Ve(s));
+    }
+    function ne(s) {
+      t.enabled !== !1 && (s.pointerType === "touch" ? Qe(s) : Xe(s));
+    }
+    function $(s) {
+      et(s), w.length === 0 && (t.domElement.releasePointerCapture(s.pointerId), t.domElement.removeEventListener("pointermove", ne), t.domElement.removeEventListener("pointerup", $)), t.dispatchEvent(Te), i = n.NONE;
+    }
+    function Ve(s) {
+      let h;
+      switch (s.button) {
+        case 0:
+          h = t.mouseButtons.LEFT;
+          break;
+        case 1:
+          h = t.mouseButtons.MIDDLE;
+          break;
+        case 2:
+          h = t.mouseButtons.RIGHT;
+          break;
+        default:
+          h = -1;
+      }
+      switch (h) {
+        case H.DOLLY:
+          if (t.enableZoom === !1) return;
+          je(s), i = n.DOLLY;
+          break;
+        case H.ROTATE:
+          if (s.ctrlKey || s.metaKey || s.shiftKey) {
+            if (t.enablePan === !1) return;
+            pe(s), i = n.PAN;
+          } else {
+            if (t.enableRotate === !1) return;
+            de(s), i = n.ROTATE;
+          }
+          break;
+        case H.PAN:
+          if (s.ctrlKey || s.metaKey || s.shiftKey) {
+            if (t.enableRotate === !1) return;
+            de(s), i = n.ROTATE;
+          } else {
+            if (t.enablePan === !1) return;
+            pe(s), i = n.PAN;
+          }
+          break;
+        default:
+          i = n.NONE;
+      }
+      i !== n.NONE && t.dispatchEvent(ae);
+    }
+    function Xe(s) {
+      switch (i) {
+        case n.ROTATE:
+          if (t.enableRotate === !1) return;
+          De(s);
+          break;
+        case n.DOLLY:
+          if (t.enableZoom === !1) return;
+          He(s);
+          break;
+        case n.PAN:
+          if (t.enablePan === !1) return;
+          Ke(s);
+          break;
+      }
+    }
+    function ve(s) {
+      t.enabled === !1 || t.enableZoom === !1 || i !== n.NONE || (s.preventDefault(), t.dispatchEvent(ae), Ge(We(s)), t.dispatchEvent(Te));
+    }
+    function We(s) {
+      const h = s.deltaMode, m = {
+        clientX: s.clientX,
+        clientY: s.clientY,
+        deltaY: s.deltaY
+      };
+      switch (h) {
+        case 1:
+          m.deltaY *= 16;
+          break;
+        case 2:
+          m.deltaY *= 100;
+          break;
+      }
+      return s.ctrlKey && !J && (m.deltaY *= 10), m;
+    }
+    function qe(s) {
+      s.key === "Control" && (J = !0, document.addEventListener("keyup", Me, { passive: !0, capture: !0 }));
+    }
+    function Me(s) {
+      s.key === "Control" && (J = !1, document.removeEventListener("keyup", Me, { passive: !0, capture: !0 }));
+    }
+    function ie(s) {
+      t.enabled === !1 || t.enablePan === !1 || $e(s);
+    }
+    function Ze(s) {
+      switch (we(s), w.length) {
+        case 1:
+          switch (t.touches.ONE) {
+            case K.ROTATE:
+              if (t.enableRotate === !1) return;
+              ge(s), i = n.TOUCH_ROTATE;
+              break;
+            case K.PAN:
+              if (t.enablePan === !1) return;
+              ue(s), i = n.TOUCH_PAN;
+              break;
+            default:
+              i = n.NONE;
+          }
+          break;
+        case 2:
+          switch (t.touches.TWO) {
+            case K.DOLLY_PAN:
+              if (t.enableZoom === !1 && t.enablePan === !1) return;
+              Ye(s), i = n.TOUCH_DOLLY_PAN;
+              break;
+            case K.DOLLY_ROTATE:
+              if (t.enableZoom === !1 && t.enableRotate === !1) return;
+              Be(s), i = n.TOUCH_DOLLY_ROTATE;
+              break;
+            default:
+              i = n.NONE;
+          }
+          break;
+        default:
+          i = n.NONE;
+      }
+      i !== n.NONE && t.dispatchEvent(ae);
+    }
+    function Qe(s) {
+      switch (we(s), i) {
+        case n.TOUCH_ROTATE:
+          if (t.enableRotate === !1) return;
+          fe(s), t.update();
+          break;
+        case n.TOUCH_PAN:
+          if (t.enablePan === !1) return;
+          ye(s), t.update();
+          break;
+        case n.TOUCH_DOLLY_PAN:
+          if (t.enableZoom === !1 && t.enablePan === !1) return;
+          _e(s), t.update();
+          break;
+        case n.TOUCH_DOLLY_ROTATE:
+          if (t.enableZoom === !1 && t.enableRotate === !1) return;
+          Ue(s), t.update();
+          break;
+        default:
+          i = n.NONE;
+      }
+    }
+    function Ee(s) {
+      t.enabled !== !1 && s.preventDefault();
+    }
+    function Je(s) {
+      w.push(s.pointerId);
+    }
+    function et(s) {
+      delete V[s.pointerId];
+      for (let h = 0; h < w.length; h++)
+        if (w[h] == s.pointerId) {
+          w.splice(h, 1);
+          return;
+        }
+    }
+    function we(s) {
+      let h = V[s.pointerId];
+      h === void 0 && (h = new S(), V[s.pointerId] = h), h.set(s.pageX, s.pageY);
+    }
+    function D(s) {
+      const h = s.pointerId === w[0] ? w[1] : w[0];
+      return V[h];
+    }
+    t.domElement.addEventListener("contextmenu", Ee), t.domElement.addEventListener("pointerdown", be), t.domElement.addEventListener("pointercancel", $), t.domElement.addEventListener("wheel", ve, { passive: !1 }), document.addEventListener("keydown", qe, { passive: !0, capture: !0 }), this.update();
+  }
+}
+class ut {
+  constructor(e, o) {
+    r(this, "scene");
+    r(this, "camera");
+    r(this, "renderer");
+    r(this, "controls");
+    r(this, "container");
+    r(this, "resizeHandler");
+    this.container = e, this.scene = new p.Scene(), this.scene.background = new p.Color(
+      o.backgroundColor ?? 657930
+    );
+    const { width: t, height: n } = Se(e), i = o.cameraFov ?? 75;
+    this.camera = new p.PerspectiveCamera(i, t / n, 0.1, 2e3);
+    const a = o.cameraPosition ?? { x: 0, y: 0, z: 80 };
+    this.camera.position.set(a.x, a.y, a.z), this.renderer = new p.WebGLRenderer({
+      antialias: !0,
+      alpha: !0,
+      powerPreference: "high-performance"
+    }), this.renderer.setSize(t, n), this.renderer.setPixelRatio(Math.min(window.devicePixelRatio, 2)), this.renderer.toneMapping = p.ACESFilmicToneMapping, this.renderer.toneMappingExposure = 1, this.renderer.shadowMap.enabled = !0, this.renderer.shadowMap.type = p.PCFSoftShadowMap, e.appendChild(this.renderer.domElement), this.controls = new gt(this.camera, this.renderer.domElement), this.controls.enableDamping = !0, this.controls.dampingFactor = 0.05, this.controls.rotateSpeed = 0.8, this.controls.zoomSpeed = 1.2, this.controls.minDistance = 10, this.controls.maxDistance = 500, this.setupLighting(), this.resizeHandler = this.onWindowResize.bind(this), window.addEventListener("resize", this.resizeHandler);
+  }
+  /**
+   * Sets up scene lighting for gradient glass on dark background
+   */
+  setupLighting() {
+    const e = new p.AmbientLight(16777215, 0.4);
+    this.scene.add(e);
+    const o = new p.DirectionalLight(16777215, 0.9);
+    o.position.set(50, 60, 40), o.castShadow = !0, o.shadow.mapSize.width = 1024, o.shadow.mapSize.height = 1024, this.scene.add(o);
+    const t = new p.DirectionalLight(16773344, 0.4);
+    t.position.set(-50, 30, -40), this.scene.add(t);
+    const n = new p.DirectionalLight(16777215, 0.3);
+    n.position.set(0, -30, -50), this.scene.add(n);
+    const i = new p.PointLight(16750950, 0.5, 150);
+    i.position.set(40, 20, 40), this.scene.add(i);
+    const a = new p.PointLight(16764057, 0.4, 150);
+    a.position.set(-40, -20, 40), this.scene.add(a);
+    const l = new p.PointLight(6724095, 0.2, 100);
+    l.position.set(0, 40, -40), this.scene.add(l);
+  }
+  /**
+   * Handle window resize
+   */
+  onWindowResize() {
+    const { width: e, height: o } = Se(this.container);
+    this.camera.aspect = e / o, this.camera.updateProjectionMatrix(), this.renderer.setSize(e, o);
+  }
+  /**
+   * Adds an object to the scene
+   */
+  add(e) {
+    this.scene.add(e);
+  }
+  /**
+   * Removes an object from the scene
+   */
+  remove(e) {
+    this.scene.remove(e);
+  }
+  /**
+   * Renders the scene
+   */
+  render() {
+    this.controls.update(), this.renderer.render(this.scene, this.camera);
+  }
+  /**
+   * Gets the camera position
+   */
+  getCameraPosition() {
+    return {
+      x: this.camera.position.x,
+      y: this.camera.position.y,
+      z: this.camera.position.z
+    };
+  }
+  /**
+   * Gets the camera's forward direction
+   */
+  getCameraDirection() {
+    const e = new p.Vector3();
+    return this.camera.getWorldDirection(e), e;
+  }
+  /**
+   * Dispose all resources
+   */
+  dispose() {
+    for (window.removeEventListener("resize", this.resizeHandler), this.controls.dispose(), this.renderer.dispose(), this.renderer.domElement.parentNode && this.renderer.domElement.parentNode.removeChild(this.renderer.domElement); this.scene.children.length > 0; ) {
+      const e = this.scene.children[0];
+      this.scene.remove(e);
+    }
+  }
+}
+class mt {
+  constructor(e, o) {
+    r(this, "sceneManager");
+    r(this, "nodeFactory");
+    r(this, "nodes", /* @__PURE__ */ new Map());
+    r(this, "nodeObjects", /* @__PURE__ */ new Map());
+    this.sceneManager = e, this.nodeFactory = o;
+  }
+  /**
+   * Checks if a node exists
+   */
+  hasNode(e) {
+    return this.nodes.has(e);
+  }
+  /**
+   * Adds a node to the graph
+   * @returns true if added, false if node already exists or invalid
+   */
+  addNode(e, o = 0) {
+    if (!Ie(e))
+      return !1;
+    if (this.nodes.has(e.id))
+      return console.warn(`[ForceGraph3D] Node with id "${e.id}" already exists`), !1;
+    const t = e.position ?? {
+      x: (Math.random() - 0.5) * 50,
+      y: (Math.random() - 0.5) * 50,
+      z: (Math.random() - 0.5) * 50
+    }, n = {
+      ...e,
+      position: t,
+      velocity: { x: 0, y: 0, z: 0 },
+      mass: 1
+    }, i = this.nodeFactory.createNode(
+      { ...e, position: t },
+      o
+    );
+    return this.sceneManager.add(i.group), this.nodes.set(e.id, n), this.nodeObjects.set(e.id, i), !0;
+  }
+  /**
+   * Removes a node from the graph
+   * @returns true if removed, false if not found
+   */
+  removeNode(e) {
+    const o = this.nodes.get(e), t = this.nodeObjects.get(e);
+    return !o || !t ? !1 : (this.sceneManager.remove(t.group), this.nodeFactory.disposeNode(t), this.nodes.delete(e), this.nodeObjects.delete(e), !0);
+  }
+  /**
+   * Updates a node's properties
+   */
+  updateNode(e, o) {
+    const t = this.nodes.get(e), n = this.nodeObjects.get(e);
+    return !t || !n ? (console.warn(`[ForceGraph3D] Node "${e}" not found`), !1) : (o.label !== void 0 && (t.label = o.label, this.nodeFactory.updateNodeLabel(n, o.label)), o.color !== void 0 && (t.color = o.color, this.nodeFactory.updateNodeColor(n, o.color)), Object.keys(o).forEach((i) => {
+      i !== "id" && i !== "label" && i !== "color" && i !== "position" && (t[i] = o[i]);
+    }), !0);
+  }
+  /**
+   * Updates a node's position (called by physics engine)
+   */
+  updateNodePosition(e, o) {
+    const t = this.nodes.get(e), n = this.nodeObjects.get(e);
+    t && n && (t.position = o, n.group.position.set(o.x, o.y, o.z));
+  }
+  /**
+   * Updates a node's LOD level
+   */
+  updateNodeLOD(e, o) {
+    const t = this.nodeObjects.get(e);
+    t && this.nodeFactory.updateNodeLOD(t, o);
+  }
+  /**
+   * Gets a node by ID
+   */
+  getNode(e) {
+    return this.nodes.get(e);
+  }
+  /**
+   * Gets a node's visual object
+   */
+  getNodeObject(e) {
+    return this.nodeObjects.get(e);
+  }
+  /**
+   * Gets all nodes
+   */
+  getAllNodes() {
+    return this.nodes;
+  }
+  /**
+   * Gets all node objects (for raycasting)
+   */
+  getAllNodeObjects() {
+    const e = [];
+    return this.nodeObjects.forEach((o) => {
+      e.push(o.group);
+    }), e;
+  }
+  /**
+   * Gets all spheres (for raycasting)
+   */
+  getAllSpheres() {
+    const e = [];
+    return this.nodeObjects.forEach((o) => {
+      e.push(o.sphere);
+    }), e;
+  }
+  /**
+   * Gets node count
+   */
+  getNodeCount() {
+    return this.nodes.size;
+  }
+  /**
+   * Clears all nodes
+   */
+  clear() {
+    this.nodes.forEach((e, o) => {
+      this.removeNode(o);
+    });
+  }
+  /**
+   * Dispose resources
+   */
+  dispose() {
+    this.clear();
+  }
+}
+class ft {
+  constructor(e, o, t) {
+    r(this, "sceneManager");
+    r(this, "nodeManager");
+    r(this, "edgeFactory");
+    r(this, "edges", []);
+    r(this, "edgeObjects", []);
+    r(this, "edgeKeySet", /* @__PURE__ */ new Set());
+    r(this, "highlightedEdgeKey", null);
+    this.sceneManager = e, this.nodeManager = o, this.edgeFactory = t;
+  }
+  /**
+   * Checks if an edge exists
+   */
+  hasEdge(e, o) {
+    const t = I(e, o);
+    return this.edgeKeySet.has(t);
+  }
+  /**
+   * Adds an edge to the graph
+   * @returns true if added, false if edge already exists or nodes don't exist
+   */
+  addEdge(e) {
+    if (!Re(e))
+      return !1;
+    if (!this.nodeManager.hasNode(e.source))
+      return console.warn(`[ForceGraph3D] Source node "${e.source}" does not exist`), !1;
+    if (!this.nodeManager.hasNode(e.target))
+      return console.warn(`[ForceGraph3D] Target node "${e.target}" does not exist`), !1;
+    const o = I(e.source, e.target);
+    if (this.edgeKeySet.has(o))
+      return console.warn(`[ForceGraph3D] Edge "${e.source}" -> "${e.target}" already exists`), !1;
+    const t = this.nodeManager.getNode(e.source), n = this.nodeManager.getNode(e.target), i = this.edgeFactory.createEdge(
+      e,
+      t,
+      n,
+      t.position,
+      n.position
+    );
+    return this.sceneManager.add(i.line), this.edges.push(e), this.edgeObjects.push(i), this.edgeKeySet.add(o), !0;
+  }
+  /**
+   * Removes an edge from the graph
+   * @returns true if removed, false if not found
+   */
+  removeEdge(e, o) {
+    const t = I(e, o);
+    if (!this.edgeKeySet.has(t))
+      return !1;
+    const n = this.edges.findIndex(
+      (a) => I(a.source, a.target) === t
+    );
+    if (n === -1)
+      return !1;
+    const i = this.edgeObjects[n];
+    return this.sceneManager.remove(i.line), this.edgeFactory.disposeEdge(i), this.edges.splice(n, 1), this.edgeObjects.splice(n, 1), this.edgeKeySet.delete(t), this.highlightedEdgeKey === t && (this.highlightedEdgeKey = null), !0;
+  }
+  /**
+   * Highlights an edge
+   */
+  highlightEdge(e, o) {
+    const t = I(e, o);
+    this.highlightedEdgeKey && this.highlightedEdgeKey !== t && this.unhighlightCurrentEdge();
+    const n = this.edges.findIndex(
+      (i) => I(i.source, i.target) === t
+    );
+    n !== -1 && (this.edgeFactory.highlightEdge(this.edgeObjects[n]), this.highlightedEdgeKey = t);
+  }
+  /**
+   * Unhighlights the currently highlighted edge
+   */
+  unhighlightCurrentEdge() {
+    if (!this.highlightedEdgeKey) return;
+    const e = this.edges.findIndex(
+      (o) => I(o.source, o.target) === this.highlightedEdgeKey
+    );
+    e !== -1 && this.edgeFactory.unhighlightEdge(this.edgeObjects[e]), this.highlightedEdgeKey = null;
+  }
+  /**
+   * Removes all edges connected to a node
+   */
+  removeEdgesForNode(e) {
+    const o = [];
+    this.edges.forEach((t) => {
+      (t.source === e || t.target === e) && o.push({ source: t.source, target: t.target });
+    }), o.forEach((t) => {
+      this.removeEdge(t.source, t.target);
+    });
+  }
+  /**
+   * Gets all edges for a node
+   */
+  getEdgesForNode(e) {
+    return this.edges.filter((o) => o.source === e || o.target === e);
+  }
+  /**
+   * Gets neighbor node IDs for a node
+   */
+  getNeighborIds(e) {
+    const o = [];
+    return this.edges.forEach((t) => {
+      t.source === e ? o.push(t.target) : t.target === e && o.push(t.source);
+    }), [...new Set(o)];
+  }
+  /**
+   * Updates all edge positions based on current node positions
+   */
+  updateEdgePositions() {
+    this.edgeObjects.forEach((e, o) => {
+      const t = this.edges[o], n = this.nodeManager.getNode(t.source), i = this.nodeManager.getNode(t.target);
+      n && i && this.edgeFactory.updateEdgePositions(
+        e,
+        n.position,
+        i.position
+      );
+    });
+  }
+  /**
+   * Gets all edges
+   */
+  getAllEdges() {
+    return this.edges;
+  }
+  /**
+   * Gets all edge line objects (for raycasting)
+   */
+  getAllEdgeLines() {
+    return this.edgeObjects.map((e) => e.line);
+  }
+  /**
+   * Gets edge count
+   */
+  getEdgeCount() {
+    return this.edges.length;
+  }
+  /**
+   * Clears all edges
+   */
+  clear() {
+    this.edgeObjects.forEach((e) => {
+      this.sceneManager.remove(e.line), this.edgeFactory.disposeEdge(e);
+    }), this.edges = [], this.edgeObjects = [], this.edgeKeySet.clear(), this.highlightedEdgeKey = null;
+  }
+  /**
+   * Dispose resources
+   */
+  dispose() {
+    this.clear();
+  }
+}
+class Le {
+  constructor(e, o, t = {}) {
+    r(this, "nodes");
+    r(this, "edges");
+    // Physics parameters
+    r(this, "repulsionStrength");
+    r(this, "attractionStrength");
+    r(this, "damping");
+    r(this, "useBarnesHut");
+    r(this, "barnesHutTheta");
+    // Simulation state
+    r(this, "alpha", 1);
+    r(this, "alphaDecay", 0.0228);
+    r(this, "alphaMin", 1e-3);
+    r(this, "alphaTarget", 0);
+    this.nodes = e, this.edges = o, this.repulsionStrength = t.repulsionStrength ?? 100, this.attractionStrength = t.attractionStrength ?? 0.01, this.damping = t.damping ?? 0.9, this.useBarnesHut = t.useBarnesHut ?? !1, this.barnesHutTheta = t.barnesHutTheta ?? 0.5;
+  }
+  /**
+   * Runs one simulation step
+   */
+  simulate() {
+    if (this.alpha < this.alphaMin) return;
+    const e = this.nodes.size;
+    (this.useBarnesHut || e >= 1e3) && e >= 100 ? this.calculateRepulsionBarnesHut() : this.calculateRepulsionBruteForce(), this.calculateAttraction(), this.applyForces(), this.alpha += (this.alphaTarget - this.alpha) * this.alphaDecay;
+  }
+  /**
+   * Brute force repulsion - O(n²)
+   */
+  calculateRepulsionBruteForce() {
+    const e = Array.from(this.nodes.values()), o = e.length;
+    for (let t = 0; t < o; t++) {
+      const n = e[t];
+      for (let i = t + 1; i < o; i++) {
+        const a = e[i], l = a.position.x - n.position.x, d = a.position.y - n.position.y, g = a.position.z - n.position.z;
+        let u = l * l + d * d + g * g;
+        u < 0.01 && (u = 0.01);
+        const x = Math.sqrt(u), v = this.repulsionStrength * this.alpha / u, y = l / x * v, f = d / x * v, M = g / x * v;
+        n.velocity.x -= y / n.mass, n.velocity.y -= f / n.mass, n.velocity.z -= M / n.mass, a.velocity.x += y / a.mass, a.velocity.y += f / a.mass, a.velocity.z += M / a.mass;
+      }
+    }
+  }
+  /**
+   * Barnes-Hut approximation - O(n log n)
+   */
+  calculateRepulsionBarnesHut() {
+    const e = Array.from(this.nodes.values()), o = new yt(e);
+    for (const t of e)
+      this.calculateForceFromOctree(t, o.root);
+  }
+  /**
+   * Recursive force calculation using octree
+   */
+  calculateForceFromOctree(e, o) {
+    if (o.isLeaf) {
+      o.node && o.node.id !== e.id && this.applyRepulsionBetween(e, o.node);
+      return;
+    }
+    if (o.mass === 0) return;
+    const t = o.centerOfMass.x - e.position.x, n = o.centerOfMass.y - e.position.y, i = o.centerOfMass.z - e.position.z, a = Math.sqrt(t * t + n * n + i * i);
+    if (o.size / a < this.barnesHutTheta) {
+      const l = Math.max(a * a, 0.01), d = this.repulsionStrength * this.alpha * o.mass / l;
+      e.velocity.x -= t / a * d / e.mass, e.velocity.y -= n / a * d / e.mass, e.velocity.z -= i / a * d / e.mass;
+    } else
+      for (const l of o.children)
+        l && this.calculateForceFromOctree(e, l);
+  }
+  /**
+   * Apply repulsion between two nodes
+   */
+  applyRepulsionBetween(e, o) {
+    const t = o.position.x - e.position.x, n = o.position.y - e.position.y, i = o.position.z - e.position.z;
+    let a = t * t + n * n + i * i;
+    a < 0.01 && (a = 0.01);
+    const l = Math.sqrt(a), d = this.repulsionStrength * this.alpha / a;
+    e.velocity.x -= t / l * d / e.mass, e.velocity.y -= n / l * d / e.mass, e.velocity.z -= i / l * d / e.mass;
+  }
+  /**
+   * Calculate attraction forces along edges
+   */
+  calculateAttraction() {
+    for (const e of this.edges) {
+      const o = this.nodes.get(e.source), t = this.nodes.get(e.target);
+      if (!o || !t) continue;
+      const n = t.position.x - o.position.x, i = t.position.y - o.position.y, a = t.position.z - o.position.z, l = Math.sqrt(n * n + i * i + a * a);
+      if (l < 0.01) continue;
+      const g = (l - 15) * this.attractionStrength * this.alpha, u = n / l * g, x = i / l * g, v = a / l * g;
+      o.velocity.x += u / o.mass, o.velocity.y += x / o.mass, o.velocity.z += v / o.mass, t.velocity.x -= u / t.mass, t.velocity.y -= x / t.mass, t.velocity.z -= v / t.mass;
+    }
+  }
+  /**
+   * Apply velocities and damping to positions
+   */
+  applyForces() {
+    for (const e of this.nodes.values())
+      e.velocity.x *= this.damping, e.velocity.y *= this.damping, e.velocity.z *= this.damping, e.position.x += e.velocity.x, e.position.y += e.velocity.y, e.position.z += e.velocity.z;
+  }
+  /**
+   * Updates the edges reference
+   */
+  setEdges(e) {
+    this.edges = e;
+  }
+  /**
+   * Resets the simulation (restarts with full energy)
+   */
+  restart() {
+    this.alpha = 1;
+  }
+  /**
+   * Gets the current alpha value
+   */
+  getAlpha() {
+    return this.alpha;
+  }
+  /**
+   * Sets physics parameters
+   */
+  setPhysicsParams(e) {
+    e.repulsionStrength !== void 0 && (this.repulsionStrength = e.repulsionStrength), e.attractionStrength !== void 0 && (this.attractionStrength = e.attractionStrength), e.damping !== void 0 && (this.damping = e.damping);
+  }
+}
+class yt {
+  constructor(e) {
+    r(this, "root");
+    const o = this.calculateBounds(e);
+    this.root = this.buildTree(e, o);
+  }
+  calculateBounds(e) {
+    if (e.length === 0)
+      return {
+        min: { x: -100, y: -100, z: -100 },
+        max: { x: 100, y: 100, z: 100 }
+      };
+    const o = { x: 1 / 0, y: 1 / 0, z: 1 / 0 }, t = { x: -1 / 0, y: -1 / 0, z: -1 / 0 };
+    for (const i of e)
+      o.x = Math.min(o.x, i.position.x), o.y = Math.min(o.y, i.position.y), o.z = Math.min(o.z, i.position.z), t.x = Math.max(t.x, i.position.x), t.y = Math.max(t.y, i.position.y), t.z = Math.max(t.z, i.position.z);
+    const n = 10;
+    return o.x -= n, o.y -= n, o.z -= n, t.x += n, t.y += n, t.z += n, { min: o, max: t };
+  }
+  buildTree(e, o, t = 0) {
+    const n = Math.max(
+      o.max.x - o.min.x,
+      o.max.y - o.min.y,
+      o.max.z - o.min.z
+    );
+    if (e.length === 0)
+      return {
+        bounds: o,
+        size: n,
+        centerOfMass: { x: 0, y: 0, z: 0 },
+        mass: 0,
+        isLeaf: !0,
+        node: null,
+        children: []
+      };
+    if (e.length === 1 || t > 20) {
+      let y = 0;
+      const f = { x: 0, y: 0, z: 0 };
+      for (const M of e)
+        y += M.mass, f.x += M.position.x * M.mass, f.y += M.position.y * M.mass, f.z += M.position.z * M.mass;
+      return y > 0 && (f.x /= y, f.y /= y, f.z /= y), {
+        bounds: o,
+        size: n,
+        centerOfMass: f,
+        mass: y,
+        isLeaf: !0,
+        node: e[0],
+        children: []
+      };
+    }
+    const i = (o.min.x + o.max.x) / 2, a = (o.min.y + o.max.y) / 2, l = (o.min.z + o.max.z) / 2, d = [[], [], [], [], [], [], [], []];
+    for (const y of e) {
+      const f = (y.position.x >= i ? 1 : 0) + (y.position.y >= a ? 2 : 0) + (y.position.z >= l ? 4 : 0);
+      d[f].push(y);
+    }
+    const g = [
+      { min: { x: o.min.x, y: o.min.y, z: o.min.z }, max: { x: i, y: a, z: l } },
+      { min: { x: i, y: o.min.y, z: o.min.z }, max: { x: o.max.x, y: a, z: l } },
+      { min: { x: o.min.x, y: a, z: o.min.z }, max: { x: i, y: o.max.y, z: l } },
+      { min: { x: i, y: a, z: o.min.z }, max: { x: o.max.x, y: o.max.y, z: l } },
+      { min: { x: o.min.x, y: o.min.y, z: l }, max: { x: i, y: a, z: o.max.z } },
+      { min: { x: i, y: o.min.y, z: l }, max: { x: o.max.x, y: a, z: o.max.z } },
+      { min: { x: o.min.x, y: a, z: l }, max: { x: i, y: o.max.y, z: o.max.z } },
+      { min: { x: i, y: a, z: l }, max: { x: o.max.x, y: o.max.y, z: o.max.z } }
+    ], u = [];
+    let x = 0;
+    const v = { x: 0, y: 0, z: 0 };
+    for (let y = 0; y < 8; y++)
+      if (d[y].length > 0) {
+        const f = this.buildTree(d[y], g[y], t + 1);
+        u.push(f), x += f.mass, v.x += f.centerOfMass.x * f.mass, v.y += f.centerOfMass.y * f.mass, v.z += f.centerOfMass.z * f.mass;
+      } else
+        u.push(null);
+    return x > 0 && (v.x /= x, v.y /= x, v.z /= x), {
+      bounds: o,
+      size: n,
+      centerOfMass: v,
+      mass: x,
+      isLeaf: !1,
+      node: null,
+      children: u
+    };
+  }
+}
+class xt {
+  constructor(e, o, t, n = 60) {
+    r(this, "sceneManager");
+    r(this, "animationId", null);
+    r(this, "isRunning", !1);
+    r(this, "frameInterval");
+    r(this, "lastFrameTime", 0);
+    r(this, "onSimulate");
+    r(this, "onRender");
+    // Performance monitoring
+    r(this, "frameCount", 0);
+    r(this, "fpsStartTime", 0);
+    r(this, "currentFPS", 60);
+    /**
+     * Main animation loop
+     */
+    r(this, "animate", () => {
+      if (!this.isRunning) return;
+      this.animationId = requestAnimationFrame(this.animate);
+      const e = performance.now(), o = e - this.lastFrameTime;
+      if (o < this.frameInterval)
+        return;
+      this.lastFrameTime = e - o % this.frameInterval, this.frameCount++;
+      const t = e - this.fpsStartTime;
+      t >= 1e3 && (this.currentFPS = this.frameCount / (t / 1e3), this.frameCount = 0, this.fpsStartTime = e), this.onSimulate(), this.onRender(), this.sceneManager.render();
+    });
+    this.sceneManager = e, this.onSimulate = o, this.onRender = t, this.frameInterval = 1e3 / n;
+  }
+  /**
+   * Starts the animation loop
+   */
+  start() {
+    this.isRunning || (this.isRunning = !0, this.lastFrameTime = performance.now(), this.fpsStartTime = performance.now(), this.frameCount = 0, this.animate());
+  }
+  /**
+   * Stops the animation loop
+   */
+  stop() {
+    this.isRunning = !1, this.animationId !== null && (cancelAnimationFrame(this.animationId), this.animationId = null);
+  }
+  /**
+   * Gets the current FPS
+   */
+  getFPS() {
+    return Math.round(this.currentFPS);
+  }
+  /**
+   * Sets target FPS
+   */
+  setTargetFPS(e) {
+    this.frameInterval = 1e3 / e;
+  }
+  /**
+   * Checks if animation is running
+   */
+  isAnimating() {
+    return this.isRunning;
+  }
+  /**
+   * Dispose
+   */
+  dispose() {
+    this.stop();
+  }
+}
+class bt {
+  constructor() {
+    r(this, "envMap", null);
+    r(this, "materialCache", /* @__PURE__ */ new Map());
+    // Color palette - white and tangerine
+    r(this, "COLORS", [
+      16777215,
+      // White
+      16750950,
+      // Tangerine/orange
+      16764057,
+      // Light peach
+      16772829,
+      // Cream
+      16746564
+      // Darker tangerine
+    ]);
+    this.createEnvironmentMap();
+  }
+  /**
+   * Creates environment map for glass reflections on dark background
+   */
+  createEnvironmentMap() {
+    const o = [], t = [
+      // Subtle colored gradients for interesting reflections
+      { colors: ["#1a1a2e", "#16213e", "#0f3460"] },
+      // +x
+      { colors: ["#2d1f1f", "#1a1a1a", "#0f0f0f"] },
+      // -x
+      { colors: ["#1f2d2d", "#1a1a2e", "#101020"] },
+      // +y
+      { colors: ["#0a0a0a", "#050505", "#000000"] },
+      // -y
+      { colors: ["#1a1a2e", "#0f1a2a", "#0a0a15"] },
+      // +z
+      { colors: ["#2d1a1a", "#1a0a0a", "#0f0505"] }
+      // -z
+    ];
+    for (const n of t) {
+      const i = document.createElement("canvas");
+      i.width = 256, i.height = 256;
+      const a = i.getContext("2d"), l = a.createRadialGradient(
+        256 / 2,
+        256 / 2,
+        0,
+        256 / 2,
+        256 / 2,
+        256 * 0.8
+      );
+      l.addColorStop(0, n.colors[0]), l.addColorStop(0.5, n.colors[1]), l.addColorStop(1, n.colors[2]), a.fillStyle = l, a.fillRect(0, 0, 256, 256);
+      const d = a.getImageData(0, 0, 256, 256);
+      for (let g = 0; g < d.data.length; g += 4) {
+        const u = (Math.random() - 0.5) * 5;
+        d.data[g] = Math.min(255, Math.max(0, d.data[g] + u)), d.data[g + 1] = Math.min(255, Math.max(0, d.data[g + 1] + u)), d.data[g + 2] = Math.min(255, Math.max(0, d.data[g + 2] + u));
+      }
+      a.putImageData(d, 0, 0), o.push(i);
+    }
+    this.envMap = new p.CubeTexture(o.map((n) => {
+      const i = new Image();
+      return i.src = n.toDataURL(), i;
+    })), this.envMap.needsUpdate = !0;
+  }
+  /**
+   * Gets a random color from the palette
+   */
+  getRandomColor() {
+    return this.COLORS[Math.floor(Math.random() * this.COLORS.length)];
+  }
+  /**
+   * Creates a gradient glass material with white glow in center
+   * All balls use the same tangerine color with white center glow
+   */
+  createGlassMaterial(e) {
+    const t = "glass-single";
+    if (this.materialCache.has(t))
+      return this.materialCache.get(t).clone();
+    const n = new p.Color(16750950), i = new p.ShaderMaterial({
+      uniforms: {
+        uColor: { value: n },
+        uEnvMap: { value: this.envMap },
+        uGlowColor: { value: new p.Color(16777215) },
+        uGlowIntensity: { value: 0.8 },
+        uReflectivity: { value: 0.4 },
+        uFresnelPower: { value: 2.5 }
+      },
+      vertexShader: `
+                varying vec3 vNormal;
+                varying vec3 vViewPosition;
+                varying vec3 vWorldPosition;
+                varying vec2 vUv;
+                
+                void main() {
+                    vNormal = normalize(normalMatrix * normal);
+                    vec4 mvPosition = modelViewMatrix * vec4(position, 1.0);
+                    vViewPosition = -mvPosition.xyz;
+                    vWorldPosition = (modelMatrix * vec4(position, 1.0)).xyz;
+                    vUv = uv;
+                    gl_Position = projectionMatrix * mvPosition;
+                }
+            `,
+      fragmentShader: `
+                uniform vec3 uColor;
+                uniform vec3 uGlowColor;
+                uniform samplerCube uEnvMap;
+                uniform float uGlowIntensity;
+                uniform float uReflectivity;
+                uniform float uFresnelPower;
+                
+                varying vec3 vNormal;
+                varying vec3 vViewPosition;
+                varying vec3 vWorldPosition;
+                varying vec2 vUv;
+                
+                void main() {
+                    vec3 viewDir = normalize(vViewPosition);
+                    vec3 normal = normalize(vNormal);
+                    
+                    // Fresnel effect - edges are more visible
+                    float fresnel = pow(1.0 - abs(dot(viewDir, normal)), uFresnelPower);
+                    
+                    // Center glow: bright white in center, fading to base color at edges
+                    // Center is where normal faces camera directly (low fresnel)
+                    float centerGlow = (1.0 - fresnel) * uGlowIntensity;
+                    
+                    // Environment reflection on edges
+                    vec3 reflectDir = reflect(-viewDir, normal);
+                    vec3 envColor = textureCube(uEnvMap, reflectDir).rgb;
+                    
+                    // Base color with reflection at edges
+                    vec3 baseColor = uColor;
+                    vec3 edgeColor = mix(baseColor, envColor, uReflectivity * fresnel);
+                    
+                    // Blend: white glow in center, colored edges
+                    vec3 finalColor = mix(edgeColor, uGlowColor, centerGlow);
+                    
+                    // Add rim highlight for glass effect
+                    float rimLight = pow(fresnel, 4.0) * 0.4;
+                    finalColor += vec3(rimLight) * uColor;
+                    
+                    // Opacity: fully opaque with glow effect visible
+                    float opacity = 0.85 + fresnel * 0.15;
+                    
+                    gl_FragColor = vec4(finalColor, opacity);
+                }
+            `,
+      transparent: !0,
+      side: p.FrontSide,
+      depthWrite: !0,
+      blending: p.NormalBlending
+    });
+    return this.materialCache.set(t, i), i.clone();
+  }
+  /**
+   * Creates material for edges (light color for dark background)
+   */
+  createEdgeMaterial(e = 6710886, o = 0.4) {
+    return new p.LineBasicMaterial({
+      color: e,
+      transparent: !0,
+      opacity: o,
+      linewidth: 1
+    });
+  }
+  /**
+   * Creates highlighted edge material
+   */
+  createHighlightedEdgeMaterial() {
+    return new p.LineBasicMaterial({
+      color: 16750950,
+      // Tangerine highlight
+      transparent: !1,
+      opacity: 1,
+      linewidth: 2
+    });
+  }
+  /**
+   * Creates a sprite material for labels (light text for dark background)
+   */
+  createLabelMaterial(e, o = 24) {
+    const t = document.createElement("canvas"), n = t.getContext("2d");
+    n.font = `600 ${o}px Inter, -apple-system, sans-serif`;
+    const a = n.measureText(e).width;
+    t.width = Math.max(128, a + 24), t.height = o + 20, n.clearRect(0, 0, t.width, t.height), n.font = `600 ${o}px Inter, -apple-system, sans-serif`, n.textAlign = "center", n.textBaseline = "middle", n.shadowColor = "rgba(0, 0, 0, 0.8)", n.shadowBlur = 4, n.shadowOffsetX = 1, n.shadowOffsetY = 1, n.fillStyle = "rgba(255, 255, 255, 0.95)", n.fillText(e, t.width / 2, t.height / 2);
+    const l = new p.CanvasTexture(t);
+    return l.needsUpdate = !0, new p.SpriteMaterial({
+      map: l,
+      transparent: !0,
+      depthTest: !1,
+      depthWrite: !1
+    });
+  }
+  /**
+   * Gets environment map
+   */
+  getEnvMap() {
+    return this.envMap;
+  }
+  /**
+   * Dispose all cached materials
+   */
+  dispose() {
+    this.materialCache.forEach((e) => e.dispose()), this.materialCache.clear(), this.envMap && this.envMap.dispose();
+  }
+}
+class vt {
+  constructor(e, o = 2, t = [32, 16, 8]) {
+    r(this, "materialFactory");
+    r(this, "geometryCache", /* @__PURE__ */ new Map());
+    r(this, "nodeRadius");
+    r(this, "lodSegments");
+    this.materialFactory = e, this.nodeRadius = o, this.lodSegments = t, this.initGeometryCache();
+  }
+  /**
+   * Pre-create geometries for each LOD level
+   */
+  initGeometryCache() {
+    this.lodSegments.forEach((e, o) => {
+      const t = `lod-${o}`;
+      this.geometryCache.set(
+        t,
+        new p.SphereGeometry(this.nodeRadius, e, e)
+      );
+    });
+  }
+  /**
+   * Gets geometry for the specified LOD level
+   */
+  getGeometry(e) {
+    const o = `lod-${e}`;
+    return this.geometryCache.has(o) ? this.geometryCache.get(o) : this.geometryCache.get("lod-0");
+  }
+  /**
+   * Creates a node visual (glass ball + label)
+   */
+  createNode(e, o = 0) {
+    const t = new p.Group();
+    t.name = `node-${e.id}`, t.userData = { nodeId: e.id, nodeData: e };
+    const n = this.getGeometry(o), i = this.materialFactory.createGlassMaterial(
+      e.color ?? 4886754
+    ), a = new p.Mesh(n, i);
+    a.castShadow = !0, a.receiveShadow = !0, t.add(a);
+    const l = this.materialFactory.createLabelMaterial(e.label), d = new p.Sprite(l);
+    return d.position.y = this.nodeRadius + 1.5, d.scale.set(4, 1, 1), t.add(d), e.position && t.position.set(
+      e.position.x,
+      e.position.y,
+      e.position.z
+    ), {
+      group: t,
+      sphere: a,
+      label: d,
+      lodLevel: o
+    };
+  }
+  /**
+   * Updates the LOD level of a node
+   */
+  updateNodeLOD(e, o) {
+    if (e.lodLevel === o) return;
+    const t = this.getGeometry(o);
+    e.sphere.geometry = t, e.lodLevel = o;
+  }
+  /**
+   * Updates the color of a node
+   */
+  updateNodeColor(e, o) {
+    e.sphere.material instanceof p.Material && e.sphere.material.dispose(), e.sphere.material = this.materialFactory.createGlassMaterial(o);
+  }
+  /**
+   * Updates the label of a node
+   */
+  updateNodeLabel(e, o) {
+    e.label.material instanceof p.SpriteMaterial && (e.label.material.map && e.label.material.map.dispose(), e.label.material.dispose()), e.label.material = this.materialFactory.createLabelMaterial(o);
+  }
+  /**
+   * Disposes a node's resources
+   */
+  disposeNode(e) {
+    e.sphere.material instanceof p.Material && e.sphere.material.dispose(), e.label.material instanceof p.SpriteMaterial && (e.label.material.map && e.label.material.map.dispose(), e.label.material.dispose());
+  }
+  /**
+   * Dispose factory resources
+   */
+  dispose() {
+    this.geometryCache.forEach((e) => e.dispose()), this.geometryCache.clear();
+  }
+}
+class Mt {
+  constructor(e, o = 10066329, t = 0.5) {
+    r(this, "materialFactory");
+    r(this, "edgeColor");
+    r(this, "edgeOpacity");
+    r(this, "defaultMaterial", null);
+    r(this, "highlightMaterial", null);
+    this.materialFactory = e, this.edgeColor = o, this.edgeOpacity = t;
+  }
+  /**
+   * Gets or creates the default edge material
+   */
+  getDefaultMaterial() {
+    return this.defaultMaterial || (this.defaultMaterial = this.materialFactory.createEdgeMaterial(
+      this.edgeColor,
+      this.edgeOpacity
+    )), this.defaultMaterial;
+  }
+  /**
+   * Gets or creates the highlight material
+   */
+  getHighlightMaterial() {
+    return this.highlightMaterial || (this.highlightMaterial = this.materialFactory.createHighlightedEdgeMaterial()), this.highlightMaterial;
+  }
+  /**
+   * Creates an edge line between two positions
+   */
+  createEdge(e, o, t, n, i) {
+    const a = new p.BufferGeometry(), l = new Float32Array([
+      n.x,
+      n.y,
+      n.z,
+      i.x,
+      i.y,
+      i.z
+    ]);
+    a.setAttribute("position", new p.BufferAttribute(l, 3));
+    const d = this.getDefaultMaterial().clone(), g = new p.Line(a, d);
+    return g.name = `edge-${e.source}-${e.target}`, g.userData = {
+      source: e.source,
+      target: e.target,
+      edge: e,
+      sourceNode: o,
+      targetNode: t
+    }, g.frustumCulled = !0, {
+      line: g,
+      source: e.source,
+      target: e.target
+    };
+  }
+  /**
+   * Highlights an edge
+   */
+  highlightEdge(e) {
+    e.line.material instanceof p.Material && e.line.material.dispose(), e.line.material = this.getHighlightMaterial().clone();
+  }
+  /**
+   * Resets an edge to default appearance
+   */
+  unhighlightEdge(e) {
+    e.line.material instanceof p.Material && e.line.material.dispose(), e.line.material = this.getDefaultMaterial().clone();
+  }
+  /**
+   * Updates an edge's positions
+   */
+  updateEdgePositions(e, o, t) {
+    const n = e.line.geometry.attributes.position, i = n.array;
+    i[0] = o.x, i[1] = o.y, i[2] = o.z, i[3] = t.x, i[4] = t.y, i[5] = t.z, n.needsUpdate = !0, e.line.geometry.computeBoundingSphere();
+  }
+  /**
+   * Disposes an edge's resources
+   */
+  disposeEdge(e) {
+    e.line.geometry.dispose(), e.line.material instanceof p.Material && e.line.material.dispose();
+  }
+  /**
+   * Dispose factory resources
+   */
+  dispose() {
+    this.defaultMaterial && this.defaultMaterial.dispose(), this.highlightMaterial && this.highlightMaterial.dispose();
+  }
+}
+class Et {
+  constructor(e, o = [50, 100, 200], t = !0) {
+    r(this, "camera");
+    r(this, "lodDistances");
+    r(this, "enabled");
+    this.camera = e, this.lodDistances = o, this.enabled = t;
+  }
+  /**
+   * Gets the LOD level for a position based on distance from camera
+   */
+  getLODLevel(e) {
+    if (!this.enabled)
+      return _.HIGH;
+    const o = e.x - this.camera.position.x, t = e.y - this.camera.position.y, n = e.z - this.camera.position.z, i = Math.sqrt(o * o + t * t + n * n);
+    return i < this.lodDistances[0] ? _.HIGH : i < this.lodDistances[1] ? _.MEDIUM : _.LOW;
+  }
+  /**
+   * Checks if a node should be visible based on distance
+   */
+  shouldRenderNode(e, o = 500) {
+    const t = e.x - this.camera.position.x, n = e.y - this.camera.position.y, i = e.z - this.camera.position.z;
+    return Math.sqrt(t * t + n * n + i * i) < o;
+  }
+  /**
+   * Sets the LOD distances
+   */
+  setLODDistances(e) {
+    this.lodDistances = e;
+  }
+  /**
+   * Enables/disables LOD
+   */
+  setEnabled(e) {
+    this.enabled = e;
+  }
+}
+class wt {
+  constructor(e, o = !0) {
+    r(this, "camera");
+    r(this, "frustum");
+    r(this, "projScreenMatrix");
+    r(this, "enabled");
+    this.camera = e, this.frustum = new p.Frustum(), this.projScreenMatrix = new p.Matrix4(), this.enabled = o;
+  }
+  /**
+   * Updates the frustum from the camera
+   */
+  update() {
+    this.projScreenMatrix.multiplyMatrices(
+      this.camera.projectionMatrix,
+      this.camera.matrixWorldInverse
+    ), this.frustum.setFromProjectionMatrix(this.projScreenMatrix);
+  }
+  /**
+   * Checks if a point is inside the frustum
+   */
+  isPointVisible(e) {
+    if (!this.enabled) return !0;
+    const o = new p.Vector3(e.x, e.y, e.z);
+    return this.frustum.containsPoint(o);
+  }
+  /**
+   * Checks if a sphere is inside or intersects the frustum
+   */
+  isSphereVisible(e, o) {
+    if (!this.enabled) return !0;
+    const t = new p.Sphere(
+      new p.Vector3(e.x, e.y, e.z),
+      o
+    );
+    return this.frustum.intersectsSphere(t);
+  }
+  /**
+   * Checks if a line segment is potentially visible
+   */
+  isLineVisible(e, o) {
+    if (!this.enabled) return !0;
+    const t = new p.Vector3(e.x, e.y, e.z), n = new p.Vector3(o.x, o.y, o.z);
+    if (this.frustum.containsPoint(t) || this.frustum.containsPoint(n))
+      return !0;
+    const i = new p.Vector3(
+      (e.x + o.x) / 2,
+      (e.y + o.y) / 2,
+      (e.z + o.z) / 2
+    ), a = i.distanceTo(t), l = new p.Sphere(i, a);
+    return this.frustum.intersectsSphere(l);
+  }
+  /**
+   * Enables/disables frustum culling
+   */
+  setEnabled(e) {
+    this.enabled = e;
+  }
+}
+class Ct {
+  constructor(e, o) {
+    r(this, "sceneManager");
+    r(this, "raycaster");
+    r(this, "mouse");
+    r(this, "container");
+    r(this, "onNodeClick", null);
+    r(this, "onNodeHover", null);
+    r(this, "onEdgeHover", null);
+    r(this, "hoveredNodeId", null);
+    r(this, "hoveredEdgeKey", null);
+    r(this, "nodeObjects", []);
+    r(this, "edgeObjects", []);
+    this.sceneManager = e, this.container = o, this.raycaster = new p.Raycaster(), this.raycaster.params.Line = { threshold: 0.5 }, this.mouse = new p.Vector2(), this.handleClick = this.handleClick.bind(this), this.handleMouseMove = this.handleMouseMove.bind(this), o.addEventListener("click", this.handleClick), o.addEventListener("mousemove", this.handleMouseMove);
+  }
+  /**
+   * Updates the list of node objects to raycast against
+   */
+  setNodeObjects(e) {
+    this.nodeObjects = e;
+  }
+  /**
+   * Updates the list of edge objects to raycast against
+   */
+  setEdgeObjects(e) {
+    this.edgeObjects = e;
+  }
+  /**
+   * Sets the click callback
+   */
+  setClickCallback(e) {
+    this.onNodeClick = e;
+  }
+  /**
+   * Sets the node hover callback
+   */
+  setHoverCallback(e) {
+    this.onNodeHover = e;
+  }
+  /**
+   * Sets the edge hover callback
+   */
+  setEdgeHoverCallback(e) {
+    this.onEdgeHover = e;
+  }
+  /**
+   * Handles click events
+   */
+  handleClick(e) {
+    const o = this.getIntersectedNode(e);
+    o && this.onNodeClick && this.onNodeClick(o);
+  }
+  /**
+   * Handles mouse move events for hover detection
+   */
+  handleMouseMove(e) {
+    const o = this.getIntersectedNode(e), t = (o == null ? void 0 : o.id) ?? null;
+    if (t !== this.hoveredNodeId && (this.hoveredNodeId = t, this.onNodeHover && this.onNodeHover(o)), o) {
+      this.hoveredEdgeKey !== null && this.onEdgeHover && (this.hoveredEdgeKey = null, this.onEdgeHover(null)), this.container.style.cursor = "pointer";
+      return;
+    }
+    const n = this.getIntersectedEdge(e), i = n ? `${n.edge.source}-${n.edge.target}` : null;
+    i !== this.hoveredEdgeKey && (this.hoveredEdgeKey = i, this.onEdgeHover && this.onEdgeHover(n)), this.container.style.cursor = n ? "pointer" : "default";
+  }
+  /**
+   * Gets the intersected node from a mouse event
+   */
+  getIntersectedNode(e) {
+    var n;
+    const o = this.container.getBoundingClientRect();
+    this.mouse.x = (e.clientX - o.left) / o.width * 2 - 1, this.mouse.y = -((e.clientY - o.top) / o.height) * 2 + 1, this.raycaster.setFromCamera(this.mouse, this.sceneManager.camera);
+    const t = this.raycaster.intersectObjects(this.nodeObjects, !0);
+    if (t.length > 0) {
+      let i = t[0].object;
+      for (; i; ) {
+        if ((n = i.userData) != null && n.nodeData)
+          return i.userData.nodeData;
+        i = i.parent;
+      }
+    }
+    return null;
+  }
+  /**
+   * Gets the intersected edge from a mouse event
+   */
+  getIntersectedEdge(e) {
+    const o = this.container.getBoundingClientRect();
+    this.mouse.x = (e.clientX - o.left) / o.width * 2 - 1, this.mouse.y = -((e.clientY - o.top) / o.height) * 2 + 1, this.raycaster.setFromCamera(this.mouse, this.sceneManager.camera);
+    const t = this.raycaster.intersectObjects(this.edgeObjects, !1);
+    if (t.length > 0) {
+      const n = t[0].object, i = n.userData;
+      if (i != null && i.edge && (i != null && i.sourceNode) && (i != null && i.targetNode))
+        return {
+          edge: i.edge,
+          sourceNode: i.sourceNode,
+          targetNode: i.targetNode,
+          edgeLine: n
+        };
+    }
+    return null;
+  }
+  /**
+   * Performs a raycast and returns the intersected node ID
+   */
+  getIntersectedNodeId(e, o) {
+    var i;
+    const t = this.container.getBoundingClientRect();
+    this.mouse.x = (e - t.left) / t.width * 2 - 1, this.mouse.y = -((o - t.top) / t.height) * 2 + 1, this.raycaster.setFromCamera(this.mouse, this.sceneManager.camera);
+    const n = this.raycaster.intersectObjects(this.nodeObjects, !0);
+    if (n.length > 0) {
+      let a = n[0].object;
+      for (; a; ) {
+        if ((i = a.userData) != null && i.nodeId)
+          return a.userData.nodeId;
+        a = a.parent;
+      }
+    }
+    return null;
+  }
+  /**
+   * Dispose resources and remove event listeners
+   */
+  dispose() {
+    this.container.removeEventListener("click", this.handleClick), this.container.removeEventListener("mousemove", this.handleMouseMove);
+  }
+}
+class Nt {
+  constructor(e) {
+    r(this, "container");
+    r(this, "panel", null);
+    r(this, "currentNodeId", null);
+    r(this, "visible", !1);
+    r(this, "panelTemplate", null);
+    r(this, "panelStyles", {});
+    r(this, "onExpand", null);
+    this.container = e, this.createPanel();
+  }
+  /**
+   * Creates the panel element
+   */
+  createPanel() {
+    this.panel = document.createElement("div"), this.panel.className = "force-graph-panel", this.panel.style.cssText = `
+      position: absolute;
+      right: 20px;
+      top: 50%;
+      transform: translateY(-50%);
+      width: 280px;
+      max-height: 80vh;
+      overflow-y: auto;
+      background: rgba(15, 15, 25, 0.85);
+      backdrop-filter: blur(20px);
+      -webkit-backdrop-filter: blur(20px);
+      border: 1px solid rgba(255, 255, 255, 0.1);
+      border-radius: 16px;
+      padding: 24px;
+      color: white;
+      font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif;
+      box-shadow: 
+        0 8px 32px rgba(0, 0, 0, 0.4),
+        inset 0 0 0 1px rgba(255, 255, 255, 0.05);
+      z-index: 1000;
+      opacity: 0;
+      pointer-events: none;
+      transition: opacity 0.3s ease, transform 0.3s ease;
+    `, Object.entries(this.panelStyles).forEach(([e, o]) => {
+      this.panel.style.setProperty(e, o);
+    }), this.container.appendChild(this.panel);
+  }
+  /**
+   * Sets the panel template function
+   */
+  setPanelTemplate(e) {
+    this.panelTemplate = e;
+  }
+  /**
+   * Sets custom panel styles
+   */
+  setPanelStyles(e) {
+    this.panelStyles = e, this.panel && Object.entries(e).forEach(([o, t]) => {
+      this.panel.style.setProperty(o, t);
+    });
+  }
+  /**
+   * Sets the expand callback
+   */
+  setExpandCallback(e) {
+    this.onExpand = e;
+  }
+  /**
+   * Shows the panel with node information
+   */
+  show(e, o) {
+    if (!this.panel) return;
+    this.currentNodeId = e.id;
+    let t;
+    this.panelTemplate ? t = this.panelTemplate(e, o) : t = this.generateDefaultContent(e, o), this.panel.innerHTML = t;
+    const n = this.panel.querySelector('[data-action="expand"]'), i = this.panel.querySelector("[data-depth-select]");
+    n && this.onExpand && n.addEventListener("click", () => {
+      if (this.currentNodeId) {
+        const l = i ? parseInt(i.value, 10) : 1;
+        this.onExpand(this.currentNodeId, l);
+      }
+    });
+    const a = this.panel.querySelector('[data-action="close"]');
+    a && a.addEventListener("click", () => {
+      this.hide();
+    }), this.panel.style.opacity = "1", this.panel.style.pointerEvents = "auto", this.panel.style.transform = "translateY(-50%) translateX(0)", this.visible = !0;
+  }
+  /**
+   * Generates default panel content
+   */
+  generateDefaultContent(e, o) {
+    const t = e.color ? `#${e.color.toString(16).padStart(6, "0")}` : "#4A90E2";
+    return `
+      <style>
+        .force-graph-panel h2 {
+          margin: 0 0 16px 0;
+          font-size: 20px;
+          font-weight: 600;
+          letter-spacing: -0.5px;
+          display: flex;
+          align-items: center;
+          gap: 10px;
+        }
+        .force-graph-panel .color-dot {
+          width: 12px;
+          height: 12px;
+          border-radius: 50%;
+          background: ${t};
+          box-shadow: 0 0 10px ${t}80;
+        }
+        .force-graph-panel .info-row {
+          display: flex;
+          justify-content: space-between;
+          padding: 8px 0;
+          border-bottom: 1px solid rgba(255, 255, 255, 0.1);
+          font-size: 13px;
+        }
+        .force-graph-panel .info-row:last-child {
+          border-bottom: none;
+        }
+        .force-graph-panel .info-label {
+          color: rgba(255, 255, 255, 0.6);
+        }
+        .force-graph-panel .info-value {
+          color: rgba(255, 255, 255, 0.95);
+          font-weight: 500;
+        }
+        .force-graph-panel .neighbors-section {
+          margin-top: 16px;
+        }
+        .force-graph-panel .neighbors-title {
+          font-size: 12px;
+          text-transform: uppercase;
+          letter-spacing: 1px;
+          color: rgba(255, 255, 255, 0.5);
+          margin-bottom: 8px;
+        }
+        .force-graph-panel .neighbor-chip {
+          display: inline-block;
+          padding: 4px 10px;
+          margin: 2px;
+          background: rgba(255, 255, 255, 0.1);
+          border-radius: 12px;
+          font-size: 12px;
+        }
+        .force-graph-panel .depth-selector {
+          margin-top: 16px;
+          margin-bottom: 8px;
+        }
+        .force-graph-panel .depth-label {
+          font-size: 12px;
+          color: rgba(255, 255, 255, 0.6);
+          margin-bottom: 6px;
+          text-transform: uppercase;
+          letter-spacing: 0.5px;
+        }
+        .force-graph-panel select {
+          width: 100%;
+          padding: 8px 12px;
+          background: rgba(255, 255, 255, 0.1);
+          border: 1px solid rgba(255, 255, 255, 0.15);
+          border-radius: 6px;
+          color: white;
+          font-size: 13px;
+          cursor: pointer;
+          outline: none;
+          transition: all 0.2s ease;
+        }
+        .force-graph-panel select:hover {
+          background: rgba(255, 255, 255, 0.15);
+        }
+        .force-graph-panel select:focus {
+          border-color: rgba(96, 165, 250, 0.5);
+        }
+        .force-graph-panel .btn-row {
+          display: flex;
+          gap: 8px;
+          margin-top: 20px;
+        }
+        .force-graph-panel button {
+          flex: 1;
+          padding: 10px 16px;
+          border: none;
+          border-radius: 8px;
+          font-size: 13px;
+          font-weight: 500;
+          cursor: pointer;
+          transition: all 0.2s ease;
+        }
+        .force-graph-panel .btn-expand {
+          background: linear-gradient(135deg, #60a5fa, #a78bfa);
+          color: white;
+        }
+        .force-graph-panel .btn-expand:hover {
+          transform: translateY(-1px);
+          box-shadow: 0 4px 12px rgba(96, 165, 250, 0.4);
+        }
+        .force-graph-panel .btn-close {
+          background: rgba(255, 255, 255, 0.1);
+          color: rgba(255, 255, 255, 0.8);
+        }
+        .force-graph-panel .btn-close:hover {
+          background: rgba(255, 255, 255, 0.15);
+        }
+      </style>
+      
+      <h2>
+        <span class="color-dot"></span>
+        ${this.escapeHtml(e.label)}
+      </h2>
+      
+      <div class="info-row">
+        <span class="info-label">ID</span>
+        <span class="info-value">${this.escapeHtml(e.id)}</span>
+      </div>
+      
+      <div class="info-row">
+        <span class="info-label">Connections</span>
+        <span class="info-value">${o.length}</span>
+      </div>
+      
+      ${o.length > 0 ? `
+        <div class="neighbors-section">
+          <div class="neighbors-title">Connected To</div>
+          ${o.slice(0, 5).map(
+      (n) => `<span class="neighbor-chip">${this.escapeHtml(n.label)}</span>`
+    ).join("")}
+          ${o.length > 5 ? `<span class="neighbor-chip">+${o.length - 5} more</span>` : ""}
+        </div>
+      ` : ""}
+      
+      <div class="depth-selector">
+        <div class="depth-label">Expansion Depth</div>
+        <select data-depth-select>
+          <option value="1">1 Level</option>
+          <option value="2">2 Levels</option>
+          <option value="3" selected>3 Levels</option>
+        </select>
+      </div>
+
+      
+      <div class="btn-row">
+        <button class="btn-expand" data-action="expand">Expand</button>
+        <button class="btn-close" data-action="close">Close</button>
+      </div>
+    `;
+  }
+  /**
+   * Escapes HTML to prevent XSS
+   */
+  escapeHtml(e) {
+    const o = document.createElement("div");
+    return o.textContent = e, o.innerHTML;
+  }
+  /**
+   * Hides the panel
+   */
+  hide() {
+    this.panel && (this.panel.style.opacity = "0", this.panel.style.pointerEvents = "none", this.panel.style.transform = "translateY(-50%) translateX(20px)", this.visible = !1, this.currentNodeId = null);
+  }
+  /**
+   * Checks if the panel is visible
+   */
+  isVisible() {
+    return this.visible;
+  }
+  /**
+   * Gets the currently displayed node ID
+   */
+  getCurrentNodeId() {
+    return this.currentNodeId;
+  }
+  /**
+   * Dispose the panel
+   */
+  dispose() {
+    this.panel && this.panel.parentNode && this.panel.parentNode.removeChild(this.panel), this.panel = null;
+  }
+}
+class zt {
+  constructor() {
+    r(this, "tooltip", null);
+    r(this, "visible", !1);
+    this.createTooltip(), this.setupMouseTracking();
+  }
+  /**
+   * Creates the tooltip element
+   */
+  createTooltip() {
+    this.tooltip = document.createElement("div"), this.tooltip.className = "force-graph-edge-tooltip", this.tooltip.style.cssText = `
+            position: fixed;
+            padding: 10px 14px;
+            background: rgba(30, 30, 30, 0.95);
+            backdrop-filter: blur(10px);
+            -webkit-backdrop-filter: blur(10px);
+            border: 1px solid rgba(255, 255, 255, 0.15);
+            border-radius: 8px;
+            color: white;
+            font-family: 'Inter', -apple-system, BlinkMacSystemFont, sans-serif;
+            font-size: 13px;
+            pointer-events: none;
+            z-index: 10000;
+            opacity: 0;
+            transform: translateY(5px);
+            transition: opacity 0.15s ease, transform 0.15s ease;
+            box-shadow: 0 4px 20px rgba(0, 0, 0, 0.3);
+            max-width: 400px;
+            white-space: normal;
+            word-wrap: break-word;
+            overflow-wrap: break-word;
+        `, document.body.appendChild(this.tooltip);
+  }
+  /**
+   * Sets up mouse tracking for tooltip following
+   */
+  setupMouseTracking() {
+    document.addEventListener("mousemove", (e) => {
+      this.visible && this.tooltip && this.positionTooltip(e.clientX, e.clientY);
+    });
+  }
+  /**
+   * Positions the tooltip near the mouse
+   */
+  positionTooltip(e, o) {
+    if (!this.tooltip) return;
+    const t = this.tooltip.getBoundingClientRect(), n = window.innerWidth, i = window.innerHeight;
+    let a = e + 15, l = o + 15;
+    a + t.width > n - 10 && (a = e - t.width - 15), l + t.height > i - 10 && (l = o - t.height - 15), a < 10 && (a = 10), l < 10 && (l = 10), this.tooltip.style.left = `${a}px`, this.tooltip.style.top = `${l}px`;
+  }
+  /**
+   * Shows the tooltip with edge info
+   */
+  show(e, o, t, n, i) {
+    if (!this.tooltip) return;
+    const a = e.relationship || "connected to";
+    this.tooltip.innerHTML = `
+            <div style="display: flex; flex-direction: column; gap: 4px;">
+                <div style="display: flex; align-items: center; gap: 6px; flex-wrap: wrap;">
+                    <span style="font-weight: 600; color: #ff9966;">${this.escapeHtml(o.label)}</span>
+                </div>
+                <div style="color: rgba(255, 255, 255, 0.6); font-style: italic; font-size: 12px; padding-left: 8px;">
+                    ↳ ${this.escapeHtml(a)}
+                </div>
+                <div style="display: flex; align-items: center; gap: 6px; flex-wrap: wrap;">
+                    <span style="font-weight: 600; color: #ff9966;">${this.escapeHtml(t.label)}</span>
+                </div>
+            </div>
+        `, this.positionTooltip(n, i), this.tooltip.style.opacity = "1", this.tooltip.style.transform = "translateY(0)", this.visible = !0;
+  }
+  /**
+   * Updates tooltip position (called externally on mouse move)
+   */
+  updatePosition(e, o) {
+    this.visible && this.positionTooltip(e, o);
+  }
+  /**
+   * Hides the tooltip
+   */
+  hide() {
+    this.tooltip && (this.tooltip.style.opacity = "0", this.tooltip.style.transform = "translateY(5px)", this.visible = !1);
+  }
+  /**
+   * Checks if tooltip is visible
+   */
+  isVisible() {
+    return this.visible;
+  }
+  /**
+   * Escapes HTML to prevent XSS
+   */
+  escapeHtml(e) {
+    const o = document.createElement("div");
+    return o.textContent = e, o.innerHTML;
+  }
+  /**
+   * Dispose the tooltip
+   */
+  dispose() {
+    this.tooltip && this.tooltip.parentNode && this.tooltip.parentNode.removeChild(this.tooltip), this.tooltip = null;
+  }
+}
+class Ot {
+  constructor(e, o = {}) {
+    // Options
+    r(this, "options");
+    r(this, "container");
+    // Core components
+    r(this, "sceneManager");
+    r(this, "nodeManager");
+    r(this, "edgeManager");
+    r(this, "graphEngine");
+    r(this, "rendererManager");
+    // Factories
+    r(this, "materialFactory");
+    r(this, "nodeFactory");
+    r(this, "edgeFactory");
+    // Performance
+    r(this, "lodManager");
+    r(this, "frustumCuller");
+    // Interaction
+    r(this, "raycasterManager");
+    r(this, "panelManager");
+    r(this, "edgeTooltipManager");
+    // Event system
+    r(this, "eventCallbacks", /* @__PURE__ */ new Map());
+    // State
+    r(this, "initialized", !1);
+    r(this, "devControls", null);
+    this.options = { ...O, ...o }, this.container = ct(e), this.materialFactory = new bt(), this.nodeFactory = new vt(
+      this.materialFactory,
+      this.options.nodeRadius ?? O.nodeRadius,
+      this.options.lodSegments ?? O.lodSegments
+    ), this.edgeFactory = new Mt(
+      this.materialFactory,
+      this.options.edgeColor ?? O.edgeColor,
+      this.options.edgeOpacity ?? O.edgeOpacity
+    ), this.sceneManager = new ut(this.container, this.options), this.lodManager = new Et(
+      this.sceneManager.camera,
+      this.options.lodDistances ?? O.lodDistances,
+      this.options.enableLOD ?? O.enableLOD
+    ), this.frustumCuller = new wt(
+      this.sceneManager.camera,
+      this.options.enableEdgeCulling ?? O.enableEdgeCulling
+    ), this.nodeManager = new mt(this.sceneManager, this.nodeFactory), this.edgeManager = new ft(this.sceneManager, this.nodeManager, this.edgeFactory), this.graphEngine = new Le(
+      this.nodeManager.getAllNodes(),
+      this.edgeManager.getAllEdges(),
+      {
+        repulsionStrength: this.options.repulsionStrength,
+        attractionStrength: this.options.attractionStrength,
+        damping: this.options.damping,
+        useBarnesHut: this.options.useBarnesHut,
+        barnesHutTheta: this.options.barnesHutTheta
+      }
+    ), this.rendererManager = new xt(
+      this.sceneManager,
+      () => this.onSimulate(),
+      () => this.onRender(),
+      this.options.targetFPS ?? O.targetFPS
+    ), this.raycasterManager = new Ct(this.sceneManager, this.container), this.panelManager = new Nt(this.container), this.edgeTooltipManager = new zt(), this.setupCallbacks(), this.rendererManager.start(), this.initialized = !0, this.emit("ready");
+  }
+  /**
+   * Sets up internal callbacks
+   */
+  setupCallbacks() {
+    this.raycasterManager.setClickCallback((e) => {
+      this.onNodeClick(e);
+    }), this.options.onNodeHover && this.raycasterManager.setHoverCallback(this.options.onNodeHover), this.panelManager.setExpandCallback((e, o) => {
+      this.expandNode(e, o);
+    }), this.options.panelTemplate && this.panelManager.setPanelTemplate(this.options.panelTemplate), this.options.panelStyles && this.panelManager.setPanelStyles(this.options.panelStyles), this.raycasterManager.setEdgeHoverCallback((e) => {
+      this.onEdgeHover(e);
+    });
+  }
+  /**
+   * Handles edge hover
+   */
+  onEdgeHover(e) {
+    if (e) {
+      this.edgeManager.highlightEdge(e.edge.source, e.edge.target);
+      const o = this.container.getBoundingClientRect(), t = o.left + o.width / 2, n = o.top + o.height / 2;
+      this.edgeTooltipManager.show(e.edge, e.sourceNode, e.targetNode, t, n), this.options.onEdgeHover && this.options.onEdgeHover(e.edge, e.sourceNode, e.targetNode), this.emit("edgeHover", e.edge, e.sourceNode, e.targetNode);
+    } else
+      this.edgeManager.unhighlightCurrentEdge(), this.edgeTooltipManager.hide(), this.options.onEdgeHover && this.options.onEdgeHover(null, null, null), this.emit("edgeHover", null, null, null);
+  }
+  /**
+   * Handles node click
+   */
+  onNodeClick(e) {
+    const t = this.edgeManager.getNeighborIds(e.id).map((n) => this.nodeManager.getNode(n)).filter((n) => n !== void 0);
+    this.options.showPanel !== !1 && this.panelManager.show(e, t), this.options.onNodeClick && this.options.onNodeClick(e), this.emit("nodeClick", e);
+  }
+  /**
+   * Called every simulation step
+   */
+  onSimulate() {
+    this.graphEngine.simulate();
+    for (const [e, o] of this.nodeManager.getAllNodes())
+      if (this.nodeManager.updateNodePosition(e, o.position), this.options.enableLOD) {
+        const t = this.lodManager.getLODLevel(o.position);
+        this.nodeManager.updateNodeLOD(e, t);
+      }
+    this.edgeManager.updateEdgePositions();
+  }
+  /**
+   * Called every render frame
+   */
+  onRender() {
+    this.frustumCuller.update(), this.raycasterManager.setNodeObjects(this.nodeManager.getAllNodeObjects()), this.raycasterManager.setEdgeObjects(this.edgeManager.getAllEdgeLines());
+  }
+  // ==========================================================================
+  // Public API
+  // ==========================================================================
+  /**
+   * Sets the graph data
+   */
+  setData(e) {
+    if (this.edgeManager.clear(), this.nodeManager.clear(), e.nodes && Array.isArray(e.nodes))
+      for (const o of e.nodes)
+        this.addNode(o);
+    if (e.edges && Array.isArray(e.edges))
+      for (const o of e.edges)
+        this.addEdge(o);
+    this.graphEngine = new Le(
+      this.nodeManager.getAllNodes(),
+      this.edgeManager.getAllEdges(),
+      {
+        repulsionStrength: this.options.repulsionStrength,
+        attractionStrength: this.options.attractionStrength,
+        damping: this.options.damping,
+        useBarnesHut: this.options.useBarnesHut,
+        barnesHutTheta: this.options.barnesHutTheta
+      }
+    ), this.graphEngine.restart();
+  }
+  /**
+   * Adds a node to the graph
+   * @returns true if added, false if node already exists or invalid
+   */
+  addNode(e) {
+    if (!Ie(e))
+      return !1;
+    const o = this.nodeManager.addNode(e);
+    return o && (this.graphEngine.restart(), this.options.onNodeAdd && this.options.onNodeAdd(e), this.emit("nodeAdd", e)), o;
+  }
+  /**
+   * Removes a node from the graph
+   * @returns true if removed, false if not found
+   */
+  removeNode(e) {
+    if (!ht(e))
+      return !1;
+    this.edgeManager.removeEdgesForNode(e);
+    const o = this.nodeManager.removeNode(e);
+    return o && (this.graphEngine.restart(), this.options.onNodeRemove && this.options.onNodeRemove(e), this.emit("nodeRemove", e), this.panelManager.getCurrentNodeId() === e && this.panelManager.hide()), o;
+  }
+  /**
+   * Updates a node's properties
+   */
+  updateNode(e, o) {
+    return this.nodeManager.updateNode(e, o);
+  }
+  /**
+   * Adds an edge to the graph
+   * @returns true if added, false if edge already exists or nodes don't exist
+   */
+  addEdge(e) {
+    if (!Re(e))
+      return !1;
+    const o = this.edgeManager.addEdge(e);
+    return o && (this.graphEngine.setEdges(this.edgeManager.getAllEdges()), this.graphEngine.restart(), this.options.onEdgeAdd && this.options.onEdgeAdd(e), this.emit("edgeAdd", e)), o;
+  }
+  /**
+   * Removes an edge from the graph
+   * @returns true if removed, false if not found
+   */
+  removeEdge(e, o) {
+    const t = this.edgeManager.removeEdge(e, o);
+    return t && (this.graphEngine.setEdges(this.edgeManager.getAllEdges()), this.options.onEdgeRemove && this.options.onEdgeRemove({ source: e, target: o }), this.emit("edgeRemove", { source: e, target: o })), t;
+  }
+  /**
+   * Expands a node by fetching more data
+   * @param nodeId - The ID of the node to expand
+   * @param depth - The depth of expansion (1-3 levels, default 1)
+   * @param fetchFn - Optional fetch function to override the default
+   */
+  async expandNode(e, o = 1, t) {
+    const n = t ?? this.options.onExpand;
+    if (!n)
+      return console.warn("[ForceGraph3D] No expand callback provided"), !1;
+    try {
+      const i = await n(e, o);
+      if (i.nodes && Array.isArray(i.nodes))
+        for (const a of i.nodes)
+          this.addNode(a);
+      if (i.edges && Array.isArray(i.edges))
+        for (const a of i.edges)
+          this.addEdge(a);
+      return this.panelManager.hide(), this.emit("expand", e, i), !0;
+    } catch (i) {
+      return console.error("[ForceGraph3D] Error expanding node:", i), !1;
+    }
+  }
+  /**
+   * Gets a node by ID
+   */
+  getNode(e) {
+    return this.nodeManager.getNode(e);
+  }
+  /**
+   * Gets neighbor nodes for a node
+   */
+  getNeighbors(e) {
+    return this.edgeManager.getNeighborIds(e).map((t) => this.nodeManager.getNode(t)).filter((t) => t !== void 0);
+  }
+  /**
+   * Gets the number of nodes
+   */
+  getNodeCount() {
+    return this.nodeManager.getNodeCount();
+  }
+  /**
+   * Gets the number of edges
+   */
+  getEdgeCount() {
+    return this.edgeManager.getEdgeCount();
+  }
+  /**
+   * Sets the expand callback
+   * @param callback - Function that fetches expansion data given a nodeId and depth
+   */
+  setExpandCallback(e) {
+    this.options.onExpand = e;
+  }
+  /**
+   * Focuses the camera on a specific node with smooth animation
+   */
+  focusOnNode(e, o = 30) {
+    const t = this.nodeManager.getNode(e);
+    if (!t) {
+      console.warn(`[ForceGraph3D] Node "${e}" not found`);
+      return;
+    }
+    const n = t.position, i = this.sceneManager.camera, a = this.sceneManager.controls, l = i.position.clone().sub(a.target).normalize(), d = {
+      x: n.x + l.x * o,
+      y: n.y + l.y * o,
+      z: n.z + l.z * o
+    }, g = { x: i.position.x, y: i.position.y, z: i.position.z }, u = { x: a.target.x, y: a.target.y, z: a.target.z }, x = 800, v = performance.now(), y = () => {
+      const f = performance.now() - v, M = Math.min(f / x, 1), C = 1 - Math.pow(1 - M, 3);
+      i.position.x = g.x + (d.x - g.x) * C, i.position.y = g.y + (d.y - g.y) * C, i.position.z = g.z + (d.z - g.z) * C, a.target.x = u.x + (n.x - u.x) * C, a.target.y = u.y + (n.y - u.y) * C, a.target.z = u.z + (n.z - u.z) * C, a.update(), M < 1 && requestAnimationFrame(y);
+    };
+    y();
+  }
+  /**
+   * Shows the info panel for a specific node
+   */
+  showNodePanel(e) {
+    const o = this.nodeManager.getNode(e);
+    if (!o) {
+      console.warn(`[ForceGraph3D] Node "${e}" not found`);
+      return;
+    }
+    const t = this.getNeighbors(e);
+    this.panelManager.show(o, t);
+  }
+  /**
+   * Searches nodes by label or ID (case-insensitive)
+   * @returns Array of matching nodes
+   */
+  searchNodes(e) {
+    if (!e || e.trim() === "")
+      return [];
+    const o = e.toLowerCase().trim(), t = this.nodeManager.getAllNodes(), n = [];
+    return t.forEach((i) => {
+      var g, u, x;
+      const a = (g = i.label) == null ? void 0 : g.toLowerCase().includes(o), l = (u = i.id) == null ? void 0 : u.toLowerCase().includes(o), d = (x = i.type) == null ? void 0 : x.toLowerCase().includes(o);
+      (a || l || d) && n.push(i);
+    }), n;
+  }
+  /**
+   * Searches edges by relationship (case-insensitive)
+   * @returns Array of matching edges with source/target node info
+   */
+  searchEdges(e) {
+    var i;
+    if (!e || e.trim() === "")
+      return [];
+    const o = e.toLowerCase().trim(), t = this.edgeManager.getAllEdges(), n = [];
+    for (const a of t)
+      if ((i = a.relationship) == null ? void 0 : i.toLowerCase().includes(o)) {
+        const d = this.nodeManager.getNode(a.source), g = this.nodeManager.getNode(a.target);
+        d && g && n.push({ edge: a, sourceNode: d, targetNode: g });
+      }
+    return n;
+  }
+  /**
+   * Gets all nodes as an array
+   */
+  getAllNodes() {
+    const e = this.nodeManager.getAllNodes();
+    return Array.from(e.values());
+  }
+  /**
+   * Gets all edges
+   */
+  getAllEdges() {
+    return this.edgeManager.getAllEdges();
+  }
+  /**
+   * Checks if the graph is initialized
+   */
+  isInitialized() {
+    return this.initialized;
+  }
+  /**
+   * Registers an event listener
+   */
+  on(e, o) {
+    this.eventCallbacks.has(e) || this.eventCallbacks.set(e, []), this.eventCallbacks.get(e).push(o);
+  }
+  /**
+   * Emits an event
+   */
+  emit(e, ...o) {
+    const t = this.eventCallbacks.get(e);
+    t && t.forEach((n) => n(...o));
+  }
+  /**
+   * Sets physics parameters
+   */
+  setPhysicsParams(e) {
+    this.graphEngine.setPhysicsParams(e), this.graphEngine.restart();
+  }
+  /**
+   * Creates dev mode controls (only in development)
+   */
+  createDevControls() {
+    this.devControls = document.createElement("div"), this.devControls.className = "force-graph-dev-controls", this.devControls.innerHTML = `
+      <style>
+        .force-graph-dev-controls {
+          position: absolute;
+          top: 20px;
+          right: 20px;
+          background: rgba(0, 0, 0, 0.8);
+          backdrop-filter: blur(10px);
+          border: 1px solid rgba(255, 255, 255, 0.1);
+          border-radius: 12px;
+          padding: 16px;
+          color: white;
+          font-family: 'Inter', -apple-system, sans-serif;
+          font-size: 12px;
+          z-index: 1001;
+          min-width: 220px;
+        }
+        .force-graph-dev-controls h3 {
+          margin: 0 0 12px 0;
+          font-size: 14px;
+          color: #60a5fa;
+        }
+        .force-graph-dev-controls .control-group {
+          margin-bottom: 12px;
+        }
+        .force-graph-dev-controls label {
+          display: block;
+          margin-bottom: 4px;
+          color: rgba(255, 255, 255, 0.7);
+        }
+        .force-graph-dev-controls input[type="range"] {
+          width: 100%;
+          margin-top: 4px;
+        }
+        .force-graph-dev-controls .value {
+          color: #60a5fa;
+          font-weight: 600;
+        }
+        .force-graph-dev-controls .stats {
+          margin-top: 12px;
+          padding-top: 12px;
+          border-top: 1px solid rgba(255, 255, 255, 0.1);
+        }
+      </style>
+      <h3>⚙️ Dev Controls</h3>
+      <div class="control-group">
+        <label>Repulsion: <span class="value" id="dev-repulsion-val">${this.options.repulsionStrength}</span></label>
+        <input type="range" id="dev-repulsion" min="10" max="500" value="${this.options.repulsionStrength}">
+      </div>
+      <div class="control-group">
+        <label>Attraction: <span class="value" id="dev-attraction-val">${(this.options.attractionStrength ?? 0.01).toFixed(3)}</span></label>
+        <input type="range" id="dev-attraction" min="1" max="100" value="${(this.options.attractionStrength ?? 0.01) * 1e3}">
+      </div>
+      <div class="control-group">
+        <label>Damping: <span class="value" id="dev-damping-val">${this.options.damping}</span></label>
+        <input type="range" id="dev-damping" min="50" max="99" value="${(this.options.damping ?? 0.9) * 100}">
+      </div>
+      <div class="stats">
+        <div>Nodes: <span class="value" id="dev-node-count">0</span></div>
+        <div>Edges: <span class="value" id="dev-edge-count">0</span></div>
+        <div>FPS: <span class="value" id="dev-fps">60</span></div>
+      </div>
+    `, this.container.appendChild(this.devControls);
+    const e = this.devControls.querySelector("#dev-repulsion"), o = this.devControls.querySelector("#dev-attraction"), t = this.devControls.querySelector("#dev-damping");
+    e == null || e.addEventListener("input", () => {
+      const n = parseFloat(e.value);
+      this.setPhysicsParams({ repulsionStrength: n }), this.devControls.querySelector("#dev-repulsion-val").textContent = n.toString();
+    }), o == null || o.addEventListener("input", () => {
+      const n = parseFloat(o.value) / 1e3;
+      this.setPhysicsParams({ attractionStrength: n }), this.devControls.querySelector("#dev-attraction-val").textContent = n.toFixed(3);
+    }), t == null || t.addEventListener("input", () => {
+      const n = parseFloat(t.value) / 100;
+      this.setPhysicsParams({ damping: n }), this.devControls.querySelector("#dev-damping-val").textContent = n.toFixed(2);
+    }), setInterval(() => {
+      const n = this.devControls.querySelector("#dev-node-count"), i = this.devControls.querySelector("#dev-edge-count"), a = this.devControls.querySelector("#dev-fps");
+      n && (n.textContent = this.getNodeCount().toString()), i && (i.textContent = this.getEdgeCount().toString()), a && (a.textContent = this.rendererManager.getFPS().toString());
+    }, 500);
+  }
+  /**
+   * Destroys the graph and releases all resources
+   */
+  destroy() {
+    this.rendererManager.dispose(), this.panelManager.dispose(), this.raycasterManager.dispose(), this.edgeTooltipManager.dispose(), this.edgeManager.dispose(), this.nodeManager.dispose(), this.nodeFactory.dispose(), this.materialFactory.dispose(), this.sceneManager.dispose(), this.devControls && this.devControls.parentNode && this.devControls.parentNode.removeChild(this.devControls), this.eventCallbacks.clear(), this.initialized = !1;
+  }
+}
+const Fe = [
+  "Alpha",
+  "Beta",
+  "Gamma",
+  "Delta",
+  "Epsilon",
+  "Zeta",
+  "Eta",
+  "Theta",
+  "Iota",
+  "Kappa",
+  "Lambda",
+  "Mu",
+  "Nu",
+  "Xi",
+  "Omicron",
+  "Pi",
+  "Rho",
+  "Sigma",
+  "Tau",
+  "Upsilon",
+  "Phi",
+  "Chi",
+  "Psi",
+  "Omega",
+  "Core",
+  "Hub",
+  "Node",
+  "Link",
+  "Point",
+  "Vertex"
+], Q = [
+  "connects to",
+  "links with",
+  "relates to",
+  "depends on",
+  "references",
+  "extends",
+  "includes",
+  "partners with",
+  "collaborates with",
+  "supports"
+], ke = [
+  16777215,
+  // White
+  16750950,
+  // Tangerine
+  16764057,
+  // Light peach
+  16772829,
+  // Cream
+  16746564
+  // Darker tangerine
+];
+function Lt(c = 30) {
+  const e = [], o = [];
+  for (let n = 0; n < c; n++) {
+    const i = n < Fe.length ? Fe[n] : `Node ${n + 1}`;
+    e.push({
+      id: `node-${n}`,
+      label: i,
+      color: ke[n % ke.length],
+      position: {
+        x: (Math.random() - 0.5) * 60,
+        y: (Math.random() - 0.5) * 60,
+        z: (Math.random() - 0.5) * 60
+      }
+    });
+  }
+  for (let n = 1; n < c; n++) {
+    const i = Math.floor(Math.random() * n);
+    o.push({
+      source: `node-${n}`,
+      target: `node-${i}`,
+      relationship: Q[Math.floor(Math.random() * Q.length)]
+    });
+  }
+  const t = Math.floor(c * 0.5);
+  for (let n = 0; n < t; n++) {
+    const i = Math.floor(Math.random() * c);
+    let a = Math.floor(Math.random() * c);
+    i === a && (a = (a + 1) % c);
+    const l = `node-${i}`, d = `node-${a}`;
+    o.some(
+      (u) => u.source === l && u.target === d || u.source === d && u.target === l
+    ) || o.push({
+      source: l,
+      target: d,
+      relationship: Q[Math.floor(Math.random() * Q.length)]
+    });
+  }
+  return { nodes: e, edges: o };
+}
+function Ft(c = 1e3) {
+  const e = [], o = [], t = Math.ceil(c / 50), n = [];
+  for (let i = 0; i < t; i++)
+    n.push({
+      x: (Math.random() - 0.5) * 200,
+      y: (Math.random() - 0.5) * 200,
+      z: (Math.random() - 0.5) * 200
+    });
+  for (let i = 0; i < c; i++) {
+    const a = n[i % t];
+    e.push({
+      id: `node-${i}`,
+      label: `N${i}`,
+      position: {
+        x: a.x + (Math.random() - 0.5) * 40,
+        y: a.y + (Math.random() - 0.5) * 40,
+        z: a.z + (Math.random() - 0.5) * 40
+      }
+    });
+  }
+  for (let i = 1; i < c; i++) {
+    const a = Math.floor(i / 50) * 50, l = a === 0 ? Math.floor(Math.random() * i) : a + Math.floor(Math.random() * Math.min(i - a, 50));
+    o.push({
+      source: `node-${i}`,
+      target: `node-${Math.min(l, i - 1)}`,
+      relationship: "links to"
+    });
+  }
+  for (let i = 1; i < t; i++) {
+    const a = i * 50, l = (i - 1) * 50 + Math.floor(Math.random() * 50);
+    o.push({
+      source: `node-${a}`,
+      target: `node-${l}`,
+      relationship: "bridges to"
+    });
+  }
+  return { nodes: e, edges: o };
+}
+export {
+  O as DEFAULT_OPTIONS,
+  Ot as ForceGraph3D,
+  _ as LODLevel,
+  I as createEdgeKey,
+  Ft as generateLargeSampleData,
+  Lt as generateSampleData,
+  Re as validateEdgeData,
+  Ie as validateNodeData
+};
+//# sourceMappingURL=force-3d-graph.js.map