@xiping/react-components 1.0.19 → 1.0.20

package/dist/es/node_modules/.pnpm/three-forcegraph@1.42.13_three@0.171.0/node_modules/three-forcegraph/dist/three-forcegraph.js

@@ -0,0 +1,1020 @@
+import "../../../../three@0.171.0/node_modules/three/build/three.module.js";
+import Fe from "../../../../../../_virtual/index4.js";
+import Ue from "../../../../../../_virtual/index5.js";
+import Ie from "../../../../kapsule@1.16.3/node_modules/kapsule/dist/kapsule.js";
+import w from "../../../../accessor-fn@1.5.3/node_modules/accessor-fn/dist/accessor-fn.js";
+import "../../../../d3-array@1.2.4/node_modules/d3-array/src/bisect.js";
+import Ge from "../../../../d3-array@1.2.4/node_modules/d3-array/src/max.js";
+import Ve from "../../../../d3-array@1.2.4/node_modules/d3-array/src/min.js";
+import He from "../../../../data-bind-mapper@1.0.3/node_modules/data-bind-mapper/dist/data-bind-mapper.js";
+import Oe from "../../../../tinycolor2@1.6.0/node_modules/tinycolor2/esm/tinycolor.js";
+import { Group as ke, Mesh as Ne, SphereGeometry as We, Color as $e, MeshLambertMaterial as qe, BufferGeometry as Ke, BufferAttribute as Je, Line as Qe, CylinderGeometry as Xe, Matrix4 as Ye, Box3 as Ze, CubicBezierCurve3 as er, QuadraticBezierCurve3 as rr, LineBasicMaterial as nr, ConeGeometry as tr, TubeGeometry as or, Vector3 as ar } from "../../../../three@0.171.0/node_modules/three/build/three.core.js";
+import ir from "../../../../d3-force-3d@3.0.6/node_modules/d3-force-3d/src/radial.js";
+import lr from "../../../../d3-force-3d@3.0.6/node_modules/d3-force-3d/src/simulation.js";
+import ur from "../../../../d3-force-3d@3.0.6/node_modules/d3-force-3d/src/link.js";
+import cr from "../../../../d3-force-3d@3.0.6/node_modules/d3-force-3d/src/manyBody.js";
+import fr from "../../../../d3-force-3d@3.0.6/node_modules/d3-force-3d/src/center.js";
+import dr from "../../../../d3-scale@4.0.2/node_modules/d3-scale/src/ordinal.js";
+import pr from "../../../../d3-scale-chromatic@3.1.0/node_modules/d3-scale-chromatic/src/categorical/Paired.js";
+function fe(r, e) {
+  (e == null || e > r.length) && (e = r.length);
+  for (var n = 0, t = Array(e); n < e; n++) t[n] = r[n];
+  return t;
+}
+function sr(r) {
+  if (Array.isArray(r)) return r;
+}
+function hr(r) {
+  if (Array.isArray(r)) return fe(r);
+}
+function De(r, e, n) {
+  if (typeof r == "function" ? r === e : r.has(e)) return arguments.length < 3 ? e : n;
+  throw new TypeError("Private element is not present on this object");
+}
+function gr(r) {
+  if (r === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return r;
+}
+function Pe(r, e, n) {
+  return e = q(e), kr(r, ge() ? Reflect.construct(e, n || [], q(r).constructor) : e.apply(r, n));
+}
+function yr(r, e) {
+  if (e.has(r)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function Ce(r, e) {
+  if (!(r instanceof e)) throw new TypeError("Cannot call a class as a function");
+}
+function ae(r, e) {
+  return r.get(De(r, e));
+}
+function ve(r, e, n) {
+  yr(r, e), e.set(r, n);
+}
+function me(r, e, n) {
+  return r.set(De(r, e), n), n;
+}
+function Me(r, e, n) {
+  if (ge()) return Reflect.construct.apply(null, arguments);
+  var t = [null];
+  t.push.apply(t, e);
+  var i = new (r.bind.apply(r, t))();
+  return i;
+}
+function vr(r, e) {
+  for (var n = 0; n < e.length; n++) {
+    var t = e[n];
+    t.enumerable = t.enumerable || !1, t.configurable = !0, "value" in t && (t.writable = !0), Object.defineProperty(r, Te(t.key), t);
+  }
+}
+function xe(r, e, n) {
+  return e && vr(r.prototype, e), Object.defineProperty(r, "prototype", {
+    writable: !1
+  }), r;
+}
+function te(r, e, n) {
+  return (e = Te(e)) in r ? Object.defineProperty(r, e, {
+    value: n,
+    enumerable: !0,
+    configurable: !0,
+    writable: !0
+  }) : r[e] = n, r;
+}
+function de() {
+  return de = typeof Reflect < "u" && Reflect.get ? Reflect.get.bind() : function(r, e, n) {
+    var t = Dr(r, e);
+    if (t) {
+      var i = Object.getOwnPropertyDescriptor(t, e);
+      return i.get ? i.get.call(arguments.length < 3 ? r : n) : i.value;
+    }
+  }, de.apply(null, arguments);
+}
+function q(r) {
+  return q = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(e) {
+    return e.__proto__ || Object.getPrototypeOf(e);
+  }, q(r);
+}
+function Ae(r, e) {
+  if (typeof e != "function" && e !== null) throw new TypeError("Super expression must either be null or a function");
+  r.prototype = Object.create(e && e.prototype, {
+    constructor: {
+      value: r,
+      writable: !0,
+      configurable: !0
+    }
+  }), Object.defineProperty(r, "prototype", {
+    writable: !1
+  }), e && pe(r, e);
+}
+function ge() {
+  try {
+    var r = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    }));
+  } catch {
+  }
+  return (ge = function() {
+    return !!r;
+  })();
+}
+function mr(r) {
+  if (typeof Symbol < "u" && r[Symbol.iterator] != null || r["@@iterator"] != null) return Array.from(r);
+}
+function br(r, e) {
+  var n = r == null ? null : typeof Symbol < "u" && r[Symbol.iterator] || r["@@iterator"];
+  if (n != null) {
+    var t, i, c, p, h = [], P = !0, _ = !1;
+    try {
+      if (c = (n = n.call(r)).next, e !== 0) for (; !(P = (t = c.call(n)).done) && (h.push(t.value), h.length !== e); P = !0) ;
+    } catch (T) {
+      _ = !0, i = T;
+    } finally {
+      try {
+        if (!P && n.return != null && (p = n.return(), Object(p) !== p)) return;
+      } finally {
+        if (_) throw i;
+      }
+    }
+    return h;
+  }
+}
+function _r() {
+  throw new TypeError(`Invalid attempt to destructure non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+}
+function wr() {
+  throw new TypeError(`Invalid attempt to spread non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+}
+function be(r, e) {
+  var n = Object.keys(r);
+  if (Object.getOwnPropertySymbols) {
+    var t = Object.getOwnPropertySymbols(r);
+    e && (t = t.filter(function(i) {
+      return Object.getOwnPropertyDescriptor(r, i).enumerable;
+    })), n.push.apply(n, t);
+  }
+  return n;
+}
+function Or(r) {
+  for (var e = 1; e < arguments.length; e++) {
+    var n = arguments[e] != null ? arguments[e] : {};
+    e % 2 ? be(Object(n), !0).forEach(function(t) {
+      te(r, t, n[t]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(r, Object.getOwnPropertyDescriptors(n)) : be(Object(n)).forEach(function(t) {
+      Object.defineProperty(r, t, Object.getOwnPropertyDescriptor(n, t));
+    });
+  }
+  return r;
+}
+function kr(r, e) {
+  if (e && (typeof e == "object" || typeof e == "function")) return e;
+  if (e !== void 0) throw new TypeError("Derived constructors may only return object or undefined");
+  return gr(r);
+}
+function pe(r, e) {
+  return pe = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(n, t) {
+    return n.__proto__ = t, n;
+  }, pe(r, e);
+}
+function X(r, e) {
+  return sr(r) || br(r, e) || je(r, e) || _r();
+}
+function Dr(r, e) {
+  for (; !{}.hasOwnProperty.call(r, e) && (r = q(r)) !== null; ) ;
+  return r;
+}
+function ie(r, e, n, t) {
+  var i = de(q(r.prototype), e, n);
+  return typeof i == "function" ? function(c) {
+    return i.apply(n, c);
+  } : i;
+}
+function U(r) {
+  return hr(r) || mr(r) || je(r) || wr();
+}
+function Pr(r, e) {
+  if (typeof r != "object" || !r) return r;
+  var n = r[Symbol.toPrimitive];
+  if (n !== void 0) {
+    var t = n.call(r, e);
+    if (typeof t != "object") return t;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (e === "string" ? String : Number)(r);
+}
+function Te(r) {
+  var e = Pr(r, "string");
+  return typeof e == "symbol" ? e : e + "";
+}
+function se(r) {
+  "@babel/helpers - typeof";
+  return se = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(e) {
+    return typeof e;
+  } : function(e) {
+    return e && typeof Symbol == "function" && e.constructor === Symbol && e !== Symbol.prototype ? "symbol" : typeof e;
+  }, se(r);
+}
+function je(r, e) {
+  if (r) {
+    if (typeof r == "string") return fe(r, e);
+    var n = {}.toString.call(r).slice(8, -1);
+    return n === "Object" && r.constructor && (n = r.constructor.name), n === "Map" || n === "Set" ? Array.from(r) : n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n) ? fe(r, e) : void 0;
+  }
+}
+var Re = function(e) {
+  e instanceof Array ? e.forEach(Re) : (e.map && e.map.dispose(), e.dispose());
+}, Ee = function(e) {
+  e.geometry && e.geometry.dispose(), e.material && Re(e.material), e.texture && e.texture.dispose(), e.children && e.children.forEach(Ee);
+}, he = function(e) {
+  for (; e.children.length; ) {
+    var n = e.children[0];
+    e.remove(n), Ee(n);
+  }
+}, le = /* @__PURE__ */ new WeakMap(), re = /* @__PURE__ */ new WeakMap(), J = /* @__PURE__ */ function(r) {
+  function e(n) {
+    var t, i = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, c = i.dataBindAttr, p = c === void 0 ? "__data" : c, h = i.objBindAttr, P = h === void 0 ? "__threeObj" : h;
+    return Ce(this, e), t = Pe(this, e), te(t, "scene", void 0), ve(t, le, void 0), ve(t, re, void 0), t.scene = n, me(le, t, p), me(re, t, P), t.onRemoveObj(function() {
+    }), t;
+  }
+  return Ae(e, r), xe(e, [{
+    key: "onCreateObj",
+    value: function(t) {
+      var i = this;
+      return ie(e, "onCreateObj", this)([function(c) {
+        var p = t(c);
+        return c[ae(re, i)] = p, p[ae(le, i)] = c, i.scene.add(p), p;
+      }]), this;
+    }
+  }, {
+    key: "onRemoveObj",
+    value: function(t) {
+      var i = this;
+      return ie(e, "onRemoveObj", this)([function(c, p) {
+        var h = ie(e, "getData", i)([c]);
+        t(c, p), i.scene.remove(c), he(c), delete h[ae(re, i)];
+      }]), this;
+    }
+  }]);
+}(He), Q = function(e) {
+  return isNaN(e) ? parseInt(Oe(e).toHex(), 16) : e;
+}, ue = function(e) {
+  return isNaN(e) ? Oe(e).getAlpha() : 1;
+}, Cr = dr(pr);
+function _e(r, e, n) {
+  !e || typeof n != "string" || r.filter(function(t) {
+    return !t[n];
+  }).forEach(function(t) {
+    t[n] = Cr(e(t));
+  });
+}
+function Mr(r, e) {
+  var n = r.nodes, t = r.links, i = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}, c = i.nodeFilter, p = c === void 0 ? function() {
+    return !0;
+  } : c, h = i.onLoopError, P = h === void 0 ? function(g) {
+    throw "Invalid DAG structure! Found cycle in node path: ".concat(g.join(" -> "), ".");
+  } : h, _ = {};
+  n.forEach(function(g) {
+    return _[e(g)] = {
+      data: g,
+      out: [],
+      depth: -1,
+      skip: !p(g)
+    };
+  }), t.forEach(function(g) {
+    var u = g.source, f = g.target, k = m(u), a = m(f);
+    if (!_.hasOwnProperty(k)) throw "Missing source node with id: ".concat(k);
+    if (!_.hasOwnProperty(a)) throw "Missing target node with id: ".concat(a);
+    var v = _[k], L = _[a];
+    v.out.push(L);
+    function m(D) {
+      return se(D) === "object" ? e(D) : D;
+    }
+  });
+  var T = [];
+  O(Object.values(_));
+  var A = Object.assign.apply(Object, [{}].concat(U(Object.entries(_).filter(function(g) {
+    var u = X(g, 2), f = u[1];
+    return !f.skip;
+  }).map(function(g) {
+    var u = X(g, 2), f = u[0], k = u[1];
+    return te({}, f, k.depth);
+  }))));
+  return A;
+  function O(g) {
+    for (var u = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [], f = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0, k = function() {
+      var m = g[a];
+      if (u.indexOf(m) !== -1) {
+        var D = [].concat(U(u.slice(u.indexOf(m))), [m]).map(function(s) {
+          return e(s.data);
+        });
+        return T.some(function(s) {
+          return s.length === D.length && s.every(function(M, S) {
+            return M === D[S];
+          });
+        }) || (T.push(D), P(D)), 1;
+      }
+      f > m.depth && (m.depth = f, O(m.out, [].concat(U(u), [m]), f + (m.skip ? 0 : 1)));
+    }, a = 0, v = g.length; a < v; a++)
+      k();
+  }
+}
+var l = window.THREE ? window.THREE : {
+  Group: ke,
+  Mesh: Ne,
+  MeshLambertMaterial: qe,
+  Color: $e,
+  BufferGeometry: Ke,
+  BufferAttribute: Je,
+  Matrix4: Ye,
+  Vector3: ar,
+  SphereGeometry: We,
+  CylinderGeometry: Xe,
+  TubeGeometry: or,
+  ConeGeometry: tr,
+  Line: Qe,
+  LineBasicMaterial: nr,
+  QuadraticBezierCurve3: rr,
+  CubicBezierCurve3: er,
+  Box3: Ze
+}, we = {
+  graph: Fe,
+  forcelayout: Ue
+}, xr = 2, ce = new l.BufferGeometry().setAttribute ? "setAttribute" : "addAttribute", ne = new l.BufferGeometry().applyMatrix4 ? "applyMatrix4" : "applyMatrix", Ar = Ie({
+  props: {
+    jsonUrl: {
+      onChange: function(e, n) {
+        var t = this;
+        e && !n.fetchingJson && (n.fetchingJson = !0, n.onLoading(), fetch(e).then(function(i) {
+          return i.json();
+        }).then(function(i) {
+          n.fetchingJson = !1, n.onFinishLoading(i), t.graphData(i);
+        }));
+      },
+      triggerUpdate: !1
+    },
+    graphData: {
+      default: {
+        nodes: [],
+        links: []
+      },
+      onChange: function(e, n) {
+        n.engineRunning = !1;
+      }
+    },
+    numDimensions: {
+      default: 3,
+      onChange: function(e, n) {
+        var t = n.d3ForceLayout.force("charge");
+        t && t.strength(e > 2 ? -60 : -30), e < 3 && i(n.graphData.nodes, "z"), e < 2 && i(n.graphData.nodes, "y");
+        function i(c, p) {
+          c.forEach(function(h) {
+            delete h[p], delete h["v".concat(p)];
+          });
+        }
+      }
+    },
+    dagMode: {
+      onChange: function(e, n) {
+        !e && n.forceEngine === "d3" && (n.graphData.nodes || []).forEach(function(t) {
+          return t.fx = t.fy = t.fz = void 0;
+        });
+      }
+    },
+    dagLevelDistance: {},
+    dagNodeFilter: {
+      default: function(e) {
+        return !0;
+      }
+    },
+    onDagError: {
+      triggerUpdate: !1
+    },
+    nodeRelSize: {
+      default: 4
+    },
+    // volume per val unit
+    nodeId: {
+      default: "id"
+    },
+    nodeVal: {
+      default: "val"
+    },
+    nodeResolution: {
+      default: 8
+    },
+    // how many slice segments in the sphere's circumference
+    nodeColor: {
+      default: "color"
+    },
+    nodeAutoColorBy: {},
+    nodeOpacity: {
+      default: 0.75
+    },
+    nodeVisibility: {
+      default: !0
+    },
+    nodeThreeObject: {},
+    nodeThreeObjectExtend: {
+      default: !1
+    },
+    nodePositionUpdate: {
+      triggerUpdate: !1
+    },
+    // custom function to call for updating the node's position. Signature: (threeObj, { x, y, z}, node). If the function returns a truthy value, the regular node position update will not run.
+    linkSource: {
+      default: "source"
+    },
+    linkTarget: {
+      default: "target"
+    },
+    linkVisibility: {
+      default: !0
+    },
+    linkColor: {
+      default: "color"
+    },
+    linkAutoColorBy: {},
+    linkOpacity: {
+      default: 0.2
+    },
+    linkWidth: {},
+    // Rounded to nearest decimal. For falsy values use dimensionless line with 1px regardless of distance.
+    linkResolution: {
+      default: 6
+    },
+    // how many radial segments in each line tube's geometry
+    linkCurvature: {
+      default: 0,
+      triggerUpdate: !1
+    },
+    // line curvature radius (0: straight, 1: semi-circle)
+    linkCurveRotation: {
+      default: 0,
+      triggerUpdate: !1
+    },
+    // line curve rotation along the line axis (0: interection with XY plane, PI: upside down)
+    linkMaterial: {},
+    linkThreeObject: {},
+    linkThreeObjectExtend: {
+      default: !1
+    },
+    linkPositionUpdate: {
+      triggerUpdate: !1
+    },
+    // custom function to call for updating the link's position. Signature: (threeObj, { start: { x, y, z},  end: { x, y, z }}, link). If the function returns a truthy value, the regular link position update will not run.
+    linkDirectionalArrowLength: {
+      default: 0
+    },
+    linkDirectionalArrowColor: {},
+    linkDirectionalArrowRelPos: {
+      default: 0.5,
+      triggerUpdate: !1
+    },
+    // value between 0<>1 indicating the relative pos along the (exposed) line
+    linkDirectionalArrowResolution: {
+      default: 8
+    },
+    // how many slice segments in the arrow's conic circumference
+    linkDirectionalParticles: {
+      default: 0
+    },
+    // animate photons travelling in the link direction
+    linkDirectionalParticleSpeed: {
+      default: 0.01,
+      triggerUpdate: !1
+    },
+    // in link length ratio per frame
+    linkDirectionalParticleWidth: {
+      default: 0.5
+    },
+    linkDirectionalParticleColor: {},
+    linkDirectionalParticleResolution: {
+      default: 4
+    },
+    // how many slice segments in the particle sphere's circumference
+    forceEngine: {
+      default: "d3"
+    },
+    // d3 or ngraph
+    d3AlphaMin: {
+      default: 0
+    },
+    d3AlphaDecay: {
+      default: 0.0228,
+      triggerUpdate: !1,
+      onChange: function(e, n) {
+        n.d3ForceLayout.alphaDecay(e);
+      }
+    },
+    d3AlphaTarget: {
+      default: 0,
+      triggerUpdate: !1,
+      onChange: function(e, n) {
+        n.d3ForceLayout.alphaTarget(e);
+      }
+    },
+    d3VelocityDecay: {
+      default: 0.4,
+      triggerUpdate: !1,
+      onChange: function(e, n) {
+        n.d3ForceLayout.velocityDecay(e);
+      }
+    },
+    ngraphPhysics: {
+      default: {
+        // defaults from https://github.com/anvaka/ngraph.physics.simulator/blob/master/index.js
+        timeStep: 20,
+        gravity: -1.2,
+        theta: 0.8,
+        springLength: 30,
+        springCoefficient: 8e-4,
+        dragCoefficient: 0.02
+      }
+    },
+    warmupTicks: {
+      default: 0,
+      triggerUpdate: !1
+    },
+    // how many times to tick the force engine at init before starting to render
+    cooldownTicks: {
+      default: 1 / 0,
+      triggerUpdate: !1
+    },
+    cooldownTime: {
+      default: 15e3,
+      triggerUpdate: !1
+    },
+    // ms
+    onLoading: {
+      default: function() {
+      },
+      triggerUpdate: !1
+    },
+    onFinishLoading: {
+      default: function() {
+      },
+      triggerUpdate: !1
+    },
+    onUpdate: {
+      default: function() {
+      },
+      triggerUpdate: !1
+    },
+    onFinishUpdate: {
+      default: function() {
+      },
+      triggerUpdate: !1
+    },
+    onEngineTick: {
+      default: function() {
+      },
+      triggerUpdate: !1
+    },
+    onEngineStop: {
+      default: function() {
+      },
+      triggerUpdate: !1
+    }
+  },
+  methods: {
+    refresh: function(e) {
+      return e._flushObjects = !0, e._rerender(), this;
+    },
+    // Expose d3 forces for external manipulation
+    d3Force: function(e, n, t) {
+      return t === void 0 ? e.d3ForceLayout.force(n) : (e.d3ForceLayout.force(n, t), this);
+    },
+    d3ReheatSimulation: function(e) {
+      return e.d3ForceLayout.alpha(1), this.resetCountdown(), this;
+    },
+    // reset cooldown state
+    resetCountdown: function(e) {
+      return e.cntTicks = 0, e.startTickTime = /* @__PURE__ */ new Date(), e.engineRunning = !0, this;
+    },
+    tickFrame: function(e) {
+      var n = e.forceEngine !== "ngraph";
+      return e.engineRunning && t(), i(), c(), this;
+      function t() {
+        ++e.cntTicks > e.cooldownTicks || /* @__PURE__ */ new Date() - e.startTickTime > e.cooldownTime || n && e.d3AlphaMin > 0 && e.d3ForceLayout.alpha() < e.d3AlphaMin ? (e.engineRunning = !1, e.onEngineStop()) : (e.layout[n ? "tick" : "step"](), e.onEngineTick());
+        var p = w(e.nodeThreeObjectExtend);
+        e.nodeDataMapper.entries().forEach(function(O) {
+          var g = X(O, 2), u = g[0], f = g[1];
+          if (f) {
+            var k = n ? u : e.layout.getNodePosition(u[e.nodeId]), a = p(u);
+            (!e.nodePositionUpdate || !e.nodePositionUpdate(a ? f.children[0] : f, {
+              x: k.x,
+              y: k.y,
+              z: k.z
+            }, u) || a) && (f.position.x = k.x, f.position.y = k.y || 0, f.position.z = k.z || 0);
+          }
+        });
+        var h = w(e.linkWidth), P = w(e.linkCurvature), _ = w(e.linkCurveRotation), T = w(e.linkThreeObjectExtend);
+        e.linkDataMapper.entries().forEach(function(O) {
+          var g = X(O, 2), u = g[0], f = g[1];
+          if (f) {
+            var k = n ? u : e.layout.getLinkPosition(e.layout.graph.getLink(u.source, u.target).id), a = k[n ? "source" : "from"], v = k[n ? "target" : "to"];
+            if (!(!a || !v || !a.hasOwnProperty("x") || !v.hasOwnProperty("x"))) {
+              A(u);
+              var L = T(u);
+              if (!(e.linkPositionUpdate && e.linkPositionUpdate(
+                L ? f.children[1] : f,
+                // pass child custom object if extending the default
+                {
+                  start: {
+                    x: a.x,
+                    y: a.y,
+                    z: a.z
+                  },
+                  end: {
+                    x: v.x,
+                    y: v.y,
+                    z: v.z
+                  }
+                },
+                u
+              ) && !L)) {
+                var m = 30, D = u.__curve, s = f.children.length ? f.children[0] : f;
+                if (s.type === "Line") {
+                  if (D) {
+                    var S = D.getPoints(m);
+                    s.geometry.getAttribute("position").array.length !== S.length * 3 && s.geometry[ce]("position", new l.BufferAttribute(new Float32Array(S.length * 3), 3)), s.geometry.setFromPoints(S);
+                  } else {
+                    var M = s.geometry.getAttribute("position");
+                    (!M || !M.array || M.array.length !== 6) && s.geometry[ce]("position", M = new l.BufferAttribute(new Float32Array(2 * 3), 3)), M.array[0] = a.x, M.array[1] = a.y || 0, M.array[2] = a.z || 0, M.array[3] = v.x, M.array[4] = v.y || 0, M.array[5] = v.z || 0, M.needsUpdate = !0;
+                  }
+                  s.geometry.computeBoundingSphere();
+                } else if (s.type === "Mesh")
+                  if (D) {
+                    s.geometry.type.match(/^Tube(Buffer)?Geometry$/) || (s.position.set(0, 0, 0), s.rotation.set(0, 0, 0), s.scale.set(1, 1, 1));
+                    var N = Math.ceil(h(u) * 10) / 10, W = N / 2, Y = new l.TubeGeometry(D, m, W, e.linkResolution, !1);
+                    s.geometry.dispose(), s.geometry = Y;
+                  } else {
+                    if (!s.geometry.type.match(/^Cylinder(Buffer)?Geometry$/)) {
+                      var G = Math.ceil(h(u) * 10) / 10, C = G / 2, E = new l.CylinderGeometry(C, C, 1, e.linkResolution, 1, !1);
+                      E[ne](new l.Matrix4().makeTranslation(0, 1 / 2, 0)), E[ne](new l.Matrix4().makeRotationX(Math.PI / 2)), s.geometry.dispose(), s.geometry = E;
+                    }
+                    var z = new l.Vector3(a.x, a.y || 0, a.z || 0), B = new l.Vector3(v.x, v.y || 0, v.z || 0), H = z.distanceTo(B);
+                    s.position.x = z.x, s.position.y = z.y, s.position.z = z.z, s.scale.z = H, s.parent.localToWorld(B), s.lookAt(B);
+                  }
+              }
+            }
+          }
+        });
+        function A(O) {
+          var g = n ? O : e.layout.getLinkPosition(e.layout.graph.getLink(O.source, O.target).id), u = g[n ? "source" : "from"], f = g[n ? "target" : "to"];
+          if (!(!u || !f || !u.hasOwnProperty("x") || !f.hasOwnProperty("x"))) {
+            var k = P(O);
+            if (!k)
+              O.__curve = null;
+            else {
+              var a = new l.Vector3(u.x, u.y || 0, u.z || 0), v = new l.Vector3(f.x, f.y || 0, f.z || 0), L = a.distanceTo(v), m, D = _(O);
+              if (L > 0) {
+                var s = f.x - u.x, M = f.y - u.y || 0, S = new l.Vector3().subVectors(v, a), G = S.clone().multiplyScalar(k).cross(s !== 0 || M !== 0 ? new l.Vector3(0, 0, 1) : new l.Vector3(0, 1, 0)).applyAxisAngle(S.normalize(), D).add(new l.Vector3().addVectors(a, v).divideScalar(2));
+                m = new l.QuadraticBezierCurve3(a, G, v);
+              } else {
+                var C = k * 70, E = -D, z = E + Math.PI / 2;
+                m = new l.CubicBezierCurve3(a, new l.Vector3(C * Math.cos(z), C * Math.sin(z), 0).add(a), new l.Vector3(C * Math.cos(E), C * Math.sin(E), 0).add(a), v);
+              }
+              O.__curve = m;
+            }
+          }
+        }
+      }
+      function i() {
+        var p = w(e.linkDirectionalArrowRelPos), h = w(e.linkDirectionalArrowLength), P = w(e.nodeVal);
+        e.arrowDataMapper.entries().forEach(function(_) {
+          var T = X(_, 2), A = T[0], O = T[1];
+          if (O) {
+            var g = n ? A : e.layout.getLinkPosition(e.layout.graph.getLink(A.source, A.target).id), u = g[n ? "source" : "from"], f = g[n ? "target" : "to"];
+            if (!(!u || !f || !u.hasOwnProperty("x") || !f.hasOwnProperty("x"))) {
+              var k = Math.cbrt(Math.max(0, P(u) || 1)) * e.nodeRelSize, a = Math.cbrt(Math.max(0, P(f) || 1)) * e.nodeRelSize, v = h(A), L = p(A), m = A.__curve ? function(C) {
+                return A.__curve.getPoint(C);
+              } : function(C) {
+                var E = function(B, H, N, W) {
+                  return H[B] + (N[B] - H[B]) * W || 0;
+                };
+                return {
+                  x: E("x", u, f, C),
+                  y: E("y", u, f, C),
+                  z: E("z", u, f, C)
+                };
+              }, D = A.__curve ? A.__curve.getLength() : Math.sqrt(["x", "y", "z"].map(function(C) {
+                return Math.pow((f[C] || 0) - (u[C] || 0), 2);
+              }).reduce(function(C, E) {
+                return C + E;
+              }, 0)), s = k + v + (D - k - a - v) * L, M = m(s / D), S = m((s - v) / D);
+              ["x", "y", "z"].forEach(function(C) {
+                return O.position[C] = S[C];
+              });
+              var G = Me(l.Vector3, U(["x", "y", "z"].map(function(C) {
+                return M[C];
+              })));
+              O.parent.localToWorld(G), O.lookAt(G);
+            }
+          }
+        });
+      }
+      function c() {
+        var p = w(e.linkDirectionalParticleSpeed);
+        e.graphData.links.forEach(function(h) {
+          var P = e.particlesDataMapper.getObj(h), _ = P && P.children, T = h.__singleHopPhotonsObj && h.__singleHopPhotonsObj.children;
+          if (!((!T || !T.length) && (!_ || !_.length))) {
+            var A = n ? h : e.layout.getLinkPosition(e.layout.graph.getLink(h.source, h.target).id), O = A[n ? "source" : "from"], g = A[n ? "target" : "to"];
+            if (!(!O || !g || !O.hasOwnProperty("x") || !g.hasOwnProperty("x"))) {
+              var u = p(h), f = h.__curve ? function(a) {
+                return h.__curve.getPoint(a);
+              } : function(a) {
+                var v = function(m, D, s, M) {
+                  return D[m] + (s[m] - D[m]) * M || 0;
+                };
+                return {
+                  x: v("x", O, g, a),
+                  y: v("y", O, g, a),
+                  z: v("z", O, g, a)
+                };
+              }, k = [].concat(U(_ || []), U(T || []));
+              k.forEach(function(a, v) {
+                var L = a.parent.__linkThreeObjType === "singleHopPhotons";
+                if (a.hasOwnProperty("__progressRatio") || (a.__progressRatio = L ? 0 : v / _.length), a.__progressRatio += u, a.__progressRatio >= 1)
+                  if (!L)
+                    a.__progressRatio = a.__progressRatio % 1;
+                  else {
+                    a.parent.remove(a), he(a);
+                    return;
+                  }
+                var m = a.__progressRatio, D = f(m);
+                ["x", "y", "z"].forEach(function(s) {
+                  return a.position[s] = D[s];
+                });
+              });
+            }
+          }
+        });
+      }
+    },
+    emitParticle: function(e, n) {
+      if (n && e.graphData.links.includes(n)) {
+        if (!n.__singleHopPhotonsObj) {
+          var t = new l.Group();
+          t.__linkThreeObjType = "singleHopPhotons", n.__singleHopPhotonsObj = t, e.graphScene.add(t);
+        }
+        var i = w(e.linkDirectionalParticleWidth), c = Math.ceil(i(n) * 10) / 10 / 2, p = e.linkDirectionalParticleResolution, h = new l.SphereGeometry(c, p, p), P = w(e.linkColor), _ = w(e.linkDirectionalParticleColor), T = _(n) || P(n) || "#f0f0f0", A = new l.Color(Q(T)), O = e.linkOpacity * 3, g = new l.MeshLambertMaterial({
+          color: A,
+          transparent: !0,
+          opacity: O
+        });
+        n.__singleHopPhotonsObj.add(new l.Mesh(h, g));
+      }
+      return this;
+    },
+    getGraphBbox: function(e) {
+      var n = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : function() {
+        return !0;
+      };
+      if (!e.initialised) return null;
+      var t = function i(c) {
+        var p = [];
+        if (c.geometry) {
+          c.geometry.computeBoundingBox();
+          var h = new l.Box3();
+          h.copy(c.geometry.boundingBox).applyMatrix4(c.matrixWorld), p.push(h);
+        }
+        return p.concat.apply(p, U((c.children || []).filter(
+          function(P) {
+            return !P.hasOwnProperty("__graphObjType") || P.__graphObjType === "node" && n(P.__data);
+          }
+          // exclude filtered out nodes
+        ).map(i)));
+      }(e.graphScene);
+      return t.length ? Object.assign.apply(Object, U(["x", "y", "z"].map(function(i) {
+        return te({}, i, [Ve(t, function(c) {
+          return c.min[i];
+        }), Ge(t, function(c) {
+          return c.max[i];
+        })]);
+      }))) : null;
+    }
+  },
+  stateInit: function() {
+    return {
+      d3ForceLayout: lr().force("link", ur()).force("charge", cr()).force("center", fr()).force("dagRadial", null).stop(),
+      engineRunning: !1
+    };
+  },
+  init: function(e, n) {
+    n.graphScene = e, n.nodeDataMapper = new J(e, {
+      objBindAttr: "__threeObj"
+    }), n.linkDataMapper = new J(e, {
+      objBindAttr: "__lineObj"
+    }), n.arrowDataMapper = new J(e, {
+      objBindAttr: "__arrowObj"
+    }), n.particlesDataMapper = new J(e, {
+      objBindAttr: "__photonsObj"
+    });
+  },
+  update: function(e, n) {
+    var t = function(d) {
+      return d.some(function(b) {
+        return n.hasOwnProperty(b);
+      });
+    };
+    if (e.engineRunning = !1, typeof e.onUpdate == "function" && e.onUpdate(), e.nodeAutoColorBy !== null && t(["nodeAutoColorBy", "graphData", "nodeColor"]) && _e(e.graphData.nodes, w(e.nodeAutoColorBy), e.nodeColor), e.linkAutoColorBy !== null && t(["linkAutoColorBy", "graphData", "linkColor"]) && _e(e.graphData.links, w(e.linkAutoColorBy), e.linkColor), e._flushObjects || t(["graphData", "nodeThreeObject", "nodeThreeObjectExtend", "nodeVal", "nodeColor", "nodeVisibility", "nodeRelSize", "nodeResolution", "nodeOpacity"])) {
+      var i = w(e.nodeThreeObject), c = w(e.nodeThreeObjectExtend), p = w(e.nodeVal), h = w(e.nodeColor), P = w(e.nodeVisibility), _ = {}, T = {};
+      (e._flushObjects || t([
+        // recreate objects if any of these props have changed
+        "nodeThreeObject",
+        "nodeThreeObjectExtend"
+      ])) && e.nodeDataMapper.clear(), e.nodeDataMapper.onCreateObj(function(o) {
+        var d = i(o), b = c(o);
+        d && e.nodeThreeObject === d && (d = d.clone());
+        var y;
+        return d && !b ? y = d : (y = new l.Mesh(), y.__graphDefaultObj = !0, d && b && y.add(d)), y.__graphObjType = "node", y;
+      }).onUpdateObj(function(o, d) {
+        if (o.__graphDefaultObj) {
+          var b = p(d) || 1, y = Math.cbrt(b) * e.nodeRelSize, j = e.nodeResolution;
+          (!o.geometry.type.match(/^Sphere(Buffer)?Geometry$/) || o.geometry.parameters.radius !== y || o.geometry.parameters.widthSegments !== j) && (_.hasOwnProperty(b) || (_[b] = new l.SphereGeometry(y, j, j)), o.geometry.dispose(), o.geometry = _[b]);
+          var R = h(d), x = new l.Color(Q(R || "#ffffaa")), F = e.nodeOpacity * ue(R);
+          (o.material.type !== "MeshLambertMaterial" || !o.material.color.equals(x) || o.material.opacity !== F) && (T.hasOwnProperty(R) || (T[R] = new l.MeshLambertMaterial({
+            color: x,
+            transparent: !0,
+            opacity: F
+          })), o.material.dispose(), o.material = T[R]);
+        }
+      }).digest(e.graphData.nodes.filter(P));
+    }
+    if (e._flushObjects || t(["graphData", "linkThreeObject", "linkThreeObjectExtend", "linkMaterial", "linkColor", "linkWidth", "linkVisibility", "linkResolution", "linkOpacity", "linkDirectionalArrowLength", "linkDirectionalArrowColor", "linkDirectionalArrowResolution", "linkDirectionalParticles", "linkDirectionalParticleWidth", "linkDirectionalParticleColor", "linkDirectionalParticleResolution"])) {
+      var A = w(e.linkThreeObject), O = w(e.linkThreeObjectExtend), g = w(e.linkMaterial), u = w(e.linkVisibility), f = w(e.linkColor), k = w(e.linkWidth), a = {}, v = {}, L = {}, m = e.graphData.links.filter(u);
+      if ((e._flushObjects || t([
+        // recreate objects if any of these props have changed
+        "linkThreeObject",
+        "linkThreeObjectExtend",
+        "linkWidth"
+      ])) && e.linkDataMapper.clear(), e.linkDataMapper.onRemoveObj(function(o) {
+        var d = o.__data && o.__data.__singleHopPhotonsObj;
+        d && (d.parent.remove(d), he(d), delete o.__data.__singleHopPhotonsObj);
+      }).onCreateObj(function(o) {
+        var d = A(o), b = O(o);
+        d && e.linkThreeObject === d && (d = d.clone());
+        var y;
+        if (!d || b) {
+          var j = !!k(o);
+          if (j)
+            y = new l.Mesh();
+          else {
+            var R = new l.BufferGeometry();
+            R[ce]("position", new l.BufferAttribute(new Float32Array(2 * 3), 3)), y = new l.Line(R);
+          }
+        }
+        var x;
+        return d ? b ? (x = new l.Group(), x.__graphDefaultObj = !0, x.add(y), x.add(d)) : x = d : (x = y, x.__graphDefaultObj = !0), x.renderOrder = 10, x.__graphObjType = "link", x;
+      }).onUpdateObj(function(o, d) {
+        if (o.__graphDefaultObj) {
+          var b = o.children.length ? o.children[0] : o, y = Math.ceil(k(d) * 10) / 10, j = !!y;
+          if (j) {
+            var R = y / 2, x = e.linkResolution;
+            if (!b.geometry.type.match(/^Cylinder(Buffer)?Geometry$/) || b.geometry.parameters.radiusTop !== R || b.geometry.parameters.radialSegments !== x) {
+              if (!a.hasOwnProperty(y)) {
+                var F = new l.CylinderGeometry(R, R, 1, x, 1, !1);
+                F[ne](new l.Matrix4().makeTranslation(0, 1 / 2, 0)), F[ne](new l.Matrix4().makeRotationX(Math.PI / 2)), a[y] = F;
+              }
+              b.geometry.dispose(), b.geometry = a[y];
+            }
+          }
+          var K = g(d);
+          if (K)
+            b.material = K;
+          else {
+            var V = f(d), $ = new l.Color(Q(V || "#f0f0f0")), I = e.linkOpacity * ue(V), ee = j ? "MeshLambertMaterial" : "LineBasicMaterial";
+            if (b.material.type !== ee || !b.material.color.equals($) || b.material.opacity !== I) {
+              var oe = j ? v : L;
+              oe.hasOwnProperty(V) || (oe[V] = new l[ee]({
+                color: $,
+                transparent: I < 1,
+                opacity: I,
+                depthWrite: I >= 1
+                // Prevent transparency issues
+              })), b.material.dispose(), b.material = oe[V];
+            }
+          }
+        }
+      }).digest(m), e.linkDirectionalArrowLength || n.hasOwnProperty("linkDirectionalArrowLength")) {
+        var D = w(e.linkDirectionalArrowLength), s = w(e.linkDirectionalArrowColor);
+        e.arrowDataMapper.onCreateObj(function() {
+          var o = new l.Mesh(void 0, new l.MeshLambertMaterial({
+            transparent: !0
+          }));
+          return o.__linkThreeObjType = "arrow", o;
+        }).onUpdateObj(function(o, d) {
+          var b = D(d), y = e.linkDirectionalArrowResolution;
+          if (!o.geometry.type.match(/^Cone(Buffer)?Geometry$/) || o.geometry.parameters.height !== b || o.geometry.parameters.radialSegments !== y) {
+            var j = new l.ConeGeometry(b * 0.25, b, y);
+            j.translate(0, b / 2, 0), j.rotateX(Math.PI / 2), o.geometry.dispose(), o.geometry = j;
+          }
+          var R = s(d) || f(d) || "#f0f0f0";
+          o.material.color = new l.Color(Q(R)), o.material.opacity = e.linkOpacity * 3 * ue(R);
+        }).digest(m.filter(D));
+      }
+      if (e.linkDirectionalParticles || n.hasOwnProperty("linkDirectionalParticles")) {
+        var M = w(e.linkDirectionalParticles), S = w(e.linkDirectionalParticleWidth), G = w(e.linkDirectionalParticleColor), C = {}, E = {};
+        e.particlesDataMapper.onCreateObj(function() {
+          var o = new l.Group();
+          return o.__linkThreeObjType = "photons", o.__photonDataMapper = new J(o), o;
+        }).onUpdateObj(function(o, d) {
+          var b = Math.round(Math.abs(M(d))), y = !!o.children.length && o.children[0], j = Math.ceil(S(d) * 10) / 10 / 2, R = e.linkDirectionalParticleResolution, x;
+          y && y.geometry.parameters.radius === j && y.geometry.parameters.widthSegments === R ? x = y.geometry : (E.hasOwnProperty(j) || (E[j] = new l.SphereGeometry(j, R, R)), x = E[j], y && y.geometry.dispose());
+          var F = G(d) || f(d) || "#f0f0f0", K = new l.Color(Q(F)), V = e.linkOpacity * 3, $;
+          y && y.material.color.equals(K) && y.material.opacity === V ? $ = y.material : (C.hasOwnProperty(F) || (C[F] = new l.MeshLambertMaterial({
+            color: K,
+            transparent: !0,
+            opacity: V
+          })), $ = C[F], y && y.material.dispose()), o.__photonDataMapper.id(function(I) {
+            return I.idx;
+          }).onCreateObj(function() {
+            return new l.Mesh(x, $);
+          }).onUpdateObj(function(I) {
+            I.geometry = x, I.material = $;
+          }).digest(U(new Array(b)).map(function(I, ee) {
+            return {
+              idx: ee
+            };
+          }));
+        }).digest(m.filter(M));
+      }
+    }
+    if (e._flushObjects = !1, t(["graphData", "nodeId", "linkSource", "linkTarget", "numDimensions", "forceEngine", "dagMode", "dagNodeFilter", "dagLevelDistance"])) {
+      e.engineRunning = !1, e.graphData.links.forEach(function(o) {
+        o.source = o[e.linkSource], o.target = o[e.linkTarget];
+      });
+      var z = e.forceEngine !== "ngraph", B;
+      if (z) {
+        (B = e.d3ForceLayout).stop().alpha(1).numDimensions(e.numDimensions).nodes(e.graphData.nodes);
+        var H = e.d3ForceLayout.force("link");
+        H && H.id(function(o) {
+          return o[e.nodeId];
+        }).links(e.graphData.links);
+        var N = e.dagMode && Mr(e.graphData, function(o) {
+          return o[e.nodeId];
+        }, {
+          nodeFilter: e.dagNodeFilter,
+          onLoopError: e.onDagError || void 0
+        }), W = Math.max.apply(Math, U(Object.values(N || []))), Y = e.dagLevelDistance || e.graphData.nodes.length / (W || 1) * xr * (["radialin", "radialout"].indexOf(e.dagMode) !== -1 ? 0.7 : 1);
+        if (["lr", "rl", "td", "bu", "zin", "zout"].includes(n.dagMode)) {
+          var Le = ["lr", "rl"].includes(n.dagMode) ? "fx" : ["td", "bu"].includes(n.dagMode) ? "fy" : "fz";
+          e.graphData.nodes.filter(e.dagNodeFilter).forEach(function(o) {
+            return delete o[Le];
+          });
+        }
+        if (["lr", "rl", "td", "bu", "zin", "zout"].includes(e.dagMode)) {
+          var Be = ["rl", "td", "zout"].includes(e.dagMode), Se = function(d) {
+            return (N[d[e.nodeId]] - W / 2) * Y * (Be ? -1 : 1);
+          }, ze = ["lr", "rl"].includes(e.dagMode) ? "fx" : ["td", "bu"].includes(e.dagMode) ? "fy" : "fz";
+          e.graphData.nodes.filter(e.dagNodeFilter).forEach(function(o) {
+            return o[ze] = Se(o);
+          });
+        }
+        e.d3ForceLayout.force("dagRadial", ["radialin", "radialout"].indexOf(e.dagMode) !== -1 ? ir(function(o) {
+          var d = N[o[e.nodeId]] || -1;
+          return (e.dagMode === "radialin" ? W - d : d) * Y;
+        }).strength(function(o) {
+          return e.dagNodeFilter(o) ? 1 : 0;
+        }) : null);
+      } else {
+        var Z = we.graph();
+        e.graphData.nodes.forEach(function(o) {
+          Z.addNode(o[e.nodeId]);
+        }), e.graphData.links.forEach(function(o) {
+          Z.addLink(o.source, o.target);
+        }), B = we.forcelayout(Z, Or({
+          dimensions: e.numDimensions
+        }, e.ngraphPhysics)), B.graph = Z;
+      }
+      for (var ye = 0; ye < e.warmupTicks && !(z && e.d3AlphaMin > 0 && e.d3ForceLayout.alpha() < e.d3AlphaMin); ye++)
+        B[z ? "tick" : "step"]();
+      e.layout = B, this.resetCountdown();
+    }
+    e.engineRunning = !0, e.onFinishUpdate();
+  }
+});
+function Tr(r) {
+  var e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : Object, n = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : !1, t = /* @__PURE__ */ function(i) {
+    function c() {
+      var p;
+      Ce(this, c);
+      for (var h = arguments.length, P = new Array(h), _ = 0; _ < h; _++)
+        P[_] = arguments[_];
+      return p = Pe(this, c, [].concat(P)), p.__kapsuleInstance = Me(r, [].concat(U(n ? [p] : []), P)), p;
+    }
+    return Ae(c, i), xe(c);
+  }(e);
+  return Object.keys(r()).forEach(function(i) {
+    return t.prototype[i] = function() {
+      var c, p = (c = this.__kapsuleInstance)[i].apply(c, arguments);
+      return p === this.__kapsuleInstance ? this : p;
+    };
+  }), t;
+}
+var jr = window.THREE ? window.THREE : {
+  Group: ke
+}, Qr = Tr(Ar, jr.Group, !0);
+export {
+  Qr as default
+};