@opentrace/components 0.1.1-rc.30 → 0.1.1-rc.44

package/dist/opentrace-components.js

@@ -2,6 +2,7 @@ import { jsxs, jsx, Fragment } from "react/jsx-runtime";
 import t, { forwardRef, useRef, useState, useEffect, useImperativeHandle, useMemo, useContext, createContext, useCallback, memo, createElement as createElement$1, useLayoutEffect } from "react";
 import { f as eventsExports, h as getDefaultExportFromCjs, r as requireIsGraph, G as Graph, g as getCommunityColor, a as buildCommunityNames, b as buildCommunityColorMap, c as getLinkColor, d as getNodeColor, i as requireGetters, u as useCommunities, j as useGraphFilters, e as useHighlights } from "./useHighlights-DbMfb0-p.js";
 import { s } from "./useHighlights-DbMfb0-p.js";
+import { A, I, d, n } from "./urlNormalize-KY4ngwCQ.js";
 function _toPrimitive$1(t2, r) {
   if ("object" != typeof t2 || !t2) return t2;
   var e2 = t2[Symbol.toPrimitive];
@@ -16,8 +17,8 @@ function _toPropertyKey$1(t2) {
   var i = _toPrimitive$1(t2, "string");
   return "symbol" == typeof i ? i : i + "";
 }
-function _classCallCheck$1(a, n2) {
-  if (!(a instanceof n2)) throw new TypeError("Cannot call a class as a function");
+function _classCallCheck$1(a, n3) {
+  if (!(a instanceof n3)) throw new TypeError("Cannot call a class as a function");
 }
 function _defineProperties$1(e2, r) {
   for (var t2 = 0; t2 < r.length; t2++) {
@@ -80,19 +81,19 @@ function _arrayWithHoles(r) {
 function _iterableToArrayLimit(r, l) {
   var t2 = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
   if (null != t2) {
-    var e2, n2, i, u, a = [], f2 = true, o = false;
+    var e2, n3, i, u, a = [], f2 = true, o = false;
     try {
       if (i = (t2 = t2.call(r)).next, 0 === l) {
         if (Object(t2) !== t2) return;
         f2 = false;
       } else for (; !(f2 = (e2 = i.call(t2)).done) && (a.push(e2.value), a.length !== l); f2 = true) ;
     } catch (r2) {
-      o = true, n2 = r2;
+      o = true, n3 = r2;
     } finally {
       try {
         if (!f2 && null != t2.return && (u = t2.return(), Object(u) !== u)) return;
       } finally {
-        if (o) throw n2;
+        if (o) throw n3;
       }
     }
     return a;
@@ -100,8 +101,8 @@ function _iterableToArrayLimit(r, l) {
 }
 function _arrayLikeToArray$1(r, a) {
   (null == a || a > r.length) && (a = r.length);
-  for (var e2 = 0, n2 = Array(a); e2 < a; e2++) n2[e2] = r[e2];
-  return n2;
+  for (var e2 = 0, n3 = Array(a); e2 < a; e2++) n3[e2] = r[e2];
+  return n3;
 }
 function _unsupportedIterableToArray$1(r, a) {
   if (r) {
@@ -386,8 +387,8 @@ function _get() {
   return _get = "undefined" != typeof Reflect && Reflect.get ? Reflect.get.bind() : function(e2, t2, r) {
     var p = _superPropBase(e2, t2);
     if (p) {
-      var n2 = Object.getOwnPropertyDescriptor(p, t2);
-      return n2.get ? n2.get.call(arguments.length < 3 ? e2 : r) : n2.value;
+      var n3 = Object.getOwnPropertyDescriptor(p, t2);
+      return n3.get ? n3.get.call(arguments.length < 3 ? e2 : r) : n3.value;
     }
   }, _get.apply(null, arguments);
 }
@@ -790,23 +791,23 @@ function drawStraightEdgeLabel(context, edgeData, sourceData, targetData, settin
   var cy = (sy + ty) / 2;
   var dx = tx - sx;
   var dy = ty - sy;
-  var d2 = Math.sqrt(dx * dx + dy * dy);
-  if (d2 < sSize + tSize) return;
-  sx += dx * sSize / d2;
-  sy += dy * sSize / d2;
-  tx -= dx * tSize / d2;
-  ty -= dy * tSize / d2;
+  var d3 = Math.sqrt(dx * dx + dy * dy);
+  if (d3 < sSize + tSize) return;
+  sx += dx * sSize / d3;
+  sy += dy * sSize / d3;
+  tx -= dx * tSize / d3;
+  ty -= dy * tSize / d3;
   cx = (sx + tx) / 2;
   cy = (sy + ty) / 2;
   dx = tx - sx;
   dy = ty - sy;
-  d2 = Math.sqrt(dx * dx + dy * dy);
+  d3 = Math.sqrt(dx * dx + dy * dy);
   var textLength = context.measureText(label).width;
-  if (textLength > d2) {
+  if (textLength > d3) {
     var ellipsis = "…";
     label = label + ellipsis;
     textLength = context.measureText(label).width;
-    while (textLength > d2 && label.length > 1) {
+    while (textLength > d3 && label.length > 1) {
       label = label.slice(0, -2) + ellipsis;
       textLength = context.measureText(label).width;
     }
@@ -814,11 +815,11 @@ function drawStraightEdgeLabel(context, edgeData, sourceData, targetData, settin
   }
   var angle;
   if (dx > 0) {
-    if (dy > 0) angle = Math.acos(dx / d2);
-    else angle = Math.asin(dy / d2);
+    if (dy > 0) angle = Math.acos(dx / d3);
+    else angle = Math.asin(dy / d3);
   } else {
-    if (dy > 0) angle = Math.acos(dx / d2) + Math.PI;
-    else angle = Math.asin(dx / d2) + Math.PI / 2;
+    if (dy > 0) angle = Math.acos(dx / d3) + Math.PI;
+    else angle = Math.asin(dx / d3) + Math.PI / 2;
   }
   context.save();
   context.translate(cx, cy);
@@ -1028,17 +1029,17 @@ function createEdgeArrowHeadProgram(inputOptions) {
         var dy = y2 - y1;
         var len = dx * dx + dy * dy;
         var n1 = 0;
-        var n2 = 0;
+        var n22 = 0;
         if (len) {
           len = 1 / Math.sqrt(len);
           n1 = -dy * len * thickness;
-          n2 = dx * len * thickness;
+          n22 = dx * len * thickness;
         }
         var array = this.array;
         array[startIndex++] = x2;
         array[startIndex++] = y2;
         array[startIndex++] = -n1;
-        array[startIndex++] = -n2;
+        array[startIndex++] = -n22;
         array[startIndex++] = radius;
         array[startIndex++] = color;
         array[startIndex++] = edgeIndex;
@@ -1154,11 +1155,11 @@ function createEdgeClampedProgram(inputOptions) {
         var radius = targetData.size || 1;
         var len = dx * dx + dy * dy;
         var n1 = 0;
-        var n2 = 0;
+        var n22 = 0;
         if (len) {
           len = 1 / Math.sqrt(len);
           n1 = -dy * len * thickness;
-          n2 = dx * len * thickness;
+          n22 = dx * len * thickness;
         }
         var array = this.array;
         array[startIndex++] = x1;
@@ -1166,7 +1167,7 @@ function createEdgeClampedProgram(inputOptions) {
         array[startIndex++] = x2;
         array[startIndex++] = y2;
         array[startIndex++] = n1;
-        array[startIndex++] = n2;
+        array[startIndex++] = n22;
         array[startIndex++] = color;
         array[startIndex++] = edgeIndex;
         array[startIndex++] = radius;
@@ -1334,11 +1335,11 @@ var EdgeRectangleProgram = /* @__PURE__ */ (function(_EdgeProgram) {
       var dy = y2 - y1;
       var len = dx * dx + dy * dy;
       var n1 = 0;
-      var n2 = 0;
+      var n22 = 0;
       if (len) {
         len = 1 / Math.sqrt(len);
         n1 = -dy * len * thickness;
-        n2 = dx * len * thickness;
+        n22 = dx * len * thickness;
       }
       var array = this.array;
       array[startIndex++] = x1;
@@ -1346,7 +1347,7 @@ var EdgeRectangleProgram = /* @__PURE__ */ (function(_EdgeProgram) {
       array[startIndex++] = x2;
       array[startIndex++] = y2;
       array[startIndex++] = n1;
-      array[startIndex++] = n2;
+      array[startIndex++] = n22;
       array[startIndex++] = color;
       array[startIndex++] = edgeIndex;
     }
@@ -2518,9 +2519,9 @@ function _toConsumableArray$1(r) {
 function _objectWithoutPropertiesLoose(r, e2) {
   if (null == r) return {};
   var t2 = {};
-  for (var n2 in r) if ({}.hasOwnProperty.call(r, n2)) {
-    if (-1 !== e2.indexOf(n2)) continue;
-    t2[n2] = r[n2];
+  for (var n3 in r) if ({}.hasOwnProperty.call(r, n3)) {
+    if (-1 !== e2.indexOf(n3)) continue;
+    t2[n3] = r[n3];
   }
   return t2;
 }
@@ -2528,8 +2529,8 @@ function _objectWithoutProperties(e2, t2) {
   if (null == e2) return {};
   var o, r, i = _objectWithoutPropertiesLoose(e2, t2);
   if (Object.getOwnPropertySymbols) {
-    var n2 = Object.getOwnPropertySymbols(e2);
-    for (r = 0; r < n2.length; r++) o = n2[r], -1 === t2.indexOf(o) && {}.propertyIsEnumerable.call(e2, o) && (i[o] = e2[o]);
+    var n3 = Object.getOwnPropertySymbols(e2);
+    for (r = 0; r < n3.length; r++) o = n3[r], -1 === t2.indexOf(o) && {}.propertyIsEnumerable.call(e2, o) && (i[o] = e2[o]);
   }
   return i;
 }
@@ -4598,9 +4599,9 @@ var Sigma$1 = /* @__PURE__ */ (function(_TypedEventEmitter) {
     }
   }]);
 })(TypedEventEmitter);
-const d = createContext(null), f = d.Provider;
+const d2 = createContext(null), f = d2.Provider;
 function h() {
-  const e2 = useContext(d);
+  const e2 = useContext(d2);
   if (null == e2) throw new Error("No context provided: useSigmaContext() can only be used in a descendant of <SigmaContainer>");
   return e2;
 }
@@ -4618,32 +4619,32 @@ function j(e2, t2) {
   if (e2 === t2) return true;
   if ("object" == typeof e2 && null != e2 && "object" == typeof t2 && null != t2) {
     if (Object.keys(e2).length != Object.keys(t2).length) return false;
-    for (const n2 in e2) {
-      if (!Object.hasOwn(t2, n2)) return false;
-      if (!j(e2[n2], t2[n2])) return false;
+    for (const n3 in e2) {
+      if (!Object.hasOwn(t2, n3)) return false;
+      if (!j(e2[n3], t2[n3])) return false;
     }
     return true;
   }
   return false;
 }
-const S = forwardRef((({ graph: e2, id: n2, className: r, style: a, settings: s2 = {}, children: d2 }, h2) => {
-  const v2 = useRef(null), p = useRef(null), w2 = { className: `react-sigma ${r || ""}`, id: n2, style: a }, [b, E] = useState(null), [_, O] = useState(s2);
+const S = forwardRef((({ graph: e2, id: n3, className: r, style: a, settings: s2 = {}, children: d3 }, h2) => {
+  const v2 = useRef(null), p = useRef(null), w2 = { className: `react-sigma ${r || ""}`, id: n3, style: a }, [b, E] = useState(null), [_, O] = useState(s2);
   useEffect((() => {
     O(((e3) => j(e3, s2) ? e3 : s2));
   }), [s2]), useEffect((() => {
     let t2 = null;
     if (null !== p.current) {
-      let n3 = new Graph();
-      e2 && (n3 = "function" == typeof e2 ? new e2() : e2), t2 = new Sigma$1(n3, p.current, _), E(((e3) => {
-        let n4 = null;
-        return e3 && (n4 = e3.getCamera().getState()), n4 && t2.getCamera().setState(n4), t2;
+      let n4 = new Graph();
+      e2 && (n4 = "function" == typeof e2 ? new e2() : e2), t2 = new Sigma$1(n4, p.current, _), E(((e3) => {
+        let n5 = null;
+        return e3 && (n5 = e3.getCamera().getState()), n5 && t2.getCamera().setState(n5), t2;
       }));
     }
     return () => {
       t2 && t2.kill();
     };
   }), [p, e2, _]), useImperativeHandle(h2, (() => b), [b]);
-  const y = useMemo((() => b && v2.current ? { sigma: b, container: v2.current } : null), [b, v2]), C = null !== y ? t.createElement(f, { value: y }, d2) : null;
+  const y = useMemo((() => b && v2.current ? { sigma: b, container: v2.current } : null), [b, v2]), C = null !== y ? t.createElement(f, { value: y }, d3) : null;
   return t.createElement("div", Object.assign({}, w2, { ref: v2 }), t.createElement("div", { className: "sigma-container", ref: p }), C);
 }));
 var SHADER_SOURCE$4 = (
@@ -4746,11 +4747,11 @@ function createEdgeDoubleClampedProgram(inputOptions) {
         var targetRadius = targetData.size || 1;
         var len = dx * dx + dy * dy;
         var n1 = 0;
-        var n2 = 0;
+        var n22 = 0;
         if (len) {
           len = 1 / Math.sqrt(len);
           n1 = -dy * len * thickness;
-          n2 = dx * len * thickness;
+          n22 = dx * len * thickness;
         }
         var array = this.array;
         array[startIndex++] = x1;
@@ -4758,7 +4759,7 @@ function createEdgeDoubleClampedProgram(inputOptions) {
         array[startIndex++] = x2;
         array[startIndex++] = y2;
         array[startIndex++] = n1;
-        array[startIndex++] = n2;
+        array[startIndex++] = n22;
         array[startIndex++] = color;
         array[startIndex++] = edgeIndex;
         array[startIndex++] = sourceRadius;
@@ -4902,8 +4903,8 @@ function _objectSpread2(e2) {
   }
   return e2;
 }
-function _classCallCheck(a, n2) {
-  if (!(a instanceof n2)) throw new TypeError("Cannot call a class as a function");
+function _classCallCheck(a, n3) {
+  if (!(a instanceof n3)) throw new TypeError("Cannot call a class as a function");
 }
 function _defineProperties(e2, r) {
   for (var t2 = 0; t2 < r.length; t2++) {
@@ -4962,8 +4963,8 @@ function _inherits(t2, e2) {
 }
 function _arrayLikeToArray(r, a) {
   (null == a || a > r.length) && (a = r.length);
-  for (var e2 = 0, n2 = Array(a); e2 < a; e2++) n2[e2] = r[e2];
-  return n2;
+  for (var e2 = 0, n3 = Array(a); e2 < a; e2++) n3[e2] = r[e2];
+  return n3;
 }
 function _arrayWithoutHoles(r) {
   if (Array.isArray(r)) return _arrayLikeToArray(r);
@@ -5428,7 +5429,7 @@ function useGraphInstance({
       nodes: serializedNodes,
       edges: serializedEdges
     });
-    const nodeIds = allNodes.map((n2) => n2.id);
+    const nodeIds = allNodes.map((n3) => n3.id);
     const simLinks = [];
     for (const link of allLinks) {
       if (link.label !== layoutConfig.layoutEdgeType) continue;
@@ -5578,9 +5579,9 @@ function useGraphVisuals(graph, layoutReady, visualState, layoutConfig, _degreeM
     );
   }, [graph, layoutReady, visualState, layoutConfig, isLargeGraph]);
 }
-function c(r, n2) {
-  const o = v(), [c2, u] = useState(false), [p, g] = useState(null), m = useRef(n2);
-  j(m.current, n2) || (m.current = n2), useEffect((() => {
+function c(r, n3) {
+  const o = v(), [c2, u] = useState(false), [p, g] = useState(null), m = useRef(n3);
+  j(m.current, n3) || (m.current = n3), useEffect((() => {
     u(false);
     let t2 = null;
     return m.current && (t2 = new r(o.getGraph(), m.current)), g(t2), () => {
@@ -5628,32 +5629,32 @@ function requireIterate() {
   var PPR = 9;
   var MAX_FORCE = 10;
   iterate = function iterate2(options, NodeMatrix, EdgeMatrix) {
-    var l, r, n2, n1, n22, rn, e2, w2, g, s2;
+    var l, r, n3, n1, n22, rn, e2, w2, g, s2;
     var order = NodeMatrix.length, size = EdgeMatrix.length;
     var adjustSizes = options.adjustSizes;
     var thetaSquared = options.barnesHutTheta * options.barnesHutTheta;
     var outboundAttCompensation, coefficient, xDist, yDist, ewc, distance, factor;
     var RegionMatrix = [];
-    for (n2 = 0; n2 < order; n2 += PPN) {
-      NodeMatrix[n2 + NODE_OLD_DX] = NodeMatrix[n2 + NODE_DX];
-      NodeMatrix[n2 + NODE_OLD_DY] = NodeMatrix[n2 + NODE_DY];
-      NodeMatrix[n2 + NODE_DX] = 0;
-      NodeMatrix[n2 + NODE_DY] = 0;
+    for (n3 = 0; n3 < order; n3 += PPN) {
+      NodeMatrix[n3 + NODE_OLD_DX] = NodeMatrix[n3 + NODE_DX];
+      NodeMatrix[n3 + NODE_OLD_DY] = NodeMatrix[n3 + NODE_DY];
+      NodeMatrix[n3 + NODE_DX] = 0;
+      NodeMatrix[n3 + NODE_DY] = 0;
     }
     if (options.outboundAttractionDistribution) {
       outboundAttCompensation = 0;
-      for (n2 = 0; n2 < order; n2 += PPN) {
-        outboundAttCompensation += NodeMatrix[n2 + NODE_MASS];
+      for (n3 = 0; n3 < order; n3 += PPN) {
+        outboundAttCompensation += NodeMatrix[n3 + NODE_MASS];
       }
       outboundAttCompensation /= order / PPN;
     }
     if (options.barnesHutOptimize) {
       var minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity, q2, q22, subdivisionAttempts;
-      for (n2 = 0; n2 < order; n2 += PPN) {
-        minX = Math.min(minX, NodeMatrix[n2 + NODE_X]);
-        maxX = Math.max(maxX, NodeMatrix[n2 + NODE_X]);
-        minY = Math.min(minY, NodeMatrix[n2 + NODE_Y]);
-        maxY = Math.max(maxY, NodeMatrix[n2 + NODE_Y]);
+      for (n3 = 0; n3 < order; n3 += PPN) {
+        minX = Math.min(minX, NodeMatrix[n3 + NODE_X]);
+        maxX = Math.max(maxX, NodeMatrix[n3 + NODE_X]);
+        minY = Math.min(minY, NodeMatrix[n3 + NODE_Y]);
+        maxY = Math.max(maxY, NodeMatrix[n3 + NODE_Y]);
       }
       var dx = maxX - minX, dy = maxY - minY;
       if (dx > dy) {
@@ -5673,32 +5674,32 @@ function requireIterate() {
       RegionMatrix[0 + REGION_MASS_CENTER_X] = 0;
       RegionMatrix[0 + REGION_MASS_CENTER_Y] = 0;
       l = 1;
-      for (n2 = 0; n2 < order; n2 += PPN) {
+      for (n3 = 0; n3 < order; n3 += PPN) {
         r = 0;
         subdivisionAttempts = SUBDIVISION_ATTEMPTS;
         while (true) {
           if (RegionMatrix[r + REGION_FIRST_CHILD] >= 0) {
-            if (NodeMatrix[n2 + NODE_X] < RegionMatrix[r + REGION_CENTER_X]) {
-              if (NodeMatrix[n2 + NODE_Y] < RegionMatrix[r + REGION_CENTER_Y]) {
+            if (NodeMatrix[n3 + NODE_X] < RegionMatrix[r + REGION_CENTER_X]) {
+              if (NodeMatrix[n3 + NODE_Y] < RegionMatrix[r + REGION_CENTER_Y]) {
                 q2 = RegionMatrix[r + REGION_FIRST_CHILD];
               } else {
                 q2 = RegionMatrix[r + REGION_FIRST_CHILD] + PPR;
               }
             } else {
-              if (NodeMatrix[n2 + NODE_Y] < RegionMatrix[r + REGION_CENTER_Y]) {
+              if (NodeMatrix[n3 + NODE_Y] < RegionMatrix[r + REGION_CENTER_Y]) {
                 q2 = RegionMatrix[r + REGION_FIRST_CHILD] + PPR * 2;
               } else {
                 q2 = RegionMatrix[r + REGION_FIRST_CHILD] + PPR * 3;
               }
             }
-            RegionMatrix[r + REGION_MASS_CENTER_X] = (RegionMatrix[r + REGION_MASS_CENTER_X] * RegionMatrix[r + REGION_MASS] + NodeMatrix[n2 + NODE_X] * NodeMatrix[n2 + NODE_MASS]) / (RegionMatrix[r + REGION_MASS] + NodeMatrix[n2 + NODE_MASS]);
-            RegionMatrix[r + REGION_MASS_CENTER_Y] = (RegionMatrix[r + REGION_MASS_CENTER_Y] * RegionMatrix[r + REGION_MASS] + NodeMatrix[n2 + NODE_Y] * NodeMatrix[n2 + NODE_MASS]) / (RegionMatrix[r + REGION_MASS] + NodeMatrix[n2 + NODE_MASS]);
-            RegionMatrix[r + REGION_MASS] += NodeMatrix[n2 + NODE_MASS];
+            RegionMatrix[r + REGION_MASS_CENTER_X] = (RegionMatrix[r + REGION_MASS_CENTER_X] * RegionMatrix[r + REGION_MASS] + NodeMatrix[n3 + NODE_X] * NodeMatrix[n3 + NODE_MASS]) / (RegionMatrix[r + REGION_MASS] + NodeMatrix[n3 + NODE_MASS]);
+            RegionMatrix[r + REGION_MASS_CENTER_Y] = (RegionMatrix[r + REGION_MASS_CENTER_Y] * RegionMatrix[r + REGION_MASS] + NodeMatrix[n3 + NODE_Y] * NodeMatrix[n3 + NODE_MASS]) / (RegionMatrix[r + REGION_MASS] + NodeMatrix[n3 + NODE_MASS]);
+            RegionMatrix[r + REGION_MASS] += NodeMatrix[n3 + NODE_MASS];
             r = q2;
             continue;
           } else {
             if (RegionMatrix[r + REGION_NODE] < 0) {
-              RegionMatrix[r + REGION_NODE] = n2;
+              RegionMatrix[r + REGION_NODE] = n3;
               break;
             } else {
               RegionMatrix[r + REGION_FIRST_CHILD] = l * PPR;
@@ -5762,14 +5763,14 @@ function requireIterate() {
               RegionMatrix[r + REGION_MASS_CENTER_Y] = NodeMatrix[RegionMatrix[r + REGION_NODE] + NODE_Y];
               RegionMatrix[q2 + REGION_NODE] = RegionMatrix[r + REGION_NODE];
               RegionMatrix[r + REGION_NODE] = -1;
-              if (NodeMatrix[n2 + NODE_X] < RegionMatrix[r + REGION_CENTER_X]) {
-                if (NodeMatrix[n2 + NODE_Y] < RegionMatrix[r + REGION_CENTER_Y]) {
+              if (NodeMatrix[n3 + NODE_X] < RegionMatrix[r + REGION_CENTER_X]) {
+                if (NodeMatrix[n3 + NODE_Y] < RegionMatrix[r + REGION_CENTER_Y]) {
                   q22 = RegionMatrix[r + REGION_FIRST_CHILD];
                 } else {
                   q22 = RegionMatrix[r + REGION_FIRST_CHILD] + PPR;
                 }
               } else {
-                if (NodeMatrix[n2 + NODE_Y] < RegionMatrix[r + REGION_CENTER_Y]) {
+                if (NodeMatrix[n3 + NODE_Y] < RegionMatrix[r + REGION_CENTER_Y]) {
                   q22 = RegionMatrix[r + REGION_FIRST_CHILD] + PPR * 2;
                 } else {
                   q22 = RegionMatrix[r + REGION_FIRST_CHILD] + PPR * 3;
@@ -5784,7 +5785,7 @@ function requireIterate() {
                   break;
                 }
               }
-              RegionMatrix[q22 + REGION_NODE] = n2;
+              RegionMatrix[q22 + REGION_NODE] = n3;
               break;
             }
           }
@@ -5793,36 +5794,36 @@ function requireIterate() {
     }
     if (options.barnesHutOptimize) {
       coefficient = options.scalingRatio;
-      for (n2 = 0; n2 < order; n2 += PPN) {
+      for (n3 = 0; n3 < order; n3 += PPN) {
         r = 0;
         while (true) {
           if (RegionMatrix[r + REGION_FIRST_CHILD] >= 0) {
             distance = Math.pow(
-              NodeMatrix[n2 + NODE_X] - RegionMatrix[r + REGION_MASS_CENTER_X],
+              NodeMatrix[n3 + NODE_X] - RegionMatrix[r + REGION_MASS_CENTER_X],
               2
             ) + Math.pow(
-              NodeMatrix[n2 + NODE_Y] - RegionMatrix[r + REGION_MASS_CENTER_Y],
+              NodeMatrix[n3 + NODE_Y] - RegionMatrix[r + REGION_MASS_CENTER_Y],
               2
             );
             s2 = RegionMatrix[r + REGION_SIZE];
             if (4 * s2 * s2 / distance < thetaSquared) {
-              xDist = NodeMatrix[n2 + NODE_X] - RegionMatrix[r + REGION_MASS_CENTER_X];
-              yDist = NodeMatrix[n2 + NODE_Y] - RegionMatrix[r + REGION_MASS_CENTER_Y];
+              xDist = NodeMatrix[n3 + NODE_X] - RegionMatrix[r + REGION_MASS_CENTER_X];
+              yDist = NodeMatrix[n3 + NODE_Y] - RegionMatrix[r + REGION_MASS_CENTER_Y];
               if (adjustSizes === true) {
                 if (distance > 0) {
-                  factor = coefficient * NodeMatrix[n2 + NODE_MASS] * RegionMatrix[r + REGION_MASS] / distance;
-                  NodeMatrix[n2 + NODE_DX] += xDist * factor;
-                  NodeMatrix[n2 + NODE_DY] += yDist * factor;
+                  factor = coefficient * NodeMatrix[n3 + NODE_MASS] * RegionMatrix[r + REGION_MASS] / distance;
+                  NodeMatrix[n3 + NODE_DX] += xDist * factor;
+                  NodeMatrix[n3 + NODE_DY] += yDist * factor;
                 } else if (distance < 0) {
-                  factor = -coefficient * NodeMatrix[n2 + NODE_MASS] * RegionMatrix[r + REGION_MASS] / Math.sqrt(distance);
-                  NodeMatrix[n2 + NODE_DX] += xDist * factor;
-                  NodeMatrix[n2 + NODE_DY] += yDist * factor;
+                  factor = -coefficient * NodeMatrix[n3 + NODE_MASS] * RegionMatrix[r + REGION_MASS] / Math.sqrt(distance);
+                  NodeMatrix[n3 + NODE_DX] += xDist * factor;
+                  NodeMatrix[n3 + NODE_DY] += yDist * factor;
                 }
               } else {
                 if (distance > 0) {
-                  factor = coefficient * NodeMatrix[n2 + NODE_MASS] * RegionMatrix[r + REGION_MASS] / distance;
-                  NodeMatrix[n2 + NODE_DX] += xDist * factor;
-                  NodeMatrix[n2 + NODE_DY] += yDist * factor;
+                  factor = coefficient * NodeMatrix[n3 + NODE_MASS] * RegionMatrix[r + REGION_MASS] / distance;
+                  NodeMatrix[n3 + NODE_DX] += xDist * factor;
+                  NodeMatrix[n3 + NODE_DY] += yDist * factor;
                 }
               }
               r = RegionMatrix[r + REGION_NEXT_SIBLING];
@@ -5834,25 +5835,25 @@ function requireIterate() {
             }
           } else {
             rn = RegionMatrix[r + REGION_NODE];
-            if (rn >= 0 && rn !== n2) {
-              xDist = NodeMatrix[n2 + NODE_X] - NodeMatrix[rn + NODE_X];
-              yDist = NodeMatrix[n2 + NODE_Y] - NodeMatrix[rn + NODE_Y];
+            if (rn >= 0 && rn !== n3) {
+              xDist = NodeMatrix[n3 + NODE_X] - NodeMatrix[rn + NODE_X];
+              yDist = NodeMatrix[n3 + NODE_Y] - NodeMatrix[rn + NODE_Y];
               distance = xDist * xDist + yDist * yDist;
               if (adjustSizes === true) {
                 if (distance > 0) {
-                  factor = coefficient * NodeMatrix[n2 + NODE_MASS] * NodeMatrix[rn + NODE_MASS] / distance;
-                  NodeMatrix[n2 + NODE_DX] += xDist * factor;
-                  NodeMatrix[n2 + NODE_DY] += yDist * factor;
+                  factor = coefficient * NodeMatrix[n3 + NODE_MASS] * NodeMatrix[rn + NODE_MASS] / distance;
+                  NodeMatrix[n3 + NODE_DX] += xDist * factor;
+                  NodeMatrix[n3 + NODE_DY] += yDist * factor;
                 } else if (distance < 0) {
-                  factor = -coefficient * NodeMatrix[n2 + NODE_MASS] * NodeMatrix[rn + NODE_MASS] / Math.sqrt(distance);
-                  NodeMatrix[n2 + NODE_DX] += xDist * factor;
-                  NodeMatrix[n2 + NODE_DY] += yDist * factor;
+                  factor = -coefficient * NodeMatrix[n3 + NODE_MASS] * NodeMatrix[rn + NODE_MASS] / Math.sqrt(distance);
+                  NodeMatrix[n3 + NODE_DX] += xDist * factor;
+                  NodeMatrix[n3 + NODE_DY] += yDist * factor;
                 }
               } else {
                 if (distance > 0) {
-                  factor = coefficient * NodeMatrix[n2 + NODE_MASS] * NodeMatrix[rn + NODE_MASS] / distance;
-                  NodeMatrix[n2 + NODE_DX] += xDist * factor;
-                  NodeMatrix[n2 + NODE_DY] += yDist * factor;
+                  factor = coefficient * NodeMatrix[n3 + NODE_MASS] * NodeMatrix[rn + NODE_MASS] / distance;
+                  NodeMatrix[n3 + NODE_DX] += xDist * factor;
+                  NodeMatrix[n3 + NODE_DY] += yDist * factor;
                 }
               }
             }
@@ -5898,19 +5899,19 @@ function requireIterate() {
     }
     g = options.gravity / options.scalingRatio;
     coefficient = options.scalingRatio;
-    for (n2 = 0; n2 < order; n2 += PPN) {
+    for (n3 = 0; n3 < order; n3 += PPN) {
       factor = 0;
-      xDist = NodeMatrix[n2 + NODE_X];
-      yDist = NodeMatrix[n2 + NODE_Y];
+      xDist = NodeMatrix[n3 + NODE_X];
+      yDist = NodeMatrix[n3 + NODE_Y];
       distance = Math.sqrt(Math.pow(xDist, 2) + Math.pow(yDist, 2));
       if (options.strongGravityMode) {
-        if (distance > 0) factor = coefficient * NodeMatrix[n2 + NODE_MASS] * g;
+        if (distance > 0) factor = coefficient * NodeMatrix[n3 + NODE_MASS] * g;
       } else {
         if (distance > 0)
-          factor = coefficient * NodeMatrix[n2 + NODE_MASS] * g / distance;
+          factor = coefficient * NodeMatrix[n3 + NODE_MASS] * g / distance;
       }
-      NodeMatrix[n2 + NODE_DX] -= xDist * factor;
-      NodeMatrix[n2 + NODE_DY] -= yDist * factor;
+      NodeMatrix[n3 + NODE_DX] -= xDist * factor;
+      NodeMatrix[n3 + NODE_DY] -= yDist * factor;
     }
     coefficient = 1 * (options.outboundAttractionDistribution ? outboundAttCompensation : 1);
     for (e2 = 0; e2 < size; e2 += PPE) {
@@ -5973,48 +5974,48 @@ function requireIterate() {
     }
     var force, swinging, traction, nodespeed, newX, newY;
     if (adjustSizes === true) {
-      for (n2 = 0; n2 < order; n2 += PPN) {
-        if (NodeMatrix[n2 + NODE_FIXED] !== 1) {
+      for (n3 = 0; n3 < order; n3 += PPN) {
+        if (NodeMatrix[n3 + NODE_FIXED] !== 1) {
           force = Math.sqrt(
-            Math.pow(NodeMatrix[n2 + NODE_DX], 2) + Math.pow(NodeMatrix[n2 + NODE_DY], 2)
+            Math.pow(NodeMatrix[n3 + NODE_DX], 2) + Math.pow(NodeMatrix[n3 + NODE_DY], 2)
           );
           if (force > MAX_FORCE) {
-            NodeMatrix[n2 + NODE_DX] = NodeMatrix[n2 + NODE_DX] * MAX_FORCE / force;
-            NodeMatrix[n2 + NODE_DY] = NodeMatrix[n2 + NODE_DY] * MAX_FORCE / force;
+            NodeMatrix[n3 + NODE_DX] = NodeMatrix[n3 + NODE_DX] * MAX_FORCE / force;
+            NodeMatrix[n3 + NODE_DY] = NodeMatrix[n3 + NODE_DY] * MAX_FORCE / force;
           }
-          swinging = NodeMatrix[n2 + NODE_MASS] * Math.sqrt(
-            (NodeMatrix[n2 + NODE_OLD_DX] - NodeMatrix[n2 + NODE_DX]) * (NodeMatrix[n2 + NODE_OLD_DX] - NodeMatrix[n2 + NODE_DX]) + (NodeMatrix[n2 + NODE_OLD_DY] - NodeMatrix[n2 + NODE_DY]) * (NodeMatrix[n2 + NODE_OLD_DY] - NodeMatrix[n2 + NODE_DY])
+          swinging = NodeMatrix[n3 + NODE_MASS] * Math.sqrt(
+            (NodeMatrix[n3 + NODE_OLD_DX] - NodeMatrix[n3 + NODE_DX]) * (NodeMatrix[n3 + NODE_OLD_DX] - NodeMatrix[n3 + NODE_DX]) + (NodeMatrix[n3 + NODE_OLD_DY] - NodeMatrix[n3 + NODE_DY]) * (NodeMatrix[n3 + NODE_OLD_DY] - NodeMatrix[n3 + NODE_DY])
           );
           traction = Math.sqrt(
-            (NodeMatrix[n2 + NODE_OLD_DX] + NodeMatrix[n2 + NODE_DX]) * (NodeMatrix[n2 + NODE_OLD_DX] + NodeMatrix[n2 + NODE_DX]) + (NodeMatrix[n2 + NODE_OLD_DY] + NodeMatrix[n2 + NODE_DY]) * (NodeMatrix[n2 + NODE_OLD_DY] + NodeMatrix[n2 + NODE_DY])
+            (NodeMatrix[n3 + NODE_OLD_DX] + NodeMatrix[n3 + NODE_DX]) * (NodeMatrix[n3 + NODE_OLD_DX] + NodeMatrix[n3 + NODE_DX]) + (NodeMatrix[n3 + NODE_OLD_DY] + NodeMatrix[n3 + NODE_DY]) * (NodeMatrix[n3 + NODE_OLD_DY] + NodeMatrix[n3 + NODE_DY])
           ) / 2;
           nodespeed = 0.1 * Math.log(1 + traction) / (1 + Math.sqrt(swinging));
-          newX = NodeMatrix[n2 + NODE_X] + NodeMatrix[n2 + NODE_DX] * (nodespeed / options.slowDown);
-          NodeMatrix[n2 + NODE_X] = newX;
-          newY = NodeMatrix[n2 + NODE_Y] + NodeMatrix[n2 + NODE_DY] * (nodespeed / options.slowDown);
-          NodeMatrix[n2 + NODE_Y] = newY;
+          newX = NodeMatrix[n3 + NODE_X] + NodeMatrix[n3 + NODE_DX] * (nodespeed / options.slowDown);
+          NodeMatrix[n3 + NODE_X] = newX;
+          newY = NodeMatrix[n3 + NODE_Y] + NodeMatrix[n3 + NODE_DY] * (nodespeed / options.slowDown);
+          NodeMatrix[n3 + NODE_Y] = newY;
         }
       }
     } else {
-      for (n2 = 0; n2 < order; n2 += PPN) {
-        if (NodeMatrix[n2 + NODE_FIXED] !== 1) {
-          swinging = NodeMatrix[n2 + NODE_MASS] * Math.sqrt(
-            (NodeMatrix[n2 + NODE_OLD_DX] - NodeMatrix[n2 + NODE_DX]) * (NodeMatrix[n2 + NODE_OLD_DX] - NodeMatrix[n2 + NODE_DX]) + (NodeMatrix[n2 + NODE_OLD_DY] - NodeMatrix[n2 + NODE_DY]) * (NodeMatrix[n2 + NODE_OLD_DY] - NodeMatrix[n2 + NODE_DY])
+      for (n3 = 0; n3 < order; n3 += PPN) {
+        if (NodeMatrix[n3 + NODE_FIXED] !== 1) {
+          swinging = NodeMatrix[n3 + NODE_MASS] * Math.sqrt(
+            (NodeMatrix[n3 + NODE_OLD_DX] - NodeMatrix[n3 + NODE_DX]) * (NodeMatrix[n3 + NODE_OLD_DX] - NodeMatrix[n3 + NODE_DX]) + (NodeMatrix[n3 + NODE_OLD_DY] - NodeMatrix[n3 + NODE_DY]) * (NodeMatrix[n3 + NODE_OLD_DY] - NodeMatrix[n3 + NODE_DY])
           );
           traction = Math.sqrt(
-            (NodeMatrix[n2 + NODE_OLD_DX] + NodeMatrix[n2 + NODE_DX]) * (NodeMatrix[n2 + NODE_OLD_DX] + NodeMatrix[n2 + NODE_DX]) + (NodeMatrix[n2 + NODE_OLD_DY] + NodeMatrix[n2 + NODE_DY]) * (NodeMatrix[n2 + NODE_OLD_DY] + NodeMatrix[n2 + NODE_DY])
+            (NodeMatrix[n3 + NODE_OLD_DX] + NodeMatrix[n3 + NODE_DX]) * (NodeMatrix[n3 + NODE_OLD_DX] + NodeMatrix[n3 + NODE_DX]) + (NodeMatrix[n3 + NODE_OLD_DY] + NodeMatrix[n3 + NODE_DY]) * (NodeMatrix[n3 + NODE_OLD_DY] + NodeMatrix[n3 + NODE_DY])
           ) / 2;
-          nodespeed = NodeMatrix[n2 + NODE_CONVERGENCE] * Math.log(1 + traction) / (1 + Math.sqrt(swinging));
-          NodeMatrix[n2 + NODE_CONVERGENCE] = Math.min(
+          nodespeed = NodeMatrix[n3 + NODE_CONVERGENCE] * Math.log(1 + traction) / (1 + Math.sqrt(swinging));
+          NodeMatrix[n3 + NODE_CONVERGENCE] = Math.min(
             1,
             Math.sqrt(
-              nodespeed * (Math.pow(NodeMatrix[n2 + NODE_DX], 2) + Math.pow(NodeMatrix[n2 + NODE_DY], 2)) / (1 + Math.sqrt(swinging))
+              nodespeed * (Math.pow(NodeMatrix[n3 + NODE_DX], 2) + Math.pow(NodeMatrix[n3 + NODE_DY], 2)) / (1 + Math.sqrt(swinging))
             )
           );
-          newX = NodeMatrix[n2 + NODE_X] + NodeMatrix[n2 + NODE_DX] * (nodespeed / options.slowDown);
-          NodeMatrix[n2 + NODE_X] = newX;
-          newY = NodeMatrix[n2 + NODE_Y] + NodeMatrix[n2 + NODE_DY] * (nodespeed / options.slowDown);
-          NodeMatrix[n2 + NODE_Y] = newY;
+          newX = NodeMatrix[n3 + NODE_X] + NodeMatrix[n3 + NODE_DX] * (nodespeed / options.slowDown);
+          NodeMatrix[n3 + NODE_X] = newX;
+          newY = NodeMatrix[n3 + NODE_Y] + NodeMatrix[n3 + NODE_DY] * (nodespeed / options.slowDown);
+          NodeMatrix[n3 + NODE_Y] = newY;
         }
       }
     }
@@ -6273,32 +6274,32 @@ function requireWebworker() {
       var PPR = 9;
       var MAX_FORCE = 10;
       moduleShim.exports = function iterate3(options, NodeMatrix, EdgeMatrix) {
-        var l, r, n2, n1, n22, rn, e2, w2, g, s2;
+        var l, r, n3, n1, n22, rn, e2, w2, g, s2;
         var order = NodeMatrix.length, size = EdgeMatrix.length;
         var adjustSizes = options.adjustSizes;
         var thetaSquared = options.barnesHutTheta * options.barnesHutTheta;
         var outboundAttCompensation, coefficient, xDist, yDist, ewc, distance, factor;
         var RegionMatrix = [];
-        for (n2 = 0; n2 < order; n2 += PPN) {
-          NodeMatrix[n2 + NODE_OLD_DX] = NodeMatrix[n2 + NODE_DX];
-          NodeMatrix[n2 + NODE_OLD_DY] = NodeMatrix[n2 + NODE_DY];
-          NodeMatrix[n2 + NODE_DX] = 0;
-          NodeMatrix[n2 + NODE_DY] = 0;
+        for (n3 = 0; n3 < order; n3 += PPN) {
+          NodeMatrix[n3 + NODE_OLD_DX] = NodeMatrix[n3 + NODE_DX];
+          NodeMatrix[n3 + NODE_OLD_DY] = NodeMatrix[n3 + NODE_DY];
+          NodeMatrix[n3 + NODE_DX] = 0;
+          NodeMatrix[n3 + NODE_DY] = 0;
         }
         if (options.outboundAttractionDistribution) {
           outboundAttCompensation = 0;
-          for (n2 = 0; n2 < order; n2 += PPN) {
-            outboundAttCompensation += NodeMatrix[n2 + NODE_MASS];
+          for (n3 = 0; n3 < order; n3 += PPN) {
+            outboundAttCompensation += NodeMatrix[n3 + NODE_MASS];
           }
           outboundAttCompensation /= order / PPN;
         }
         if (options.barnesHutOptimize) {
           var minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity, q2, q22, subdivisionAttempts;
-          for (n2 = 0; n2 < order; n2 += PPN) {
-            minX = Math.min(minX, NodeMatrix[n2 + NODE_X]);
-            maxX = Math.max(maxX, NodeMatrix[n2 + NODE_X]);
-            minY = Math.min(minY, NodeMatrix[n2 + NODE_Y]);
-            maxY = Math.max(maxY, NodeMatrix[n2 + NODE_Y]);
+          for (n3 = 0; n3 < order; n3 += PPN) {
+            minX = Math.min(minX, NodeMatrix[n3 + NODE_X]);
+            maxX = Math.max(maxX, NodeMatrix[n3 + NODE_X]);
+            minY = Math.min(minY, NodeMatrix[n3 + NODE_Y]);
+            maxY = Math.max(maxY, NodeMatrix[n3 + NODE_Y]);
           }
           var dx = maxX - minX, dy = maxY - minY;
           if (dx > dy) {
@@ -6318,32 +6319,32 @@ function requireWebworker() {
           RegionMatrix[0 + REGION_MASS_CENTER_X] = 0;
           RegionMatrix[0 + REGION_MASS_CENTER_Y] = 0;
           l = 1;
-          for (n2 = 0; n2 < order; n2 += PPN) {
+          for (n3 = 0; n3 < order; n3 += PPN) {
             r = 0;
             subdivisionAttempts = SUBDIVISION_ATTEMPTS;
             while (true) {
               if (RegionMatrix[r + REGION_FIRST_CHILD] >= 0) {
-                if (NodeMatrix[n2 + NODE_X] < RegionMatrix[r + REGION_CENTER_X]) {
-                  if (NodeMatrix[n2 + NODE_Y] < RegionMatrix[r + REGION_CENTER_Y]) {
+                if (NodeMatrix[n3 + NODE_X] < RegionMatrix[r + REGION_CENTER_X]) {
+                  if (NodeMatrix[n3 + NODE_Y] < RegionMatrix[r + REGION_CENTER_Y]) {
                     q2 = RegionMatrix[r + REGION_FIRST_CHILD];
                   } else {
                     q2 = RegionMatrix[r + REGION_FIRST_CHILD] + PPR;
                   }
                 } else {
-                  if (NodeMatrix[n2 + NODE_Y] < RegionMatrix[r + REGION_CENTER_Y]) {
+                  if (NodeMatrix[n3 + NODE_Y] < RegionMatrix[r + REGION_CENTER_Y]) {
                     q2 = RegionMatrix[r + REGION_FIRST_CHILD] + PPR * 2;
                   } else {
                     q2 = RegionMatrix[r + REGION_FIRST_CHILD] + PPR * 3;
                   }
                 }
-                RegionMatrix[r + REGION_MASS_CENTER_X] = (RegionMatrix[r + REGION_MASS_CENTER_X] * RegionMatrix[r + REGION_MASS] + NodeMatrix[n2 + NODE_X] * NodeMatrix[n2 + NODE_MASS]) / (RegionMatrix[r + REGION_MASS] + NodeMatrix[n2 + NODE_MASS]);
-                RegionMatrix[r + REGION_MASS_CENTER_Y] = (RegionMatrix[r + REGION_MASS_CENTER_Y] * RegionMatrix[r + REGION_MASS] + NodeMatrix[n2 + NODE_Y] * NodeMatrix[n2 + NODE_MASS]) / (RegionMatrix[r + REGION_MASS] + NodeMatrix[n2 + NODE_MASS]);
-                RegionMatrix[r + REGION_MASS] += NodeMatrix[n2 + NODE_MASS];
+                RegionMatrix[r + REGION_MASS_CENTER_X] = (RegionMatrix[r + REGION_MASS_CENTER_X] * RegionMatrix[r + REGION_MASS] + NodeMatrix[n3 + NODE_X] * NodeMatrix[n3 + NODE_MASS]) / (RegionMatrix[r + REGION_MASS] + NodeMatrix[n3 + NODE_MASS]);
+                RegionMatrix[r + REGION_MASS_CENTER_Y] = (RegionMatrix[r + REGION_MASS_CENTER_Y] * RegionMatrix[r + REGION_MASS] + NodeMatrix[n3 + NODE_Y] * NodeMatrix[n3 + NODE_MASS]) / (RegionMatrix[r + REGION_MASS] + NodeMatrix[n3 + NODE_MASS]);
+                RegionMatrix[r + REGION_MASS] += NodeMatrix[n3 + NODE_MASS];
                 r = q2;
                 continue;
               } else {
                 if (RegionMatrix[r + REGION_NODE] < 0) {
-                  RegionMatrix[r + REGION_NODE] = n2;
+                  RegionMatrix[r + REGION_NODE] = n3;
                   break;
                 } else {
                   RegionMatrix[r + REGION_FIRST_CHILD] = l * PPR;
@@ -6407,14 +6408,14 @@ function requireWebworker() {
                   RegionMatrix[r + REGION_MASS_CENTER_Y] = NodeMatrix[RegionMatrix[r + REGION_NODE] + NODE_Y];
                   RegionMatrix[q2 + REGION_NODE] = RegionMatrix[r + REGION_NODE];
                   RegionMatrix[r + REGION_NODE] = -1;
-                  if (NodeMatrix[n2 + NODE_X] < RegionMatrix[r + REGION_CENTER_X]) {
-                    if (NodeMatrix[n2 + NODE_Y] < RegionMatrix[r + REGION_CENTER_Y]) {
+                  if (NodeMatrix[n3 + NODE_X] < RegionMatrix[r + REGION_CENTER_X]) {
+                    if (NodeMatrix[n3 + NODE_Y] < RegionMatrix[r + REGION_CENTER_Y]) {
                       q22 = RegionMatrix[r + REGION_FIRST_CHILD];
                     } else {
                       q22 = RegionMatrix[r + REGION_FIRST_CHILD] + PPR;
                     }
                   } else {
-                    if (NodeMatrix[n2 + NODE_Y] < RegionMatrix[r + REGION_CENTER_Y]) {
+                    if (NodeMatrix[n3 + NODE_Y] < RegionMatrix[r + REGION_CENTER_Y]) {
                       q22 = RegionMatrix[r + REGION_FIRST_CHILD] + PPR * 2;
                     } else {
                       q22 = RegionMatrix[r + REGION_FIRST_CHILD] + PPR * 3;
@@ -6429,7 +6430,7 @@ function requireWebworker() {
                       break;
                     }
                   }
-                  RegionMatrix[q22 + REGION_NODE] = n2;
+                  RegionMatrix[q22 + REGION_NODE] = n3;
                   break;
                 }
               }
@@ -6438,36 +6439,36 @@ function requireWebworker() {
         }
         if (options.barnesHutOptimize) {
           coefficient = options.scalingRatio;
-          for (n2 = 0; n2 < order; n2 += PPN) {
+          for (n3 = 0; n3 < order; n3 += PPN) {
             r = 0;
             while (true) {
               if (RegionMatrix[r + REGION_FIRST_CHILD] >= 0) {
                 distance = Math.pow(
-                  NodeMatrix[n2 + NODE_X] - RegionMatrix[r + REGION_MASS_CENTER_X],
+                  NodeMatrix[n3 + NODE_X] - RegionMatrix[r + REGION_MASS_CENTER_X],
                   2
                 ) + Math.pow(
-                  NodeMatrix[n2 + NODE_Y] - RegionMatrix[r + REGION_MASS_CENTER_Y],
+                  NodeMatrix[n3 + NODE_Y] - RegionMatrix[r + REGION_MASS_CENTER_Y],
                   2
                 );
                 s2 = RegionMatrix[r + REGION_SIZE];
                 if (4 * s2 * s2 / distance < thetaSquared) {
-                  xDist = NodeMatrix[n2 + NODE_X] - RegionMatrix[r + REGION_MASS_CENTER_X];
-                  yDist = NodeMatrix[n2 + NODE_Y] - RegionMatrix[r + REGION_MASS_CENTER_Y];
+                  xDist = NodeMatrix[n3 + NODE_X] - RegionMatrix[r + REGION_MASS_CENTER_X];
+                  yDist = NodeMatrix[n3 + NODE_Y] - RegionMatrix[r + REGION_MASS_CENTER_Y];
                   if (adjustSizes === true) {
                     if (distance > 0) {
-                      factor = coefficient * NodeMatrix[n2 + NODE_MASS] * RegionMatrix[r + REGION_MASS] / distance;
-                      NodeMatrix[n2 + NODE_DX] += xDist * factor;
-                      NodeMatrix[n2 + NODE_DY] += yDist * factor;
+                      factor = coefficient * NodeMatrix[n3 + NODE_MASS] * RegionMatrix[r + REGION_MASS] / distance;
+                      NodeMatrix[n3 + NODE_DX] += xDist * factor;
+                      NodeMatrix[n3 + NODE_DY] += yDist * factor;
                     } else if (distance < 0) {
-                      factor = -coefficient * NodeMatrix[n2 + NODE_MASS] * RegionMatrix[r + REGION_MASS] / Math.sqrt(distance);
-                      NodeMatrix[n2 + NODE_DX] += xDist * factor;
-                      NodeMatrix[n2 + NODE_DY] += yDist * factor;
+                      factor = -coefficient * NodeMatrix[n3 + NODE_MASS] * RegionMatrix[r + REGION_MASS] / Math.sqrt(distance);
+                      NodeMatrix[n3 + NODE_DX] += xDist * factor;
+                      NodeMatrix[n3 + NODE_DY] += yDist * factor;
                     }
                   } else {
                     if (distance > 0) {
-                      factor = coefficient * NodeMatrix[n2 + NODE_MASS] * RegionMatrix[r + REGION_MASS] / distance;
-                      NodeMatrix[n2 + NODE_DX] += xDist * factor;
-                      NodeMatrix[n2 + NODE_DY] += yDist * factor;
+                      factor = coefficient * NodeMatrix[n3 + NODE_MASS] * RegionMatrix[r + REGION_MASS] / distance;
+                      NodeMatrix[n3 + NODE_DX] += xDist * factor;
+                      NodeMatrix[n3 + NODE_DY] += yDist * factor;
                     }
                   }
                   r = RegionMatrix[r + REGION_NEXT_SIBLING];
@@ -6479,25 +6480,25 @@ function requireWebworker() {
                 }
               } else {
                 rn = RegionMatrix[r + REGION_NODE];
-                if (rn >= 0 && rn !== n2) {
-                  xDist = NodeMatrix[n2 + NODE_X] - NodeMatrix[rn + NODE_X];
-                  yDist = NodeMatrix[n2 + NODE_Y] - NodeMatrix[rn + NODE_Y];
+                if (rn >= 0 && rn !== n3) {
+                  xDist = NodeMatrix[n3 + NODE_X] - NodeMatrix[rn + NODE_X];
+                  yDist = NodeMatrix[n3 + NODE_Y] - NodeMatrix[rn + NODE_Y];
                   distance = xDist * xDist + yDist * yDist;
                   if (adjustSizes === true) {
                     if (distance > 0) {
-                      factor = coefficient * NodeMatrix[n2 + NODE_MASS] * NodeMatrix[rn + NODE_MASS] / distance;
-                      NodeMatrix[n2 + NODE_DX] += xDist * factor;
-                      NodeMatrix[n2 + NODE_DY] += yDist * factor;
+                      factor = coefficient * NodeMatrix[n3 + NODE_MASS] * NodeMatrix[rn + NODE_MASS] / distance;
+                      NodeMatrix[n3 + NODE_DX] += xDist * factor;
+                      NodeMatrix[n3 + NODE_DY] += yDist * factor;
                     } else if (distance < 0) {
-                      factor = -coefficient * NodeMatrix[n2 + NODE_MASS] * NodeMatrix[rn + NODE_MASS] / Math.sqrt(distance);
-                      NodeMatrix[n2 + NODE_DX] += xDist * factor;
-                      NodeMatrix[n2 + NODE_DY] += yDist * factor;
+                      factor = -coefficient * NodeMatrix[n3 + NODE_MASS] * NodeMatrix[rn + NODE_MASS] / Math.sqrt(distance);
+                      NodeMatrix[n3 + NODE_DX] += xDist * factor;
+                      NodeMatrix[n3 + NODE_DY] += yDist * factor;
                     }
                   } else {
                     if (distance > 0) {
-                      factor = coefficient * NodeMatrix[n2 + NODE_MASS] * NodeMatrix[rn + NODE_MASS] / distance;
-                      NodeMatrix[n2 + NODE_DX] += xDist * factor;
-                      NodeMatrix[n2 + NODE_DY] += yDist * factor;
+                      factor = coefficient * NodeMatrix[n3 + NODE_MASS] * NodeMatrix[rn + NODE_MASS] / distance;
+                      NodeMatrix[n3 + NODE_DX] += xDist * factor;
+                      NodeMatrix[n3 + NODE_DY] += yDist * factor;
                     }
                   }
                 }
@@ -6543,19 +6544,19 @@ function requireWebworker() {
         }
         g = options.gravity / options.scalingRatio;
         coefficient = options.scalingRatio;
-        for (n2 = 0; n2 < order; n2 += PPN) {
+        for (n3 = 0; n3 < order; n3 += PPN) {
           factor = 0;
-          xDist = NodeMatrix[n2 + NODE_X];
-          yDist = NodeMatrix[n2 + NODE_Y];
+          xDist = NodeMatrix[n3 + NODE_X];
+          yDist = NodeMatrix[n3 + NODE_Y];
           distance = Math.sqrt(Math.pow(xDist, 2) + Math.pow(yDist, 2));
           if (options.strongGravityMode) {
-            if (distance > 0) factor = coefficient * NodeMatrix[n2 + NODE_MASS] * g;
+            if (distance > 0) factor = coefficient * NodeMatrix[n3 + NODE_MASS] * g;
           } else {
             if (distance > 0)
-              factor = coefficient * NodeMatrix[n2 + NODE_MASS] * g / distance;
+              factor = coefficient * NodeMatrix[n3 + NODE_MASS] * g / distance;
           }
-          NodeMatrix[n2 + NODE_DX] -= xDist * factor;
-          NodeMatrix[n2 + NODE_DY] -= yDist * factor;
+          NodeMatrix[n3 + NODE_DX] -= xDist * factor;
+          NodeMatrix[n3 + NODE_DY] -= yDist * factor;
         }
         coefficient = 1 * (options.outboundAttractionDistribution ? outboundAttCompensation : 1);
         for (e2 = 0; e2 < size; e2 += PPE) {
@@ -6618,48 +6619,48 @@ function requireWebworker() {
         }
         var force, swinging, traction, nodespeed, newX, newY;
         if (adjustSizes === true) {
-          for (n2 = 0; n2 < order; n2 += PPN) {
-            if (NodeMatrix[n2 + NODE_FIXED] !== 1) {
+          for (n3 = 0; n3 < order; n3 += PPN) {
+            if (NodeMatrix[n3 + NODE_FIXED] !== 1) {
               force = Math.sqrt(
-                Math.pow(NodeMatrix[n2 + NODE_DX], 2) + Math.pow(NodeMatrix[n2 + NODE_DY], 2)
+                Math.pow(NodeMatrix[n3 + NODE_DX], 2) + Math.pow(NodeMatrix[n3 + NODE_DY], 2)
               );
               if (force > MAX_FORCE) {
-                NodeMatrix[n2 + NODE_DX] = NodeMatrix[n2 + NODE_DX] * MAX_FORCE / force;
-                NodeMatrix[n2 + NODE_DY] = NodeMatrix[n2 + NODE_DY] * MAX_FORCE / force;
+                NodeMatrix[n3 + NODE_DX] = NodeMatrix[n3 + NODE_DX] * MAX_FORCE / force;
+                NodeMatrix[n3 + NODE_DY] = NodeMatrix[n3 + NODE_DY] * MAX_FORCE / force;
               }
-              swinging = NodeMatrix[n2 + NODE_MASS] * Math.sqrt(
-                (NodeMatrix[n2 + NODE_OLD_DX] - NodeMatrix[n2 + NODE_DX]) * (NodeMatrix[n2 + NODE_OLD_DX] - NodeMatrix[n2 + NODE_DX]) + (NodeMatrix[n2 + NODE_OLD_DY] - NodeMatrix[n2 + NODE_DY]) * (NodeMatrix[n2 + NODE_OLD_DY] - NodeMatrix[n2 + NODE_DY])
+              swinging = NodeMatrix[n3 + NODE_MASS] * Math.sqrt(
+                (NodeMatrix[n3 + NODE_OLD_DX] - NodeMatrix[n3 + NODE_DX]) * (NodeMatrix[n3 + NODE_OLD_DX] - NodeMatrix[n3 + NODE_DX]) + (NodeMatrix[n3 + NODE_OLD_DY] - NodeMatrix[n3 + NODE_DY]) * (NodeMatrix[n3 + NODE_OLD_DY] - NodeMatrix[n3 + NODE_DY])
               );
               traction = Math.sqrt(
-                (NodeMatrix[n2 + NODE_OLD_DX] + NodeMatrix[n2 + NODE_DX]) * (NodeMatrix[n2 + NODE_OLD_DX] + NodeMatrix[n2 + NODE_DX]) + (NodeMatrix[n2 + NODE_OLD_DY] + NodeMatrix[n2 + NODE_DY]) * (NodeMatrix[n2 + NODE_OLD_DY] + NodeMatrix[n2 + NODE_DY])
+                (NodeMatrix[n3 + NODE_OLD_DX] + NodeMatrix[n3 + NODE_DX]) * (NodeMatrix[n3 + NODE_OLD_DX] + NodeMatrix[n3 + NODE_DX]) + (NodeMatrix[n3 + NODE_OLD_DY] + NodeMatrix[n3 + NODE_DY]) * (NodeMatrix[n3 + NODE_OLD_DY] + NodeMatrix[n3 + NODE_DY])
               ) / 2;
               nodespeed = 0.1 * Math.log(1 + traction) / (1 + Math.sqrt(swinging));
-              newX = NodeMatrix[n2 + NODE_X] + NodeMatrix[n2 + NODE_DX] * (nodespeed / options.slowDown);
-              NodeMatrix[n2 + NODE_X] = newX;
-              newY = NodeMatrix[n2 + NODE_Y] + NodeMatrix[n2 + NODE_DY] * (nodespeed / options.slowDown);
-              NodeMatrix[n2 + NODE_Y] = newY;
+              newX = NodeMatrix[n3 + NODE_X] + NodeMatrix[n3 + NODE_DX] * (nodespeed / options.slowDown);
+              NodeMatrix[n3 + NODE_X] = newX;
+              newY = NodeMatrix[n3 + NODE_Y] + NodeMatrix[n3 + NODE_DY] * (nodespeed / options.slowDown);
+              NodeMatrix[n3 + NODE_Y] = newY;
             }
           }
         } else {
-          for (n2 = 0; n2 < order; n2 += PPN) {
-            if (NodeMatrix[n2 + NODE_FIXED] !== 1) {
-              swinging = NodeMatrix[n2 + NODE_MASS] * Math.sqrt(
-                (NodeMatrix[n2 + NODE_OLD_DX] - NodeMatrix[n2 + NODE_DX]) * (NodeMatrix[n2 + NODE_OLD_DX] - NodeMatrix[n2 + NODE_DX]) + (NodeMatrix[n2 + NODE_OLD_DY] - NodeMatrix[n2 + NODE_DY]) * (NodeMatrix[n2 + NODE_OLD_DY] - NodeMatrix[n2 + NODE_DY])
+          for (n3 = 0; n3 < order; n3 += PPN) {
+            if (NodeMatrix[n3 + NODE_FIXED] !== 1) {
+              swinging = NodeMatrix[n3 + NODE_MASS] * Math.sqrt(
+                (NodeMatrix[n3 + NODE_OLD_DX] - NodeMatrix[n3 + NODE_DX]) * (NodeMatrix[n3 + NODE_OLD_DX] - NodeMatrix[n3 + NODE_DX]) + (NodeMatrix[n3 + NODE_OLD_DY] - NodeMatrix[n3 + NODE_DY]) * (NodeMatrix[n3 + NODE_OLD_DY] - NodeMatrix[n3 + NODE_DY])
               );
               traction = Math.sqrt(
-                (NodeMatrix[n2 + NODE_OLD_DX] + NodeMatrix[n2 + NODE_DX]) * (NodeMatrix[n2 + NODE_OLD_DX] + NodeMatrix[n2 + NODE_DX]) + (NodeMatrix[n2 + NODE_OLD_DY] + NodeMatrix[n2 + NODE_DY]) * (NodeMatrix[n2 + NODE_OLD_DY] + NodeMatrix[n2 + NODE_DY])
+                (NodeMatrix[n3 + NODE_OLD_DX] + NodeMatrix[n3 + NODE_DX]) * (NodeMatrix[n3 + NODE_OLD_DX] + NodeMatrix[n3 + NODE_DX]) + (NodeMatrix[n3 + NODE_OLD_DY] + NodeMatrix[n3 + NODE_DY]) * (NodeMatrix[n3 + NODE_OLD_DY] + NodeMatrix[n3 + NODE_DY])
               ) / 2;
-              nodespeed = NodeMatrix[n2 + NODE_CONVERGENCE] * Math.log(1 + traction) / (1 + Math.sqrt(swinging));
-              NodeMatrix[n2 + NODE_CONVERGENCE] = Math.min(
+              nodespeed = NodeMatrix[n3 + NODE_CONVERGENCE] * Math.log(1 + traction) / (1 + Math.sqrt(swinging));
+              NodeMatrix[n3 + NODE_CONVERGENCE] = Math.min(
                 1,
                 Math.sqrt(
-                  nodespeed * (Math.pow(NodeMatrix[n2 + NODE_DX], 2) + Math.pow(NodeMatrix[n2 + NODE_DY], 2)) / (1 + Math.sqrt(swinging))
+                  nodespeed * (Math.pow(NodeMatrix[n3 + NODE_DX], 2) + Math.pow(NodeMatrix[n3 + NODE_DY], 2)) / (1 + Math.sqrt(swinging))
                 )
               );
-              newX = NodeMatrix[n2 + NODE_X] + NodeMatrix[n2 + NODE_DX] * (nodespeed / options.slowDown);
-              NodeMatrix[n2 + NODE_X] = newX;
-              newY = NodeMatrix[n2 + NODE_Y] + NodeMatrix[n2 + NODE_DY] * (nodespeed / options.slowDown);
-              NodeMatrix[n2 + NODE_Y] = newY;
+              newX = NodeMatrix[n3 + NODE_X] + NodeMatrix[n3 + NODE_DX] * (nodespeed / options.slowDown);
+              NodeMatrix[n3 + NODE_X] = newX;
+              newY = NodeMatrix[n3 + NODE_Y] + NodeMatrix[n3 + NODE_DY] * (nodespeed / options.slowDown);
+              NodeMatrix[n3 + NODE_Y] = newY;
             }
           }
         }
@@ -6797,7 +6798,7 @@ function requireWorker() {
 }
 var workerExports = requireWorker();
 const e = /* @__PURE__ */ getDefaultExportFromCjs(workerExports);
-function n(t2 = {}) {
+function n2(t2 = {}) {
   return c(e, t2);
 }
 function zoomToNodes(sigma, nodeIds, duration = 600, padding = 0.2) {
@@ -6857,7 +6858,7 @@ function LayoutPipeline({
   const timerRef = useRef(null);
   const spacingWorkerRef = useRef(null);
   const perCommunityNoverlapCancel = useRef(null);
-  const { start, stop } = n({
+  const { start, stop } = n2({
     settings: {
       gravity: layoutConfig.fa2Gravity,
       scalingRatio: layoutConfig.fa2ScalingRatio,
@@ -7481,7 +7482,7 @@ const GraphCanvas = memo(
         ref,
         () => ({
           selectNode: (nodeId, nodeHops) => {
-            const node = nodes.find((n2) => n2.id === nodeId);
+            const node = nodes.find((n3) => n3.id === nodeId);
             if (node) {
               onNodeClick?.(node);
               if (sigmaRef.current) {
@@ -7497,7 +7498,7 @@ const GraphCanvas = memo(
                   adj.get(s2).push(t2);
                   adj.get(t2).push(s2);
                 }
-                for (let d2 = 0; d2 < h2 && frontier.size > 0; d2++) {
+                for (let d3 = 0; d3 < h2 && frontier.size > 0; d3++) {
                   const next = /* @__PURE__ */ new Set();
                   frontier.forEach((id) => {
                     adj.get(id)?.forEach((nb) => {
@@ -7796,7 +7797,7 @@ function GraphBadge({
       totalNodes,
       ")"
     ] }),
-    /* @__PURE__ */ jsx("span", { children: "nodes" }),
+    /* @__PURE__ */ jsx("span", { className: "graph-badge-label", children: "nodes" }),
     /* @__PURE__ */ jsx("span", { className: "graph-badge-sep", children: "·" }),
     /* @__PURE__ */ jsx("span", { className: "graph-badge-rendered", children: edgeCount }),
     totalEdges != null && /* @__PURE__ */ jsxs("span", { className: "graph-badge-total", children: [
@@ -7804,7 +7805,7 @@ function GraphBadge({
       totalEdges,
       ")"
     ] }),
-    /* @__PURE__ */ jsx("span", { children: "edges" })
+    /* @__PURE__ */ jsx("span", { className: "graph-badge-label", children: "edges" })
   ] });
 }
 const DEFAULT_MAX_VISIBLE = 5;
@@ -7874,6 +7875,198 @@ function GraphLegend({
     ] })
   ] });
 }
+function GraphToolbar({
+  logo,
+  searchQuery,
+  onSearchQueryChange,
+  onSearch,
+  onReset,
+  searchDisabled,
+  showResetButton,
+  hops,
+  onHopsChange,
+  maxHops = 5,
+  nodeCount,
+  edgeCount,
+  totalNodes,
+  totalEdges,
+  mobilePanelTabs,
+  onMobilePanelTab,
+  actions,
+  persistentActions,
+  className
+}) {
+  const [menuOpen, setMenuOpen] = useState(false);
+  const navRef = useRef(null);
+  const burgerRef = useRef(null);
+  useEffect(() => {
+    if (!menuOpen) return;
+    const onClickOutside = (e2) => {
+      if (navRef.current?.contains(e2.target)) return;
+      if (burgerRef.current?.contains(e2.target)) return;
+      setMenuOpen(false);
+    };
+    const onEscape = (e2) => {
+      if (e2.key === "Escape") setMenuOpen(false);
+    };
+    document.addEventListener("mousedown", onClickOutside);
+    document.addEventListener("keydown", onEscape);
+    return () => {
+      document.removeEventListener("mousedown", onClickOutside);
+      document.removeEventListener("keydown", onEscape);
+    };
+  }, [menuOpen]);
+  const handleNavClick = useCallback((e2) => {
+    const target = e2.target;
+    const clickable = target.closest("button, a");
+    if (clickable && !clickable.classList.contains("ot-clear-search") && !clickable.classList.contains("ot-search-btn")) {
+      setMenuOpen(false);
+    }
+  }, []);
+  const visibleTabs = mobilePanelTabs?.filter((t2) => t2.visible !== false);
+  const searchMarkup = (id) => /* @__PURE__ */ jsxs("div", { className: "ot-search-container", children: [
+    /* @__PURE__ */ jsx(
+      "input",
+      {
+        type: "text",
+        placeholder: "Search nodes...",
+        value: searchQuery,
+        onChange: (e2) => onSearchQueryChange(e2.target.value),
+        onKeyDown: (e2) => e2.key === "Enter" && onSearch(),
+        className: "ot-search-input"
+      }
+    ),
+    /* @__PURE__ */ jsxs("div", { className: "ot-search-params", children: [
+      /* @__PURE__ */ jsx("label", { htmlFor: `ot-hops-input-${id}`, children: "Hops:" }),
+      /* @__PURE__ */ jsx(
+        "input",
+        {
+          id: `ot-hops-input-${id}`,
+          type: "number",
+          min: "0",
+          max: maxHops,
+          value: hops,
+          onChange: (e2) => onHopsChange(
+            Math.min(maxHops, Math.max(0, parseInt(e2.target.value) || 0))
+          ),
+          className: "ot-hops-input",
+          title: `Number of connection hops to include (max ${maxHops})`
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxs("div", { className: "ot-search-actions", children: [
+      searchQuery && /* @__PURE__ */ jsx(
+        "button",
+        {
+          className: "ot-clear-search",
+          onClick: onReset,
+          title: "Clear search",
+          children: "×"
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        "button",
+        {
+          className: "ot-search-btn",
+          onClick: onSearch,
+          title: "Query API and rerender",
+          disabled: searchDisabled,
+          children: /* @__PURE__ */ jsxs(
+            "svg",
+            {
+              width: "14",
+              height: "14",
+              viewBox: "0 0 24 24",
+              fill: "none",
+              stroke: "currentColor",
+              strokeWidth: "2.5",
+              strokeLinecap: "round",
+              strokeLinejoin: "round",
+              children: [
+                /* @__PURE__ */ jsx("circle", { cx: "11", cy: "11", r: "8" }),
+                /* @__PURE__ */ jsx("line", { x1: "21", y1: "21", x2: "16.65", y2: "16.65" })
+              ]
+            }
+          )
+        }
+      )
+    ] })
+  ] });
+  return /* @__PURE__ */ jsxs("header", { className: `ot-toolbar${className ? ` ${className}` : ""}`, children: [
+    logo,
+    /* @__PURE__ */ jsx("div", { className: "ot-search-tablet", children: searchMarkup("tablet") }),
+    persistentActions && /* @__PURE__ */ jsx("div", { className: "ot-persistent-mobile", children: persistentActions }),
+    /* @__PURE__ */ jsx(
+      "button",
+      {
+        type: "button",
+        className: "ot-burger-btn",
+        ref: burgerRef,
+        onClick: () => setMenuOpen((v2) => !v2),
+        "aria-label": "Toggle menu",
+        "aria-expanded": menuOpen,
+        children: /* @__PURE__ */ jsx(
+          "svg",
+          {
+            width: "22",
+            height: "22",
+            viewBox: "0 0 24 24",
+            fill: "none",
+            stroke: "currentColor",
+            strokeWidth: "2",
+            strokeLinecap: "round",
+            strokeLinejoin: "round",
+            children: menuOpen ? /* @__PURE__ */ jsxs(Fragment, { children: [
+              /* @__PURE__ */ jsx("line", { x1: "18", y1: "6", x2: "6", y2: "18" }),
+              /* @__PURE__ */ jsx("line", { x1: "6", y1: "6", x2: "18", y2: "18" })
+            ] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+              /* @__PURE__ */ jsx("line", { x1: "3", y1: "6", x2: "21", y2: "6" }),
+              /* @__PURE__ */ jsx("line", { x1: "3", y1: "12", x2: "21", y2: "12" }),
+              /* @__PURE__ */ jsx("line", { x1: "3", y1: "18", x2: "21", y2: "18" })
+            ] })
+          }
+        )
+      }
+    ),
+    /* @__PURE__ */ jsxs(
+      "nav",
+      {
+        className: `ot-toolbar-nav${menuOpen ? " open" : ""}`,
+        ref: navRef,
+        onClick: handleNavClick,
+        children: [
+          visibleTabs?.map((tab) => /* @__PURE__ */ jsxs(
+            "button",
+            {
+              type: "button",
+              className: "ot-mobile-panel-btn",
+              onClick: () => onMobilePanelTab?.(tab.key),
+              children: [
+                tab.icon,
+                /* @__PURE__ */ jsx("span", { className: "ot-menu-label", children: tab.label })
+              ]
+            },
+            tab.key
+          )),
+          visibleTabs && visibleTabs.length > 0 && /* @__PURE__ */ jsx("div", { className: "ot-menu-divider" }),
+          /* @__PURE__ */ jsx("div", { className: "ot-search-nav", children: searchMarkup("nav") }),
+          showResetButton && /* @__PURE__ */ jsx("button", { className: "ot-reset-btn", onClick: onReset, children: "Show All" }),
+          /* @__PURE__ */ jsx(
+            GraphBadge,
+            {
+              nodeCount,
+              edgeCount,
+              totalNodes,
+              totalEdges
+            }
+          ),
+          persistentActions && /* @__PURE__ */ jsx("div", { className: "ot-persistent-desktop", children: persistentActions }),
+          actions
+        ]
+      }
+    )
+  ] });
+}
 const q = typeof window < "u" ? useLayoutEffect : useEffect;
 function ie(e2) {
   if (e2 !== void 0)
@@ -7892,7 +8085,7 @@ function be({
   defaultHeight: t2,
   defaultWidth: s2,
   disabled: r,
-  element: n2,
+  element: n3,
   mode: o,
   style: i
 }) {
@@ -7902,26 +8095,26 @@ function be({
       styleWidth: ie(i?.width)
     }),
     [i?.height, i?.width]
-  ), [c2, d2] = useState({
+  ), [c2, d3] = useState({
     height: t2,
     width: s2
   }), a = r || f2 !== void 0 || o === "only-width" || f2 !== void 0 && l !== void 0;
   return q(() => {
-    if (n2 === null || a)
+    if (n3 === null || a)
       return;
     const h2 = new ResizeObserver((p) => {
-      for (const I of p) {
-        const { contentRect: u, target: w2 } = I;
-        n2 === w2 && d2((m) => m.height === u.height && m.width === u.width ? m : {
+      for (const I2 of p) {
+        const { contentRect: u, target: w2 } = I2;
+        n3 === w2 && d3((m) => m.height === u.height && m.width === u.width ? m : {
           height: u.height,
           width: u.width
         });
       }
     });
-    return h2.observe(n2, { box: e2 }), () => {
-      h2?.unobserve(n2);
+    return h2.observe(n3, { box: e2 }), () => {
+      h2?.unobserve(n3);
     };
-  }, [e2, a, n2, f2, l]), useMemo(
+  }, [e2, a, n3, f2, l]), useMemo(
     () => ({
       height: f2 ?? c2.height,
       width: l ?? c2.width
@@ -7973,8 +8166,8 @@ function fe({
       e2.size === 0 ? 0 : e2.size - 1
     );
     L(r !== void 0, "Unexpected bounds cache miss");
-    const n2 = (r.scrollOffset + r.size) / e2.size;
-    return t2 * n2;
+    const n3 = (r.scrollOffset + r.size) / e2.size;
+    return t2 * n3;
   }
 }
 function we({
@@ -7982,7 +8175,7 @@ function we({
   cachedBounds: t2,
   index: s2,
   itemCount: r,
-  itemSize: n2,
+  itemSize: n3,
   containerScrollOffset: o,
   containerSize: i
 }) {
@@ -7993,24 +8186,24 @@ function we({
   const f2 = fe({
     cachedBounds: t2,
     itemCount: r,
-    itemSize: n2
+    itemSize: n3
   }), l = t2.get(s2), c2 = Math.max(
     0,
     Math.min(f2 - i, l.scrollOffset)
-  ), d2 = Math.max(
+  ), d3 = Math.max(
     0,
     l.scrollOffset - i + l.size
   );
-  switch (e2 === "smart" && (o >= d2 && o <= c2 ? e2 = "auto" : e2 = "center"), e2) {
+  switch (e2 === "smart" && (o >= d3 && o <= c2 ? e2 = "auto" : e2 = "center"), e2) {
     case "start":
       return c2;
     case "end":
-      return d2;
+      return d3;
     case "center":
       return l.scrollOffset <= i / 2 ? 0 : l.scrollOffset + l.size / 2 >= f2 - i / 2 ? f2 - i : l.scrollOffset + l.size / 2 - i / 2;
     case "auto":
     default:
-      return o >= d2 && o <= c2 ? o : o < d2 ? d2 : c2;
+      return o >= d3 && o <= c2 ? o : o < d3 ? d3 : c2;
   }
 }
 function P({
@@ -8018,23 +8211,23 @@ function P({
   containerScrollOffset: t2,
   containerSize: s2,
   itemCount: r,
-  overscanCount: n2
+  overscanCount: n3
 }) {
   const o = r - 1;
-  let i = 0, f2 = -1, l = 0, c2 = -1, d2 = 0;
-  for (; d2 < o; ) {
-    const a = e2.get(d2);
+  let i = 0, f2 = -1, l = 0, c2 = -1, d3 = 0;
+  for (; d3 < o; ) {
+    const a = e2.get(d3);
     if (a.scrollOffset + a.size > t2)
       break;
-    d2++;
+    d3++;
   }
-  for (i = d2, l = Math.max(0, i - n2); d2 < o; ) {
-    const a = e2.get(d2);
+  for (i = d3, l = Math.max(0, i - n3); d3 < o; ) {
+    const a = e2.get(d3);
     if (a.scrollOffset + a.size >= t2 + s2)
       break;
-    d2++;
+    d3++;
   }
-  return f2 = Math.min(o, d2), c2 = Math.min(r - 1, f2 + n2), i < 0 && (i = 0, f2 = -1, l = 0, c2 = -1), {
+  return f2 = Math.min(o, d3), c2 = Math.min(r - 1, f2 + n3), i < 0 && (i = 0, f2 = -1, l = 0, c2 = -1), {
     startIndexVisible: i,
     stopIndexVisible: f2,
     startIndexOverscan: l,
@@ -8048,8 +8241,8 @@ function me({
 }) {
   const r = /* @__PURE__ */ new Map();
   return {
-    get(n2) {
-      for (L(n2 < e2, `Invalid index ${n2}`); r.size - 1 < n2; ) {
+    get(n3) {
+      for (L(n3 < e2, `Invalid index ${n3}`); r.size - 1 < n3; ) {
         const i = r.size;
         let f2;
         switch (typeof s2) {
@@ -8071,21 +8264,21 @@ function me({
           const l = r.get(i - 1);
           L(
             l !== void 0,
-            `Unexpected bounds cache miss for index ${n2}`
+            `Unexpected bounds cache miss for index ${n3}`
           ), r.set(i, {
             scrollOffset: l.scrollOffset + l.size,
             size: f2
           });
         }
       }
-      const o = r.get(n2);
+      const o = r.get(n3);
       return L(
         o !== void 0,
-        `Unexpected bounds cache miss for index ${n2}`
+        `Unexpected bounds cache miss for index ${n3}`
       ), o;
     },
-    set(n2, o) {
-      r.set(n2, o);
+    set(n3, o) {
+      r.set(n3, o);
     },
     get size() {
       return r.size;
@@ -8134,14 +8327,14 @@ function te({
   containerStyle: t2,
   defaultContainerSize: s2 = 0,
   direction: r,
-  isRtl: n2 = false,
+  isRtl: n3 = false,
   itemCount: o,
   itemProps: i,
   itemSize: f2,
   onResize: l,
   overscanCount: c2
 }) {
-  const { height: d2 = s2, width: a = s2 } = be({
+  const { height: d3 = s2, width: a = s2 } = be({
     defaultHeight: s2,
     defaultWidth: void 0,
     element: e2,
@@ -8150,17 +8343,17 @@ function te({
   }), h2 = useRef({
     height: 0,
     width: 0
-  }), p = d2, I = ye({ containerSize: p, itemSize: f2 });
+  }), p = d3, I2 = ye({ containerSize: p, itemSize: f2 });
   useLayoutEffect(() => {
     if (typeof l == "function") {
       const g = h2.current;
-      (g.height !== d2 || g.width !== a) && (l({ height: d2, width: a }, { ...g }), g.height = d2, g.width = a);
+      (g.height !== d3 || g.width !== a) && (l({ height: d3, width: a }, { ...g }), g.height = d3, g.width = a);
     }
-  }, [d2, l, a]);
+  }, [d3, l, a]);
   const u = Oe({
     itemCount: o,
     itemProps: i,
-    itemSize: I
+    itemSize: I2
   }), w2 = useCallback(
     (g) => u.get(g),
     [u]
@@ -8187,15 +8380,15 @@ function te({
     () => fe({
       cachedBounds: u,
       itemCount: o,
-      itemSize: I
+      itemSize: I2
     }),
-    [u, o, I]
+    [u, o, I2]
   ), $ = useCallback(
     (g) => {
       const S2 = Z({
         containerElement: e2,
         direction: r,
-        isRtl: n2,
+        isRtl: n3,
         scrollOffset: g
       });
       return P({
@@ -8211,7 +8404,7 @@ function te({
       e2,
       p,
       r,
-      n2,
+      n3,
       o,
       c2
     ]
@@ -8227,7 +8420,7 @@ function te({
         const { scrollLeft: E, scrollTop: b } = e2, v2 = Z({
           containerElement: e2,
           direction: r,
-          isRtl: n2,
+          isRtl: n3,
           scrollOffset: b
         }), R = P({
           cachedBounds: u,
@@ -8263,13 +8456,13 @@ function te({
         containerSize: p,
         index: E,
         itemCount: o,
-        itemSize: I
+        itemSize: I2
       });
       if (e2) {
         if (b = Z({
           containerElement: e2,
           direction: r,
-          isRtl: n2,
+          isRtl: n3,
           scrollOffset: b
         }), typeof e2.scrollTo != "function") {
           const v2 = $(b);
@@ -8296,13 +8489,13 @@ function ue(e2, t2) {
   const {
     ariaAttributes: s2,
     style: r,
-    ...n2
+    ...n3
   } = e2, {
     ariaAttributes: o,
     style: i,
     ...f2
   } = t2;
-  return Y(s2, o) && Y(r, i) && Y(n2, f2);
+  return Y(s2, o) && Y(r, i) && Y(n3, f2);
 }
 function ze(e2) {
   return e2 != null && typeof e2 == "object" && "getAverageRowHeight" in e2 && typeof e2.getAverageRowHeight == "function";
@@ -8313,18 +8506,18 @@ function Ae({
   className: t2,
   defaultHeight: s2 = 0,
   listRef: r,
-  onResize: n2,
+  onResize: n3,
   onRowsRendered: o,
   overscanCount: i = 3,
   rowComponent: f2,
   rowCount: l,
   rowHeight: c2,
-  rowProps: d2,
+  rowProps: d3,
   tagName: a = "div",
   style: h2,
   ...p
 }) {
-  const I = de(d2), u = useMemo(
+  const I2 = de(d3), u = useMemo(
     () => memo(f2, ue),
     [f2]
   ), [w2, m] = useState(null), O = ze(c2), G = useMemo(() => O ? (b) => c2.getRowHeight(b) ?? c2.getAverageRowHeight() : c2, [O, c2]), {
@@ -8341,9 +8534,9 @@ function Ae({
     defaultContainerSize: s2,
     direction: "vertical",
     itemCount: l,
-    itemProps: I,
+    itemProps: I2,
     itemSize: G,
-    onResize: n2,
+    onResize: n3,
     overscanCount: i
   });
   useImperativeHandle(
@@ -8413,7 +8606,7 @@ function Ae({
           /* @__PURE__ */ createElement$1(
             u,
             {
-              ...I,
+              ...I2,
               ariaAttributes: {
                 "aria-posinset": v2 + 1,
                 "aria-setsize": l,
@@ -8440,7 +8633,7 @@ function Ae({
     x,
     O,
     l,
-    I,
+    I2,
     z,
     y
   ]), E = /* @__PURE__ */ jsx(
@@ -8665,8 +8858,8 @@ function DiscoverPanel({
   const maxHops = useMemo(() => {
     if (!hopMap || hopMap.size === 0) return 1;
     let max = 0;
-    for (const d2 of hopMap.values()) {
-      if (d2 > max) max = d2;
+    for (const d3 of hopMap.values()) {
+      if (d3 > max) max = d3;
     }
     return max || 1;
   }, [hopMap]);
@@ -8772,6 +8965,7 @@ function DiscoverPanel({
   ] });
 }
 export {
+  A as AddRepoModal,
   DEFAULT_LAYOUT_CONFIG,
   DiscoverPanel,
   EDGE_OPACITY_DEFAULT,
@@ -8790,6 +8984,8 @@ export {
   GraphBadge,
   GraphCanvas,
   GraphLegend,
+  GraphToolbar,
+  I as IndexingProgress,
   LABEL_COLOR,
   LABEL_FONT,
   LABEL_RENDERED_SIZE_THRESHOLD,
@@ -8804,10 +9000,12 @@ export {
   ZOOM_SIZE_EXPONENT,
   buildCommunityColorMap,
   buildCommunityNames,
+  d as detectProvider,
   drawNodeHover,
   getCommunityColor,
   getLinkColor,
   getNodeColor,
+  n as normalizeRepoUrl,
   setHoveredNodeKey,
   s as shouldHideNode,
   useCommunities,