@reddb-io/ui 0.1.1

package/dist/embed/sigma.esm-y0qgY-OC.js

@@ -0,0 +1,2355 @@
+import { g as Y, e as O, d as Z, c as j, i as Q, n as Re, o as Ne, p as Me, N as Ge, a as Ie, E as Fe, h as v, f as c, j as ne, r as ge, m as ve, k as ze, _ as Ae } from "./index-fad77a13.esm-BqPj0saH.js";
+import { e as Ue, r as He, g as Be } from "./RedUiEmbedRoot-BGoLxJf1.js";
+var ue = /* @__PURE__ */ (function(s) {
+  function n() {
+    var i;
+    return Z(this, n), i = j(this, n), i.rawEmitter = i, i;
+  }
+  return Y(n, s), O(n);
+})(Ue.EventEmitter), We = He();
+const Oe = /* @__PURE__ */ Be(We);
+var Ze = function(n) {
+  return n;
+}, _e = function(n) {
+  return n * n;
+}, Ve = function(n) {
+  return n * (2 - n);
+}, qe = function(n) {
+  return (n *= 2) < 1 ? 0.5 * n * n : -0.5 * (--n * (n - 2) - 1);
+}, Ye = function(n) {
+  return n * n * n;
+}, je = function(n) {
+  return --n * n * n + 1;
+}, Xe = function(n) {
+  return (n *= 2) < 1 ? 0.5 * n * n * n : 0.5 * ((n -= 2) * n * n + 2);
+}, Ke = {
+  linear: Ze,
+  quadraticIn: _e,
+  quadraticOut: Ve,
+  quadraticInOut: qe,
+  cubicIn: Ye,
+  cubicOut: je,
+  cubicInOut: Xe
+}, Je = {
+  easing: "quadraticInOut",
+  duration: 150
+};
+function N() {
+  return Float32Array.of(1, 0, 0, 0, 1, 0, 0, 0, 1);
+}
+function ee(s, n, i) {
+  return s[0] = n, s[4] = typeof i == "number" ? i : n, s;
+}
+function fe(s, n) {
+  var i = Math.sin(n), e = Math.cos(n);
+  return s[0] = e, s[1] = i, s[3] = -i, s[4] = e, s;
+}
+function me(s, n, i) {
+  return s[6] = n, s[7] = i, s;
+}
+function W(s, n) {
+  var i = s[0], e = s[1], t = s[2], a = s[3], r = s[4], o = s[5], h = s[6], d = s[7], l = s[8], u = n[0], g = n[1], f = n[2], m = n[3], p = n[4], y = n[5], E = n[6], b = n[7], x = n[8];
+  return s[0] = u * i + g * a + f * h, s[1] = u * e + g * r + f * d, s[2] = u * t + g * o + f * l, s[3] = m * i + p * a + y * h, s[4] = m * e + p * r + y * d, s[5] = m * t + p * o + y * l, s[6] = E * i + b * a + x * h, s[7] = E * e + b * r + x * d, s[8] = E * t + b * o + x * l, s;
+}
+function de(s, n) {
+  var i = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 1, e = s[0], t = s[1], a = s[3], r = s[4], o = s[6], h = s[7], d = n.x, l = n.y;
+  return {
+    x: d * e + l * a + o * i,
+    y: d * t + l * r + h * i
+  };
+}
+function Qe(s, n) {
+  var i = s.height / s.width, e = n.height / n.width;
+  return i < 1 && e > 1 || i > 1 && e < 1 ? 1 : Math.min(Math.max(e, 1 / e), Math.max(1 / i, i));
+}
+function X(s, n, i, e, t) {
+  var a = s.angle, r = s.ratio, o = s.x, h = s.y, d = n.width, l = n.height, u = N(), g = Math.min(d, l) - 2 * e, f = Qe(n, i);
+  return t ? (W(u, me(N(), o, h)), W(u, ee(N(), r)), W(u, fe(N(), a)), W(u, ee(N(), d / g / 2 / f, l / g / 2 / f))) : (W(u, ee(N(), 2 * (g / d) * f, 2 * (g / l) * f)), W(u, fe(N(), -a)), W(u, ee(N(), 1 / r)), W(u, me(N(), -o, -h))), u;
+}
+function $e(s, n, i) {
+  var e = de(s, {
+    x: Math.cos(n.angle),
+    y: Math.sin(n.angle)
+  }, 0), t = e.x, a = e.y;
+  return 1 / Math.sqrt(Math.pow(t, 2) + Math.pow(a, 2)) / i.width;
+}
+function et(s) {
+  if (!s.order) return {
+    x: [0, 1],
+    y: [0, 1]
+  };
+  var n = 1 / 0, i = -1 / 0, e = 1 / 0, t = -1 / 0;
+  return s.forEachNode(function(a, r) {
+    var o = r.x, h = r.y;
+    o < n && (n = o), o > i && (i = o), h < e && (e = h), h > t && (t = h);
+  }), {
+    x: [n, i],
+    y: [e, t]
+  };
+}
+function tt(s) {
+  if (!Oe(s)) throw new Error("Sigma: invalid graph instance.");
+  s.forEachNode(function(n, i) {
+    if (!Number.isFinite(i.x) || !Number.isFinite(i.y))
+      throw new Error("Sigma: Coordinates of node ".concat(n, " are invalid. A node must have a numeric 'x' and 'y' attribute."));
+  });
+}
+function it(s, n, i) {
+  var e = document.createElement(s);
+  if (n)
+    for (var t in n)
+      e.style[t] = n[t];
+  if (i)
+    for (var a in i)
+      e.setAttribute(a, i[a]);
+  return e;
+}
+function pe() {
+  return typeof window.devicePixelRatio < "u" ? window.devicePixelRatio : 1;
+}
+function ye(s, n, i) {
+  return i.sort(function(e, t) {
+    var a = n(e) || 0, r = n(t) || 0;
+    return a < r ? -1 : a > r ? 1 : 0;
+  });
+}
+function be(s) {
+  var n = Q(s.x, 2), i = n[0], e = n[1], t = Q(s.y, 2), a = t[0], r = t[1], o = Math.max(e - i, r - a), h = (e + i) / 2, d = (r + a) / 2;
+  (o === 0 || Math.abs(o) === 1 / 0 || isNaN(o)) && (o = 1), isNaN(h) && (h = 0), isNaN(d) && (d = 0);
+  var l = function(g) {
+    return {
+      x: 0.5 + (g.x - h) / o,
+      y: 0.5 + (g.y - d) / o
+    };
+  };
+  return l.applyTo = function(u) {
+    u.x = 0.5 + (u.x - h) / o, u.y = 0.5 + (u.y - d) / o;
+  }, l.inverse = function(u) {
+    return {
+      x: h + o * (u.x - 0.5),
+      y: d + o * (u.y - 0.5)
+    };
+  }, l.ratio = o, l;
+}
+function le(s) {
+  "@babel/helpers - typeof";
+  return le = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(n) {
+    return typeof n;
+  } : function(n) {
+    return n && typeof Symbol == "function" && n.constructor === Symbol && n !== Symbol.prototype ? "symbol" : typeof n;
+  }, le(s);
+}
+function xe(s, n) {
+  var i = n.size;
+  if (i !== 0) {
+    var e = s.length;
+    s.length += i;
+    var t = 0;
+    n.forEach(function(a) {
+      s[e + t] = a, t++;
+    });
+  }
+}
+function se(s) {
+  s = s || {};
+  for (var n = 0, i = arguments.length <= 1 ? 0 : arguments.length - 1; n < i; n++) {
+    var e = n + 1 < 1 || arguments.length <= n + 1 ? void 0 : arguments[n + 1];
+    e && Object.assign(s, e);
+  }
+  return s;
+}
+var ce = {
+  // Performance
+  hideEdgesOnMove: !1,
+  hideLabelsOnMove: !1,
+  renderLabels: !0,
+  renderEdgeLabels: !1,
+  enableEdgeEvents: !1,
+  // Component rendering
+  defaultNodeColor: "#999",
+  defaultNodeType: "circle",
+  defaultEdgeColor: "#ccc",
+  defaultEdgeType: "line",
+  labelFont: "Arial",
+  labelSize: 14,
+  labelWeight: "normal",
+  labelColor: {
+    color: "#000"
+  },
+  edgeLabelFont: "Arial",
+  edgeLabelSize: 14,
+  edgeLabelWeight: "normal",
+  edgeLabelColor: {
+    attribute: "color"
+  },
+  stagePadding: 30,
+  defaultDrawEdgeLabel: Me,
+  defaultDrawNodeLabel: Ne,
+  defaultDrawNodeHover: Re,
+  minEdgeThickness: 1.7,
+  antiAliasingFeather: 1,
+  // Mouse and touch settings
+  dragTimeout: 100,
+  draggedEventsTolerance: 3,
+  inertiaDuration: 200,
+  inertiaRatio: 3,
+  zoomDuration: 250,
+  zoomingRatio: 1.7,
+  doubleClickTimeout: 300,
+  doubleClickZoomingRatio: 2.2,
+  doubleClickZoomingDuration: 200,
+  tapMoveTolerance: 10,
+  // Size and scaling
+  zoomToSizeRatioFunction: Math.sqrt,
+  itemSizesReference: "screen",
+  autoRescale: !0,
+  autoCenter: !0,
+  // Labels
+  labelDensity: 1,
+  labelGridCellSize: 100,
+  labelRenderedSizeThreshold: 6,
+  // Reducers
+  nodeReducer: null,
+  edgeReducer: null,
+  // Features
+  zIndex: !1,
+  minCameraRatio: null,
+  maxCameraRatio: null,
+  enableCameraZooming: !0,
+  enableCameraPanning: !0,
+  enableCameraRotation: !0,
+  cameraPanBoundaries: null,
+  // Lifecycle
+  allowInvalidContainer: !1,
+  // Program classes
+  nodeProgramClasses: {},
+  nodeHoverProgramClasses: {},
+  edgeProgramClasses: {}
+}, at = {
+  circle: Ge
+}, rt = {
+  arrow: Fe,
+  line: Ie
+};
+function oe(s) {
+  if (typeof s.labelDensity != "number" || s.labelDensity < 0)
+    throw new Error("Settings: invalid `labelDensity`. Expecting a positive number.");
+  var n = s.minCameraRatio, i = s.maxCameraRatio;
+  if (typeof n == "number" && typeof i == "number" && i < n)
+    throw new Error("Settings: invalid camera ratio boundaries. Expecting `maxCameraRatio` to be greater than `minCameraRatio`.");
+}
+function nt(s) {
+  var n = se({}, ce, s);
+  return n.nodeProgramClasses = se({}, at, n.nodeProgramClasses), n.edgeProgramClasses = se({}, rt, n.edgeProgramClasses), n;
+}
+var te = 1.5, Ce = /* @__PURE__ */ (function(s) {
+  function n() {
+    var i;
+    return Z(this, n), i = j(this, n), c(i, "x", 0.5), c(i, "y", 0.5), c(i, "angle", 0), c(i, "ratio", 1), c(i, "minRatio", null), c(i, "maxRatio", null), c(i, "enabledZooming", !0), c(i, "enabledPanning", !0), c(i, "enabledRotation", !0), c(i, "clean", null), c(i, "nextFrame", null), c(i, "previousState", null), c(i, "enabled", !0), i.previousState = i.getState(), i;
+  }
+  return Y(n, s), O(n, [{
+    key: "enable",
+    value: (
+      /**
+       * Method used to enable the camera.
+       */
+      function() {
+        return this.enabled = !0, this;
+      }
+    )
+    /**
+     * Method used to disable the camera.
+     */
+  }, {
+    key: "disable",
+    value: function() {
+      return this.enabled = !1, this;
+    }
+    /**
+     * Method used to retrieve the camera's current state.
+     */
+  }, {
+    key: "getState",
+    value: function() {
+      return {
+        x: this.x,
+        y: this.y,
+        angle: this.angle,
+        ratio: this.ratio
+      };
+    }
+    /**
+     * Method used to check whether the camera has the given state.
+     */
+  }, {
+    key: "hasState",
+    value: function(e) {
+      return this.x === e.x && this.y === e.y && this.ratio === e.ratio && this.angle === e.angle;
+    }
+    /**
+     * Method used to retrieve the camera's previous state.
+     */
+  }, {
+    key: "getPreviousState",
+    value: function() {
+      var e = this.previousState;
+      return e ? {
+        x: e.x,
+        y: e.y,
+        angle: e.angle,
+        ratio: e.ratio
+      } : null;
+    }
+    /**
+     * Method used to check minRatio and maxRatio values.
+     */
+  }, {
+    key: "getBoundedRatio",
+    value: function(e) {
+      var t = e;
+      return typeof this.minRatio == "number" && (t = Math.max(t, this.minRatio)), typeof this.maxRatio == "number" && (t = Math.min(t, this.maxRatio)), t;
+    }
+    /**
+     * Method used to check various things to return a legit state candidate.
+     */
+  }, {
+    key: "validateState",
+    value: function(e) {
+      var t = {};
+      return this.enabledPanning && typeof e.x == "number" && (t.x = e.x), this.enabledPanning && typeof e.y == "number" && (t.y = e.y), this.enabledZooming && typeof e.ratio == "number" && (t.ratio = this.getBoundedRatio(e.ratio)), this.enabledRotation && typeof e.angle == "number" && (t.angle = e.angle), this.clean ? this.clean(v(v({}, this.getState()), t)) : t;
+    }
+    /**
+     * Method used to check whether the camera is currently being animated.
+     */
+  }, {
+    key: "isAnimated",
+    value: function() {
+      return !!this.nextFrame;
+    }
+    /**
+     * Method used to set the camera's state.
+     */
+  }, {
+    key: "setState",
+    value: function(e) {
+      if (!this.enabled) return this;
+      this.previousState = this.getState();
+      var t = this.validateState(e);
+      return typeof t.x == "number" && (this.x = t.x), typeof t.y == "number" && (this.y = t.y), typeof t.ratio == "number" && (this.ratio = t.ratio), typeof t.angle == "number" && (this.angle = t.angle), this.hasState(this.previousState) || this.emit("updated", this.getState()), this;
+    }
+    /**
+     * Method used to update the camera's state using a function.
+     */
+  }, {
+    key: "updateState",
+    value: function(e) {
+      return this.setState(e(this.getState())), this;
+    }
+    /**
+     * Method used to animate the camera.
+     */
+  }, {
+    key: "animate",
+    value: function(e) {
+      var t = this, a = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, r = arguments.length > 2 ? arguments[2] : void 0;
+      if (!r) return new Promise(function(f) {
+        return t.animate(e, a, f);
+      });
+      if (this.enabled) {
+        var o = v(v({}, Je), a), h = this.validateState(e), d = typeof o.easing == "function" ? o.easing : Ke[o.easing], l = Date.now(), u = this.getState(), g = function() {
+          var m = (Date.now() - l) / o.duration;
+          if (m >= 1) {
+            t.nextFrame = null, t.setState(h), t.animationCallback && (t.animationCallback.call(null), t.animationCallback = void 0);
+            return;
+          }
+          var p = d(m), y = {};
+          typeof h.x == "number" && (y.x = u.x + (h.x - u.x) * p), typeof h.y == "number" && (y.y = u.y + (h.y - u.y) * p), t.enabledRotation && typeof h.angle == "number" && (y.angle = u.angle + (h.angle - u.angle) * p), typeof h.ratio == "number" && (y.ratio = u.ratio + (h.ratio - u.ratio) * p), t.setState(y), t.nextFrame = requestAnimationFrame(g);
+        };
+        this.nextFrame ? (cancelAnimationFrame(this.nextFrame), this.animationCallback && this.animationCallback.call(null), this.nextFrame = requestAnimationFrame(g)) : g(), this.animationCallback = r;
+      }
+    }
+    /**
+     * Method used to zoom the camera.
+     */
+  }, {
+    key: "animatedZoom",
+    value: function(e) {
+      return e ? typeof e == "number" ? this.animate({
+        ratio: this.ratio / e
+      }) : this.animate({
+        ratio: this.ratio / (e.factor || te)
+      }, e) : this.animate({
+        ratio: this.ratio / te
+      });
+    }
+    /**
+     * Method used to unzoom the camera.
+     */
+  }, {
+    key: "animatedUnzoom",
+    value: function(e) {
+      return e ? typeof e == "number" ? this.animate({
+        ratio: this.ratio * e
+      }) : this.animate({
+        ratio: this.ratio * (e.factor || te)
+      }, e) : this.animate({
+        ratio: this.ratio * te
+      });
+    }
+    /**
+     * Method used to reset the camera.
+     */
+  }, {
+    key: "animatedReset",
+    value: function(e) {
+      return this.animate({
+        x: 0.5,
+        y: 0.5,
+        ratio: 1,
+        angle: 0
+      }, e);
+    }
+    /**
+     * Returns a new Camera instance, with the same state as the current camera.
+     */
+  }, {
+    key: "copy",
+    value: function() {
+      return n.from(this.getState());
+    }
+  }], [{
+    key: "from",
+    value: function(e) {
+      var t = new n();
+      return t.setState(e);
+    }
+  }]);
+})(ue);
+function M(s, n) {
+  var i = n.getBoundingClientRect();
+  return {
+    x: s.clientX - i.left,
+    y: s.clientY - i.top
+  };
+}
+function F(s, n) {
+  var i = v(v({}, M(s, n)), {}, {
+    sigmaDefaultPrevented: !1,
+    preventSigmaDefault: function() {
+      i.sigmaDefaultPrevented = !0;
+    },
+    original: s
+  });
+  return i;
+}
+function K(s) {
+  var n = "x" in s ? s : v(v({}, s.touches[0] || s.previousTouches[0]), {}, {
+    original: s.original,
+    sigmaDefaultPrevented: s.sigmaDefaultPrevented,
+    preventSigmaDefault: function() {
+      s.sigmaDefaultPrevented = !0, n.sigmaDefaultPrevented = !0;
+    }
+  });
+  return n;
+}
+function st(s, n) {
+  return v(v({}, F(s, n)), {}, {
+    delta: Te(s)
+  });
+}
+var ot = 2;
+function ie(s) {
+  for (var n = [], i = 0, e = Math.min(s.length, ot); i < e; i++) n.push(s[i]);
+  return n;
+}
+function J(s, n, i) {
+  var e = {
+    touches: ie(s.touches).map(function(t) {
+      return M(t, i);
+    }),
+    previousTouches: n.map(function(t) {
+      return M(t, i);
+    }),
+    sigmaDefaultPrevented: !1,
+    preventSigmaDefault: function() {
+      e.sigmaDefaultPrevented = !0;
+    },
+    original: s
+  };
+  return e;
+}
+function Te(s) {
+  if (typeof s.deltaY < "u") return s.deltaY * -3 / 360;
+  if (typeof s.detail < "u") return s.detail / -9;
+  throw new Error("Captor: could not extract delta from event.");
+}
+var De = /* @__PURE__ */ (function(s) {
+  function n(i, e) {
+    var t;
+    return Z(this, n), t = j(this, n), t.container = i, t.renderer = e, t;
+  }
+  return Y(n, s), O(n);
+})(ue), ht = ["doubleClickTimeout", "doubleClickZoomingDuration", "doubleClickZoomingRatio", "dragTimeout", "draggedEventsTolerance", "inertiaDuration", "inertiaRatio", "zoomDuration", "zoomingRatio"], dt = ht.reduce(function(s, n) {
+  return v(v({}, s), {}, c({}, n, ce[n]));
+}, {}), lt = /* @__PURE__ */ (function(s) {
+  function n(i, e) {
+    var t;
+    return Z(this, n), t = j(this, n, [i, e]), c(t, "enabled", !0), c(t, "draggedEvents", 0), c(t, "downStartTime", null), c(t, "lastMouseX", null), c(t, "lastMouseY", null), c(t, "isMouseDown", !1), c(t, "isMoving", !1), c(t, "movingTimeout", null), c(t, "startCameraState", null), c(t, "clicks", 0), c(t, "doubleClickTimeout", null), c(t, "currentWheelDirection", 0), c(t, "settings", dt), t.handleClick = t.handleClick.bind(t), t.handleRightClick = t.handleRightClick.bind(t), t.handleDown = t.handleDown.bind(t), t.handleUp = t.handleUp.bind(t), t.handleMove = t.handleMove.bind(t), t.handleWheel = t.handleWheel.bind(t), t.handleLeave = t.handleLeave.bind(t), t.handleEnter = t.handleEnter.bind(t), i.addEventListener("click", t.handleClick, {
+      capture: !1
+    }), i.addEventListener("contextmenu", t.handleRightClick, {
+      capture: !1
+    }), i.addEventListener("mousedown", t.handleDown, {
+      capture: !1
+    }), i.addEventListener("wheel", t.handleWheel, {
+      capture: !1
+    }), i.addEventListener("mouseleave", t.handleLeave, {
+      capture: !1
+    }), i.addEventListener("mouseenter", t.handleEnter, {
+      capture: !1
+    }), document.addEventListener("mousemove", t.handleMove, {
+      capture: !1
+    }), document.addEventListener("mouseup", t.handleUp, {
+      capture: !1
+    }), t;
+  }
+  return Y(n, s), O(n, [{
+    key: "kill",
+    value: function() {
+      var e = this.container;
+      e.removeEventListener("click", this.handleClick), e.removeEventListener("contextmenu", this.handleRightClick), e.removeEventListener("mousedown", this.handleDown), e.removeEventListener("wheel", this.handleWheel), e.removeEventListener("mouseleave", this.handleLeave), e.removeEventListener("mouseenter", this.handleEnter), document.removeEventListener("mousemove", this.handleMove), document.removeEventListener("mouseup", this.handleUp);
+    }
+  }, {
+    key: "handleClick",
+    value: function(e) {
+      var t = this;
+      if (this.enabled) {
+        if (this.clicks++, this.clicks === 2)
+          return this.clicks = 0, typeof this.doubleClickTimeout == "number" && (clearTimeout(this.doubleClickTimeout), this.doubleClickTimeout = null), this.handleDoubleClick(e);
+        setTimeout(function() {
+          t.clicks = 0, t.doubleClickTimeout = null;
+        }, this.settings.doubleClickTimeout), this.draggedEvents < this.settings.draggedEventsTolerance && this.emit("click", F(e, this.container));
+      }
+    }
+  }, {
+    key: "handleRightClick",
+    value: function(e) {
+      this.enabled && this.emit("rightClick", F(e, this.container));
+    }
+  }, {
+    key: "handleDoubleClick",
+    value: function(e) {
+      if (this.enabled) {
+        e.preventDefault(), e.stopPropagation();
+        var t = F(e, this.container);
+        if (this.emit("doubleClick", t), !t.sigmaDefaultPrevented) {
+          var a = this.renderer.getCamera(), r = a.getBoundedRatio(a.getState().ratio / this.settings.doubleClickZoomingRatio);
+          a.animate(this.renderer.getViewportZoomedState(M(e, this.container), r), {
+            easing: "quadraticInOut",
+            duration: this.settings.doubleClickZoomingDuration
+          });
+        }
+      }
+    }
+  }, {
+    key: "handleDown",
+    value: function(e) {
+      if (this.enabled) {
+        if (e.button === 0) {
+          this.startCameraState = this.renderer.getCamera().getState();
+          var t = M(e, this.container), a = t.x, r = t.y;
+          this.lastMouseX = a, this.lastMouseY = r, this.draggedEvents = 0, this.downStartTime = Date.now(), this.isMouseDown = !0;
+        }
+        this.emit("mousedown", F(e, this.container));
+      }
+    }
+  }, {
+    key: "handleUp",
+    value: function(e) {
+      var t = this;
+      if (!(!this.enabled || !this.isMouseDown)) {
+        var a = this.renderer.getCamera();
+        this.isMouseDown = !1, typeof this.movingTimeout == "number" && (clearTimeout(this.movingTimeout), this.movingTimeout = null);
+        var r = M(e, this.container), o = r.x, h = r.y, d = a.getState(), l = a.getPreviousState() || {
+          x: 0,
+          y: 0
+        };
+        this.isMoving ? a.animate({
+          x: d.x + this.settings.inertiaRatio * (d.x - l.x),
+          y: d.y + this.settings.inertiaRatio * (d.y - l.y)
+        }, {
+          duration: this.settings.inertiaDuration,
+          easing: "quadraticOut"
+        }) : (this.lastMouseX !== o || this.lastMouseY !== h) && a.setState({
+          x: d.x,
+          y: d.y
+        }), this.isMoving = !1, setTimeout(function() {
+          var u = t.draggedEvents > 0;
+          t.draggedEvents = 0, u && t.renderer.getSetting("hideEdgesOnMove") && t.renderer.refresh();
+        }, 0), this.emit("mouseup", F(e, this.container));
+      }
+    }
+  }, {
+    key: "handleMove",
+    value: function(e) {
+      var t = this;
+      if (this.enabled) {
+        var a = F(e, this.container);
+        if (this.emit("mousemovebody", a), (e.target === this.container || e.composedPath()[0] === this.container) && this.emit("mousemove", a), !a.sigmaDefaultPrevented && this.isMouseDown) {
+          this.isMoving = !0, this.draggedEvents++, typeof this.movingTimeout == "number" && clearTimeout(this.movingTimeout), this.movingTimeout = window.setTimeout(function() {
+            t.movingTimeout = null, t.isMoving = !1;
+          }, this.settings.dragTimeout);
+          var r = this.renderer.getCamera(), o = M(e, this.container), h = o.x, d = o.y, l = this.renderer.viewportToFramedGraph({
+            x: this.lastMouseX,
+            y: this.lastMouseY
+          }), u = this.renderer.viewportToFramedGraph({
+            x: h,
+            y: d
+          }), g = l.x - u.x, f = l.y - u.y, m = r.getState(), p = m.x + g, y = m.y + f;
+          r.setState({
+            x: p,
+            y
+          }), this.lastMouseX = h, this.lastMouseY = d, e.preventDefault(), e.stopPropagation();
+        }
+      }
+    }
+  }, {
+    key: "handleLeave",
+    value: function(e) {
+      this.emit("mouseleave", F(e, this.container));
+    }
+  }, {
+    key: "handleEnter",
+    value: function(e) {
+      this.emit("mouseenter", F(e, this.container));
+    }
+  }, {
+    key: "handleWheel",
+    value: function(e) {
+      var t = this, a = this.renderer.getCamera();
+      if (!(!this.enabled || !a.enabledZooming)) {
+        var r = Te(e);
+        if (r) {
+          var o = st(e, this.container);
+          if (this.emit("wheel", o), o.sigmaDefaultPrevented) {
+            e.preventDefault(), e.stopPropagation();
+            return;
+          }
+          var h = a.getState().ratio, d = r > 0 ? 1 / this.settings.zoomingRatio : this.settings.zoomingRatio, l = a.getBoundedRatio(h * d), u = r > 0 ? 1 : -1, g = Date.now();
+          h !== l && (e.preventDefault(), e.stopPropagation(), !(this.currentWheelDirection === u && this.lastWheelTriggerTime && g - this.lastWheelTriggerTime < this.settings.zoomDuration / 5) && (a.animate(this.renderer.getViewportZoomedState(M(e, this.container), l), {
+            easing: "quadraticOut",
+            duration: this.settings.zoomDuration
+          }, function() {
+            t.currentWheelDirection = 0;
+          }), this.currentWheelDirection = u, this.lastWheelTriggerTime = g));
+        }
+      }
+    }
+  }, {
+    key: "setSettings",
+    value: function(e) {
+      this.settings = e;
+    }
+  }]);
+})(De), ut = ["dragTimeout", "inertiaDuration", "inertiaRatio", "doubleClickTimeout", "doubleClickZoomingRatio", "doubleClickZoomingDuration", "tapMoveTolerance"], ct = ut.reduce(function(s, n) {
+  return v(v({}, s), {}, c({}, n, ce[n]));
+}, {}), gt = /* @__PURE__ */ (function(s) {
+  function n(i, e) {
+    var t;
+    return Z(this, n), t = j(this, n, [i, e]), c(t, "enabled", !0), c(t, "isMoving", !1), c(t, "hasMoved", !1), c(t, "touchMode", 0), c(t, "startTouchesPositions", []), c(t, "lastTouches", []), c(t, "lastTap", null), c(t, "settings", ct), t.handleStart = t.handleStart.bind(t), t.handleLeave = t.handleLeave.bind(t), t.handleMove = t.handleMove.bind(t), i.addEventListener("touchstart", t.handleStart, {
+      capture: !1
+    }), i.addEventListener("touchcancel", t.handleLeave, {
+      capture: !1
+    }), document.addEventListener("touchend", t.handleLeave, {
+      capture: !1,
+      passive: !1
+    }), document.addEventListener("touchmove", t.handleMove, {
+      capture: !1,
+      passive: !1
+    }), t;
+  }
+  return Y(n, s), O(n, [{
+    key: "kill",
+    value: function() {
+      var e = this.container;
+      e.removeEventListener("touchstart", this.handleStart), e.removeEventListener("touchcancel", this.handleLeave), document.removeEventListener("touchend", this.handleLeave), document.removeEventListener("touchmove", this.handleMove);
+    }
+  }, {
+    key: "getDimensions",
+    value: function() {
+      return {
+        width: this.container.offsetWidth,
+        height: this.container.offsetHeight
+      };
+    }
+  }, {
+    key: "handleStart",
+    value: function(e) {
+      var t = this;
+      if (this.enabled) {
+        e.preventDefault();
+        var a = ie(e.touches);
+        if (this.touchMode = a.length, this.startCameraState = this.renderer.getCamera().getState(), this.startTouchesPositions = a.map(function(f) {
+          return M(f, t.container);
+        }), this.touchMode === 2) {
+          var r = Q(this.startTouchesPositions, 2), o = r[0], h = o.x, d = o.y, l = r[1], u = l.x, g = l.y;
+          this.startTouchesAngle = Math.atan2(g - d, u - h), this.startTouchesDistance = Math.sqrt(Math.pow(u - h, 2) + Math.pow(g - d, 2));
+        }
+        this.emit("touchdown", J(e, this.lastTouches, this.container)), this.lastTouches = a, this.lastTouchesPositions = this.startTouchesPositions;
+      }
+    }
+  }, {
+    key: "handleLeave",
+    value: function(e) {
+      if (!(!this.enabled || !this.startTouchesPositions.length)) {
+        switch (e.cancelable && e.preventDefault(), this.movingTimeout && (this.isMoving = !1, clearTimeout(this.movingTimeout)), this.touchMode) {
+          // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+          // @ts-ignore
+          case 2:
+            if (e.touches.length === 1) {
+              this.handleStart(e), e.preventDefault();
+              break;
+            }
+          /* falls through */
+          case 1:
+            if (this.isMoving) {
+              var t = this.renderer.getCamera(), a = t.getState(), r = t.getPreviousState() || {
+                x: 0,
+                y: 0
+              };
+              t.animate({
+                x: a.x + this.settings.inertiaRatio * (a.x - r.x),
+                y: a.y + this.settings.inertiaRatio * (a.y - r.y)
+              }, {
+                duration: this.settings.inertiaDuration,
+                easing: "quadraticOut"
+              });
+            }
+            this.hasMoved = !1, this.isMoving = !1, this.touchMode = 0;
+            break;
+        }
+        if (this.emit("touchup", J(e, this.lastTouches, this.container)), !e.touches.length) {
+          var o = M(this.lastTouches[0], this.container), h = this.startTouchesPositions[0], d = Math.pow(o.x - h.x, 2) + Math.pow(o.y - h.y, 2);
+          if (!e.touches.length && d < Math.pow(this.settings.tapMoveTolerance, 2))
+            if (this.lastTap && Date.now() - this.lastTap.time < this.settings.doubleClickTimeout) {
+              var l = J(e, this.lastTouches, this.container);
+              if (this.emit("doubletap", l), this.lastTap = null, !l.sigmaDefaultPrevented) {
+                var u = this.renderer.getCamera(), g = u.getBoundedRatio(u.getState().ratio / this.settings.doubleClickZoomingRatio);
+                u.animate(this.renderer.getViewportZoomedState(o, g), {
+                  easing: "quadraticInOut",
+                  duration: this.settings.doubleClickZoomingDuration
+                });
+              }
+            } else {
+              var f = J(e, this.lastTouches, this.container);
+              this.emit("tap", f), this.lastTap = {
+                time: Date.now(),
+                position: f.touches[0] || f.previousTouches[0]
+              };
+            }
+        }
+        this.lastTouches = ie(e.touches), this.startTouchesPositions = [];
+      }
+    }
+  }, {
+    key: "handleMove",
+    value: function(e) {
+      var t = this;
+      if (!(!this.enabled || !this.startTouchesPositions.length)) {
+        e.preventDefault();
+        var a = ie(e.touches), r = a.map(function(B) {
+          return M(B, t.container);
+        }), o = this.lastTouches;
+        this.lastTouches = a, this.lastTouchesPositions = r;
+        var h = J(e, o, this.container);
+        if (this.emit("touchmove", h), !h.sigmaDefaultPrevented && (this.hasMoved || (this.hasMoved = r.some(function(B, ae) {
+          var G = t.startTouchesPositions[ae];
+          return G && (B.x !== G.x || B.y !== G.y);
+        })), !!this.hasMoved)) {
+          this.isMoving = !0, this.movingTimeout && clearTimeout(this.movingTimeout), this.movingTimeout = window.setTimeout(function() {
+            t.isMoving = !1;
+          }, this.settings.dragTimeout);
+          var d = this.renderer.getCamera(), l = this.startCameraState, u = this.renderer.getSetting("stagePadding");
+          switch (this.touchMode) {
+            case 1: {
+              var g = this.renderer.viewportToFramedGraph((this.startTouchesPositions || [])[0]), f = g.x, m = g.y, p = this.renderer.viewportToFramedGraph(r[0]), y = p.x, E = p.y;
+              d.setState({
+                x: l.x + f - y,
+                y: l.y + m - E
+              });
+              break;
+            }
+            case 2: {
+              var b = {
+                x: 0.5,
+                y: 0.5,
+                angle: 0,
+                ratio: 1
+              }, x = r[0], C = x.x, I = x.y, A = r[1], w = A.x, k = A.y, T = Math.atan2(k - I, w - C) - this.startTouchesAngle, L = Math.hypot(k - I, w - C) / this.startTouchesDistance, D = d.getBoundedRatio(l.ratio / L);
+              b.ratio = D, b.angle = l.angle + T;
+              var S = this.getDimensions(), _ = this.renderer.viewportToFramedGraph((this.startTouchesPositions || [])[0], {
+                cameraState: l
+              }), P = Math.min(S.width, S.height) - 2 * u, R = P / S.width, U = P / S.height, $ = D / P, q = C - P / 2 / R, V = I - P / 2 / U, H = [q * Math.cos(-b.angle) - V * Math.sin(-b.angle), V * Math.cos(-b.angle) + q * Math.sin(-b.angle)];
+              q = H[0], V = H[1], b.x = _.x - q * $, b.y = _.y + V * $, d.setState(b);
+              break;
+            }
+          }
+        }
+      }
+    }
+  }, {
+    key: "setSettings",
+    value: function(e) {
+      this.settings = e;
+    }
+  }]);
+})(De);
+function vt(s) {
+  if (Array.isArray(s)) return Ae(s);
+}
+function ft(s) {
+  if (typeof Symbol < "u" && s[Symbol.iterator] != null || s["@@iterator"] != null) return Array.from(s);
+}
+function mt() {
+  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 Ee(s) {
+  return vt(s) || ft(s) || ze(s) || mt();
+}
+function pt(s, n) {
+  if (s == null) return {};
+  var i = {};
+  for (var e in s) if ({}.hasOwnProperty.call(s, e)) {
+    if (n.indexOf(e) !== -1) continue;
+    i[e] = s[e];
+  }
+  return i;
+}
+function he(s, n) {
+  if (s == null) return {};
+  var i, e, t = pt(s, n);
+  if (Object.getOwnPropertySymbols) {
+    var a = Object.getOwnPropertySymbols(s);
+    for (e = 0; e < a.length; e++) i = a[e], n.indexOf(i) === -1 && {}.propertyIsEnumerable.call(s, i) && (t[i] = s[i]);
+  }
+  return t;
+}
+var we = /* @__PURE__ */ (function() {
+  function s(n, i) {
+    Z(this, s), this.key = n, this.size = i;
+  }
+  return O(s, null, [{
+    key: "compare",
+    value: function(i, e) {
+      return i.size > e.size ? -1 : i.size < e.size || i.key > e.key ? 1 : -1;
+    }
+  }]);
+})(), Le = /* @__PURE__ */ (function() {
+  function s() {
+    Z(this, s), c(this, "width", 0), c(this, "height", 0), c(this, "cellSize", 0), c(this, "columns", 0), c(this, "rows", 0), c(this, "cells", {});
+  }
+  return O(s, [{
+    key: "resizeAndClear",
+    value: function(i, e) {
+      this.width = i.width, this.height = i.height, this.cellSize = e, this.columns = Math.ceil(i.width / e), this.rows = Math.ceil(i.height / e), this.cells = {};
+    }
+  }, {
+    key: "getIndex",
+    value: function(i) {
+      var e = Math.floor(i.x / this.cellSize), t = Math.floor(i.y / this.cellSize);
+      return t * this.columns + e;
+    }
+  }, {
+    key: "add",
+    value: function(i, e, t) {
+      var a = new we(i, e), r = this.getIndex(t), o = this.cells[r];
+      o || (o = [], this.cells[r] = o), o.push(a);
+    }
+  }, {
+    key: "organize",
+    value: function() {
+      for (var i in this.cells) {
+        var e = this.cells[i];
+        e.sort(we.compare);
+      }
+    }
+  }, {
+    key: "getLabelsToDisplay",
+    value: function(i, e) {
+      var t = this.cellSize * this.cellSize, a = t / i / i, r = a * e / t, o = Math.ceil(r), h = [];
+      for (var d in this.cells)
+        for (var l = this.cells[d], u = 0; u < Math.min(o, l.length); u++)
+          h.push(l[u].key);
+      return h;
+    }
+  }]);
+})();
+function yt(s) {
+  var n = s.graph, i = s.hoveredNode, e = s.highlightedNodes, t = s.displayedNodeLabels, a = [];
+  return n.forEachEdge(function(r, o, h, d) {
+    (h === i || d === i || e.has(h) || e.has(d) || t.has(h) && t.has(d)) && a.push(r);
+  }), a;
+}
+var Se = 150, Pe = 50, z = Object.prototype.hasOwnProperty;
+function bt(s, n, i) {
+  if (!z.call(i, "x") || !z.call(i, "y")) throw new Error('Sigma: could not find a valid position (x, y) for node "'.concat(n, '". All your nodes must have a number "x" and "y". Maybe your forgot to apply a layout or your "nodeReducer" is not returning the correct data?'));
+  return i.color || (i.color = s.defaultNodeColor), !i.label && i.label !== "" && (i.label = null), i.label !== void 0 && i.label !== null ? i.label = "" + i.label : i.label = null, i.size || (i.size = 2), z.call(i, "hidden") || (i.hidden = !1), z.call(i, "highlighted") || (i.highlighted = !1), z.call(i, "forceLabel") || (i.forceLabel = !1), (!i.type || i.type === "") && (i.type = s.defaultNodeType), i.zIndex || (i.zIndex = 0), i;
+}
+function xt(s, n, i) {
+  return i.color || (i.color = s.defaultEdgeColor), i.label || (i.label = ""), i.size || (i.size = 0.5), z.call(i, "hidden") || (i.hidden = !1), z.call(i, "forceLabel") || (i.forceLabel = !1), (!i.type || i.type === "") && (i.type = s.defaultEdgeType), i.zIndex || (i.zIndex = 0), i;
+}
+var Ct = /* @__PURE__ */ (function(s) {
+  function n(i, e) {
+    var t, a = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+    if (Z(this, n), t = j(this, n), c(t, "elements", {}), c(t, "canvasContexts", {}), c(t, "webGLContexts", {}), c(t, "pickingLayers", /* @__PURE__ */ new Set()), c(t, "textures", {}), c(t, "frameBuffers", {}), c(t, "activeListeners", {}), c(t, "labelGrid", new Le()), c(t, "nodeDataCache", {}), c(t, "edgeDataCache", {}), c(t, "nodeProgramIndex", {}), c(t, "edgeProgramIndex", {}), c(t, "nodesWithForcedLabels", /* @__PURE__ */ new Set()), c(t, "edgesWithForcedLabels", /* @__PURE__ */ new Set()), c(t, "nodeExtent", {
+      x: [0, 1],
+      y: [0, 1]
+    }), c(t, "nodeZExtent", [1 / 0, -1 / 0]), c(t, "edgeZExtent", [1 / 0, -1 / 0]), c(t, "matrix", N()), c(t, "invMatrix", N()), c(t, "correctionRatio", 1), c(t, "customBBox", null), c(t, "normalizationFunction", be({
+      x: [0, 1],
+      y: [0, 1]
+    })), c(t, "graphToViewportRatio", 1), c(t, "itemIDsIndex", {}), c(t, "nodeIndices", {}), c(t, "edgeIndices", {}), c(t, "width", 0), c(t, "height", 0), c(t, "pixelRatio", pe()), c(t, "pickingDownSizingRatio", 2 * t.pixelRatio), c(t, "displayedNodeLabels", /* @__PURE__ */ new Set()), c(t, "displayedEdgeLabels", /* @__PURE__ */ new Set()), c(t, "highlightedNodes", /* @__PURE__ */ new Set()), c(t, "hoveredNode", null), c(t, "hoveredEdge", null), c(t, "renderFrame", null), c(t, "renderHighlightedNodesFrame", null), c(t, "needToProcess", !1), c(t, "checkEdgesEventsFrame", null), c(t, "nodePrograms", {}), c(t, "nodeHoverPrograms", {}), c(t, "edgePrograms", {}), t.settings = nt(a), oe(t.settings), tt(i), !(e instanceof HTMLElement)) throw new Error("Sigma: container should be an html element.");
+    t.graph = i, t.container = e, t.createWebGLContext("edges", {
+      picking: a.enableEdgeEvents
+    }), t.createCanvasContext("edgeLabels"), t.createWebGLContext("nodes", {
+      picking: !0
+    }), t.createCanvasContext("labels"), t.createCanvasContext("hovers"), t.createWebGLContext("hoverNodes"), t.createCanvasContext("mouse", {
+      style: {
+        touchAction: "none",
+        userSelect: "none"
+      }
+    }), t.resize();
+    for (var r in t.settings.nodeProgramClasses)
+      t.registerNodeProgram(r, t.settings.nodeProgramClasses[r], t.settings.nodeHoverProgramClasses[r]);
+    for (var o in t.settings.edgeProgramClasses)
+      t.registerEdgeProgram(o, t.settings.edgeProgramClasses[o]);
+    return t.camera = new Ce(), t.bindCameraHandlers(), t.mouseCaptor = new lt(t.elements.mouse, t), t.mouseCaptor.setSettings(t.settings), t.touchCaptor = new gt(t.elements.mouse, t), t.touchCaptor.setSettings(t.settings), t.bindEventHandlers(), t.bindGraphHandlers(), t.handleSettingsUpdate(), t.refresh(), t;
+  }
+  return Y(n, s), O(n, [{
+    key: "registerNodeProgram",
+    value: function(e, t, a) {
+      return this.nodePrograms[e] && this.nodePrograms[e].kill(), this.nodeHoverPrograms[e] && this.nodeHoverPrograms[e].kill(), this.nodePrograms[e] = new t(this.webGLContexts.nodes, this.frameBuffers.nodes, this), this.nodeHoverPrograms[e] = new (a || t)(this.webGLContexts.hoverNodes, null, this), this;
+    }
+    /**
+     * Internal function used to register an edge program
+     *
+     * @param  {string}          key              - The program's key, matching the related edges "type" values.
+     * @param  {EdgeProgramType} EdgeProgramClass - An edges program class.
+     * @return {Sigma}
+     */
+  }, {
+    key: "registerEdgeProgram",
+    value: function(e, t) {
+      return this.edgePrograms[e] && this.edgePrograms[e].kill(), this.edgePrograms[e] = new t(this.webGLContexts.edges, this.frameBuffers.edges, this), this;
+    }
+    /**
+     * Internal function used to unregister a node program
+     *
+     * @param  {string} key - The program's key, matching the related nodes "type" values.
+     * @return {Sigma}
+     */
+  }, {
+    key: "unregisterNodeProgram",
+    value: function(e) {
+      if (this.nodePrograms[e]) {
+        var t = this.nodePrograms, a = t[e], r = he(t, [e].map(ne));
+        a.kill(), this.nodePrograms = r;
+      }
+      if (this.nodeHoverPrograms[e]) {
+        var o = this.nodeHoverPrograms, h = o[e], d = he(o, [e].map(ne));
+        h.kill(), this.nodePrograms = d;
+      }
+      return this;
+    }
+    /**
+     * Internal function used to unregister an edge program
+     *
+     * @param  {string} key - The program's key, matching the related edges "type" values.
+     * @return {Sigma}
+     */
+  }, {
+    key: "unregisterEdgeProgram",
+    value: function(e) {
+      if (this.edgePrograms[e]) {
+        var t = this.edgePrograms, a = t[e], r = he(t, [e].map(ne));
+        a.kill(), this.edgePrograms = r;
+      }
+      return this;
+    }
+    /**
+     * Method (re)binding WebGL texture (for picking).
+     *
+     * @return {Sigma}
+     */
+  }, {
+    key: "resetWebGLTexture",
+    value: function(e) {
+      var t = this.webGLContexts[e], a = this.frameBuffers[e], r = this.textures[e];
+      r && t.deleteTexture(r);
+      var o = t.createTexture();
+      return t.bindFramebuffer(t.FRAMEBUFFER, a), t.bindTexture(t.TEXTURE_2D, o), t.texImage2D(t.TEXTURE_2D, 0, t.RGBA, this.width, this.height, 0, t.RGBA, t.UNSIGNED_BYTE, null), t.framebufferTexture2D(t.FRAMEBUFFER, t.COLOR_ATTACHMENT0, t.TEXTURE_2D, o, 0), this.textures[e] = o, this;
+    }
+    /**
+     * Method binding camera handlers.
+     *
+     * @return {Sigma}
+     */
+  }, {
+    key: "bindCameraHandlers",
+    value: function() {
+      var e = this;
+      return this.activeListeners.camera = function() {
+        e.scheduleRender();
+      }, this.camera.on("updated", this.activeListeners.camera), this;
+    }
+    /**
+     * Method unbinding camera handlers.
+     *
+     * @return {Sigma}
+     */
+  }, {
+    key: "unbindCameraHandlers",
+    value: function() {
+      return this.camera.removeListener("updated", this.activeListeners.camera), this;
+    }
+    /**
+     * Method that returns the closest node to a given position.
+     */
+  }, {
+    key: "getNodeAtPosition",
+    value: function(e) {
+      var t = e.x, a = e.y, r = ge(this.webGLContexts.nodes, this.frameBuffers.nodes, t, a, this.pixelRatio, this.pickingDownSizingRatio), o = ve.apply(void 0, Ee(r)), h = this.itemIDsIndex[o];
+      return h && h.type === "node" ? h.id : null;
+    }
+    /**
+     * Method binding event handlers.
+     *
+     * @return {Sigma}
+     */
+  }, {
+    key: "bindEventHandlers",
+    value: function() {
+      var e = this;
+      this.activeListeners.handleResize = function() {
+        e.scheduleRefresh();
+      }, window.addEventListener("resize", this.activeListeners.handleResize), this.activeListeners.handleMove = function(a) {
+        var r = K(a), o = {
+          event: r,
+          preventSigmaDefault: function() {
+            r.preventSigmaDefault();
+          }
+        }, h = e.getNodeAtPosition(r);
+        if (h && e.hoveredNode !== h && !e.nodeDataCache[h].hidden) {
+          e.hoveredNode && e.emit("leaveNode", v(v({}, o), {}, {
+            node: e.hoveredNode
+          })), e.hoveredNode = h, e.emit("enterNode", v(v({}, o), {}, {
+            node: h
+          })), e.scheduleHighlightedNodesRender();
+          return;
+        }
+        if (e.hoveredNode && e.getNodeAtPosition(r) !== e.hoveredNode) {
+          var d = e.hoveredNode;
+          e.hoveredNode = null, e.emit("leaveNode", v(v({}, o), {}, {
+            node: d
+          })), e.scheduleHighlightedNodesRender();
+          return;
+        }
+        if (e.settings.enableEdgeEvents) {
+          var l = e.hoveredNode ? null : e.getEdgeAtPoint(o.event.x, o.event.y);
+          l !== e.hoveredEdge && (e.hoveredEdge && e.emit("leaveEdge", v(v({}, o), {}, {
+            edge: e.hoveredEdge
+          })), l && e.emit("enterEdge", v(v({}, o), {}, {
+            edge: l
+          })), e.hoveredEdge = l);
+        }
+      }, this.activeListeners.handleMoveBody = function(a) {
+        var r = K(a);
+        e.emit("moveBody", {
+          event: r,
+          preventSigmaDefault: function() {
+            r.preventSigmaDefault();
+          }
+        });
+      }, this.activeListeners.handleLeave = function(a) {
+        var r = K(a), o = {
+          event: r,
+          preventSigmaDefault: function() {
+            r.preventSigmaDefault();
+          }
+        };
+        e.hoveredNode && (e.emit("leaveNode", v(v({}, o), {}, {
+          node: e.hoveredNode
+        })), e.scheduleHighlightedNodesRender()), e.settings.enableEdgeEvents && e.hoveredEdge && (e.emit("leaveEdge", v(v({}, o), {}, {
+          edge: e.hoveredEdge
+        })), e.scheduleHighlightedNodesRender()), e.emit("leaveStage", v({}, o));
+      }, this.activeListeners.handleEnter = function(a) {
+        var r = K(a), o = {
+          event: r,
+          preventSigmaDefault: function() {
+            r.preventSigmaDefault();
+          }
+        };
+        e.emit("enterStage", v({}, o));
+      };
+      var t = function(r) {
+        return function(o) {
+          var h = K(o), d = {
+            event: h,
+            preventSigmaDefault: function() {
+              h.preventSigmaDefault();
+            }
+          }, l = e.getNodeAtPosition(h);
+          if (l) return e.emit("".concat(r, "Node"), v(v({}, d), {}, {
+            node: l
+          }));
+          if (e.settings.enableEdgeEvents) {
+            var u = e.getEdgeAtPoint(h.x, h.y);
+            if (u) return e.emit("".concat(r, "Edge"), v(v({}, d), {}, {
+              edge: u
+            }));
+          }
+          return e.emit("".concat(r, "Stage"), d);
+        };
+      };
+      return this.activeListeners.handleClick = t("click"), this.activeListeners.handleRightClick = t("rightClick"), this.activeListeners.handleDoubleClick = t("doubleClick"), this.activeListeners.handleWheel = t("wheel"), this.activeListeners.handleDown = t("down"), this.activeListeners.handleUp = t("up"), this.mouseCaptor.on("mousemove", this.activeListeners.handleMove), this.mouseCaptor.on("mousemovebody", this.activeListeners.handleMoveBody), this.mouseCaptor.on("click", this.activeListeners.handleClick), this.mouseCaptor.on("rightClick", this.activeListeners.handleRightClick), this.mouseCaptor.on("doubleClick", this.activeListeners.handleDoubleClick), this.mouseCaptor.on("wheel", this.activeListeners.handleWheel), this.mouseCaptor.on("mousedown", this.activeListeners.handleDown), this.mouseCaptor.on("mouseup", this.activeListeners.handleUp), this.mouseCaptor.on("mouseleave", this.activeListeners.handleLeave), this.mouseCaptor.on("mouseenter", this.activeListeners.handleEnter), this.touchCaptor.on("touchdown", this.activeListeners.handleDown), this.touchCaptor.on("touchdown", this.activeListeners.handleMove), this.touchCaptor.on("touchup", this.activeListeners.handleUp), this.touchCaptor.on("touchmove", this.activeListeners.handleMove), this.touchCaptor.on("tap", this.activeListeners.handleClick), this.touchCaptor.on("doubletap", this.activeListeners.handleDoubleClick), this.touchCaptor.on("touchmove", this.activeListeners.handleMoveBody), this;
+    }
+    /**
+     * Method binding graph handlers
+     *
+     * @return {Sigma}
+     */
+  }, {
+    key: "bindGraphHandlers",
+    value: function() {
+      var e = this, t = this.graph, a = /* @__PURE__ */ new Set(["x", "y", "zIndex", "type"]);
+      return this.activeListeners.eachNodeAttributesUpdatedGraphUpdate = function(r) {
+        var o, h = (o = r.hints) === null || o === void 0 ? void 0 : o.attributes;
+        e.graph.forEachNode(function(l) {
+          return e.updateNode(l);
+        });
+        var d = !h || h.some(function(l) {
+          return a.has(l);
+        });
+        e.refresh({
+          partialGraph: {
+            nodes: t.nodes()
+          },
+          skipIndexation: !d,
+          schedule: !0
+        });
+      }, this.activeListeners.eachEdgeAttributesUpdatedGraphUpdate = function(r) {
+        var o, h = (o = r.hints) === null || o === void 0 ? void 0 : o.attributes;
+        e.graph.forEachEdge(function(l) {
+          return e.updateEdge(l);
+        });
+        var d = h && ["zIndex", "type"].some(function(l) {
+          return h == null ? void 0 : h.includes(l);
+        });
+        e.refresh({
+          partialGraph: {
+            edges: t.edges()
+          },
+          skipIndexation: !d,
+          schedule: !0
+        });
+      }, this.activeListeners.addNodeGraphUpdate = function(r) {
+        var o = r.key;
+        e.addNode(o), e.refresh({
+          partialGraph: {
+            nodes: [o]
+          },
+          skipIndexation: !1,
+          schedule: !0
+        });
+      }, this.activeListeners.updateNodeGraphUpdate = function(r) {
+        var o = r.key;
+        e.refresh({
+          partialGraph: {
+            nodes: [o]
+          },
+          skipIndexation: !1,
+          schedule: !0
+        });
+      }, this.activeListeners.dropNodeGraphUpdate = function(r) {
+        var o = r.key;
+        e.removeNode(o), e.refresh({
+          schedule: !0
+        });
+      }, this.activeListeners.addEdgeGraphUpdate = function(r) {
+        var o = r.key;
+        e.addEdge(o), e.refresh({
+          partialGraph: {
+            edges: [o]
+          },
+          schedule: !0
+        });
+      }, this.activeListeners.updateEdgeGraphUpdate = function(r) {
+        var o = r.key;
+        e.refresh({
+          partialGraph: {
+            edges: [o]
+          },
+          skipIndexation: !1,
+          schedule: !0
+        });
+      }, this.activeListeners.dropEdgeGraphUpdate = function(r) {
+        var o = r.key;
+        e.removeEdge(o), e.refresh({
+          schedule: !0
+        });
+      }, this.activeListeners.clearEdgesGraphUpdate = function() {
+        e.clearEdgeState(), e.clearEdgeIndices(), e.refresh({
+          schedule: !0
+        });
+      }, this.activeListeners.clearGraphUpdate = function() {
+        e.clearEdgeState(), e.clearNodeState(), e.clearEdgeIndices(), e.clearNodeIndices(), e.refresh({
+          schedule: !0
+        });
+      }, t.on("nodeAdded", this.activeListeners.addNodeGraphUpdate), t.on("nodeDropped", this.activeListeners.dropNodeGraphUpdate), t.on("nodeAttributesUpdated", this.activeListeners.updateNodeGraphUpdate), t.on("eachNodeAttributesUpdated", this.activeListeners.eachNodeAttributesUpdatedGraphUpdate), t.on("edgeAdded", this.activeListeners.addEdgeGraphUpdate), t.on("edgeDropped", this.activeListeners.dropEdgeGraphUpdate), t.on("edgeAttributesUpdated", this.activeListeners.updateEdgeGraphUpdate), t.on("eachEdgeAttributesUpdated", this.activeListeners.eachEdgeAttributesUpdatedGraphUpdate), t.on("edgesCleared", this.activeListeners.clearEdgesGraphUpdate), t.on("cleared", this.activeListeners.clearGraphUpdate), this;
+    }
+    /**
+     * Method used to unbind handlers from the graph.
+     *
+     * @return {undefined}
+     */
+  }, {
+    key: "unbindGraphHandlers",
+    value: function() {
+      var e = this.graph;
+      e.removeListener("nodeAdded", this.activeListeners.addNodeGraphUpdate), e.removeListener("nodeDropped", this.activeListeners.dropNodeGraphUpdate), e.removeListener("nodeAttributesUpdated", this.activeListeners.updateNodeGraphUpdate), e.removeListener("eachNodeAttributesUpdated", this.activeListeners.eachNodeAttributesUpdatedGraphUpdate), e.removeListener("edgeAdded", this.activeListeners.addEdgeGraphUpdate), e.removeListener("edgeDropped", this.activeListeners.dropEdgeGraphUpdate), e.removeListener("edgeAttributesUpdated", this.activeListeners.updateEdgeGraphUpdate), e.removeListener("eachEdgeAttributesUpdated", this.activeListeners.eachEdgeAttributesUpdatedGraphUpdate), e.removeListener("edgesCleared", this.activeListeners.clearEdgesGraphUpdate), e.removeListener("cleared", this.activeListeners.clearGraphUpdate);
+    }
+    /**
+     * Method looking for an edge colliding with a given point at (x, y). Returns
+     * the key of the edge if any, or null else.
+     */
+  }, {
+    key: "getEdgeAtPoint",
+    value: function(e, t) {
+      var a = ge(this.webGLContexts.edges, this.frameBuffers.edges, e, t, this.pixelRatio, this.pickingDownSizingRatio), r = ve.apply(void 0, Ee(a)), o = this.itemIDsIndex[r];
+      return o && o.type === "edge" ? o.id : null;
+    }
+    /**
+     * Method used to process the whole graph's data.
+     *  - extent
+     *  - normalizationFunction
+     *  - compute node's coordinate
+     *  - labelgrid
+     *  - program data allocation
+     * @return {Sigma}
+     */
+  }, {
+    key: "process",
+    value: function() {
+      var e = this;
+      this.emit("beforeProcess");
+      var t = this.graph, a = this.settings, r = this.getDimensions();
+      if (this.nodeExtent = et(this.graph), !this.settings.autoRescale) {
+        var o = r.width, h = r.height, d = this.nodeExtent, l = d.x, u = d.y;
+        this.nodeExtent = {
+          x: [(l[0] + l[1]) / 2 - o / 2, (l[0] + l[1]) / 2 + o / 2],
+          y: [(u[0] + u[1]) / 2 - h / 2, (u[0] + u[1]) / 2 + h / 2]
+        };
+      }
+      this.normalizationFunction = be(this.customBBox || this.nodeExtent);
+      var g = new Ce(), f = X(g.getState(), r, this.getGraphDimensions(), this.getStagePadding());
+      this.labelGrid.resizeAndClear(r, a.labelGridCellSize);
+      for (var m = {}, p = {}, y = {}, E = {}, b = 1, x = t.nodes(), C = 0, I = x.length; C < I; C++) {
+        var A = x[C], w = this.nodeDataCache[A], k = t.getNodeAttributes(A);
+        w.x = k.x, w.y = k.y, this.normalizationFunction.applyTo(w), typeof w.label == "string" && !w.hidden && this.labelGrid.add(A, w.size, this.framedGraphToViewport(w, {
+          matrix: f
+        })), m[w.type] = (m[w.type] || 0) + 1;
+      }
+      this.labelGrid.organize();
+      for (var T in this.nodePrograms) {
+        if (!z.call(this.nodePrograms, T))
+          throw new Error('Sigma: could not find a suitable program for node type "'.concat(T, '"!'));
+        this.nodePrograms[T].reallocate(m[T] || 0), m[T] = 0;
+      }
+      this.settings.zIndex && this.nodeZExtent[0] !== this.nodeZExtent[1] && (x = ye(this.nodeZExtent, function(re) {
+        return e.nodeDataCache[re].zIndex;
+      }, x));
+      for (var L = 0, D = x.length; L < D; L++) {
+        var S = x[L];
+        p[S] = b, E[p[S]] = {
+          type: "node",
+          id: S
+        }, b++;
+        var _ = this.nodeDataCache[S];
+        this.addNodeToProgram(S, p[S], m[_.type]++);
+      }
+      for (var P = {}, R = t.edges(), U = 0, $ = R.length; U < $; U++) {
+        var q = R[U], V = this.edgeDataCache[q];
+        P[V.type] = (P[V.type] || 0) + 1;
+      }
+      this.settings.zIndex && this.edgeZExtent[0] !== this.edgeZExtent[1] && (R = ye(this.edgeZExtent, function(re) {
+        return e.edgeDataCache[re].zIndex;
+      }, R));
+      for (var H in this.edgePrograms) {
+        if (!z.call(this.edgePrograms, H))
+          throw new Error('Sigma: could not find a suitable program for edge type "'.concat(H, '"!'));
+        this.edgePrograms[H].reallocate(P[H] || 0), P[H] = 0;
+      }
+      for (var B = 0, ae = R.length; B < ae; B++) {
+        var G = R[B];
+        y[G] = b, E[y[G]] = {
+          type: "edge",
+          id: G
+        }, b++;
+        var ke = this.edgeDataCache[G];
+        this.addEdgeToProgram(G, y[G], P[ke.type]++);
+      }
+      return this.itemIDsIndex = E, this.nodeIndices = p, this.edgeIndices = y, this.emit("afterProcess"), this;
+    }
+    /**
+     * Method that backports potential settings updates where it's needed.
+     * @private
+     */
+  }, {
+    key: "handleSettingsUpdate",
+    value: function(e) {
+      var t = this, a = this.settings;
+      if (this.camera.minRatio = a.minCameraRatio, this.camera.maxRatio = a.maxCameraRatio, this.camera.enabledZooming = a.enableCameraZooming, this.camera.enabledPanning = a.enableCameraPanning, this.camera.enabledRotation = a.enableCameraRotation, a.cameraPanBoundaries ? this.camera.clean = function(l) {
+        return t.cleanCameraState(l, a.cameraPanBoundaries && le(a.cameraPanBoundaries) === "object" ? a.cameraPanBoundaries : {});
+      } : this.camera.clean = null, this.camera.setState(this.camera.validateState(this.camera.getState())), e) {
+        if (e.edgeProgramClasses !== a.edgeProgramClasses) {
+          for (var r in a.edgeProgramClasses)
+            a.edgeProgramClasses[r] !== e.edgeProgramClasses[r] && this.registerEdgeProgram(r, a.edgeProgramClasses[r]);
+          for (var o in e.edgeProgramClasses)
+            a.edgeProgramClasses[o] || this.unregisterEdgeProgram(o);
+        }
+        if (e.nodeProgramClasses !== a.nodeProgramClasses || e.nodeHoverProgramClasses !== a.nodeHoverProgramClasses) {
+          for (var h in a.nodeProgramClasses)
+            (a.nodeProgramClasses[h] !== e.nodeProgramClasses[h] || a.nodeHoverProgramClasses[h] !== e.nodeHoverProgramClasses[h]) && this.registerNodeProgram(h, a.nodeProgramClasses[h], a.nodeHoverProgramClasses[h]);
+          for (var d in e.nodeProgramClasses)
+            a.nodeProgramClasses[d] || this.unregisterNodeProgram(d);
+        }
+      }
+      return this.mouseCaptor.setSettings(this.settings), this.touchCaptor.setSettings(this.settings), this;
+    }
+  }, {
+    key: "cleanCameraState",
+    value: function(e) {
+      var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, a = t.tolerance, r = a === void 0 ? 0 : a, o = t.boundaries, h = v({}, e), d = o || this.nodeExtent, l = Q(d.x, 2), u = l[0], g = l[1], f = Q(d.y, 2), m = f[0], p = f[1], y = [this.graphToViewport({
+        x: u,
+        y: m
+      }, {
+        cameraState: e
+      }), this.graphToViewport({
+        x: g,
+        y: m
+      }, {
+        cameraState: e
+      }), this.graphToViewport({
+        x: u,
+        y: p
+      }, {
+        cameraState: e
+      }), this.graphToViewport({
+        x: g,
+        y: p
+      }, {
+        cameraState: e
+      })], E = 1 / 0, b = -1 / 0, x = 1 / 0, C = -1 / 0;
+      y.forEach(function(P) {
+        var R = P.x, U = P.y;
+        E = Math.min(E, R), b = Math.max(b, R), x = Math.min(x, U), C = Math.max(C, U);
+      });
+      var I = b - E, A = C - x, w = this.getDimensions(), k = w.width, T = w.height, L = 0, D = 0;
+      if (I >= k ? b < k - r ? L = b - (k - r) : E > r && (L = E - r) : b > k + r ? L = b - (k + r) : E < -r && (L = E + r), A >= T ? C < T - r ? D = C - (T - r) : x > r && (D = x - r) : C > T + r ? D = C - (T + r) : x < -r && (D = x + r), L || D) {
+        var S = this.viewportToFramedGraph({
+          x: 0,
+          y: 0
+        }, {
+          cameraState: e
+        }), _ = this.viewportToFramedGraph({
+          x: L,
+          y: D
+        }, {
+          cameraState: e
+        });
+        L = _.x - S.x, D = _.y - S.y, h.x += L, h.y += D;
+      }
+      return h;
+    }
+    /**
+     * Method used to render labels.
+     *
+     * @return {Sigma}
+     */
+  }, {
+    key: "renderLabels",
+    value: function() {
+      if (!this.settings.renderLabels) return this;
+      var e = this.camera.getState(), t = this.labelGrid.getLabelsToDisplay(e.ratio, this.settings.labelDensity);
+      xe(t, this.nodesWithForcedLabels), this.displayedNodeLabels = /* @__PURE__ */ new Set();
+      for (var a = this.canvasContexts.labels, r = 0, o = t.length; r < o; r++) {
+        var h = t[r], d = this.nodeDataCache[h];
+        if (!this.displayedNodeLabels.has(h) && !d.hidden) {
+          var l = this.framedGraphToViewport(d), u = l.x, g = l.y, f = this.scaleSize(d.size);
+          if (!(!d.forceLabel && f < this.settings.labelRenderedSizeThreshold) && !(u < -Se || u > this.width + Se || g < -Pe || g > this.height + Pe)) {
+            this.displayedNodeLabels.add(h);
+            var m = this.settings.defaultDrawNodeLabel, p = this.nodePrograms[d.type], y = (p == null ? void 0 : p.drawLabel) || m;
+            y(a, v(v({
+              key: h
+            }, d), {}, {
+              size: f,
+              x: u,
+              y: g
+            }), this.settings);
+          }
+        }
+      }
+      return this;
+    }
+    /**
+     * Method used to render edge labels, based on which node labels were
+     * rendered.
+     *
+     * @return {Sigma}
+     */
+  }, {
+    key: "renderEdgeLabels",
+    value: function() {
+      if (!this.settings.renderEdgeLabels) return this;
+      var e = this.canvasContexts.edgeLabels;
+      e.clearRect(0, 0, this.width, this.height);
+      var t = yt({
+        graph: this.graph,
+        hoveredNode: this.hoveredNode,
+        displayedNodeLabels: this.displayedNodeLabels,
+        highlightedNodes: this.highlightedNodes
+      });
+      xe(t, this.edgesWithForcedLabels);
+      for (var a = /* @__PURE__ */ new Set(), r = 0, o = t.length; r < o; r++) {
+        var h = t[r], d = this.graph.extremities(h), l = this.nodeDataCache[d[0]], u = this.nodeDataCache[d[1]], g = this.edgeDataCache[h];
+        if (!a.has(h) && !(g.hidden || l.hidden || u.hidden)) {
+          var f = this.settings.defaultDrawEdgeLabel, m = this.edgePrograms[g.type], p = (m == null ? void 0 : m.drawLabel) || f;
+          p(e, v(v({
+            key: h
+          }, g), {}, {
+            size: this.scaleSize(g.size)
+          }), v(v(v({
+            key: d[0]
+          }, l), this.framedGraphToViewport(l)), {}, {
+            size: this.scaleSize(l.size)
+          }), v(v(v({
+            key: d[1]
+          }, u), this.framedGraphToViewport(u)), {}, {
+            size: this.scaleSize(u.size)
+          }), this.settings), a.add(h);
+        }
+      }
+      return this.displayedEdgeLabels = a, this;
+    }
+    /**
+     * Method used to render the highlighted nodes.
+     *
+     * @return {Sigma}
+     */
+  }, {
+    key: "renderHighlightedNodes",
+    value: function() {
+      var e = this, t = this.canvasContexts.hovers;
+      t.clearRect(0, 0, this.width, this.height);
+      var a = function(f) {
+        var m = e.nodeDataCache[f], p = e.framedGraphToViewport(m), y = p.x, E = p.y, b = e.scaleSize(m.size), x = e.settings.defaultDrawNodeHover, C = e.nodePrograms[m.type], I = (C == null ? void 0 : C.drawHover) || x;
+        I(t, v(v({
+          key: f
+        }, m), {}, {
+          size: b,
+          x: y,
+          y: E
+        }), e.settings);
+      }, r = [];
+      this.hoveredNode && !this.nodeDataCache[this.hoveredNode].hidden && r.push(this.hoveredNode), this.highlightedNodes.forEach(function(g) {
+        g !== e.hoveredNode && r.push(g);
+      }), r.forEach(function(g) {
+        return a(g);
+      });
+      var o = {};
+      r.forEach(function(g) {
+        var f = e.nodeDataCache[g].type;
+        o[f] = (o[f] || 0) + 1;
+      });
+      for (var h in this.nodeHoverPrograms)
+        this.nodeHoverPrograms[h].reallocate(o[h] || 0), o[h] = 0;
+      r.forEach(function(g) {
+        var f = e.nodeDataCache[g];
+        e.nodeHoverPrograms[f.type].process(0, o[f.type]++, f);
+      }), this.webGLContexts.hoverNodes.clear(this.webGLContexts.hoverNodes.COLOR_BUFFER_BIT);
+      var d = this.getRenderParams();
+      for (var l in this.nodeHoverPrograms) {
+        var u = this.nodeHoverPrograms[l];
+        u.render(d);
+      }
+    }
+    /**
+     * Method used to schedule a hover render.
+     *
+     */
+  }, {
+    key: "scheduleHighlightedNodesRender",
+    value: function() {
+      var e = this;
+      this.renderHighlightedNodesFrame || this.renderFrame || (this.renderHighlightedNodesFrame = requestAnimationFrame(function() {
+        e.renderHighlightedNodesFrame = null, e.renderHighlightedNodes(), e.renderEdgeLabels();
+      }));
+    }
+    /**
+     * Method used to render.
+     *
+     * @return {Sigma}
+     */
+  }, {
+    key: "render",
+    value: function() {
+      var e = this;
+      this.emit("beforeRender");
+      var t = function() {
+        return e.emit("afterRender"), e;
+      };
+      if (this.renderFrame && (cancelAnimationFrame(this.renderFrame), this.renderFrame = null), this.resize(), this.needToProcess && this.process(), this.needToProcess = !1, this.clear(), this.pickingLayers.forEach(function(y) {
+        return e.resetWebGLTexture(y);
+      }), !this.graph.order) return t();
+      var a = this.mouseCaptor, r = this.camera.isAnimated() || a.isMoving || a.draggedEvents || a.currentWheelDirection, o = this.camera.getState(), h = this.getDimensions(), d = this.getGraphDimensions(), l = this.getStagePadding();
+      this.matrix = X(o, h, d, l), this.invMatrix = X(o, h, d, l, !0), this.correctionRatio = $e(this.matrix, o, h), this.graphToViewportRatio = this.getGraphToViewportRatio();
+      var u = this.getRenderParams();
+      for (var g in this.nodePrograms) {
+        var f = this.nodePrograms[g];
+        f.render(u);
+      }
+      if (!this.settings.hideEdgesOnMove || !r)
+        for (var m in this.edgePrograms) {
+          var p = this.edgePrograms[m];
+          p.render(u);
+        }
+      return this.settings.hideLabelsOnMove && r || (this.renderLabels(), this.renderEdgeLabels(), this.renderHighlightedNodes()), t();
+    }
+    /**
+     * Add a node in the internal data structures.
+     * @private
+     * @param key The node's graphology ID
+     */
+  }, {
+    key: "addNode",
+    value: function(e) {
+      var t = Object.assign({}, this.graph.getNodeAttributes(e));
+      this.settings.nodeReducer && (t = this.settings.nodeReducer(e, t));
+      var a = bt(this.settings, e, t);
+      this.nodeDataCache[e] = a, this.nodesWithForcedLabels.delete(e), a.forceLabel && !a.hidden && this.nodesWithForcedLabels.add(e), this.highlightedNodes.delete(e), a.highlighted && !a.hidden && this.highlightedNodes.add(e), this.settings.zIndex && (a.zIndex < this.nodeZExtent[0] && (this.nodeZExtent[0] = a.zIndex), a.zIndex > this.nodeZExtent[1] && (this.nodeZExtent[1] = a.zIndex));
+    }
+    /**
+     * Update a node the internal data structures.
+     * @private
+     * @param key The node's graphology ID
+     */
+  }, {
+    key: "updateNode",
+    value: function(e) {
+      this.addNode(e);
+      var t = this.nodeDataCache[e];
+      this.normalizationFunction.applyTo(t);
+    }
+    /**
+     * Remove a node from the internal data structures.
+     * @private
+     * @param key The node's graphology ID
+     */
+  }, {
+    key: "removeNode",
+    value: function(e) {
+      delete this.nodeDataCache[e], delete this.nodeProgramIndex[e], this.highlightedNodes.delete(e), this.hoveredNode === e && (this.hoveredNode = null), this.nodesWithForcedLabels.delete(e);
+    }
+    /**
+     * Add an edge into the internal data structures.
+     * @private
+     * @param key The edge's graphology ID
+     */
+  }, {
+    key: "addEdge",
+    value: function(e) {
+      var t = Object.assign({}, this.graph.getEdgeAttributes(e));
+      this.settings.edgeReducer && (t = this.settings.edgeReducer(e, t));
+      var a = xt(this.settings, e, t);
+      this.edgeDataCache[e] = a, this.edgesWithForcedLabels.delete(e), a.forceLabel && !a.hidden && this.edgesWithForcedLabels.add(e), this.settings.zIndex && (a.zIndex < this.edgeZExtent[0] && (this.edgeZExtent[0] = a.zIndex), a.zIndex > this.edgeZExtent[1] && (this.edgeZExtent[1] = a.zIndex));
+    }
+    /**
+     * Update an edge in the internal data structures.
+     * @private
+     * @param key The edge's graphology ID
+     */
+  }, {
+    key: "updateEdge",
+    value: function(e) {
+      this.addEdge(e);
+    }
+    /**
+     * Remove an edge from the internal data structures.
+     * @private
+     * @param key The edge's graphology ID
+     */
+  }, {
+    key: "removeEdge",
+    value: function(e) {
+      delete this.edgeDataCache[e], delete this.edgeProgramIndex[e], this.hoveredEdge === e && (this.hoveredEdge = null), this.edgesWithForcedLabels.delete(e);
+    }
+    /**
+     * Clear all indices related to nodes.
+     * @private
+     */
+  }, {
+    key: "clearNodeIndices",
+    value: function() {
+      this.labelGrid = new Le(), this.nodeExtent = {
+        x: [0, 1],
+        y: [0, 1]
+      }, this.nodeDataCache = {}, this.edgeProgramIndex = {}, this.nodesWithForcedLabels = /* @__PURE__ */ new Set(), this.nodeZExtent = [1 / 0, -1 / 0], this.highlightedNodes = /* @__PURE__ */ new Set();
+    }
+    /**
+     * Clear all indices related to edges.
+     * @private
+     */
+  }, {
+    key: "clearEdgeIndices",
+    value: function() {
+      this.edgeDataCache = {}, this.edgeProgramIndex = {}, this.edgesWithForcedLabels = /* @__PURE__ */ new Set(), this.edgeZExtent = [1 / 0, -1 / 0];
+    }
+    /**
+     * Clear all indices.
+     * @private
+     */
+  }, {
+    key: "clearIndices",
+    value: function() {
+      this.clearEdgeIndices(), this.clearNodeIndices();
+    }
+    /**
+     * Clear all graph state related to nodes.
+     * @private
+     */
+  }, {
+    key: "clearNodeState",
+    value: function() {
+      this.displayedNodeLabels = /* @__PURE__ */ new Set(), this.highlightedNodes = /* @__PURE__ */ new Set(), this.hoveredNode = null;
+    }
+    /**
+     * Clear all graph state related to edges.
+     * @private
+     */
+  }, {
+    key: "clearEdgeState",
+    value: function() {
+      this.displayedEdgeLabels = /* @__PURE__ */ new Set(), this.highlightedNodes = /* @__PURE__ */ new Set(), this.hoveredEdge = null;
+    }
+    /**
+     * Clear all graph state.
+     * @private
+     */
+  }, {
+    key: "clearState",
+    value: function() {
+      this.clearEdgeState(), this.clearNodeState();
+    }
+    /**
+     * Add the node data to its program.
+     * @private
+     * @param node The node's graphology ID
+     * @param fingerprint A fingerprint used to identity the node with picking
+     * @param position The index where to place the node in the program
+     */
+  }, {
+    key: "addNodeToProgram",
+    value: function(e, t, a) {
+      var r = this.nodeDataCache[e], o = this.nodePrograms[r.type];
+      if (!o) throw new Error('Sigma: could not find a suitable program for node type "'.concat(r.type, '"!'));
+      o.process(t, a, r), this.nodeProgramIndex[e] = a;
+    }
+    /**
+     * Add the edge data to its program.
+     * @private
+     * @param edge The edge's graphology ID
+     * @param fingerprint A fingerprint used to identity the edge with picking
+     * @param position The index where to place the edge in the program
+     */
+  }, {
+    key: "addEdgeToProgram",
+    value: function(e, t, a) {
+      var r = this.edgeDataCache[e], o = this.edgePrograms[r.type];
+      if (!o) throw new Error('Sigma: could not find a suitable program for edge type "'.concat(r.type, '"!'));
+      var h = this.graph.extremities(e), d = this.nodeDataCache[h[0]], l = this.nodeDataCache[h[1]];
+      o.process(t, a, d, l, r), this.edgeProgramIndex[e] = a;
+    }
+    /**---------------------------------------------------------------------------
+     * Public API.
+     **---------------------------------------------------------------------------
+     */
+    /**
+     * Function used to get the render params.
+     *
+     * @return {RenderParams}
+     */
+  }, {
+    key: "getRenderParams",
+    value: function() {
+      return {
+        matrix: this.matrix,
+        invMatrix: this.invMatrix,
+        width: this.width,
+        height: this.height,
+        pixelRatio: this.pixelRatio,
+        zoomRatio: this.camera.ratio,
+        cameraAngle: this.camera.angle,
+        sizeRatio: 1 / this.scaleSize(),
+        correctionRatio: this.correctionRatio,
+        downSizingRatio: this.pickingDownSizingRatio,
+        minEdgeThickness: this.settings.minEdgeThickness,
+        antiAliasingFeather: this.settings.antiAliasingFeather
+      };
+    }
+    /**
+     * Function used to retrieve the actual stage padding value.
+     *
+     * @return {number}
+     */
+  }, {
+    key: "getStagePadding",
+    value: function() {
+      var e = this.settings, t = e.stagePadding, a = e.autoRescale;
+      return a && t || 0;
+    }
+    /**
+     * Function used to create a layer element.
+     *
+     * @param {string} id - Context's id.
+     * @param {string} tag - The HTML tag to use.
+     * @param options
+     * @return {Sigma}
+     */
+  }, {
+    key: "createLayer",
+    value: function(e, t) {
+      var a = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+      if (this.elements[e]) throw new Error('Sigma: a layer named "'.concat(e, '" already exists'));
+      var r = it(t, {
+        position: "absolute"
+      }, {
+        class: "sigma-".concat(e)
+      });
+      return a.style && Object.assign(r.style, a.style), this.elements[e] = r, "beforeLayer" in a && a.beforeLayer ? this.elements[a.beforeLayer].before(r) : "afterLayer" in a && a.afterLayer ? this.elements[a.afterLayer].after(r) : this.container.appendChild(r), r;
+    }
+    /**
+     * Function used to create a canvas element.
+     *
+     * @param {string} id - Context's id.
+     * @param options
+     * @return {Sigma}
+     */
+  }, {
+    key: "createCanvas",
+    value: function(e) {
+      var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+      return this.createLayer(e, "canvas", t);
+    }
+    /**
+     * Function used to create a canvas context and add the relevant DOM elements.
+     *
+     * @param  {string} id - Context's id.
+     * @param  options
+     * @return {Sigma}
+     */
+  }, {
+    key: "createCanvasContext",
+    value: function(e) {
+      var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, a = this.createCanvas(e, t), r = {
+        preserveDrawingBuffer: !1,
+        antialias: !1
+      };
+      return this.canvasContexts[e] = a.getContext("2d", r), this;
+    }
+    /**
+     * Function used to create a WebGL context and add the relevant DOM
+     * elements.
+     *
+     * @param  {string}  id      - Context's id.
+     * @param  {object?} options - #getContext params to override (optional)
+     * @return {WebGLRenderingContext}
+     */
+  }, {
+    key: "createWebGLContext",
+    value: function(e) {
+      var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, a = (t == null ? void 0 : t.canvas) || this.createCanvas(e, t);
+      t.hidden && a.remove();
+      var r = v({
+        preserveDrawingBuffer: !1,
+        antialias: !1
+      }, t), o;
+      o = a.getContext("webgl2", r), o || (o = a.getContext("webgl", r)), o || (o = a.getContext("experimental-webgl", r));
+      var h = o;
+      if (this.webGLContexts[e] = h, h.blendFunc(h.ONE, h.ONE_MINUS_SRC_ALPHA), t.picking) {
+        this.pickingLayers.add(e);
+        var d = h.createFramebuffer();
+        if (!d) throw new Error("Sigma: cannot create a new frame buffer for layer ".concat(e));
+        this.frameBuffers[e] = d;
+      }
+      return h;
+    }
+    /**
+     * Function used to properly kill a layer.
+     *
+     * @param  {string} id - Layer id.
+     * @return {Sigma}
+     */
+  }, {
+    key: "killLayer",
+    value: function(e) {
+      var t = this.elements[e];
+      if (!t) throw new Error("Sigma: cannot kill layer ".concat(e, ", which does not exist"));
+      if (this.webGLContexts[e]) {
+        var a, r = this.webGLContexts[e];
+        (a = r.getExtension("WEBGL_lose_context")) === null || a === void 0 || a.loseContext(), delete this.webGLContexts[e];
+      } else this.canvasContexts[e] && delete this.canvasContexts[e];
+      return t.remove(), delete this.elements[e], this;
+    }
+    /**
+     * Method returning the renderer's camera.
+     *
+     * @return {Camera}
+     */
+  }, {
+    key: "getCamera",
+    value: function() {
+      return this.camera;
+    }
+    /**
+     * Method setting the renderer's camera.
+     *
+     * @param  {Camera} camera - New camera.
+     * @return {Sigma}
+     */
+  }, {
+    key: "setCamera",
+    value: function(e) {
+      this.unbindCameraHandlers(), this.camera = e, this.bindCameraHandlers();
+    }
+    /**
+     * Method returning the container DOM element.
+     *
+     * @return {HTMLElement}
+     */
+  }, {
+    key: "getContainer",
+    value: function() {
+      return this.container;
+    }
+    /**
+     * Method returning the renderer's graph.
+     *
+     * @return {Graph}
+     */
+  }, {
+    key: "getGraph",
+    value: function() {
+      return this.graph;
+    }
+    /**
+     * Method used to set the renderer's graph.
+     *
+     * @return {Graph}
+     */
+  }, {
+    key: "setGraph",
+    value: function(e) {
+      e !== this.graph && (this.hoveredNode && !e.hasNode(this.hoveredNode) && (this.hoveredNode = null), this.hoveredEdge && !e.hasEdge(this.hoveredEdge) && (this.hoveredEdge = null), this.unbindGraphHandlers(), this.checkEdgesEventsFrame !== null && (cancelAnimationFrame(this.checkEdgesEventsFrame), this.checkEdgesEventsFrame = null), this.graph = e, this.bindGraphHandlers(), this.refresh());
+    }
+    /**
+     * Method returning the mouse captor.
+     *
+     * @return {MouseCaptor}
+     */
+  }, {
+    key: "getMouseCaptor",
+    value: function() {
+      return this.mouseCaptor;
+    }
+    /**
+     * Method returning the touch captor.
+     *
+     * @return {TouchCaptor}
+     */
+  }, {
+    key: "getTouchCaptor",
+    value: function() {
+      return this.touchCaptor;
+    }
+    /**
+     * Method returning the current renderer's dimensions.
+     *
+     * @return {Dimensions}
+     */
+  }, {
+    key: "getDimensions",
+    value: function() {
+      return {
+        width: this.width,
+        height: this.height
+      };
+    }
+    /**
+     * Method returning the current graph's dimensions.
+     *
+     * @return {Dimensions}
+     */
+  }, {
+    key: "getGraphDimensions",
+    value: function() {
+      var e = this.customBBox || this.nodeExtent;
+      return {
+        width: e.x[1] - e.x[0] || 1,
+        height: e.y[1] - e.y[0] || 1
+      };
+    }
+    /**
+     * Method used to get all the sigma node attributes.
+     * It's useful for example to get the position of a node
+     * and to get values that are set by the nodeReducer
+     *
+     * @param  {string} key - The node's key.
+     * @return {NodeDisplayData | undefined} A copy of the desired node's attribute or undefined if not found
+     */
+  }, {
+    key: "getNodeDisplayData",
+    value: function(e) {
+      var t = this.nodeDataCache[e];
+      return t ? Object.assign({}, t) : void 0;
+    }
+    /**
+     * Method used to get all the sigma edge attributes.
+     * It's useful for example to get values that are set by the edgeReducer.
+     *
+     * @param  {string} key - The edge's key.
+     * @return {EdgeDisplayData | undefined} A copy of the desired edge's attribute or undefined if not found
+     */
+  }, {
+    key: "getEdgeDisplayData",
+    value: function(e) {
+      var t = this.edgeDataCache[e];
+      return t ? Object.assign({}, t) : void 0;
+    }
+    /**
+     * Method used to get the set of currently displayed node labels.
+     *
+     * @return {Set<string>} A set of node keys whose label is displayed.
+     */
+  }, {
+    key: "getNodeDisplayedLabels",
+    value: function() {
+      return new Set(this.displayedNodeLabels);
+    }
+    /**
+     * Method used to get the set of currently displayed edge labels.
+     *
+     * @return {Set<string>} A set of edge keys whose label is displayed.
+     */
+  }, {
+    key: "getEdgeDisplayedLabels",
+    value: function() {
+      return new Set(this.displayedEdgeLabels);
+    }
+    /**
+     * Method returning a copy of the settings collection.
+     *
+     * @return {Settings} A copy of the settings collection.
+     */
+  }, {
+    key: "getSettings",
+    value: function() {
+      return v({}, this.settings);
+    }
+    /**
+     * Method returning the current value for a given setting key.
+     *
+     * @param  {string} key - The setting key to get.
+     * @return {any} The value attached to this setting key or undefined if not found
+     */
+  }, {
+    key: "getSetting",
+    value: function(e) {
+      return this.settings[e];
+    }
+    /**
+     * Method setting the value of a given setting key. Note that this will schedule
+     * a new render next frame.
+     *
+     * @param  {string} key - The setting key to set.
+     * @param  {any}    value - The value to set.
+     * @return {Sigma}
+     */
+  }, {
+    key: "setSetting",
+    value: function(e, t) {
+      var a = v({}, this.settings);
+      return this.settings[e] = t, oe(this.settings), this.handleSettingsUpdate(a), this.scheduleRefresh(), this;
+    }
+    /**
+     * Method updating the value of a given setting key using the provided function.
+     * Note that this will schedule a new render next frame.
+     *
+     * @param  {string}   key     - The setting key to set.
+     * @param  {function} updater - The update function.
+     * @return {Sigma}
+     */
+  }, {
+    key: "updateSetting",
+    value: function(e, t) {
+      return this.setSetting(e, t(this.settings[e])), this;
+    }
+    /**
+     * Method setting multiple settings at once.
+     *
+     * @param  {Partial<Settings>} settings - The settings to set.
+     * @return {Sigma}
+     */
+  }, {
+    key: "setSettings",
+    value: function(e) {
+      var t = v({}, this.settings);
+      return this.settings = v(v({}, this.settings), e), oe(this.settings), this.handleSettingsUpdate(t), this.scheduleRefresh(), this;
+    }
+    /**
+     * Method used to resize the renderer.
+     *
+     * @param  {boolean} force - If true, then resize is processed even if size is unchanged (optional).
+     * @return {Sigma}
+     */
+  }, {
+    key: "resize",
+    value: function(e) {
+      var t = this.width, a = this.height;
+      if (this.width = this.container.offsetWidth, this.height = this.container.offsetHeight, this.pixelRatio = pe(), this.width === 0)
+        if (this.settings.allowInvalidContainer) this.width = 1;
+        else throw new Error("Sigma: Container has no width. You can set the allowInvalidContainer setting to true to stop seeing this error.");
+      if (this.height === 0)
+        if (this.settings.allowInvalidContainer) this.height = 1;
+        else throw new Error("Sigma: Container has no height. You can set the allowInvalidContainer setting to true to stop seeing this error.");
+      if (!e && t === this.width && a === this.height) return this;
+      for (var r in this.elements) {
+        var o = this.elements[r];
+        o.style.width = this.width + "px", o.style.height = this.height + "px";
+      }
+      for (var h in this.canvasContexts)
+        this.elements[h].setAttribute("width", this.width * this.pixelRatio + "px"), this.elements[h].setAttribute("height", this.height * this.pixelRatio + "px"), this.pixelRatio !== 1 && this.canvasContexts[h].scale(this.pixelRatio, this.pixelRatio);
+      for (var d in this.webGLContexts) {
+        this.elements[d].setAttribute("width", this.width * this.pixelRatio + "px"), this.elements[d].setAttribute("height", this.height * this.pixelRatio + "px");
+        var l = this.webGLContexts[d];
+        if (l.viewport(0, 0, this.width * this.pixelRatio, this.height * this.pixelRatio), this.pickingLayers.has(d)) {
+          var u = this.textures[d];
+          u && l.deleteTexture(u);
+        }
+      }
+      return this.emit("resize"), this;
+    }
+    /**
+     * Method used to clear all the canvases.
+     *
+     * @return {Sigma}
+     */
+  }, {
+    key: "clear",
+    value: function() {
+      return this.emit("beforeClear"), this.webGLContexts.nodes.bindFramebuffer(WebGLRenderingContext.FRAMEBUFFER, null), this.webGLContexts.nodes.clear(WebGLRenderingContext.COLOR_BUFFER_BIT), this.webGLContexts.edges.bindFramebuffer(WebGLRenderingContext.FRAMEBUFFER, null), this.webGLContexts.edges.clear(WebGLRenderingContext.COLOR_BUFFER_BIT), this.webGLContexts.hoverNodes.clear(WebGLRenderingContext.COLOR_BUFFER_BIT), this.canvasContexts.labels.clearRect(0, 0, this.width, this.height), this.canvasContexts.hovers.clearRect(0, 0, this.width, this.height), this.canvasContexts.edgeLabels.clearRect(0, 0, this.width, this.height), this.emit("afterClear"), this;
+    }
+    /**
+     * Method used to refresh, i.e. force the renderer to reprocess graph
+     * data and render, but keep the state.
+     * - if a partialGraph is provided, we only reprocess those nodes & edges.
+     * - if schedule is TRUE, we schedule a render instead of sync render
+     * - if skipIndexation is TRUE, then labelGrid & program indexation are skipped (can be used if you haven't modify x, y, zIndex & size)
+     *
+     * @return {Sigma}
+     */
+  }, {
+    key: "refresh",
+    value: function(e) {
+      var t = this, a = (e == null ? void 0 : e.skipIndexation) !== void 0 ? e == null ? void 0 : e.skipIndexation : !1, r = (e == null ? void 0 : e.schedule) !== void 0 ? e.schedule : !1, o = !e || !e.partialGraph;
+      if (o)
+        this.clearEdgeIndices(), this.clearNodeIndices(), this.graph.forEachNode(function(C) {
+          return t.addNode(C);
+        }), this.graph.forEachEdge(function(C) {
+          return t.addEdge(C);
+        });
+      else {
+        for (var h, d, l = ((h = e.partialGraph) === null || h === void 0 ? void 0 : h.nodes) || [], u = 0, g = (l == null ? void 0 : l.length) || 0; u < g; u++) {
+          var f = l[u];
+          if (this.updateNode(f), a) {
+            var m = this.nodeProgramIndex[f];
+            if (m === void 0) throw new Error('Sigma: node "'.concat(f, `" can't be repaint`));
+            this.addNodeToProgram(f, this.nodeIndices[f], m);
+          }
+        }
+        for (var p = (e == null || (d = e.partialGraph) === null || d === void 0 ? void 0 : d.edges) || [], y = 0, E = p.length; y < E; y++) {
+          var b = p[y];
+          if (this.updateEdge(b), a) {
+            var x = this.edgeProgramIndex[b];
+            if (x === void 0) throw new Error('Sigma: edge "'.concat(b, `" can't be repaint`));
+            this.addEdgeToProgram(b, this.edgeIndices[b], x);
+          }
+        }
+      }
+      return (o || !a) && (this.needToProcess = !0), r ? this.scheduleRender() : this.render(), this;
+    }
+    /**
+     * Method used to schedule a render at the next available frame.
+     * This method can be safely called on a same frame because it basically
+     * debounces refresh to the next frame.
+     *
+     * @return {Sigma}
+     */
+  }, {
+    key: "scheduleRender",
+    value: function() {
+      var e = this;
+      return this.renderFrame || (this.renderFrame = requestAnimationFrame(function() {
+        e.render();
+      })), this;
+    }
+    /**
+     * Method used to schedule a refresh (i.e. fully reprocess graph data and render)
+     * at the next available frame.
+     * This method can be safely called on a same frame because it basically
+     * debounces refresh to the next frame.
+     *
+     * @return {Sigma}
+     */
+  }, {
+    key: "scheduleRefresh",
+    value: function(e) {
+      return this.refresh(v(v({}, e), {}, {
+        schedule: !0
+      }));
+    }
+    /**
+     * Method used to (un)zoom, while preserving the position of a viewport point.
+     * Used for instance to zoom "on the mouse cursor".
+     *
+     * @param viewportTarget
+     * @param newRatio
+     * @return {CameraState}
+     */
+  }, {
+    key: "getViewportZoomedState",
+    value: function(e, t) {
+      var a = this.camera.getState(), r = a.ratio, o = a.angle, h = a.x, d = a.y, l = this.settings, u = l.minCameraRatio, g = l.maxCameraRatio;
+      typeof g == "number" && (t = Math.min(t, g)), typeof u == "number" && (t = Math.max(t, u));
+      var f = t / r, m = {
+        x: this.width / 2,
+        y: this.height / 2
+      }, p = this.viewportToFramedGraph(e), y = this.viewportToFramedGraph(m);
+      return {
+        angle: o,
+        x: (p.x - y.x) * (1 - f) + h,
+        y: (p.y - y.y) * (1 - f) + d,
+        ratio: t
+      };
+    }
+    /**
+     * Method returning the abstract rectangle containing the graph according
+     * to the camera's state.
+     *
+     * @return {object} - The view's rectangle.
+     */
+  }, {
+    key: "viewRectangle",
+    value: function() {
+      var e = this.viewportToFramedGraph({
+        x: 0,
+        y: 0
+      }), t = this.viewportToFramedGraph({
+        x: this.width,
+        y: 0
+      }), a = this.viewportToFramedGraph({
+        x: 0,
+        y: this.height
+      });
+      return {
+        x1: e.x,
+        y1: e.y,
+        x2: t.x,
+        y2: t.y,
+        height: t.y - a.y
+      };
+    }
+    /**
+     * Method returning the coordinates of a point from the framed graph system to the viewport system. It allows
+     * overriding anything that is used to get the translation matrix, or even the matrix itself.
+     *
+     * Be careful if overriding dimensions, padding or cameraState, as the computation of the matrix is not the lightest
+     * of computations.
+     */
+  }, {
+    key: "framedGraphToViewport",
+    value: function(e) {
+      var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, a = !!t.cameraState || !!t.viewportDimensions || !!t.graphDimensions, r = t.matrix ? t.matrix : a ? X(t.cameraState || this.camera.getState(), t.viewportDimensions || this.getDimensions(), t.graphDimensions || this.getGraphDimensions(), t.padding || this.getStagePadding()) : this.matrix, o = de(r, e);
+      return {
+        x: (1 + o.x) * this.width / 2,
+        y: (1 - o.y) * this.height / 2
+      };
+    }
+    /**
+     * Method returning the coordinates of a point from the viewport system to the framed graph system. It allows
+     * overriding anything that is used to get the translation matrix, or even the matrix itself.
+     *
+     * Be careful if overriding dimensions, padding or cameraState, as the computation of the matrix is not the lightest
+     * of computations.
+     */
+  }, {
+    key: "viewportToFramedGraph",
+    value: function(e) {
+      var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, a = !!t.cameraState || !!t.viewportDimensions || !t.graphDimensions, r = t.matrix ? t.matrix : a ? X(t.cameraState || this.camera.getState(), t.viewportDimensions || this.getDimensions(), t.graphDimensions || this.getGraphDimensions(), t.padding || this.getStagePadding(), !0) : this.invMatrix, o = de(r, {
+        x: e.x / this.width * 2 - 1,
+        y: 1 - e.y / this.height * 2
+      });
+      return isNaN(o.x) && (o.x = 0), isNaN(o.y) && (o.y = 0), o;
+    }
+    /**
+     * Method used to translate a point's coordinates from the viewport system (pixel distance from the top-left of the
+     * stage) to the graph system (the reference system of data as they are in the given graph instance).
+     *
+     * This method accepts an optional camera which can be useful if you need to translate coordinates
+     * based on a different view than the one being currently being displayed on screen.
+     *
+     * @param {Coordinates}                  viewportPoint
+     * @param {CoordinateConversionOverride} override
+     */
+  }, {
+    key: "viewportToGraph",
+    value: function(e) {
+      var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+      return this.normalizationFunction.inverse(this.viewportToFramedGraph(e, t));
+    }
+    /**
+     * Method used to translate a point's coordinates from the graph system (the reference system of data as they are in
+     * the given graph instance) to the viewport system (pixel distance from the top-left of the stage).
+     *
+     * This method accepts an optional camera which can be useful if you need to translate coordinates
+     * based on a different view than the one being currently being displayed on screen.
+     *
+     * @param {Coordinates}                  graphPoint
+     * @param {CoordinateConversionOverride} override
+     */
+  }, {
+    key: "graphToViewport",
+    value: function(e) {
+      var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+      return this.framedGraphToViewport(this.normalizationFunction(e), t);
+    }
+    /**
+     * Method returning the distance multiplier between the graph system and the
+     * viewport system.
+     */
+  }, {
+    key: "getGraphToViewportRatio",
+    value: function() {
+      var e = {
+        x: 0,
+        y: 0
+      }, t = {
+        x: 1,
+        y: 1
+      }, a = Math.sqrt(Math.pow(e.x - t.x, 2) + Math.pow(e.y - t.y, 2)), r = this.graphToViewport(e), o = this.graphToViewport(t), h = Math.sqrt(Math.pow(r.x - o.x, 2) + Math.pow(r.y - o.y, 2));
+      return h / a;
+    }
+    /**
+     * Method returning the graph's bounding box.
+     *
+     * @return {{ x: Extent, y: Extent }}
+     */
+  }, {
+    key: "getBBox",
+    value: function() {
+      return this.nodeExtent;
+    }
+    /**
+     * Method returning the graph's custom bounding box, if any.
+     *
+     * @return {{ x: Extent, y: Extent } | null}
+     */
+  }, {
+    key: "getCustomBBox",
+    value: function() {
+      return this.customBBox;
+    }
+    /**
+     * Method used to override the graph's bounding box with a custom one. Give `null` as the argument to stop overriding.
+     *
+     * @return {Sigma}
+     */
+  }, {
+    key: "setCustomBBox",
+    value: function(e) {
+      return this.customBBox = e, this.scheduleRender(), this;
+    }
+    /**
+     * Method used to shut the container & release event listeners.
+     *
+     * @return {undefined}
+     */
+  }, {
+    key: "kill",
+    value: function() {
+      this.emit("kill"), this.removeAllListeners(), this.unbindCameraHandlers(), window.removeEventListener("resize", this.activeListeners.handleResize), this.mouseCaptor.kill(), this.touchCaptor.kill(), this.unbindGraphHandlers(), this.clearIndices(), this.clearState(), this.nodeDataCache = {}, this.edgeDataCache = {}, this.highlightedNodes.clear(), this.renderFrame && (cancelAnimationFrame(this.renderFrame), this.renderFrame = null), this.renderHighlightedNodesFrame && (cancelAnimationFrame(this.renderHighlightedNodesFrame), this.renderHighlightedNodesFrame = null);
+      for (var e = this.container; e.firstChild; ) e.removeChild(e.firstChild);
+      for (var t in this.nodePrograms)
+        this.nodePrograms[t].kill();
+      for (var a in this.nodeHoverPrograms)
+        this.nodeHoverPrograms[a].kill();
+      for (var r in this.edgePrograms)
+        this.edgePrograms[r].kill();
+      this.nodePrograms = {}, this.nodeHoverPrograms = {}, this.edgePrograms = {};
+      for (var o in this.elements)
+        this.killLayer(o);
+      this.canvasContexts = {}, this.webGLContexts = {}, this.elements = {};
+    }
+    /**
+     * Method used to scale the given size according to the camera's ratio, i.e.
+     * zooming state.
+     *
+     * @param  {number?} size -        The size to scale (node size, edge thickness etc.).
+     * @param  {number?} cameraRatio - A camera ratio (defaults to the actual camera ratio).
+     * @return {number}              - The scaled size.
+     */
+  }, {
+    key: "scaleSize",
+    value: function() {
+      var e = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 1, t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : this.camera.ratio;
+      return e / this.settings.zoomToSizeRatioFunction(t) * (this.getSetting("itemSizesReference") === "positions" ? t * this.graphToViewportRatio : 1);
+    }
+    /**
+     * Method that returns the collection of all used canvases.
+     * At the moment, the instantiated canvases are the following, and in the
+     * following order in the DOM:
+     * - `edges`
+     * - `nodes`
+     * - `edgeLabels`
+     * - `labels`
+     * - `hovers`
+     * - `hoverNodes`
+     * - `mouse`
+     *
+     * @return {PlainObject<HTMLCanvasElement>} - The collection of canvases.
+     */
+  }, {
+    key: "getCanvases",
+    value: function() {
+      var e = {};
+      for (var t in this.elements) this.elements[t] instanceof HTMLCanvasElement && (e[t] = this.elements[t]);
+      return e;
+    }
+  }]);
+})(ue), Lt = Ct;
+export {
+  Ce as Camera,
+  lt as MouseCaptor,
+  Ct as Sigma,
+  gt as TouchCaptor,
+  Lt as default
+};
+//# sourceMappingURL=sigma.esm-y0qgY-OC.js.map