@xiping/react-components 1.0.20 → 1.0.21

package/dist/es/node_modules/.pnpm/three-forcegraph@1.43.0_three@0.178.0/node_modules/three-forcegraph/dist/three-forcegraph.js

@@ -0,0 +1,1037 @@
+import "../../../../three@0.178.0/node_modules/three/build/three.module.js";
+import Ue from "../../../../../../_virtual/index4.js";
+import Ie from "../../../../../../_virtual/index5.js";
+import Ge from "../../../../kapsule@1.16.3/node_modules/kapsule/dist/kapsule.js";
+import v from "../../../../accessor-fn@1.5.3/node_modules/accessor-fn/dist/accessor-fn.js";
+import Ve from "../../../../data-bind-mapper@1.0.3/node_modules/data-bind-mapper/dist/data-bind-mapper.js";
+import ke from "../../../../tinycolor2@1.6.0/node_modules/tinycolor2/esm/tinycolor.js";
+import { Group as De, Mesh as He, SphereGeometry as Ne, Color as We, MeshLambertMaterial as $e, BufferGeometry as qe, BufferAttribute as Ke, Line as Je, CylinderGeometry as Qe, Matrix4 as Xe, Box3 as Ye, CubicBezierCurve3 as Ze, QuadraticBezierCurve3 as er, LineBasicMaterial as rr, ConeGeometry as nr, TubeGeometry as tr, Vector3 as or } from "../../../../three@0.178.0/node_modules/three/build/three.core.js";
+import ar from "../../../../d3-force-3d@3.0.6/node_modules/d3-force-3d/src/radial.js";
+import ir from "../../../../d3-force-3d@3.0.6/node_modules/d3-force-3d/src/simulation.js";
+import lr from "../../../../d3-force-3d@3.0.6/node_modules/d3-force-3d/src/link.js";
+import ur from "../../../../d3-force-3d@3.0.6/node_modules/d3-force-3d/src/manyBody.js";
+import cr from "../../../../d3-force-3d@3.0.6/node_modules/d3-force-3d/src/center.js";
+import fr from "../../../../d3-array@3.2.4/node_modules/d3-array/src/min.js";
+import dr from "../../../../d3-array@3.2.4/node_modules/d3-array/src/max.js";
+import pr from "../../../../d3-scale@4.0.2/node_modules/d3-scale/src/ordinal.js";
+import sr 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 hr(r) {
+  if (Array.isArray(r)) return r;
+}
+function gr(r) {
+  if (Array.isArray(r)) return fe(r);
+}
+function Pe(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 yr(r) {
+  if (r === void 0) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return r;
+}
+function Me(r, e, n) {
+  return e = K(e), Dr(r, ge() ? Reflect.construct(e, n || [], K(r).constructor) : e.apply(r, n));
+}
+function vr(r, e) {
+  if (e.has(r)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function xe(r, e) {
+  if (!(r instanceof e)) throw new TypeError("Cannot call a class as a function");
+}
+function ae(r, e) {
+  return r.get(Pe(r, e));
+}
+function me(r, e, n) {
+  vr(r, e), e.set(r, n);
+}
+function be(r, e, n) {
+  return r.set(Pe(r, e), n), n;
+}
+function Ce(r, e, n) {
+  if (ge()) return Reflect.construct.apply(null, arguments);
+  var t = [null];
+  t.push.apply(t, e);
+  var a = new (r.bind.apply(r, t))();
+  return a;
+}
+function mr(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, je(t.key), t);
+  }
+}
+function Te(r, e, n) {
+  return e && mr(r.prototype, e), Object.defineProperty(r, "prototype", {
+    writable: !1
+  }), r;
+}
+function oe(r, e, n) {
+  return (e = je(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 = Pr(r, e);
+    if (t) {
+      var a = Object.getOwnPropertyDescriptor(t, e);
+      return a.get ? a.get.call(arguments.length < 3 ? r : n) : a.value;
+    }
+  }, de.apply(null, arguments);
+}
+function K(r) {
+  return K = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(e) {
+    return e.__proto__ || Object.getPrototypeOf(e);
+  }, K(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 br(r) {
+  if (typeof Symbol < "u" && r[Symbol.iterator] != null || r["@@iterator"] != null) return Array.from(r);
+}
+function _r(r, e) {
+  var n = r == null ? null : typeof Symbol < "u" && r[Symbol.iterator] || r["@@iterator"];
+  if (n != null) {
+    var t, a, c, s, m = [], y = !0, k = !1;
+    try {
+      if (c = (n = n.call(r)).next, e !== 0) for (; !(y = (t = c.call(n)).done) && (m.push(t.value), m.length !== e); y = !0) ;
+    } catch (R) {
+      k = !0, a = R;
+    } finally {
+      try {
+        if (!y && n.return != null && (s = n.return(), Object(s) !== s)) return;
+      } finally {
+        if (k) throw a;
+      }
+    }
+    return m;
+  }
+}
+function wr() {
+  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 Or() {
+  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 _e(r, e) {
+  var n = Object.keys(r);
+  if (Object.getOwnPropertySymbols) {
+    var t = Object.getOwnPropertySymbols(r);
+    e && (t = t.filter(function(a) {
+      return Object.getOwnPropertyDescriptor(r, a).enumerable;
+    })), n.push.apply(n, t);
+  }
+  return n;
+}
+function kr(r) {
+  for (var e = 1; e < arguments.length; e++) {
+    var n = arguments[e] != null ? arguments[e] : {};
+    e % 2 ? _e(Object(n), !0).forEach(function(t) {
+      oe(r, t, n[t]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(r, Object.getOwnPropertyDescriptors(n)) : _e(Object(n)).forEach(function(t) {
+      Object.defineProperty(r, t, Object.getOwnPropertyDescriptor(n, t));
+    });
+  }
+  return r;
+}
+function Dr(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 yr(r);
+}
+function pe(r, e) {
+  return pe = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(n, t) {
+    return n.__proto__ = t, n;
+  }, pe(r, e);
+}
+function ee(r, e) {
+  return hr(r) || _r(r, e) || Re(r, e) || wr();
+}
+function Pr(r, e) {
+  for (; !{}.hasOwnProperty.call(r, e) && (r = K(r)) !== null; ) ;
+  return r;
+}
+function ie(r, e, n, t) {
+  var a = de(K(r.prototype), e, n);
+  return typeof a == "function" ? function(c) {
+    return a.apply(n, c);
+  } : a;
+}
+function F(r) {
+  return gr(r) || br(r) || Re(r) || Or();
+}
+function Mr(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 je(r) {
+  var e = Mr(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 Re(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 Ee = function(e) {
+  e instanceof Array ? e.forEach(Ee) : (e.map && e.map.dispose(), e.dispose());
+}, Le = function(e) {
+  e.geometry && e.geometry.dispose(), e.material && Ee(e.material), e.texture && e.texture.dispose(), e.children && e.children.forEach(Le);
+}, he = function(e) {
+  for (; e.children.length; ) {
+    var n = e.children[0];
+    e.remove(n), Le(n);
+  }
+}, le = /* @__PURE__ */ new WeakMap(), ne = /* @__PURE__ */ new WeakMap(), Y = /* @__PURE__ */ function(r) {
+  function e(n) {
+    var t, a = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, c = a.dataBindAttr, s = c === void 0 ? "__data" : c, m = a.objBindAttr, y = m === void 0 ? "__threeObj" : m;
+    return xe(this, e), t = Me(this, e), oe(t, "scene", void 0), me(t, le, void 0), me(t, ne, void 0), t.scene = n, be(le, t, s), be(ne, t, y), t.onRemoveObj(function() {
+    }), t;
+  }
+  return Ae(e, r), Te(e, [{
+    key: "onCreateObj",
+    value: function(t) {
+      var a = this;
+      return ie(e, "onCreateObj", this)([function(c) {
+        var s = t(c);
+        return c[ae(ne, a)] = s, s[ae(le, a)] = c, a.scene.add(s), s;
+      }]), this;
+    }
+  }, {
+    key: "onRemoveObj",
+    value: function(t) {
+      var a = this;
+      return ie(e, "onRemoveObj", this)([function(c, s) {
+        var m = ie(e, "getData", a)([c]);
+        t(c, s), a.scene.remove(c), he(c), delete m[ae(ne, a)];
+      }]), this;
+    }
+  }]);
+}(Ve), Z = function(e) {
+  return isNaN(e) ? parseInt(ke(e).toHex(), 16) : e;
+}, ue = function(e) {
+  return isNaN(e) ? ke(e).getAlpha() : 1;
+}, xr = pr(sr);
+function we(r, e, n) {
+  !e || typeof n != "string" || r.filter(function(t) {
+    return !t[n];
+  }).forEach(function(t) {
+    t[n] = xr(e(t));
+  });
+}
+function Cr(r, e) {
+  var n = r.nodes, t = r.links, a = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}, c = a.nodeFilter, s = c === void 0 ? function() {
+    return !0;
+  } : c, m = a.onLoopError, y = m === void 0 ? function(g) {
+    throw "Invalid DAG structure! Found cycle in node path: ".concat(g.join(" -> "), ".");
+  } : m, k = {};
+  n.forEach(function(g) {
+    return k[e(g)] = {
+      data: g,
+      out: [],
+      depth: -1,
+      skip: !s(g)
+    };
+  }), t.forEach(function(g) {
+    var i = g.source, f = g.target, w = _(i), h = _(f);
+    if (!k.hasOwnProperty(w)) throw "Missing source node with id: ".concat(w);
+    if (!k.hasOwnProperty(h)) throw "Missing target node with id: ".concat(h);
+    var O = k[w], b = k[h];
+    O.out.push(b);
+    function _(P) {
+      return se(P) === "object" ? e(P) : P;
+    }
+  });
+  var R = [];
+  x(Object.values(k));
+  var j = Object.assign.apply(Object, [{}].concat(F(Object.entries(k).filter(function(g) {
+    var i = ee(g, 2), f = i[1];
+    return !f.skip;
+  }).map(function(g) {
+    var i = ee(g, 2), f = i[0], w = i[1];
+    return oe({}, f, w.depth);
+  }))));
+  return j;
+  function x(g) {
+    for (var i = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : [], f = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 0, w = function() {
+      var _ = g[h];
+      if (i.indexOf(_) !== -1) {
+        var P = [].concat(F(i.slice(i.indexOf(_))), [_]).map(function(p) {
+          return e(p.data);
+        });
+        return R.some(function(p) {
+          return p.length === P.length && p.every(function(D, L) {
+            return D === P[L];
+          });
+        }) || (R.push(P), y(P)), 1;
+      }
+      f > _.depth && (_.depth = f, x(_.out, [].concat(F(i), [_]), f + (_.skip ? 0 : 1)));
+    }, h = 0, O = g.length; h < O; h++)
+      w();
+  }
+}
+var l = window.THREE ? window.THREE : {
+  Group: De,
+  Mesh: He,
+  MeshLambertMaterial: $e,
+  Color: We,
+  BufferGeometry: qe,
+  BufferAttribute: Ke,
+  Matrix4: Xe,
+  Vector3: or,
+  SphereGeometry: Ne,
+  CylinderGeometry: Qe,
+  TubeGeometry: tr,
+  ConeGeometry: nr,
+  Line: Je,
+  LineBasicMaterial: rr,
+  QuadraticBezierCurve3: er,
+  CubicBezierCurve3: Ze,
+  Box3: Ye
+}, Oe = {
+  graph: Ue,
+  forcelayout: Ie
+}, Tr = 2, ce = new l.BufferGeometry().setAttribute ? "setAttribute" : "addAttribute", te = new l.BufferGeometry().applyMatrix4 ? "applyMatrix4" : "applyMatrix", Ar = Ge({
+  props: {
+    jsonUrl: {
+      onChange: function(e, n) {
+        var t = this;
+        e && !n.fetchingJson && (n.fetchingJson = !0, n.onLoading(), fetch(e).then(function(a) {
+          return a.json();
+        }).then(function(a) {
+          n.fetchingJson = !1, n.onFinishLoading(a), t.graphData(a);
+        }));
+      },
+      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 && a(n.graphData.nodes, "z"), e < 2 && a(n.graphData.nodes, "y");
+        function a(c, s) {
+          c.forEach(function(m) {
+            delete m[s], delete m["v".concat(s)];
+          });
+        }
+      }
+    },
+    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
+    linkDirectionalParticleOffset: {
+      default: 0,
+      triggerUpdate: !1
+    },
+    // starting position offset along the link's length, like a pre-delay. Values between [0, 1]
+    linkDirectionalParticleWidth: {
+      default: 0.5
+    },
+    linkDirectionalParticleColor: {},
+    linkDirectionalParticleResolution: {
+      default: 4
+    },
+    // how many slice segments in the particle sphere's circumference
+    linkDirectionalParticleThreeObject: {},
+    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(), a(), 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 s = v(e.nodeThreeObjectExtend);
+        e.nodeDataMapper.entries().forEach(function(x) {
+          var g = ee(x, 2), i = g[0], f = g[1];
+          if (f) {
+            var w = n ? i : e.layout.getNodePosition(i[e.nodeId]), h = s(i);
+            (!e.nodePositionUpdate || !e.nodePositionUpdate(h ? f.children[0] : f, {
+              x: w.x,
+              y: w.y,
+              z: w.z
+            }, i) || h) && (f.position.x = w.x, f.position.y = w.y || 0, f.position.z = w.z || 0);
+          }
+        });
+        var m = v(e.linkWidth), y = v(e.linkCurvature), k = v(e.linkCurveRotation), R = v(e.linkThreeObjectExtend);
+        e.linkDataMapper.entries().forEach(function(x) {
+          var g = ee(x, 2), i = g[0], f = g[1];
+          if (f) {
+            var w = n ? i : e.layout.getLinkPosition(e.layout.graph.getLink(i.source, i.target).id), h = w[n ? "source" : "from"], O = w[n ? "target" : "to"];
+            if (!(!h || !O || !h.hasOwnProperty("x") || !O.hasOwnProperty("x"))) {
+              j(i);
+              var b = R(i);
+              if (!(e.linkPositionUpdate && e.linkPositionUpdate(
+                b ? f.children[1] : f,
+                // pass child custom object if extending the default
+                {
+                  start: {
+                    x: h.x,
+                    y: h.y,
+                    z: h.z
+                  },
+                  end: {
+                    x: O.x,
+                    y: O.y,
+                    z: O.z
+                  }
+                },
+                i
+              ) && !b)) {
+                var _ = 30, P = i.__curve, p = f.children.length ? f.children[0] : f;
+                if (p.type === "Line") {
+                  if (P) {
+                    var L = P.getPoints(_);
+                    p.geometry.getAttribute("position").array.length !== L.length * 3 && p.geometry[ce]("position", new l.BufferAttribute(new Float32Array(L.length * 3), 3)), p.geometry.setFromPoints(L);
+                  } else {
+                    var D = p.geometry.getAttribute("position");
+                    (!D || !D.array || D.array.length !== 6) && p.geometry[ce]("position", D = new l.BufferAttribute(new Float32Array(2 * 3), 3)), D.array[0] = h.x, D.array[1] = h.y || 0, D.array[2] = h.z || 0, D.array[3] = O.x, D.array[4] = O.y || 0, D.array[5] = O.z || 0, D.needsUpdate = !0;
+                  }
+                  p.geometry.computeBoundingSphere();
+                } else if (p.type === "Mesh")
+                  if (P) {
+                    p.geometry.type.match(/^Tube(Buffer)?Geometry$/) || (p.position.set(0, 0, 0), p.rotation.set(0, 0, 0), p.scale.set(1, 1, 1));
+                    var $ = Math.ceil(m(i) * 10) / 10, N = $ / 2, J = new l.TubeGeometry(P, _, N, e.linkResolution, !1);
+                    p.geometry.dispose(), p.geometry = J;
+                  } else {
+                    if (!p.geometry.type.match(/^Cylinder(Buffer)?Geometry$/)) {
+                      var U = Math.ceil(m(i) * 10) / 10, C = U / 2, B = new l.CylinderGeometry(C, C, 1, e.linkResolution, 1, !1);
+                      B[te](new l.Matrix4().makeTranslation(0, 1 / 2, 0)), B[te](new l.Matrix4().makeRotationX(Math.PI / 2)), p.geometry.dispose(), p.geometry = B;
+                    }
+                    var z = new l.Vector3(h.x, h.y || 0, h.z || 0), S = new l.Vector3(O.x, O.y || 0, O.z || 0), I = z.distanceTo(S);
+                    p.position.x = z.x, p.position.y = z.y, p.position.z = z.z, p.scale.z = I, p.parent.localToWorld(S), p.lookAt(S);
+                  }
+              }
+            }
+          }
+        });
+        function j(x) {
+          var g = n ? x : e.layout.getLinkPosition(e.layout.graph.getLink(x.source, x.target).id), i = g[n ? "source" : "from"], f = g[n ? "target" : "to"];
+          if (!(!i || !f || !i.hasOwnProperty("x") || !f.hasOwnProperty("x"))) {
+            var w = y(x);
+            if (!w)
+              x.__curve = null;
+            else {
+              var h = new l.Vector3(i.x, i.y || 0, i.z || 0), O = new l.Vector3(f.x, f.y || 0, f.z || 0), b = h.distanceTo(O), _, P = k(x);
+              if (b > 0) {
+                var p = f.x - i.x, D = f.y - i.y || 0, L = new l.Vector3().subVectors(O, h), U = L.clone().multiplyScalar(w).cross(p !== 0 || D !== 0 ? new l.Vector3(0, 0, 1) : new l.Vector3(0, 1, 0)).applyAxisAngle(L.normalize(), P).add(new l.Vector3().addVectors(h, O).divideScalar(2));
+                _ = new l.QuadraticBezierCurve3(h, U, O);
+              } else {
+                var C = w * 70, B = -P, z = B + Math.PI / 2;
+                _ = new l.CubicBezierCurve3(h, new l.Vector3(C * Math.cos(z), C * Math.sin(z), 0).add(h), new l.Vector3(C * Math.cos(B), C * Math.sin(B), 0).add(h), O);
+              }
+              x.__curve = _;
+            }
+          }
+        }
+      }
+      function a() {
+        var s = v(e.linkDirectionalArrowRelPos), m = v(e.linkDirectionalArrowLength), y = v(e.nodeVal);
+        e.arrowDataMapper.entries().forEach(function(k) {
+          var R = ee(k, 2), j = R[0], x = R[1];
+          if (x) {
+            var g = n ? j : e.layout.getLinkPosition(e.layout.graph.getLink(j.source, j.target).id), i = g[n ? "source" : "from"], f = g[n ? "target" : "to"];
+            if (!(!i || !f || !i.hasOwnProperty("x") || !f.hasOwnProperty("x"))) {
+              var w = Math.cbrt(Math.max(0, y(i) || 1)) * e.nodeRelSize, h = Math.cbrt(Math.max(0, y(f) || 1)) * e.nodeRelSize, O = m(j), b = s(j), _ = j.__curve ? function(C) {
+                return j.__curve.getPoint(C);
+              } : function(C) {
+                var B = function(S, I, $, N) {
+                  return I[S] + ($[S] - I[S]) * N || 0;
+                };
+                return {
+                  x: B("x", i, f, C),
+                  y: B("y", i, f, C),
+                  z: B("z", i, f, C)
+                };
+              }, P = j.__curve ? j.__curve.getLength() : Math.sqrt(["x", "y", "z"].map(function(C) {
+                return Math.pow((f[C] || 0) - (i[C] || 0), 2);
+              }).reduce(function(C, B) {
+                return C + B;
+              }, 0)), p = w + O + (P - w - h - O) * b, D = _(p / P), L = _((p - O) / P);
+              ["x", "y", "z"].forEach(function(C) {
+                return x.position[C] = L[C];
+              });
+              var U = Ce(l.Vector3, F(["x", "y", "z"].map(function(C) {
+                return D[C];
+              })));
+              x.parent.localToWorld(U), x.lookAt(U);
+            }
+          }
+        });
+      }
+      function c() {
+        var s = v(e.linkDirectionalParticleSpeed), m = v(e.linkDirectionalParticleOffset);
+        e.graphData.links.forEach(function(y) {
+          var k = e.particlesDataMapper.getObj(y), R = k && k.children, j = y.__singleHopPhotonsObj && y.__singleHopPhotonsObj.children;
+          if (!((!j || !j.length) && (!R || !R.length))) {
+            var x = n ? y : e.layout.getLinkPosition(e.layout.graph.getLink(y.source, y.target).id), g = x[n ? "source" : "from"], i = x[n ? "target" : "to"];
+            if (!(!g || !i || !g.hasOwnProperty("x") || !i.hasOwnProperty("x"))) {
+              var f = s(y), w = Math.abs(m(y)), h = y.__curve ? function(b) {
+                return y.__curve.getPoint(b);
+              } : function(b) {
+                var _ = function(p, D, L, U) {
+                  return D[p] + (L[p] - D[p]) * U || 0;
+                };
+                return {
+                  x: _("x", g, i, b),
+                  y: _("y", g, i, b),
+                  z: _("z", g, i, b)
+                };
+              }, O = [].concat(F(R || []), F(j || []));
+              O.forEach(function(b, _) {
+                var P = b.parent.__linkThreeObjType === "singleHopPhotons";
+                if (b.hasOwnProperty("__progressRatio") || (b.__progressRatio = P ? 0 : (_ + w) / R.length), b.__progressRatio += f, b.__progressRatio >= 1)
+                  if (!P)
+                    b.__progressRatio = b.__progressRatio % 1;
+                  else {
+                    b.parent.remove(b), he(b);
+                    return;
+                  }
+                var p = b.__progressRatio, D = h(p);
+                b.geometry.type !== "SphereGeometry" && b.lookAt(D.x, D.y, D.z), ["x", "y", "z"].forEach(function(L) {
+                  return b.position[L] = D[L];
+                });
+              });
+            }
+          }
+        });
+      }
+    },
+    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 a = v(e.linkDirectionalParticleThreeObject)(n);
+        if (a && e.linkDirectionalParticleThreeObject === a && (a = a.clone()), !a) {
+          var c = v(e.linkDirectionalParticleWidth), s = Math.ceil(c(n) * 10) / 10 / 2, m = e.linkDirectionalParticleResolution, y = new l.SphereGeometry(s, m, m), k = v(e.linkColor), R = v(e.linkDirectionalParticleColor), j = R(n) || k(n) || "#f0f0f0", x = new l.Color(Z(j)), g = e.linkOpacity * 3, i = new l.MeshLambertMaterial({
+            color: x,
+            transparent: !0,
+            opacity: g
+          });
+          a = new l.Mesh(y, i);
+        }
+        n.__singleHopPhotonsObj.add(a);
+      }
+      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 a(c) {
+        var s = [];
+        if (c.geometry) {
+          c.geometry.computeBoundingBox();
+          var m = new l.Box3();
+          m.copy(c.geometry.boundingBox).applyMatrix4(c.matrixWorld), s.push(m);
+        }
+        return s.concat.apply(s, F((c.children || []).filter(
+          function(y) {
+            return !y.hasOwnProperty("__graphObjType") || y.__graphObjType === "node" && n(y.__data);
+          }
+          // exclude filtered out nodes
+        ).map(a)));
+      }(e.graphScene);
+      return t.length ? Object.assign.apply(Object, F(["x", "y", "z"].map(function(a) {
+        return oe({}, a, [fr(t, function(c) {
+          return c.min[a];
+        }), dr(t, function(c) {
+          return c.max[a];
+        })]);
+      }))) : null;
+    }
+  },
+  stateInit: function() {
+    return {
+      d3ForceLayout: ir().force("link", lr()).force("charge", ur()).force("center", cr()).force("dagRadial", null).stop(),
+      engineRunning: !1
+    };
+  },
+  init: function(e, n) {
+    n.graphScene = e, n.nodeDataMapper = new Y(e, {
+      objBindAttr: "__threeObj"
+    }), n.linkDataMapper = new Y(e, {
+      objBindAttr: "__lineObj"
+    }), n.arrowDataMapper = new Y(e, {
+      objBindAttr: "__arrowObj"
+    }), n.particlesDataMapper = new Y(e, {
+      objBindAttr: "__photonsObj"
+    });
+  },
+  update: function(e, n) {
+    var t = function(u) {
+      return u.some(function(d) {
+        return n.hasOwnProperty(d);
+      });
+    };
+    if (e.engineRunning = !1, typeof e.onUpdate == "function" && e.onUpdate(), e.nodeAutoColorBy !== null && t(["nodeAutoColorBy", "graphData", "nodeColor"]) && we(e.graphData.nodes, v(e.nodeAutoColorBy), e.nodeColor), e.linkAutoColorBy !== null && t(["linkAutoColorBy", "graphData", "linkColor"]) && we(e.graphData.links, v(e.linkAutoColorBy), e.linkColor), e._flushObjects || t(["graphData", "nodeThreeObject", "nodeThreeObjectExtend", "nodeVal", "nodeColor", "nodeVisibility", "nodeRelSize", "nodeResolution", "nodeOpacity"])) {
+      var a = v(e.nodeThreeObject), c = v(e.nodeThreeObjectExtend), s = v(e.nodeVal), m = v(e.nodeColor), y = v(e.nodeVisibility), k = {}, R = {};
+      (e._flushObjects || t([
+        // recreate objects if any of these props have changed
+        "nodeThreeObject",
+        "nodeThreeObjectExtend"
+      ])) && e.nodeDataMapper.clear(), e.nodeDataMapper.onCreateObj(function(o) {
+        var u = a(o), d = c(o);
+        u && e.nodeThreeObject === u && (u = u.clone());
+        var M;
+        return u && !d ? M = u : (M = new l.Mesh(), M.__graphDefaultObj = !0, u && d && M.add(u)), M.__graphObjType = "node", M;
+      }).onUpdateObj(function(o, u) {
+        if (o.__graphDefaultObj) {
+          var d = s(u) || 1, M = Math.cbrt(d) * e.nodeRelSize, E = e.nodeResolution;
+          (!o.geometry.type.match(/^Sphere(Buffer)?Geometry$/) || o.geometry.parameters.radius !== M || o.geometry.parameters.widthSegments !== E) && (k.hasOwnProperty(d) || (k[d] = new l.SphereGeometry(M, E, E)), o.geometry.dispose(), o.geometry = k[d]);
+          var T = m(u), A = new l.Color(Z(T || "#ffffaa")), G = e.nodeOpacity * ue(T);
+          (o.material.type !== "MeshLambertMaterial" || !o.material.color.equals(A) || o.material.opacity !== G) && (R.hasOwnProperty(T) || (R[T] = new l.MeshLambertMaterial({
+            color: A,
+            transparent: !0,
+            opacity: G
+          })), o.material.dispose(), o.material = R[T]);
+        }
+      }).digest(e.graphData.nodes.filter(y));
+    }
+    if (e._flushObjects || t(["graphData", "linkThreeObject", "linkThreeObjectExtend", "linkMaterial", "linkColor", "linkWidth", "linkVisibility", "linkResolution", "linkOpacity", "linkDirectionalArrowLength", "linkDirectionalArrowColor", "linkDirectionalArrowResolution", "linkDirectionalParticles", "linkDirectionalParticleWidth", "linkDirectionalParticleColor", "linkDirectionalParticleResolution", "linkDirectionalParticleThreeObject"])) {
+      var j = v(e.linkThreeObject), x = v(e.linkThreeObjectExtend), g = v(e.linkMaterial), i = v(e.linkVisibility), f = v(e.linkColor), w = v(e.linkWidth), h = {}, O = {}, b = {}, _ = e.graphData.links.filter(i);
+      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 u = o.__data && o.__data.__singleHopPhotonsObj;
+        u && (u.parent.remove(u), he(u), delete o.__data.__singleHopPhotonsObj);
+      }).onCreateObj(function(o) {
+        var u = j(o), d = x(o);
+        u && e.linkThreeObject === u && (u = u.clone());
+        var M;
+        if (!u || d) {
+          var E = !!w(o);
+          if (E)
+            M = new l.Mesh();
+          else {
+            var T = new l.BufferGeometry();
+            T[ce]("position", new l.BufferAttribute(new Float32Array(2 * 3), 3)), M = new l.Line(T);
+          }
+        }
+        var A;
+        return u ? d ? (A = new l.Group(), A.__graphDefaultObj = !0, A.add(M), A.add(u)) : A = u : (A = M, A.__graphDefaultObj = !0), A.renderOrder = 10, A.__graphObjType = "link", A;
+      }).onUpdateObj(function(o, u) {
+        if (o.__graphDefaultObj) {
+          var d = o.children.length ? o.children[0] : o, M = Math.ceil(w(u) * 10) / 10, E = !!M;
+          if (E) {
+            var T = M / 2, A = e.linkResolution;
+            if (!d.geometry.type.match(/^Cylinder(Buffer)?Geometry$/) || d.geometry.parameters.radiusTop !== T || d.geometry.parameters.radialSegments !== A) {
+              if (!h.hasOwnProperty(M)) {
+                var G = new l.CylinderGeometry(T, T, 1, A, 1, !1);
+                G[te](new l.Matrix4().makeTranslation(0, 1 / 2, 0)), G[te](new l.Matrix4().makeRotationX(Math.PI / 2)), h[M] = G;
+              }
+              d.geometry.dispose(), d.geometry = h[M];
+            }
+          }
+          var W = g(u);
+          if (W)
+            d.material = W;
+          else {
+            var V = f(u), Q = new l.Color(Z(V || "#f0f0f0")), q = e.linkOpacity * ue(V), H = E ? "MeshLambertMaterial" : "LineBasicMaterial";
+            if (d.material.type !== H || !d.material.color.equals(Q) || d.material.opacity !== q) {
+              var X = E ? O : b;
+              X.hasOwnProperty(V) || (X[V] = new l[H]({
+                color: Q,
+                transparent: q < 1,
+                opacity: q,
+                depthWrite: q >= 1
+                // Prevent transparency issues
+              })), d.material.dispose(), d.material = X[V];
+            }
+          }
+        }
+      }).digest(_), e.linkDirectionalArrowLength || n.hasOwnProperty("linkDirectionalArrowLength")) {
+        var P = v(e.linkDirectionalArrowLength), p = v(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, u) {
+          var d = P(u), M = e.linkDirectionalArrowResolution;
+          if (!o.geometry.type.match(/^Cone(Buffer)?Geometry$/) || o.geometry.parameters.height !== d || o.geometry.parameters.radialSegments !== M) {
+            var E = new l.ConeGeometry(d * 0.25, d, M);
+            E.translate(0, d / 2, 0), E.rotateX(Math.PI / 2), o.geometry.dispose(), o.geometry = E;
+          }
+          var T = p(u) || f(u) || "#f0f0f0";
+          o.material.color = new l.Color(Z(T)), o.material.opacity = e.linkOpacity * 3 * ue(T);
+        }).digest(_.filter(P));
+      }
+      if (e.linkDirectionalParticles || n.hasOwnProperty("linkDirectionalParticles")) {
+        var D = v(e.linkDirectionalParticles), L = v(e.linkDirectionalParticleWidth), U = v(e.linkDirectionalParticleColor), C = v(e.linkDirectionalParticleThreeObject), B = {}, z = {};
+        e.particlesDataMapper.onCreateObj(function() {
+          var o = new l.Group();
+          return o.__linkThreeObjType = "photons", o.__photonDataMapper = new Y(o), o;
+        }).onUpdateObj(function(o, u) {
+          var d = !!o.children.length && o.children[0], M = C(u), E, T;
+          if (M)
+            E = M.geometry, T = M.material;
+          else {
+            var A = Math.ceil(L(u) * 10) / 10 / 2, G = e.linkDirectionalParticleResolution;
+            d && d.geometry.parameters.radius === A && d.geometry.parameters.widthSegments === G ? E = d.geometry : (z.hasOwnProperty(A) || (z[A] = new l.SphereGeometry(A, G, G)), E = z[A]);
+            var W = U(u) || f(u) || "#f0f0f0", V = new l.Color(Z(W)), Q = e.linkOpacity * 3;
+            d && d.material.color.equals(V) && d.material.opacity === Q ? T = d.material : (B.hasOwnProperty(W) || (B[W] = new l.MeshLambertMaterial({
+              color: V,
+              transparent: !0,
+              opacity: Q
+            })), T = B[W]);
+          }
+          d && (d.geometry !== E && d.geometry.dispose(), d.material !== T && d.material.dispose());
+          var q = Math.round(Math.abs(D(u)));
+          o.__photonDataMapper.id(function(H) {
+            return H.idx;
+          }).onCreateObj(function() {
+            return new l.Mesh(E, T);
+          }).onUpdateObj(function(H) {
+            H.geometry = E, H.material = T;
+          }).digest(F(new Array(q)).map(function(H, X) {
+            return {
+              idx: X
+            };
+          }));
+        }).digest(_.filter(D));
+      }
+    }
+    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 S = e.forceEngine !== "ngraph", I;
+      if (S) {
+        (I = e.d3ForceLayout).stop().alpha(1).numDimensions(e.numDimensions).nodes(e.graphData.nodes);
+        var $ = e.d3ForceLayout.force("link");
+        $ && $.id(function(o) {
+          return o[e.nodeId];
+        }).links(e.graphData.links);
+        var N = e.dagMode && Cr(e.graphData, function(o) {
+          return o[e.nodeId];
+        }, {
+          nodeFilter: e.dagNodeFilter,
+          onLoopError: e.onDagError || void 0
+        }), J = Math.max.apply(Math, F(Object.values(N || []))), ye = e.dagLevelDistance || e.graphData.nodes.length / (J || 1) * Tr * (["radialin", "radialout"].indexOf(e.dagMode) !== -1 ? 0.7 : 1);
+        if (["lr", "rl", "td", "bu", "zin", "zout"].includes(n.dagMode)) {
+          var Be = ["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[Be];
+          });
+        }
+        if (["lr", "rl", "td", "bu", "zin", "zout"].includes(e.dagMode)) {
+          var ze = ["rl", "td", "zout"].includes(e.dagMode), Se = function(u) {
+            return (N[u[e.nodeId]] - J / 2) * ye * (ze ? -1 : 1);
+          }, Fe = ["lr", "rl"].includes(e.dagMode) ? "fx" : ["td", "bu"].includes(e.dagMode) ? "fy" : "fz";
+          e.graphData.nodes.filter(e.dagNodeFilter).forEach(function(o) {
+            return o[Fe] = Se(o);
+          });
+        }
+        e.d3ForceLayout.force("dagRadial", ["radialin", "radialout"].indexOf(e.dagMode) !== -1 ? ar(function(o) {
+          var u = N[o[e.nodeId]] || -1;
+          return (e.dagMode === "radialin" ? J - u : u) * ye;
+        }).strength(function(o) {
+          return e.dagNodeFilter(o) ? 1 : 0;
+        }) : null);
+      } else {
+        var re = Oe.graph();
+        e.graphData.nodes.forEach(function(o) {
+          re.addNode(o[e.nodeId]);
+        }), e.graphData.links.forEach(function(o) {
+          re.addLink(o.source, o.target);
+        }), I = Oe.forcelayout(re, kr({
+          dimensions: e.numDimensions
+        }, e.ngraphPhysics)), I.graph = re;
+      }
+      for (var ve = 0; ve < e.warmupTicks && !(S && e.d3AlphaMin > 0 && e.d3ForceLayout.alpha() < e.d3AlphaMin); ve++)
+        I[S ? "tick" : "step"]();
+      e.layout = I, this.resetCountdown();
+    }
+    e.engineRunning = !0, e.onFinishUpdate();
+  }
+});
+function jr(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(a) {
+    function c() {
+      var s;
+      xe(this, c);
+      for (var m = arguments.length, y = new Array(m), k = 0; k < m; k++)
+        y[k] = arguments[k];
+      return s = Me(this, c, [].concat(y)), s.__kapsuleInstance = Ce(r, [].concat(F(n ? [s] : []), y)), s;
+    }
+    return Ae(c, a), Te(c);
+  }(e);
+  return Object.keys(r()).forEach(function(a) {
+    return t.prototype[a] = function() {
+      var c, s = (c = this.__kapsuleInstance)[a].apply(c, arguments);
+      return s === this.__kapsuleInstance ? this : s;
+    };
+  }), t;
+}
+var Rr = window.THREE ? window.THREE : {
+  Group: De
+}, Qr = jr(Ar, Rr.Group, !0);
+export {
+  Qr as default
+};