🐛 Update: Added support for the 'find' command in settings.local.json. Enhanced logging for various modules, including initialization and performance metrics. Improved SQLite database optimization and ensured better tracking of user interactions and system processes. 📚

network-visualization/node_modules/gsap/CSSRulePlugin.js

@@ -0,0 +1,133 @@
+/*!
+ * CSSRulePlugin 3.13.0
+ * https://gsap.com
+ *
+ * @license Copyright 2008-2025, GreenSock. All rights reserved.
+ * Subject to the terms at https://gsap.com/standard-license
+ * @author: Jack Doyle, jack@greensock.com
+*/
+
+/* eslint-disable */
+var gsap,
+    _coreInitted,
+    _win,
+    _doc,
+    CSSPlugin,
+    _windowExists = function _windowExists() {
+  return typeof window !== "undefined";
+},
+    _getGSAP = function _getGSAP() {
+  return gsap || _windowExists() && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+},
+    _checkRegister = function _checkRegister() {
+  if (!_coreInitted) {
+    _initCore();
+
+    if (!CSSPlugin) {
+      console.warn("Please gsap.registerPlugin(CSSPlugin, CSSRulePlugin)");
+    }
+  }
+
+  return _coreInitted;
+},
+    _initCore = function _initCore(core) {
+  gsap = core || _getGSAP();
+
+  if (_windowExists()) {
+    _win = window;
+    _doc = document;
+  }
+
+  if (gsap) {
+    CSSPlugin = gsap.plugins.css;
+
+    if (CSSPlugin) {
+      _coreInitted = 1;
+    }
+  }
+};
+
+export var CSSRulePlugin = {
+  version: "3.13.0",
+  name: "cssRule",
+  init: function init(target, value, tween, index, targets) {
+    if (!_checkRegister() || typeof target.cssText === "undefined") {
+      return false;
+    }
+
+    var div = target._gsProxy = target._gsProxy || _doc.createElement("div");
+
+    this.ss = target;
+    this.style = div.style;
+    div.style.cssText = target.cssText;
+    CSSPlugin.prototype.init.call(this, div, value, tween, index, targets); //we just offload all the work to the regular CSSPlugin and then copy the cssText back over to the rule in the render() method. This allows us to have all of the updates to CSSPlugin automatically flow through to CSSRulePlugin instead of having to maintain both
+  },
+  render: function render(ratio, data) {
+    var pt = data._pt,
+        style = data.style,
+        ss = data.ss,
+        i;
+
+    while (pt) {
+      pt.r(ratio, pt.d);
+      pt = pt._next;
+    }
+
+    i = style.length;
+
+    while (--i > -1) {
+      ss[style[i]] = style[style[i]];
+    }
+  },
+  getRule: function getRule(selector) {
+    _checkRegister();
+
+    var ruleProp = _doc.all ? "rules" : "cssRules",
+        styleSheets = _doc.styleSheets,
+        i = styleSheets.length,
+        pseudo = selector.charAt(0) === ":",
+        j,
+        curSS,
+        cs,
+        a;
+    selector = (pseudo ? "" : ",") + selector.split("::").join(":").toLowerCase() + ","; //note: old versions of IE report tag name selectors as upper case, so we just change everything to lowercase.
+
+    if (pseudo) {
+      a = [];
+    }
+
+    while (i--) {
+      //Firefox may throw insecure operation errors when css is loaded from other domains, so try/catch.
+      try {
+        curSS = styleSheets[i][ruleProp];
+
+        if (!curSS) {
+          continue;
+        }
+
+        j = curSS.length;
+      } catch (e) {
+        console.warn(e);
+        continue;
+      }
+
+      while (--j > -1) {
+        cs = curSS[j];
+
+        if (cs.selectorText && ("," + cs.selectorText.split("::").join(":").toLowerCase() + ",").indexOf(selector) !== -1) {
+          //note: IE adds an extra ":" to pseudo selectors, so .myClass:after becomes .myClass::after, so we need to strip the extra one out.
+          if (pseudo) {
+            a.push(cs.style);
+          } else {
+            return cs.style;
+          }
+        }
+      }
+    }
+
+    return a;
+  },
+  register: _initCore
+};
+_getGSAP() && gsap.registerPlugin(CSSRulePlugin);
+export { CSSRulePlugin as default };

network-visualization/node_modules/gsap/CustomBounce.js

@@ -0,0 +1,165 @@
+/*!
+ * CustomBounce 3.13.0
+ * https://gsap.com
+ *
+ * @license Copyright 2008-2025, GreenSock. All rights reserved.
+ * Subject to the terms at https://gsap.com/standard-license
+ * @author: Jack Doyle, jack@greensock.com
+*/
+
+/* eslint-disable */
+var gsap,
+    _coreInitted,
+    createCustomEase,
+    _getGSAP = function _getGSAP() {
+  return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+},
+    _initCore = function _initCore(required) {
+  gsap = _getGSAP();
+  createCustomEase = gsap && gsap.parseEase("_CE");
+
+  if (createCustomEase) {
+    _coreInitted = 1;
+
+    gsap.parseEase("bounce").config = function (vars) {
+      return typeof vars === "object" ? _create("", vars) : _create("bounce(" + vars + ")", {
+        strength: +vars
+      });
+    };
+  } else {
+    required && console.warn("Please gsap.registerPlugin(CustomEase, CustomBounce)");
+  }
+},
+    _normalizeX = function _normalizeX(a) {
+  //scales all the x values in an array [x, y, x, y...] AND rounds them to the closest hundredth (decimal)
+  var l = a.length,
+      s = 1 / a[l - 2],
+      rnd = 1000,
+      i;
+
+  for (i = 2; i < l; i += 2) {
+    a[i] = ~~(a[i] * s * rnd) / rnd;
+  }
+
+  a[l - 2] = 1; //in case there are any rounding errors. x should always end at 1.
+},
+    _bonusValidated = 1,
+    //<name>CustomBounce</name>
+_create = function _create(id, vars) {
+  if (!_coreInitted) {
+    _initCore(1);
+  }
+
+  vars = vars || {};
+
+  if (_bonusValidated) {
+    var max = 0.999,
+        decay = Math.min(max, vars.strength || 0.7),
+        // Math.min(0.999, 1 - 0.3 / (vars.strength || 1)),
+    decayX = decay,
+        gap = (vars.squash || 0) / 100,
+        originalGap = gap,
+        slope = 1 / 0.03,
+        w = 0.2,
+        h = 1,
+        prevX = 0.1,
+        path = [0, 0, 0.07, 0, 0.1, 1, 0.1, 1],
+        squashPath = [0, 0, 0, 0, 0.1, 0, 0.1, 0],
+        cp1,
+        cp2,
+        x,
+        y,
+        i,
+        nextX,
+        squishMagnitude;
+
+    for (i = 0; i < 200; i++) {
+      w *= decayX * ((decayX + 1) / 2);
+      h *= decay * decay;
+      nextX = prevX + w;
+      x = prevX + w * 0.49;
+      y = 1 - h;
+      cp1 = prevX + h / slope;
+      cp2 = x + (x - cp1) * 0.8;
+
+      if (gap) {
+        prevX += gap;
+        cp1 += gap;
+        x += gap;
+        cp2 += gap;
+        nextX += gap;
+        squishMagnitude = gap / originalGap;
+        squashPath.push(prevX - gap, 0, prevX - gap, squishMagnitude, prevX - gap / 2, squishMagnitude, //center peak anchor
+        prevX, squishMagnitude, prevX, 0, prevX, 0, //base anchor
+        prevX, squishMagnitude * -0.6, prevX + (nextX - prevX) / 6, 0, nextX, 0);
+        path.push(prevX - gap, 1, prevX, 1, prevX, 1);
+        gap *= decay * decay;
+      }
+
+      path.push(prevX, 1, cp1, y, x, y, cp2, y, nextX, 1, nextX, 1);
+      decay *= 0.95;
+      slope = h / (nextX - cp2);
+      prevX = nextX;
+
+      if (y > max) {
+        break;
+      }
+    }
+
+    if (vars.endAtStart && vars.endAtStart !== "false") {
+      x = -0.1;
+      path.unshift(x, 1, x, 1, -0.07, 0);
+
+      if (originalGap) {
+        gap = originalGap * 2.5; //make the initial anticipation squash longer (more realistic)
+
+        x -= gap;
+        path.unshift(x, 1, x, 1, x, 1);
+        squashPath.splice(0, 6);
+        squashPath.unshift(x, 0, x, 0, x, 1, x + gap / 2, 1, x + gap, 1, x + gap, 0, x + gap, 0, x + gap, -0.6, x + gap + 0.033, 0);
+
+        for (i = 0; i < squashPath.length; i += 2) {
+          squashPath[i] -= x;
+        }
+      }
+
+      for (i = 0; i < path.length; i += 2) {
+        path[i] -= x;
+        path[i + 1] = 1 - path[i + 1];
+      }
+    }
+
+    if (gap) {
+      _normalizeX(squashPath);
+
+      squashPath[2] = "C" + squashPath[2];
+      createCustomEase(vars.squashID || id + "-squash", "M" + squashPath.join(","));
+    }
+
+    _normalizeX(path);
+
+    path[2] = "C" + path[2];
+    return createCustomEase(id, "M" + path.join(","));
+  }
+};
+
+export var CustomBounce = /*#__PURE__*/function () {
+  function CustomBounce(id, vars) {
+    this.ease = _create(id, vars);
+  }
+
+  CustomBounce.create = function create(id, vars) {
+    return _create(id, vars);
+  };
+
+  CustomBounce.register = function register(core) {
+    gsap = core;
+
+    _initCore();
+  };
+
+  return CustomBounce;
+}();
+_getGSAP() && gsap.registerPlugin(CustomBounce);
+CustomBounce.version = "3.13.0";
+export { CustomBounce as default };

network-visualization/node_modules/gsap/CustomEase.js

@@ -0,0 +1,373 @@
+/*!
+ * CustomEase 3.13.0
+ * https://gsap.com
+ *
+ * @license Copyright 2008-2025, GreenSock. All rights reserved.
+ * Subject to the terms at https://gsap.com/standard-license
+ * @author: Jack Doyle, jack@greensock.com
+*/
+
+/* eslint-disable */
+import { stringToRawPath, rawPathToString, transformRawPath } from "./utils/paths.js";
+
+var gsap,
+    _coreInitted,
+    _getGSAP = function _getGSAP() {
+  return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+},
+    _initCore = function _initCore() {
+  gsap = _getGSAP();
+
+  if (gsap) {
+    gsap.registerEase("_CE", CustomEase.create);
+    _coreInitted = 1;
+  } else {
+    console.warn("Please gsap.registerPlugin(CustomEase)");
+  }
+},
+    _bigNum = 1e20,
+    _round = function _round(value) {
+  return ~~(value * 1000 + (value < 0 ? -.5 : .5)) / 1000;
+},
+    _bonusValidated = 1,
+    //<name>CustomEase</name>
+_numExp = /[-+=.]*\d+[.e\-+]*\d*[e\-+]*\d*/gi,
+    //finds any numbers, including ones that start with += or -=, negative numbers, and ones in scientific notation like 1e-8.
+_needsParsingExp = /[cLlsSaAhHvVtTqQ]/g,
+    _findMinimum = function _findMinimum(values) {
+  var l = values.length,
+      min = _bigNum,
+      i;
+
+  for (i = 1; i < l; i += 6) {
+    +values[i] < min && (min = +values[i]);
+  }
+
+  return min;
+},
+    //takes all the points and translates/scales them so that the x starts at 0 and ends at 1.
+_normalize = function _normalize(values, height, originY) {
+  if (!originY && originY !== 0) {
+    originY = Math.max(+values[values.length - 1], +values[1]);
+  }
+
+  var tx = +values[0] * -1,
+      ty = -originY,
+      l = values.length,
+      sx = 1 / (+values[l - 2] + tx),
+      sy = -height || (Math.abs(+values[l - 1] - +values[1]) < 0.01 * (+values[l - 2] - +values[0]) ? _findMinimum(values) + ty : +values[l - 1] + ty),
+      i;
+
+  if (sy) {
+    //typically y ends at 1 (so that the end values are reached)
+    sy = 1 / sy;
+  } else {
+    //in case the ease returns to its beginning value, scale everything proportionally
+    sy = -sx;
+  }
+
+  for (i = 0; i < l; i += 2) {
+    values[i] = (+values[i] + tx) * sx;
+    values[i + 1] = (+values[i + 1] + ty) * sy;
+  }
+},
+    //note that this function returns point objects like {x, y} rather than working with segments which are arrays with alternating x, y values as in the similar function in paths.js
+_bezierToPoints = function _bezierToPoints(x1, y1, x2, y2, x3, y3, x4, y4, threshold, points, index) {
+  var x12 = (x1 + x2) / 2,
+      y12 = (y1 + y2) / 2,
+      x23 = (x2 + x3) / 2,
+      y23 = (y2 + y3) / 2,
+      x34 = (x3 + x4) / 2,
+      y34 = (y3 + y4) / 2,
+      x123 = (x12 + x23) / 2,
+      y123 = (y12 + y23) / 2,
+      x234 = (x23 + x34) / 2,
+      y234 = (y23 + y34) / 2,
+      x1234 = (x123 + x234) / 2,
+      y1234 = (y123 + y234) / 2,
+      dx = x4 - x1,
+      dy = y4 - y1,
+      d2 = Math.abs((x2 - x4) * dy - (y2 - y4) * dx),
+      d3 = Math.abs((x3 - x4) * dy - (y3 - y4) * dx),
+      length;
+
+  if (!points) {
+    points = [{
+      x: x1,
+      y: y1
+    }, {
+      x: x4,
+      y: y4
+    }];
+    index = 1;
+  }
+
+  points.splice(index || points.length - 1, 0, {
+    x: x1234,
+    y: y1234
+  });
+
+  if ((d2 + d3) * (d2 + d3) > threshold * (dx * dx + dy * dy)) {
+    length = points.length;
+
+    _bezierToPoints(x1, y1, x12, y12, x123, y123, x1234, y1234, threshold, points, index);
+
+    _bezierToPoints(x1234, y1234, x234, y234, x34, y34, x4, y4, threshold, points, index + 1 + (points.length - length));
+  }
+
+  return points;
+};
+
+export var CustomEase = /*#__PURE__*/function () {
+  function CustomEase(id, data, config) {
+    _coreInitted || _initCore();
+    this.id = id;
+    _bonusValidated && this.setData(data, config);
+  }
+
+  var _proto = CustomEase.prototype;
+
+  _proto.setData = function setData(data, config) {
+    config = config || {};
+    data = data || "0,0,1,1";
+    var values = data.match(_numExp),
+        closest = 1,
+        points = [],
+        lookup = [],
+        precision = config.precision || 1,
+        fast = precision <= 1,
+        l,
+        a1,
+        a2,
+        i,
+        inc,
+        j,
+        point,
+        prevPoint,
+        p;
+    this.data = data;
+
+    if (_needsParsingExp.test(data) || ~data.indexOf("M") && data.indexOf("C") < 0) {
+      values = stringToRawPath(data)[0];
+    }
+
+    l = values.length;
+
+    if (l === 4) {
+      values.unshift(0, 0);
+      values.push(1, 1);
+      l = 8;
+    } else if ((l - 2) % 6) {
+      throw "Invalid CustomEase";
+    }
+
+    if (+values[0] !== 0 || +values[l - 2] !== 1) {
+      _normalize(values, config.height, config.originY);
+    }
+
+    this.segment = values;
+
+    for (i = 2; i < l; i += 6) {
+      a1 = {
+        x: +values[i - 2],
+        y: +values[i - 1]
+      };
+      a2 = {
+        x: +values[i + 4],
+        y: +values[i + 5]
+      };
+      points.push(a1, a2);
+
+      _bezierToPoints(a1.x, a1.y, +values[i], +values[i + 1], +values[i + 2], +values[i + 3], a2.x, a2.y, 1 / (precision * 200000), points, points.length - 1);
+    }
+
+    l = points.length;
+
+    for (i = 0; i < l; i++) {
+      point = points[i];
+      prevPoint = points[i - 1] || point;
+
+      if ((point.x > prevPoint.x || prevPoint.y !== point.y && prevPoint.x === point.x || point === prevPoint) && point.x <= 1) {
+        //if a point goes BACKWARD in time or is a duplicate, just drop it. Also it shouldn't go past 1 on the x axis, as could happen in a string like "M0,0 C0,0 0.12,0.68 0.18,0.788 0.195,0.845 0.308,1 0.32,1 0.403,1.005 0.398,1 0.5,1 0.602,1 0.816,1.005 0.9,1 0.91,1 0.948,0.69 0.962,0.615 1.003,0.376 1,0 1,0".
+        prevPoint.cx = point.x - prevPoint.x; //change in x between this point and the next point (performance optimization)
+
+        prevPoint.cy = point.y - prevPoint.y;
+        prevPoint.n = point;
+        prevPoint.nx = point.x; //next point's x value (performance optimization, making lookups faster in getRatio()). Remember, the lookup will always land on a spot where it's either this point or the very next one (never beyond that)
+
+        if (fast && i > 1 && Math.abs(prevPoint.cy / prevPoint.cx - points[i - 2].cy / points[i - 2].cx) > 2) {
+          //if there's a sudden change in direction, prioritize accuracy over speed. Like a bounce ease - you don't want to risk the sampling chunks landing on each side of the bounce anchor and having it clipped off.
+          fast = 0;
+        }
+
+        if (prevPoint.cx < closest) {
+          if (!prevPoint.cx) {
+            prevPoint.cx = 0.001; //avoids math problems in getRatio() (dividing by zero)
+
+            if (i === l - 1) {
+              //in case the final segment goes vertical RIGHT at the end, make sure we end at the end.
+              prevPoint.x -= 0.001;
+              closest = Math.min(closest, 0.001);
+              fast = 0;
+            }
+          } else {
+            closest = prevPoint.cx;
+          }
+        }
+      } else {
+        points.splice(i--, 1);
+        l--;
+      }
+    }
+
+    l = 1 / closest + 1 | 0;
+    inc = 1 / l;
+    j = 0;
+    point = points[0];
+
+    if (fast) {
+      for (i = 0; i < l; i++) {
+        //for fastest lookups, we just sample along the path at equal x (time) distance. Uses more memory and is slightly less accurate for anchors that don't land on the sampling points, but for the vast majority of eases it's excellent (and fast).
+        p = i * inc;
+
+        if (point.nx < p) {
+          point = points[++j];
+        }
+
+        a1 = point.y + (p - point.x) / point.cx * point.cy;
+        lookup[i] = {
+          x: p,
+          cx: inc,
+          y: a1,
+          cy: 0,
+          nx: 9
+        };
+
+        if (i) {
+          lookup[i - 1].cy = a1 - lookup[i - 1].y;
+        }
+      }
+
+      j = points[points.length - 1];
+      lookup[l - 1].cy = j.y - a1;
+      lookup[l - 1].cx = j.x - lookup[lookup.length - 1].x; //make sure it lands EXACTLY where it should. Otherwise, it might be something like 0.9999999999 instead of 1.
+    } else {
+      //this option is more accurate, ensuring that EVERY anchor is hit perfectly. Clipping across a bounce, for example, would never happen.
+      for (i = 0; i < l; i++) {
+        //build a lookup table based on the smallest distance so that we can instantly find the appropriate point (well, it'll either be that point or the very next one). We'll look up based on the linear progress. So it's it's 0.5 and the lookup table has 100 elements, it'd be like lookup[Math.floor(0.5 * 100)]
+        if (point.nx < i * inc) {
+          point = points[++j];
+        }
+
+        lookup[i] = point;
+      }
+
+      if (j < points.length - 1) {
+        lookup[i - 1] = points[points.length - 2];
+      }
+    } //this._calcEnd = (points[points.length-1].y !== 1 || points[0].y !== 0); //ensures that we don't run into floating point errors. As long as we're starting at 0 and ending at 1, tell GSAP to skip the final calculation and use 0/1 as the factor.
+
+
+    this.ease = function (p) {
+      var point = lookup[p * l | 0] || lookup[l - 1];
+
+      if (point.nx < p) {
+        point = point.n;
+      }
+
+      return point.y + (p - point.x) / point.cx * point.cy;
+    };
+
+    this.ease.custom = this;
+    this.id && gsap && gsap.registerEase(this.id, this.ease);
+    return this;
+  };
+
+  _proto.getSVGData = function getSVGData(config) {
+    return CustomEase.getSVGData(this, config);
+  };
+
+  CustomEase.create = function create(id, data, config) {
+    return new CustomEase(id, data, config).ease;
+  };
+
+  CustomEase.register = function register(core) {
+    gsap = core;
+
+    _initCore();
+  };
+
+  CustomEase.get = function get(id) {
+    return gsap.parseEase(id);
+  };
+
+  CustomEase.getSVGData = function getSVGData(ease, config) {
+    config = config || {};
+    var width = config.width || 100,
+        height = config.height || 100,
+        x = config.x || 0,
+        y = (config.y || 0) + height,
+        e = gsap.utils.toArray(config.path)[0],
+        a,
+        slope,
+        i,
+        inc,
+        tx,
+        ty,
+        precision,
+        threshold,
+        prevX,
+        prevY;
+
+    if (config.invert) {
+      height = -height;
+      y = 0;
+    }
+
+    if (typeof ease === "string") {
+      ease = gsap.parseEase(ease);
+    }
+
+    if (ease.custom) {
+      ease = ease.custom;
+    }
+
+    if (ease instanceof CustomEase) {
+      a = rawPathToString(transformRawPath([ease.segment], width, 0, 0, -height, x, y));
+    } else {
+      a = [x, y];
+      precision = Math.max(5, (config.precision || 1) * 200);
+      inc = 1 / precision;
+      precision += 2;
+      threshold = 5 / precision;
+      prevX = _round(x + inc * width);
+      prevY = _round(y + ease(inc) * -height);
+      slope = (prevY - y) / (prevX - x);
+
+      for (i = 2; i < precision; i++) {
+        tx = _round(x + i * inc * width);
+        ty = _round(y + ease(i * inc) * -height);
+
+        if (Math.abs((ty - prevY) / (tx - prevX) - slope) > threshold || i === precision - 1) {
+          //only add points when the slope changes beyond the threshold
+          a.push(prevX, prevY);
+          slope = (ty - prevY) / (tx - prevX);
+        }
+
+        prevX = tx;
+        prevY = ty;
+      }
+
+      a = "M" + a.join(",");
+    }
+
+    e && e.setAttribute("d", a);
+    return a;
+  };
+
+  return CustomEase;
+}();
+CustomEase.version = "3.13.0";
+CustomEase.headless = true;
+_getGSAP() && gsap.registerPlugin(CustomEase);
+export { CustomEase as default };

network-visualization/node_modules/gsap/CustomWiggle.js

@@ -0,0 +1,161 @@
+/*!
+ * CustomWiggle 3.13.0
+ * https://gsap.com
+ *
+ * @license Copyright 2008-2025, GreenSock. All rights reserved.
+ * Subject to the terms at https://gsap.com/standard-license
+ * @author: Jack Doyle, jack@greensock.com
+*/
+
+/* eslint-disable */
+var gsap,
+    _coreInitted,
+    createCustomEase,
+    _getGSAP = function _getGSAP() {
+  return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+},
+    _eases = {
+  easeOut: "M0,1,C0.7,1,0.6,0,1,0",
+  easeInOut: "M0,0,C0.1,0,0.24,1,0.444,1,0.644,1,0.6,0,1,0",
+  anticipate: "M0,0,C0,0.222,0.024,0.386,0,0.4,0.18,0.455,0.65,0.646,0.7,0.67,0.9,0.76,1,0.846,1,1",
+  uniform: "M0,0,C0,0.95,0,1,0,1,0,1,1,1,1,1,1,1,1,0,1,0"
+},
+    _linearEase = function _linearEase(p) {
+  return p;
+},
+    _initCore = function _initCore(required) {
+  if (!_coreInitted) {
+    gsap = _getGSAP();
+    createCustomEase = gsap && gsap.parseEase("_CE");
+
+    if (createCustomEase) {
+      for (var p in _eases) {
+        _eases[p] = createCustomEase("", _eases[p]);
+      }
+
+      _coreInitted = 1;
+
+      _create("wiggle").config = function (vars) {
+        return typeof vars === "object" ? _create("", vars) : _create("wiggle(" + vars + ")", {
+          wiggles: +vars
+        });
+      };
+    } else {
+      required && console.warn("Please gsap.registerPlugin(CustomEase, CustomWiggle)");
+    }
+  }
+},
+    _parseEase = function _parseEase(ease, invertNonCustomEases) {
+  if (typeof ease !== "function") {
+    ease = gsap.parseEase(ease) || createCustomEase("", ease);
+  }
+
+  return ease.custom || !invertNonCustomEases ? ease : function (p) {
+    return 1 - ease(p);
+  };
+},
+    _bonusValidated = 1,
+    //<name>CustomWiggle</name>
+_create = function _create(id, vars) {
+  if (!_coreInitted) {
+    _initCore(1);
+  }
+
+  vars = vars || {};
+  var wiggles = (vars.wiggles || 10) | 0,
+      inc = 1 / wiggles,
+      x = inc / 2,
+      anticipate = vars.type === "anticipate",
+      yEase = _eases[vars.type] || _eases.easeOut,
+      xEase = _linearEase,
+      rnd = 1000,
+      nextX,
+      nextY,
+      angle,
+      handleX,
+      handleY,
+      easedX,
+      y,
+      path,
+      i;
+
+  if (_bonusValidated) {
+    if (anticipate) {
+      //the anticipate ease is actually applied on the x-axis (timing) and uses easeOut for amplitude.
+      xEase = yEase;
+      yEase = _eases.easeOut;
+    }
+
+    if (vars.timingEase) {
+      xEase = _parseEase(vars.timingEase);
+    }
+
+    if (vars.amplitudeEase) {
+      yEase = _parseEase(vars.amplitudeEase, true);
+    }
+
+    easedX = xEase(x);
+    y = anticipate ? -yEase(x) : yEase(x);
+    path = [0, 0, easedX / 4, 0, easedX / 2, y, easedX, y];
+
+    if (vars.type === "random") {
+      //if we just select random values on the y-axis and plug them into the "normal" algorithm, since the control points are always straight horizontal, it creates a bit of a slowdown at each anchor which just didn't seem as desirable, so we switched to an algorithm that bends the control points to be more in line with their context.
+      path.length = 4;
+      nextX = xEase(inc);
+      nextY = Math.random() * 2 - 1;
+
+      for (i = 2; i < wiggles; i++) {
+        x = nextX;
+        y = nextY;
+        nextX = xEase(inc * i);
+        nextY = Math.random() * 2 - 1;
+        angle = Math.atan2(nextY - path[path.length - 3], nextX - path[path.length - 4]);
+        handleX = Math.cos(angle) * inc;
+        handleY = Math.sin(angle) * inc;
+        path.push(x - handleX, y - handleY, x, y, x + handleX, y + handleY);
+      }
+
+      path.push(nextX, 0, 1, 0);
+    } else {
+      for (i = 1; i < wiggles; i++) {
+        path.push(xEase(x + inc / 2), y);
+        x += inc;
+        y = (y > 0 ? -1 : 1) * yEase(i * inc);
+        easedX = xEase(x);
+        path.push(xEase(x - inc / 2), y, easedX, y);
+      }
+
+      path.push(xEase(x + inc / 4), y, xEase(x + inc / 4), 0, 1, 0);
+    }
+
+    i = path.length;
+
+    while (--i > -1) {
+      path[i] = ~~(path[i] * rnd) / rnd; //round values to avoid odd strings for super tiny values
+    }
+
+    path[2] = "C" + path[2];
+    return createCustomEase(id, "M" + path.join(","));
+  }
+};
+
+export var CustomWiggle = /*#__PURE__*/function () {
+  function CustomWiggle(id, vars) {
+    this.ease = _create(id, vars);
+  }
+
+  CustomWiggle.create = function create(id, vars) {
+    return _create(id, vars);
+  };
+
+  CustomWiggle.register = function register(core) {
+    gsap = core;
+
+    _initCore();
+  };
+
+  return CustomWiggle;
+}();
+_getGSAP() && gsap.registerPlugin(CustomWiggle);
+CustomWiggle.version = "3.13.0";
+export { CustomWiggle as default };

network-visualization/node_modules/gsap/DrawSVGPlugin.js

@@ -0,0 +1,314 @@
+/*!
+ * DrawSVGPlugin 3.13.0
+ * https://gsap.com
+ *
+ * @license Copyright 2008-2025, GreenSock. All rights reserved.
+ * Subject to the terms at https://gsap.com/standard-license
+ * @author: Jack Doyle, jack@greensock.com
+*/
+
+/* eslint-disable */
+var gsap,
+    _toArray,
+    _doc,
+    _win,
+    _isEdge,
+    _coreInitted,
+    _warned,
+    _getStyleSaver,
+    _reverting,
+    _windowExists = function _windowExists() {
+  return typeof window !== "undefined";
+},
+    _getGSAP = function _getGSAP() {
+  return gsap || _windowExists() && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+},
+    _numExp = /[-+=\.]*\d+[\.e\-\+]*\d*[e\-\+]*\d*/gi,
+    //finds any numbers, including ones that start with += or -=, negative numbers, and ones in scientific notation like 1e-8.
+_types = {
+  rect: ["width", "height"],
+  circle: ["r", "r"],
+  ellipse: ["rx", "ry"],
+  line: ["x2", "y2"]
+},
+    _round = function _round(value) {
+  return Math.round(value * 10000) / 10000;
+},
+    _parseNum = function _parseNum(value) {
+  return parseFloat(value) || 0;
+},
+    _parseSingleVal = function _parseSingleVal(value, length) {
+  var num = _parseNum(value);
+
+  return ~value.indexOf("%") ? num / 100 * length : num;
+},
+    _getAttributeAsNumber = function _getAttributeAsNumber(target, attr) {
+  return _parseNum(target.getAttribute(attr));
+},
+    _sqrt = Math.sqrt,
+    _getDistance = function _getDistance(x1, y1, x2, y2, scaleX, scaleY) {
+  return _sqrt(Math.pow((_parseNum(x2) - _parseNum(x1)) * scaleX, 2) + Math.pow((_parseNum(y2) - _parseNum(y1)) * scaleY, 2));
+},
+    _warn = function _warn(message) {
+  return console.warn(message);
+},
+    _hasNonScalingStroke = function _hasNonScalingStroke(target) {
+  return target.getAttribute("vector-effect") === "non-scaling-stroke";
+},
+    _bonusValidated = 1,
+    //<name>DrawSVGPlugin</name>
+//accepts values like "100%" or "20% 80%" or "20 50" and parses it into an absolute start and end position on the line/stroke based on its length. Returns an an array with the start and end values, like [0, 243]
+_parse = function _parse(value, length, defaultStart) {
+  var i = value.indexOf(" "),
+      s,
+      e;
+
+  if (i < 0) {
+    s = defaultStart !== undefined ? defaultStart + "" : value;
+    e = value;
+  } else {
+    s = value.substr(0, i);
+    e = value.substr(i + 1);
+  }
+
+  s = _parseSingleVal(s, length);
+  e = _parseSingleVal(e, length);
+  return s > e ? [e, s] : [s, e];
+},
+    _getLength = function _getLength(target) {
+  target = _toArray(target)[0];
+
+  if (!target) {
+    return 0;
+  }
+
+  var type = target.tagName.toLowerCase(),
+      style = target.style,
+      scaleX = 1,
+      scaleY = 1,
+      length,
+      bbox,
+      points,
+      prevPoint,
+      i,
+      rx,
+      ry;
+
+  if (_hasNonScalingStroke(target)) {
+    //non-scaling-stroke basically scales the shape and then strokes it at the screen-level (after transforms), thus we need to adjust the length accordingly.
+    scaleY = target.getScreenCTM();
+    scaleX = _sqrt(scaleY.a * scaleY.a + scaleY.b * scaleY.b);
+    scaleY = _sqrt(scaleY.d * scaleY.d + scaleY.c * scaleY.c);
+  }
+
+  try {
+    //IE bug: calling <path>.getTotalLength() locks the repaint area of the stroke to whatever its current dimensions are on that frame/tick. To work around that, we must call getBBox() to force IE to recalculate things.
+    bbox = target.getBBox(); //solely for fixing bug in IE - we don't actually use the bbox.
+  } catch (e) {
+    //firefox has a bug that throws an error if the element isn't visible.
+    _warn("Some browsers won't measure invisible elements (like display:none or masks inside defs).");
+  }
+
+  var _ref = bbox || {
+    x: 0,
+    y: 0,
+    width: 0,
+    height: 0
+  },
+      x = _ref.x,
+      y = _ref.y,
+      width = _ref.width,
+      height = _ref.height;
+
+  if ((!bbox || !width && !height) && _types[type]) {
+    //if the element isn't visible, try to discern width/height using its attributes.
+    width = _getAttributeAsNumber(target, _types[type][0]);
+    height = _getAttributeAsNumber(target, _types[type][1]);
+
+    if (type !== "rect" && type !== "line") {
+      //double the radius for circles and ellipses
+      width *= 2;
+      height *= 2;
+    }
+
+    if (type === "line") {
+      x = _getAttributeAsNumber(target, "x1");
+      y = _getAttributeAsNumber(target, "y1");
+      width = Math.abs(width - x);
+      height = Math.abs(height - y);
+    }
+  }
+
+  if (type === "path") {
+    prevPoint = style.strokeDasharray;
+    style.strokeDasharray = "none";
+    length = target.getTotalLength() || 0;
+    _round(scaleX) !== _round(scaleY) && !_warned && (_warned = 1) && _warn("Warning: <path> length cannot be measured when vector-effect is non-scaling-stroke and the element isn't proportionally scaled.");
+    length *= (scaleX + scaleY) / 2;
+    style.strokeDasharray = prevPoint;
+  } else if (type === "rect") {
+    length = width * 2 * scaleX + height * 2 * scaleY;
+  } else if (type === "line") {
+    length = _getDistance(x, y, x + width, y + height, scaleX, scaleY);
+  } else if (type === "polyline" || type === "polygon") {
+    points = target.getAttribute("points").match(_numExp) || [];
+    type === "polygon" && points.push(points[0], points[1]);
+    length = 0;
+
+    for (i = 2; i < points.length; i += 2) {
+      length += _getDistance(points[i - 2], points[i - 1], points[i], points[i + 1], scaleX, scaleY) || 0;
+    }
+  } else if (type === "circle" || type === "ellipse") {
+    rx = width / 2 * scaleX;
+    ry = height / 2 * scaleY;
+    length = Math.PI * (3 * (rx + ry) - _sqrt((3 * rx + ry) * (rx + 3 * ry)));
+  }
+
+  return length || 0;
+},
+    _getPosition = function _getPosition(target, length) {
+  target = _toArray(target)[0];
+
+  if (!target) {
+    return [0, 0];
+  }
+
+  length || (length = _getLength(target) + 1);
+
+  var cs = _win.getComputedStyle(target),
+      dash = cs.strokeDasharray || "",
+      offset = _parseNum(cs.strokeDashoffset),
+      i = dash.indexOf(",");
+
+  i < 0 && (i = dash.indexOf(" "));
+  dash = i < 0 ? length : _parseNum(dash.substr(0, i));
+  dash > length && (dash = length);
+  return [-offset || 0, dash - offset || 0];
+},
+    _initCore = function _initCore() {
+  if (_windowExists()) {
+    _doc = document;
+    _win = window;
+    _coreInitted = gsap = _getGSAP();
+    _toArray = gsap.utils.toArray;
+    _getStyleSaver = gsap.core.getStyleSaver;
+
+    _reverting = gsap.core.reverting || function () {};
+
+    _isEdge = ((_win.navigator || {}).userAgent || "").indexOf("Edge") !== -1; //Microsoft Edge has a bug that causes it not to redraw the path correctly if the stroke-linecap is anything other than "butt" (like "round") and it doesn't match the stroke-linejoin. A way to trigger it is to change the stroke-miterlimit, so we'll only do that if/when we have to (to maximize performance)
+  }
+};
+
+export var DrawSVGPlugin = {
+  version: "3.13.0",
+  name: "drawSVG",
+  register: function register(core) {
+    gsap = core;
+
+    _initCore();
+  },
+  init: function init(target, value, tween, index, targets) {
+    if (!target.getBBox) {
+      return false;
+    }
+
+    _coreInitted || _initCore();
+
+    var length = _getLength(target),
+        start,
+        end,
+        cs;
+
+    this.styles = _getStyleSaver && _getStyleSaver(target, "strokeDashoffset,strokeDasharray,strokeMiterlimit");
+    this.tween = tween;
+    this._style = target.style;
+    this._target = target;
+
+    if (value + "" === "true") {
+      value = "0 100%";
+    } else if (!value) {
+      value = "0 0";
+    } else if ((value + "").indexOf(" ") === -1) {
+      value = "0 " + value;
+    }
+
+    start = _getPosition(target, length);
+    end = _parse(value, length, start[0]);
+    this._length = _round(length);
+    this._dash = _round(start[1] - start[0]); //some browsers render artifacts if dash is 0, so we use a very small number in that case.
+
+    this._offset = _round(-start[0]);
+    this._dashPT = this.add(this, "_dash", this._dash, _round(end[1] - end[0]), 0, 0, 0, 0, 0, 1);
+    this._offsetPT = this.add(this, "_offset", this._offset, _round(-end[0]), 0, 0, 0, 0, 0, 1);
+
+    if (_isEdge) {
+      //to work around a bug in Microsoft Edge, animate the stroke-miterlimit by 0.0001 just to trigger the repaint (unnecessary if it's "round" and stroke-linejoin is also "round"). Imperceptible, relatively high-performance, and effective. Another option was to set the "d" <path> attribute to its current value on every tick, but that seems like it'd be much less performant.
+      cs = _win.getComputedStyle(target);
+
+      if (cs.strokeLinecap !== cs.strokeLinejoin) {
+        end = _parseNum(cs.strokeMiterlimit);
+        this.add(target.style, "strokeMiterlimit", end, end + 0.01);
+      }
+    }
+
+    this._live = _hasNonScalingStroke(target) || ~(value + "").indexOf("live");
+    this._nowrap = ~(value + "").indexOf("nowrap");
+
+    this._props.push("drawSVG");
+
+    return _bonusValidated;
+  },
+  render: function render(ratio, data) {
+    if (data.tween._time || !_reverting()) {
+      var pt = data._pt,
+          style = data._style,
+          length,
+          lengthRatio,
+          dash,
+          offset;
+
+      if (pt) {
+        //when the element has vector-effect="non-scaling-stroke" and the SVG is resized (like on a window resize), it actually changes the length of the stroke! So we must sense that and make the proper adjustments.
+        if (data._live) {
+          length = _getLength(data._target);
+
+          if (length !== data._length) {
+            lengthRatio = length / data._length;
+            data._length = length;
+
+            if (data._offsetPT) {
+              data._offsetPT.s *= lengthRatio;
+              data._offsetPT.c *= lengthRatio;
+            }
+
+            if (data._dashPT) {
+              data._dashPT.s *= lengthRatio;
+              data._dashPT.c *= lengthRatio;
+            } else {
+              data._dash *= lengthRatio;
+            }
+          }
+        }
+
+        while (pt) {
+          pt.r(ratio, pt.d);
+          pt = pt._next;
+        }
+
+        dash = data._dash || ratio && ratio !== 1 && 0.0001 || 0; // only let it be zero if it's at the start or end of the tween.
+
+        length = data._length - dash + 0.1;
+        offset = data._offset;
+        dash && offset && dash + Math.abs(offset % data._length) > data._length - 0.05 && (offset += offset < 0 ? 0.005 : -0.005) && (length += 0.005);
+        style.strokeDashoffset = dash ? offset : offset + 0.001;
+        style.strokeDasharray = length < 0.1 ? "none" : dash ? dash + "px," + (data._nowrap ? 999999 : length) + "px" : "0px, 999999px";
+      }
+    } else {
+      data.styles.revert();
+    }
+  },
+  getLength: _getLength,
+  getPosition: _getPosition
+};
+_getGSAP() && gsap.registerPlugin(DrawSVGPlugin);
+export { DrawSVGPlugin as default };

network-visualization/node_modules/gsap/EasePack.js

@@ -0,0 +1,211 @@
+/*!
+ * EasePack 3.13.0
+ * https://gsap.com
+ *
+ * @license Copyright 2008-2025, GreenSock. All rights reserved.
+ * Subject to the terms at https://gsap.com/standard-license
+ * @author: Jack Doyle, jack@greensock.com
+*/
+
+/* eslint-disable */
+var gsap,
+    _coreInitted,
+    _registerEase,
+    _getGSAP = function _getGSAP() {
+  return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+},
+    _boolean = function _boolean(value, defaultValue) {
+  return !!(typeof value === "undefined" ? defaultValue : value && !~(value + "").indexOf("false"));
+},
+    _initCore = function _initCore(core) {
+  gsap = core || _getGSAP();
+
+  if (gsap) {
+    _registerEase = gsap.registerEase; //add weighted ease capabilities to standard eases so users can do "power2.inOut(0.8)" for example to push everything toward the "out", or (-0.8) to push it toward the "in" (0 is neutral)
+
+    var eases = gsap.parseEase(),
+        createConfig = function createConfig(ease) {
+      return function (ratio) {
+        var y = 0.5 + ratio / 2;
+
+        ease.config = function (p) {
+          return ease(2 * (1 - p) * p * y + p * p);
+        };
+      };
+    },
+        p;
+
+    for (p in eases) {
+      if (!eases[p].config) {
+        createConfig(eases[p]);
+      }
+    }
+
+    _registerEase("slow", SlowMo);
+
+    _registerEase("expoScale", ExpoScaleEase);
+
+    _registerEase("rough", RoughEase);
+
+    for (p in EasePack) {
+      p !== "version" && gsap.core.globals(p, EasePack[p]);
+    }
+
+    _coreInitted = 1;
+  }
+},
+    _createSlowMo = function _createSlowMo(linearRatio, power, yoyoMode) {
+  linearRatio = Math.min(1, linearRatio || 0.7);
+
+  var pow = linearRatio < 1 ? power || power === 0 ? power : 0.7 : 0,
+      p1 = (1 - linearRatio) / 2,
+      p3 = p1 + linearRatio,
+      calcEnd = _boolean(yoyoMode);
+
+  return function (p) {
+    var r = p + (0.5 - p) * pow;
+    return p < p1 ? calcEnd ? 1 - (p = 1 - p / p1) * p : r - (p = 1 - p / p1) * p * p * p * r : p > p3 ? calcEnd ? p === 1 ? 0 : 1 - (p = (p - p3) / p1) * p : r + (p - r) * (p = (p - p3) / p1) * p * p * p : calcEnd ? 1 : r;
+  };
+},
+    _createExpoScale = function _createExpoScale(start, end, ease) {
+  var p1 = Math.log(end / start),
+      p2 = end - start;
+  ease && (ease = gsap.parseEase(ease));
+  return function (p) {
+    return (start * Math.exp(p1 * (ease ? ease(p) : p)) - start) / p2;
+  };
+},
+    EasePoint = function EasePoint(time, value, next) {
+  this.t = time;
+  this.v = value;
+
+  if (next) {
+    this.next = next;
+    next.prev = this;
+    this.c = next.v - value;
+    this.gap = next.t - time;
+  }
+},
+    _createRoughEase = function _createRoughEase(vars) {
+  if (typeof vars !== "object") {
+    //users may pass in via a string, like "rough(30)"
+    vars = {
+      points: +vars || 20
+    };
+  }
+
+  var taper = vars.taper || "none",
+      a = [],
+      cnt = 0,
+      points = (+vars.points || 20) | 0,
+      i = points,
+      randomize = _boolean(vars.randomize, true),
+      clamp = _boolean(vars.clamp),
+      template = gsap ? gsap.parseEase(vars.template) : 0,
+      strength = (+vars.strength || 1) * 0.4,
+      x,
+      y,
+      bump,
+      invX,
+      obj,
+      pnt,
+      recent;
+
+  while (--i > -1) {
+    x = randomize ? Math.random() : 1 / points * i;
+    y = template ? template(x) : x;
+
+    if (taper === "none") {
+      bump = strength;
+    } else if (taper === "out") {
+      invX = 1 - x;
+      bump = invX * invX * strength;
+    } else if (taper === "in") {
+      bump = x * x * strength;
+    } else if (x < 0.5) {
+      //"both" (start)
+      invX = x * 2;
+      bump = invX * invX * 0.5 * strength;
+    } else {
+      //"both" (end)
+      invX = (1 - x) * 2;
+      bump = invX * invX * 0.5 * strength;
+    }
+
+    if (randomize) {
+      y += Math.random() * bump - bump * 0.5;
+    } else if (i % 2) {
+      y += bump * 0.5;
+    } else {
+      y -= bump * 0.5;
+    }
+
+    if (clamp) {
+      if (y > 1) {
+        y = 1;
+      } else if (y < 0) {
+        y = 0;
+      }
+    }
+
+    a[cnt++] = {
+      x: x,
+      y: y
+    };
+  }
+
+  a.sort(function (a, b) {
+    return a.x - b.x;
+  });
+  pnt = new EasePoint(1, 1, null);
+  i = points;
+
+  while (i--) {
+    obj = a[i];
+    pnt = new EasePoint(obj.x, obj.y, pnt);
+  }
+
+  recent = new EasePoint(0, 0, pnt.t ? pnt : pnt.next);
+  return function (p) {
+    var pnt = recent;
+
+    if (p > pnt.t) {
+      while (pnt.next && p >= pnt.t) {
+        pnt = pnt.next;
+      }
+
+      pnt = pnt.prev;
+    } else {
+      while (pnt.prev && p <= pnt.t) {
+        pnt = pnt.prev;
+      }
+    }
+
+    recent = pnt;
+    return pnt.v + (p - pnt.t) / pnt.gap * pnt.c;
+  };
+};
+
+export var SlowMo = _createSlowMo(0.7);
+SlowMo.ease = SlowMo; //for backward compatibility
+
+SlowMo.config = _createSlowMo;
+export var ExpoScaleEase = _createExpoScale(1, 2);
+ExpoScaleEase.config = _createExpoScale;
+export var RoughEase = _createRoughEase();
+RoughEase.ease = RoughEase; //for backward compatibility
+
+RoughEase.config = _createRoughEase;
+export var EasePack = {
+  SlowMo: SlowMo,
+  RoughEase: RoughEase,
+  ExpoScaleEase: ExpoScaleEase
+};
+
+for (var p in EasePack) {
+  EasePack[p].register = _initCore;
+  EasePack[p].version = "3.13.0";
+}
+
+_getGSAP() && gsap.registerPlugin(SlowMo);
+export { EasePack as default };

network-visualization/node_modules/gsap/EaselPlugin.js

@@ -0,0 +1,340 @@
+/*!
+ * EaselPlugin 3.13.0
+ * https://gsap.com
+ *
+ * @license Copyright 2008-2025, GreenSock. All rights reserved.
+ * Subject to the terms at https://gsap.com/standard-license
+ * @author: Jack Doyle, jack@greensock.com
+*/
+
+/* eslint-disable */
+var gsap,
+    _coreInitted,
+    _win,
+    _createJS,
+    _ColorFilter,
+    _ColorMatrixFilter,
+    _colorProps = "redMultiplier,greenMultiplier,blueMultiplier,alphaMultiplier,redOffset,greenOffset,blueOffset,alphaOffset".split(","),
+    _windowExists = function _windowExists() {
+  return typeof window !== "undefined";
+},
+    _getGSAP = function _getGSAP() {
+  return gsap || _windowExists() && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+},
+    _getCreateJS = function _getCreateJS() {
+  return _createJS || _win && _win.createjs || _win || {};
+},
+    _warn = function _warn(message) {
+  return console.warn(message);
+},
+    _cache = function _cache(target) {
+  var b = target.getBounds && target.getBounds();
+
+  if (!b) {
+    b = target.nominalBounds || {
+      x: 0,
+      y: 0,
+      width: 100,
+      height: 100
+    };
+    target.setBounds && target.setBounds(b.x, b.y, b.width, b.height);
+  }
+
+  target.cache && target.cache(b.x, b.y, b.width, b.height);
+
+  _warn("EaselPlugin: for filters to display in EaselJS, you must call the object's cache() method first. GSAP attempted to use the target's getBounds() for the cache but that may not be completely accurate. " + target);
+},
+    _parseColorFilter = function _parseColorFilter(target, v, plugin) {
+  if (!_ColorFilter) {
+    _ColorFilter = _getCreateJS().ColorFilter;
+
+    if (!_ColorFilter) {
+      _warn("EaselPlugin error: The EaselJS ColorFilter JavaScript file wasn't loaded.");
+    }
+  }
+
+  var filters = target.filters || [],
+      i = filters.length,
+      c,
+      s,
+      e,
+      a,
+      p,
+      pt;
+
+  while (i--) {
+    if (filters[i] instanceof _ColorFilter) {
+      s = filters[i];
+      break;
+    }
+  }
+
+  if (!s) {
+    s = new _ColorFilter();
+    filters.push(s);
+    target.filters = filters;
+  }
+
+  e = s.clone();
+
+  if (v.tint != null) {
+    c = gsap.utils.splitColor(v.tint);
+    a = v.tintAmount != null ? +v.tintAmount : 1;
+    e.redOffset = +c[0] * a;
+    e.greenOffset = +c[1] * a;
+    e.blueOffset = +c[2] * a;
+    e.redMultiplier = e.greenMultiplier = e.blueMultiplier = 1 - a;
+  } else {
+    for (p in v) {
+      if (p !== "exposure") if (p !== "brightness") {
+        e[p] = +v[p];
+      }
+    }
+  }
+
+  if (v.exposure != null) {
+    e.redOffset = e.greenOffset = e.blueOffset = 255 * (+v.exposure - 1);
+    e.redMultiplier = e.greenMultiplier = e.blueMultiplier = 1;
+  } else if (v.brightness != null) {
+    a = +v.brightness - 1;
+    e.redOffset = e.greenOffset = e.blueOffset = a > 0 ? a * 255 : 0;
+    e.redMultiplier = e.greenMultiplier = e.blueMultiplier = 1 - Math.abs(a);
+  }
+
+  i = 8;
+
+  while (i--) {
+    p = _colorProps[i];
+
+    if (s[p] !== e[p]) {
+      pt = plugin.add(s, p, s[p], e[p], 0, 0, 0, 0, 0, 1);
+
+      if (pt) {
+        pt.op = "easel_colorFilter";
+      }
+    }
+  }
+
+  plugin._props.push("easel_colorFilter");
+
+  if (!target.cacheID) {
+    _cache(target);
+  }
+},
+    _idMatrix = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0],
+    _lumR = 0.212671,
+    _lumG = 0.715160,
+    _lumB = 0.072169,
+    _applyMatrix = function _applyMatrix(m, m2) {
+  if (!(m instanceof Array) || !(m2 instanceof Array)) {
+    return m2;
+  }
+
+  var temp = [],
+      i = 0,
+      z = 0,
+      y,
+      x;
+
+  for (y = 0; y < 4; y++) {
+    for (x = 0; x < 5; x++) {
+      z = x === 4 ? m[i + 4] : 0;
+      temp[i + x] = m[i] * m2[x] + m[i + 1] * m2[x + 5] + m[i + 2] * m2[x + 10] + m[i + 3] * m2[x + 15] + z;
+    }
+
+    i += 5;
+  }
+
+  return temp;
+},
+    _setSaturation = function _setSaturation(m, n) {
+  if (isNaN(n)) {
+    return m;
+  }
+
+  var inv = 1 - n,
+      r = inv * _lumR,
+      g = inv * _lumG,
+      b = inv * _lumB;
+  return _applyMatrix([r + n, g, b, 0, 0, r, g + n, b, 0, 0, r, g, b + n, 0, 0, 0, 0, 0, 1, 0], m);
+},
+    _colorize = function _colorize(m, color, amount) {
+  if (isNaN(amount)) {
+    amount = 1;
+  }
+
+  var c = gsap.utils.splitColor(color),
+      r = c[0] / 255,
+      g = c[1] / 255,
+      b = c[2] / 255,
+      inv = 1 - amount;
+  return _applyMatrix([inv + amount * r * _lumR, amount * r * _lumG, amount * r * _lumB, 0, 0, amount * g * _lumR, inv + amount * g * _lumG, amount * g * _lumB, 0, 0, amount * b * _lumR, amount * b * _lumG, inv + amount * b * _lumB, 0, 0, 0, 0, 0, 1, 0], m);
+},
+    _setHue = function _setHue(m, n) {
+  if (isNaN(n)) {
+    return m;
+  }
+
+  n *= Math.PI / 180;
+  var c = Math.cos(n),
+      s = Math.sin(n);
+  return _applyMatrix([_lumR + c * (1 - _lumR) + s * -_lumR, _lumG + c * -_lumG + s * -_lumG, _lumB + c * -_lumB + s * (1 - _lumB), 0, 0, _lumR + c * -_lumR + s * 0.143, _lumG + c * (1 - _lumG) + s * 0.14, _lumB + c * -_lumB + s * -0.283, 0, 0, _lumR + c * -_lumR + s * -(1 - _lumR), _lumG + c * -_lumG + s * _lumG, _lumB + c * (1 - _lumB) + s * _lumB, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1], m);
+},
+    _setContrast = function _setContrast(m, n) {
+  if (isNaN(n)) {
+    return m;
+  }
+
+  n += 0.01;
+  return _applyMatrix([n, 0, 0, 0, 128 * (1 - n), 0, n, 0, 0, 128 * (1 - n), 0, 0, n, 0, 128 * (1 - n), 0, 0, 0, 1, 0], m);
+},
+    _parseColorMatrixFilter = function _parseColorMatrixFilter(target, v, plugin) {
+  if (!_ColorMatrixFilter) {
+    _ColorMatrixFilter = _getCreateJS().ColorMatrixFilter;
+
+    if (!_ColorMatrixFilter) {
+      _warn("EaselPlugin: The EaselJS ColorMatrixFilter JavaScript file wasn't loaded.");
+    }
+  }
+
+  var filters = target.filters || [],
+      i = filters.length,
+      matrix,
+      startMatrix,
+      s,
+      pg;
+
+  while (--i > -1) {
+    if (filters[i] instanceof _ColorMatrixFilter) {
+      s = filters[i];
+      break;
+    }
+  }
+
+  if (!s) {
+    s = new _ColorMatrixFilter(_idMatrix.slice());
+    filters.push(s);
+    target.filters = filters;
+  }
+
+  startMatrix = s.matrix;
+  matrix = _idMatrix.slice();
+
+  if (v.colorize != null) {
+    matrix = _colorize(matrix, v.colorize, Number(v.colorizeAmount));
+  }
+
+  if (v.contrast != null) {
+    matrix = _setContrast(matrix, Number(v.contrast));
+  }
+
+  if (v.hue != null) {
+    matrix = _setHue(matrix, Number(v.hue));
+  }
+
+  if (v.saturation != null) {
+    matrix = _setSaturation(matrix, Number(v.saturation));
+  }
+
+  i = matrix.length;
+
+  while (--i > -1) {
+    if (matrix[i] !== startMatrix[i]) {
+      pg = plugin.add(startMatrix, i, startMatrix[i], matrix[i], 0, 0, 0, 0, 0, 1);
+
+      if (pg) {
+        pg.op = "easel_colorMatrixFilter";
+      }
+    }
+  }
+
+  plugin._props.push("easel_colorMatrixFilter");
+
+  if (!target.cacheID) {
+    _cache();
+  }
+
+  plugin._matrix = startMatrix;
+},
+    _initCore = function _initCore(core) {
+  gsap = core || _getGSAP();
+
+  if (_windowExists()) {
+    _win = window;
+  }
+
+  if (gsap) {
+    _coreInitted = 1;
+  }
+};
+
+export var EaselPlugin = {
+  version: "3.13.0",
+  name: "easel",
+  init: function init(target, value, tween, index, targets) {
+    if (!_coreInitted) {
+      _initCore();
+
+      if (!gsap) {
+        _warn("Please gsap.registerPlugin(EaselPlugin)");
+      }
+    }
+
+    this.target = target;
+    var p, pt, tint, colorMatrix, end, labels, i;
+
+    for (p in value) {
+      end = value[p];
+
+      if (p === "colorFilter" || p === "tint" || p === "tintAmount" || p === "exposure" || p === "brightness") {
+        if (!tint) {
+          _parseColorFilter(target, value.colorFilter || value, this);
+
+          tint = true;
+        }
+      } else if (p === "saturation" || p === "contrast" || p === "hue" || p === "colorize" || p === "colorizeAmount") {
+        if (!colorMatrix) {
+          _parseColorMatrixFilter(target, value.colorMatrixFilter || value, this);
+
+          colorMatrix = true;
+        }
+      } else if (p === "frame") {
+        if (typeof end === "string" && end.charAt(1) !== "=" && (labels = target.labels)) {
+          for (i = 0; i < labels.length; i++) {
+            if (labels[i].label === end) {
+              end = labels[i].position;
+            }
+          }
+        }
+
+        pt = this.add(target, "gotoAndStop", target.currentFrame, end, index, targets, Math.round, 0, 0, 1);
+
+        if (pt) {
+          pt.op = p;
+        }
+      } else if (target[p] != null) {
+        this.add(target, p, "get", end);
+      }
+    }
+  },
+  render: function render(ratio, data) {
+    var pt = data._pt;
+
+    while (pt) {
+      pt.r(ratio, pt.d);
+      pt = pt._next;
+    }
+
+    if (data.target.cacheID) {
+      data.target.updateCache();
+    }
+  },
+  register: _initCore
+};
+
+EaselPlugin.registerCreateJS = function (createjs) {
+  _createJS = createjs;
+};
+
+_getGSAP() && gsap.registerPlugin(EaselPlugin);
+export { EaselPlugin as default };

network-visualization/node_modules/gsap/InertiaPlugin.js

@@ -0,0 +1,478 @@
+/*!
+ * InertiaPlugin 3.13.0
+ * https://gsap.com
+ *
+ * @license Copyright 2008-2025, GreenSock. All rights reserved.
+ * Subject to the terms at https://gsap.com/standard-license
+ * @author: Jack Doyle, jack@greensock.com
+*/
+
+/* eslint-disable */
+import { VelocityTracker } from "./utils/VelocityTracker.js";
+
+var gsap,
+    _coreInitted,
+    _parseEase,
+    _toArray,
+    _power3,
+    _config,
+    _getUnit,
+    PropTween,
+    _getCache,
+    _checkPointRatio,
+    _clamp,
+    _processingVars,
+    _getStyleSaver,
+    _reverting,
+    _getTracker = VelocityTracker.getByTarget,
+    _getGSAP = function _getGSAP() {
+  return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+},
+    _isString = function _isString(value) {
+  return typeof value === "string";
+},
+    _isNumber = function _isNumber(value) {
+  return typeof value === "number";
+},
+    _isObject = function _isObject(value) {
+  return typeof value === "object";
+},
+    _isFunction = function _isFunction(value) {
+  return typeof value === "function";
+},
+    _bonusValidated = 1,
+    //<name>InertiaPlugin</name>
+_isArray = Array.isArray,
+    _emptyFunc = function _emptyFunc(p) {
+  return p;
+},
+    _bigNum = 1e10,
+    _tinyNum = 1 / _bigNum,
+    _checkPoint = 0.05,
+    _round = function _round(value) {
+  return Math.round(value * 10000) / 10000;
+},
+    _extend = function _extend(obj, defaults, exclude) {
+  for (var p in defaults) {
+    if (!(p in obj) && p !== exclude) {
+      obj[p] = defaults[p];
+    }
+  }
+
+  return obj;
+},
+    _deepClone = function _deepClone(obj) {
+  var copy = {},
+      p,
+      v;
+
+  for (p in obj) {
+    copy[p] = _isObject(v = obj[p]) && !_isArray(v) ? _deepClone(v) : v;
+  }
+
+  return copy;
+},
+    _getClosest = function _getClosest(n, values, max, min, radius) {
+  var i = values.length,
+      closest = 0,
+      absDif = _bigNum,
+      val,
+      dif,
+      p,
+      dist;
+
+  if (_isObject(n)) {
+    while (i--) {
+      val = values[i];
+      dif = 0;
+
+      for (p in n) {
+        dist = val[p] - n[p];
+        dif += dist * dist;
+      }
+
+      if (dif < absDif) {
+        closest = i;
+        absDif = dif;
+      }
+    }
+
+    if ((radius || _bigNum) < _bigNum && radius < Math.sqrt(absDif)) {
+      return n;
+    }
+  } else {
+    while (i--) {
+      val = values[i];
+      dif = val - n;
+
+      if (dif < 0) {
+        dif = -dif;
+      }
+
+      if (dif < absDif && val >= min && val <= max) {
+        closest = i;
+        absDif = dif;
+      }
+    }
+  }
+
+  return values[closest];
+},
+    _parseEnd = function _parseEnd(curProp, end, max, min, name, radius, velocity) {
+  if (curProp.end === "auto") {
+    return curProp;
+  }
+
+  var endVar = curProp.end,
+      adjustedEnd,
+      p;
+  max = isNaN(max) ? _bigNum : max;
+  min = isNaN(min) ? -_bigNum : min;
+
+  if (_isObject(end)) {
+    //for objects, like {x, y} where they're linked and we must pass an object to the function or find the closest value in an array.
+    adjustedEnd = end.calculated ? end : (_isFunction(endVar) ? endVar(end, velocity) : _getClosest(end, endVar, max, min, radius)) || end;
+
+    if (!end.calculated) {
+      for (p in adjustedEnd) {
+        end[p] = adjustedEnd[p];
+      }
+
+      end.calculated = true;
+    }
+
+    adjustedEnd = adjustedEnd[name];
+  } else {
+    adjustedEnd = _isFunction(endVar) ? endVar(end, velocity) : _isArray(endVar) ? _getClosest(end, endVar, max, min, radius) : parseFloat(endVar);
+  }
+
+  if (adjustedEnd > max) {
+    adjustedEnd = max;
+  } else if (adjustedEnd < min) {
+    adjustedEnd = min;
+  }
+
+  return {
+    max: adjustedEnd,
+    min: adjustedEnd,
+    unitFactor: curProp.unitFactor
+  };
+},
+    _getNumOrDefault = function _getNumOrDefault(vars, property, defaultValue) {
+  return isNaN(vars[property]) ? defaultValue : +vars[property];
+},
+    _calculateChange = function _calculateChange(velocity, duration) {
+  return duration * _checkPoint * velocity / _checkPointRatio;
+},
+    _calculateDuration = function _calculateDuration(start, end, velocity) {
+  return Math.abs((end - start) * _checkPointRatio / velocity / _checkPoint);
+},
+    _reservedProps = {
+  resistance: 1,
+  checkpoint: 1,
+  preventOvershoot: 1,
+  linkedProps: 1,
+  radius: 1,
+  duration: 1
+},
+    _processLinkedProps = function _processLinkedProps(target, vars, getVal, resistance) {
+  if (vars.linkedProps) {
+    //when there are linkedProps (typically "x,y" where snapping has to factor in multiple properties, we must first populate an object with all of those end values, then feed it to the function that make any necessary alterations. So the point of this first loop is to simply build an object (like {x:100, y:204.5}) for feeding into that function which we'll do later in the "real" loop.
+    var linkedPropNames = vars.linkedProps.split(","),
+        linkedProps = {},
+        i,
+        p,
+        curProp,
+        curVelocity,
+        tracker,
+        curDuration;
+
+    for (i = 0; i < linkedPropNames.length; i++) {
+      p = linkedPropNames[i];
+      curProp = vars[p];
+
+      if (curProp) {
+        if (_isNumber(curProp.velocity)) {
+          curVelocity = curProp.velocity;
+        } else {
+          tracker = tracker || _getTracker(target);
+          curVelocity = tracker && tracker.isTracking(p) ? tracker.get(p) : 0;
+        }
+
+        curDuration = Math.abs(curVelocity / _getNumOrDefault(curProp, "resistance", resistance));
+        linkedProps[p] = parseFloat(getVal(target, p)) + _calculateChange(curVelocity, curDuration);
+      }
+    }
+
+    return linkedProps;
+  }
+},
+    _calculateTweenDuration = function _calculateTweenDuration(target, vars, maxDuration, minDuration, overshootTolerance, recordEnd) {
+  if (maxDuration === void 0) {
+    maxDuration = 10;
+  }
+
+  if (minDuration === void 0) {
+    minDuration = 0.2;
+  }
+
+  if (overshootTolerance === void 0) {
+    overshootTolerance = 1;
+  }
+
+  if (recordEnd === void 0) {
+    recordEnd = 0;
+  }
+
+  _isString(target) && (target = _toArray(target)[0]);
+
+  if (!target) {
+    return 0;
+  }
+
+  var duration = 0,
+      clippedDuration = _bigNum,
+      inertiaVars = vars.inertia || vars,
+      getVal = _getCache(target).get,
+      resistance = _getNumOrDefault(inertiaVars, "resistance", _config.resistance),
+      p,
+      curProp,
+      curDuration,
+      curVelocity,
+      curVal,
+      end,
+      curClippedDuration,
+      tracker,
+      unitFactor,
+      linkedProps; //when there are linkedProps (typically "x,y" where snapping has to factor in multiple properties, we must first populate an object with all of those end values, then feed it to the function that make any necessary alterations. So the point of this first loop is to simply build an object (like {x:100, y:204.5}) for feeding into that function which we'll do later in the "real" loop.
+
+
+  linkedProps = _processLinkedProps(target, inertiaVars, getVal, resistance);
+
+  for (p in inertiaVars) {
+    if (!_reservedProps[p]) {
+      curProp = inertiaVars[p];
+
+      if (!_isObject(curProp)) {
+        tracker = tracker || _getTracker(target);
+
+        if (tracker && tracker.isTracking(p)) {
+          curProp = _isNumber(curProp) ? {
+            velocity: curProp
+          } : {
+            velocity: tracker.get(p)
+          }; //if we're tracking this property, we should use the tracking velocity and then use the numeric value that was passed in as the min and max so that it tweens exactly there.
+        } else {
+          curVelocity = +curProp || 0;
+          curDuration = Math.abs(curVelocity / resistance);
+        }
+      }
+
+      if (_isObject(curProp)) {
+        if (_isNumber(curProp.velocity)) {
+          curVelocity = curProp.velocity;
+        } else {
+          tracker = tracker || _getTracker(target);
+          curVelocity = tracker && tracker.isTracking(p) ? tracker.get(p) : 0;
+        }
+
+        curDuration = _clamp(minDuration, maxDuration, Math.abs(curVelocity / _getNumOrDefault(curProp, "resistance", resistance)));
+        curVal = parseFloat(getVal(target, p)) || 0;
+        end = curVal + _calculateChange(curVelocity, curDuration);
+
+        if ("end" in curProp) {
+          curProp = _parseEnd(curProp, linkedProps && p in linkedProps ? linkedProps : end, curProp.max, curProp.min, p, inertiaVars.radius, curVelocity);
+
+          if (recordEnd) {
+            _processingVars === vars && (_processingVars = inertiaVars = _deepClone(vars));
+            inertiaVars[p] = _extend(curProp, inertiaVars[p], "end");
+          }
+        }
+
+        if ("max" in curProp && end > +curProp.max + _tinyNum) {
+          unitFactor = curProp.unitFactor || _config.unitFactors[p] || 1; //some values are measured in special units like radians in which case our thresholds need to be adjusted accordingly.
+          //if the value is already exceeding the max or the velocity is too low, the duration can end up being uncomfortably long but in most situations, users want the snapping to occur relatively quickly (0.75 seconds), so we implement a cap here to make things more intuitive. If the max and min match, it means we're animating to a particular value and we don't want to shorten the time unless the velocity is really slow. Example: a rotation where the start and natural end value are less than the snapping spot, but the natural end is pretty close to the snap.
+
+          curClippedDuration = curVal > curProp.max && curProp.min !== curProp.max || curVelocity * unitFactor > -15 && curVelocity * unitFactor < 45 ? minDuration + (maxDuration - minDuration) * 0.1 : _calculateDuration(curVal, curProp.max, curVelocity);
+
+          if (curClippedDuration + overshootTolerance < clippedDuration) {
+            clippedDuration = curClippedDuration + overshootTolerance;
+          }
+        } else if ("min" in curProp && end < +curProp.min - _tinyNum) {
+          unitFactor = curProp.unitFactor || _config.unitFactors[p] || 1; //some values are measured in special units like radians in which case our thresholds need to be adjusted accordingly.
+          //if the value is already exceeding the min or if the velocity is too low, the duration can end up being uncomfortably long but in most situations, users want the snapping to occur relatively quickly (0.75 seconds), so we implement a cap here to make things more intuitive.
+
+          curClippedDuration = curVal < curProp.min && curProp.min !== curProp.max || curVelocity * unitFactor > -45 && curVelocity * unitFactor < 15 ? minDuration + (maxDuration - minDuration) * 0.1 : _calculateDuration(curVal, curProp.min, curVelocity);
+
+          if (curClippedDuration + overshootTolerance < clippedDuration) {
+            clippedDuration = curClippedDuration + overshootTolerance;
+          }
+        }
+
+        curClippedDuration > duration && (duration = curClippedDuration);
+      }
+
+      curDuration > duration && (duration = curDuration);
+    }
+  }
+
+  duration > clippedDuration && (duration = clippedDuration);
+  return duration > maxDuration ? maxDuration : duration < minDuration ? minDuration : duration;
+},
+    _initCore = function _initCore() {
+  gsap = _getGSAP();
+
+  if (gsap) {
+    _parseEase = gsap.parseEase;
+    _toArray = gsap.utils.toArray;
+    _getUnit = gsap.utils.getUnit;
+    _getCache = gsap.core.getCache;
+    _clamp = gsap.utils.clamp;
+    _getStyleSaver = gsap.core.getStyleSaver;
+
+    _reverting = gsap.core.reverting || function () {};
+
+    _power3 = _parseEase("power3");
+    _checkPointRatio = _power3(0.05);
+    PropTween = gsap.core.PropTween;
+    gsap.config({
+      resistance: 100,
+      unitFactors: {
+        time: 1000,
+        totalTime: 1000,
+        progress: 1000,
+        totalProgress: 1000
+      }
+    });
+    _config = gsap.config();
+    gsap.registerPlugin(VelocityTracker);
+    _coreInitted = 1;
+  }
+};
+
+export var InertiaPlugin = {
+  version: "3.13.0",
+  name: "inertia",
+  register: function register(core) {
+    gsap = core;
+
+    _initCore();
+  },
+  init: function init(target, vars, tween, index, targets) {
+    _coreInitted || _initCore();
+
+    var tracker = _getTracker(target);
+
+    if (vars === "auto") {
+      if (!tracker) {
+        console.warn("No inertia tracking on " + target + ". InertiaPlugin.track(target) first.");
+        return;
+      }
+
+      vars = tracker.getAll();
+    }
+
+    this.styles = _getStyleSaver && typeof target.style === "object" && _getStyleSaver(target);
+    this.target = target;
+    this.tween = tween;
+    _processingVars = vars; // gets swapped inside _calculateTweenDuration() if there's a function-based value encountered (to avoid double-calling it)
+
+    var cache = target._gsap,
+        getVal = cache.get,
+        dur = vars.duration,
+        durIsObj = _isObject(dur),
+        preventOvershoot = vars.preventOvershoot || durIsObj && dur.overshoot === 0,
+        resistance = _getNumOrDefault(vars, "resistance", _config.resistance),
+        duration = _isNumber(dur) ? dur : _calculateTweenDuration(target, vars, durIsObj && dur.max || 10, durIsObj && dur.min || 0.2, durIsObj && "overshoot" in dur ? +dur.overshoot : preventOvershoot ? 0 : 1, true),
+        p,
+        curProp,
+        curVal,
+        unit,
+        velocity,
+        change1,
+        end,
+        change2,
+        linkedProps;
+
+    vars = _processingVars;
+    _processingVars = 0; //when there are linkedProps (typically "x,y" where snapping has to factor in multiple properties, we must first populate an object with all of those end values, then feed it to the function that make any necessary alterations. So the point of this first loop is to simply build an object (like {x:100, y:204.5}) for feeding into that function which we'll do later in the "real" loop.
+
+    linkedProps = _processLinkedProps(target, vars, getVal, resistance);
+
+    for (p in vars) {
+      if (!_reservedProps[p]) {
+        curProp = vars[p];
+        _isFunction(curProp) && (curProp = curProp(index, target, targets));
+
+        if (_isNumber(curProp)) {
+          velocity = curProp;
+        } else if (_isObject(curProp) && !isNaN(curProp.velocity)) {
+          velocity = +curProp.velocity;
+        } else {
+          if (tracker && tracker.isTracking(p)) {
+            velocity = tracker.get(p);
+          } else {
+            console.warn("ERROR: No velocity was defined for " + target + " property: " + p);
+          }
+        }
+
+        change1 = _calculateChange(velocity, duration);
+        change2 = 0;
+        curVal = getVal(target, p);
+        unit = _getUnit(curVal);
+        curVal = parseFloat(curVal);
+
+        if (_isObject(curProp)) {
+          end = curVal + change1;
+
+          if ("end" in curProp) {
+            curProp = _parseEnd(curProp, linkedProps && p in linkedProps ? linkedProps : end, curProp.max, curProp.min, p, vars.radius, velocity);
+          }
+
+          if ("max" in curProp && +curProp.max < end) {
+            if (preventOvershoot || curProp.preventOvershoot) {
+              change1 = curProp.max - curVal;
+            } else {
+              change2 = curProp.max - curVal - change1;
+            }
+          } else if ("min" in curProp && +curProp.min > end) {
+            if (preventOvershoot || curProp.preventOvershoot) {
+              change1 = curProp.min - curVal;
+            } else {
+              change2 = curProp.min - curVal - change1;
+            }
+          }
+        }
+
+        this._props.push(p);
+
+        this.styles && this.styles.save(p);
+        this._pt = new PropTween(this._pt, target, p, curVal, 0, _emptyFunc, 0, cache.set(target, p, this));
+        this._pt.u = unit || 0;
+        this._pt.c1 = change1;
+        this._pt.c2 = change2;
+      }
+    }
+
+    tween.duration(duration);
+    return _bonusValidated;
+  },
+  render: function render(ratio, data) {
+    var pt = data._pt;
+    ratio = _power3(data.tween._time / data.tween._dur);
+
+    if (ratio || !_reverting()) {
+      while (pt) {
+        pt.set(pt.t, pt.p, _round(pt.s + pt.c1 * ratio + pt.c2 * ratio * ratio) + pt.u, pt.d, ratio);
+        pt = pt._next;
+      }
+    } else {
+      data.styles.revert();
+    }
+  }
+};
+"track,untrack,isTracking,getVelocity,getByTarget".split(",").forEach(function (name) {
+  return InertiaPlugin[name] = VelocityTracker[name];
+});
+_getGSAP() && gsap.registerPlugin(InertiaPlugin);
+export { InertiaPlugin as default, VelocityTracker };

network-visualization/node_modules/gsap/MotionPathHelper.js

@@ -0,0 +1,376 @@
+/*!
+ * MotionPathHelper 3.13.0
+ * https://gsap.com
+ *
+ * @license Copyright 2008-2025, GreenSock. All rights reserved.
+ * Subject to the terms at https://gsap.com/standard-license
+ * @author: Jack Doyle, jack@greensock.com
+*/
+
+/* eslint-disable */
+import PathEditor from "./utils/PathEditor.js";
+
+var gsap,
+    _win,
+    _doc,
+    _docEl,
+    _body,
+    MotionPathPlugin,
+    _arrayToRawPath,
+    _rawPathToString,
+    _context,
+    _bonusValidated = 1,
+    //<name>MotionPathHelper</name>
+_selectorExp = /(^[#\.][a-z]|[a-y][a-z])/i,
+    _isString = function _isString(value) {
+  return typeof value === "string";
+},
+    _createElement = function _createElement(type, ns) {
+  var e = _doc.createElementNS ? _doc.createElementNS((ns || "http://www.w3.org/1999/xhtml").replace(/^https/, "http"), type) : _doc.createElement(type); //some servers swap in https for http in the namespace which can break things, making "style" inaccessible.
+
+  return e.style ? e : _doc.createElement(type); //some environments won't allow access to the element's style when created with a namespace in which case we default to the standard createElement() to work around the issue. Also note that when GSAP is embedded directly inside an SVG file, createElement() won't allow access to the style object in Firefox (see https://gsap.com/forums/topic/20215-problem-using-tweenmax-in-standalone-self-containing-svg-file-err-cannot-set-property-csstext-of-undefined/).
+},
+    _getPositionOnPage = function _getPositionOnPage(target) {
+  var bounds = target.getBoundingClientRect(),
+      windowOffsetY = _docEl.clientTop - (_win.pageYOffset || _docEl.scrollTop || _body.scrollTop || 0),
+      windowOffsetX = _docEl.clientLeft - (_win.pageXOffset || _docEl.scrollLeft || _body.scrollLeft || 0);
+  return {
+    left: bounds.left + windowOffsetX,
+    top: bounds.top + windowOffsetY,
+    right: bounds.right + windowOffsetX,
+    bottom: bounds.bottom + windowOffsetY
+  };
+},
+    _getInitialPath = function _getInitialPath(x, y) {
+  var coordinates = [0, 31, 8, 58, 24, 75, 40, 90, 69, 100, 100, 100],
+      i;
+
+  for (i = 0; i < coordinates.length; i += 2) {
+    coordinates[i] += x;
+    coordinates[i + 1] += y;
+  }
+
+  return "M" + x + "," + y + "C" + coordinates.join(",");
+},
+    _getGlobalTime = function _getGlobalTime(animation) {
+  var time = animation.totalTime();
+
+  while (animation) {
+    time = animation.startTime() + time / (animation.timeScale() || 1);
+    animation = animation.parent;
+  }
+
+  return time;
+},
+    _copyElement,
+    _initCopyToClipboard = function _initCopyToClipboard() {
+  _copyElement = _createElement("textarea");
+  _copyElement.style.display = "none";
+
+  _body.appendChild(_copyElement);
+},
+    _parsePath = function _parsePath(path, target, vars) {
+  return _isString(path) && _selectorExp.test(path) ? _doc.querySelector(path) : Array.isArray(path) ? _rawPathToString(_arrayToRawPath([{
+    x: gsap.getProperty(target, "x"),
+    y: gsap.getProperty(target, "y")
+  }].concat(path), vars)) : _isString(path) || path && (path.tagName + "").toLowerCase() === "path" ? path : 0;
+},
+    _addCopyToClipboard = function _addCopyToClipboard(target, getter, onComplete) {
+  target.addEventListener('click', function (e) {
+    if (e.target._gsHelper) {
+      var c = getter(e.target);
+      _copyElement.value = c;
+
+      if (c && _copyElement.select) {
+        console.log(c);
+        _copyElement.style.display = "block";
+
+        _copyElement.select();
+
+        try {
+          _doc.execCommand('copy');
+
+          _copyElement.blur();
+
+          onComplete && onComplete(target);
+        } catch (err) {
+          console.warn("Copy didn't work; this browser doesn't permit that.");
+        }
+
+        _copyElement.style.display = "none";
+      }
+    }
+  });
+},
+    _identityMatrixObject = {
+  matrix: {
+    a: 1,
+    b: 0,
+    c: 0,
+    d: 1,
+    e: 0,
+    f: 0
+  }
+},
+    _getConsolidatedMatrix = function _getConsolidatedMatrix(target) {
+  return (target.transform.baseVal.consolidate() || _identityMatrixObject).matrix;
+},
+    _findMotionPathTween = function _findMotionPathTween(target) {
+  var tweens = gsap.getTweensOf(target),
+      i = 0;
+
+  for (; i < tweens.length; i++) {
+    if (tweens[i].vars.motionPath) {
+      return tweens[i];
+    } else if (tweens[i].timeline) {
+      tweens.push.apply(tweens, tweens[i].timeline.getChildren());
+    }
+  }
+},
+    _initCore = function _initCore(core, required) {
+  var message = "Please gsap.registerPlugin(MotionPathPlugin)";
+  _win = window;
+  gsap = gsap || core || _win.gsap || console.warn(message);
+  gsap && PathEditor.register(gsap);
+  _doc = document;
+  _body = _doc.body;
+  _docEl = _doc.documentElement;
+
+  if (gsap) {
+    MotionPathPlugin = gsap.plugins.motionPath;
+    MotionPathHelper.PathEditor = PathEditor;
+
+    _context = gsap.core.context || function () {};
+  }
+
+  if (!MotionPathPlugin) {
+    required === true && console.warn(message);
+  } else {
+    _initCopyToClipboard();
+
+    _arrayToRawPath = MotionPathPlugin.arrayToRawPath;
+    _rawPathToString = MotionPathPlugin.rawPathToString;
+  }
+};
+
+export var MotionPathHelper = /*#__PURE__*/function () {
+  function MotionPathHelper(targetOrTween, vars) {
+    var _this = this;
+
+    if (vars === void 0) {
+      vars = {};
+    }
+
+    if (!MotionPathPlugin) {
+      _initCore(vars.gsap, 1);
+    }
+
+    var copyButton = _createElement("div"),
+        self = this,
+        offset = {
+      x: 0,
+      y: 0
+    },
+        target,
+        path,
+        isSVG,
+        startX,
+        startY,
+        position,
+        svg,
+        animation,
+        svgNamespace,
+        temp,
+        matrix,
+        refreshPath,
+        animationToScrub,
+        createdSVG;
+
+    if (targetOrTween instanceof gsap.core.Tween) {
+      animation = targetOrTween;
+      target = animation.targets()[0];
+    } else {
+      target = gsap.utils.toArray(targetOrTween)[0];
+      animation = _findMotionPathTween(target);
+    }
+
+    path = _parsePath(vars.path, target, vars);
+    this.offset = offset;
+    position = _getPositionOnPage(target);
+    startX = parseFloat(gsap.getProperty(target, "x", "px"));
+    startY = parseFloat(gsap.getProperty(target, "y", "px"));
+    isSVG = target.getCTM && target.tagName.toLowerCase() !== "svg";
+
+    if (animation && !path) {
+      path = _parsePath(animation.vars.motionPath.path || animation.vars.motionPath, target, animation.vars.motionPath);
+    }
+
+    copyButton.setAttribute("class", "copy-motion-path");
+    copyButton.style.cssText = "border-radius:8px; background-color:rgba(85, 85, 85, 0.7); color:#fff; cursor:pointer; padding:6px 12px; font-family:Signika Negative, Arial, sans-serif; position:fixed; left:50%; transform:translate(-50%, 0); font-size:19px; bottom:10px";
+    copyButton.innerText = "COPY MOTION PATH";
+    copyButton._gsHelper = self;
+
+    (gsap.utils.toArray(vars.container)[0] || _body).appendChild(copyButton);
+
+    _addCopyToClipboard(copyButton, function () {
+      return self.getString();
+    }, function () {
+      return gsap.fromTo(copyButton, {
+        backgroundColor: "white"
+      }, {
+        duration: 0.5,
+        backgroundColor: "rgba(85, 85, 85, 0.6)"
+      });
+    });
+
+    svg = path && path.ownerSVGElement;
+
+    if (!svg) {
+      svgNamespace = isSVG && target.ownerSVGElement && target.ownerSVGElement.getAttribute("xmlns") || "http://www.w3.org/2000/svg";
+
+      if (isSVG) {
+        svg = target.ownerSVGElement;
+        temp = target.getBBox();
+        matrix = _getConsolidatedMatrix(target);
+        startX = matrix.e;
+        startY = matrix.f;
+        offset.x = temp.x;
+        offset.y = temp.y;
+      } else {
+        svg = _createElement("svg", svgNamespace);
+        createdSVG = true;
+
+        _body.appendChild(svg);
+
+        svg.setAttribute("viewBox", "0 0 100 100");
+        svg.setAttribute("class", "motion-path-helper");
+        svg.style.cssText = "overflow:visible; background-color: transparent; position:absolute; z-index:5000; width:100px; height:100px; top:" + (position.top - startY) + "px; left:" + (position.left - startX) + "px;";
+      }
+
+      temp = _isString(path) && !_selectorExp.test(path) ? path : _getInitialPath(startX, startY);
+      path = _createElement("path", svgNamespace);
+      path.setAttribute("d", temp);
+      path.setAttribute("vector-effect", "non-scaling-stroke");
+      path.style.cssText = "fill:transparent; stroke-width:" + (vars.pathWidth || 3) + "; stroke:" + (vars.pathColor || "#555") + "; opacity:" + (vars.pathOpacity || 0.6);
+      svg.appendChild(path);
+    } else {
+      vars.pathColor && gsap.set(path, {
+        stroke: vars.pathColor
+      });
+      vars.pathWidth && gsap.set(path, {
+        strokeWidth: vars.pathWidth
+      });
+      vars.pathOpacity && gsap.set(path, {
+        opacity: vars.pathOpacity
+      });
+    }
+
+    if (offset.x || offset.y) {
+      gsap.set(path, {
+        x: offset.x,
+        y: offset.y
+      });
+    }
+
+    if (!("selected" in vars)) {
+      vars.selected = true;
+    }
+
+    if (!("anchorSnap" in vars)) {
+      vars.anchorSnap = function (p) {
+        if (p.x * p.x + p.y * p.y < 16) {
+          p.x = p.y = 0;
+        }
+      };
+    }
+
+    animationToScrub = animation && animation.parent && animation.parent.data === "nested" ? animation.parent.parent : animation;
+
+    vars.onPress = function () {
+      animationToScrub.pause(0);
+    };
+
+    refreshPath = function refreshPath() {
+      //let m = _getConsolidatedMatrix(path);
+      //animation.vars.motionPath.offsetX = m.e - offset.x;
+      //animation.vars.motionPath.offsetY = m.f - offset.y;
+      animation.invalidate();
+      animationToScrub.restart();
+    };
+
+    vars.onRelease = vars.onDeleteAnchor = refreshPath;
+    this.editor = PathEditor.create(path, vars);
+
+    if (vars.center) {
+      gsap.set(target, {
+        transformOrigin: "50% 50%",
+        xPercent: -50,
+        yPercent: -50
+      });
+    }
+
+    if (animation) {
+      if (animation.vars.motionPath.path) {
+        animation.vars.motionPath.path = path;
+      } else {
+        animation.vars.motionPath = {
+          path: path
+        };
+      }
+
+      if (animationToScrub.parent !== gsap.globalTimeline) {
+        gsap.globalTimeline.add(animationToScrub, _getGlobalTime(animationToScrub) - animationToScrub.delay());
+      }
+
+      animationToScrub.repeat(-1).repeatDelay(1);
+    } else {
+      animation = animationToScrub = gsap.to(target, {
+        motionPath: {
+          path: path,
+          start: vars.start || 0,
+          end: "end" in vars ? vars.end : 1,
+          autoRotate: "autoRotate" in vars ? vars.autoRotate : false,
+          align: path,
+          alignOrigin: vars.alignOrigin
+        },
+        duration: vars.duration || 5,
+        ease: vars.ease || "power1.inOut",
+        repeat: -1,
+        repeatDelay: 1,
+        paused: !vars.path
+      });
+    }
+
+    this.animation = animation;
+
+    _context(this);
+
+    this.kill = this.revert = function () {
+      _this.editor.kill();
+
+      copyButton.parentNode && copyButton.parentNode.removeChild(copyButton);
+      createdSVG && svg.parentNode && svg.parentNode.removeChild(svg);
+      animationToScrub && animationToScrub.revert();
+    };
+  }
+
+  var _proto = MotionPathHelper.prototype;
+
+  _proto.getString = function getString() {
+    return this.editor.getString(true, -this.offset.x, -this.offset.y);
+  };
+
+  return MotionPathHelper;
+}();
+MotionPathHelper.register = _initCore;
+
+MotionPathHelper.create = function (target, vars) {
+  return new MotionPathHelper(target, vars);
+};
+
+MotionPathHelper.editPath = function (path, vars) {
+  return PathEditor.create(path, vars);
+};
+
+MotionPathHelper.version = "3.13.0";
+export { MotionPathHelper as default };

network-visualization/node_modules/gsap/MotionPathPlugin.js

@@ -0,0 +1,369 @@
+/*!
+ * MotionPathPlugin 3.13.0
+ * https://gsap.com
+ *
+ * @license Copyright 2008-2025, GreenSock. All rights reserved.
+ * Subject to the terms at https://gsap.com/standard-license
+ * @author: Jack Doyle, jack@greensock.com
+*/
+
+/* eslint-disable */
+import { getRawPath, cacheRawPathMeasurements, getPositionOnPath, pointsToSegment, flatPointsToSegment, sliceRawPath, stringToRawPath, rawPathToString, transformRawPath, convertToPath as _convertToPath } from "./utils/paths.js";
+import { getGlobalMatrix } from "./utils/matrix.js";
+
+var _xProps = "x,translateX,left,marginLeft,xPercent".split(","),
+    _yProps = "y,translateY,top,marginTop,yPercent".split(","),
+    _DEG2RAD = Math.PI / 180,
+    gsap,
+    PropTween,
+    _getUnit,
+    _toArray,
+    _getStyleSaver,
+    _reverting,
+    _getGSAP = function _getGSAP() {
+  return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+},
+    _populateSegmentFromArray = function _populateSegmentFromArray(segment, values, property, mode) {
+  //mode: 0 = x but don't fill y yet, 1 = y, 2 = x and fill y with 0.
+  var l = values.length,
+      si = mode === 2 ? 0 : mode,
+      i = 0,
+      v;
+
+  for (; i < l; i++) {
+    segment[si] = v = parseFloat(values[i][property]);
+    mode === 2 && (segment[si + 1] = 0);
+    si += 2;
+  }
+
+  return segment;
+},
+    _getPropNum = function _getPropNum(target, prop, unit) {
+  return parseFloat(target._gsap.get(target, prop, unit || "px")) || 0;
+},
+    _relativize = function _relativize(segment) {
+  var x = segment[0],
+      y = segment[1],
+      i;
+
+  for (i = 2; i < segment.length; i += 2) {
+    x = segment[i] += x;
+    y = segment[i + 1] += y;
+  }
+},
+    // feed in an array of quadratic bezier points like [{x: 0, y: 0}, ...] and it'll convert it to cubic bezier
+// _quadToCubic = points => {
+// 	let cubic = [],
+// 		l = points.length - 1,
+// 		i = 1,
+// 		a, b, c;
+// 	for (; i < l; i+=2) {
+// 		a = points[i-1];
+// 		b = points[i];
+// 		c = points[i+1];
+// 		cubic.push(a, {x: (2 * b.x + a.x) / 3, y: (2 * b.y + a.y) / 3}, {x: (2 * b.x + c.x) / 3, y: (2 * b.y + c.y) / 3});
+// 	}
+// 	cubic.push(points[l]);
+// 	return cubic;
+// },
+_segmentToRawPath = function _segmentToRawPath(plugin, segment, target, x, y, slicer, vars, unitX, unitY) {
+  if (vars.type === "cubic") {
+    segment = [segment];
+  } else {
+    vars.fromCurrent !== false && segment.unshift(_getPropNum(target, x, unitX), y ? _getPropNum(target, y, unitY) : 0);
+    vars.relative && _relativize(segment);
+    var pointFunc = y ? pointsToSegment : flatPointsToSegment;
+    segment = [pointFunc(segment, vars.curviness)];
+  }
+
+  segment = slicer(_align(segment, target, vars));
+
+  _addDimensionalPropTween(plugin, target, x, segment, "x", unitX);
+
+  y && _addDimensionalPropTween(plugin, target, y, segment, "y", unitY);
+  return cacheRawPathMeasurements(segment, vars.resolution || (vars.curviness === 0 ? 20 : 12)); //when curviness is 0, it creates control points right on top of the anchors which makes it more sensitive to resolution, thus we change the default accordingly.
+},
+    _emptyFunc = function _emptyFunc(v) {
+  return v;
+},
+    _numExp = /[-+\.]*\d+\.?(?:e-|e\+)?\d*/g,
+    _originToPoint = function _originToPoint(element, origin, parentMatrix) {
+  // origin is an array of normalized values (0-1) in relation to the width/height, so [0.5, 0.5] would be the center. It can also be "auto" in which case it will be the top left unless it's a <path>, when it will start at the beginning of the path itself.
+  var m = getGlobalMatrix(element),
+      x = 0,
+      y = 0,
+      svg;
+
+  if ((element.tagName + "").toLowerCase() === "svg") {
+    svg = element.viewBox.baseVal;
+    svg.width || (svg = {
+      width: +element.getAttribute("width"),
+      height: +element.getAttribute("height")
+    });
+  } else {
+    svg = origin && element.getBBox && element.getBBox();
+  }
+
+  if (origin && origin !== "auto") {
+    x = origin.push ? origin[0] * (svg ? svg.width : element.offsetWidth || 0) : origin.x;
+    y = origin.push ? origin[1] * (svg ? svg.height : element.offsetHeight || 0) : origin.y;
+  }
+
+  return parentMatrix.apply(x || y ? m.apply({
+    x: x,
+    y: y
+  }) : {
+    x: m.e,
+    y: m.f
+  });
+},
+    _getAlignMatrix = function _getAlignMatrix(fromElement, toElement, fromOrigin, toOrigin) {
+  var parentMatrix = getGlobalMatrix(fromElement.parentNode, true, true),
+      m = parentMatrix.clone().multiply(getGlobalMatrix(toElement)),
+      fromPoint = _originToPoint(fromElement, fromOrigin, parentMatrix),
+      _originToPoint2 = _originToPoint(toElement, toOrigin, parentMatrix),
+      x = _originToPoint2.x,
+      y = _originToPoint2.y,
+      p;
+
+  m.e = m.f = 0;
+
+  if (toOrigin === "auto" && toElement.getTotalLength && toElement.tagName.toLowerCase() === "path") {
+    p = toElement.getAttribute("d").match(_numExp) || [];
+    p = m.apply({
+      x: +p[0],
+      y: +p[1]
+    });
+    x += p.x;
+    y += p.y;
+  } //if (p || (toElement.getBBox && fromElement.getBBox && toElement.ownerSVGElement === fromElement.ownerSVGElement)) {
+
+
+  if (p) {
+    p = m.apply(toElement.getBBox());
+    x -= p.x;
+    y -= p.y;
+  }
+
+  m.e = x - fromPoint.x;
+  m.f = y - fromPoint.y;
+  return m;
+},
+    _align = function _align(rawPath, target, _ref) {
+  var align = _ref.align,
+      matrix = _ref.matrix,
+      offsetX = _ref.offsetX,
+      offsetY = _ref.offsetY,
+      alignOrigin = _ref.alignOrigin;
+
+  var x = rawPath[0][0],
+      y = rawPath[0][1],
+      curX = _getPropNum(target, "x"),
+      curY = _getPropNum(target, "y"),
+      alignTarget,
+      m,
+      p;
+
+  if (!rawPath || !rawPath.length) {
+    return getRawPath("M0,0L0,0");
+  }
+
+  if (align) {
+    if (align === "self" || (alignTarget = _toArray(align)[0] || target) === target) {
+      transformRawPath(rawPath, 1, 0, 0, 1, curX - x, curY - y);
+    } else {
+      if (alignOrigin && alignOrigin[2] !== false) {
+        gsap.set(target, {
+          transformOrigin: alignOrigin[0] * 100 + "% " + alignOrigin[1] * 100 + "%"
+        });
+      } else {
+        alignOrigin = [_getPropNum(target, "xPercent") / -100, _getPropNum(target, "yPercent") / -100];
+      }
+
+      m = _getAlignMatrix(target, alignTarget, alignOrigin, "auto");
+      p = m.apply({
+        x: x,
+        y: y
+      });
+      transformRawPath(rawPath, m.a, m.b, m.c, m.d, curX + m.e - (p.x - m.e), curY + m.f - (p.y - m.f));
+    }
+  }
+
+  if (matrix) {
+    transformRawPath(rawPath, matrix.a, matrix.b, matrix.c, matrix.d, matrix.e, matrix.f);
+  } else if (offsetX || offsetY) {
+    transformRawPath(rawPath, 1, 0, 0, 1, offsetX || 0, offsetY || 0);
+  }
+
+  return rawPath;
+},
+    _addDimensionalPropTween = function _addDimensionalPropTween(plugin, target, property, rawPath, pathProperty, forceUnit) {
+  var cache = target._gsap,
+      harness = cache.harness,
+      alias = harness && harness.aliases && harness.aliases[property],
+      prop = alias && alias.indexOf(",") < 0 ? alias : property,
+      pt = plugin._pt = new PropTween(plugin._pt, target, prop, 0, 0, _emptyFunc, 0, cache.set(target, prop, plugin));
+  pt.u = _getUnit(cache.get(target, prop, forceUnit)) || 0;
+  pt.path = rawPath;
+  pt.pp = pathProperty;
+
+  plugin._props.push(prop);
+},
+    _sliceModifier = function _sliceModifier(start, end) {
+  return function (rawPath) {
+    return start || end !== 1 ? sliceRawPath(rawPath, start, end) : rawPath;
+  };
+};
+
+export var MotionPathPlugin = {
+  version: "3.13.0",
+  name: "motionPath",
+  register: function register(core, Plugin, propTween) {
+    gsap = core;
+    _getUnit = gsap.utils.getUnit;
+    _toArray = gsap.utils.toArray;
+    _getStyleSaver = gsap.core.getStyleSaver;
+
+    _reverting = gsap.core.reverting || function () {};
+
+    PropTween = propTween;
+  },
+  init: function init(target, vars, tween) {
+    if (!gsap) {
+      console.warn("Please gsap.registerPlugin(MotionPathPlugin)");
+      return false;
+    }
+
+    if (!(typeof vars === "object" && !vars.style) || !vars.path) {
+      vars = {
+        path: vars
+      };
+    }
+
+    var rawPaths = [],
+        _vars = vars,
+        path = _vars.path,
+        autoRotate = _vars.autoRotate,
+        unitX = _vars.unitX,
+        unitY = _vars.unitY,
+        x = _vars.x,
+        y = _vars.y,
+        firstObj = path[0],
+        slicer = _sliceModifier(vars.start, "end" in vars ? vars.end : 1),
+        rawPath,
+        p;
+
+    this.rawPaths = rawPaths;
+    this.target = target;
+    this.tween = tween;
+    this.styles = _getStyleSaver && _getStyleSaver(target, "transform");
+
+    if (this.rotate = autoRotate || autoRotate === 0) {
+      //get the rotational data FIRST so that the setTransform() method is called in the correct order in the render() loop - rotation gets set last.
+      this.rOffset = parseFloat(autoRotate) || 0;
+      this.radians = !!vars.useRadians;
+      this.rProp = vars.rotation || "rotation"; // rotation property
+
+      this.rSet = target._gsap.set(target, this.rProp, this); // rotation setter
+
+      this.ru = _getUnit(target._gsap.get(target, this.rProp)) || 0; // rotation units
+    }
+
+    if (Array.isArray(path) && !("closed" in path) && typeof firstObj !== "number") {
+      for (p in firstObj) {
+        if (!x && ~_xProps.indexOf(p)) {
+          x = p;
+        } else if (!y && ~_yProps.indexOf(p)) {
+          y = p;
+        }
+      }
+
+      if (x && y) {
+        //correlated values
+        rawPaths.push(_segmentToRawPath(this, _populateSegmentFromArray(_populateSegmentFromArray([], path, x, 0), path, y, 1), target, x, y, slicer, vars, unitX || _getUnit(path[0][x]), unitY || _getUnit(path[0][y])));
+      } else {
+        x = y = 0;
+      }
+
+      for (p in firstObj) {
+        p !== x && p !== y && rawPaths.push(_segmentToRawPath(this, _populateSegmentFromArray([], path, p, 2), target, p, 0, slicer, vars, _getUnit(path[0][p])));
+      }
+    } else {
+      rawPath = slicer(_align(getRawPath(vars.path), target, vars));
+      cacheRawPathMeasurements(rawPath, vars.resolution);
+      rawPaths.push(rawPath);
+
+      _addDimensionalPropTween(this, target, vars.x || "x", rawPath, "x", vars.unitX || "px");
+
+      _addDimensionalPropTween(this, target, vars.y || "y", rawPath, "y", vars.unitY || "px");
+    }
+
+    tween.vars.immediateRender && this.render(tween.progress(), this);
+  },
+  render: function render(ratio, data) {
+    var rawPaths = data.rawPaths,
+        i = rawPaths.length,
+        pt = data._pt;
+
+    if (data.tween._time || !_reverting()) {
+      if (ratio > 1) {
+        ratio = 1;
+      } else if (ratio < 0) {
+        ratio = 0;
+      }
+
+      while (i--) {
+        getPositionOnPath(rawPaths[i], ratio, !i && data.rotate, rawPaths[i]);
+      }
+
+      while (pt) {
+        pt.set(pt.t, pt.p, pt.path[pt.pp] + pt.u, pt.d, ratio);
+        pt = pt._next;
+      }
+
+      data.rotate && data.rSet(data.target, data.rProp, rawPaths[0].angle * (data.radians ? _DEG2RAD : 1) + data.rOffset + data.ru, data, ratio);
+    } else {
+      data.styles.revert();
+    }
+  },
+  getLength: function getLength(path) {
+    return cacheRawPathMeasurements(getRawPath(path)).totalLength;
+  },
+  sliceRawPath: sliceRawPath,
+  getRawPath: getRawPath,
+  pointsToSegment: pointsToSegment,
+  stringToRawPath: stringToRawPath,
+  rawPathToString: rawPathToString,
+  transformRawPath: transformRawPath,
+  getGlobalMatrix: getGlobalMatrix,
+  getPositionOnPath: getPositionOnPath,
+  cacheRawPathMeasurements: cacheRawPathMeasurements,
+  convertToPath: function convertToPath(targets, swap) {
+    return _toArray(targets).map(function (target) {
+      return _convertToPath(target, swap !== false);
+    });
+  },
+  convertCoordinates: function convertCoordinates(fromElement, toElement, point) {
+    var m = getGlobalMatrix(toElement, true, true).multiply(getGlobalMatrix(fromElement));
+    return point ? m.apply(point) : m;
+  },
+  getAlignMatrix: _getAlignMatrix,
+  getRelativePosition: function getRelativePosition(fromElement, toElement, fromOrigin, toOrigin) {
+    var m = _getAlignMatrix(fromElement, toElement, fromOrigin, toOrigin);
+
+    return {
+      x: m.e,
+      y: m.f
+    };
+  },
+  arrayToRawPath: function arrayToRawPath(value, vars) {
+    vars = vars || {};
+
+    var segment = _populateSegmentFromArray(_populateSegmentFromArray([], value, vars.x || "x", 0), value, vars.y || "y", 1);
+
+    vars.relative && _relativize(segment);
+    return [vars.type === "cubic" ? segment : pointsToSegment(segment, vars.curviness)];
+  }
+};
+_getGSAP() && gsap.registerPlugin(MotionPathPlugin);
+export { MotionPathPlugin as default };

network-visualization/node_modules/gsap/Observer.js

@@ -0,0 +1,708 @@
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+/*!
+ * Observer 3.13.0
+ * https://gsap.com
+ *
+ * @license Copyright 2008-2025, GreenSock. All rights reserved.
+ * Subject to the terms at https://gsap.com/standard-license
+ * @author: Jack Doyle, jack@greensock.com
+*/
+
+/* eslint-disable */
+var gsap,
+    _coreInitted,
+    _clamp,
+    _win,
+    _doc,
+    _docEl,
+    _body,
+    _isTouch,
+    _pointerType,
+    ScrollTrigger,
+    _root,
+    _normalizer,
+    _eventTypes,
+    _context,
+    _getGSAP = function _getGSAP() {
+  return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+},
+    _startup = 1,
+    _observers = [],
+    _scrollers = [],
+    _proxies = [],
+    _getTime = Date.now,
+    _bridge = function _bridge(name, value) {
+  return value;
+},
+    _integrate = function _integrate() {
+  var core = ScrollTrigger.core,
+      data = core.bridge || {},
+      scrollers = core._scrollers,
+      proxies = core._proxies;
+  scrollers.push.apply(scrollers, _scrollers);
+  proxies.push.apply(proxies, _proxies);
+  _scrollers = scrollers;
+  _proxies = proxies;
+
+  _bridge = function _bridge(name, value) {
+    return data[name](value);
+  };
+},
+    _getProxyProp = function _getProxyProp(element, property) {
+  return ~_proxies.indexOf(element) && _proxies[_proxies.indexOf(element) + 1][property];
+},
+    _isViewport = function _isViewport(el) {
+  return !!~_root.indexOf(el);
+},
+    _addListener = function _addListener(element, type, func, passive, capture) {
+  return element.addEventListener(type, func, {
+    passive: passive !== false,
+    capture: !!capture
+  });
+},
+    _removeListener = function _removeListener(element, type, func, capture) {
+  return element.removeEventListener(type, func, !!capture);
+},
+    _scrollLeft = "scrollLeft",
+    _scrollTop = "scrollTop",
+    _onScroll = function _onScroll() {
+  return _normalizer && _normalizer.isPressed || _scrollers.cache++;
+},
+    _scrollCacheFunc = function _scrollCacheFunc(f, doNotCache) {
+  var cachingFunc = function cachingFunc(value) {
+    // since reading the scrollTop/scrollLeft/pageOffsetY/pageOffsetX can trigger a layout, this function allows us to cache the value so it only gets read fresh after a "scroll" event fires (or while we're refreshing because that can lengthen the page and alter the scroll position). when "soft" is true, that means don't actually set the scroll, but cache the new value instead (useful in ScrollSmoother)
+    if (value || value === 0) {
+      _startup && (_win.history.scrollRestoration = "manual"); // otherwise the new position will get overwritten by the browser onload.
+
+      var isNormalizing = _normalizer && _normalizer.isPressed;
+      value = cachingFunc.v = Math.round(value) || (_normalizer && _normalizer.iOS ? 1 : 0); //TODO: iOS Bug: if you allow it to go to 0, Safari can start to report super strange (wildly inaccurate) touch positions!
+
+      f(value);
+      cachingFunc.cacheID = _scrollers.cache;
+      isNormalizing && _bridge("ss", value); // set scroll (notify ScrollTrigger so it can dispatch a "scrollStart" event if necessary
+    } else if (doNotCache || _scrollers.cache !== cachingFunc.cacheID || _bridge("ref")) {
+      cachingFunc.cacheID = _scrollers.cache;
+      cachingFunc.v = f();
+    }
+
+    return cachingFunc.v + cachingFunc.offset;
+  };
+
+  cachingFunc.offset = 0;
+  return f && cachingFunc;
+},
+    _horizontal = {
+  s: _scrollLeft,
+  p: "left",
+  p2: "Left",
+  os: "right",
+  os2: "Right",
+  d: "width",
+  d2: "Width",
+  a: "x",
+  sc: _scrollCacheFunc(function (value) {
+    return arguments.length ? _win.scrollTo(value, _vertical.sc()) : _win.pageXOffset || _doc[_scrollLeft] || _docEl[_scrollLeft] || _body[_scrollLeft] || 0;
+  })
+},
+    _vertical = {
+  s: _scrollTop,
+  p: "top",
+  p2: "Top",
+  os: "bottom",
+  os2: "Bottom",
+  d: "height",
+  d2: "Height",
+  a: "y",
+  op: _horizontal,
+  sc: _scrollCacheFunc(function (value) {
+    return arguments.length ? _win.scrollTo(_horizontal.sc(), value) : _win.pageYOffset || _doc[_scrollTop] || _docEl[_scrollTop] || _body[_scrollTop] || 0;
+  })
+},
+    _getTarget = function _getTarget(t, self) {
+  return (self && self._ctx && self._ctx.selector || gsap.utils.toArray)(t)[0] || (typeof t === "string" && gsap.config().nullTargetWarn !== false ? console.warn("Element not found:", t) : null);
+},
+    _isWithin = function _isWithin(element, list) {
+  // check if the element is in the list or is a descendant of an element in the list.
+  var i = list.length;
+
+  while (i--) {
+    if (list[i] === element || list[i].contains(element)) {
+      return true;
+    }
+  }
+
+  return false;
+},
+    _getScrollFunc = function _getScrollFunc(element, _ref) {
+  var s = _ref.s,
+      sc = _ref.sc;
+  // we store the scroller functions in an alternating sequenced Array like [element, verticalScrollFunc, horizontalScrollFunc, ...] so that we can minimize memory, maximize performance, and we also record the last position as a ".rec" property in order to revert to that after refreshing to ensure things don't shift around.
+  _isViewport(element) && (element = _doc.scrollingElement || _docEl);
+
+  var i = _scrollers.indexOf(element),
+      offset = sc === _vertical.sc ? 1 : 2;
+
+  !~i && (i = _scrollers.push(element) - 1);
+  _scrollers[i + offset] || _addListener(element, "scroll", _onScroll); // clear the cache when a scroll occurs
+
+  var prev = _scrollers[i + offset],
+      func = prev || (_scrollers[i + offset] = _scrollCacheFunc(_getProxyProp(element, s), true) || (_isViewport(element) ? sc : _scrollCacheFunc(function (value) {
+    return arguments.length ? element[s] = value : element[s];
+  })));
+  func.target = element;
+  prev || (func.smooth = gsap.getProperty(element, "scrollBehavior") === "smooth"); // only set it the first time (don't reset every time a scrollFunc is requested because perhaps it happens during a refresh() when it's disabled in ScrollTrigger.
+
+  return func;
+},
+    _getVelocityProp = function _getVelocityProp(value, minTimeRefresh, useDelta) {
+  var v1 = value,
+      v2 = value,
+      t1 = _getTime(),
+      t2 = t1,
+      min = minTimeRefresh || 50,
+      dropToZeroTime = Math.max(500, min * 3),
+      update = function update(value, force) {
+    var t = _getTime();
+
+    if (force || t - t1 > min) {
+      v2 = v1;
+      v1 = value;
+      t2 = t1;
+      t1 = t;
+    } else if (useDelta) {
+      v1 += value;
+    } else {
+      // not totally necessary, but makes it a bit more accurate by adjusting the v1 value according to the new slope. This way we're not just ignoring the incoming data. Removing for now because it doesn't seem to make much practical difference and it's probably not worth the kb.
+      v1 = v2 + (value - v2) / (t - t2) * (t1 - t2);
+    }
+  },
+      reset = function reset() {
+    v2 = v1 = useDelta ? 0 : v1;
+    t2 = t1 = 0;
+  },
+      getVelocity = function getVelocity(latestValue) {
+    var tOld = t2,
+        vOld = v2,
+        t = _getTime();
+
+    (latestValue || latestValue === 0) && latestValue !== v1 && update(latestValue);
+    return t1 === t2 || t - t2 > dropToZeroTime ? 0 : (v1 + (useDelta ? vOld : -vOld)) / ((useDelta ? t : t1) - tOld) * 1000;
+  };
+
+  return {
+    update: update,
+    reset: reset,
+    getVelocity: getVelocity
+  };
+},
+    _getEvent = function _getEvent(e, preventDefault) {
+  preventDefault && !e._gsapAllow && e.preventDefault();
+  return e.changedTouches ? e.changedTouches[0] : e;
+},
+    _getAbsoluteMax = function _getAbsoluteMax(a) {
+  var max = Math.max.apply(Math, a),
+      min = Math.min.apply(Math, a);
+  return Math.abs(max) >= Math.abs(min) ? max : min;
+},
+    _setScrollTrigger = function _setScrollTrigger() {
+  ScrollTrigger = gsap.core.globals().ScrollTrigger;
+  ScrollTrigger && ScrollTrigger.core && _integrate();
+},
+    _initCore = function _initCore(core) {
+  gsap = core || _getGSAP();
+
+  if (!_coreInitted && gsap && typeof document !== "undefined" && document.body) {
+    _win = window;
+    _doc = document;
+    _docEl = _doc.documentElement;
+    _body = _doc.body;
+    _root = [_win, _doc, _docEl, _body];
+    _clamp = gsap.utils.clamp;
+
+    _context = gsap.core.context || function () {};
+
+    _pointerType = "onpointerenter" in _body ? "pointer" : "mouse"; // isTouch is 0 if no touch, 1 if ONLY touch, and 2 if it can accommodate touch but also other types like mouse/pointer.
+
+    _isTouch = Observer.isTouch = _win.matchMedia && _win.matchMedia("(hover: none), (pointer: coarse)").matches ? 1 : "ontouchstart" in _win || navigator.maxTouchPoints > 0 || navigator.msMaxTouchPoints > 0 ? 2 : 0;
+    _eventTypes = Observer.eventTypes = ("ontouchstart" in _docEl ? "touchstart,touchmove,touchcancel,touchend" : !("onpointerdown" in _docEl) ? "mousedown,mousemove,mouseup,mouseup" : "pointerdown,pointermove,pointercancel,pointerup").split(",");
+    setTimeout(function () {
+      return _startup = 0;
+    }, 500);
+
+    _setScrollTrigger();
+
+    _coreInitted = 1;
+  }
+
+  return _coreInitted;
+};
+
+_horizontal.op = _vertical;
+_scrollers.cache = 0;
+export var Observer = /*#__PURE__*/function () {
+  function Observer(vars) {
+    this.init(vars);
+  }
+
+  var _proto = Observer.prototype;
+
+  _proto.init = function init(vars) {
+    _coreInitted || _initCore(gsap) || console.warn("Please gsap.registerPlugin(Observer)");
+    ScrollTrigger || _setScrollTrigger();
+    var tolerance = vars.tolerance,
+        dragMinimum = vars.dragMinimum,
+        type = vars.type,
+        target = vars.target,
+        lineHeight = vars.lineHeight,
+        debounce = vars.debounce,
+        preventDefault = vars.preventDefault,
+        onStop = vars.onStop,
+        onStopDelay = vars.onStopDelay,
+        ignore = vars.ignore,
+        wheelSpeed = vars.wheelSpeed,
+        event = vars.event,
+        onDragStart = vars.onDragStart,
+        onDragEnd = vars.onDragEnd,
+        onDrag = vars.onDrag,
+        onPress = vars.onPress,
+        onRelease = vars.onRelease,
+        onRight = vars.onRight,
+        onLeft = vars.onLeft,
+        onUp = vars.onUp,
+        onDown = vars.onDown,
+        onChangeX = vars.onChangeX,
+        onChangeY = vars.onChangeY,
+        onChange = vars.onChange,
+        onToggleX = vars.onToggleX,
+        onToggleY = vars.onToggleY,
+        onHover = vars.onHover,
+        onHoverEnd = vars.onHoverEnd,
+        onMove = vars.onMove,
+        ignoreCheck = vars.ignoreCheck,
+        isNormalizer = vars.isNormalizer,
+        onGestureStart = vars.onGestureStart,
+        onGestureEnd = vars.onGestureEnd,
+        onWheel = vars.onWheel,
+        onEnable = vars.onEnable,
+        onDisable = vars.onDisable,
+        onClick = vars.onClick,
+        scrollSpeed = vars.scrollSpeed,
+        capture = vars.capture,
+        allowClicks = vars.allowClicks,
+        lockAxis = vars.lockAxis,
+        onLockAxis = vars.onLockAxis;
+    this.target = target = _getTarget(target) || _docEl;
+    this.vars = vars;
+    ignore && (ignore = gsap.utils.toArray(ignore));
+    tolerance = tolerance || 1e-9;
+    dragMinimum = dragMinimum || 0;
+    wheelSpeed = wheelSpeed || 1;
+    scrollSpeed = scrollSpeed || 1;
+    type = type || "wheel,touch,pointer";
+    debounce = debounce !== false;
+    lineHeight || (lineHeight = parseFloat(_win.getComputedStyle(_body).lineHeight) || 22); // note: browser may report "normal", so default to 22.
+
+    var id,
+        onStopDelayedCall,
+        dragged,
+        moved,
+        wheeled,
+        locked,
+        axis,
+        self = this,
+        prevDeltaX = 0,
+        prevDeltaY = 0,
+        passive = vars.passive || !preventDefault && vars.passive !== false,
+        scrollFuncX = _getScrollFunc(target, _horizontal),
+        scrollFuncY = _getScrollFunc(target, _vertical),
+        scrollX = scrollFuncX(),
+        scrollY = scrollFuncY(),
+        limitToTouch = ~type.indexOf("touch") && !~type.indexOf("pointer") && _eventTypes[0] === "pointerdown",
+        // for devices that accommodate mouse events and touch events, we need to distinguish.
+    isViewport = _isViewport(target),
+        ownerDoc = target.ownerDocument || _doc,
+        deltaX = [0, 0, 0],
+        // wheel, scroll, pointer/touch
+    deltaY = [0, 0, 0],
+        onClickTime = 0,
+        clickCapture = function clickCapture() {
+      return onClickTime = _getTime();
+    },
+        _ignoreCheck = function _ignoreCheck(e, isPointerOrTouch) {
+      return (self.event = e) && ignore && _isWithin(e.target, ignore) || isPointerOrTouch && limitToTouch && e.pointerType !== "touch" || ignoreCheck && ignoreCheck(e, isPointerOrTouch);
+    },
+        onStopFunc = function onStopFunc() {
+      self._vx.reset();
+
+      self._vy.reset();
+
+      onStopDelayedCall.pause();
+      onStop && onStop(self);
+    },
+        update = function update() {
+      var dx = self.deltaX = _getAbsoluteMax(deltaX),
+          dy = self.deltaY = _getAbsoluteMax(deltaY),
+          changedX = Math.abs(dx) >= tolerance,
+          changedY = Math.abs(dy) >= tolerance;
+
+      onChange && (changedX || changedY) && onChange(self, dx, dy, deltaX, deltaY); // in ScrollTrigger.normalizeScroll(), we need to know if it was touch/pointer so we need access to the deltaX/deltaY Arrays before we clear them out.
+
+      if (changedX) {
+        onRight && self.deltaX > 0 && onRight(self);
+        onLeft && self.deltaX < 0 && onLeft(self);
+        onChangeX && onChangeX(self);
+        onToggleX && self.deltaX < 0 !== prevDeltaX < 0 && onToggleX(self);
+        prevDeltaX = self.deltaX;
+        deltaX[0] = deltaX[1] = deltaX[2] = 0;
+      }
+
+      if (changedY) {
+        onDown && self.deltaY > 0 && onDown(self);
+        onUp && self.deltaY < 0 && onUp(self);
+        onChangeY && onChangeY(self);
+        onToggleY && self.deltaY < 0 !== prevDeltaY < 0 && onToggleY(self);
+        prevDeltaY = self.deltaY;
+        deltaY[0] = deltaY[1] = deltaY[2] = 0;
+      }
+
+      if (moved || dragged) {
+        onMove && onMove(self);
+
+        if (dragged) {
+          onDragStart && dragged === 1 && onDragStart(self);
+          onDrag && onDrag(self);
+          dragged = 0;
+        }
+
+        moved = false;
+      }
+
+      locked && !(locked = false) && onLockAxis && onLockAxis(self);
+
+      if (wheeled) {
+        onWheel(self);
+        wheeled = false;
+      }
+
+      id = 0;
+    },
+        onDelta = function onDelta(x, y, index) {
+      deltaX[index] += x;
+      deltaY[index] += y;
+
+      self._vx.update(x);
+
+      self._vy.update(y);
+
+      debounce ? id || (id = requestAnimationFrame(update)) : update();
+    },
+        onTouchOrPointerDelta = function onTouchOrPointerDelta(x, y) {
+      if (lockAxis && !axis) {
+        self.axis = axis = Math.abs(x) > Math.abs(y) ? "x" : "y";
+        locked = true;
+      }
+
+      if (axis !== "y") {
+        deltaX[2] += x;
+
+        self._vx.update(x, true); // update the velocity as frequently as possible instead of in the debounced function so that very quick touch-scrolls (flicks) feel natural. If it's the mouse/touch/pointer, force it so that we get snappy/accurate momentum scroll.
+
+      }
+
+      if (axis !== "x") {
+        deltaY[2] += y;
+
+        self._vy.update(y, true);
+      }
+
+      debounce ? id || (id = requestAnimationFrame(update)) : update();
+    },
+        _onDrag = function _onDrag(e) {
+      if (_ignoreCheck(e, 1)) {
+        return;
+      }
+
+      e = _getEvent(e, preventDefault);
+      var x = e.clientX,
+          y = e.clientY,
+          dx = x - self.x,
+          dy = y - self.y,
+          isDragging = self.isDragging;
+      self.x = x;
+      self.y = y;
+
+      if (isDragging || (dx || dy) && (Math.abs(self.startX - x) >= dragMinimum || Math.abs(self.startY - y) >= dragMinimum)) {
+        dragged = isDragging ? 2 : 1; // dragged: 0 = not dragging, 1 = first drag, 2 = normal drag
+
+        isDragging || (self.isDragging = true);
+        onTouchOrPointerDelta(dx, dy);
+      }
+    },
+        _onPress = self.onPress = function (e) {
+      if (_ignoreCheck(e, 1) || e && e.button) {
+        return;
+      }
+
+      self.axis = axis = null;
+      onStopDelayedCall.pause();
+      self.isPressed = true;
+      e = _getEvent(e); // note: may need to preventDefault(?) Won't side-scroll on iOS Safari if we do, though.
+
+      prevDeltaX = prevDeltaY = 0;
+      self.startX = self.x = e.clientX;
+      self.startY = self.y = e.clientY;
+
+      self._vx.reset(); // otherwise the t2 may be stale if the user touches and flicks super fast and releases in less than 2 requestAnimationFrame ticks, causing velocity to be 0.
+
+
+      self._vy.reset();
+
+      _addListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, passive, true);
+
+      self.deltaX = self.deltaY = 0;
+      onPress && onPress(self);
+    },
+        _onRelease = self.onRelease = function (e) {
+      if (_ignoreCheck(e, 1)) {
+        return;
+      }
+
+      _removeListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, true);
+
+      var isTrackingDrag = !isNaN(self.y - self.startY),
+          wasDragging = self.isDragging,
+          isDragNotClick = wasDragging && (Math.abs(self.x - self.startX) > 3 || Math.abs(self.y - self.startY) > 3),
+          // some touch devices need some wiggle room in terms of sensing clicks - the finger may move a few pixels.
+      eventData = _getEvent(e);
+
+      if (!isDragNotClick && isTrackingDrag) {
+        self._vx.reset();
+
+        self._vy.reset(); //if (preventDefault && allowClicks && self.isPressed) { // check isPressed because in a rare edge case, the inputObserver in ScrollTrigger may stopPropagation() on the press/drag, so the onRelease may get fired without the onPress/onDrag ever getting called, thus it could trigger a click to occur on a link after scroll-dragging it.
+
+
+        if (preventDefault && allowClicks) {
+          gsap.delayedCall(0.08, function () {
+            // some browsers (like Firefox) won't trust script-generated clicks, so if the user tries to click on a video to play it, for example, it simply won't work. Since a regular "click" event will most likely be generated anyway (one that has its isTrusted flag set to true), we must slightly delay our script-generated click so that the "real"/trusted one is prioritized. Remember, when there are duplicate events in quick succession, we suppress all but the first one. Some browsers don't even trigger the "real" one at all, so our synthetic one is a safety valve that ensures that no matter what, a click event does get dispatched.
+            if (_getTime() - onClickTime > 300 && !e.defaultPrevented) {
+              if (e.target.click) {
+                //some browsers (like mobile Safari) don't properly trigger the click event
+                e.target.click();
+              } else if (ownerDoc.createEvent) {
+                var syntheticEvent = ownerDoc.createEvent("MouseEvents");
+                syntheticEvent.initMouseEvent("click", true, true, _win, 1, eventData.screenX, eventData.screenY, eventData.clientX, eventData.clientY, false, false, false, false, 0, null);
+                e.target.dispatchEvent(syntheticEvent);
+              }
+            }
+          });
+        }
+      }
+
+      self.isDragging = self.isGesturing = self.isPressed = false;
+      onStop && wasDragging && !isNormalizer && onStopDelayedCall.restart(true);
+      dragged && update(); // in case debouncing, we don't want onDrag to fire AFTER onDragEnd().
+
+      onDragEnd && wasDragging && onDragEnd(self);
+      onRelease && onRelease(self, isDragNotClick);
+    },
+        _onGestureStart = function _onGestureStart(e) {
+      return e.touches && e.touches.length > 1 && (self.isGesturing = true) && onGestureStart(e, self.isDragging);
+    },
+        _onGestureEnd = function _onGestureEnd() {
+      return (self.isGesturing = false) || onGestureEnd(self);
+    },
+        onScroll = function onScroll(e) {
+      if (_ignoreCheck(e)) {
+        return;
+      }
+
+      var x = scrollFuncX(),
+          y = scrollFuncY();
+      onDelta((x - scrollX) * scrollSpeed, (y - scrollY) * scrollSpeed, 1);
+      scrollX = x;
+      scrollY = y;
+      onStop && onStopDelayedCall.restart(true);
+    },
+        _onWheel = function _onWheel(e) {
+      if (_ignoreCheck(e)) {
+        return;
+      }
+
+      e = _getEvent(e, preventDefault);
+      onWheel && (wheeled = true);
+      var multiplier = (e.deltaMode === 1 ? lineHeight : e.deltaMode === 2 ? _win.innerHeight : 1) * wheelSpeed;
+      onDelta(e.deltaX * multiplier, e.deltaY * multiplier, 0);
+      onStop && !isNormalizer && onStopDelayedCall.restart(true);
+    },
+        _onMove = function _onMove(e) {
+      if (_ignoreCheck(e)) {
+        return;
+      }
+
+      var x = e.clientX,
+          y = e.clientY,
+          dx = x - self.x,
+          dy = y - self.y;
+      self.x = x;
+      self.y = y;
+      moved = true;
+      onStop && onStopDelayedCall.restart(true);
+      (dx || dy) && onTouchOrPointerDelta(dx, dy);
+    },
+        _onHover = function _onHover(e) {
+      self.event = e;
+      onHover(self);
+    },
+        _onHoverEnd = function _onHoverEnd(e) {
+      self.event = e;
+      onHoverEnd(self);
+    },
+        _onClick = function _onClick(e) {
+      return _ignoreCheck(e) || _getEvent(e, preventDefault) && onClick(self);
+    };
+
+    onStopDelayedCall = self._dc = gsap.delayedCall(onStopDelay || 0.25, onStopFunc).pause();
+    self.deltaX = self.deltaY = 0;
+    self._vx = _getVelocityProp(0, 50, true);
+    self._vy = _getVelocityProp(0, 50, true);
+    self.scrollX = scrollFuncX;
+    self.scrollY = scrollFuncY;
+    self.isDragging = self.isGesturing = self.isPressed = false;
+
+    _context(this);
+
+    self.enable = function (e) {
+      if (!self.isEnabled) {
+        _addListener(isViewport ? ownerDoc : target, "scroll", _onScroll);
+
+        type.indexOf("scroll") >= 0 && _addListener(isViewport ? ownerDoc : target, "scroll", onScroll, passive, capture);
+        type.indexOf("wheel") >= 0 && _addListener(target, "wheel", _onWheel, passive, capture);
+
+        if (type.indexOf("touch") >= 0 && _isTouch || type.indexOf("pointer") >= 0) {
+          _addListener(target, _eventTypes[0], _onPress, passive, capture);
+
+          _addListener(ownerDoc, _eventTypes[2], _onRelease);
+
+          _addListener(ownerDoc, _eventTypes[3], _onRelease);
+
+          allowClicks && _addListener(target, "click", clickCapture, true, true);
+          onClick && _addListener(target, "click", _onClick);
+          onGestureStart && _addListener(ownerDoc, "gesturestart", _onGestureStart);
+          onGestureEnd && _addListener(ownerDoc, "gestureend", _onGestureEnd);
+          onHover && _addListener(target, _pointerType + "enter", _onHover);
+          onHoverEnd && _addListener(target, _pointerType + "leave", _onHoverEnd);
+          onMove && _addListener(target, _pointerType + "move", _onMove);
+        }
+
+        self.isEnabled = true;
+        self.isDragging = self.isGesturing = self.isPressed = moved = dragged = false;
+
+        self._vx.reset();
+
+        self._vy.reset();
+
+        scrollX = scrollFuncX();
+        scrollY = scrollFuncY();
+        e && e.type && _onPress(e);
+        onEnable && onEnable(self);
+      }
+
+      return self;
+    };
+
+    self.disable = function () {
+      if (self.isEnabled) {
+        // only remove the _onScroll listener if there aren't any others that rely on the functionality.
+        _observers.filter(function (o) {
+          return o !== self && _isViewport(o.target);
+        }).length || _removeListener(isViewport ? ownerDoc : target, "scroll", _onScroll);
+
+        if (self.isPressed) {
+          self._vx.reset();
+
+          self._vy.reset();
+
+          _removeListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, true);
+        }
+
+        _removeListener(isViewport ? ownerDoc : target, "scroll", onScroll, capture);
+
+        _removeListener(target, "wheel", _onWheel, capture);
+
+        _removeListener(target, _eventTypes[0], _onPress, capture);
+
+        _removeListener(ownerDoc, _eventTypes[2], _onRelease);
+
+        _removeListener(ownerDoc, _eventTypes[3], _onRelease);
+
+        _removeListener(target, "click", clickCapture, true);
+
+        _removeListener(target, "click", _onClick);
+
+        _removeListener(ownerDoc, "gesturestart", _onGestureStart);
+
+        _removeListener(ownerDoc, "gestureend", _onGestureEnd);
+
+        _removeListener(target, _pointerType + "enter", _onHover);
+
+        _removeListener(target, _pointerType + "leave", _onHoverEnd);
+
+        _removeListener(target, _pointerType + "move", _onMove);
+
+        self.isEnabled = self.isPressed = self.isDragging = false;
+        onDisable && onDisable(self);
+      }
+    };
+
+    self.kill = self.revert = function () {
+      self.disable();
+
+      var i = _observers.indexOf(self);
+
+      i >= 0 && _observers.splice(i, 1);
+      _normalizer === self && (_normalizer = 0);
+    };
+
+    _observers.push(self);
+
+    isNormalizer && _isViewport(target) && (_normalizer = self);
+    self.enable(event);
+  };
+
+  _createClass(Observer, [{
+    key: "velocityX",
+    get: function get() {
+      return this._vx.getVelocity();
+    }
+  }, {
+    key: "velocityY",
+    get: function get() {
+      return this._vy.getVelocity();
+    }
+  }]);
+
+  return Observer;
+}();
+Observer.version = "3.13.0";
+
+Observer.create = function (vars) {
+  return new Observer(vars);
+};
+
+Observer.register = _initCore;
+
+Observer.getAll = function () {
+  return _observers.slice();
+};
+
+Observer.getById = function (id) {
+  return _observers.filter(function (o) {
+    return o.vars.id === id;
+  })[0];
+};
+
+_getGSAP() && gsap.registerPlugin(Observer);
+export { Observer as default, _isViewport, _scrollers, _getScrollFunc, _getProxyProp, _proxies, _getVelocityProp, _vertical, _horizontal, _getTarget };

network-visualization/node_modules/gsap/Physics2DPlugin.js

@@ -0,0 +1,173 @@
+/*!
+ * Physics2DPlugin 3.13.0
+ * https://gsap.com
+ *
+ * @license Copyright 2008-2025, GreenSock. All rights reserved.
+ * Subject to the terms at https://gsap.com/standard-license
+ * @author: Jack Doyle, jack@greensock.com
+*/
+
+/* eslint-disable */
+var gsap,
+    _coreInitted,
+    _getUnit,
+    _getStyleSaver,
+    _reverting,
+    _DEG2RAD = Math.PI / 180,
+    _getGSAP = function _getGSAP() {
+  return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+},
+    _round = function _round(value) {
+  return Math.round(value * 10000) / 10000;
+},
+    _bonusValidated = 1,
+    //<name>Physics2DPlugin</name>
+_initCore = function _initCore(core) {
+  gsap = core || _getGSAP();
+
+  if (!_coreInitted) {
+    _getUnit = gsap.utils.getUnit;
+    _getStyleSaver = gsap.core.getStyleSaver;
+
+    _reverting = gsap.core.reverting || function () {};
+
+    _coreInitted = 1;
+  }
+};
+
+var PhysicsProp = function PhysicsProp(target, p, velocity, acceleration, stepsPerTimeUnit) {
+  var cache = target._gsap,
+      curVal = cache.get(target, p);
+  this.p = p;
+  this.set = cache.set(target, p); //setter
+
+  this.s = this.val = parseFloat(curVal);
+  this.u = _getUnit(curVal) || 0;
+  this.vel = velocity || 0;
+  this.v = this.vel / stepsPerTimeUnit;
+
+  if (acceleration || acceleration === 0) {
+    this.acc = acceleration;
+    this.a = this.acc / (stepsPerTimeUnit * stepsPerTimeUnit);
+  } else {
+    this.acc = this.a = 0;
+  }
+};
+
+export var Physics2DPlugin = {
+  version: "3.13.0",
+  name: "physics2D",
+  register: _initCore,
+  init: function init(target, value, tween) {
+    _coreInitted || _initCore();
+    var data = this,
+        angle = +value.angle || 0,
+        velocity = +value.velocity || 0,
+        acceleration = +value.acceleration || 0,
+        xProp = value.xProp || "x",
+        yProp = value.yProp || "y",
+        aAngle = value.accelerationAngle || value.accelerationAngle === 0 ? +value.accelerationAngle : angle;
+    data.styles = _getStyleSaver && _getStyleSaver(target, value.xProp && value.xProp !== "x" ? value.xProp + "," + value.yProp : "transform");
+    data.target = target;
+    data.tween = tween;
+    data.step = 0;
+    data.sps = 30; //steps per second
+
+    if (value.gravity) {
+      acceleration = +value.gravity;
+      aAngle = 90;
+    }
+
+    angle *= _DEG2RAD;
+    aAngle *= _DEG2RAD;
+    data.fr = 1 - (+value.friction || 0);
+
+    data._props.push(xProp, yProp);
+
+    data.xp = new PhysicsProp(target, xProp, Math.cos(angle) * velocity, Math.cos(aAngle) * acceleration, data.sps);
+    data.yp = new PhysicsProp(target, yProp, Math.sin(angle) * velocity, Math.sin(aAngle) * acceleration, data.sps);
+    data.skipX = data.skipY = 0;
+  },
+  render: function render(ratio, data) {
+    var xp = data.xp,
+        yp = data.yp,
+        tween = data.tween,
+        target = data.target,
+        step = data.step,
+        sps = data.sps,
+        fr = data.fr,
+        skipX = data.skipX,
+        skipY = data.skipY,
+        time = tween._from ? tween._dur - tween._time : tween._time,
+        x,
+        y,
+        tt,
+        steps,
+        remainder,
+        i;
+
+    if (tween._time || !_reverting()) {
+      if (fr === 1) {
+        tt = time * time * 0.5;
+        x = xp.s + xp.vel * time + xp.acc * tt;
+        y = yp.s + yp.vel * time + yp.acc * tt;
+      } else {
+        time *= sps;
+        steps = i = (time | 0) - step;
+        /*
+        Note: rounding errors build up if we walk the calculations backward which we used to do like this to maximize performance:
+        	i = -i;
+        	while (i--) {
+        		xp.val -= xp.v;
+        		yp.val -= yp.v;
+        		xp.v /= fr;
+        		yp.v /= fr;
+        		xp.v -= xp.a;
+        		yp.v -= yp.a;
+        	}
+        but now for the sake of accuracy (to ensure rewinding always goes back to EXACTLY the same spot), we force the calculations to go forward every time. So if the tween is going backward, we just start from the beginning and iterate. This is only necessary with friction.
+         */
+
+        if (i < 0) {
+          xp.v = xp.vel / sps;
+          yp.v = yp.vel / sps;
+          xp.val = xp.s;
+          yp.val = yp.s;
+          data.step = 0;
+          steps = i = time | 0;
+        }
+
+        remainder = time % 1 * fr;
+
+        while (i--) {
+          xp.v += xp.a;
+          yp.v += yp.a;
+          xp.v *= fr;
+          yp.v *= fr;
+          xp.val += xp.v;
+          yp.val += yp.v;
+        }
+
+        x = xp.val + xp.v * remainder;
+        y = yp.val + yp.v * remainder;
+        data.step += steps;
+      }
+
+      skipX || xp.set(target, xp.p, _round(x) + xp.u);
+      skipY || yp.set(target, yp.p, _round(y) + yp.u);
+    } else {
+      data.styles.revert();
+    }
+  },
+  kill: function kill(property) {
+    if (this.xp.p === property) {
+      this.skipX = 1;
+    }
+
+    if (this.yp.p === property) {
+      this.skipY = 1;
+    }
+  }
+};
+_getGSAP() && gsap.registerPlugin(Physics2DPlugin);
+export { Physics2DPlugin as default };

network-visualization/node_modules/gsap/PhysicsPropsPlugin.js

@@ -0,0 +1,174 @@
+/*!
+ * PhysicsPropsPlugin 3.13.0
+ * https://gsap.com
+ *
+ * @license Copyright 2008-2025, GreenSock. All rights reserved.
+ * Subject to the terms at https://gsap.com/standard-license
+ * @author: Jack Doyle, jack@greensock.com
+*/
+
+/* eslint-disable */
+var gsap,
+    _coreInitted,
+    _getUnit,
+    _getStyleSaver,
+    _reverting,
+    _getGSAP = function _getGSAP() {
+  return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+},
+    _round = function _round(value) {
+  return Math.round(value * 10000) / 10000;
+},
+    _bonusValidated = 1,
+    //<name>PhysicsPropsPlugin</name>
+_initCore = function _initCore(core) {
+  gsap = core || _getGSAP();
+
+  if (!_coreInitted) {
+    _getUnit = gsap.utils.getUnit;
+    _getStyleSaver = gsap.core.getStyleSaver;
+
+    _reverting = gsap.core.reverting || function () {};
+
+    _coreInitted = 1;
+  }
+};
+
+var PhysicsProp = function PhysicsProp(target, p, velocity, acceleration, friction, stepsPerTimeUnit) {
+  var cache = target._gsap,
+      curVal = cache.get(target, p);
+  this.p = p;
+  this.set = cache.set(target, p); //setter
+
+  this.s = this.val = parseFloat(curVal);
+  this.u = _getUnit(curVal) || 0;
+  this.vel = velocity || 0;
+  this.v = this.vel / stepsPerTimeUnit;
+
+  if (acceleration || acceleration === 0) {
+    this.acc = acceleration;
+    this.a = this.acc / (stepsPerTimeUnit * stepsPerTimeUnit);
+  } else {
+    this.acc = this.a = 0;
+  }
+
+  this.fr = 1 - (friction || 0);
+};
+
+export var PhysicsPropsPlugin = {
+  version: "3.13.0",
+  name: "physicsProps",
+  register: _initCore,
+  init: function init(target, value, tween) {
+    _coreInitted || _initCore();
+    var data = this,
+        p;
+    data.styles = _getStyleSaver && _getStyleSaver(target);
+    data.target = target;
+    data.tween = tween;
+    data.step = 0;
+    data.sps = 30; //steps per second
+
+    data.vProps = [];
+
+    for (p in value) {
+      var _value$p = value[p],
+          velocity = _value$p.velocity,
+          acceleration = _value$p.acceleration,
+          friction = _value$p.friction;
+
+      if (velocity || acceleration) {
+        data.vProps.push(new PhysicsProp(target, p, velocity, acceleration, friction, data.sps));
+
+        data._props.push(p);
+
+        _getStyleSaver && data.styles.save(p);
+        friction && (data.hasFr = 1);
+      }
+    }
+  },
+  render: function render(ratio, data) {
+    var vProps = data.vProps,
+        tween = data.tween,
+        target = data.target,
+        step = data.step,
+        hasFr = data.hasFr,
+        sps = data.sps,
+        i = vProps.length,
+        time = tween._from ? tween._dur - tween._time : tween._time,
+        curProp,
+        steps,
+        remainder,
+        j,
+        tt;
+
+    if (tween._time || !_reverting()) {
+      if (hasFr) {
+        time *= sps;
+        steps = (time | 0) - step;
+        /*
+        Note: rounding errors build up if we walk the calculations backward which we used to do like this to maximize performance:
+        while (i--) {
+        	curProp = vProps[i];
+        	j = -steps;
+        	while (j--) {
+        		curProp.val -= curProp.v;
+        		curProp.v /= curProp.fr;
+        		curProp.v -= curProp.a;
+        	}
+        	curProp.set(target, curProp.p, _round(curProp.val + (curProp.v * remainder * curProp.fr)) + curProp.u);
+        }
+        but now for the sake of accuracy (to ensure rewinding always goes back to EXACTLY the same spot), we force the calculations to go forward every time. So if the tween is going backward, we just start from the beginning and iterate. This is only necessary with friction.
+         */
+
+        if (steps < 0) {
+          while (i--) {
+            curProp = vProps[i];
+            curProp.v = curProp.vel / sps;
+            curProp.val = curProp.s;
+          }
+
+          i = vProps.length;
+          data.step = step = 0;
+          steps = time | 0;
+        }
+
+        remainder = time % 1;
+
+        while (i--) {
+          curProp = vProps[i];
+          j = steps;
+
+          while (j--) {
+            curProp.v += curProp.a;
+            curProp.v *= curProp.fr;
+            curProp.val += curProp.v;
+          }
+
+          curProp.set(target, curProp.p, _round(curProp.val + curProp.v * remainder * curProp.fr) + curProp.u);
+        }
+
+        data.step += steps;
+      } else {
+        tt = time * time * 0.5;
+
+        while (i--) {
+          curProp = vProps[i];
+          curProp.set(target, curProp.p, _round(curProp.s + curProp.vel * time + curProp.acc * tt) + curProp.u);
+        }
+      }
+    } else {
+      data.styles.revert();
+    }
+  },
+  kill: function kill(property) {
+    var vProps = this.vProps,
+        i = vProps.length;
+
+    while (i--) {
+      vProps[i].p === property && vProps.splice(i, 1);
+    }
+  }
+};
+_getGSAP() && gsap.registerPlugin(PhysicsPropsPlugin);
+export { PhysicsPropsPlugin as default };

network-visualization/node_modules/gsap/PixiPlugin.js

@@ -0,0 +1,473 @@
+/*!
+ * PixiPlugin 3.13.0
+ * https://gsap.com
+ *
+ * @license Copyright 2008-2025, GreenSock. All rights reserved.
+ * Subject to the terms at https://gsap.com/standard-license
+ * @author: Jack Doyle, jack@greensock.com
+*/
+
+/* eslint-disable */
+var gsap,
+    _splitColor,
+    _coreInitted,
+    _PIXI,
+    PropTween,
+    _getSetter,
+    _isV4,
+    _isV8Plus,
+    _windowExists = function _windowExists() {
+  return typeof window !== "undefined";
+},
+    _getGSAP = function _getGSAP() {
+  return gsap || _windowExists() && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+},
+    _isFunction = function _isFunction(value) {
+  return typeof value === "function";
+},
+    _warn = function _warn(message) {
+  return console.warn(message);
+},
+    _idMatrix = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0],
+    _lumR = 0.212671,
+    _lumG = 0.715160,
+    _lumB = 0.072169,
+    _filterClass = function _filterClass(name) {
+  return _isFunction(_PIXI[name]) ? _PIXI[name] : _PIXI.filters[name];
+},
+    // in PIXI 7.1, filters moved from PIXI.filters to just PIXI
+_applyMatrix = function _applyMatrix(m, m2) {
+  var temp = [],
+      i = 0,
+      z = 0,
+      y,
+      x;
+
+  for (y = 0; y < 4; y++) {
+    for (x = 0; x < 5; x++) {
+      z = x === 4 ? m[i + 4] : 0;
+      temp[i + x] = m[i] * m2[x] + m[i + 1] * m2[x + 5] + m[i + 2] * m2[x + 10] + m[i + 3] * m2[x + 15] + z;
+    }
+
+    i += 5;
+  }
+
+  return temp;
+},
+    _setSaturation = function _setSaturation(m, n) {
+  var inv = 1 - n,
+      r = inv * _lumR,
+      g = inv * _lumG,
+      b = inv * _lumB;
+  return _applyMatrix([r + n, g, b, 0, 0, r, g + n, b, 0, 0, r, g, b + n, 0, 0, 0, 0, 0, 1, 0], m);
+},
+    _colorize = function _colorize(m, color, amount) {
+  var c = _splitColor(color),
+      r = c[0] / 255,
+      g = c[1] / 255,
+      b = c[2] / 255,
+      inv = 1 - amount;
+
+  return _applyMatrix([inv + amount * r * _lumR, amount * r * _lumG, amount * r * _lumB, 0, 0, amount * g * _lumR, inv + amount * g * _lumG, amount * g * _lumB, 0, 0, amount * b * _lumR, amount * b * _lumG, inv + amount * b * _lumB, 0, 0, 0, 0, 0, 1, 0], m);
+},
+    _setHue = function _setHue(m, n) {
+  n *= Math.PI / 180;
+  var c = Math.cos(n),
+      s = Math.sin(n);
+  return _applyMatrix([_lumR + c * (1 - _lumR) + s * -_lumR, _lumG + c * -_lumG + s * -_lumG, _lumB + c * -_lumB + s * (1 - _lumB), 0, 0, _lumR + c * -_lumR + s * 0.143, _lumG + c * (1 - _lumG) + s * 0.14, _lumB + c * -_lumB + s * -0.283, 0, 0, _lumR + c * -_lumR + s * -(1 - _lumR), _lumG + c * -_lumG + s * _lumG, _lumB + c * (1 - _lumB) + s * _lumB, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1], m);
+},
+    _setContrast = function _setContrast(m, n) {
+  return _applyMatrix([n, 0, 0, 0, 0.5 * (1 - n), 0, n, 0, 0, 0.5 * (1 - n), 0, 0, n, 0, 0.5 * (1 - n), 0, 0, 0, 1, 0], m);
+},
+    _getFilter = function _getFilter(target, type) {
+  var filterClass = _filterClass(type),
+      filters = target.filters || [],
+      i = filters.length,
+      filter;
+
+  filterClass || _warn(type + " not found. PixiPlugin.registerPIXI(PIXI)");
+
+  while (--i > -1) {
+    if (filters[i] instanceof filterClass) {
+      return filters[i];
+    }
+  }
+
+  filter = new filterClass();
+
+  if (type === "BlurFilter") {
+    if (_isV8Plus) {
+      filter.strength = 0;
+    } else {
+      filter.blur = 0;
+    }
+  }
+
+  target.filters = [].concat(filters, [filter]);
+  return filter;
+},
+    _addColorMatrixFilterCacheTween = function _addColorMatrixFilterCacheTween(p, plugin, cache, vars) {
+  //we cache the ColorMatrixFilter components in a _gsColorMatrixFilter object attached to the target object so that it's easy to grab the current value at any time.
+  plugin.add(cache, p, cache[p], vars[p]);
+
+  plugin._props.push(p);
+},
+    _applyBrightnessToMatrix = function _applyBrightnessToMatrix(brightness, matrix) {
+  var filterClass = _filterClass("ColorMatrixFilter"),
+      temp = new filterClass();
+
+  temp.matrix = matrix;
+  temp.brightness(brightness, true);
+  return temp.matrix;
+},
+    _copy = function _copy(obj) {
+  var copy = {},
+      p;
+
+  for (p in obj) {
+    copy[p] = obj[p];
+  }
+
+  return copy;
+},
+    _CMFdefaults = {
+  contrast: 1,
+  saturation: 1,
+  colorizeAmount: 0,
+  colorize: "rgb(255,255,255)",
+  hue: 0,
+  brightness: 1
+},
+    _parseColorMatrixFilter = function _parseColorMatrixFilter(target, v, pg) {
+  var filter = _getFilter(target, "ColorMatrixFilter"),
+      cache = target._gsColorMatrixFilter = target._gsColorMatrixFilter || _copy(_CMFdefaults),
+      combine = v.combineCMF && !("colorMatrixFilter" in v && !v.colorMatrixFilter),
+      i,
+      matrix,
+      startMatrix;
+
+  startMatrix = filter.matrix;
+
+  if (v.resolution) {
+    filter.resolution = v.resolution;
+  }
+
+  if (v.matrix && v.matrix.length === startMatrix.length) {
+    matrix = v.matrix;
+
+    if (cache.contrast !== 1) {
+      _addColorMatrixFilterCacheTween("contrast", pg, cache, _CMFdefaults);
+    }
+
+    if (cache.hue) {
+      _addColorMatrixFilterCacheTween("hue", pg, cache, _CMFdefaults);
+    }
+
+    if (cache.brightness !== 1) {
+      _addColorMatrixFilterCacheTween("brightness", pg, cache, _CMFdefaults);
+    }
+
+    if (cache.colorizeAmount) {
+      _addColorMatrixFilterCacheTween("colorize", pg, cache, _CMFdefaults);
+
+      _addColorMatrixFilterCacheTween("colorizeAmount", pg, cache, _CMFdefaults);
+    }
+
+    if (cache.saturation !== 1) {
+      _addColorMatrixFilterCacheTween("saturation", pg, cache, _CMFdefaults);
+    }
+  } else {
+    matrix = _idMatrix.slice();
+
+    if (v.contrast != null) {
+      matrix = _setContrast(matrix, +v.contrast);
+
+      _addColorMatrixFilterCacheTween("contrast", pg, cache, v);
+    } else if (cache.contrast !== 1) {
+      if (combine) {
+        matrix = _setContrast(matrix, cache.contrast);
+      } else {
+        _addColorMatrixFilterCacheTween("contrast", pg, cache, _CMFdefaults);
+      }
+    }
+
+    if (v.hue != null) {
+      matrix = _setHue(matrix, +v.hue);
+
+      _addColorMatrixFilterCacheTween("hue", pg, cache, v);
+    } else if (cache.hue) {
+      if (combine) {
+        matrix = _setHue(matrix, cache.hue);
+      } else {
+        _addColorMatrixFilterCacheTween("hue", pg, cache, _CMFdefaults);
+      }
+    }
+
+    if (v.brightness != null) {
+      matrix = _applyBrightnessToMatrix(+v.brightness, matrix);
+
+      _addColorMatrixFilterCacheTween("brightness", pg, cache, v);
+    } else if (cache.brightness !== 1) {
+      if (combine) {
+        matrix = _applyBrightnessToMatrix(cache.brightness, matrix);
+      } else {
+        _addColorMatrixFilterCacheTween("brightness", pg, cache, _CMFdefaults);
+      }
+    }
+
+    if (v.colorize != null) {
+      v.colorizeAmount = "colorizeAmount" in v ? +v.colorizeAmount : 1;
+      matrix = _colorize(matrix, v.colorize, v.colorizeAmount);
+
+      _addColorMatrixFilterCacheTween("colorize", pg, cache, v);
+
+      _addColorMatrixFilterCacheTween("colorizeAmount", pg, cache, v);
+    } else if (cache.colorizeAmount) {
+      if (combine) {
+        matrix = _colorize(matrix, cache.colorize, cache.colorizeAmount);
+      } else {
+        _addColorMatrixFilterCacheTween("colorize", pg, cache, _CMFdefaults);
+
+        _addColorMatrixFilterCacheTween("colorizeAmount", pg, cache, _CMFdefaults);
+      }
+    }
+
+    if (v.saturation != null) {
+      matrix = _setSaturation(matrix, +v.saturation);
+
+      _addColorMatrixFilterCacheTween("saturation", pg, cache, v);
+    } else if (cache.saturation !== 1) {
+      if (combine) {
+        matrix = _setSaturation(matrix, cache.saturation);
+      } else {
+        _addColorMatrixFilterCacheTween("saturation", pg, cache, _CMFdefaults);
+      }
+    }
+  }
+
+  i = matrix.length;
+
+  while (--i > -1) {
+    if (matrix[i] !== startMatrix[i]) {
+      pg.add(startMatrix, i, startMatrix[i], matrix[i], "colorMatrixFilter");
+    }
+  }
+
+  pg._props.push("colorMatrixFilter");
+},
+    _renderColor = function _renderColor(ratio, _ref) {
+  var t = _ref.t,
+      p = _ref.p,
+      color = _ref.color,
+      set = _ref.set;
+  set(t, p, color[0] << 16 | color[1] << 8 | color[2]);
+},
+    _renderDirtyCache = function _renderDirtyCache(ratio, _ref2) {
+  var g = _ref2.g;
+
+  if (_isV8Plus) {
+    g.fill();
+    g.stroke();
+  } else if (g) {
+    // in order for PixiJS to actually redraw GraphicsData, we've gotta increment the "dirty" and "clearDirty" values. If we don't do this, the values will be tween properly, but not rendered.
+    g.dirty++;
+    g.clearDirty++;
+  }
+},
+    _renderAutoAlpha = function _renderAutoAlpha(ratio, data) {
+  data.t.visible = !!data.t.alpha;
+},
+    _addColorTween = function _addColorTween(target, p, value, plugin) {
+  var currentValue = target[p],
+      startColor = _splitColor(_isFunction(currentValue) ? target[p.indexOf("set") || !_isFunction(target["get" + p.substr(3)]) ? p : "get" + p.substr(3)]() : currentValue),
+      endColor = _splitColor(value);
+
+  plugin._pt = new PropTween(plugin._pt, target, p, 0, 0, _renderColor, {
+    t: target,
+    p: p,
+    color: startColor,
+    set: _getSetter(target, p)
+  });
+  plugin.add(startColor, 0, startColor[0], endColor[0]);
+  plugin.add(startColor, 1, startColor[1], endColor[1]);
+  plugin.add(startColor, 2, startColor[2], endColor[2]);
+},
+    _colorProps = {
+  tint: 1,
+  lineColor: 1,
+  fillColor: 1,
+  strokeColor: 1
+},
+    _xyContexts = "position,scale,skew,pivot,anchor,tilePosition,tileScale".split(","),
+    _contexts = {
+  x: "position",
+  y: "position",
+  tileX: "tilePosition",
+  tileY: "tilePosition"
+},
+    _colorMatrixFilterProps = {
+  colorMatrixFilter: 1,
+  saturation: 1,
+  contrast: 1,
+  hue: 1,
+  colorize: 1,
+  colorizeAmount: 1,
+  brightness: 1,
+  combineCMF: 1
+},
+    _DEG2RAD = Math.PI / 180,
+    _isString = function _isString(value) {
+  return typeof value === "string";
+},
+    _degreesToRadians = function _degreesToRadians(value) {
+  return _isString(value) && value.charAt(1) === "=" ? value.substr(0, 2) + parseFloat(value.substr(2)) * _DEG2RAD : value * _DEG2RAD;
+},
+    _renderPropWithEnd = function _renderPropWithEnd(ratio, data) {
+  return data.set(data.t, data.p, ratio === 1 ? data.e : Math.round((data.s + data.c * ratio) * 100000) / 100000, data);
+},
+    _addRotationalPropTween = function _addRotationalPropTween(plugin, target, property, startNum, endValue, radians) {
+  var cap = 360 * (radians ? _DEG2RAD : 1),
+      isString = _isString(endValue),
+      relative = isString && endValue.charAt(1) === "=" ? +(endValue.charAt(0) + "1") : 0,
+      endNum = parseFloat(relative ? endValue.substr(2) : endValue) * (radians ? _DEG2RAD : 1),
+      change = relative ? endNum * relative : endNum - startNum,
+      finalValue = startNum + change,
+      direction,
+      pt;
+
+  if (isString) {
+    direction = endValue.split("_")[1];
+
+    if (direction === "short") {
+      change %= cap;
+
+      if (change !== change % (cap / 2)) {
+        change += change < 0 ? cap : -cap;
+      }
+    }
+
+    if (direction === "cw" && change < 0) {
+      change = (change + cap * 1e10) % cap - ~~(change / cap) * cap;
+    } else if (direction === "ccw" && change > 0) {
+      change = (change - cap * 1e10) % cap - ~~(change / cap) * cap;
+    }
+  }
+
+  plugin._pt = pt = new PropTween(plugin._pt, target, property, startNum, change, _renderPropWithEnd);
+  pt.e = finalValue;
+  return pt;
+},
+    _initCore = function _initCore() {
+  if (!_coreInitted) {
+    gsap = _getGSAP();
+    _PIXI = _coreInitted = _PIXI || _windowExists() && window.PIXI;
+    var version = _PIXI && _PIXI.VERSION && parseFloat(_PIXI.VERSION.split(".")[0]) || 0;
+    _isV4 = version === 4;
+    _isV8Plus = version >= 8;
+
+    _splitColor = function _splitColor(color) {
+      return gsap.utils.splitColor((color + "").substr(0, 2) === "0x" ? "#" + color.substr(2) : color);
+    }; // some colors in PIXI are reported as "0xFF4421" instead of "#FF4421".
+
+  }
+},
+    i,
+    p; //context setup...
+
+
+for (i = 0; i < _xyContexts.length; i++) {
+  p = _xyContexts[i];
+  _contexts[p + "X"] = p;
+  _contexts[p + "Y"] = p;
+}
+
+export var PixiPlugin = {
+  version: "3.13.0",
+  name: "pixi",
+  register: function register(core, Plugin, propTween) {
+    gsap = core;
+    PropTween = propTween;
+    _getSetter = Plugin.getSetter;
+
+    _initCore();
+  },
+  headless: true,
+  // doesn't need window
+  registerPIXI: function registerPIXI(pixi) {
+    _PIXI = pixi;
+  },
+  init: function init(target, values, tween, index, targets) {
+    _PIXI || _initCore();
+
+    if (!_PIXI) {
+      _warn("PIXI was not found. PixiPlugin.registerPIXI(PIXI);");
+
+      return false;
+    }
+
+    var context, axis, value, colorMatrix, filter, p, padding, i, data, subProp;
+
+    for (p in values) {
+      context = _contexts[p];
+      value = values[p];
+
+      if (context) {
+        axis = ~p.charAt(p.length - 1).toLowerCase().indexOf("x") ? "x" : "y";
+        this.add(target[context], axis, target[context][axis], context === "skew" ? _degreesToRadians(value) : value, 0, 0, 0, 0, 0, 1);
+      } else if (p === "scale" || p === "anchor" || p === "pivot" || p === "tileScale") {
+        this.add(target[p], "x", target[p].x, value);
+        this.add(target[p], "y", target[p].y, value);
+      } else if (p === "rotation" || p === "angle") {
+        //PIXI expects rotation in radians, but as a convenience we let folks define it in degrees and we do the conversion.
+        _addRotationalPropTween(this, target, p, target[p], value, p === "rotation");
+      } else if (_colorMatrixFilterProps[p]) {
+        if (!colorMatrix) {
+          _parseColorMatrixFilter(target, values.colorMatrixFilter || values, this);
+
+          colorMatrix = true;
+        }
+      } else if (p === "blur" || p === "blurX" || p === "blurY" || p === "blurPadding") {
+        filter = _getFilter(target, "BlurFilter");
+        this.add(filter, p, filter[p], value);
+
+        if (values.blurPadding !== 0) {
+          padding = values.blurPadding || Math.max(filter[p], value) * 2;
+          i = target.filters.length;
+
+          while (--i > -1) {
+            target.filters[i].padding = Math.max(target.filters[i].padding, padding); //if we don't expand the padding on all the filters, it can look clipped.
+          }
+        }
+      } else if (_colorProps[p]) {
+        if ((p === "lineColor" || p === "fillColor" || p === "strokeColor") && target instanceof _PIXI.Graphics) {
+          data = "fillStyle" in target ? [target] : (target.geometry || target).graphicsData; //"geometry" was introduced in PIXI version 5
+
+          subProp = p.substr(0, p.length - 5);
+          _isV8Plus && subProp === "line" && (subProp = "stroke"); // in v8, lineColor became strokeColor.
+
+          this._pt = new PropTween(this._pt, target, p, 0, 0, _renderDirtyCache, {
+            g: target.geometry || target
+          });
+          i = data.length;
+
+          while (--i > -1) {
+            _addColorTween(_isV4 ? data[i] : data[i][subProp + "Style"], _isV4 ? p : "color", value, this);
+          }
+        } else {
+          _addColorTween(target, p, value, this);
+        }
+      } else if (p === "autoAlpha") {
+        this._pt = new PropTween(this._pt, target, "visible", 0, 0, _renderAutoAlpha);
+        this.add(target, "alpha", target.alpha, value);
+
+        this._props.push("alpha", "visible");
+      } else if (p !== "resolution") {
+        this.add(target, p, "get", value);
+      }
+
+      this._props.push(p);
+    }
+  }
+};
+_getGSAP() && gsap.registerPlugin(PixiPlugin);
+export { PixiPlugin as default };

network-visualization/node_modules/gsap/README.md

@@ -0,0 +1,93 @@
+# GSAP (GreenSock Animation Platform)
+
+[![GSAP - Animate anything](https://gsap.com/GSAP-share-image.png)](http://gsap.com)
+
+GSAP is a **framework-agnostic** JavaScript animation library that turns developers into animation superheroes. Build high-performance animations that work in **every** major browser. Animate CSS, SVG, canvas, React, Vue, WebGL, colors, strings, motion paths, generic objects...anything JavaScript can touch! GSAP's <a href="https://gsap.com/docs/v3/Plugins/ScrollTrigger/">ScrollTrigger</a> plugin delivers jaw-dropping scroll-based animations with minimal code. <a href="https://gsap.com/docs/v3/GSAP/gsap.matchMedia()">gsap.matchMedia()</a> makes building responsive, accessibility-friendly animations a breeze.
+
+No other library delivers such advanced sequencing, reliability, and tight control while solving real-world problems on over 12 million sites. GSAP works around countless browser inconsistencies; your animations ***just work***. At its core, GSAP is a high-speed property manipulator, updating values over time with extreme accuracy. It's up to 20x faster than jQuery!
+
+GSAP is completely flexible; sprinkle it wherever you want. **Zero dependencies.**
+
+There are many optional <a href="https://gsap.com/docs/v3/Plugins">plugins</a> and <a href="https://gsap.com/docs/v3/Eases">easing</a> functions for achieving advanced effects easily like <a href="https://gsap.com/docs/v3/Plugins/ScrollTrigger/">scrolling</a>, <a href="https://gsap.com/docs/v3/Plugins/MorphSVGPlugin">morphing</a>, [text splitting](https://gsap.com/docs/v3/Plugins/SplitText), animating along a <a href="https://gsap.com/docs/v3/Plugins/MotionPathPlugin">motion path</a> or <a href="https://gsap.com/docs/v3/Plugins/Flip/">FLIP</a> animations. There's even a handy <a href="https://gsap.com/docs/v3/Plugins/Observer/">Observer</a> for normalizing event detection across browsers/devices. 
+
+
+### Get Started
+
+[![Get Started with GSAP](http://gsap.com/_img/github/get-started.jpg)](http://gsap.com/get-started)
+
+
+## Docs &amp; Installation
+
+View the <a href="https://gsap.com/docs">full documentation here</a>, including an <a href="https://gsap.com/install">installation guide</a>.
+
+### CDN
+
+```html
+<script src="https://cdn.jsdelivr.net/npm/gsap@3.13/dist/gsap.min.js"></script>
+```
+
+See <a href="https://www.jsdelivr.com/gsap">JSDelivr's dedicated GSAP page</a> for quick CDN links to the core files/plugins. There are more <a href="https://gsap.com/install">installation instructions</a> at gsap.com.
+
+**Every major ad network excludes GSAP from file size calculations** and most have it on their own CDNs, so contact them for the appropriate URL(s). 
+
+### NPM
+See the <a href="https://gsap.com/install">guide to using GSAP via NPM here</a>.
+
+```javascript
+npm install gsap
+```
+
+GSAP's core can animate almost anything including CSS and attributes, plus it includes all of the <a href="https://gsap.com/docs/v3/GSAP/UtilityMethods">utility methods</a> like <a href="https://gsap.com/docs/v3/GSAP/UtilityMethods/interpolate()">interpolate()</a>, <a href="https://gsap.com/docs/v3/GSAP/UtilityMethods/mapRange()">mapRange()</a>, most of the <a href="https://gsap.com/docs/v3/Eases">eases</a>, and it can do snapping and modifiers. 
+
+```javascript
+// typical import
+import gsap from "gsap";
+
+// get other plugins:
+import ScrollTrigger from "gsap/ScrollTrigger";
+import Flip from "gsap/Flip";
+import Draggable from "gsap/Draggable";
+
+// or all tools are exported from the "all" file (excluding members-only plugins):
+import { gsap, ScrollTrigger, Draggable, MotionPathPlugin } from "gsap/all";
+
+// don't forget to register plugins
+gsap.registerPlugin(ScrollTrigger, Draggable, Flip, MotionPathPlugin); 
+```
+
+The NPM files are ES modules, but there's also a /dist/ directory with <a href="https://www.davidbcalhoun.com/2014/what-is-amd-commonjs-and-umd/">UMD</a> files for extra compatibility.
+
+## GSAP is FREE! 
+
+Thanks to [Webflow](https://webflow.com), GSAP is now **100% FREE** including ALL of the bonus plugins like [SplitText](https://gsap.com/docs/v3/Plugins/SplitText), [MorphSVG](https://gsap.com/docs/v3/Plugins/MorphSVGPlugin), and all the others that were exclusively available to Club GSAP members. That's right - the entire GSAP toolset is FREE, even for commercial use! 🤯  Read more [here](https://webflow.com/blog/gsap-becomes-free)
+
+### ScrollTrigger &amp; ScrollSmoother
+
+If you're looking for scroll-driven animations, GSAP's <a href="https://gsap.com/docs/v3/Plugins/ScrollTrigger/">ScrollTrigger</a> plugin is the standard. There's a companion <a href="https://gsap.com/docs/v3/Plugins/ScrollSmoother/">ScrollSmoother</a> as well.
+
+[![ScrollTrigger](http://gsap.com/_img/github/scrolltrigger.jpg)](https://gsap.com/docs/v3/Plugins/ScrollTrigger)
+
+### Using React? 
+
+There's a <a href="https://www.npmjs.com/package/@gsap/react">@gsap/react</a> package that exposes a `useGSAP()` hook which is a drop-in replacement for `useEffect()`/`useLayoutEffect()`, automating cleanup tasks. Please read the <a href="https://gsap.com/react">React guide</a> for details.
+
+### Resources
+
+* <a href="https://gsap.com/">gsap.com</a>
+* <a href="https://gsap.com/get-started/">Getting started guide</a>
+* <a href="https://gsap.com/docs/">Docs</a>
+* <a href="https://gsap.com/demos">Demos &amp; starter templates</a>
+* <a href="https://gsap.com/community/">Community forums</a>
+* <a href="https://gsap.com/docs/v3/Eases">Ease Visualizer</a>
+* <a href="https://gsap.com/showcase">Showcase</a>
+* <a href="https://www.youtube.com/@GreenSockLearning">YouTube Channel</a>
+* <a href="https://gsap.com/cheatsheet">Cheat sheet</a>
+* <a href="https://webflow.com">Webflow</a>
+
+### Need help?
+Ask in the friendly <a href="https://gsap.com/community/">GSAP forums</a>. Or share your knowledge and help someone else - it's a great way to sharpen your skills! Report any bugs there too (or <a href="https://github.com/greensock/GSAP/issues">file an issue here</a> if you prefer).
+
+### License
+GreenSock's standard "no charge" license can be viewed at <a href="https://gsap.com/standard-license">https://gsap.com/standard-license</a>.
+
+Copyright (c) 2008-2025, GreenSock. All rights reserved.

network-visualization/node_modules/gsap/SECURITY.md

@@ -0,0 +1,6 @@
+# Security Policy
+
+Please report (suspected) security vulnerabilities to
+**[info@greensock.com](mailto:info@greensock.com)**. You will receive a response from
+us within 72 hours. If the issue is confirmed, we will release a patch as soon
+as possible depending on complexity.

network-visualization/node_modules/gsap/ScrambleTextPlugin.js

@@ -0,0 +1,251 @@
+/*!
+ * ScrambleTextPlugin 3.13.0
+ * https://gsap.com
+ *
+ * @license Copyright 2008-2025, GreenSock. All rights reserved.
+ * Subject to the terms at https://gsap.com/standard-license
+ * @author: Jack Doyle, jack@greensock.com
+*/
+
+/* eslint-disable */
+import { emojiSafeSplit, getText } from "./utils/strings.js";
+
+var CharSet = /*#__PURE__*/function () {
+  function CharSet(chars) {
+    this.chars = emojiSafeSplit(chars);
+    this.sets = [];
+    this.length = 50;
+
+    for (var i = 0; i < 20; i++) {
+      this.sets[i] = _scrambleText(80, this.chars); //we create 20 strings that are 80 characters long, randomly chosen and pack them into an array. We then randomly choose the scrambled text from this array in order to greatly improve efficiency compared to creating new randomized text from scratch each and every time it's needed. This is a simple lookup whereas the other technique requires looping through as many times as there are characters needed, and calling Math.random() each time through the loop, building the string, etc.
+    }
+  }
+
+  var _proto = CharSet.prototype;
+
+  _proto.grow = function grow(newLength) {
+    //if we encounter a tween that has more than 80 characters, we'll need to add to the character sets accordingly. Once it's cached, it'll only need to grow again if we exceed that new length. Again, this is an efficiency tactic.
+    for (var i = 0; i < 20; i++) {
+      this.sets[i] += _scrambleText(newLength - this.length, this.chars);
+    }
+
+    this.length = newLength;
+  };
+
+  return CharSet;
+}();
+
+var gsap,
+    _coreInitted,
+    _getGSAP = function _getGSAP() {
+  return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+},
+    _bonusValidated = 1,
+    //<name>ScrambleTextPlugin</name>
+_spacesExp = /\s+/g,
+    _scrambleText = function _scrambleText(length, chars) {
+  var l = chars.length,
+      s = "";
+
+  while (--length > -1) {
+    s += chars[~~(Math.random() * l)];
+  }
+
+  return s;
+},
+    _upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ",
+    _lower = _upper.toLowerCase(),
+    _charsLookup = {
+  upperCase: new CharSet(_upper),
+  lowerCase: new CharSet(_lower),
+  upperAndLowerCase: new CharSet(_upper + _lower)
+},
+    _initCore = function _initCore() {
+  _coreInitted = gsap = _getGSAP();
+};
+
+export var ScrambleTextPlugin = {
+  version: "3.13.0",
+  name: "scrambleText",
+  register: function register(core, Plugin, propTween) {
+    gsap = core;
+
+    _initCore();
+  },
+  init: function init(target, value, tween, index, targets) {
+    _coreInitted || _initCore();
+    this.prop = "innerHTML" in target ? "innerHTML" : "textContent" in target ? "textContent" : 0; // SVG text in IE doesn't have innerHTML, but it does have textContent.
+
+    if (!this.prop) {
+      return;
+    }
+
+    this.target = target;
+
+    if (typeof value !== "object") {
+      value = {
+        text: value
+      };
+    }
+
+    var text = value.text || value.value || "",
+        trim = value.trim !== false,
+        data = this,
+        delim,
+        maxLength,
+        charset,
+        splitByChars;
+    data.delimiter = delim = value.delimiter || "";
+    data.original = emojiSafeSplit(getText(target).replace(_spacesExp, " ").split("&nbsp;").join(""), delim, trim);
+
+    if (text === "{original}" || text === true || text == null) {
+      text = data.original.join(delim);
+    }
+
+    data.text = emojiSafeSplit((text || "").replace(_spacesExp, " "), delim, trim);
+    data.hasClass = !!(value.newClass || value.oldClass);
+    data.newClass = value.newClass;
+    data.oldClass = value.oldClass;
+    splitByChars = delim === "";
+    data.textHasEmoji = splitByChars && !!data.text.emoji;
+    data.charsHaveEmoji = !!value.chars && !!emojiSafeSplit(value.chars).emoji;
+    data.length = splitByChars ? data.original.length : data.original.join(delim).length;
+    data.lengthDif = (splitByChars ? data.text.length : data.text.join(delim).length) - data.length;
+    data.fillChar = value.fillChar || value.chars && ~value.chars.indexOf(" ") ? "&nbsp;" : "";
+    data.charSet = charset = _charsLookup[value.chars || "upperCase"] || new CharSet(value.chars);
+    data.speed = 0.05 / (value.speed || 1);
+    data.prevScrambleTime = 0;
+    data.setIndex = Math.random() * 20 | 0;
+    maxLength = data.length + Math.max(data.lengthDif, 0);
+
+    if (maxLength > charset.length) {
+      charset.grow(maxLength);
+    }
+
+    data.chars = charset.sets[data.setIndex];
+    data.revealDelay = value.revealDelay || 0;
+    data.tweenLength = value.tweenLength !== false;
+    data.tween = tween;
+    data.rightToLeft = !!value.rightToLeft;
+
+    data._props.push("scrambleText", "text");
+
+    return _bonusValidated;
+  },
+  render: function render(ratio, data) {
+    var target = data.target,
+        prop = data.prop,
+        text = data.text,
+        delimiter = data.delimiter,
+        tween = data.tween,
+        prevScrambleTime = data.prevScrambleTime,
+        revealDelay = data.revealDelay,
+        setIndex = data.setIndex,
+        chars = data.chars,
+        charSet = data.charSet,
+        length = data.length,
+        textHasEmoji = data.textHasEmoji,
+        charsHaveEmoji = data.charsHaveEmoji,
+        lengthDif = data.lengthDif,
+        tweenLength = data.tweenLength,
+        oldClass = data.oldClass,
+        newClass = data.newClass,
+        rightToLeft = data.rightToLeft,
+        fillChar = data.fillChar,
+        speed = data.speed,
+        original = data.original,
+        hasClass = data.hasClass,
+        l = text.length,
+        time = tween._time,
+        timeDif = time - prevScrambleTime,
+        i,
+        i2,
+        startText,
+        endText,
+        applyNew,
+        applyOld,
+        str,
+        startClass,
+        endClass,
+        position,
+        r;
+
+    if (revealDelay) {
+      if (tween._from) {
+        time = tween._dur - time; //invert the time for from() tweens
+      }
+
+      ratio = time === 0 ? 0 : time < revealDelay ? 0.000001 : time === tween._dur ? 1 : tween._ease((time - revealDelay) / (tween._dur - revealDelay));
+    }
+
+    if (ratio < 0) {
+      ratio = 0;
+    } else if (ratio > 1) {
+      ratio = 1;
+    }
+
+    if (rightToLeft) {
+      ratio = 1 - ratio;
+    }
+
+    i = ~~(ratio * l + 0.5);
+
+    if (ratio) {
+      if (timeDif > speed || timeDif < -speed) {
+        data.setIndex = setIndex = (setIndex + (Math.random() * 19 | 0)) % 20;
+        data.chars = charSet.sets[setIndex];
+        data.prevScrambleTime += timeDif;
+      }
+
+      endText = chars;
+    } else {
+      endText = original.join(delimiter);
+    }
+
+    r = tween._from ? ratio : 1 - ratio;
+    position = length + (tweenLength ? tween._from ? r * r * r : 1 - r * r * r : 1) * lengthDif;
+
+    if (rightToLeft) {
+      if (ratio === 1 && (tween._from || tween.data === "isFromStart")) {
+        //special case for from() tweens
+        startText = "";
+        endText = original.join(delimiter);
+      } else {
+        str = text.slice(i).join(delimiter);
+
+        if (charsHaveEmoji) {
+          startText = emojiSafeSplit(endText).slice(0, position - (textHasEmoji ? emojiSafeSplit(str) : str).length + 0.5 | 0).join("");
+        } else {
+          startText = endText.substr(0, position - (textHasEmoji ? emojiSafeSplit(str) : str).length + 0.5 | 0);
+        }
+
+        endText = str;
+      }
+    } else {
+      startText = text.slice(0, i).join(delimiter);
+      i2 = (textHasEmoji ? emojiSafeSplit(startText) : startText).length;
+
+      if (charsHaveEmoji) {
+        endText = emojiSafeSplit(endText).slice(i2, position + 0.5 | 0).join("");
+      } else {
+        endText = endText.substr(i2, position - i2 + 0.5 | 0);
+      }
+    }
+
+    if (hasClass) {
+      startClass = rightToLeft ? oldClass : newClass;
+      endClass = rightToLeft ? newClass : oldClass;
+      applyNew = startClass && i !== 0;
+      applyOld = endClass && i !== l;
+      str = (applyNew ? "<span class='" + startClass + "'>" : "") + startText + (applyNew ? "</span>" : "") + (applyOld ? "<span class='" + endClass + "'>" : "") + delimiter + endText + (applyOld ? "</span>" : "");
+    } else {
+      str = startText + delimiter + endText;
+    }
+
+    target[prop] = fillChar === "&nbsp;" && ~str.indexOf("  ") ? str.split("  ").join("&nbsp;&nbsp;") : str;
+  }
+};
+ScrambleTextPlugin.emojiSafeSplit = emojiSafeSplit;
+ScrambleTextPlugin.getText = getText;
+_getGSAP() && gsap.registerPlugin(ScrambleTextPlugin);
+export { ScrambleTextPlugin as default };

network-visualization/node_modules/gsap/ScrollToPlugin.js

@@ -0,0 +1,281 @@
+/*!
+ * ScrollToPlugin 3.13.0
+ * https://gsap.com
+ *
+ * @license Copyright 2008-2025, GreenSock. All rights reserved.
+ * Subject to the terms at https://gsap.com/standard-license
+ * @author: Jack Doyle, jack@greensock.com
+*/
+
+/* eslint-disable */
+var gsap,
+    _coreInitted,
+    _window,
+    _docEl,
+    _body,
+    _toArray,
+    _config,
+    ScrollTrigger,
+    _windowExists = function _windowExists() {
+  return typeof window !== "undefined";
+},
+    _getGSAP = function _getGSAP() {
+  return gsap || _windowExists() && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+},
+    _isString = function _isString(value) {
+  return typeof value === "string";
+},
+    _isFunction = function _isFunction(value) {
+  return typeof value === "function";
+},
+    _max = function _max(element, axis) {
+  var dim = axis === "x" ? "Width" : "Height",
+      scroll = "scroll" + dim,
+      client = "client" + dim;
+  return element === _window || element === _docEl || element === _body ? Math.max(_docEl[scroll], _body[scroll]) - (_window["inner" + dim] || _docEl[client] || _body[client]) : element[scroll] - element["offset" + dim];
+},
+    _buildGetter = function _buildGetter(e, axis) {
+  //pass in an element and an axis ("x" or "y") and it'll return a getter function for the scroll position of that element (like scrollTop or scrollLeft, although if the element is the window, it'll use the pageXOffset/pageYOffset or the documentElement's scrollTop/scrollLeft or document.body's. Basically this streamlines things and makes a very fast getter across browsers.
+  var p = "scroll" + (axis === "x" ? "Left" : "Top");
+
+  if (e === _window) {
+    if (e.pageXOffset != null) {
+      p = "page" + axis.toUpperCase() + "Offset";
+    } else {
+      e = _docEl[p] != null ? _docEl : _body;
+    }
+  }
+
+  return function () {
+    return e[p];
+  };
+},
+    _clean = function _clean(value, index, target, targets) {
+  _isFunction(value) && (value = value(index, target, targets));
+
+  if (typeof value !== "object") {
+    return _isString(value) && value !== "max" && value.charAt(1) !== "=" ? {
+      x: value,
+      y: value
+    } : {
+      y: value
+    }; //if we don't receive an object as the parameter, assume the user intends "y".
+  } else if (value.nodeType) {
+    return {
+      y: value,
+      x: value
+    };
+  } else {
+    var result = {},
+        p;
+
+    for (p in value) {
+      result[p] = p !== "onAutoKill" && _isFunction(value[p]) ? value[p](index, target, targets) : value[p];
+    }
+
+    return result;
+  }
+},
+    _getOffset = function _getOffset(element, container) {
+  element = _toArray(element)[0];
+
+  if (!element || !element.getBoundingClientRect) {
+    return console.warn("scrollTo target doesn't exist. Using 0") || {
+      x: 0,
+      y: 0
+    };
+  }
+
+  var rect = element.getBoundingClientRect(),
+      isRoot = !container || container === _window || container === _body,
+      cRect = isRoot ? {
+    top: _docEl.clientTop - (_window.pageYOffset || _docEl.scrollTop || _body.scrollTop || 0),
+    left: _docEl.clientLeft - (_window.pageXOffset || _docEl.scrollLeft || _body.scrollLeft || 0)
+  } : container.getBoundingClientRect(),
+      offsets = {
+    x: rect.left - cRect.left,
+    y: rect.top - cRect.top
+  };
+
+  if (!isRoot && container) {
+    //only add the current scroll position if it's not the window/body.
+    offsets.x += _buildGetter(container, "x")();
+    offsets.y += _buildGetter(container, "y")();
+  }
+
+  return offsets;
+},
+    _parseVal = function _parseVal(value, target, axis, currentVal, offset) {
+  return !isNaN(value) && typeof value !== "object" ? parseFloat(value) - offset : _isString(value) && value.charAt(1) === "=" ? parseFloat(value.substr(2)) * (value.charAt(0) === "-" ? -1 : 1) + currentVal - offset : value === "max" ? _max(target, axis) - offset : Math.min(_max(target, axis), _getOffset(value, target)[axis] - offset);
+},
+    _initCore = function _initCore() {
+  gsap = _getGSAP();
+
+  if (_windowExists() && gsap && typeof document !== "undefined" && document.body) {
+    _window = window;
+    _body = document.body;
+    _docEl = document.documentElement;
+    _toArray = gsap.utils.toArray;
+    gsap.config({
+      autoKillThreshold: 7
+    });
+    _config = gsap.config();
+    _coreInitted = 1;
+  }
+};
+
+export var ScrollToPlugin = {
+  version: "3.13.0",
+  name: "scrollTo",
+  rawVars: 1,
+  register: function register(core) {
+    gsap = core;
+
+    _initCore();
+  },
+  init: function init(target, value, tween, index, targets) {
+    _coreInitted || _initCore();
+    var data = this,
+        snapType = gsap.getProperty(target, "scrollSnapType");
+    data.isWin = target === _window;
+    data.target = target;
+    data.tween = tween;
+    value = _clean(value, index, target, targets);
+    data.vars = value;
+    data.autoKill = !!("autoKill" in value ? value : _config).autoKill;
+    data.getX = _buildGetter(target, "x");
+    data.getY = _buildGetter(target, "y");
+    data.x = data.xPrev = data.getX();
+    data.y = data.yPrev = data.getY();
+    ScrollTrigger || (ScrollTrigger = gsap.core.globals().ScrollTrigger);
+    gsap.getProperty(target, "scrollBehavior") === "smooth" && gsap.set(target, {
+      scrollBehavior: "auto"
+    });
+
+    if (snapType && snapType !== "none") {
+      // disable scroll snapping to avoid strange behavior
+      data.snap = 1;
+      data.snapInline = target.style.scrollSnapType;
+      target.style.scrollSnapType = "none";
+    }
+
+    if (value.x != null) {
+      data.add(data, "x", data.x, _parseVal(value.x, target, "x", data.x, value.offsetX || 0), index, targets);
+
+      data._props.push("scrollTo_x");
+    } else {
+      data.skipX = 1;
+    }
+
+    if (value.y != null) {
+      data.add(data, "y", data.y, _parseVal(value.y, target, "y", data.y, value.offsetY || 0), index, targets);
+
+      data._props.push("scrollTo_y");
+    } else {
+      data.skipY = 1;
+    }
+  },
+  render: function render(ratio, data) {
+    var pt = data._pt,
+        target = data.target,
+        tween = data.tween,
+        autoKill = data.autoKill,
+        xPrev = data.xPrev,
+        yPrev = data.yPrev,
+        isWin = data.isWin,
+        snap = data.snap,
+        snapInline = data.snapInline,
+        x,
+        y,
+        yDif,
+        xDif,
+        threshold;
+
+    while (pt) {
+      pt.r(ratio, pt.d);
+      pt = pt._next;
+    }
+
+    x = isWin || !data.skipX ? data.getX() : xPrev;
+    y = isWin || !data.skipY ? data.getY() : yPrev;
+    yDif = y - yPrev;
+    xDif = x - xPrev;
+    threshold = _config.autoKillThreshold;
+
+    if (data.x < 0) {
+      //can't scroll to a position less than 0! Might happen if someone uses a Back.easeOut or Elastic.easeOut when scrolling back to the top of the page (for example)
+      data.x = 0;
+    }
+
+    if (data.y < 0) {
+      data.y = 0;
+    }
+
+    if (autoKill) {
+      //note: iOS has a bug that throws off the scroll by several pixels, so we need to check if it's within 7 pixels of the previous one that we set instead of just looking for an exact match.
+      if (!data.skipX && (xDif > threshold || xDif < -threshold) && x < _max(target, "x")) {
+        data.skipX = 1; //if the user scrolls separately, we should stop tweening!
+      }
+
+      if (!data.skipY && (yDif > threshold || yDif < -threshold) && y < _max(target, "y")) {
+        data.skipY = 1; //if the user scrolls separately, we should stop tweening!
+      }
+
+      if (data.skipX && data.skipY) {
+        tween.kill();
+        data.vars.onAutoKill && data.vars.onAutoKill.apply(tween, data.vars.onAutoKillParams || []);
+      }
+    }
+
+    if (isWin) {
+      _window.scrollTo(!data.skipX ? data.x : x, !data.skipY ? data.y : y);
+    } else {
+      data.skipY || (target.scrollTop = data.y);
+      data.skipX || (target.scrollLeft = data.x);
+    }
+
+    if (snap && (ratio === 1 || ratio === 0)) {
+      y = target.scrollTop;
+      x = target.scrollLeft;
+      snapInline ? target.style.scrollSnapType = snapInline : target.style.removeProperty("scroll-snap-type");
+      target.scrollTop = y + 1; // bug in Safari causes the element to totally reset its scroll position when scroll-snap-type changes, so we need to set it to a slightly different value and then back again to work around this bug.
+
+      target.scrollLeft = x + 1;
+      target.scrollTop = y;
+      target.scrollLeft = x;
+    }
+
+    data.xPrev = data.x;
+    data.yPrev = data.y;
+    ScrollTrigger && ScrollTrigger.update();
+  },
+  kill: function kill(property) {
+    var both = property === "scrollTo",
+        i = this._props.indexOf(property);
+
+    if (both || property === "scrollTo_x") {
+      this.skipX = 1;
+    }
+
+    if (both || property === "scrollTo_y") {
+      this.skipY = 1;
+    }
+
+    i > -1 && this._props.splice(i, 1);
+    return !this._props.length;
+  }
+};
+ScrollToPlugin.max = _max;
+ScrollToPlugin.getOffset = _getOffset;
+ScrollToPlugin.buildGetter = _buildGetter;
+
+ScrollToPlugin.config = function (vars) {
+  _config || _initCore() || (_config = gsap.config()); // in case the window hasn't been defined yet.
+
+  for (var p in vars) {
+    _config[p] = vars[p];
+  }
+};
+
+_getGSAP() && gsap.registerPlugin(ScrollToPlugin);
+export { ScrollToPlugin as default };

network-visualization/node_modules/gsap/SplitText.js

@@ -0,0 +1,310 @@
+/*!
+ * SplitText 3.13.0
+ * https://gsap.com
+ *
+ * @license Copyright 2025, GreenSock. All rights reserved. Subject to the terms at https://gsap.com/standard-license.
+ * @author: Jack Doyle
+ */
+
+let gsap, _fonts, _coreInitted, _initIfNecessary = () => _coreInitted || SplitText.register(window.gsap), _charSegmenter = typeof Intl !== "undefined" ? new Intl.Segmenter() : 0, _toArray = (r) => typeof r === "string" ? _toArray(document.querySelectorAll(r)) : "length" in r ? Array.from(r) : [r], _elements = (targets) => _toArray(targets).filter((e) => e instanceof HTMLElement), _emptyArray = [], _context = function() {
+}, _spacesRegEx = /\s+/g, _emojiSafeRegEx = new RegExp("\\p{RI}\\p{RI}|\\p{Emoji}(\\p{EMod}|\\u{FE0F}\\u{20E3}?|[\\u{E0020}-\\u{E007E}]+\\u{E007F})?(\\u{200D}\\p{Emoji}(\\p{EMod}|\\u{FE0F}\\u{20E3}?|[\\u{E0020}-\\u{E007E}]+\\u{E007F})?)*|.", "gu"), _emptyBounds = { left: 0, top: 0, width: 0, height: 0 }, _stretchToFitSpecialChars = (collection, specialCharsRegEx) => {
+  if (specialCharsRegEx) {
+    let charsFound = new Set(collection.join("").match(specialCharsRegEx) || _emptyArray), i = collection.length, slots, word, char, combined;
+    if (charsFound.size) {
+      while (--i > -1) {
+        word = collection[i];
+        for (char of charsFound) {
+          if (char.startsWith(word) && char.length > word.length) {
+            slots = 0;
+            combined = word;
+            while (char.startsWith(combined += collection[i + ++slots]) && combined.length < char.length) {
+            }
+            if (slots && combined.length === char.length) {
+              collection[i] = char;
+              collection.splice(i + 1, slots);
+              break;
+            }
+          }
+        }
+      }
+    }
+  }
+  return collection;
+}, _disallowInline = (element) => window.getComputedStyle(element).display === "inline" && (element.style.display = "inline-block"), _insertNodeBefore = (newChild, parent, existingChild) => parent.insertBefore(typeof newChild === "string" ? document.createTextNode(newChild) : newChild, existingChild), _getWrapper = (type, config, collection) => {
+  let className = config[type + "sClass"] || "", { tag = "div", aria = "auto", propIndex = false } = config, display = type === "line" ? "block" : "inline-block", incrementClass = className.indexOf("++") > -1, wrapper = (text) => {
+    let el = document.createElement(tag), i = collection.length + 1;
+    className && (el.className = className + (incrementClass ? " " + className + i : ""));
+    propIndex && el.style.setProperty("--" + type, i + "");
+    aria !== "none" && el.setAttribute("aria-hidden", "true");
+    if (tag !== "span") {
+      el.style.position = "relative";
+      el.style.display = display;
+    }
+    el.textContent = text;
+    collection.push(el);
+    return el;
+  };
+  incrementClass && (className = className.replace("++", ""));
+  wrapper.collection = collection;
+  return wrapper;
+}, _getLineWrapper = (element, nodes, config, collection) => {
+  let lineWrapper = _getWrapper("line", config, collection), textAlign = window.getComputedStyle(element).textAlign || "left";
+  return (startIndex, endIndex) => {
+    let newLine = lineWrapper("");
+    newLine.style.textAlign = textAlign;
+    element.insertBefore(newLine, nodes[startIndex]);
+    for (; startIndex < endIndex; startIndex++) {
+      newLine.appendChild(nodes[startIndex]);
+    }
+    newLine.normalize();
+  };
+}, _splitWordsAndCharsRecursively = (element, config, wordWrapper, charWrapper, prepForCharsOnly, deepSlice, ignore, charSplitRegEx, specialCharsRegEx, isNested) => {
+  var _a;
+  let nodes = Array.from(element.childNodes), i = 0, { wordDelimiter, reduceWhiteSpace = true, prepareText } = config, elementBounds = element.getBoundingClientRect(), lastBounds = elementBounds, isPreformatted = !reduceWhiteSpace && window.getComputedStyle(element).whiteSpace.substring(0, 3) === "pre", ignoredPreviousSibling = 0, wordsCollection = wordWrapper.collection, wordDelimIsNotSpace, wordDelimString, wordDelimSplitter, curNode, words, curWordEl, startsWithSpace, endsWithSpace, j, bounds, curWordChars, clonedNode, curSubNode, tempSubNode, curTextContent, wordText, lastWordText, k;
+  if (typeof wordDelimiter === "object") {
+    wordDelimSplitter = wordDelimiter.delimiter || wordDelimiter;
+    wordDelimString = wordDelimiter.replaceWith || "";
+  } else {
+    wordDelimString = wordDelimiter === "" ? "" : wordDelimiter || " ";
+  }
+  wordDelimIsNotSpace = wordDelimString !== " ";
+  for (; i < nodes.length; i++) {
+    curNode = nodes[i];
+    if (curNode.nodeType === 3) {
+      curTextContent = curNode.textContent || "";
+      if (reduceWhiteSpace) {
+        curTextContent = curTextContent.replace(_spacesRegEx, " ");
+      } else if (isPreformatted) {
+        curTextContent = curTextContent.replace(/\n/g, wordDelimString + "\n");
+      }
+      prepareText && (curTextContent = prepareText(curTextContent, element));
+      curNode.textContent = curTextContent;
+      words = wordDelimString || wordDelimSplitter ? curTextContent.split(wordDelimSplitter || wordDelimString) : curTextContent.match(charSplitRegEx) || _emptyArray;
+      lastWordText = words[words.length - 1];
+      endsWithSpace = wordDelimIsNotSpace ? lastWordText.slice(-1) === " " : !lastWordText;
+      lastWordText || words.pop();
+      lastBounds = elementBounds;
+      startsWithSpace = wordDelimIsNotSpace ? words[0].charAt(0) === " " : !words[0];
+      startsWithSpace && _insertNodeBefore(" ", element, curNode);
+      words[0] || words.shift();
+      _stretchToFitSpecialChars(words, specialCharsRegEx);
+      deepSlice && isNested || (curNode.textContent = "");
+      for (j = 1; j <= words.length; j++) {
+        wordText = words[j - 1];
+        if (!reduceWhiteSpace && isPreformatted && wordText.charAt(0) === "\n") {
+          (_a = curNode.previousSibling) == null ? void 0 : _a.remove();
+          _insertNodeBefore(document.createElement("br"), element, curNode);
+          wordText = wordText.slice(1);
+        }
+        if (!reduceWhiteSpace && wordText === "") {
+          _insertNodeBefore(wordDelimString, element, curNode);
+        } else if (wordText === " ") {
+          element.insertBefore(document.createTextNode(" "), curNode);
+        } else {
+          wordDelimIsNotSpace && wordText.charAt(0) === " " && _insertNodeBefore(" ", element, curNode);
+          if (ignoredPreviousSibling && j === 1 && !startsWithSpace && wordsCollection.indexOf(ignoredPreviousSibling.parentNode) > -1) {
+            curWordEl = wordsCollection[wordsCollection.length - 1];
+            curWordEl.appendChild(document.createTextNode(charWrapper ? "" : wordText));
+          } else {
+            curWordEl = wordWrapper(charWrapper ? "" : wordText);
+            _insertNodeBefore(curWordEl, element, curNode);
+            ignoredPreviousSibling && j === 1 && !startsWithSpace && curWordEl.insertBefore(ignoredPreviousSibling, curWordEl.firstChild);
+          }
+          if (charWrapper) {
+            curWordChars = _charSegmenter ? _stretchToFitSpecialChars([..._charSegmenter.segment(wordText)].map((s) => s.segment), specialCharsRegEx) : wordText.match(charSplitRegEx) || _emptyArray;
+            for (k = 0; k < curWordChars.length; k++) {
+              curWordEl.appendChild(curWordChars[k] === " " ? document.createTextNode(" ") : charWrapper(curWordChars[k]));
+            }
+          }
+          if (deepSlice && isNested) {
+            curTextContent = curNode.textContent = curTextContent.substring(wordText.length + 1, curTextContent.length);
+            bounds = curWordEl.getBoundingClientRect();
+            if (bounds.top > lastBounds.top && bounds.left <= lastBounds.left) {
+              clonedNode = element.cloneNode();
+              curSubNode = element.childNodes[0];
+              while (curSubNode && curSubNode !== curWordEl) {
+                tempSubNode = curSubNode;
+                curSubNode = curSubNode.nextSibling;
+                clonedNode.appendChild(tempSubNode);
+              }
+              element.parentNode.insertBefore(clonedNode, element);
+              prepForCharsOnly && _disallowInline(clonedNode);
+            }
+            lastBounds = bounds;
+          }
+          if (j < words.length || endsWithSpace) {
+            _insertNodeBefore(j >= words.length ? " " : wordDelimIsNotSpace && wordText.slice(-1) === " " ? " " + wordDelimString : wordDelimString, element, curNode);
+          }
+        }
+      }
+      element.removeChild(curNode);
+      ignoredPreviousSibling = 0;
+    } else if (curNode.nodeType === 1) {
+      if (ignore && ignore.indexOf(curNode) > -1) {
+        wordsCollection.indexOf(curNode.previousSibling) > -1 && wordsCollection[wordsCollection.length - 1].appendChild(curNode);
+        ignoredPreviousSibling = curNode;
+      } else {
+        _splitWordsAndCharsRecursively(curNode, config, wordWrapper, charWrapper, prepForCharsOnly, deepSlice, ignore, charSplitRegEx, specialCharsRegEx, true);
+        ignoredPreviousSibling = 0;
+      }
+      prepForCharsOnly && _disallowInline(curNode);
+    }
+  }
+};
+const _SplitText = class _SplitText {
+  constructor(elements, config) {
+    this.isSplit = false;
+    _initIfNecessary();
+    this.elements = _elements(elements);
+    this.chars = [];
+    this.words = [];
+    this.lines = [];
+    this.masks = [];
+    this.vars = config;
+    this._split = () => this.isSplit && this.split(this.vars);
+    let orig = [], timerId, checkWidths = () => {
+      let i = orig.length, o;
+      while (i--) {
+        o = orig[i];
+        let w = o.element.offsetWidth;
+        if (w !== o.width) {
+          o.width = w;
+          this._split();
+          return;
+        }
+      }
+    };
+    this._data = { orig, obs: typeof ResizeObserver !== "undefined" && new ResizeObserver(() => {
+      clearTimeout(timerId);
+      timerId = setTimeout(checkWidths, 200);
+    }) };
+    _context(this);
+    this.split(config);
+  }
+  split(config) {
+    this.isSplit && this.revert();
+    this.vars = config = config || this.vars || {};
+    let { type = "chars,words,lines", aria = "auto", deepSlice = true, smartWrap, onSplit, autoSplit = false, specialChars, mask } = this.vars, splitLines = type.indexOf("lines") > -1, splitCharacters = type.indexOf("chars") > -1, splitWords = type.indexOf("words") > -1, onlySplitCharacters = splitCharacters && !splitWords && !splitLines, specialCharsRegEx = specialChars && ("push" in specialChars ? new RegExp("(?:" + specialChars.join("|") + ")", "gu") : specialChars), finalCharSplitRegEx = specialCharsRegEx ? new RegExp(specialCharsRegEx.source + "|" + _emojiSafeRegEx.source, "gu") : _emojiSafeRegEx, ignore = !!config.ignore && _elements(config.ignore), { orig, animTime, obs } = this._data, onSplitResult;
+    if (splitCharacters || splitWords || splitLines) {
+      this.elements.forEach((element, index) => {
+        orig[index] = {
+          element,
+          html: element.innerHTML,
+          ariaL: element.getAttribute("aria-label"),
+          ariaH: element.getAttribute("aria-hidden")
+        };
+        aria === "auto" ? element.setAttribute("aria-label", (element.textContent || "").trim()) : aria === "hidden" && element.setAttribute("aria-hidden", "true");
+        let chars = [], words = [], lines = [], charWrapper = splitCharacters ? _getWrapper("char", config, chars) : null, wordWrapper = _getWrapper("word", config, words), i, curWord, smartWrapSpan, nextSibling;
+        _splitWordsAndCharsRecursively(element, config, wordWrapper, charWrapper, onlySplitCharacters, deepSlice && (splitLines || onlySplitCharacters), ignore, finalCharSplitRegEx, specialCharsRegEx, false);
+        if (splitLines) {
+          let nodes = _toArray(element.childNodes), wrapLine = _getLineWrapper(element, nodes, config, lines), curNode, toRemove = [], lineStartIndex = 0, allBounds = nodes.map((n) => n.nodeType === 1 ? n.getBoundingClientRect() : _emptyBounds), lastBounds = _emptyBounds;
+          for (i = 0; i < nodes.length; i++) {
+            curNode = nodes[i];
+            if (curNode.nodeType === 1) {
+              if (curNode.nodeName === "BR") {
+                toRemove.push(curNode);
+                wrapLine(lineStartIndex, i + 1);
+                lineStartIndex = i + 1;
+                lastBounds = allBounds[lineStartIndex];
+              } else {
+                if (i && allBounds[i].top > lastBounds.top && allBounds[i].left <= lastBounds.left) {
+                  wrapLine(lineStartIndex, i);
+                  lineStartIndex = i;
+                }
+                lastBounds = allBounds[i];
+              }
+            }
+          }
+          lineStartIndex < i && wrapLine(lineStartIndex, i);
+          toRemove.forEach((el) => {
+            var _a;
+            return (_a = el.parentNode) == null ? void 0 : _a.removeChild(el);
+          });
+        }
+        if (!splitWords) {
+          for (i = 0; i < words.length; i++) {
+            curWord = words[i];
+            if (splitCharacters || !curWord.nextSibling || curWord.nextSibling.nodeType !== 3) {
+              if (smartWrap && !splitLines) {
+                smartWrapSpan = document.createElement("span");
+                smartWrapSpan.style.whiteSpace = "nowrap";
+                while (curWord.firstChild) {
+                  smartWrapSpan.appendChild(curWord.firstChild);
+                }
+                curWord.replaceWith(smartWrapSpan);
+              } else {
+                curWord.replaceWith(...curWord.childNodes);
+              }
+            } else {
+              nextSibling = curWord.nextSibling;
+              if (nextSibling && nextSibling.nodeType === 3) {
+                nextSibling.textContent = (curWord.textContent || "") + (nextSibling.textContent || "");
+                curWord.remove();
+              }
+            }
+          }
+          words.length = 0;
+          element.normalize();
+        }
+        this.lines.push(...lines);
+        this.words.push(...words);
+        this.chars.push(...chars);
+      });
+      mask && this[mask] && this.masks.push(...this[mask].map((el) => {
+        let maskEl = el.cloneNode();
+        el.replaceWith(maskEl);
+        maskEl.appendChild(el);
+        el.className && (maskEl.className = el.className.replace(/(\b\w+\b)/g, "$1-mask"));
+        maskEl.style.overflow = "clip";
+        return maskEl;
+      }));
+    }
+    this.isSplit = true;
+    _fonts && (autoSplit ? _fonts.addEventListener("loadingdone", this._split) : _fonts.status === "loading" && console.warn("SplitText called before fonts loaded"));
+    if ((onSplitResult = onSplit && onSplit(this)) && onSplitResult.totalTime) {
+      this._data.anim = animTime ? onSplitResult.totalTime(animTime) : onSplitResult;
+    }
+    splitLines && autoSplit && this.elements.forEach((element, index) => {
+      orig[index].width = element.offsetWidth;
+      obs && obs.observe(element);
+    });
+    return this;
+  }
+  revert() {
+    var _a, _b;
+    let { orig, anim, obs } = this._data;
+    obs && obs.disconnect();
+    orig.forEach(({ element, html, ariaL, ariaH }) => {
+      element.innerHTML = html;
+      ariaL ? element.setAttribute("aria-label", ariaL) : element.removeAttribute("aria-label");
+      ariaH ? element.setAttribute("aria-hidden", ariaH) : element.removeAttribute("aria-hidden");
+    });
+    this.chars.length = this.words.length = this.lines.length = orig.length = this.masks.length = 0;
+    this.isSplit = false;
+    _fonts == null ? void 0 : _fonts.removeEventListener("loadingdone", this._split);
+    if (anim) {
+      this._data.animTime = anim.totalTime();
+      anim.revert();
+    }
+    (_b = (_a = this.vars).onRevert) == null ? void 0 : _b.call(_a, this);
+    return this;
+  }
+  static create(elements, config) {
+    return new _SplitText(elements, config);
+  }
+  static register(core) {
+    gsap = gsap || core || window.gsap;
+    if (gsap) {
+      _toArray = gsap.utils.toArray;
+      _context = gsap.core.context || _context;
+    }
+    if (!_coreInitted && window.innerWidth > 0) {
+      _fonts = document.fonts;
+      _coreInitted = true;
+    }
+  }
+};
+_SplitText.version = "3.13.0";
+let SplitText = _SplitText;
+
+export { SplitText, SplitText as default };

network-visualization/node_modules/gsap/TextPlugin.js

@@ -0,0 +1,165 @@
+/*!
+ * TextPlugin 3.13.0
+ * https://gsap.com
+ *
+ * @license Copyright 2008-2025, GreenSock. All rights reserved.
+ * Subject to the terms at https://gsap.com/standard-license
+ * @author: Jack Doyle, jack@greensock.com
+*/
+
+/* eslint-disable */
+import { emojiSafeSplit, getText, splitInnerHTML } from "./utils/strings.js";
+
+var gsap,
+    _tempDiv,
+    _getGSAP = function _getGSAP() {
+  return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+};
+
+export var TextPlugin = {
+  version: "3.13.0",
+  name: "text",
+  init: function init(target, value, tween) {
+    typeof value !== "object" && (value = {
+      value: value
+    });
+
+    var i = target.nodeName.toUpperCase(),
+        data = this,
+        _value = value,
+        newClass = _value.newClass,
+        oldClass = _value.oldClass,
+        preserveSpaces = _value.preserveSpaces,
+        rtl = _value.rtl,
+        delimiter = data.delimiter = value.delimiter || "",
+        fillChar = data.fillChar = value.fillChar || (value.padSpace ? " " : ""),
+        _short,
+        text,
+        original,
+        j,
+        condensedText,
+        condensedOriginal,
+        aggregate,
+        s;
+
+    data.svg = target.getBBox && (i === "TEXT" || i === "TSPAN");
+
+    if (!("innerHTML" in target) && !data.svg) {
+      return false;
+    }
+
+    data.target = target;
+
+    if (!("value" in value)) {
+      data.text = data.original = [""];
+      return;
+    }
+
+    original = splitInnerHTML(target, delimiter, false, preserveSpaces, data.svg);
+    _tempDiv || (_tempDiv = document.createElement("div"));
+    _tempDiv.innerHTML = value.value;
+    text = splitInnerHTML(_tempDiv, delimiter, false, preserveSpaces, data.svg);
+    data.from = tween._from;
+
+    if ((data.from || rtl) && !(rtl && data.from)) {
+      // right-to-left or "from()" tweens should invert things (but if it's BOTH .from() and rtl, inverting twice equals not inverting at all :)
+      i = original;
+      original = text;
+      text = i;
+    }
+
+    data.hasClass = !!(newClass || oldClass);
+    data.newClass = rtl ? oldClass : newClass;
+    data.oldClass = rtl ? newClass : oldClass;
+    i = original.length - text.length;
+    _short = i < 0 ? original : text;
+
+    if (i < 0) {
+      i = -i;
+    }
+
+    while (--i > -1) {
+      _short.push(fillChar);
+    }
+
+    if (value.type === "diff") {
+      j = 0;
+      condensedText = [];
+      condensedOriginal = [];
+      aggregate = "";
+
+      for (i = 0; i < text.length; i++) {
+        s = text[i];
+
+        if (s === original[i]) {
+          aggregate += s;
+        } else {
+          condensedText[j] = aggregate + s;
+          condensedOriginal[j++] = aggregate + original[i];
+          aggregate = "";
+        }
+      }
+
+      text = condensedText;
+      original = condensedOriginal;
+
+      if (aggregate) {
+        text.push(aggregate);
+        original.push(aggregate);
+      }
+    }
+
+    value.speed && tween.duration(Math.min(0.05 / value.speed * _short.length, value.maxDuration || 9999));
+    data.rtl = rtl;
+    data.original = original;
+    data.text = text;
+
+    data._props.push("text");
+  },
+  render: function render(ratio, data) {
+    if (ratio > 1) {
+      ratio = 1;
+    } else if (ratio < 0) {
+      ratio = 0;
+    }
+
+    if (data.from) {
+      ratio = 1 - ratio;
+    }
+
+    var text = data.text,
+        hasClass = data.hasClass,
+        newClass = data.newClass,
+        oldClass = data.oldClass,
+        delimiter = data.delimiter,
+        target = data.target,
+        fillChar = data.fillChar,
+        original = data.original,
+        rtl = data.rtl,
+        l = text.length,
+        i = (rtl ? 1 - ratio : ratio) * l + 0.5 | 0,
+        applyNew,
+        applyOld,
+        str;
+
+    if (hasClass && ratio) {
+      applyNew = newClass && i;
+      applyOld = oldClass && i !== l;
+      str = (applyNew ? "<span class='" + newClass + "'>" : "") + text.slice(0, i).join(delimiter) + (applyNew ? "</span>" : "") + (applyOld ? "<span class='" + oldClass + "'>" : "") + delimiter + original.slice(i).join(delimiter) + (applyOld ? "</span>" : "");
+    } else {
+      str = text.slice(0, i).join(delimiter) + delimiter + original.slice(i).join(delimiter);
+    }
+
+    if (data.svg) {
+      //SVG text elements don't have an "innerHTML" in Microsoft browsers.
+      target.textContent = str;
+    } else {
+      target.innerHTML = fillChar === "&nbsp;" && ~str.indexOf("  ") ? str.split("  ").join("&nbsp;&nbsp;") : str;
+    }
+  }
+};
+TextPlugin.splitInnerHTML = splitInnerHTML;
+TextPlugin.emojiSafeSplit = emojiSafeSplit;
+TextPlugin.getText = getText;
+_getGSAP() && gsap.registerPlugin(TextPlugin);
+export { TextPlugin as default };

network-visualization/node_modules/gsap/all.js

@@ -0,0 +1,31 @@
+import gsap from "./gsap-core.js";
+import CSSPlugin from "./CSSPlugin.js";
+var gsapWithCSS = gsap.registerPlugin(CSSPlugin) || gsap,
+    // to protect from tree shaking
+TweenMaxWithCSS = gsapWithCSS.core.Tween;
+export { gsapWithCSS as gsap, gsapWithCSS as default, TweenMaxWithCSS as TweenMax, CSSPlugin };
+export { TweenLite, TimelineMax, TimelineLite, Power0, Power1, Power2, Power3, Power4, Linear, Quad, Cubic, Quart, Quint, Strong, Elastic, Back, SteppedEase, Bounce, Sine, Expo, Circ, wrap, wrapYoyo, distribute, random, snap, normalize, getUnit, clamp, splitColor, toArray, mapRange, pipe, unitize, interpolate, shuffle, selector } from "./gsap-core.js";
+export * from "./CustomEase.js";
+export * from "./Draggable.js";
+export * from "./CSSRulePlugin.js";
+export * from "./EaselPlugin.js";
+export * from "./EasePack.js";
+export * from "./Flip.js";
+export * from "./MotionPathPlugin.js";
+export * from "./Observer.js";
+export * from "./PixiPlugin.js";
+export * from "./ScrollToPlugin.js";
+export * from "./ScrollTrigger.js";
+export * from "./TextPlugin.js";
+export * from "./DrawSVGPlugin.js";
+export * from "./Physics2DPlugin.js";
+export * from "./PhysicsPropsPlugin.js";
+export * from "./ScrambleTextPlugin.js";
+export * from "./CustomBounce.js";
+export * from "./CustomWiggle.js";
+export * from "./GSDevTools.js";
+export * from "./InertiaPlugin.js";
+export * from "./MorphSVGPlugin.js";
+export * from "./MotionPathHelper.js";
+export * from "./ScrollSmoother.js";
+export * from "./SplitText.js";

network-visualization/node_modules/gsap/dist/CSSRulePlugin.js

@@ -0,0 +1,139 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = global || self, factory(global.window = global.window || {}));
+}(this, (function (exports) { 'use strict';
+
+	/*!
+	 * CSSRulePlugin 3.13.0
+	 * https://gsap.com
+	 *
+	 * @license Copyright 2008-2025, GreenSock. All rights reserved.
+	 * Subject to the terms at https://gsap.com/standard-license
+	 * @author: Jack Doyle, jack@greensock.com
+	*/
+	var gsap,
+	    _coreInitted,
+	    _doc,
+	    CSSPlugin,
+	    _windowExists = function _windowExists() {
+	  return typeof window !== "undefined";
+	},
+	    _getGSAP = function _getGSAP() {
+	  return gsap || _windowExists() && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+	},
+	    _checkRegister = function _checkRegister() {
+	  if (!_coreInitted) {
+	    _initCore();
+
+	    if (!CSSPlugin) {
+	      console.warn("Please gsap.registerPlugin(CSSPlugin, CSSRulePlugin)");
+	    }
+	  }
+
+	  return _coreInitted;
+	},
+	    _initCore = function _initCore(core) {
+	  gsap = core || _getGSAP();
+
+	  if (_windowExists()) {
+	    _doc = document;
+	  }
+
+	  if (gsap) {
+	    CSSPlugin = gsap.plugins.css;
+
+	    if (CSSPlugin) {
+	      _coreInitted = 1;
+	    }
+	  }
+	};
+
+	var CSSRulePlugin = {
+	  version: "3.13.0",
+	  name: "cssRule",
+	  init: function init(target, value, tween, index, targets) {
+	    if (!_checkRegister() || typeof target.cssText === "undefined") {
+	      return false;
+	    }
+
+	    var div = target._gsProxy = target._gsProxy || _doc.createElement("div");
+
+	    this.ss = target;
+	    this.style = div.style;
+	    div.style.cssText = target.cssText;
+	    CSSPlugin.prototype.init.call(this, div, value, tween, index, targets);
+	  },
+	  render: function render(ratio, data) {
+	    var pt = data._pt,
+	        style = data.style,
+	        ss = data.ss,
+	        i;
+
+	    while (pt) {
+	      pt.r(ratio, pt.d);
+	      pt = pt._next;
+	    }
+
+	    i = style.length;
+
+	    while (--i > -1) {
+	      ss[style[i]] = style[style[i]];
+	    }
+	  },
+	  getRule: function getRule(selector) {
+	    _checkRegister();
+
+	    var ruleProp = _doc.all ? "rules" : "cssRules",
+	        styleSheets = _doc.styleSheets,
+	        i = styleSheets.length,
+	        pseudo = selector.charAt(0) === ":",
+	        j,
+	        curSS,
+	        cs,
+	        a;
+	    selector = (pseudo ? "" : ",") + selector.split("::").join(":").toLowerCase() + ",";
+
+	    if (pseudo) {
+	      a = [];
+	    }
+
+	    while (i--) {
+	      try {
+	        curSS = styleSheets[i][ruleProp];
+
+	        if (!curSS) {
+	          continue;
+	        }
+
+	        j = curSS.length;
+	      } catch (e) {
+	        console.warn(e);
+	        continue;
+	      }
+
+	      while (--j > -1) {
+	        cs = curSS[j];
+
+	        if (cs.selectorText && ("," + cs.selectorText.split("::").join(":").toLowerCase() + ",").indexOf(selector) !== -1) {
+	          if (pseudo) {
+	            a.push(cs.style);
+	          } else {
+	            return cs.style;
+	          }
+	        }
+	      }
+	    }
+
+	    return a;
+	  },
+	  register: _initCore
+	};
+	_getGSAP() && gsap.registerPlugin(CSSRulePlugin);
+
+	exports.CSSRulePlugin = CSSRulePlugin;
+	exports.default = CSSRulePlugin;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

network-visualization/node_modules/gsap/dist/CSSRulePlugin.min.js

@@ -0,0 +1,11 @@
+/*!
+ * CSSRulePlugin 3.13.0
+ * https://gsap.com
+ * 
+ * @license Copyright 2025, GreenSock. All rights reserved.
+ * Subject to the terms at https://gsap.com/standard-license.
+ * @author: Jack Doyle, jack@greensock.com
+ */
+
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e=e||self).window=e.window||{})}(this,function(e){"use strict";function h(){return"undefined"!=typeof window}function i(){return t||h()&&(t=window.gsap)&&t.registerPlugin&&t}function j(){return n||(s(),o||console.warn("Please gsap.registerPlugin(CSSPlugin, CSSRulePlugin)")),n}var t,n,c,o,s=function _initCore(e){t=e||i(),h()&&(c=document),t&&(o=t.plugins.css)&&(n=1)},r={version:"3.13.0",name:"cssRule",init:function init(e,t,n,i,s){if(!j()||void 0===e.cssText)return!1;var r=e._gsProxy=e._gsProxy||c.createElement("div");this.ss=e,this.style=r.style,r.style.cssText=e.cssText,o.prototype.init.call(this,r,t,n,i,s)},render:function render(e,t){for(var n,i=t._pt,s=t.style,r=t.ss;i;)i.r(e,i.d),i=i._next;for(n=s.length;-1<--n;)r[s[n]]=s[s[n]]},getRule:function getRule(e){j();var t,n,i,s,r=c.all?"rules":"cssRules",o=c.styleSheets,l=o.length,u=":"===e.charAt(0);for(e=(u?"":",")+e.split("::").join(":").toLowerCase()+",",u&&(s=[]);l--;){try{if(!(n=o[l][r]))continue;t=n.length}catch(e){console.warn(e);continue}for(;-1<--t;)if((i=n[t]).selectorText&&-1!==(","+i.selectorText.split("::").join(":").toLowerCase()+",").indexOf(e)){if(!u)return i.style;s.push(i.style)}}return s},register:s};i()&&t.registerPlugin(r),e.CSSRulePlugin=r,e.default=r;if (typeof(window)==="undefined"||window!==e){Object.defineProperty(e,"__esModule",{value:!0})} else {delete e.default}});
+

network-visualization/node_modules/gsap/dist/CustomBounce.js

@@ -0,0 +1,168 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = global || self, factory(global.window = global.window || {}));
+}(this, (function (exports) { 'use strict';
+
+	/*!
+	 * CustomBounce 3.13.0
+	 * https://gsap.com
+	 *
+	 * @license Copyright 2008-2025, GreenSock. All rights reserved.
+	 * Subject to the terms at https://gsap.com/standard-license
+	 * @author: Jack Doyle, jack@greensock.com
+	*/
+	var gsap,
+	    _coreInitted,
+	    createCustomEase,
+	    _getGSAP = function _getGSAP() {
+	  return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+	},
+	    _initCore = function _initCore(required) {
+	  gsap = _getGSAP();
+	  createCustomEase = gsap && gsap.parseEase("_CE");
+
+	  if (createCustomEase) {
+	    _coreInitted = 1;
+
+	    gsap.parseEase("bounce").config = function (vars) {
+	      return typeof vars === "object" ? _create("", vars) : _create("bounce(" + vars + ")", {
+	        strength: +vars
+	      });
+	    };
+	  } else {
+	    required && console.warn("Please gsap.registerPlugin(CustomEase, CustomBounce)");
+	  }
+	},
+	    _normalizeX = function _normalizeX(a) {
+	  var l = a.length,
+	      s = 1 / a[l - 2],
+	      rnd = 1000,
+	      i;
+
+	  for (i = 2; i < l; i += 2) {
+	    a[i] = ~~(a[i] * s * rnd) / rnd;
+	  }
+
+	  a[l - 2] = 1;
+	},
+	    _create = function _create(id, vars) {
+	  if (!_coreInitted) {
+	    _initCore(1);
+	  }
+
+	  vars = vars || {};
+
+	  {
+	    var max = 0.999,
+	        decay = Math.min(max, vars.strength || 0.7),
+	        decayX = decay,
+	        gap = (vars.squash || 0) / 100,
+	        originalGap = gap,
+	        slope = 1 / 0.03,
+	        w = 0.2,
+	        h = 1,
+	        prevX = 0.1,
+	        path = [0, 0, 0.07, 0, 0.1, 1, 0.1, 1],
+	        squashPath = [0, 0, 0, 0, 0.1, 0, 0.1, 0],
+	        cp1,
+	        cp2,
+	        x,
+	        y,
+	        i,
+	        nextX,
+	        squishMagnitude;
+
+	    for (i = 0; i < 200; i++) {
+	      w *= decayX * ((decayX + 1) / 2);
+	      h *= decay * decay;
+	      nextX = prevX + w;
+	      x = prevX + w * 0.49;
+	      y = 1 - h;
+	      cp1 = prevX + h / slope;
+	      cp2 = x + (x - cp1) * 0.8;
+
+	      if (gap) {
+	        prevX += gap;
+	        cp1 += gap;
+	        x += gap;
+	        cp2 += gap;
+	        nextX += gap;
+	        squishMagnitude = gap / originalGap;
+	        squashPath.push(prevX - gap, 0, prevX - gap, squishMagnitude, prevX - gap / 2, squishMagnitude, prevX, squishMagnitude, prevX, 0, prevX, 0, prevX, squishMagnitude * -0.6, prevX + (nextX - prevX) / 6, 0, nextX, 0);
+	        path.push(prevX - gap, 1, prevX, 1, prevX, 1);
+	        gap *= decay * decay;
+	      }
+
+	      path.push(prevX, 1, cp1, y, x, y, cp2, y, nextX, 1, nextX, 1);
+	      decay *= 0.95;
+	      slope = h / (nextX - cp2);
+	      prevX = nextX;
+
+	      if (y > max) {
+	        break;
+	      }
+	    }
+
+	    if (vars.endAtStart && vars.endAtStart !== "false") {
+	      x = -0.1;
+	      path.unshift(x, 1, x, 1, -0.07, 0);
+
+	      if (originalGap) {
+	        gap = originalGap * 2.5;
+	        x -= gap;
+	        path.unshift(x, 1, x, 1, x, 1);
+	        squashPath.splice(0, 6);
+	        squashPath.unshift(x, 0, x, 0, x, 1, x + gap / 2, 1, x + gap, 1, x + gap, 0, x + gap, 0, x + gap, -0.6, x + gap + 0.033, 0);
+
+	        for (i = 0; i < squashPath.length; i += 2) {
+	          squashPath[i] -= x;
+	        }
+	      }
+
+	      for (i = 0; i < path.length; i += 2) {
+	        path[i] -= x;
+	        path[i + 1] = 1 - path[i + 1];
+	      }
+	    }
+
+	    if (gap) {
+	      _normalizeX(squashPath);
+
+	      squashPath[2] = "C" + squashPath[2];
+	      createCustomEase(vars.squashID || id + "-squash", "M" + squashPath.join(","));
+	    }
+
+	    _normalizeX(path);
+
+	    path[2] = "C" + path[2];
+	    return createCustomEase(id, "M" + path.join(","));
+	  }
+	};
+
+	var CustomBounce = function () {
+	  function CustomBounce(id, vars) {
+	    this.ease = _create(id, vars);
+	  }
+
+	  CustomBounce.create = function create(id, vars) {
+	    return _create(id, vars);
+	  };
+
+	  CustomBounce.register = function register(core) {
+	    gsap = core;
+
+	    _initCore();
+	  };
+
+	  return CustomBounce;
+	}();
+	_getGSAP() && gsap.registerPlugin(CustomBounce);
+	CustomBounce.version = "3.13.0";
+
+	exports.CustomBounce = CustomBounce;
+	exports.default = CustomBounce;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

network-visualization/node_modules/gsap/dist/CustomBounce.min.js

@@ -0,0 +1,11 @@
+/*!
+ * CustomBounce 3.13.0
+ * https://gsap.com
+ * 
+ * @license Copyright 2025, GreenSock. All rights reserved.
+ * Subject to the terms at https://gsap.com/standard-license.
+ * @author: Jack Doyle, jack@greensock.com
+ */
+
+!function(e,n){"object"==typeof exports&&"undefined"!=typeof module?n(exports):"function"==typeof define&&define.amd?define(["exports"],n):n((e=e||self).window=e.window||{})}(this,function(e){"use strict";function g(){return n||"undefined"!=typeof window&&(n=window.gsap)&&n.registerPlugin&&n}function h(e){n=g(),(j=n&&n.parseEase("_CE"))?(b=1,n.parseEase("bounce").config=function(e){return"object"==typeof e?t("",e):t("bounce("+e+")",{strength:+e})}):e&&console.warn("Please gsap.registerPlugin(CustomEase, CustomBounce)")}function i(e){var n,t=e.length,o=1/e[t-2];for(n=2;n<t;n+=2)e[n]=~~(e[n]*o*1e3)/1e3;e[t-2]=1}var n,b,j,t=function _create(e,n){b||h(1),n=n||{};var t,o,u,s,r,f,c,a=Math.min(.999,n.strength||.7),g=a,d=(n.squash||0)/100,p=d,l=1/.03,m=.2,C=1,w=.1,y=[0,0,.07,0,.1,1,.1,1],B=[0,0,0,0,.1,0,.1,0];for(r=0;r<200&&(f=w+(m*=g*((g+1)/2)),s=1-(C*=a*a),o=(u=w+.49*m)+.8*(u-(t=w+C/l)),d&&(w+=d,t+=d,u+=d,o+=d,f+=d,c=d/p,B.push(w-d,0,w-d,c,w-d/2,c,w,c,w,0,w,0,w,-.6*c,w+(f-w)/6,0,f,0),y.push(w-d,1,w,1,w,1),d*=a*a),y.push(w,1,t,s,u,s,o,s,f,1,f,1),a*=.95,l=C/(f-o),w=f,!(.999<s));r++);if(n.endAtStart&&"false"!==n.endAtStart){if(u=-.1,y.unshift(u,1,u,1,-.07,0),p)for(u-=d=2.5*p,y.unshift(u,1,u,1,u,1),B.splice(0,6),B.unshift(u,0,u,0,u,1,u+d/2,1,u+d,1,u+d,0,u+d,0,u+d,-.6,u+d+.033,0),r=0;r<B.length;r+=2)B[r]-=u;for(r=0;r<y.length;r+=2)y[r]-=u,y[r+1]=1-y[r+1]}return d&&(i(B),B[2]="C"+B[2],j(n.squashID||e+"-squash","M"+B.join(","))),i(y),y[2]="C"+y[2],j(e,"M"+y.join(","))},o=(CustomBounce.create=function create(e,n){return t(e,n)},CustomBounce.register=function register(e){n=e,h()},CustomBounce);function CustomBounce(e,n){this.ease=t(e,n)}g()&&n.registerPlugin(o),o.version="3.13.0",e.CustomBounce=o,e.default=o;if (typeof(window)==="undefined"||window!==e){Object.defineProperty(e,"__esModule",{value:!0})} else {delete e.default}});
+

network-visualization/node_modules/gsap/dist/CustomEase.js

@@ -0,0 +1,716 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = global || self, factory(global.window = global.window || {}));
+}(this, (function (exports) { 'use strict';
+
+	var _svgPathExp = /[achlmqstvz]|(-?\d*\.?\d*(?:e[\-+]?\d+)?)[0-9]/ig,
+	    _scientific = /[\+\-]?\d*\.?\d+e[\+\-]?\d+/ig,
+	    _DEG2RAD = Math.PI / 180,
+	    _sin = Math.sin,
+	    _cos = Math.cos,
+	    _abs = Math.abs,
+	    _sqrt = Math.sqrt,
+	    _isNumber = function _isNumber(value) {
+	  return typeof value === "number";
+	},
+	    _roundingNum = 1e5,
+	    _round = function _round(value) {
+	  return Math.round(value * _roundingNum) / _roundingNum || 0;
+	};
+	function transformRawPath(rawPath, a, b, c, d, tx, ty) {
+	  var j = rawPath.length,
+	      segment,
+	      l,
+	      i,
+	      x,
+	      y;
+
+	  while (--j > -1) {
+	    segment = rawPath[j];
+	    l = segment.length;
+
+	    for (i = 0; i < l; i += 2) {
+	      x = segment[i];
+	      y = segment[i + 1];
+	      segment[i] = x * a + y * c + tx;
+	      segment[i + 1] = x * b + y * d + ty;
+	    }
+	  }
+
+	  rawPath._dirty = 1;
+	  return rawPath;
+	}
+
+	function arcToSegment(lastX, lastY, rx, ry, angle, largeArcFlag, sweepFlag, x, y) {
+	  if (lastX === x && lastY === y) {
+	    return;
+	  }
+
+	  rx = _abs(rx);
+	  ry = _abs(ry);
+
+	  var angleRad = angle % 360 * _DEG2RAD,
+	      cosAngle = _cos(angleRad),
+	      sinAngle = _sin(angleRad),
+	      PI = Math.PI,
+	      TWOPI = PI * 2,
+	      dx2 = (lastX - x) / 2,
+	      dy2 = (lastY - y) / 2,
+	      x1 = cosAngle * dx2 + sinAngle * dy2,
+	      y1 = -sinAngle * dx2 + cosAngle * dy2,
+	      x1_sq = x1 * x1,
+	      y1_sq = y1 * y1,
+	      radiiCheck = x1_sq / (rx * rx) + y1_sq / (ry * ry);
+
+	  if (radiiCheck > 1) {
+	    rx = _sqrt(radiiCheck) * rx;
+	    ry = _sqrt(radiiCheck) * ry;
+	  }
+
+	  var rx_sq = rx * rx,
+	      ry_sq = ry * ry,
+	      sq = (rx_sq * ry_sq - rx_sq * y1_sq - ry_sq * x1_sq) / (rx_sq * y1_sq + ry_sq * x1_sq);
+
+	  if (sq < 0) {
+	    sq = 0;
+	  }
+
+	  var coef = (largeArcFlag === sweepFlag ? -1 : 1) * _sqrt(sq),
+	      cx1 = coef * (rx * y1 / ry),
+	      cy1 = coef * -(ry * x1 / rx),
+	      sx2 = (lastX + x) / 2,
+	      sy2 = (lastY + y) / 2,
+	      cx = sx2 + (cosAngle * cx1 - sinAngle * cy1),
+	      cy = sy2 + (sinAngle * cx1 + cosAngle * cy1),
+	      ux = (x1 - cx1) / rx,
+	      uy = (y1 - cy1) / ry,
+	      vx = (-x1 - cx1) / rx,
+	      vy = (-y1 - cy1) / ry,
+	      temp = ux * ux + uy * uy,
+	      angleStart = (uy < 0 ? -1 : 1) * Math.acos(ux / _sqrt(temp)),
+	      angleExtent = (ux * vy - uy * vx < 0 ? -1 : 1) * Math.acos((ux * vx + uy * vy) / _sqrt(temp * (vx * vx + vy * vy)));
+
+	  isNaN(angleExtent) && (angleExtent = PI);
+
+	  if (!sweepFlag && angleExtent > 0) {
+	    angleExtent -= TWOPI;
+	  } else if (sweepFlag && angleExtent < 0) {
+	    angleExtent += TWOPI;
+	  }
+
+	  angleStart %= TWOPI;
+	  angleExtent %= TWOPI;
+
+	  var segments = Math.ceil(_abs(angleExtent) / (TWOPI / 4)),
+	      rawPath = [],
+	      angleIncrement = angleExtent / segments,
+	      controlLength = 4 / 3 * _sin(angleIncrement / 2) / (1 + _cos(angleIncrement / 2)),
+	      ma = cosAngle * rx,
+	      mb = sinAngle * rx,
+	      mc = sinAngle * -ry,
+	      md = cosAngle * ry,
+	      i;
+
+	  for (i = 0; i < segments; i++) {
+	    angle = angleStart + i * angleIncrement;
+	    x1 = _cos(angle);
+	    y1 = _sin(angle);
+	    ux = _cos(angle += angleIncrement);
+	    uy = _sin(angle);
+	    rawPath.push(x1 - controlLength * y1, y1 + controlLength * x1, ux + controlLength * uy, uy - controlLength * ux, ux, uy);
+	  }
+
+	  for (i = 0; i < rawPath.length; i += 2) {
+	    x1 = rawPath[i];
+	    y1 = rawPath[i + 1];
+	    rawPath[i] = x1 * ma + y1 * mc + cx;
+	    rawPath[i + 1] = x1 * mb + y1 * md + cy;
+	  }
+
+	  rawPath[i - 2] = x;
+	  rawPath[i - 1] = y;
+	  return rawPath;
+	}
+
+	function stringToRawPath(d) {
+	  var a = (d + "").replace(_scientific, function (m) {
+	    var n = +m;
+	    return n < 0.0001 && n > -0.0001 ? 0 : n;
+	  }).match(_svgPathExp) || [],
+	      path = [],
+	      relativeX = 0,
+	      relativeY = 0,
+	      twoThirds = 2 / 3,
+	      elements = a.length,
+	      points = 0,
+	      errorMessage = "ERROR: malformed path: " + d,
+	      i,
+	      j,
+	      x,
+	      y,
+	      command,
+	      isRelative,
+	      segment,
+	      startX,
+	      startY,
+	      difX,
+	      difY,
+	      beziers,
+	      prevCommand,
+	      flag1,
+	      flag2,
+	      line = function line(sx, sy, ex, ey) {
+	    difX = (ex - sx) / 3;
+	    difY = (ey - sy) / 3;
+	    segment.push(sx + difX, sy + difY, ex - difX, ey - difY, ex, ey);
+	  };
+
+	  if (!d || !isNaN(a[0]) || isNaN(a[1])) {
+	    console.log(errorMessage);
+	    return path;
+	  }
+
+	  for (i = 0; i < elements; i++) {
+	    prevCommand = command;
+
+	    if (isNaN(a[i])) {
+	      command = a[i].toUpperCase();
+	      isRelative = command !== a[i];
+	    } else {
+	      i--;
+	    }
+
+	    x = +a[i + 1];
+	    y = +a[i + 2];
+
+	    if (isRelative) {
+	      x += relativeX;
+	      y += relativeY;
+	    }
+
+	    if (!i) {
+	      startX = x;
+	      startY = y;
+	    }
+
+	    if (command === "M") {
+	      if (segment) {
+	        if (segment.length < 8) {
+	          path.length -= 1;
+	        } else {
+	          points += segment.length;
+	        }
+	      }
+
+	      relativeX = startX = x;
+	      relativeY = startY = y;
+	      segment = [x, y];
+	      path.push(segment);
+	      i += 2;
+	      command = "L";
+	    } else if (command === "C") {
+	      if (!segment) {
+	        segment = [0, 0];
+	      }
+
+	      if (!isRelative) {
+	        relativeX = relativeY = 0;
+	      }
+
+	      segment.push(x, y, relativeX + a[i + 3] * 1, relativeY + a[i + 4] * 1, relativeX += a[i + 5] * 1, relativeY += a[i + 6] * 1);
+	      i += 6;
+	    } else if (command === "S") {
+	      difX = relativeX;
+	      difY = relativeY;
+
+	      if (prevCommand === "C" || prevCommand === "S") {
+	        difX += relativeX - segment[segment.length - 4];
+	        difY += relativeY - segment[segment.length - 3];
+	      }
+
+	      if (!isRelative) {
+	        relativeX = relativeY = 0;
+	      }
+
+	      segment.push(difX, difY, x, y, relativeX += a[i + 3] * 1, relativeY += a[i + 4] * 1);
+	      i += 4;
+	    } else if (command === "Q") {
+	      difX = relativeX + (x - relativeX) * twoThirds;
+	      difY = relativeY + (y - relativeY) * twoThirds;
+
+	      if (!isRelative) {
+	        relativeX = relativeY = 0;
+	      }
+
+	      relativeX += a[i + 3] * 1;
+	      relativeY += a[i + 4] * 1;
+	      segment.push(difX, difY, relativeX + (x - relativeX) * twoThirds, relativeY + (y - relativeY) * twoThirds, relativeX, relativeY);
+	      i += 4;
+	    } else if (command === "T") {
+	      difX = relativeX - segment[segment.length - 4];
+	      difY = relativeY - segment[segment.length - 3];
+	      segment.push(relativeX + difX, relativeY + difY, x + (relativeX + difX * 1.5 - x) * twoThirds, y + (relativeY + difY * 1.5 - y) * twoThirds, relativeX = x, relativeY = y);
+	      i += 2;
+	    } else if (command === "H") {
+	      line(relativeX, relativeY, relativeX = x, relativeY);
+	      i += 1;
+	    } else if (command === "V") {
+	      line(relativeX, relativeY, relativeX, relativeY = x + (isRelative ? relativeY - relativeX : 0));
+	      i += 1;
+	    } else if (command === "L" || command === "Z") {
+	      if (command === "Z") {
+	        x = startX;
+	        y = startY;
+	        segment.closed = true;
+	      }
+
+	      if (command === "L" || _abs(relativeX - x) > 0.5 || _abs(relativeY - y) > 0.5) {
+	        line(relativeX, relativeY, x, y);
+
+	        if (command === "L") {
+	          i += 2;
+	        }
+	      }
+
+	      relativeX = x;
+	      relativeY = y;
+	    } else if (command === "A") {
+	      flag1 = a[i + 4];
+	      flag2 = a[i + 5];
+	      difX = a[i + 6];
+	      difY = a[i + 7];
+	      j = 7;
+
+	      if (flag1.length > 1) {
+	        if (flag1.length < 3) {
+	          difY = difX;
+	          difX = flag2;
+	          j--;
+	        } else {
+	          difY = flag2;
+	          difX = flag1.substr(2);
+	          j -= 2;
+	        }
+
+	        flag2 = flag1.charAt(1);
+	        flag1 = flag1.charAt(0);
+	      }
+
+	      beziers = arcToSegment(relativeX, relativeY, +a[i + 1], +a[i + 2], +a[i + 3], +flag1, +flag2, (isRelative ? relativeX : 0) + difX * 1, (isRelative ? relativeY : 0) + difY * 1);
+	      i += j;
+
+	      if (beziers) {
+	        for (j = 0; j < beziers.length; j++) {
+	          segment.push(beziers[j]);
+	        }
+	      }
+
+	      relativeX = segment[segment.length - 2];
+	      relativeY = segment[segment.length - 1];
+	    } else {
+	      console.log(errorMessage);
+	    }
+	  }
+
+	  i = segment.length;
+
+	  if (i < 6) {
+	    path.pop();
+	    i = 0;
+	  } else if (segment[0] === segment[i - 2] && segment[1] === segment[i - 1]) {
+	    segment.closed = true;
+	  }
+
+	  path.totalPoints = points + i;
+	  return path;
+	}
+	function rawPathToString(rawPath) {
+	  if (_isNumber(rawPath[0])) {
+	    rawPath = [rawPath];
+	  }
+
+	  var result = "",
+	      l = rawPath.length,
+	      sl,
+	      s,
+	      i,
+	      segment;
+
+	  for (s = 0; s < l; s++) {
+	    segment = rawPath[s];
+	    result += "M" + _round(segment[0]) + "," + _round(segment[1]) + " C";
+	    sl = segment.length;
+
+	    for (i = 2; i < sl; i++) {
+	      result += _round(segment[i++]) + "," + _round(segment[i++]) + " " + _round(segment[i++]) + "," + _round(segment[i++]) + " " + _round(segment[i++]) + "," + _round(segment[i]) + " ";
+	    }
+
+	    if (segment.closed) {
+	      result += "z";
+	    }
+	  }
+
+	  return result;
+	}
+
+	/*!
+	 * CustomEase 3.13.0
+	 * https://gsap.com
+	 *
+	 * @license Copyright 2008-2025, GreenSock. All rights reserved.
+	 * Subject to the terms at https://gsap.com/standard-license
+	 * @author: Jack Doyle, jack@greensock.com
+	*/
+
+	var gsap,
+	    _coreInitted,
+	    _getGSAP = function _getGSAP() {
+	  return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+	},
+	    _initCore = function _initCore() {
+	  gsap = _getGSAP();
+
+	  if (gsap) {
+	    gsap.registerEase("_CE", CustomEase.create);
+	    _coreInitted = 1;
+	  } else {
+	    console.warn("Please gsap.registerPlugin(CustomEase)");
+	  }
+	},
+	    _bigNum = 1e20,
+	    _round$1 = function _round(value) {
+	  return ~~(value * 1000 + (value < 0 ? -.5 : .5)) / 1000;
+	},
+	    _numExp = /[-+=.]*\d+[.e\-+]*\d*[e\-+]*\d*/gi,
+	    _needsParsingExp = /[cLlsSaAhHvVtTqQ]/g,
+	    _findMinimum = function _findMinimum(values) {
+	  var l = values.length,
+	      min = _bigNum,
+	      i;
+
+	  for (i = 1; i < l; i += 6) {
+	    +values[i] < min && (min = +values[i]);
+	  }
+
+	  return min;
+	},
+	    _normalize = function _normalize(values, height, originY) {
+	  if (!originY && originY !== 0) {
+	    originY = Math.max(+values[values.length - 1], +values[1]);
+	  }
+
+	  var tx = +values[0] * -1,
+	      ty = -originY,
+	      l = values.length,
+	      sx = 1 / (+values[l - 2] + tx),
+	      sy = -height || (Math.abs(+values[l - 1] - +values[1]) < 0.01 * (+values[l - 2] - +values[0]) ? _findMinimum(values) + ty : +values[l - 1] + ty),
+	      i;
+
+	  if (sy) {
+	    sy = 1 / sy;
+	  } else {
+	    sy = -sx;
+	  }
+
+	  for (i = 0; i < l; i += 2) {
+	    values[i] = (+values[i] + tx) * sx;
+	    values[i + 1] = (+values[i + 1] + ty) * sy;
+	  }
+	},
+	    _bezierToPoints = function _bezierToPoints(x1, y1, x2, y2, x3, y3, x4, y4, threshold, points, index) {
+	  var x12 = (x1 + x2) / 2,
+	      y12 = (y1 + y2) / 2,
+	      x23 = (x2 + x3) / 2,
+	      y23 = (y2 + y3) / 2,
+	      x34 = (x3 + x4) / 2,
+	      y34 = (y3 + y4) / 2,
+	      x123 = (x12 + x23) / 2,
+	      y123 = (y12 + y23) / 2,
+	      x234 = (x23 + x34) / 2,
+	      y234 = (y23 + y34) / 2,
+	      x1234 = (x123 + x234) / 2,
+	      y1234 = (y123 + y234) / 2,
+	      dx = x4 - x1,
+	      dy = y4 - y1,
+	      d2 = Math.abs((x2 - x4) * dy - (y2 - y4) * dx),
+	      d3 = Math.abs((x3 - x4) * dy - (y3 - y4) * dx),
+	      length;
+
+	  if (!points) {
+	    points = [{
+	      x: x1,
+	      y: y1
+	    }, {
+	      x: x4,
+	      y: y4
+	    }];
+	    index = 1;
+	  }
+
+	  points.splice(index || points.length - 1, 0, {
+	    x: x1234,
+	    y: y1234
+	  });
+
+	  if ((d2 + d3) * (d2 + d3) > threshold * (dx * dx + dy * dy)) {
+	    length = points.length;
+
+	    _bezierToPoints(x1, y1, x12, y12, x123, y123, x1234, y1234, threshold, points, index);
+
+	    _bezierToPoints(x1234, y1234, x234, y234, x34, y34, x4, y4, threshold, points, index + 1 + (points.length - length));
+	  }
+
+	  return points;
+	};
+
+	var CustomEase = function () {
+	  function CustomEase(id, data, config) {
+	    _coreInitted || _initCore();
+	    this.id = id;
+	     this.setData(data, config);
+	  }
+
+	  var _proto = CustomEase.prototype;
+
+	  _proto.setData = function setData(data, config) {
+	    config = config || {};
+	    data = data || "0,0,1,1";
+	    var values = data.match(_numExp),
+	        closest = 1,
+	        points = [],
+	        lookup = [],
+	        precision = config.precision || 1,
+	        fast = precision <= 1,
+	        l,
+	        a1,
+	        a2,
+	        i,
+	        inc,
+	        j,
+	        point,
+	        prevPoint,
+	        p;
+	    this.data = data;
+
+	    if (_needsParsingExp.test(data) || ~data.indexOf("M") && data.indexOf("C") < 0) {
+	      values = stringToRawPath(data)[0];
+	    }
+
+	    l = values.length;
+
+	    if (l === 4) {
+	      values.unshift(0, 0);
+	      values.push(1, 1);
+	      l = 8;
+	    } else if ((l - 2) % 6) {
+	      throw "Invalid CustomEase";
+	    }
+
+	    if (+values[0] !== 0 || +values[l - 2] !== 1) {
+	      _normalize(values, config.height, config.originY);
+	    }
+
+	    this.segment = values;
+
+	    for (i = 2; i < l; i += 6) {
+	      a1 = {
+	        x: +values[i - 2],
+	        y: +values[i - 1]
+	      };
+	      a2 = {
+	        x: +values[i + 4],
+	        y: +values[i + 5]
+	      };
+	      points.push(a1, a2);
+
+	      _bezierToPoints(a1.x, a1.y, +values[i], +values[i + 1], +values[i + 2], +values[i + 3], a2.x, a2.y, 1 / (precision * 200000), points, points.length - 1);
+	    }
+
+	    l = points.length;
+
+	    for (i = 0; i < l; i++) {
+	      point = points[i];
+	      prevPoint = points[i - 1] || point;
+
+	      if ((point.x > prevPoint.x || prevPoint.y !== point.y && prevPoint.x === point.x || point === prevPoint) && point.x <= 1) {
+	        prevPoint.cx = point.x - prevPoint.x;
+	        prevPoint.cy = point.y - prevPoint.y;
+	        prevPoint.n = point;
+	        prevPoint.nx = point.x;
+
+	        if (fast && i > 1 && Math.abs(prevPoint.cy / prevPoint.cx - points[i - 2].cy / points[i - 2].cx) > 2) {
+	          fast = 0;
+	        }
+
+	        if (prevPoint.cx < closest) {
+	          if (!prevPoint.cx) {
+	            prevPoint.cx = 0.001;
+
+	            if (i === l - 1) {
+	              prevPoint.x -= 0.001;
+	              closest = Math.min(closest, 0.001);
+	              fast = 0;
+	            }
+	          } else {
+	            closest = prevPoint.cx;
+	          }
+	        }
+	      } else {
+	        points.splice(i--, 1);
+	        l--;
+	      }
+	    }
+
+	    l = 1 / closest + 1 | 0;
+	    inc = 1 / l;
+	    j = 0;
+	    point = points[0];
+
+	    if (fast) {
+	      for (i = 0; i < l; i++) {
+	        p = i * inc;
+
+	        if (point.nx < p) {
+	          point = points[++j];
+	        }
+
+	        a1 = point.y + (p - point.x) / point.cx * point.cy;
+	        lookup[i] = {
+	          x: p,
+	          cx: inc,
+	          y: a1,
+	          cy: 0,
+	          nx: 9
+	        };
+
+	        if (i) {
+	          lookup[i - 1].cy = a1 - lookup[i - 1].y;
+	        }
+	      }
+
+	      j = points[points.length - 1];
+	      lookup[l - 1].cy = j.y - a1;
+	      lookup[l - 1].cx = j.x - lookup[lookup.length - 1].x;
+	    } else {
+	      for (i = 0; i < l; i++) {
+	        if (point.nx < i * inc) {
+	          point = points[++j];
+	        }
+
+	        lookup[i] = point;
+	      }
+
+	      if (j < points.length - 1) {
+	        lookup[i - 1] = points[points.length - 2];
+	      }
+	    }
+
+	    this.ease = function (p) {
+	      var point = lookup[p * l | 0] || lookup[l - 1];
+
+	      if (point.nx < p) {
+	        point = point.n;
+	      }
+
+	      return point.y + (p - point.x) / point.cx * point.cy;
+	    };
+
+	    this.ease.custom = this;
+	    this.id && gsap && gsap.registerEase(this.id, this.ease);
+	    return this;
+	  };
+
+	  _proto.getSVGData = function getSVGData(config) {
+	    return CustomEase.getSVGData(this, config);
+	  };
+
+	  CustomEase.create = function create(id, data, config) {
+	    return new CustomEase(id, data, config).ease;
+	  };
+
+	  CustomEase.register = function register(core) {
+	    gsap = core;
+
+	    _initCore();
+	  };
+
+	  CustomEase.get = function get(id) {
+	    return gsap.parseEase(id);
+	  };
+
+	  CustomEase.getSVGData = function getSVGData(ease, config) {
+	    config = config || {};
+	    var width = config.width || 100,
+	        height = config.height || 100,
+	        x = config.x || 0,
+	        y = (config.y || 0) + height,
+	        e = gsap.utils.toArray(config.path)[0],
+	        a,
+	        slope,
+	        i,
+	        inc,
+	        tx,
+	        ty,
+	        precision,
+	        threshold,
+	        prevX,
+	        prevY;
+
+	    if (config.invert) {
+	      height = -height;
+	      y = 0;
+	    }
+
+	    if (typeof ease === "string") {
+	      ease = gsap.parseEase(ease);
+	    }
+
+	    if (ease.custom) {
+	      ease = ease.custom;
+	    }
+
+	    if (ease instanceof CustomEase) {
+	      a = rawPathToString(transformRawPath([ease.segment], width, 0, 0, -height, x, y));
+	    } else {
+	      a = [x, y];
+	      precision = Math.max(5, (config.precision || 1) * 200);
+	      inc = 1 / precision;
+	      precision += 2;
+	      threshold = 5 / precision;
+	      prevX = _round$1(x + inc * width);
+	      prevY = _round$1(y + ease(inc) * -height);
+	      slope = (prevY - y) / (prevX - x);
+
+	      for (i = 2; i < precision; i++) {
+	        tx = _round$1(x + i * inc * width);
+	        ty = _round$1(y + ease(i * inc) * -height);
+
+	        if (Math.abs((ty - prevY) / (tx - prevX) - slope) > threshold || i === precision - 1) {
+	          a.push(prevX, prevY);
+	          slope = (ty - prevY) / (tx - prevX);
+	        }
+
+	        prevX = tx;
+	        prevY = ty;
+	      }
+
+	      a = "M" + a.join(",");
+	    }
+
+	    e && e.setAttribute("d", a);
+	    return a;
+	  };
+
+	  return CustomEase;
+	}();
+	CustomEase.version = "3.13.0";
+	CustomEase.headless = true;
+	_getGSAP() && gsap.registerPlugin(CustomEase);
+
+	exports.CustomEase = CustomEase;
+	exports.default = CustomEase;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

network-visualization/node_modules/gsap/dist/CustomWiggle.js

@@ -0,0 +1,167 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = global || self, factory(global.window = global.window || {}));
+}(this, (function (exports) { 'use strict';
+
+	/*!
+	 * CustomWiggle 3.13.0
+	 * https://gsap.com
+	 *
+	 * @license Copyright 2008-2025, GreenSock. All rights reserved.
+	 * Subject to the terms at https://gsap.com/standard-license
+	 * @author: Jack Doyle, jack@greensock.com
+	*/
+	var gsap,
+	    _coreInitted,
+	    createCustomEase,
+	    _getGSAP = function _getGSAP() {
+	  return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+	},
+	    _eases = {
+	  easeOut: "M0,1,C0.7,1,0.6,0,1,0",
+	  easeInOut: "M0,0,C0.1,0,0.24,1,0.444,1,0.644,1,0.6,0,1,0",
+	  anticipate: "M0,0,C0,0.222,0.024,0.386,0,0.4,0.18,0.455,0.65,0.646,0.7,0.67,0.9,0.76,1,0.846,1,1",
+	  uniform: "M0,0,C0,0.95,0,1,0,1,0,1,1,1,1,1,1,1,1,0,1,0"
+	},
+	    _linearEase = function _linearEase(p) {
+	  return p;
+	},
+	    _initCore = function _initCore(required) {
+	  if (!_coreInitted) {
+	    gsap = _getGSAP();
+	    createCustomEase = gsap && gsap.parseEase("_CE");
+
+	    if (createCustomEase) {
+	      for (var p in _eases) {
+	        _eases[p] = createCustomEase("", _eases[p]);
+	      }
+
+	      _coreInitted = 1;
+
+	      _create("wiggle").config = function (vars) {
+	        return typeof vars === "object" ? _create("", vars) : _create("wiggle(" + vars + ")", {
+	          wiggles: +vars
+	        });
+	      };
+	    } else {
+	      required && console.warn("Please gsap.registerPlugin(CustomEase, CustomWiggle)");
+	    }
+	  }
+	},
+	    _parseEase = function _parseEase(ease, invertNonCustomEases) {
+	  if (typeof ease !== "function") {
+	    ease = gsap.parseEase(ease) || createCustomEase("", ease);
+	  }
+
+	  return ease.custom || !invertNonCustomEases ? ease : function (p) {
+	    return 1 - ease(p);
+	  };
+	},
+	    _create = function _create(id, vars) {
+	  if (!_coreInitted) {
+	    _initCore(1);
+	  }
+
+	  vars = vars || {};
+	  var wiggles = (vars.wiggles || 10) | 0,
+	      inc = 1 / wiggles,
+	      x = inc / 2,
+	      anticipate = vars.type === "anticipate",
+	      yEase = _eases[vars.type] || _eases.easeOut,
+	      xEase = _linearEase,
+	      rnd = 1000,
+	      nextX,
+	      nextY,
+	      angle,
+	      handleX,
+	      handleY,
+	      easedX,
+	      y,
+	      path,
+	      i;
+
+	  {
+	    if (anticipate) {
+	      xEase = yEase;
+	      yEase = _eases.easeOut;
+	    }
+
+	    if (vars.timingEase) {
+	      xEase = _parseEase(vars.timingEase);
+	    }
+
+	    if (vars.amplitudeEase) {
+	      yEase = _parseEase(vars.amplitudeEase, true);
+	    }
+
+	    easedX = xEase(x);
+	    y = anticipate ? -yEase(x) : yEase(x);
+	    path = [0, 0, easedX / 4, 0, easedX / 2, y, easedX, y];
+
+	    if (vars.type === "random") {
+	      path.length = 4;
+	      nextX = xEase(inc);
+	      nextY = Math.random() * 2 - 1;
+
+	      for (i = 2; i < wiggles; i++) {
+	        x = nextX;
+	        y = nextY;
+	        nextX = xEase(inc * i);
+	        nextY = Math.random() * 2 - 1;
+	        angle = Math.atan2(nextY - path[path.length - 3], nextX - path[path.length - 4]);
+	        handleX = Math.cos(angle) * inc;
+	        handleY = Math.sin(angle) * inc;
+	        path.push(x - handleX, y - handleY, x, y, x + handleX, y + handleY);
+	      }
+
+	      path.push(nextX, 0, 1, 0);
+	    } else {
+	      for (i = 1; i < wiggles; i++) {
+	        path.push(xEase(x + inc / 2), y);
+	        x += inc;
+	        y = (y > 0 ? -1 : 1) * yEase(i * inc);
+	        easedX = xEase(x);
+	        path.push(xEase(x - inc / 2), y, easedX, y);
+	      }
+
+	      path.push(xEase(x + inc / 4), y, xEase(x + inc / 4), 0, 1, 0);
+	    }
+
+	    i = path.length;
+
+	    while (--i > -1) {
+	      path[i] = ~~(path[i] * rnd) / rnd;
+	    }
+
+	    path[2] = "C" + path[2];
+	    return createCustomEase(id, "M" + path.join(","));
+	  }
+	};
+
+	var CustomWiggle = function () {
+	  function CustomWiggle(id, vars) {
+	    this.ease = _create(id, vars);
+	  }
+
+	  CustomWiggle.create = function create(id, vars) {
+	    return _create(id, vars);
+	  };
+
+	  CustomWiggle.register = function register(core) {
+	    gsap = core;
+
+	    _initCore();
+	  };
+
+	  return CustomWiggle;
+	}();
+	_getGSAP() && gsap.registerPlugin(CustomWiggle);
+	CustomWiggle.version = "3.13.0";
+
+	exports.CustomWiggle = CustomWiggle;
+	exports.default = CustomWiggle;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

network-visualization/node_modules/gsap/dist/CustomWiggle.min.js

@@ -0,0 +1,11 @@
+/*!
+ * CustomWiggle 3.13.0
+ * https://gsap.com
+ * 
+ * @license Copyright 2025, GreenSock. All rights reserved.
+ * Subject to the terms at https://gsap.com/standard-license.
+ * @author: Jack Doyle, jack@greensock.com
+ */
+
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e=e||self).window=e.window||{})}(this,function(e){"use strict";function g(){return n||"undefined"!=typeof window&&(n=window.gsap)&&n.registerPlugin&&n}function i(e){return e}function j(e){if(!C)if(n=g(),M=n&&n.parseEase("_CE")){for(var t in y)y[t]=M("",y[t]);C=1,o("wiggle").config=function(e){return"object"==typeof e?o("",e):o("wiggle("+e+")",{wiggles:+e})}}else e&&console.warn("Please gsap.registerPlugin(CustomEase, CustomWiggle)")}function k(t,e){return"function"!=typeof t&&(t=n.parseEase(t)||M("",t)),t.custom||!e?t:function(e){return 1-t(e)}}var n,C,M,y={easeOut:"M0,1,C0.7,1,0.6,0,1,0",easeInOut:"M0,0,C0.1,0,0.24,1,0.444,1,0.644,1,0.6,0,1,0",anticipate:"M0,0,C0,0.222,0.024,0.386,0,0.4,0.18,0.455,0.65,0.646,0.7,0.67,0.9,0.76,1,0.846,1,1",uniform:"M0,0,C0,0.95,0,1,0,1,0,1,1,1,1,1,1,1,1,0,1,0"},o=function _create(e,t){C||j(1);var n,o,s,u,r,a,g,f,l,c=0|((t=t||{}).wiggles||10),p=1/c,d=p/2,m="anticipate"===t.type,h=y[t.type]||y.easeOut,w=i;if(m&&(w=h,h=y.easeOut),t.timingEase&&(w=k(t.timingEase)),t.amplitudeEase&&(h=k(t.amplitudeEase,!0)),f=[0,0,(a=w(d))/4,0,a/2,g=m?-h(d):h(d),a,g],"random"===t.type){for(f.length=4,n=w(p),o=2*Math.random()-1,l=2;l<c;l++)d=n,g=o,n=w(p*l),o=2*Math.random()-1,s=Math.atan2(o-f[f.length-3],n-f[f.length-4]),u=Math.cos(s)*p,r=Math.sin(s)*p,f.push(d-u,g-r,d,g,d+u,g+r);f.push(n,0,1,0)}else{for(l=1;l<c;l++)f.push(w(d+p/2),g),d+=p,g=(0<g?-1:1)*h(l*p),a=w(d),f.push(w(d-p/2),g,a,g);f.push(w(d+p/4),g,w(d+p/4),0,1,0)}for(l=f.length;-1<--l;)f[l]=~~(1e3*f[l])/1e3;return f[2]="C"+f[2],M(e,"M"+f.join(","))},t=(CustomWiggle.create=function create(e,t){return o(e,t)},CustomWiggle.register=function register(e){n=e,j()},CustomWiggle);function CustomWiggle(e,t){this.ease=o(e,t)}g()&&n.registerPlugin(t),t.version="3.13.0",e.CustomWiggle=t,e.default=t;if (typeof(window)==="undefined"||window!==e){Object.defineProperty(e,"__esModule",{value:!0})} else {delete e.default}});
+

network-visualization/node_modules/gsap/dist/DrawSVGPlugin.js

@@ -0,0 +1,310 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = global || self, factory(global.window = global.window || {}));
+}(this, (function (exports) { 'use strict';
+
+	/*!
+	 * DrawSVGPlugin 3.13.0
+	 * https://gsap.com
+	 *
+	 * @license Copyright 2008-2025, GreenSock. All rights reserved.
+	 * Subject to the terms at https://gsap.com/standard-license
+	 * @author: Jack Doyle, jack@greensock.com
+	*/
+	var gsap,
+	    _toArray,
+	    _win,
+	    _isEdge,
+	    _coreInitted,
+	    _warned,
+	    _getStyleSaver,
+	    _reverting,
+	    _windowExists = function _windowExists() {
+	  return typeof window !== "undefined";
+	},
+	    _getGSAP = function _getGSAP() {
+	  return gsap || _windowExists() && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+	},
+	    _numExp = /[-+=\.]*\d+[\.e\-\+]*\d*[e\-\+]*\d*/gi,
+	    _types = {
+	  rect: ["width", "height"],
+	  circle: ["r", "r"],
+	  ellipse: ["rx", "ry"],
+	  line: ["x2", "y2"]
+	},
+	    _round = function _round(value) {
+	  return Math.round(value * 10000) / 10000;
+	},
+	    _parseNum = function _parseNum(value) {
+	  return parseFloat(value) || 0;
+	},
+	    _parseSingleVal = function _parseSingleVal(value, length) {
+	  var num = _parseNum(value);
+
+	  return ~value.indexOf("%") ? num / 100 * length : num;
+	},
+	    _getAttributeAsNumber = function _getAttributeAsNumber(target, attr) {
+	  return _parseNum(target.getAttribute(attr));
+	},
+	    _sqrt = Math.sqrt,
+	    _getDistance = function _getDistance(x1, y1, x2, y2, scaleX, scaleY) {
+	  return _sqrt(Math.pow((_parseNum(x2) - _parseNum(x1)) * scaleX, 2) + Math.pow((_parseNum(y2) - _parseNum(y1)) * scaleY, 2));
+	},
+	    _warn = function _warn(message) {
+	  return console.warn(message);
+	},
+	    _hasNonScalingStroke = function _hasNonScalingStroke(target) {
+	  return target.getAttribute("vector-effect") === "non-scaling-stroke";
+	},
+	    _bonusValidated = 1,
+	    _parse = function _parse(value, length, defaultStart) {
+	  var i = value.indexOf(" "),
+	      s,
+	      e;
+
+	  if (i < 0) {
+	    s = defaultStart !== undefined ? defaultStart + "" : value;
+	    e = value;
+	  } else {
+	    s = value.substr(0, i);
+	    e = value.substr(i + 1);
+	  }
+
+	  s = _parseSingleVal(s, length);
+	  e = _parseSingleVal(e, length);
+	  return s > e ? [e, s] : [s, e];
+	},
+	    _getLength = function _getLength(target) {
+	  target = _toArray(target)[0];
+
+	  if (!target) {
+	    return 0;
+	  }
+
+	  var type = target.tagName.toLowerCase(),
+	      style = target.style,
+	      scaleX = 1,
+	      scaleY = 1,
+	      length,
+	      bbox,
+	      points,
+	      prevPoint,
+	      i,
+	      rx,
+	      ry;
+
+	  if (_hasNonScalingStroke(target)) {
+	    scaleY = target.getScreenCTM();
+	    scaleX = _sqrt(scaleY.a * scaleY.a + scaleY.b * scaleY.b);
+	    scaleY = _sqrt(scaleY.d * scaleY.d + scaleY.c * scaleY.c);
+	  }
+
+	  try {
+	    bbox = target.getBBox();
+	  } catch (e) {
+	    _warn("Some browsers won't measure invisible elements (like display:none or masks inside defs).");
+	  }
+
+	  var _ref = bbox || {
+	    x: 0,
+	    y: 0,
+	    width: 0,
+	    height: 0
+	  },
+	      x = _ref.x,
+	      y = _ref.y,
+	      width = _ref.width,
+	      height = _ref.height;
+
+	  if ((!bbox || !width && !height) && _types[type]) {
+	    width = _getAttributeAsNumber(target, _types[type][0]);
+	    height = _getAttributeAsNumber(target, _types[type][1]);
+
+	    if (type !== "rect" && type !== "line") {
+	      width *= 2;
+	      height *= 2;
+	    }
+
+	    if (type === "line") {
+	      x = _getAttributeAsNumber(target, "x1");
+	      y = _getAttributeAsNumber(target, "y1");
+	      width = Math.abs(width - x);
+	      height = Math.abs(height - y);
+	    }
+	  }
+
+	  if (type === "path") {
+	    prevPoint = style.strokeDasharray;
+	    style.strokeDasharray = "none";
+	    length = target.getTotalLength() || 0;
+	    _round(scaleX) !== _round(scaleY) && !_warned && (_warned = 1) && _warn("Warning: <path> length cannot be measured when vector-effect is non-scaling-stroke and the element isn't proportionally scaled.");
+	    length *= (scaleX + scaleY) / 2;
+	    style.strokeDasharray = prevPoint;
+	  } else if (type === "rect") {
+	    length = width * 2 * scaleX + height * 2 * scaleY;
+	  } else if (type === "line") {
+	    length = _getDistance(x, y, x + width, y + height, scaleX, scaleY);
+	  } else if (type === "polyline" || type === "polygon") {
+	    points = target.getAttribute("points").match(_numExp) || [];
+	    type === "polygon" && points.push(points[0], points[1]);
+	    length = 0;
+
+	    for (i = 2; i < points.length; i += 2) {
+	      length += _getDistance(points[i - 2], points[i - 1], points[i], points[i + 1], scaleX, scaleY) || 0;
+	    }
+	  } else if (type === "circle" || type === "ellipse") {
+	    rx = width / 2 * scaleX;
+	    ry = height / 2 * scaleY;
+	    length = Math.PI * (3 * (rx + ry) - _sqrt((3 * rx + ry) * (rx + 3 * ry)));
+	  }
+
+	  return length || 0;
+	},
+	    _getPosition = function _getPosition(target, length) {
+	  target = _toArray(target)[0];
+
+	  if (!target) {
+	    return [0, 0];
+	  }
+
+	  length || (length = _getLength(target) + 1);
+
+	  var cs = _win.getComputedStyle(target),
+	      dash = cs.strokeDasharray || "",
+	      offset = _parseNum(cs.strokeDashoffset),
+	      i = dash.indexOf(",");
+
+	  i < 0 && (i = dash.indexOf(" "));
+	  dash = i < 0 ? length : _parseNum(dash.substr(0, i));
+	  dash > length && (dash = length);
+	  return [-offset || 0, dash - offset || 0];
+	},
+	    _initCore = function _initCore() {
+	  if (_windowExists()) {
+	    _win = window;
+	    _coreInitted = gsap = _getGSAP();
+	    _toArray = gsap.utils.toArray;
+	    _getStyleSaver = gsap.core.getStyleSaver;
+
+	    _reverting = gsap.core.reverting || function () {};
+
+	    _isEdge = ((_win.navigator || {}).userAgent || "").indexOf("Edge") !== -1;
+	  }
+	};
+
+	var DrawSVGPlugin = {
+	  version: "3.13.0",
+	  name: "drawSVG",
+	  register: function register(core) {
+	    gsap = core;
+
+	    _initCore();
+	  },
+	  init: function init(target, value, tween, index, targets) {
+	    if (!target.getBBox) {
+	      return false;
+	    }
+
+	    _coreInitted || _initCore();
+
+	    var length = _getLength(target),
+	        start,
+	        end,
+	        cs;
+
+	    this.styles = _getStyleSaver && _getStyleSaver(target, "strokeDashoffset,strokeDasharray,strokeMiterlimit");
+	    this.tween = tween;
+	    this._style = target.style;
+	    this._target = target;
+
+	    if (value + "" === "true") {
+	      value = "0 100%";
+	    } else if (!value) {
+	      value = "0 0";
+	    } else if ((value + "").indexOf(" ") === -1) {
+	      value = "0 " + value;
+	    }
+
+	    start = _getPosition(target, length);
+	    end = _parse(value, length, start[0]);
+	    this._length = _round(length);
+	    this._dash = _round(start[1] - start[0]);
+	    this._offset = _round(-start[0]);
+	    this._dashPT = this.add(this, "_dash", this._dash, _round(end[1] - end[0]), 0, 0, 0, 0, 0, 1);
+	    this._offsetPT = this.add(this, "_offset", this._offset, _round(-end[0]), 0, 0, 0, 0, 0, 1);
+
+	    if (_isEdge) {
+	      cs = _win.getComputedStyle(target);
+
+	      if (cs.strokeLinecap !== cs.strokeLinejoin) {
+	        end = _parseNum(cs.strokeMiterlimit);
+	        this.add(target.style, "strokeMiterlimit", end, end + 0.01);
+	      }
+	    }
+
+	    this._live = _hasNonScalingStroke(target) || ~(value + "").indexOf("live");
+	    this._nowrap = ~(value + "").indexOf("nowrap");
+
+	    this._props.push("drawSVG");
+
+	    return _bonusValidated;
+	  },
+	  render: function render(ratio, data) {
+	    if (data.tween._time || !_reverting()) {
+	      var pt = data._pt,
+	          style = data._style,
+	          length,
+	          lengthRatio,
+	          dash,
+	          offset;
+
+	      if (pt) {
+	        if (data._live) {
+	          length = _getLength(data._target);
+
+	          if (length !== data._length) {
+	            lengthRatio = length / data._length;
+	            data._length = length;
+
+	            if (data._offsetPT) {
+	              data._offsetPT.s *= lengthRatio;
+	              data._offsetPT.c *= lengthRatio;
+	            }
+
+	            if (data._dashPT) {
+	              data._dashPT.s *= lengthRatio;
+	              data._dashPT.c *= lengthRatio;
+	            } else {
+	              data._dash *= lengthRatio;
+	            }
+	          }
+	        }
+
+	        while (pt) {
+	          pt.r(ratio, pt.d);
+	          pt = pt._next;
+	        }
+
+	        dash = data._dash || ratio && ratio !== 1 && 0.0001 || 0;
+	        length = data._length - dash + 0.1;
+	        offset = data._offset;
+	        dash && offset && dash + Math.abs(offset % data._length) > data._length - 0.05 && (offset += offset < 0 ? 0.005 : -0.005) && (length += 0.005);
+	        style.strokeDashoffset = dash ? offset : offset + 0.001;
+	        style.strokeDasharray = length < 0.1 ? "none" : dash ? dash + "px," + (data._nowrap ? 999999 : length) + "px" : "0px, 999999px";
+	      }
+	    } else {
+	      data.styles.revert();
+	    }
+	  },
+	  getLength: _getLength,
+	  getPosition: _getPosition
+	};
+	_getGSAP() && gsap.registerPlugin(DrawSVGPlugin);
+
+	exports.DrawSVGPlugin = DrawSVGPlugin;
+	exports.default = DrawSVGPlugin;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

network-visualization/node_modules/gsap/dist/DrawSVGPlugin.min.js

@@ -0,0 +1,11 @@
+/*!
+ * DrawSVGPlugin 3.13.0
+ * https://gsap.com
+ * 
+ * @license Copyright 2025, GreenSock. All rights reserved.
+ * Subject to the terms at https://gsap.com/standard-license.
+ * @author: Jack Doyle, jack@greensock.com
+ */
+
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e=e||self).window=e.window||{})}(this,function(e){"use strict";function l(){return"undefined"!=typeof window}function m(){return t||l()&&(t=window.gsap)&&t.registerPlugin&&t}function p(e){return Math.round(1e4*e)/1e4}function q(e){return parseFloat(e)||0}function r(e,t){var r=q(e);return~e.indexOf("%")?r/100*t:r}function s(e,t){return q(e.getAttribute(t))}function u(e,t,r,n,s,i){return D(Math.pow((q(r)-q(e))*s,2)+Math.pow((q(n)-q(t))*i,2))}function v(e){return console.warn(e)}function w(e){return"non-scaling-stroke"===e.getAttribute("vector-effect")}function z(e){if(!(e=k(e)[0]))return 0;var t,r,n,i,o,a,f,h=e.tagName.toLowerCase(),l=e.style,d=1,c=1;w(e)&&(c=e.getScreenCTM(),d=D(c.a*c.a+c.b*c.b),c=D(c.d*c.d+c.c*c.c));try{r=e.getBBox()}catch(e){v("Some browsers won't measure invisible elements (like display:none or masks inside defs).")}var g=r||{x:0,y:0,width:0,height:0},_=g.x,y=g.y,x=g.width,m=g.height;if(r&&(x||m)||!M[h]||(x=s(e,M[h][0]),m=s(e,M[h][1]),"rect"!==h&&"line"!==h&&(x*=2,m*=2),"line"===h&&(_=s(e,"x1"),y=s(e,"y1"),x=Math.abs(x-_),m=Math.abs(m-y))),"path"===h)i=l.strokeDasharray,l.strokeDasharray="none",t=e.getTotalLength()||0,p(d)!==p(c)&&!b&&(b=1)&&v("Warning: <path> length cannot be measured when vector-effect is non-scaling-stroke and the element isn't proportionally scaled."),t*=(d+c)/2,l.strokeDasharray=i;else if("rect"===h)t=2*x*d+2*m*c;else if("line"===h)t=u(_,y,_+x,y+m,d,c);else if("polyline"===h||"polygon"===h)for(n=e.getAttribute("points").match(P)||[],"polygon"===h&&n.push(n[0],n[1]),t=0,o=2;o<n.length;o+=2)t+=u(n[o-2],n[o-1],n[o],n[o+1],d,c)||0;else"circle"!==h&&"ellipse"!==h||(a=x/2*d,f=m/2*c,t=Math.PI*(3*(a+f)-D((3*a+f)*(a+3*f))));return t||0}function A(e,t){if(!(e=k(e)[0]))return[0,0];t=t||z(e)+1;var r=f.getComputedStyle(e),n=r.strokeDasharray||"",s=q(r.strokeDashoffset),i=n.indexOf(",");return i<0&&(i=n.indexOf(" ")),t<(n=i<0?t:q(n.substr(0,i)))&&(n=t),[-s||0,n-s||0]}function B(){l()&&(f=window,d=t=m(),k=t.utils.toArray,c=t.core.getStyleSaver,g=t.core.reverting||function(){},h=-1!==((f.navigator||{}).userAgent||"").indexOf("Edge"))}var t,k,f,h,d,b,c,g,P=/[-+=\.]*\d+[\.e\-\+]*\d*[e\-\+]*\d*/gi,M={rect:["width","height"],circle:["r","r"],ellipse:["rx","ry"],line:["x2","y2"]},D=Math.sqrt,n={version:"3.13.0",name:"drawSVG",register:function register(e){t=e,B()},init:function init(e,t,n){if(!e.getBBox)return!1;d||B();var s,i,o,a=z(e);return this.styles=c&&c(e,"strokeDashoffset,strokeDasharray,strokeMiterlimit"),this.tween=n,this._style=e.style,this._target=e,t+""=="true"?t="0 100%":t?-1===(t+"").indexOf(" ")&&(t="0 "+t):t="0 0",i=function _parse(e,t,n){var s,i,o=e.indexOf(" ");return i=o<0?(s=void 0!==n?n+"":e,e):(s=e.substr(0,o),e.substr(o+1)),s=r(s,t),(i=r(i,t))<s?[i,s]:[s,i]}(t,a,(s=A(e,a))[0]),this._length=p(a),this._dash=p(s[1]-s[0]),this._offset=p(-s[0]),this._dashPT=this.add(this,"_dash",this._dash,p(i[1]-i[0]),0,0,0,0,0,1),this._offsetPT=this.add(this,"_offset",this._offset,p(-i[0]),0,0,0,0,0,1),h&&(o=f.getComputedStyle(e)).strokeLinecap!==o.strokeLinejoin&&(i=q(o.strokeMiterlimit),this.add(e.style,"strokeMiterlimit",i,i+.01)),this._live=w(e)||~(t+"").indexOf("live"),this._nowrap=~(t+"").indexOf("nowrap"),this._props.push("drawSVG"),1},render:function render(e,t){if(t.tween._time||!g()){var r,n,s,i,o=t._pt,a=t._style;if(o){for(t._live&&(r=z(t._target))!==t._length&&(n=r/t._length,t._length=r,t._offsetPT&&(t._offsetPT.s*=n,t._offsetPT.c*=n),t._dashPT?(t._dashPT.s*=n,t._dashPT.c*=n):t._dash*=n);o;)o.r(e,o.d),o=o._next;s=t._dash||e&&1!==e&&1e-4||0,r=t._length-s+.1,i=t._offset,s&&i&&s+Math.abs(i%t._length)>t._length-.05&&(i+=i<0?.005:-.005)&&(r+=.005),a.strokeDashoffset=s?i:i+.001,a.strokeDasharray=r<.1?"none":s?s+"px,"+(t._nowrap?999999:r)+"px":"0px, 999999px"}}else t.styles.revert()},getLength:z,getPosition:A};m()&&t.registerPlugin(n),e.DrawSVGPlugin=n,e.default=n;if (typeof(window)==="undefined"||window!==e){Object.defineProperty(e,"__esModule",{value:!0})} else {delete e.default}});
+

network-visualization/node_modules/gsap/dist/EasePack.js

@@ -0,0 +1,216 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = global || self, factory(global.window = global.window || {}));
+}(this, (function (exports) { 'use strict';
+
+	/*!
+	 * EasePack 3.13.0
+	 * https://gsap.com
+	 *
+	 * @license Copyright 2008-2025, GreenSock. All rights reserved.
+	 * Subject to the terms at https://gsap.com/standard-license
+	 * @author: Jack Doyle, jack@greensock.com
+	*/
+	var gsap,
+	    _registerEase,
+	    _getGSAP = function _getGSAP() {
+	  return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+	},
+	    _boolean = function _boolean(value, defaultValue) {
+	  return !!(typeof value === "undefined" ? defaultValue : value && !~(value + "").indexOf("false"));
+	},
+	    _initCore = function _initCore(core) {
+	  gsap = core || _getGSAP();
+
+	  if (gsap) {
+	    _registerEase = gsap.registerEase;
+
+	    var eases = gsap.parseEase(),
+	        createConfig = function createConfig(ease) {
+	      return function (ratio) {
+	        var y = 0.5 + ratio / 2;
+
+	        ease.config = function (p) {
+	          return ease(2 * (1 - p) * p * y + p * p);
+	        };
+	      };
+	    },
+	        p;
+
+	    for (p in eases) {
+	      if (!eases[p].config) {
+	        createConfig(eases[p]);
+	      }
+	    }
+
+	    _registerEase("slow", SlowMo);
+
+	    _registerEase("expoScale", ExpoScaleEase);
+
+	    _registerEase("rough", RoughEase);
+
+	    for (p in EasePack) {
+	      p !== "version" && gsap.core.globals(p, EasePack[p]);
+	    }
+	  }
+	},
+	    _createSlowMo = function _createSlowMo(linearRatio, power, yoyoMode) {
+	  linearRatio = Math.min(1, linearRatio || 0.7);
+
+	  var pow = linearRatio < 1 ? power || power === 0 ? power : 0.7 : 0,
+	      p1 = (1 - linearRatio) / 2,
+	      p3 = p1 + linearRatio,
+	      calcEnd = _boolean(yoyoMode);
+
+	  return function (p) {
+	    var r = p + (0.5 - p) * pow;
+	    return p < p1 ? calcEnd ? 1 - (p = 1 - p / p1) * p : r - (p = 1 - p / p1) * p * p * p * r : p > p3 ? calcEnd ? p === 1 ? 0 : 1 - (p = (p - p3) / p1) * p : r + (p - r) * (p = (p - p3) / p1) * p * p * p : calcEnd ? 1 : r;
+	  };
+	},
+	    _createExpoScale = function _createExpoScale(start, end, ease) {
+	  var p1 = Math.log(end / start),
+	      p2 = end - start;
+	  ease && (ease = gsap.parseEase(ease));
+	  return function (p) {
+	    return (start * Math.exp(p1 * (ease ? ease(p) : p)) - start) / p2;
+	  };
+	},
+	    EasePoint = function EasePoint(time, value, next) {
+	  this.t = time;
+	  this.v = value;
+
+	  if (next) {
+	    this.next = next;
+	    next.prev = this;
+	    this.c = next.v - value;
+	    this.gap = next.t - time;
+	  }
+	},
+	    _createRoughEase = function _createRoughEase(vars) {
+	  if (typeof vars !== "object") {
+	    vars = {
+	      points: +vars || 20
+	    };
+	  }
+
+	  var taper = vars.taper || "none",
+	      a = [],
+	      cnt = 0,
+	      points = (+vars.points || 20) | 0,
+	      i = points,
+	      randomize = _boolean(vars.randomize, true),
+	      clamp = _boolean(vars.clamp),
+	      template = gsap ? gsap.parseEase(vars.template) : 0,
+	      strength = (+vars.strength || 1) * 0.4,
+	      x,
+	      y,
+	      bump,
+	      invX,
+	      obj,
+	      pnt,
+	      recent;
+
+	  while (--i > -1) {
+	    x = randomize ? Math.random() : 1 / points * i;
+	    y = template ? template(x) : x;
+
+	    if (taper === "none") {
+	      bump = strength;
+	    } else if (taper === "out") {
+	      invX = 1 - x;
+	      bump = invX * invX * strength;
+	    } else if (taper === "in") {
+	      bump = x * x * strength;
+	    } else if (x < 0.5) {
+	      invX = x * 2;
+	      bump = invX * invX * 0.5 * strength;
+	    } else {
+	      invX = (1 - x) * 2;
+	      bump = invX * invX * 0.5 * strength;
+	    }
+
+	    if (randomize) {
+	      y += Math.random() * bump - bump * 0.5;
+	    } else if (i % 2) {
+	      y += bump * 0.5;
+	    } else {
+	      y -= bump * 0.5;
+	    }
+
+	    if (clamp) {
+	      if (y > 1) {
+	        y = 1;
+	      } else if (y < 0) {
+	        y = 0;
+	      }
+	    }
+
+	    a[cnt++] = {
+	      x: x,
+	      y: y
+	    };
+	  }
+
+	  a.sort(function (a, b) {
+	    return a.x - b.x;
+	  });
+	  pnt = new EasePoint(1, 1, null);
+	  i = points;
+
+	  while (i--) {
+	    obj = a[i];
+	    pnt = new EasePoint(obj.x, obj.y, pnt);
+	  }
+
+	  recent = new EasePoint(0, 0, pnt.t ? pnt : pnt.next);
+	  return function (p) {
+	    var pnt = recent;
+
+	    if (p > pnt.t) {
+	      while (pnt.next && p >= pnt.t) {
+	        pnt = pnt.next;
+	      }
+
+	      pnt = pnt.prev;
+	    } else {
+	      while (pnt.prev && p <= pnt.t) {
+	        pnt = pnt.prev;
+	      }
+	    }
+
+	    recent = pnt;
+	    return pnt.v + (p - pnt.t) / pnt.gap * pnt.c;
+	  };
+	};
+
+	var SlowMo = _createSlowMo(0.7);
+	SlowMo.ease = SlowMo;
+	SlowMo.config = _createSlowMo;
+	var ExpoScaleEase = _createExpoScale(1, 2);
+	ExpoScaleEase.config = _createExpoScale;
+	var RoughEase = _createRoughEase();
+	RoughEase.ease = RoughEase;
+	RoughEase.config = _createRoughEase;
+	var EasePack = {
+	  SlowMo: SlowMo,
+	  RoughEase: RoughEase,
+	  ExpoScaleEase: ExpoScaleEase
+	};
+
+	for (var p in EasePack) {
+	  EasePack[p].register = _initCore;
+	  EasePack[p].version = "3.13.0";
+	}
+
+	_getGSAP() && gsap.registerPlugin(SlowMo);
+
+	exports.EasePack = EasePack;
+	exports.ExpoScaleEase = ExpoScaleEase;
+	exports.RoughEase = RoughEase;
+	exports.SlowMo = SlowMo;
+	exports.default = EasePack;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

network-visualization/node_modules/gsap/dist/EasePack.min.js

@@ -0,0 +1,11 @@
+/*!
+ * EasePack 3.13.0
+ * https://gsap.com
+ * 
+ * @license Copyright 2025, GreenSock. All rights reserved.
+ * Subject to the terms at https://gsap.com/standard-license.
+ * @author: Jack Doyle, jack@greensock.com
+ */
+
+!function(e,n){"object"==typeof exports&&"undefined"!=typeof module?n(exports):"function"==typeof define&&define.amd?define(["exports"],n):n((e=e||self).window=e.window||{})}(this,function(e){"use strict";function f(){return w||"undefined"!=typeof window&&(w=window.gsap)&&w.registerPlugin&&w}function g(e,n){return!!(void 0===e?n:e&&!~(e+"").indexOf("false"))}function h(e){if(w=e||f()){r=w.registerEase;var n,t=w.parseEase(),o=function createConfig(t){return function(e){var n=.5+e/2;t.config=function(e){return t(2*(1-e)*e*n+e*e)}}};for(n in t)t[n].config||o(t[n]);for(n in r("slow",a),r("expoScale",s),r("rough",u),c)"version"!==n&&w.core.globals(n,c[n])}}function i(e,n,t){var o=(e=Math.min(1,e||.7))<1?n||0===n?n:.7:0,r=(1-e)/2,i=r+e,a=g(t);return function(e){var n=e+(.5-e)*o;return e<r?a?1-(e=1-e/r)*e:n-(e=1-e/r)*e*e*e*n:i<e?a?1===e?0:1-(e=(e-i)/r)*e:n+(e-n)*(e=(e-i)/r)*e*e*e:a?1:n}}function j(n,e,t){var o=Math.log(e/n),r=e-n;return t=t&&w.parseEase(t),function(e){return(n*Math.exp(o*(t?t(e):e))-n)/r}}function k(e,n,t){this.t=e,this.v=n,t&&(((this.next=t).prev=this).c=t.v-n,this.gap=t.t-e)}function l(e){"object"!=typeof e&&(e={points:+e||20});for(var n,t,o,r,i,a,f,s=e.taper||"none",u=[],c=0,p=0|(+e.points||20),l=p,v=g(e.randomize,!0),d=g(e.clamp),h=w?w.parseEase(e.template):0,x=.4*(+e.strength||1);-1<--l;)n=v?Math.random():1/p*l,t=h?h(n):n,o="none"===s?x:"out"===s?(r=1-n)*r*x:"in"===s?n*n*x:n<.5?(r=2*n)*r*.5*x:(r=2*(1-n))*r*.5*x,v?t+=Math.random()*o-.5*o:l%2?t+=.5*o:t-=.5*o,d&&(1<t?t=1:t<0&&(t=0)),u[c++]={x:n,y:t};for(u.sort(function(e,n){return e.x-n.x}),a=new k(1,1,null),l=p;l--;)i=u[l],a=new k(i.x,i.y,a);return f=new k(0,0,a.t?a:a.next),function(e){var n=f;if(e>n.t){for(;n.next&&e>=n.t;)n=n.next;n=n.prev}else for(;n.prev&&e<=n.t;)n=n.prev;return(f=n).v+(e-n.t)/n.gap*n.c}}var w,r,a=i(.7);(a.ease=a).config=i;var s=j(1,2);s.config=j;var u=l();(u.ease=u).config=l;var c={SlowMo:a,RoughEase:u,ExpoScaleEase:s};for(var n in c)c[n].register=h,c[n].version="3.13.0";f()&&w.registerPlugin(a),e.EasePack=c,e.ExpoScaleEase=s,e.RoughEase=u,e.SlowMo=a,e.default=c;if (typeof(window)==="undefined"||window!==e){Object.defineProperty(e,"__esModule",{value:!0})} else {delete e.default}});
+

network-visualization/node_modules/gsap/dist/EaselPlugin.js

@@ -0,0 +1,350 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = global || self, factory(global.window = global.window || {}));
+}(this, (function (exports) { 'use strict';
+
+	/*!
+	 * EaselPlugin 3.13.0
+	 * https://gsap.com
+	 *
+	 * @license Copyright 2008-2025, GreenSock. All rights reserved.
+	 * Subject to the terms at https://gsap.com/standard-license
+	 * @author: Jack Doyle, jack@greensock.com
+	*/
+	var gsap,
+	    _coreInitted,
+	    _win,
+	    _createJS,
+	    _ColorFilter,
+	    _ColorMatrixFilter,
+	    _colorProps = "redMultiplier,greenMultiplier,blueMultiplier,alphaMultiplier,redOffset,greenOffset,blueOffset,alphaOffset".split(","),
+	    _windowExists = function _windowExists() {
+	  return typeof window !== "undefined";
+	},
+	    _getGSAP = function _getGSAP() {
+	  return gsap || _windowExists() && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+	},
+	    _getCreateJS = function _getCreateJS() {
+	  return _createJS || _win && _win.createjs || _win || {};
+	},
+	    _warn = function _warn(message) {
+	  return console.warn(message);
+	},
+	    _cache = function _cache(target) {
+	  var b = target.getBounds && target.getBounds();
+
+	  if (!b) {
+	    b = target.nominalBounds || {
+	      x: 0,
+	      y: 0,
+	      width: 100,
+	      height: 100
+	    };
+	    target.setBounds && target.setBounds(b.x, b.y, b.width, b.height);
+	  }
+
+	  target.cache && target.cache(b.x, b.y, b.width, b.height);
+
+	  _warn("EaselPlugin: for filters to display in EaselJS, you must call the object's cache() method first. GSAP attempted to use the target's getBounds() for the cache but that may not be completely accurate. " + target);
+	},
+	    _parseColorFilter = function _parseColorFilter(target, v, plugin) {
+	  if (!_ColorFilter) {
+	    _ColorFilter = _getCreateJS().ColorFilter;
+
+	    if (!_ColorFilter) {
+	      _warn("EaselPlugin error: The EaselJS ColorFilter JavaScript file wasn't loaded.");
+	    }
+	  }
+
+	  var filters = target.filters || [],
+	      i = filters.length,
+	      c,
+	      s,
+	      e,
+	      a,
+	      p,
+	      pt;
+
+	  while (i--) {
+	    if (filters[i] instanceof _ColorFilter) {
+	      s = filters[i];
+	      break;
+	    }
+	  }
+
+	  if (!s) {
+	    s = new _ColorFilter();
+	    filters.push(s);
+	    target.filters = filters;
+	  }
+
+	  e = s.clone();
+
+	  if (v.tint != null) {
+	    c = gsap.utils.splitColor(v.tint);
+	    a = v.tintAmount != null ? +v.tintAmount : 1;
+	    e.redOffset = +c[0] * a;
+	    e.greenOffset = +c[1] * a;
+	    e.blueOffset = +c[2] * a;
+	    e.redMultiplier = e.greenMultiplier = e.blueMultiplier = 1 - a;
+	  } else {
+	    for (p in v) {
+	      if (p !== "exposure") if (p !== "brightness") {
+	        e[p] = +v[p];
+	      }
+	    }
+	  }
+
+	  if (v.exposure != null) {
+	    e.redOffset = e.greenOffset = e.blueOffset = 255 * (+v.exposure - 1);
+	    e.redMultiplier = e.greenMultiplier = e.blueMultiplier = 1;
+	  } else if (v.brightness != null) {
+	    a = +v.brightness - 1;
+	    e.redOffset = e.greenOffset = e.blueOffset = a > 0 ? a * 255 : 0;
+	    e.redMultiplier = e.greenMultiplier = e.blueMultiplier = 1 - Math.abs(a);
+	  }
+
+	  i = 8;
+
+	  while (i--) {
+	    p = _colorProps[i];
+
+	    if (s[p] !== e[p]) {
+	      pt = plugin.add(s, p, s[p], e[p], 0, 0, 0, 0, 0, 1);
+
+	      if (pt) {
+	        pt.op = "easel_colorFilter";
+	      }
+	    }
+	  }
+
+	  plugin._props.push("easel_colorFilter");
+
+	  if (!target.cacheID) {
+	    _cache(target);
+	  }
+	},
+	    _idMatrix = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0],
+	    _lumR = 0.212671,
+	    _lumG = 0.715160,
+	    _lumB = 0.072169,
+	    _applyMatrix = function _applyMatrix(m, m2) {
+	  if (!(m instanceof Array) || !(m2 instanceof Array)) {
+	    return m2;
+	  }
+
+	  var temp = [],
+	      i = 0,
+	      z = 0,
+	      y,
+	      x;
+
+	  for (y = 0; y < 4; y++) {
+	    for (x = 0; x < 5; x++) {
+	      z = x === 4 ? m[i + 4] : 0;
+	      temp[i + x] = m[i] * m2[x] + m[i + 1] * m2[x + 5] + m[i + 2] * m2[x + 10] + m[i + 3] * m2[x + 15] + z;
+	    }
+
+	    i += 5;
+	  }
+
+	  return temp;
+	},
+	    _setSaturation = function _setSaturation(m, n) {
+	  if (isNaN(n)) {
+	    return m;
+	  }
+
+	  var inv = 1 - n,
+	      r = inv * _lumR,
+	      g = inv * _lumG,
+	      b = inv * _lumB;
+	  return _applyMatrix([r + n, g, b, 0, 0, r, g + n, b, 0, 0, r, g, b + n, 0, 0, 0, 0, 0, 1, 0], m);
+	},
+	    _colorize = function _colorize(m, color, amount) {
+	  if (isNaN(amount)) {
+	    amount = 1;
+	  }
+
+	  var c = gsap.utils.splitColor(color),
+	      r = c[0] / 255,
+	      g = c[1] / 255,
+	      b = c[2] / 255,
+	      inv = 1 - amount;
+	  return _applyMatrix([inv + amount * r * _lumR, amount * r * _lumG, amount * r * _lumB, 0, 0, amount * g * _lumR, inv + amount * g * _lumG, amount * g * _lumB, 0, 0, amount * b * _lumR, amount * b * _lumG, inv + amount * b * _lumB, 0, 0, 0, 0, 0, 1, 0], m);
+	},
+	    _setHue = function _setHue(m, n) {
+	  if (isNaN(n)) {
+	    return m;
+	  }
+
+	  n *= Math.PI / 180;
+	  var c = Math.cos(n),
+	      s = Math.sin(n);
+	  return _applyMatrix([_lumR + c * (1 - _lumR) + s * -_lumR, _lumG + c * -_lumG + s * -_lumG, _lumB + c * -_lumB + s * (1 - _lumB), 0, 0, _lumR + c * -_lumR + s * 0.143, _lumG + c * (1 - _lumG) + s * 0.14, _lumB + c * -_lumB + s * -0.283, 0, 0, _lumR + c * -_lumR + s * -(1 - _lumR), _lumG + c * -_lumG + s * _lumG, _lumB + c * (1 - _lumB) + s * _lumB, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1], m);
+	},
+	    _setContrast = function _setContrast(m, n) {
+	  if (isNaN(n)) {
+	    return m;
+	  }
+
+	  n += 0.01;
+	  return _applyMatrix([n, 0, 0, 0, 128 * (1 - n), 0, n, 0, 0, 128 * (1 - n), 0, 0, n, 0, 128 * (1 - n), 0, 0, 0, 1, 0], m);
+	},
+	    _parseColorMatrixFilter = function _parseColorMatrixFilter(target, v, plugin) {
+	  if (!_ColorMatrixFilter) {
+	    _ColorMatrixFilter = _getCreateJS().ColorMatrixFilter;
+
+	    if (!_ColorMatrixFilter) {
+	      _warn("EaselPlugin: The EaselJS ColorMatrixFilter JavaScript file wasn't loaded.");
+	    }
+	  }
+
+	  var filters = target.filters || [],
+	      i = filters.length,
+	      matrix,
+	      startMatrix,
+	      s,
+	      pg;
+
+	  while (--i > -1) {
+	    if (filters[i] instanceof _ColorMatrixFilter) {
+	      s = filters[i];
+	      break;
+	    }
+	  }
+
+	  if (!s) {
+	    s = new _ColorMatrixFilter(_idMatrix.slice());
+	    filters.push(s);
+	    target.filters = filters;
+	  }
+
+	  startMatrix = s.matrix;
+	  matrix = _idMatrix.slice();
+
+	  if (v.colorize != null) {
+	    matrix = _colorize(matrix, v.colorize, Number(v.colorizeAmount));
+	  }
+
+	  if (v.contrast != null) {
+	    matrix = _setContrast(matrix, Number(v.contrast));
+	  }
+
+	  if (v.hue != null) {
+	    matrix = _setHue(matrix, Number(v.hue));
+	  }
+
+	  if (v.saturation != null) {
+	    matrix = _setSaturation(matrix, Number(v.saturation));
+	  }
+
+	  i = matrix.length;
+
+	  while (--i > -1) {
+	    if (matrix[i] !== startMatrix[i]) {
+	      pg = plugin.add(startMatrix, i, startMatrix[i], matrix[i], 0, 0, 0, 0, 0, 1);
+
+	      if (pg) {
+	        pg.op = "easel_colorMatrixFilter";
+	      }
+	    }
+	  }
+
+	  plugin._props.push("easel_colorMatrixFilter");
+
+	  if (!target.cacheID) {
+	    _cache();
+	  }
+
+	  plugin._matrix = startMatrix;
+	},
+	    _initCore = function _initCore(core) {
+	  gsap = core || _getGSAP();
+
+	  if (_windowExists()) {
+	    _win = window;
+	  }
+
+	  if (gsap) {
+	    _coreInitted = 1;
+	  }
+	};
+
+	var EaselPlugin = {
+	  version: "3.13.0",
+	  name: "easel",
+	  init: function init(target, value, tween, index, targets) {
+	    if (!_coreInitted) {
+	      _initCore();
+
+	      if (!gsap) {
+	        _warn("Please gsap.registerPlugin(EaselPlugin)");
+	      }
+	    }
+
+	    this.target = target;
+	    var p, pt, tint, colorMatrix, end, labels, i;
+
+	    for (p in value) {
+	      end = value[p];
+
+	      if (p === "colorFilter" || p === "tint" || p === "tintAmount" || p === "exposure" || p === "brightness") {
+	        if (!tint) {
+	          _parseColorFilter(target, value.colorFilter || value, this);
+
+	          tint = true;
+	        }
+	      } else if (p === "saturation" || p === "contrast" || p === "hue" || p === "colorize" || p === "colorizeAmount") {
+	        if (!colorMatrix) {
+	          _parseColorMatrixFilter(target, value.colorMatrixFilter || value, this);
+
+	          colorMatrix = true;
+	        }
+	      } else if (p === "frame") {
+	        if (typeof end === "string" && end.charAt(1) !== "=" && (labels = target.labels)) {
+	          for (i = 0; i < labels.length; i++) {
+	            if (labels[i].label === end) {
+	              end = labels[i].position;
+	            }
+	          }
+	        }
+
+	        pt = this.add(target, "gotoAndStop", target.currentFrame, end, index, targets, Math.round, 0, 0, 1);
+
+	        if (pt) {
+	          pt.op = p;
+	        }
+	      } else if (target[p] != null) {
+	        this.add(target, p, "get", end);
+	      }
+	    }
+	  },
+	  render: function render(ratio, data) {
+	    var pt = data._pt;
+
+	    while (pt) {
+	      pt.r(ratio, pt.d);
+	      pt = pt._next;
+	    }
+
+	    if (data.target.cacheID) {
+	      data.target.updateCache();
+	    }
+	  },
+	  register: _initCore
+	};
+
+	EaselPlugin.registerCreateJS = function (createjs) {
+	  _createJS = createjs;
+	};
+
+	_getGSAP() && gsap.registerPlugin(EaselPlugin);
+
+	exports.EaselPlugin = EaselPlugin;
+	exports.default = EaselPlugin;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

network-visualization/node_modules/gsap/dist/EaselPlugin.min.js

@@ -0,0 +1,11 @@
+/*!
+ * EaselPlugin 3.13.0
+ * https://gsap.com
+ * 
+ * @license Copyright 2025, GreenSock. All rights reserved.
+ * Subject to the terms at https://gsap.com/standard-license.
+ * @author: Jack Doyle, jack@greensock.com
+ */
+
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e=e||self).window=e.window||{})}(this,function(e){"use strict";function k(){return"undefined"!=typeof window}function l(){return h||k()&&(h=window.gsap)&&h.registerPlugin&&h}function m(){return r||t&&t.createjs||t||{}}function n(e){return console.warn(e)}function o(e){var t=e.getBounds&&e.getBounds();t||(t=e.nominalBounds||{x:0,y:0,width:100,height:100},e.setBounds&&e.setBounds(t.x,t.y,t.width,t.height)),e.cache&&e.cache(t.x,t.y,t.width,t.height),n("EaselPlugin: for filters to display in EaselJS, you must call the object's cache() method first. GSAP attempted to use the target's getBounds() for the cache but that may not be completely accurate. "+e)}function p(e,t,r){(b=b||m().ColorFilter)||n("EaselPlugin error: The EaselJS ColorFilter JavaScript file wasn't loaded.");for(var i,l,s,u,a,f,c=e.filters||[],d=c.length;d--;)if(c[d]instanceof b){l=c[d];break}if(l||(l=new b,c.push(l),e.filters=c),s=l.clone(),null!=t.tint)i=h.utils.splitColor(t.tint),u=null!=t.tintAmount?+t.tintAmount:1,s.redOffset=i[0]*u,s.greenOffset=i[1]*u,s.blueOffset=i[2]*u,s.redMultiplier=s.greenMultiplier=s.blueMultiplier=1-u;else for(a in t)"exposure"!==a&&"brightness"!==a&&(s[a]=+t[a]);for(null!=t.exposure?(s.redOffset=s.greenOffset=s.blueOffset=255*(t.exposure-1),s.redMultiplier=s.greenMultiplier=s.blueMultiplier=1):null!=t.brightness&&(u=t.brightness-1,s.redOffset=s.greenOffset=s.blueOffset=0<u?255*u:0,s.redMultiplier=s.greenMultiplier=s.blueMultiplier=1-Math.abs(u)),d=8;d--;)l[a=M[d]]!==s[a]&&(f=r.add(l,a,l[a],s[a],0,0,0,0,0,1))&&(f.op="easel_colorFilter");r._props.push("easel_colorFilter"),e.cacheID||o(e)}function u(e,t){if(!(e instanceof Array&&t instanceof Array))return t;var r,i,n=[],l=0,o=0;for(r=0;r<4;r++){for(i=0;i<5;i++)o=4===i?e[l+4]:0,n[l+i]=e[l]*t[i]+e[l+1]*t[i+5]+e[l+2]*t[i+10]+e[l+3]*t[i+15]+o;l+=5}return n}function z(e,t,r){(d=d||m().ColorMatrixFilter)||n("EaselPlugin: The EaselJS ColorMatrixFilter JavaScript file wasn't loaded.");for(var i,l,s,a,f=e.filters||[],c=f.length;-1<--c;)if(f[c]instanceof d){s=f[c];break}for(s||(s=new d(w.slice()),f.push(s),e.filters=f),l=s.matrix,i=w.slice(),null!=t.colorize&&(i=function _colorize(e,t,r){isNaN(r)&&(r=1);var i=h.utils.splitColor(t),n=i[0]/255,l=i[1]/255,o=i[2]/255,s=1-r;return u([s+r*n*x,r*n*y,r*n*_,0,0,r*l*x,s+r*l*y,r*l*_,0,0,r*o*x,r*o*y,s+r*o*_,0,0,0,0,0,1,0],e)}(i,t.colorize,Number(t.colorizeAmount))),null!=t.contrast&&(i=function _setContrast(e,t){return isNaN(t)?e:u([t+=.01,0,0,0,128*(1-t),0,t,0,0,128*(1-t),0,0,t,0,128*(1-t),0,0,0,1,0],e)}(i,Number(t.contrast))),null!=t.hue&&(i=function _setHue(e,t){if(isNaN(t))return e;t*=Math.PI/180;var r=Math.cos(t),i=Math.sin(t);return u([x+r*(1-x)+i*-x,y+r*-y+i*-y,_+r*-_+i*(1-_),0,0,x+r*-x+.143*i,y+r*(1-y)+.14*i,_+r*-_+-.283*i,0,0,x+r*-x+i*-(1-x),y+r*-y+i*y,_+r*(1-_)+i*_,0,0,0,0,0,1,0,0,0,0,0,1],e)}(i,Number(t.hue))),null!=t.saturation&&(i=function _setSaturation(e,t){if(isNaN(t))return e;var r=1-t,i=r*x,n=r*y,l=r*_;return u([i+t,n,l,0,0,i,n+t,l,0,0,i,n,l+t,0,0,0,0,0,1,0],e)}(i,Number(t.saturation))),c=i.length;-1<--c;)i[c]!==l[c]&&(a=r.add(l,c,l[c],i[c],0,0,0,0,0,1))&&(a.op="easel_colorMatrixFilter");r._props.push("easel_colorMatrixFilter"),e.cacheID||o(),r._matrix=l}function A(e){h=e||l(),k()&&(t=window),h&&(g=1)}var h,g,t,r,b,d,M="redMultiplier,greenMultiplier,blueMultiplier,alphaMultiplier,redOffset,greenOffset,blueOffset,alphaOffset".split(","),w=[1,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0],x=.212671,y=.71516,_=.072169,i={version:"3.13.0",name:"easel",init:function init(e,t,r,i,l){var o,s,u,a,f,c,d;for(o in g||(A(),h||n("Please gsap.registerPlugin(EaselPlugin)")),this.target=e,t)if(f=t[o],"colorFilter"===o||"tint"===o||"tintAmount"===o||"exposure"===o||"brightness"===o)u||(p(e,t.colorFilter||t,this),u=!0);else if("saturation"===o||"contrast"===o||"hue"===o||"colorize"===o||"colorizeAmount"===o)a||(z(e,t.colorMatrixFilter||t,this),a=!0);else if("frame"===o){if("string"==typeof f&&"="!==f.charAt(1)&&(c=e.labels))for(d=0;d<c.length;d++)c[d].label===f&&(f=c[d].position);(s=this.add(e,"gotoAndStop",e.currentFrame,f,i,l,Math.round,0,0,1))&&(s.op=o)}else null!=e[o]&&this.add(e,o,"get",f)},render:function render(e,t){for(var r=t._pt;r;)r.r(e,r.d),r=r._next;t.target.cacheID&&t.target.updateCache()},register:A,registerCreateJS:function(e){r=e}};l()&&h.registerPlugin(i),e.EaselPlugin=i,e.default=i;if (typeof(window)==="undefined"||window!==e){Object.defineProperty(e,"__esModule",{value:!0})} else {delete e.default}});
+

network-visualization/node_modules/gsap/dist/InertiaPlugin.js

@@ -0,0 +1,718 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = global || self, factory(global.window = global.window || {}));
+}(this, (function (exports) { 'use strict';
+
+	var gsap,
+	    _coreInitted,
+	    _toArray,
+	    _getUnit,
+	    _first,
+	    _ticker,
+	    _time1,
+	    _time2,
+	    _getCache,
+	    _getGSAP = function _getGSAP() {
+	  return gsap || typeof window !== "undefined" && (gsap = window.gsap);
+	},
+	    _lookup = {},
+	    _round = function _round(value) {
+	  return Math.round(value * 10000) / 10000;
+	},
+	    _getID = function _getID(target) {
+	  return _getCache(target).id;
+	},
+	    _getByTarget = function _getByTarget(target) {
+	  return _lookup[_getID(typeof target === "string" ? _toArray(target)[0] : target)];
+	},
+	    _onTick = function _onTick(time) {
+	  var pt = _first,
+	      val;
+
+	  if (time - _time1 >= 0.05) {
+	    _time2 = _time1;
+	    _time1 = time;
+
+	    while (pt) {
+	      val = pt.g(pt.t, pt.p);
+
+	      if (val !== pt.v1 || time - pt.t1 > 0.2) {
+	        pt.v2 = pt.v1;
+	        pt.v1 = val;
+	        pt.t2 = pt.t1;
+	        pt.t1 = time;
+	      }
+
+	      pt = pt._next;
+	    }
+	  }
+	},
+	    _types = {
+	  deg: 360,
+	  rad: Math.PI * 2
+	},
+	    _initCore = function _initCore() {
+	  gsap = _getGSAP();
+
+	  if (gsap) {
+	    _toArray = gsap.utils.toArray;
+	    _getUnit = gsap.utils.getUnit;
+	    _getCache = gsap.core.getCache;
+	    _ticker = gsap.ticker;
+	    _coreInitted = 1;
+	  }
+	};
+
+	var PropTracker = function PropTracker(target, property, type, next) {
+	  this.t = target;
+	  this.p = property;
+	  this.g = target._gsap.get;
+	  this.rCap = _types[type || _getUnit(this.g(target, property))];
+	  this.v1 = this.v2 = 0;
+	  this.t1 = this.t2 = _ticker.time;
+
+	  if (next) {
+	    this._next = next;
+	    next._prev = this;
+	  }
+	};
+
+	var VelocityTracker = function () {
+	  function VelocityTracker(target, property) {
+	    if (!_coreInitted) {
+	      _initCore();
+	    }
+
+	    this.target = _toArray(target)[0];
+	    _lookup[_getID(this.target)] = this;
+	    this._props = {};
+	    property && this.add(property);
+	  }
+
+	  VelocityTracker.register = function register(core) {
+	    gsap = core;
+
+	    _initCore();
+	  };
+
+	  var _proto = VelocityTracker.prototype;
+
+	  _proto.get = function get(property, skipRecentTick) {
+	    var pt = this._props[property] || console.warn("Not tracking " + property + " velocity."),
+	        val,
+	        dif,
+	        rotationCap;
+	    val = parseFloat(skipRecentTick ? pt.v1 : pt.g(pt.t, pt.p));
+	    dif = val - parseFloat(pt.v2);
+	    rotationCap = pt.rCap;
+
+	    if (rotationCap) {
+	      dif = dif % rotationCap;
+
+	      if (dif !== dif % (rotationCap / 2)) {
+	        dif = dif < 0 ? dif + rotationCap : dif - rotationCap;
+	      }
+	    }
+
+	    return _round(dif / ((skipRecentTick ? pt.t1 : _ticker.time) - pt.t2));
+	  };
+
+	  _proto.getAll = function getAll() {
+	    var result = {},
+	        props = this._props,
+	        p;
+
+	    for (p in props) {
+	      result[p] = this.get(p);
+	    }
+
+	    return result;
+	  };
+
+	  _proto.isTracking = function isTracking(property) {
+	    return property in this._props;
+	  };
+
+	  _proto.add = function add(property, type) {
+	    if (!(property in this._props)) {
+	      if (!_first) {
+	        _ticker.add(_onTick);
+
+	        _time1 = _time2 = _ticker.time;
+	      }
+
+	      _first = this._props[property] = new PropTracker(this.target, property, type, _first);
+	    }
+	  };
+
+	  _proto.remove = function remove(property) {
+	    var pt = this._props[property],
+	        prev,
+	        next;
+
+	    if (pt) {
+	      prev = pt._prev;
+	      next = pt._next;
+
+	      if (prev) {
+	        prev._next = next;
+	      }
+
+	      if (next) {
+	        next._prev = prev;
+	      } else if (_first === pt) {
+	        _ticker.remove(_onTick);
+
+	        _first = 0;
+	      }
+
+	      delete this._props[property];
+	    }
+	  };
+
+	  _proto.kill = function kill(shallow) {
+	    for (var p in this._props) {
+	      this.remove(p);
+	    }
+
+	    if (!shallow) {
+	      delete _lookup[_getID(this.target)];
+	    }
+	  };
+
+	  VelocityTracker.track = function track(targets, properties, types) {
+	    if (!_coreInitted) {
+	      _initCore();
+	    }
+
+	    var result = [],
+	        targs = _toArray(targets),
+	        a = properties.split(","),
+	        t = (types || "").split(","),
+	        i = targs.length,
+	        tracker,
+	        j;
+
+	    while (i--) {
+	      tracker = _getByTarget(targs[i]) || new VelocityTracker(targs[i]);
+	      j = a.length;
+
+	      while (j--) {
+	        tracker.add(a[j], t[j] || t[0]);
+	      }
+
+	      result.push(tracker);
+	    }
+
+	    return result;
+	  };
+
+	  VelocityTracker.untrack = function untrack(targets, properties) {
+	    var props = (properties || "").split(",");
+
+	    _toArray(targets).forEach(function (target) {
+	      var tracker = _getByTarget(target);
+
+	      if (tracker) {
+	        if (!props.length) {
+	          tracker.kill(1);
+	        } else {
+	          props.forEach(function (p) {
+	            return tracker.remove(p);
+	          });
+	        }
+	      }
+	    });
+	  };
+
+	  VelocityTracker.isTracking = function isTracking(target, property) {
+	    var tracker = _getByTarget(target);
+
+	    return tracker && tracker.isTracking(property);
+	  };
+
+	  VelocityTracker.getVelocity = function getVelocity(target, property) {
+	    var tracker = _getByTarget(target);
+
+	    return !tracker || !tracker.isTracking(property) ? console.warn("Not tracking velocity of " + property) : tracker.get(property);
+	  };
+
+	  return VelocityTracker;
+	}();
+	VelocityTracker.getByTarget = _getByTarget;
+	_getGSAP() && gsap.registerPlugin(VelocityTracker);
+
+	/*!
+	 * InertiaPlugin 3.13.0
+	 * https://gsap.com
+	 *
+	 * @license Copyright 2008-2025, GreenSock. All rights reserved.
+	 * Subject to the terms at https://gsap.com/standard-license
+	 * @author: Jack Doyle, jack@greensock.com
+	*/
+
+	var gsap$1,
+	    _coreInitted$1,
+	    _parseEase,
+	    _toArray$1,
+	    _power3,
+	    _config,
+	    _getUnit$1,
+	    PropTween,
+	    _getCache$1,
+	    _checkPointRatio,
+	    _clamp,
+	    _processingVars,
+	    _getStyleSaver,
+	    _reverting,
+	    _getTracker = VelocityTracker.getByTarget,
+	    _getGSAP$1 = function _getGSAP() {
+	  return gsap$1 || typeof window !== "undefined" && (gsap$1 = window.gsap) && gsap$1.registerPlugin && gsap$1;
+	},
+	    _isString = function _isString(value) {
+	  return typeof value === "string";
+	},
+	    _isNumber = function _isNumber(value) {
+	  return typeof value === "number";
+	},
+	    _isObject = function _isObject(value) {
+	  return typeof value === "object";
+	},
+	    _isFunction = function _isFunction(value) {
+	  return typeof value === "function";
+	},
+	    _bonusValidated = 1,
+	    _isArray = Array.isArray,
+	    _emptyFunc = function _emptyFunc(p) {
+	  return p;
+	},
+	    _bigNum = 1e10,
+	    _tinyNum = 1 / _bigNum,
+	    _checkPoint = 0.05,
+	    _round$1 = function _round(value) {
+	  return Math.round(value * 10000) / 10000;
+	},
+	    _extend = function _extend(obj, defaults, exclude) {
+	  for (var p in defaults) {
+	    if (!(p in obj) && p !== exclude) {
+	      obj[p] = defaults[p];
+	    }
+	  }
+
+	  return obj;
+	},
+	    _deepClone = function _deepClone(obj) {
+	  var copy = {},
+	      p,
+	      v;
+
+	  for (p in obj) {
+	    copy[p] = _isObject(v = obj[p]) && !_isArray(v) ? _deepClone(v) : v;
+	  }
+
+	  return copy;
+	},
+	    _getClosest = function _getClosest(n, values, max, min, radius) {
+	  var i = values.length,
+	      closest = 0,
+	      absDif = _bigNum,
+	      val,
+	      dif,
+	      p,
+	      dist;
+
+	  if (_isObject(n)) {
+	    while (i--) {
+	      val = values[i];
+	      dif = 0;
+
+	      for (p in n) {
+	        dist = val[p] - n[p];
+	        dif += dist * dist;
+	      }
+
+	      if (dif < absDif) {
+	        closest = i;
+	        absDif = dif;
+	      }
+	    }
+
+	    if ((radius || _bigNum) < _bigNum && radius < Math.sqrt(absDif)) {
+	      return n;
+	    }
+	  } else {
+	    while (i--) {
+	      val = values[i];
+	      dif = val - n;
+
+	      if (dif < 0) {
+	        dif = -dif;
+	      }
+
+	      if (dif < absDif && val >= min && val <= max) {
+	        closest = i;
+	        absDif = dif;
+	      }
+	    }
+	  }
+
+	  return values[closest];
+	},
+	    _parseEnd = function _parseEnd(curProp, end, max, min, name, radius, velocity) {
+	  if (curProp.end === "auto") {
+	    return curProp;
+	  }
+
+	  var endVar = curProp.end,
+	      adjustedEnd,
+	      p;
+	  max = isNaN(max) ? _bigNum : max;
+	  min = isNaN(min) ? -_bigNum : min;
+
+	  if (_isObject(end)) {
+	    adjustedEnd = end.calculated ? end : (_isFunction(endVar) ? endVar(end, velocity) : _getClosest(end, endVar, max, min, radius)) || end;
+
+	    if (!end.calculated) {
+	      for (p in adjustedEnd) {
+	        end[p] = adjustedEnd[p];
+	      }
+
+	      end.calculated = true;
+	    }
+
+	    adjustedEnd = adjustedEnd[name];
+	  } else {
+	    adjustedEnd = _isFunction(endVar) ? endVar(end, velocity) : _isArray(endVar) ? _getClosest(end, endVar, max, min, radius) : parseFloat(endVar);
+	  }
+
+	  if (adjustedEnd > max) {
+	    adjustedEnd = max;
+	  } else if (adjustedEnd < min) {
+	    adjustedEnd = min;
+	  }
+
+	  return {
+	    max: adjustedEnd,
+	    min: adjustedEnd,
+	    unitFactor: curProp.unitFactor
+	  };
+	},
+	    _getNumOrDefault = function _getNumOrDefault(vars, property, defaultValue) {
+	  return isNaN(vars[property]) ? defaultValue : +vars[property];
+	},
+	    _calculateChange = function _calculateChange(velocity, duration) {
+	  return duration * _checkPoint * velocity / _checkPointRatio;
+	},
+	    _calculateDuration = function _calculateDuration(start, end, velocity) {
+	  return Math.abs((end - start) * _checkPointRatio / velocity / _checkPoint);
+	},
+	    _reservedProps = {
+	  resistance: 1,
+	  checkpoint: 1,
+	  preventOvershoot: 1,
+	  linkedProps: 1,
+	  radius: 1,
+	  duration: 1
+	},
+	    _processLinkedProps = function _processLinkedProps(target, vars, getVal, resistance) {
+	  if (vars.linkedProps) {
+	    var linkedPropNames = vars.linkedProps.split(","),
+	        linkedProps = {},
+	        i,
+	        p,
+	        curProp,
+	        curVelocity,
+	        tracker,
+	        curDuration;
+
+	    for (i = 0; i < linkedPropNames.length; i++) {
+	      p = linkedPropNames[i];
+	      curProp = vars[p];
+
+	      if (curProp) {
+	        if (_isNumber(curProp.velocity)) {
+	          curVelocity = curProp.velocity;
+	        } else {
+	          tracker = tracker || _getTracker(target);
+	          curVelocity = tracker && tracker.isTracking(p) ? tracker.get(p) : 0;
+	        }
+
+	        curDuration = Math.abs(curVelocity / _getNumOrDefault(curProp, "resistance", resistance));
+	        linkedProps[p] = parseFloat(getVal(target, p)) + _calculateChange(curVelocity, curDuration);
+	      }
+	    }
+
+	    return linkedProps;
+	  }
+	},
+	    _calculateTweenDuration = function _calculateTweenDuration(target, vars, maxDuration, minDuration, overshootTolerance, recordEnd) {
+	  if (maxDuration === void 0) {
+	    maxDuration = 10;
+	  }
+
+	  if (minDuration === void 0) {
+	    minDuration = 0.2;
+	  }
+
+	  if (overshootTolerance === void 0) {
+	    overshootTolerance = 1;
+	  }
+
+	  if (recordEnd === void 0) {
+	    recordEnd = 0;
+	  }
+
+	  _isString(target) && (target = _toArray$1(target)[0]);
+
+	  if (!target) {
+	    return 0;
+	  }
+
+	  var duration = 0,
+	      clippedDuration = _bigNum,
+	      inertiaVars = vars.inertia || vars,
+	      getVal = _getCache$1(target).get,
+	      resistance = _getNumOrDefault(inertiaVars, "resistance", _config.resistance),
+	      p,
+	      curProp,
+	      curDuration,
+	      curVelocity,
+	      curVal,
+	      end,
+	      curClippedDuration,
+	      tracker,
+	      unitFactor,
+	      linkedProps;
+
+	  linkedProps = _processLinkedProps(target, inertiaVars, getVal, resistance);
+
+	  for (p in inertiaVars) {
+	    if (!_reservedProps[p]) {
+	      curProp = inertiaVars[p];
+
+	      if (!_isObject(curProp)) {
+	        tracker = tracker || _getTracker(target);
+
+	        if (tracker && tracker.isTracking(p)) {
+	          curProp = _isNumber(curProp) ? {
+	            velocity: curProp
+	          } : {
+	            velocity: tracker.get(p)
+	          };
+	        } else {
+	          curVelocity = +curProp || 0;
+	          curDuration = Math.abs(curVelocity / resistance);
+	        }
+	      }
+
+	      if (_isObject(curProp)) {
+	        if (_isNumber(curProp.velocity)) {
+	          curVelocity = curProp.velocity;
+	        } else {
+	          tracker = tracker || _getTracker(target);
+	          curVelocity = tracker && tracker.isTracking(p) ? tracker.get(p) : 0;
+	        }
+
+	        curDuration = _clamp(minDuration, maxDuration, Math.abs(curVelocity / _getNumOrDefault(curProp, "resistance", resistance)));
+	        curVal = parseFloat(getVal(target, p)) || 0;
+	        end = curVal + _calculateChange(curVelocity, curDuration);
+
+	        if ("end" in curProp) {
+	          curProp = _parseEnd(curProp, linkedProps && p in linkedProps ? linkedProps : end, curProp.max, curProp.min, p, inertiaVars.radius, curVelocity);
+
+	          if (recordEnd) {
+	            _processingVars === vars && (_processingVars = inertiaVars = _deepClone(vars));
+	            inertiaVars[p] = _extend(curProp, inertiaVars[p], "end");
+	          }
+	        }
+
+	        if ("max" in curProp && end > +curProp.max + _tinyNum) {
+	          unitFactor = curProp.unitFactor || _config.unitFactors[p] || 1;
+	          curClippedDuration = curVal > curProp.max && curProp.min !== curProp.max || curVelocity * unitFactor > -15 && curVelocity * unitFactor < 45 ? minDuration + (maxDuration - minDuration) * 0.1 : _calculateDuration(curVal, curProp.max, curVelocity);
+
+	          if (curClippedDuration + overshootTolerance < clippedDuration) {
+	            clippedDuration = curClippedDuration + overshootTolerance;
+	          }
+	        } else if ("min" in curProp && end < +curProp.min - _tinyNum) {
+	          unitFactor = curProp.unitFactor || _config.unitFactors[p] || 1;
+	          curClippedDuration = curVal < curProp.min && curProp.min !== curProp.max || curVelocity * unitFactor > -45 && curVelocity * unitFactor < 15 ? minDuration + (maxDuration - minDuration) * 0.1 : _calculateDuration(curVal, curProp.min, curVelocity);
+
+	          if (curClippedDuration + overshootTolerance < clippedDuration) {
+	            clippedDuration = curClippedDuration + overshootTolerance;
+	          }
+	        }
+
+	        curClippedDuration > duration && (duration = curClippedDuration);
+	      }
+
+	      curDuration > duration && (duration = curDuration);
+	    }
+	  }
+
+	  duration > clippedDuration && (duration = clippedDuration);
+	  return duration > maxDuration ? maxDuration : duration < minDuration ? minDuration : duration;
+	},
+	    _initCore$1 = function _initCore() {
+	  gsap$1 = _getGSAP$1();
+
+	  if (gsap$1) {
+	    _parseEase = gsap$1.parseEase;
+	    _toArray$1 = gsap$1.utils.toArray;
+	    _getUnit$1 = gsap$1.utils.getUnit;
+	    _getCache$1 = gsap$1.core.getCache;
+	    _clamp = gsap$1.utils.clamp;
+	    _getStyleSaver = gsap$1.core.getStyleSaver;
+
+	    _reverting = gsap$1.core.reverting || function () {};
+
+	    _power3 = _parseEase("power3");
+	    _checkPointRatio = _power3(0.05);
+	    PropTween = gsap$1.core.PropTween;
+	    gsap$1.config({
+	      resistance: 100,
+	      unitFactors: {
+	        time: 1000,
+	        totalTime: 1000,
+	        progress: 1000,
+	        totalProgress: 1000
+	      }
+	    });
+	    _config = gsap$1.config();
+	    gsap$1.registerPlugin(VelocityTracker);
+	    _coreInitted$1 = 1;
+	  }
+	};
+
+	var InertiaPlugin = {
+	  version: "3.13.0",
+	  name: "inertia",
+	  register: function register(core) {
+	    gsap$1 = core;
+
+	    _initCore$1();
+	  },
+	  init: function init(target, vars, tween, index, targets) {
+	    _coreInitted$1 || _initCore$1();
+
+	    var tracker = _getTracker(target);
+
+	    if (vars === "auto") {
+	      if (!tracker) {
+	        console.warn("No inertia tracking on " + target + ". InertiaPlugin.track(target) first.");
+	        return;
+	      }
+
+	      vars = tracker.getAll();
+	    }
+
+	    this.styles = _getStyleSaver && typeof target.style === "object" && _getStyleSaver(target);
+	    this.target = target;
+	    this.tween = tween;
+	    _processingVars = vars;
+
+	    var cache = target._gsap,
+	        getVal = cache.get,
+	        dur = vars.duration,
+	        durIsObj = _isObject(dur),
+	        preventOvershoot = vars.preventOvershoot || durIsObj && dur.overshoot === 0,
+	        resistance = _getNumOrDefault(vars, "resistance", _config.resistance),
+	        duration = _isNumber(dur) ? dur : _calculateTweenDuration(target, vars, durIsObj && dur.max || 10, durIsObj && dur.min || 0.2, durIsObj && "overshoot" in dur ? +dur.overshoot : preventOvershoot ? 0 : 1, true),
+	        p,
+	        curProp,
+	        curVal,
+	        unit,
+	        velocity,
+	        change1,
+	        end,
+	        change2,
+	        linkedProps;
+
+	    vars = _processingVars;
+	    _processingVars = 0;
+	    linkedProps = _processLinkedProps(target, vars, getVal, resistance);
+
+	    for (p in vars) {
+	      if (!_reservedProps[p]) {
+	        curProp = vars[p];
+	        _isFunction(curProp) && (curProp = curProp(index, target, targets));
+
+	        if (_isNumber(curProp)) {
+	          velocity = curProp;
+	        } else if (_isObject(curProp) && !isNaN(curProp.velocity)) {
+	          velocity = +curProp.velocity;
+	        } else {
+	          if (tracker && tracker.isTracking(p)) {
+	            velocity = tracker.get(p);
+	          } else {
+	            console.warn("ERROR: No velocity was defined for " + target + " property: " + p);
+	          }
+	        }
+
+	        change1 = _calculateChange(velocity, duration);
+	        change2 = 0;
+	        curVal = getVal(target, p);
+	        unit = _getUnit$1(curVal);
+	        curVal = parseFloat(curVal);
+
+	        if (_isObject(curProp)) {
+	          end = curVal + change1;
+
+	          if ("end" in curProp) {
+	            curProp = _parseEnd(curProp, linkedProps && p in linkedProps ? linkedProps : end, curProp.max, curProp.min, p, vars.radius, velocity);
+	          }
+
+	          if ("max" in curProp && +curProp.max < end) {
+	            if (preventOvershoot || curProp.preventOvershoot) {
+	              change1 = curProp.max - curVal;
+	            } else {
+	              change2 = curProp.max - curVal - change1;
+	            }
+	          } else if ("min" in curProp && +curProp.min > end) {
+	            if (preventOvershoot || curProp.preventOvershoot) {
+	              change1 = curProp.min - curVal;
+	            } else {
+	              change2 = curProp.min - curVal - change1;
+	            }
+	          }
+	        }
+
+	        this._props.push(p);
+
+	        this.styles && this.styles.save(p);
+	        this._pt = new PropTween(this._pt, target, p, curVal, 0, _emptyFunc, 0, cache.set(target, p, this));
+	        this._pt.u = unit || 0;
+	        this._pt.c1 = change1;
+	        this._pt.c2 = change2;
+	      }
+	    }
+
+	    tween.duration(duration);
+	    return _bonusValidated;
+	  },
+	  render: function render(ratio, data) {
+	    var pt = data._pt;
+	    ratio = _power3(data.tween._time / data.tween._dur);
+
+	    if (ratio || !_reverting()) {
+	      while (pt) {
+	        pt.set(pt.t, pt.p, _round$1(pt.s + pt.c1 * ratio + pt.c2 * ratio * ratio) + pt.u, pt.d, ratio);
+	        pt = pt._next;
+	      }
+	    } else {
+	      data.styles.revert();
+	    }
+	  }
+	};
+	"track,untrack,isTracking,getVelocity,getByTarget".split(",").forEach(function (name) {
+	  return InertiaPlugin[name] = VelocityTracker[name];
+	});
+	_getGSAP$1() && gsap$1.registerPlugin(InertiaPlugin);
+
+	exports.InertiaPlugin = InertiaPlugin;
+	exports.VelocityTracker = VelocityTracker;
+	exports.default = InertiaPlugin;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

network-visualization/node_modules/gsap/dist/Observer.js

@@ -0,0 +1,716 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = global || self, factory(global.window = global.window || {}));
+}(this, (function (exports) { 'use strict';
+
+  function _defineProperties(target, props) {
+    for (var i = 0; i < props.length; i++) {
+      var descriptor = props[i];
+      descriptor.enumerable = descriptor.enumerable || false;
+      descriptor.configurable = true;
+      if ("value" in descriptor) descriptor.writable = true;
+      Object.defineProperty(target, descriptor.key, descriptor);
+    }
+  }
+
+  function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+  }
+
+  /*!
+   * Observer 3.13.0
+   * https://gsap.com
+   *
+   * @license Copyright 2008-2025, GreenSock. All rights reserved.
+   * Subject to the terms at https://gsap.com/standard-license
+   * @author: Jack Doyle, jack@greensock.com
+  */
+  var gsap,
+      _coreInitted,
+      _clamp,
+      _win,
+      _doc,
+      _docEl,
+      _body,
+      _isTouch,
+      _pointerType,
+      ScrollTrigger,
+      _root,
+      _normalizer,
+      _eventTypes,
+      _context,
+      _getGSAP = function _getGSAP() {
+    return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+  },
+      _startup = 1,
+      _observers = [];
+      exports._scrollers = [];
+      exports._proxies = [];
+      var _getTime = Date.now,
+      _bridge = function _bridge(name, value) {
+    return value;
+  },
+      _integrate = function _integrate() {
+    var core = ScrollTrigger.core,
+        data = core.bridge || {},
+        scrollers = core._scrollers,
+        proxies = core._proxies;
+    scrollers.push.apply(scrollers, exports._scrollers);
+    proxies.push.apply(proxies, exports._proxies);
+    exports._scrollers = scrollers;
+    exports._proxies = proxies;
+
+    _bridge = function _bridge(name, value) {
+      return data[name](value);
+    };
+  },
+      _getProxyProp = function _getProxyProp(element, property) {
+    return ~exports._proxies.indexOf(element) && exports._proxies[exports._proxies.indexOf(element) + 1][property];
+  },
+      _isViewport = function _isViewport(el) {
+    return !!~_root.indexOf(el);
+  },
+      _addListener = function _addListener(element, type, func, passive, capture) {
+    return element.addEventListener(type, func, {
+      passive: passive !== false,
+      capture: !!capture
+    });
+  },
+      _removeListener = function _removeListener(element, type, func, capture) {
+    return element.removeEventListener(type, func, !!capture);
+  },
+      _scrollLeft = "scrollLeft",
+      _scrollTop = "scrollTop",
+      _onScroll = function _onScroll() {
+    return _normalizer && _normalizer.isPressed || exports._scrollers.cache++;
+  },
+      _scrollCacheFunc = function _scrollCacheFunc(f, doNotCache) {
+    var cachingFunc = function cachingFunc(value) {
+      if (value || value === 0) {
+        _startup && (_win.history.scrollRestoration = "manual");
+        var isNormalizing = _normalizer && _normalizer.isPressed;
+        value = cachingFunc.v = Math.round(value) || (_normalizer && _normalizer.iOS ? 1 : 0);
+        f(value);
+        cachingFunc.cacheID = exports._scrollers.cache;
+        isNormalizing && _bridge("ss", value);
+      } else if (doNotCache || exports._scrollers.cache !== cachingFunc.cacheID || _bridge("ref")) {
+        cachingFunc.cacheID = exports._scrollers.cache;
+        cachingFunc.v = f();
+      }
+
+      return cachingFunc.v + cachingFunc.offset;
+    };
+
+    cachingFunc.offset = 0;
+    return f && cachingFunc;
+  },
+      _horizontal = {
+    s: _scrollLeft,
+    p: "left",
+    p2: "Left",
+    os: "right",
+    os2: "Right",
+    d: "width",
+    d2: "Width",
+    a: "x",
+    sc: _scrollCacheFunc(function (value) {
+      return arguments.length ? _win.scrollTo(value, _vertical.sc()) : _win.pageXOffset || _doc[_scrollLeft] || _docEl[_scrollLeft] || _body[_scrollLeft] || 0;
+    })
+  },
+      _vertical = {
+    s: _scrollTop,
+    p: "top",
+    p2: "Top",
+    os: "bottom",
+    os2: "Bottom",
+    d: "height",
+    d2: "Height",
+    a: "y",
+    op: _horizontal,
+    sc: _scrollCacheFunc(function (value) {
+      return arguments.length ? _win.scrollTo(_horizontal.sc(), value) : _win.pageYOffset || _doc[_scrollTop] || _docEl[_scrollTop] || _body[_scrollTop] || 0;
+    })
+  },
+      _getTarget = function _getTarget(t, self) {
+    return (self && self._ctx && self._ctx.selector || gsap.utils.toArray)(t)[0] || (typeof t === "string" && gsap.config().nullTargetWarn !== false ? console.warn("Element not found:", t) : null);
+  },
+      _isWithin = function _isWithin(element, list) {
+    var i = list.length;
+
+    while (i--) {
+      if (list[i] === element || list[i].contains(element)) {
+        return true;
+      }
+    }
+
+    return false;
+  },
+      _getScrollFunc = function _getScrollFunc(element, _ref) {
+    var s = _ref.s,
+        sc = _ref.sc;
+    _isViewport(element) && (element = _doc.scrollingElement || _docEl);
+
+    var i = exports._scrollers.indexOf(element),
+        offset = sc === _vertical.sc ? 1 : 2;
+
+    !~i && (i = exports._scrollers.push(element) - 1);
+    exports._scrollers[i + offset] || _addListener(element, "scroll", _onScroll);
+    var prev = exports._scrollers[i + offset],
+        func = prev || (exports._scrollers[i + offset] = _scrollCacheFunc(_getProxyProp(element, s), true) || (_isViewport(element) ? sc : _scrollCacheFunc(function (value) {
+      return arguments.length ? element[s] = value : element[s];
+    })));
+    func.target = element;
+    prev || (func.smooth = gsap.getProperty(element, "scrollBehavior") === "smooth");
+    return func;
+  },
+      _getVelocityProp = function _getVelocityProp(value, minTimeRefresh, useDelta) {
+    var v1 = value,
+        v2 = value,
+        t1 = _getTime(),
+        t2 = t1,
+        min = minTimeRefresh || 50,
+        dropToZeroTime = Math.max(500, min * 3),
+        update = function update(value, force) {
+      var t = _getTime();
+
+      if (force || t - t1 > min) {
+        v2 = v1;
+        v1 = value;
+        t2 = t1;
+        t1 = t;
+      } else if (useDelta) {
+        v1 += value;
+      } else {
+        v1 = v2 + (value - v2) / (t - t2) * (t1 - t2);
+      }
+    },
+        reset = function reset() {
+      v2 = v1 = useDelta ? 0 : v1;
+      t2 = t1 = 0;
+    },
+        getVelocity = function getVelocity(latestValue) {
+      var tOld = t2,
+          vOld = v2,
+          t = _getTime();
+
+      (latestValue || latestValue === 0) && latestValue !== v1 && update(latestValue);
+      return t1 === t2 || t - t2 > dropToZeroTime ? 0 : (v1 + (useDelta ? vOld : -vOld)) / ((useDelta ? t : t1) - tOld) * 1000;
+    };
+
+    return {
+      update: update,
+      reset: reset,
+      getVelocity: getVelocity
+    };
+  },
+      _getEvent = function _getEvent(e, preventDefault) {
+    preventDefault && !e._gsapAllow && e.preventDefault();
+    return e.changedTouches ? e.changedTouches[0] : e;
+  },
+      _getAbsoluteMax = function _getAbsoluteMax(a) {
+    var max = Math.max.apply(Math, a),
+        min = Math.min.apply(Math, a);
+    return Math.abs(max) >= Math.abs(min) ? max : min;
+  },
+      _setScrollTrigger = function _setScrollTrigger() {
+    ScrollTrigger = gsap.core.globals().ScrollTrigger;
+    ScrollTrigger && ScrollTrigger.core && _integrate();
+  },
+      _initCore = function _initCore(core) {
+    gsap = core || _getGSAP();
+
+    if (!_coreInitted && gsap && typeof document !== "undefined" && document.body) {
+      _win = window;
+      _doc = document;
+      _docEl = _doc.documentElement;
+      _body = _doc.body;
+      _root = [_win, _doc, _docEl, _body];
+      _clamp = gsap.utils.clamp;
+
+      _context = gsap.core.context || function () {};
+
+      _pointerType = "onpointerenter" in _body ? "pointer" : "mouse";
+      _isTouch = Observer.isTouch = _win.matchMedia && _win.matchMedia("(hover: none), (pointer: coarse)").matches ? 1 : "ontouchstart" in _win || navigator.maxTouchPoints > 0 || navigator.msMaxTouchPoints > 0 ? 2 : 0;
+      _eventTypes = Observer.eventTypes = ("ontouchstart" in _docEl ? "touchstart,touchmove,touchcancel,touchend" : !("onpointerdown" in _docEl) ? "mousedown,mousemove,mouseup,mouseup" : "pointerdown,pointermove,pointercancel,pointerup").split(",");
+      setTimeout(function () {
+        return _startup = 0;
+      }, 500);
+
+      _setScrollTrigger();
+
+      _coreInitted = 1;
+    }
+
+    return _coreInitted;
+  };
+
+  _horizontal.op = _vertical;
+  exports._scrollers.cache = 0;
+  var Observer = function () {
+    function Observer(vars) {
+      this.init(vars);
+    }
+
+    var _proto = Observer.prototype;
+
+    _proto.init = function init(vars) {
+      _coreInitted || _initCore(gsap) || console.warn("Please gsap.registerPlugin(Observer)");
+      ScrollTrigger || _setScrollTrigger();
+      var tolerance = vars.tolerance,
+          dragMinimum = vars.dragMinimum,
+          type = vars.type,
+          target = vars.target,
+          lineHeight = vars.lineHeight,
+          debounce = vars.debounce,
+          preventDefault = vars.preventDefault,
+          onStop = vars.onStop,
+          onStopDelay = vars.onStopDelay,
+          ignore = vars.ignore,
+          wheelSpeed = vars.wheelSpeed,
+          event = vars.event,
+          onDragStart = vars.onDragStart,
+          onDragEnd = vars.onDragEnd,
+          onDrag = vars.onDrag,
+          onPress = vars.onPress,
+          onRelease = vars.onRelease,
+          onRight = vars.onRight,
+          onLeft = vars.onLeft,
+          onUp = vars.onUp,
+          onDown = vars.onDown,
+          onChangeX = vars.onChangeX,
+          onChangeY = vars.onChangeY,
+          onChange = vars.onChange,
+          onToggleX = vars.onToggleX,
+          onToggleY = vars.onToggleY,
+          onHover = vars.onHover,
+          onHoverEnd = vars.onHoverEnd,
+          onMove = vars.onMove,
+          ignoreCheck = vars.ignoreCheck,
+          isNormalizer = vars.isNormalizer,
+          onGestureStart = vars.onGestureStart,
+          onGestureEnd = vars.onGestureEnd,
+          onWheel = vars.onWheel,
+          onEnable = vars.onEnable,
+          onDisable = vars.onDisable,
+          onClick = vars.onClick,
+          scrollSpeed = vars.scrollSpeed,
+          capture = vars.capture,
+          allowClicks = vars.allowClicks,
+          lockAxis = vars.lockAxis,
+          onLockAxis = vars.onLockAxis;
+      this.target = target = _getTarget(target) || _docEl;
+      this.vars = vars;
+      ignore && (ignore = gsap.utils.toArray(ignore));
+      tolerance = tolerance || 1e-9;
+      dragMinimum = dragMinimum || 0;
+      wheelSpeed = wheelSpeed || 1;
+      scrollSpeed = scrollSpeed || 1;
+      type = type || "wheel,touch,pointer";
+      debounce = debounce !== false;
+      lineHeight || (lineHeight = parseFloat(_win.getComputedStyle(_body).lineHeight) || 22);
+
+      var id,
+          onStopDelayedCall,
+          dragged,
+          moved,
+          wheeled,
+          locked,
+          axis,
+          self = this,
+          prevDeltaX = 0,
+          prevDeltaY = 0,
+          passive = vars.passive || !preventDefault && vars.passive !== false,
+          scrollFuncX = _getScrollFunc(target, _horizontal),
+          scrollFuncY = _getScrollFunc(target, _vertical),
+          scrollX = scrollFuncX(),
+          scrollY = scrollFuncY(),
+          limitToTouch = ~type.indexOf("touch") && !~type.indexOf("pointer") && _eventTypes[0] === "pointerdown",
+          isViewport = _isViewport(target),
+          ownerDoc = target.ownerDocument || _doc,
+          deltaX = [0, 0, 0],
+          deltaY = [0, 0, 0],
+          onClickTime = 0,
+          clickCapture = function clickCapture() {
+        return onClickTime = _getTime();
+      },
+          _ignoreCheck = function _ignoreCheck(e, isPointerOrTouch) {
+        return (self.event = e) && ignore && _isWithin(e.target, ignore) || isPointerOrTouch && limitToTouch && e.pointerType !== "touch" || ignoreCheck && ignoreCheck(e, isPointerOrTouch);
+      },
+          onStopFunc = function onStopFunc() {
+        self._vx.reset();
+
+        self._vy.reset();
+
+        onStopDelayedCall.pause();
+        onStop && onStop(self);
+      },
+          update = function update() {
+        var dx = self.deltaX = _getAbsoluteMax(deltaX),
+            dy = self.deltaY = _getAbsoluteMax(deltaY),
+            changedX = Math.abs(dx) >= tolerance,
+            changedY = Math.abs(dy) >= tolerance;
+
+        onChange && (changedX || changedY) && onChange(self, dx, dy, deltaX, deltaY);
+
+        if (changedX) {
+          onRight && self.deltaX > 0 && onRight(self);
+          onLeft && self.deltaX < 0 && onLeft(self);
+          onChangeX && onChangeX(self);
+          onToggleX && self.deltaX < 0 !== prevDeltaX < 0 && onToggleX(self);
+          prevDeltaX = self.deltaX;
+          deltaX[0] = deltaX[1] = deltaX[2] = 0;
+        }
+
+        if (changedY) {
+          onDown && self.deltaY > 0 && onDown(self);
+          onUp && self.deltaY < 0 && onUp(self);
+          onChangeY && onChangeY(self);
+          onToggleY && self.deltaY < 0 !== prevDeltaY < 0 && onToggleY(self);
+          prevDeltaY = self.deltaY;
+          deltaY[0] = deltaY[1] = deltaY[2] = 0;
+        }
+
+        if (moved || dragged) {
+          onMove && onMove(self);
+
+          if (dragged) {
+            onDragStart && dragged === 1 && onDragStart(self);
+            onDrag && onDrag(self);
+            dragged = 0;
+          }
+
+          moved = false;
+        }
+
+        locked && !(locked = false) && onLockAxis && onLockAxis(self);
+
+        if (wheeled) {
+          onWheel(self);
+          wheeled = false;
+        }
+
+        id = 0;
+      },
+          onDelta = function onDelta(x, y, index) {
+        deltaX[index] += x;
+        deltaY[index] += y;
+
+        self._vx.update(x);
+
+        self._vy.update(y);
+
+        debounce ? id || (id = requestAnimationFrame(update)) : update();
+      },
+          onTouchOrPointerDelta = function onTouchOrPointerDelta(x, y) {
+        if (lockAxis && !axis) {
+          self.axis = axis = Math.abs(x) > Math.abs(y) ? "x" : "y";
+          locked = true;
+        }
+
+        if (axis !== "y") {
+          deltaX[2] += x;
+
+          self._vx.update(x, true);
+        }
+
+        if (axis !== "x") {
+          deltaY[2] += y;
+
+          self._vy.update(y, true);
+        }
+
+        debounce ? id || (id = requestAnimationFrame(update)) : update();
+      },
+          _onDrag = function _onDrag(e) {
+        if (_ignoreCheck(e, 1)) {
+          return;
+        }
+
+        e = _getEvent(e, preventDefault);
+        var x = e.clientX,
+            y = e.clientY,
+            dx = x - self.x,
+            dy = y - self.y,
+            isDragging = self.isDragging;
+        self.x = x;
+        self.y = y;
+
+        if (isDragging || (dx || dy) && (Math.abs(self.startX - x) >= dragMinimum || Math.abs(self.startY - y) >= dragMinimum)) {
+          dragged = isDragging ? 2 : 1;
+          isDragging || (self.isDragging = true);
+          onTouchOrPointerDelta(dx, dy);
+        }
+      },
+          _onPress = self.onPress = function (e) {
+        if (_ignoreCheck(e, 1) || e && e.button) {
+          return;
+        }
+
+        self.axis = axis = null;
+        onStopDelayedCall.pause();
+        self.isPressed = true;
+        e = _getEvent(e);
+        prevDeltaX = prevDeltaY = 0;
+        self.startX = self.x = e.clientX;
+        self.startY = self.y = e.clientY;
+
+        self._vx.reset();
+
+        self._vy.reset();
+
+        _addListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, passive, true);
+
+        self.deltaX = self.deltaY = 0;
+        onPress && onPress(self);
+      },
+          _onRelease = self.onRelease = function (e) {
+        if (_ignoreCheck(e, 1)) {
+          return;
+        }
+
+        _removeListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, true);
+
+        var isTrackingDrag = !isNaN(self.y - self.startY),
+            wasDragging = self.isDragging,
+            isDragNotClick = wasDragging && (Math.abs(self.x - self.startX) > 3 || Math.abs(self.y - self.startY) > 3),
+            eventData = _getEvent(e);
+
+        if (!isDragNotClick && isTrackingDrag) {
+          self._vx.reset();
+
+          self._vy.reset();
+
+          if (preventDefault && allowClicks) {
+            gsap.delayedCall(0.08, function () {
+              if (_getTime() - onClickTime > 300 && !e.defaultPrevented) {
+                if (e.target.click) {
+                  e.target.click();
+                } else if (ownerDoc.createEvent) {
+                  var syntheticEvent = ownerDoc.createEvent("MouseEvents");
+                  syntheticEvent.initMouseEvent("click", true, true, _win, 1, eventData.screenX, eventData.screenY, eventData.clientX, eventData.clientY, false, false, false, false, 0, null);
+                  e.target.dispatchEvent(syntheticEvent);
+                }
+              }
+            });
+          }
+        }
+
+        self.isDragging = self.isGesturing = self.isPressed = false;
+        onStop && wasDragging && !isNormalizer && onStopDelayedCall.restart(true);
+        dragged && update();
+        onDragEnd && wasDragging && onDragEnd(self);
+        onRelease && onRelease(self, isDragNotClick);
+      },
+          _onGestureStart = function _onGestureStart(e) {
+        return e.touches && e.touches.length > 1 && (self.isGesturing = true) && onGestureStart(e, self.isDragging);
+      },
+          _onGestureEnd = function _onGestureEnd() {
+        return (self.isGesturing = false) || onGestureEnd(self);
+      },
+          onScroll = function onScroll(e) {
+        if (_ignoreCheck(e)) {
+          return;
+        }
+
+        var x = scrollFuncX(),
+            y = scrollFuncY();
+        onDelta((x - scrollX) * scrollSpeed, (y - scrollY) * scrollSpeed, 1);
+        scrollX = x;
+        scrollY = y;
+        onStop && onStopDelayedCall.restart(true);
+      },
+          _onWheel = function _onWheel(e) {
+        if (_ignoreCheck(e)) {
+          return;
+        }
+
+        e = _getEvent(e, preventDefault);
+        onWheel && (wheeled = true);
+        var multiplier = (e.deltaMode === 1 ? lineHeight : e.deltaMode === 2 ? _win.innerHeight : 1) * wheelSpeed;
+        onDelta(e.deltaX * multiplier, e.deltaY * multiplier, 0);
+        onStop && !isNormalizer && onStopDelayedCall.restart(true);
+      },
+          _onMove = function _onMove(e) {
+        if (_ignoreCheck(e)) {
+          return;
+        }
+
+        var x = e.clientX,
+            y = e.clientY,
+            dx = x - self.x,
+            dy = y - self.y;
+        self.x = x;
+        self.y = y;
+        moved = true;
+        onStop && onStopDelayedCall.restart(true);
+        (dx || dy) && onTouchOrPointerDelta(dx, dy);
+      },
+          _onHover = function _onHover(e) {
+        self.event = e;
+        onHover(self);
+      },
+          _onHoverEnd = function _onHoverEnd(e) {
+        self.event = e;
+        onHoverEnd(self);
+      },
+          _onClick = function _onClick(e) {
+        return _ignoreCheck(e) || _getEvent(e, preventDefault) && onClick(self);
+      };
+
+      onStopDelayedCall = self._dc = gsap.delayedCall(onStopDelay || 0.25, onStopFunc).pause();
+      self.deltaX = self.deltaY = 0;
+      self._vx = _getVelocityProp(0, 50, true);
+      self._vy = _getVelocityProp(0, 50, true);
+      self.scrollX = scrollFuncX;
+      self.scrollY = scrollFuncY;
+      self.isDragging = self.isGesturing = self.isPressed = false;
+
+      _context(this);
+
+      self.enable = function (e) {
+        if (!self.isEnabled) {
+          _addListener(isViewport ? ownerDoc : target, "scroll", _onScroll);
+
+          type.indexOf("scroll") >= 0 && _addListener(isViewport ? ownerDoc : target, "scroll", onScroll, passive, capture);
+          type.indexOf("wheel") >= 0 && _addListener(target, "wheel", _onWheel, passive, capture);
+
+          if (type.indexOf("touch") >= 0 && _isTouch || type.indexOf("pointer") >= 0) {
+            _addListener(target, _eventTypes[0], _onPress, passive, capture);
+
+            _addListener(ownerDoc, _eventTypes[2], _onRelease);
+
+            _addListener(ownerDoc, _eventTypes[3], _onRelease);
+
+            allowClicks && _addListener(target, "click", clickCapture, true, true);
+            onClick && _addListener(target, "click", _onClick);
+            onGestureStart && _addListener(ownerDoc, "gesturestart", _onGestureStart);
+            onGestureEnd && _addListener(ownerDoc, "gestureend", _onGestureEnd);
+            onHover && _addListener(target, _pointerType + "enter", _onHover);
+            onHoverEnd && _addListener(target, _pointerType + "leave", _onHoverEnd);
+            onMove && _addListener(target, _pointerType + "move", _onMove);
+          }
+
+          self.isEnabled = true;
+          self.isDragging = self.isGesturing = self.isPressed = moved = dragged = false;
+
+          self._vx.reset();
+
+          self._vy.reset();
+
+          scrollX = scrollFuncX();
+          scrollY = scrollFuncY();
+          e && e.type && _onPress(e);
+          onEnable && onEnable(self);
+        }
+
+        return self;
+      };
+
+      self.disable = function () {
+        if (self.isEnabled) {
+          _observers.filter(function (o) {
+            return o !== self && _isViewport(o.target);
+          }).length || _removeListener(isViewport ? ownerDoc : target, "scroll", _onScroll);
+
+          if (self.isPressed) {
+            self._vx.reset();
+
+            self._vy.reset();
+
+            _removeListener(isNormalizer ? target : ownerDoc, _eventTypes[1], _onDrag, true);
+          }
+
+          _removeListener(isViewport ? ownerDoc : target, "scroll", onScroll, capture);
+
+          _removeListener(target, "wheel", _onWheel, capture);
+
+          _removeListener(target, _eventTypes[0], _onPress, capture);
+
+          _removeListener(ownerDoc, _eventTypes[2], _onRelease);
+
+          _removeListener(ownerDoc, _eventTypes[3], _onRelease);
+
+          _removeListener(target, "click", clickCapture, true);
+
+          _removeListener(target, "click", _onClick);
+
+          _removeListener(ownerDoc, "gesturestart", _onGestureStart);
+
+          _removeListener(ownerDoc, "gestureend", _onGestureEnd);
+
+          _removeListener(target, _pointerType + "enter", _onHover);
+
+          _removeListener(target, _pointerType + "leave", _onHoverEnd);
+
+          _removeListener(target, _pointerType + "move", _onMove);
+
+          self.isEnabled = self.isPressed = self.isDragging = false;
+          onDisable && onDisable(self);
+        }
+      };
+
+      self.kill = self.revert = function () {
+        self.disable();
+
+        var i = _observers.indexOf(self);
+
+        i >= 0 && _observers.splice(i, 1);
+        _normalizer === self && (_normalizer = 0);
+      };
+
+      _observers.push(self);
+
+      isNormalizer && _isViewport(target) && (_normalizer = self);
+      self.enable(event);
+    };
+
+    _createClass(Observer, [{
+      key: "velocityX",
+      get: function get() {
+        return this._vx.getVelocity();
+      }
+    }, {
+      key: "velocityY",
+      get: function get() {
+        return this._vy.getVelocity();
+      }
+    }]);
+
+    return Observer;
+  }();
+  Observer.version = "3.13.0";
+
+  Observer.create = function (vars) {
+    return new Observer(vars);
+  };
+
+  Observer.register = _initCore;
+
+  Observer.getAll = function () {
+    return _observers.slice();
+  };
+
+  Observer.getById = function (id) {
+    return _observers.filter(function (o) {
+      return o.vars.id === id;
+    })[0];
+  };
+
+  _getGSAP() && gsap.registerPlugin(Observer);
+
+  exports.Observer = Observer;
+  exports._getProxyProp = _getProxyProp;
+  exports._getScrollFunc = _getScrollFunc;
+  exports._getTarget = _getTarget;
+  exports._getVelocityProp = _getVelocityProp;
+  exports._horizontal = _horizontal;
+  exports._isViewport = _isViewport;
+  exports._vertical = _vertical;
+  exports.default = Observer;
+
+  if (typeof(window) === 'undefined' || window !== exports) {Object.defineProperty(exports, '__esModule', { value: true });} else {delete window.default;}
+
+})));

network-visualization/node_modules/gsap/dist/Physics2DPlugin.js

@@ -0,0 +1,167 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = global || self, factory(global.window = global.window || {}));
+}(this, (function (exports) { 'use strict';
+
+	/*!
+	 * Physics2DPlugin 3.13.0
+	 * https://gsap.com
+	 *
+	 * @license Copyright 2008-2025, GreenSock. All rights reserved.
+	 * Subject to the terms at https://gsap.com/standard-license
+	 * @author: Jack Doyle, jack@greensock.com
+	*/
+	var gsap,
+	    _coreInitted,
+	    _getUnit,
+	    _getStyleSaver,
+	    _reverting,
+	    _DEG2RAD = Math.PI / 180,
+	    _getGSAP = function _getGSAP() {
+	  return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+	},
+	    _round = function _round(value) {
+	  return Math.round(value * 10000) / 10000;
+	},
+	    _initCore = function _initCore(core) {
+	  gsap = core || _getGSAP();
+
+	  if (!_coreInitted) {
+	    _getUnit = gsap.utils.getUnit;
+	    _getStyleSaver = gsap.core.getStyleSaver;
+
+	    _reverting = gsap.core.reverting || function () {};
+
+	    _coreInitted = 1;
+	  }
+	};
+
+	var PhysicsProp = function PhysicsProp(target, p, velocity, acceleration, stepsPerTimeUnit) {
+	  var cache = target._gsap,
+	      curVal = cache.get(target, p);
+	  this.p = p;
+	  this.set = cache.set(target, p);
+	  this.s = this.val = parseFloat(curVal);
+	  this.u = _getUnit(curVal) || 0;
+	  this.vel = velocity || 0;
+	  this.v = this.vel / stepsPerTimeUnit;
+
+	  if (acceleration || acceleration === 0) {
+	    this.acc = acceleration;
+	    this.a = this.acc / (stepsPerTimeUnit * stepsPerTimeUnit);
+	  } else {
+	    this.acc = this.a = 0;
+	  }
+	};
+
+	var Physics2DPlugin = {
+	  version: "3.13.0",
+	  name: "physics2D",
+	  register: _initCore,
+	  init: function init(target, value, tween) {
+	    _coreInitted || _initCore();
+	    var data = this,
+	        angle = +value.angle || 0,
+	        velocity = +value.velocity || 0,
+	        acceleration = +value.acceleration || 0,
+	        xProp = value.xProp || "x",
+	        yProp = value.yProp || "y",
+	        aAngle = value.accelerationAngle || value.accelerationAngle === 0 ? +value.accelerationAngle : angle;
+	    data.styles = _getStyleSaver && _getStyleSaver(target, value.xProp && value.xProp !== "x" ? value.xProp + "," + value.yProp : "transform");
+	    data.target = target;
+	    data.tween = tween;
+	    data.step = 0;
+	    data.sps = 30;
+
+	    if (value.gravity) {
+	      acceleration = +value.gravity;
+	      aAngle = 90;
+	    }
+
+	    angle *= _DEG2RAD;
+	    aAngle *= _DEG2RAD;
+	    data.fr = 1 - (+value.friction || 0);
+
+	    data._props.push(xProp, yProp);
+
+	    data.xp = new PhysicsProp(target, xProp, Math.cos(angle) * velocity, Math.cos(aAngle) * acceleration, data.sps);
+	    data.yp = new PhysicsProp(target, yProp, Math.sin(angle) * velocity, Math.sin(aAngle) * acceleration, data.sps);
+	    data.skipX = data.skipY = 0;
+	  },
+	  render: function render(ratio, data) {
+	    var xp = data.xp,
+	        yp = data.yp,
+	        tween = data.tween,
+	        target = data.target,
+	        step = data.step,
+	        sps = data.sps,
+	        fr = data.fr,
+	        skipX = data.skipX,
+	        skipY = data.skipY,
+	        time = tween._from ? tween._dur - tween._time : tween._time,
+	        x,
+	        y,
+	        tt,
+	        steps,
+	        remainder,
+	        i;
+
+	    if (tween._time || !_reverting()) {
+	      if (fr === 1) {
+	        tt = time * time * 0.5;
+	        x = xp.s + xp.vel * time + xp.acc * tt;
+	        y = yp.s + yp.vel * time + yp.acc * tt;
+	      } else {
+	        time *= sps;
+	        steps = i = (time | 0) - step;
+
+	        if (i < 0) {
+	          xp.v = xp.vel / sps;
+	          yp.v = yp.vel / sps;
+	          xp.val = xp.s;
+	          yp.val = yp.s;
+	          data.step = 0;
+	          steps = i = time | 0;
+	        }
+
+	        remainder = time % 1 * fr;
+
+	        while (i--) {
+	          xp.v += xp.a;
+	          yp.v += yp.a;
+	          xp.v *= fr;
+	          yp.v *= fr;
+	          xp.val += xp.v;
+	          yp.val += yp.v;
+	        }
+
+	        x = xp.val + xp.v * remainder;
+	        y = yp.val + yp.v * remainder;
+	        data.step += steps;
+	      }
+
+	      skipX || xp.set(target, xp.p, _round(x) + xp.u);
+	      skipY || yp.set(target, yp.p, _round(y) + yp.u);
+	    } else {
+	      data.styles.revert();
+	    }
+	  },
+	  kill: function kill(property) {
+	    if (this.xp.p === property) {
+	      this.skipX = 1;
+	    }
+
+	    if (this.yp.p === property) {
+	      this.skipY = 1;
+	    }
+	  }
+	};
+	_getGSAP() && gsap.registerPlugin(Physics2DPlugin);
+
+	exports.Physics2DPlugin = Physics2DPlugin;
+	exports.default = Physics2DPlugin;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

network-visualization/node_modules/gsap/dist/Physics2DPlugin.min.js

@@ -0,0 +1,11 @@
+/*!
+ * Physics2DPlugin 3.13.0
+ * https://gsap.com
+ * 
+ * @license Copyright 2025, GreenSock. All rights reserved.
+ * Subject to the terms at https://gsap.com/standard-license.
+ * @author: Jack Doyle, jack@greensock.com
+ */
+
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e=e||self).window=e.window||{})}(this,function(e){"use strict";function j(){return t||"undefined"!=typeof window&&(t=window.gsap)&&t.registerPlugin&&t}function k(e){return Math.round(1e4*e)/1e4}function l(e){t=e||j(),v||(o=t.utils.getUnit,f=t.core.getStyleSaver,w=t.core.reverting||function(){},v=1)}function m(e,t,i,s,n){var r=e._gsap,a=r.get(e,t);this.p=t,this.set=r.set(e,t),this.s=this.val=parseFloat(a),this.u=o(a)||0,this.vel=i||0,this.v=this.vel/n,s||0===s?(this.acc=s,this.a=this.acc/(n*n)):this.acc=this.a=0}var t,v,o,f,w,u=Math.PI/180,i={version:"3.13.0",name:"physics2D",register:l,init:function init(e,t,i){v||l();var s=this,n=+t.angle||0,r=+t.velocity||0,a=+t.acceleration||0,o=t.xProp||"x",p=t.yProp||"y",c=t.accelerationAngle||0===t.accelerationAngle?+t.accelerationAngle:n;s.styles=f&&f(e,t.xProp&&"x"!==t.xProp?t.xProp+","+t.yProp:"transform"),s.target=e,s.tween=i,s.step=0,s.sps=30,t.gravity&&(a=+t.gravity,c=90),n*=u,c*=u,s.fr=1-(+t.friction||0),s._props.push(o,p),s.xp=new m(e,o,Math.cos(n)*r,Math.cos(c)*a,s.sps),s.yp=new m(e,p,Math.sin(n)*r,Math.sin(c)*a,s.sps),s.skipX=s.skipY=0},render:function render(e,t){var i,s,n,r,a,o,p=t.xp,l=t.yp,c=t.tween,v=t.target,f=t.step,u=t.sps,h=t.fr,d=t.skipX,g=t.skipY,y=c._from?c._dur-c._time:c._time;if(c._time||!w()){if(1===h)n=y*y*.5,i=p.s+p.vel*y+p.acc*n,s=l.s+l.vel*y+l.acc*n;else{for(r=o=(0|(y*=u))-f,o<0&&(p.v=p.vel/u,l.v=l.vel/u,p.val=p.s,l.val=l.s,r=o=(t.step=0)|y),a=y%1*h;o--;)p.v+=p.a,l.v+=l.a,p.v*=h,l.v*=h,p.val+=p.v,l.val+=l.v;i=p.val+p.v*a,s=l.val+l.v*a,t.step+=r}d||p.set(v,p.p,k(i)+p.u),g||l.set(v,l.p,k(s)+l.u)}else t.styles.revert()},kill:function kill(e){this.xp.p===e&&(this.skipX=1),this.yp.p===e&&(this.skipY=1)}};j()&&t.registerPlugin(i),e.Physics2DPlugin=i,e.default=i;if (typeof(window)==="undefined"||window!==e){Object.defineProperty(e,"__esModule",{value:!0})} else {delete e.default}});
+

network-visualization/node_modules/gsap/dist/PhysicsPropsPlugin.js

@@ -0,0 +1,166 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = global || self, factory(global.window = global.window || {}));
+}(this, (function (exports) { 'use strict';
+
+	/*!
+	 * PhysicsPropsPlugin 3.13.0
+	 * https://gsap.com
+	 *
+	 * @license Copyright 2008-2025, GreenSock. All rights reserved.
+	 * Subject to the terms at https://gsap.com/standard-license
+	 * @author: Jack Doyle, jack@greensock.com
+	*/
+	var gsap,
+	    _coreInitted,
+	    _getUnit,
+	    _getStyleSaver,
+	    _reverting,
+	    _getGSAP = function _getGSAP() {
+	  return gsap || typeof window !== "undefined" && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+	},
+	    _round = function _round(value) {
+	  return Math.round(value * 10000) / 10000;
+	},
+	    _initCore = function _initCore(core) {
+	  gsap = core || _getGSAP();
+
+	  if (!_coreInitted) {
+	    _getUnit = gsap.utils.getUnit;
+	    _getStyleSaver = gsap.core.getStyleSaver;
+
+	    _reverting = gsap.core.reverting || function () {};
+
+	    _coreInitted = 1;
+	  }
+	};
+
+	var PhysicsProp = function PhysicsProp(target, p, velocity, acceleration, friction, stepsPerTimeUnit) {
+	  var cache = target._gsap,
+	      curVal = cache.get(target, p);
+	  this.p = p;
+	  this.set = cache.set(target, p);
+	  this.s = this.val = parseFloat(curVal);
+	  this.u = _getUnit(curVal) || 0;
+	  this.vel = velocity || 0;
+	  this.v = this.vel / stepsPerTimeUnit;
+
+	  if (acceleration || acceleration === 0) {
+	    this.acc = acceleration;
+	    this.a = this.acc / (stepsPerTimeUnit * stepsPerTimeUnit);
+	  } else {
+	    this.acc = this.a = 0;
+	  }
+
+	  this.fr = 1 - (friction || 0);
+	};
+
+	var PhysicsPropsPlugin = {
+	  version: "3.13.0",
+	  name: "physicsProps",
+	  register: _initCore,
+	  init: function init(target, value, tween) {
+	    _coreInitted || _initCore();
+	    var data = this,
+	        p;
+	    data.styles = _getStyleSaver && _getStyleSaver(target);
+	    data.target = target;
+	    data.tween = tween;
+	    data.step = 0;
+	    data.sps = 30;
+	    data.vProps = [];
+
+	    for (p in value) {
+	      var _value$p = value[p],
+	          velocity = _value$p.velocity,
+	          acceleration = _value$p.acceleration,
+	          friction = _value$p.friction;
+
+	      if (velocity || acceleration) {
+	        data.vProps.push(new PhysicsProp(target, p, velocity, acceleration, friction, data.sps));
+
+	        data._props.push(p);
+
+	        _getStyleSaver && data.styles.save(p);
+	        friction && (data.hasFr = 1);
+	      }
+	    }
+	  },
+	  render: function render(ratio, data) {
+	    var vProps = data.vProps,
+	        tween = data.tween,
+	        target = data.target,
+	        step = data.step,
+	        hasFr = data.hasFr,
+	        sps = data.sps,
+	        i = vProps.length,
+	        time = tween._from ? tween._dur - tween._time : tween._time,
+	        curProp,
+	        steps,
+	        remainder,
+	        j,
+	        tt;
+
+	    if (tween._time || !_reverting()) {
+	      if (hasFr) {
+	        time *= sps;
+	        steps = (time | 0) - step;
+
+	        if (steps < 0) {
+	          while (i--) {
+	            curProp = vProps[i];
+	            curProp.v = curProp.vel / sps;
+	            curProp.val = curProp.s;
+	          }
+
+	          i = vProps.length;
+	          data.step = step = 0;
+	          steps = time | 0;
+	        }
+
+	        remainder = time % 1;
+
+	        while (i--) {
+	          curProp = vProps[i];
+	          j = steps;
+
+	          while (j--) {
+	            curProp.v += curProp.a;
+	            curProp.v *= curProp.fr;
+	            curProp.val += curProp.v;
+	          }
+
+	          curProp.set(target, curProp.p, _round(curProp.val + curProp.v * remainder * curProp.fr) + curProp.u);
+	        }
+
+	        data.step += steps;
+	      } else {
+	        tt = time * time * 0.5;
+
+	        while (i--) {
+	          curProp = vProps[i];
+	          curProp.set(target, curProp.p, _round(curProp.s + curProp.vel * time + curProp.acc * tt) + curProp.u);
+	        }
+	      }
+	    } else {
+	      data.styles.revert();
+	    }
+	  },
+	  kill: function kill(property) {
+	    var vProps = this.vProps,
+	        i = vProps.length;
+
+	    while (i--) {
+	      vProps[i].p === property && vProps.splice(i, 1);
+	    }
+	  }
+	};
+	_getGSAP() && gsap.registerPlugin(PhysicsPropsPlugin);
+
+	exports.PhysicsPropsPlugin = PhysicsPropsPlugin;
+	exports.default = PhysicsPropsPlugin;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

network-visualization/node_modules/gsap/dist/PhysicsPropsPlugin.min.js

@@ -0,0 +1,11 @@
+/*!
+ * PhysicsPropsPlugin 3.13.0
+ * https://gsap.com
+ * 
+ * @license Copyright 2025, GreenSock. All rights reserved.
+ * Subject to the terms at https://gsap.com/standard-license.
+ * @author: Jack Doyle, jack@greensock.com
+ */
+
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e=e||self).window=e.window||{})}(this,function(e){"use strict";function i(){return t||"undefined"!=typeof window&&(t=window.gsap)&&t.registerPlugin&&t}function j(e){return Math.round(1e4*e)/1e4}function k(e){t=e||i(),p||(a=t.utils.getUnit,c=t.core.getStyleSaver,d=t.core.reverting||function(){},p=1)}function l(e,t,s,i,r,n){var o=e._gsap,f=o.get(e,t);this.p=t,this.set=o.set(e,t),this.s=this.val=parseFloat(f),this.u=a(f)||0,this.vel=s||0,this.v=this.vel/n,i||0===i?(this.acc=i,this.a=this.acc/(n*n)):this.acc=this.a=0,this.fr=1-(r||0)}var t,p,a,c,d,s={version:"3.13.0",name:"physicsProps",register:k,init:function init(e,t,s){p||k();var i,r=this;for(i in r.styles=c&&c(e),r.target=e,r.tween=s,r.step=0,r.sps=30,r.vProps=[],t){var n=t[i],o=n.velocity,f=n.acceleration,a=n.friction;(o||f)&&(r.vProps.push(new l(e,i,o,f,a,r.sps)),r._props.push(i),c&&r.styles.save(i),a&&(r.hasFr=1))}},render:function render(e,t){var s,i,r,n,o,f=t.vProps,l=t.tween,a=t.target,p=t.step,c=t.hasFr,u=t.sps,v=f.length,h=l._from?l._dur-l._time:l._time;if(l._time||!d())if(c){if((i=(0|(h*=u))-p)<0){for(;v--;)(s=f[v]).v=s.vel/u,s.val=s.s;v=f.length,t.step=p=0,i=0|h}for(r=h%1;v--;){for(s=f[v],n=i;n--;)s.v+=s.a,s.v*=s.fr,s.val+=s.v;s.set(a,s.p,j(s.val+s.v*r*s.fr)+s.u)}t.step+=i}else for(o=h*h*.5;v--;)(s=f[v]).set(a,s.p,j(s.s+s.vel*h+s.acc*o)+s.u);else t.styles.revert()},kill:function kill(e){for(var t=this.vProps,s=t.length;s--;)t[s].p===e&&t.splice(s,1)}};i()&&t.registerPlugin(s),e.PhysicsPropsPlugin=s,e.default=s;if (typeof(window)==="undefined"||window!==e){Object.defineProperty(e,"__esModule",{value:!0})} else {delete e.default}});
+

network-visualization/node_modules/gsap/dist/PixiPlugin.js

@@ -0,0 +1,474 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = global || self, factory(global.window = global.window || {}));
+}(this, (function (exports) { 'use strict';
+
+	/*!
+	 * PixiPlugin 3.13.0
+	 * https://gsap.com
+	 *
+	 * @license Copyright 2008-2025, GreenSock. All rights reserved.
+	 * Subject to the terms at https://gsap.com/standard-license
+	 * @author: Jack Doyle, jack@greensock.com
+	*/
+	var gsap,
+	    _splitColor,
+	    _coreInitted,
+	    _PIXI,
+	    PropTween,
+	    _getSetter,
+	    _isV4,
+	    _isV8Plus,
+	    _windowExists = function _windowExists() {
+	  return typeof window !== "undefined";
+	},
+	    _getGSAP = function _getGSAP() {
+	  return gsap || _windowExists() && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+	},
+	    _isFunction = function _isFunction(value) {
+	  return typeof value === "function";
+	},
+	    _warn = function _warn(message) {
+	  return console.warn(message);
+	},
+	    _idMatrix = [1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0],
+	    _lumR = 0.212671,
+	    _lumG = 0.715160,
+	    _lumB = 0.072169,
+	    _filterClass = function _filterClass(name) {
+	  return _isFunction(_PIXI[name]) ? _PIXI[name] : _PIXI.filters[name];
+	},
+	    _applyMatrix = function _applyMatrix(m, m2) {
+	  var temp = [],
+	      i = 0,
+	      z = 0,
+	      y,
+	      x;
+
+	  for (y = 0; y < 4; y++) {
+	    for (x = 0; x < 5; x++) {
+	      z = x === 4 ? m[i + 4] : 0;
+	      temp[i + x] = m[i] * m2[x] + m[i + 1] * m2[x + 5] + m[i + 2] * m2[x + 10] + m[i + 3] * m2[x + 15] + z;
+	    }
+
+	    i += 5;
+	  }
+
+	  return temp;
+	},
+	    _setSaturation = function _setSaturation(m, n) {
+	  var inv = 1 - n,
+	      r = inv * _lumR,
+	      g = inv * _lumG,
+	      b = inv * _lumB;
+	  return _applyMatrix([r + n, g, b, 0, 0, r, g + n, b, 0, 0, r, g, b + n, 0, 0, 0, 0, 0, 1, 0], m);
+	},
+	    _colorize = function _colorize(m, color, amount) {
+	  var c = _splitColor(color),
+	      r = c[0] / 255,
+	      g = c[1] / 255,
+	      b = c[2] / 255,
+	      inv = 1 - amount;
+
+	  return _applyMatrix([inv + amount * r * _lumR, amount * r * _lumG, amount * r * _lumB, 0, 0, amount * g * _lumR, inv + amount * g * _lumG, amount * g * _lumB, 0, 0, amount * b * _lumR, amount * b * _lumG, inv + amount * b * _lumB, 0, 0, 0, 0, 0, 1, 0], m);
+	},
+	    _setHue = function _setHue(m, n) {
+	  n *= Math.PI / 180;
+	  var c = Math.cos(n),
+	      s = Math.sin(n);
+	  return _applyMatrix([_lumR + c * (1 - _lumR) + s * -_lumR, _lumG + c * -_lumG + s * -_lumG, _lumB + c * -_lumB + s * (1 - _lumB), 0, 0, _lumR + c * -_lumR + s * 0.143, _lumG + c * (1 - _lumG) + s * 0.14, _lumB + c * -_lumB + s * -0.283, 0, 0, _lumR + c * -_lumR + s * -(1 - _lumR), _lumG + c * -_lumG + s * _lumG, _lumB + c * (1 - _lumB) + s * _lumB, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1], m);
+	},
+	    _setContrast = function _setContrast(m, n) {
+	  return _applyMatrix([n, 0, 0, 0, 0.5 * (1 - n), 0, n, 0, 0, 0.5 * (1 - n), 0, 0, n, 0, 0.5 * (1 - n), 0, 0, 0, 1, 0], m);
+	},
+	    _getFilter = function _getFilter(target, type) {
+	  var filterClass = _filterClass(type),
+	      filters = target.filters || [],
+	      i = filters.length,
+	      filter;
+
+	  filterClass || _warn(type + " not found. PixiPlugin.registerPIXI(PIXI)");
+
+	  while (--i > -1) {
+	    if (filters[i] instanceof filterClass) {
+	      return filters[i];
+	    }
+	  }
+
+	  filter = new filterClass();
+
+	  if (type === "BlurFilter") {
+	    if (_isV8Plus) {
+	      filter.strength = 0;
+	    } else {
+	      filter.blur = 0;
+	    }
+	  }
+
+	  target.filters = [].concat(filters, [filter]);
+	  return filter;
+	},
+	    _addColorMatrixFilterCacheTween = function _addColorMatrixFilterCacheTween(p, plugin, cache, vars) {
+	  plugin.add(cache, p, cache[p], vars[p]);
+
+	  plugin._props.push(p);
+	},
+	    _applyBrightnessToMatrix = function _applyBrightnessToMatrix(brightness, matrix) {
+	  var filterClass = _filterClass("ColorMatrixFilter"),
+	      temp = new filterClass();
+
+	  temp.matrix = matrix;
+	  temp.brightness(brightness, true);
+	  return temp.matrix;
+	},
+	    _copy = function _copy(obj) {
+	  var copy = {},
+	      p;
+
+	  for (p in obj) {
+	    copy[p] = obj[p];
+	  }
+
+	  return copy;
+	},
+	    _CMFdefaults = {
+	  contrast: 1,
+	  saturation: 1,
+	  colorizeAmount: 0,
+	  colorize: "rgb(255,255,255)",
+	  hue: 0,
+	  brightness: 1
+	},
+	    _parseColorMatrixFilter = function _parseColorMatrixFilter(target, v, pg) {
+	  var filter = _getFilter(target, "ColorMatrixFilter"),
+	      cache = target._gsColorMatrixFilter = target._gsColorMatrixFilter || _copy(_CMFdefaults),
+	      combine = v.combineCMF && !("colorMatrixFilter" in v && !v.colorMatrixFilter),
+	      i,
+	      matrix,
+	      startMatrix;
+
+	  startMatrix = filter.matrix;
+
+	  if (v.resolution) {
+	    filter.resolution = v.resolution;
+	  }
+
+	  if (v.matrix && v.matrix.length === startMatrix.length) {
+	    matrix = v.matrix;
+
+	    if (cache.contrast !== 1) {
+	      _addColorMatrixFilterCacheTween("contrast", pg, cache, _CMFdefaults);
+	    }
+
+	    if (cache.hue) {
+	      _addColorMatrixFilterCacheTween("hue", pg, cache, _CMFdefaults);
+	    }
+
+	    if (cache.brightness !== 1) {
+	      _addColorMatrixFilterCacheTween("brightness", pg, cache, _CMFdefaults);
+	    }
+
+	    if (cache.colorizeAmount) {
+	      _addColorMatrixFilterCacheTween("colorize", pg, cache, _CMFdefaults);
+
+	      _addColorMatrixFilterCacheTween("colorizeAmount", pg, cache, _CMFdefaults);
+	    }
+
+	    if (cache.saturation !== 1) {
+	      _addColorMatrixFilterCacheTween("saturation", pg, cache, _CMFdefaults);
+	    }
+	  } else {
+	    matrix = _idMatrix.slice();
+
+	    if (v.contrast != null) {
+	      matrix = _setContrast(matrix, +v.contrast);
+
+	      _addColorMatrixFilterCacheTween("contrast", pg, cache, v);
+	    } else if (cache.contrast !== 1) {
+	      if (combine) {
+	        matrix = _setContrast(matrix, cache.contrast);
+	      } else {
+	        _addColorMatrixFilterCacheTween("contrast", pg, cache, _CMFdefaults);
+	      }
+	    }
+
+	    if (v.hue != null) {
+	      matrix = _setHue(matrix, +v.hue);
+
+	      _addColorMatrixFilterCacheTween("hue", pg, cache, v);
+	    } else if (cache.hue) {
+	      if (combine) {
+	        matrix = _setHue(matrix, cache.hue);
+	      } else {
+	        _addColorMatrixFilterCacheTween("hue", pg, cache, _CMFdefaults);
+	      }
+	    }
+
+	    if (v.brightness != null) {
+	      matrix = _applyBrightnessToMatrix(+v.brightness, matrix);
+
+	      _addColorMatrixFilterCacheTween("brightness", pg, cache, v);
+	    } else if (cache.brightness !== 1) {
+	      if (combine) {
+	        matrix = _applyBrightnessToMatrix(cache.brightness, matrix);
+	      } else {
+	        _addColorMatrixFilterCacheTween("brightness", pg, cache, _CMFdefaults);
+	      }
+	    }
+
+	    if (v.colorize != null) {
+	      v.colorizeAmount = "colorizeAmount" in v ? +v.colorizeAmount : 1;
+	      matrix = _colorize(matrix, v.colorize, v.colorizeAmount);
+
+	      _addColorMatrixFilterCacheTween("colorize", pg, cache, v);
+
+	      _addColorMatrixFilterCacheTween("colorizeAmount", pg, cache, v);
+	    } else if (cache.colorizeAmount) {
+	      if (combine) {
+	        matrix = _colorize(matrix, cache.colorize, cache.colorizeAmount);
+	      } else {
+	        _addColorMatrixFilterCacheTween("colorize", pg, cache, _CMFdefaults);
+
+	        _addColorMatrixFilterCacheTween("colorizeAmount", pg, cache, _CMFdefaults);
+	      }
+	    }
+
+	    if (v.saturation != null) {
+	      matrix = _setSaturation(matrix, +v.saturation);
+
+	      _addColorMatrixFilterCacheTween("saturation", pg, cache, v);
+	    } else if (cache.saturation !== 1) {
+	      if (combine) {
+	        matrix = _setSaturation(matrix, cache.saturation);
+	      } else {
+	        _addColorMatrixFilterCacheTween("saturation", pg, cache, _CMFdefaults);
+	      }
+	    }
+	  }
+
+	  i = matrix.length;
+
+	  while (--i > -1) {
+	    if (matrix[i] !== startMatrix[i]) {
+	      pg.add(startMatrix, i, startMatrix[i], matrix[i], "colorMatrixFilter");
+	    }
+	  }
+
+	  pg._props.push("colorMatrixFilter");
+	},
+	    _renderColor = function _renderColor(ratio, _ref) {
+	  var t = _ref.t,
+	      p = _ref.p,
+	      color = _ref.color,
+	      set = _ref.set;
+	  set(t, p, color[0] << 16 | color[1] << 8 | color[2]);
+	},
+	    _renderDirtyCache = function _renderDirtyCache(ratio, _ref2) {
+	  var g = _ref2.g;
+
+	  if (_isV8Plus) {
+	    g.fill();
+	    g.stroke();
+	  } else if (g) {
+	    g.dirty++;
+	    g.clearDirty++;
+	  }
+	},
+	    _renderAutoAlpha = function _renderAutoAlpha(ratio, data) {
+	  data.t.visible = !!data.t.alpha;
+	},
+	    _addColorTween = function _addColorTween(target, p, value, plugin) {
+	  var currentValue = target[p],
+	      startColor = _splitColor(_isFunction(currentValue) ? target[p.indexOf("set") || !_isFunction(target["get" + p.substr(3)]) ? p : "get" + p.substr(3)]() : currentValue),
+	      endColor = _splitColor(value);
+
+	  plugin._pt = new PropTween(plugin._pt, target, p, 0, 0, _renderColor, {
+	    t: target,
+	    p: p,
+	    color: startColor,
+	    set: _getSetter(target, p)
+	  });
+	  plugin.add(startColor, 0, startColor[0], endColor[0]);
+	  plugin.add(startColor, 1, startColor[1], endColor[1]);
+	  plugin.add(startColor, 2, startColor[2], endColor[2]);
+	},
+	    _colorProps = {
+	  tint: 1,
+	  lineColor: 1,
+	  fillColor: 1,
+	  strokeColor: 1
+	},
+	    _xyContexts = "position,scale,skew,pivot,anchor,tilePosition,tileScale".split(","),
+	    _contexts = {
+	  x: "position",
+	  y: "position",
+	  tileX: "tilePosition",
+	  tileY: "tilePosition"
+	},
+	    _colorMatrixFilterProps = {
+	  colorMatrixFilter: 1,
+	  saturation: 1,
+	  contrast: 1,
+	  hue: 1,
+	  colorize: 1,
+	  colorizeAmount: 1,
+	  brightness: 1,
+	  combineCMF: 1
+	},
+	    _DEG2RAD = Math.PI / 180,
+	    _isString = function _isString(value) {
+	  return typeof value === "string";
+	},
+	    _degreesToRadians = function _degreesToRadians(value) {
+	  return _isString(value) && value.charAt(1) === "=" ? value.substr(0, 2) + parseFloat(value.substr(2)) * _DEG2RAD : value * _DEG2RAD;
+	},
+	    _renderPropWithEnd = function _renderPropWithEnd(ratio, data) {
+	  return data.set(data.t, data.p, ratio === 1 ? data.e : Math.round((data.s + data.c * ratio) * 100000) / 100000, data);
+	},
+	    _addRotationalPropTween = function _addRotationalPropTween(plugin, target, property, startNum, endValue, radians) {
+	  var cap = 360 * (radians ? _DEG2RAD : 1),
+	      isString = _isString(endValue),
+	      relative = isString && endValue.charAt(1) === "=" ? +(endValue.charAt(0) + "1") : 0,
+	      endNum = parseFloat(relative ? endValue.substr(2) : endValue) * (radians ? _DEG2RAD : 1),
+	      change = relative ? endNum * relative : endNum - startNum,
+	      finalValue = startNum + change,
+	      direction,
+	      pt;
+
+	  if (isString) {
+	    direction = endValue.split("_")[1];
+
+	    if (direction === "short") {
+	      change %= cap;
+
+	      if (change !== change % (cap / 2)) {
+	        change += change < 0 ? cap : -cap;
+	      }
+	    }
+
+	    if (direction === "cw" && change < 0) {
+	      change = (change + cap * 1e10) % cap - ~~(change / cap) * cap;
+	    } else if (direction === "ccw" && change > 0) {
+	      change = (change - cap * 1e10) % cap - ~~(change / cap) * cap;
+	    }
+	  }
+
+	  plugin._pt = pt = new PropTween(plugin._pt, target, property, startNum, change, _renderPropWithEnd);
+	  pt.e = finalValue;
+	  return pt;
+	},
+	    _initCore = function _initCore() {
+	  if (!_coreInitted) {
+	    gsap = _getGSAP();
+	    _PIXI = _coreInitted = _PIXI || _windowExists() && window.PIXI;
+	    var version = _PIXI && _PIXI.VERSION && parseFloat(_PIXI.VERSION.split(".")[0]) || 0;
+	    _isV4 = version === 4;
+	    _isV8Plus = version >= 8;
+
+	    _splitColor = function _splitColor(color) {
+	      return gsap.utils.splitColor((color + "").substr(0, 2) === "0x" ? "#" + color.substr(2) : color);
+	    };
+	  }
+	},
+	    i,
+	    p;
+
+	for (i = 0; i < _xyContexts.length; i++) {
+	  p = _xyContexts[i];
+	  _contexts[p + "X"] = p;
+	  _contexts[p + "Y"] = p;
+	}
+
+	var PixiPlugin = {
+	  version: "3.13.0",
+	  name: "pixi",
+	  register: function register(core, Plugin, propTween) {
+	    gsap = core;
+	    PropTween = propTween;
+	    _getSetter = Plugin.getSetter;
+
+	    _initCore();
+	  },
+	  headless: true,
+	  registerPIXI: function registerPIXI(pixi) {
+	    _PIXI = pixi;
+	  },
+	  init: function init(target, values, tween, index, targets) {
+	    _PIXI || _initCore();
+
+	    if (!_PIXI) {
+	      _warn("PIXI was not found. PixiPlugin.registerPIXI(PIXI);");
+
+	      return false;
+	    }
+
+	    var context, axis, value, colorMatrix, filter, p, padding, i, data, subProp;
+
+	    for (p in values) {
+	      context = _contexts[p];
+	      value = values[p];
+
+	      if (context) {
+	        axis = ~p.charAt(p.length - 1).toLowerCase().indexOf("x") ? "x" : "y";
+	        this.add(target[context], axis, target[context][axis], context === "skew" ? _degreesToRadians(value) : value, 0, 0, 0, 0, 0, 1);
+	      } else if (p === "scale" || p === "anchor" || p === "pivot" || p === "tileScale") {
+	        this.add(target[p], "x", target[p].x, value);
+	        this.add(target[p], "y", target[p].y, value);
+	      } else if (p === "rotation" || p === "angle") {
+	        _addRotationalPropTween(this, target, p, target[p], value, p === "rotation");
+	      } else if (_colorMatrixFilterProps[p]) {
+	        if (!colorMatrix) {
+	          _parseColorMatrixFilter(target, values.colorMatrixFilter || values, this);
+
+	          colorMatrix = true;
+	        }
+	      } else if (p === "blur" || p === "blurX" || p === "blurY" || p === "blurPadding") {
+	        filter = _getFilter(target, "BlurFilter");
+	        this.add(filter, p, filter[p], value);
+
+	        if (values.blurPadding !== 0) {
+	          padding = values.blurPadding || Math.max(filter[p], value) * 2;
+	          i = target.filters.length;
+
+	          while (--i > -1) {
+	            target.filters[i].padding = Math.max(target.filters[i].padding, padding);
+	          }
+	        }
+	      } else if (_colorProps[p]) {
+	        if ((p === "lineColor" || p === "fillColor" || p === "strokeColor") && target instanceof _PIXI.Graphics) {
+	          data = "fillStyle" in target ? [target] : (target.geometry || target).graphicsData;
+	          subProp = p.substr(0, p.length - 5);
+	          _isV8Plus && subProp === "line" && (subProp = "stroke");
+	          this._pt = new PropTween(this._pt, target, p, 0, 0, _renderDirtyCache, {
+	            g: target.geometry || target
+	          });
+	          i = data.length;
+
+	          while (--i > -1) {
+	            _addColorTween(_isV4 ? data[i] : data[i][subProp + "Style"], _isV4 ? p : "color", value, this);
+	          }
+	        } else {
+	          _addColorTween(target, p, value, this);
+	        }
+	      } else if (p === "autoAlpha") {
+	        this._pt = new PropTween(this._pt, target, "visible", 0, 0, _renderAutoAlpha);
+	        this.add(target, "alpha", target.alpha, value);
+
+	        this._props.push("alpha", "visible");
+	      } else if (p !== "resolution") {
+	        this.add(target, p, "get", value);
+	      }
+
+	      this._props.push(p);
+	    }
+	  }
+	};
+	_getGSAP() && gsap.registerPlugin(PixiPlugin);
+
+	exports.PixiPlugin = PixiPlugin;
+	exports.default = PixiPlugin;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

network-visualization/node_modules/gsap/dist/ScrollSmoother.js

@@ -0,0 +1,972 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = global || self, factory(global.window = global.window || {}));
+}(this, (function (exports) { 'use strict';
+
+  function _defineProperties(target, props) {
+    for (var i = 0; i < props.length; i++) {
+      var descriptor = props[i];
+      descriptor.enumerable = descriptor.enumerable || false;
+      descriptor.configurable = true;
+      if ("value" in descriptor) descriptor.writable = true;
+      Object.defineProperty(target, descriptor.key, descriptor);
+    }
+  }
+
+  function _createClass(Constructor, protoProps, staticProps) {
+    if (protoProps) _defineProperties(Constructor.prototype, protoProps);
+    if (staticProps) _defineProperties(Constructor, staticProps);
+    return Constructor;
+  }
+
+  /*!
+   * ScrollSmoother 3.13.0
+   * https://gsap.com
+   *
+   * @license Copyright 2008-2025, GreenSock. All rights reserved.
+   * Subject to the terms at https://gsap.com/standard-license
+   * @author: Jack Doyle, jack@greensock.com
+  */
+  var gsap,
+      _coreInitted,
+      _win,
+      _doc,
+      _docEl,
+      _body,
+      _toArray,
+      _clamp,
+      ScrollTrigger,
+      _mainInstance,
+      _expo,
+      _getVelocityProp,
+      _inputObserver,
+      _context,
+      _onResizeDelayedCall,
+      _windowExists = function _windowExists() {
+    return typeof window !== "undefined";
+  },
+      _getGSAP = function _getGSAP() {
+    return gsap || _windowExists() && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+  },
+      _round = function _round(value) {
+    return Math.round(value * 100000) / 100000 || 0;
+  },
+      _maxScroll = function _maxScroll(scroller) {
+    return ScrollTrigger.maxScroll(scroller || _win);
+  },
+      _autoDistance = function _autoDistance(el, progress) {
+    var parent = el.parentNode || _docEl,
+        b1 = el.getBoundingClientRect(),
+        b2 = parent.getBoundingClientRect(),
+        gapTop = b2.top - b1.top,
+        gapBottom = b2.bottom - b1.bottom,
+        change = (Math.abs(gapTop) > Math.abs(gapBottom) ? gapTop : gapBottom) / (1 - progress),
+        offset = -change * progress,
+        ratio,
+        extraChange;
+
+    if (change > 0) {
+      ratio = b2.height / (_win.innerHeight + b2.height);
+      extraChange = ratio === 0.5 ? b2.height * 2 : Math.min(b2.height, Math.abs(-change * ratio / (2 * ratio - 1))) * 2 * (progress || 1);
+      offset += progress ? -extraChange * progress : -extraChange / 2;
+      change += extraChange;
+    }
+
+    return {
+      change: change,
+      offset: offset
+    };
+  },
+      _wrap = function _wrap(el) {
+    var wrapper = _doc.querySelector(".ScrollSmoother-wrapper");
+
+    if (!wrapper) {
+      wrapper = _doc.createElement("div");
+      wrapper.classList.add("ScrollSmoother-wrapper");
+      el.parentNode.insertBefore(wrapper, el);
+      wrapper.appendChild(el);
+    }
+
+    return wrapper;
+  };
+
+  var ScrollSmoother = function () {
+    function ScrollSmoother(vars) {
+      var _this = this;
+
+      _coreInitted || ScrollSmoother.register(gsap) || console.warn("Please gsap.registerPlugin(ScrollSmoother)");
+      vars = this.vars = vars || {};
+      _mainInstance && _mainInstance.kill();
+      _mainInstance = this;
+
+      _context(this);
+
+      var _vars = vars,
+          smoothTouch = _vars.smoothTouch,
+          _onUpdate = _vars.onUpdate,
+          onStop = _vars.onStop,
+          smooth = _vars.smooth,
+          onFocusIn = _vars.onFocusIn,
+          normalizeScroll = _vars.normalizeScroll,
+          wholePixels = _vars.wholePixels,
+          content,
+          wrapper,
+          height,
+          mainST,
+          effects,
+          sections,
+          intervalID,
+          wrapperCSS,
+          contentCSS,
+          paused,
+          pausedNormalizer,
+          recordedRefreshScroll,
+          recordedRefreshScrub,
+          allowUpdates,
+          self = this,
+          effectsPrefix = vars.effectsPrefix || "",
+          scrollFunc = ScrollTrigger.getScrollFunc(_win),
+          smoothDuration = ScrollTrigger.isTouch === 1 ? smoothTouch === true ? 0.8 : parseFloat(smoothTouch) || 0 : smooth === 0 || smooth === false ? 0 : parseFloat(smooth) || 0.8,
+          speed = smoothDuration && +vars.speed || 1,
+          currentY = 0,
+          delta = 0,
+          startupPhase = 1,
+          tracker = _getVelocityProp(0),
+          updateVelocity = function updateVelocity() {
+        return tracker.update(-currentY);
+      },
+          scroll = {
+        y: 0
+      },
+          removeScroll = function removeScroll() {
+        return content.style.overflow = "visible";
+      },
+          isProxyScrolling,
+          killScrub = function killScrub(trigger) {
+        trigger.update();
+        var scrub = trigger.getTween();
+
+        if (scrub) {
+          scrub.pause();
+          scrub._time = scrub._dur;
+          scrub._tTime = scrub._tDur;
+        }
+
+        isProxyScrolling = false;
+        trigger.animation.progress(trigger.progress, true);
+      },
+          render = function render(y, force) {
+        if (y !== currentY && !paused || force) {
+          wholePixels && (y = Math.round(y));
+
+          if (smoothDuration) {
+            content.style.transform = "matrix3d(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, " + y + ", 0, 1)";
+            content._gsap.y = y + "px";
+          }
+
+          delta = y - currentY;
+          currentY = y;
+          ScrollTrigger.isUpdating || ScrollSmoother.isRefreshing || ScrollTrigger.update();
+        }
+      },
+          scrollTop = function scrollTop(value) {
+        if (arguments.length) {
+          value < 0 && (value = 0);
+          scroll.y = -value;
+          isProxyScrolling = true;
+          paused ? currentY = -value : render(-value);
+          ScrollTrigger.isRefreshing ? mainST.update() : scrollFunc(value / speed);
+          return this;
+        }
+
+        return -currentY;
+      },
+          resizeObserver = typeof ResizeObserver !== "undefined" && vars.autoResize !== false && new ResizeObserver(function () {
+        if (!ScrollTrigger.isRefreshing) {
+          var max = _maxScroll(wrapper) * speed;
+          max < -currentY && scrollTop(max);
+
+          _onResizeDelayedCall.restart(true);
+        }
+      }),
+          lastFocusElement,
+          _onFocusIn = function _onFocusIn(e) {
+        wrapper.scrollTop = 0;
+
+        if (e.target.contains && e.target.contains(wrapper) || onFocusIn && onFocusIn(_this, e) === false) {
+          return;
+        }
+
+        ScrollTrigger.isInViewport(e.target) || e.target === lastFocusElement || _this.scrollTo(e.target, false, "center center");
+        lastFocusElement = e.target;
+      },
+          _transformPosition = function _transformPosition(position, st) {
+        if (position < st.start) {
+          return position;
+        }
+
+        var ratio = isNaN(st.ratio) ? 1 : st.ratio,
+            change = st.end - st.start,
+            distance = position - st.start,
+            offset = st.offset || 0,
+            pins = st.pins || [],
+            pinOffset = pins.offset || 0,
+            progressOffset = st._startClamp && st.start <= 0 || st.pins && st.pins.offset ? 0 : st._endClamp && st.end === _maxScroll() ? 1 : 0.5;
+        pins.forEach(function (p) {
+          change -= p.distance;
+
+          if (p.nativeStart <= position) {
+            distance -= p.distance;
+          }
+        });
+
+        if (pinOffset) {
+          distance *= (change - pinOffset / ratio) / change;
+        }
+
+        return position + (distance - offset * progressOffset) / ratio - distance;
+      },
+          adjustEffectRelatedTriggers = function adjustEffectRelatedTriggers(st, triggers, partial) {
+        partial || (st.pins.length = st.pins.offset = 0);
+        var pins = st.pins,
+            markers = st.markers,
+            dif,
+            isClamped,
+            start,
+            end,
+            nativeStart,
+            nativeEnd,
+            i,
+            trig;
+
+        for (i = 0; i < triggers.length; i++) {
+          trig = triggers[i];
+
+          if (st.trigger && trig.trigger && st !== trig && (trig.trigger === st.trigger || trig.pinnedContainer === st.trigger || st.trigger.contains(trig.trigger))) {
+            nativeStart = trig._startNative || trig._startClamp || trig.start;
+            nativeEnd = trig._endNative || trig._endClamp || trig.end;
+            start = _transformPosition(nativeStart, st);
+            end = trig.pin && nativeEnd > 0 ? start + (nativeEnd - nativeStart) : _transformPosition(nativeEnd, st);
+            trig.setPositions(start, end, true, (trig._startClamp ? Math.max(0, start) : start) - nativeStart);
+            trig.markerStart && markers.push(gsap.quickSetter([trig.markerStart, trig.markerEnd], "y", "px"));
+
+            if (trig.pin && trig.end > 0 && !partial) {
+              dif = trig.end - trig.start;
+              isClamped = st._startClamp && trig.start < 0;
+
+              if (isClamped) {
+                if (st.start > 0) {
+                  st.setPositions(0, st.end + (st._startNative - st.start), true);
+                  adjustEffectRelatedTriggers(st, triggers);
+                  return;
+                }
+
+                dif += trig.start;
+                pins.offset = -trig.start;
+              }
+
+              pins.push({
+                start: trig.start,
+                nativeStart: nativeStart,
+                end: trig.end,
+                distance: dif,
+                trig: trig
+              });
+              st.setPositions(st.start, st.end + (isClamped ? -trig.start : dif), true);
+            }
+          }
+        }
+      },
+          adjustParallaxPosition = function adjustParallaxPosition(triggers, createdAfterEffectWasApplied) {
+        effects.forEach(function (st) {
+          return adjustEffectRelatedTriggers(st, triggers, createdAfterEffectWasApplied);
+        });
+      },
+          onRefresh = function onRefresh() {
+        _docEl = _doc.documentElement;
+        _body = _doc.body;
+        removeScroll();
+        requestAnimationFrame(removeScroll);
+
+        if (effects) {
+          ScrollTrigger.getAll().forEach(function (st) {
+            st._startNative = st.start;
+            st._endNative = st.end;
+          });
+          effects.forEach(function (st) {
+            var start = st._startClamp || st.start,
+                end = st.autoSpeed ? Math.min(_maxScroll(), st.end) : start + Math.abs((st.end - start) / st.ratio),
+                offset = end - st.end;
+            start -= offset / 2;
+            end -= offset / 2;
+
+            if (start > end) {
+              var s = start;
+              start = end;
+              end = s;
+            }
+
+            if (st._startClamp && start < 0) {
+              end = st.ratio < 0 ? _maxScroll() : st.end / st.ratio;
+              offset = end - st.end;
+              start = 0;
+            } else if (st.ratio < 0 || st._endClamp && end >= _maxScroll()) {
+              end = _maxScroll();
+              start = st.ratio < 0 ? 0 : st.ratio > 1 ? 0 : end - (end - st.start) / st.ratio;
+              offset = (end - start) * st.ratio - (st.end - st.start);
+            }
+
+            st.offset = offset || 0.0001;
+            st.pins.length = st.pins.offset = 0;
+            st.setPositions(start, end, true);
+          });
+          adjustParallaxPosition(ScrollTrigger.sort());
+        }
+
+        tracker.reset();
+      },
+          addOnRefresh = function addOnRefresh() {
+        return ScrollTrigger.addEventListener("refresh", onRefresh);
+      },
+          restoreEffects = function restoreEffects() {
+        return effects && effects.forEach(function (st) {
+          return st.vars.onRefresh(st);
+        });
+      },
+          revertEffects = function revertEffects() {
+        effects && effects.forEach(function (st) {
+          return st.vars.onRefreshInit(st);
+        });
+        return restoreEffects;
+      },
+          effectValueGetter = function effectValueGetter(name, value, index, el) {
+        return function () {
+          var v = typeof value === "function" ? value(index, el) : value;
+          v || v === 0 || (v = el.getAttribute("data-" + effectsPrefix + name) || (name === "speed" ? 1 : 0));
+          el.setAttribute("data-" + effectsPrefix + name, v);
+          var clamp = (v + "").substr(0, 6) === "clamp(";
+          return {
+            clamp: clamp,
+            value: clamp ? v.substr(6, v.length - 7) : v
+          };
+        };
+      },
+          createEffect = function createEffect(el, speed, lag, index, effectsPadding) {
+        effectsPadding = (typeof effectsPadding === "function" ? effectsPadding(index, el) : effectsPadding) || 0;
+
+        var getSpeed = effectValueGetter("speed", speed, index, el),
+            getLag = effectValueGetter("lag", lag, index, el),
+            startY = gsap.getProperty(el, "y"),
+            cache = el._gsap,
+            ratio,
+            st,
+            autoSpeed,
+            scrub,
+            progressOffset,
+            yOffset,
+            pins = [],
+            initDynamicValues = function initDynamicValues() {
+          speed = getSpeed();
+          lag = parseFloat(getLag().value);
+          ratio = parseFloat(speed.value) || 1;
+          autoSpeed = speed.value === "auto";
+          progressOffset = autoSpeed || st && st._startClamp && st.start <= 0 || pins.offset ? 0 : st && st._endClamp && st.end === _maxScroll() ? 1 : 0.5;
+          scrub && scrub.kill();
+          scrub = lag && gsap.to(el, {
+            ease: _expo,
+            overwrite: false,
+            y: "+=0",
+            duration: lag
+          });
+
+          if (st) {
+            st.ratio = ratio;
+            st.autoSpeed = autoSpeed;
+          }
+        },
+            revert = function revert() {
+          cache.y = startY + "px";
+          cache.renderTransform(1);
+          initDynamicValues();
+        },
+            markers = [],
+            change = 0,
+            updateChange = function updateChange(self) {
+          if (autoSpeed) {
+            revert();
+
+            var auto = _autoDistance(el, _clamp(0, 1, -self.start / (self.end - self.start)));
+
+            change = auto.change;
+            yOffset = auto.offset;
+          } else {
+            yOffset = pins.offset || 0;
+            change = (self.end - self.start - yOffset) * (1 - ratio);
+          }
+
+          pins.forEach(function (p) {
+            return change -= p.distance * (1 - ratio);
+          });
+          self.offset = change || 0.001;
+          self.vars.onUpdate(self);
+          scrub && scrub.progress(1);
+        };
+
+        initDynamicValues();
+
+        if (ratio !== 1 || autoSpeed || scrub) {
+          st = ScrollTrigger.create({
+            trigger: autoSpeed ? el.parentNode : el,
+            start: function start() {
+              return speed.clamp ? "clamp(top bottom+=" + effectsPadding + ")" : "top bottom+=" + effectsPadding;
+            },
+            end: function end() {
+              return speed.value < 0 ? "max" : speed.clamp ? "clamp(bottom top-=" + effectsPadding + ")" : "bottom top-=" + effectsPadding;
+            },
+            scroller: wrapper,
+            scrub: true,
+            refreshPriority: -999,
+            onRefreshInit: revert,
+            onRefresh: updateChange,
+            onKill: function onKill(self) {
+              var i = effects.indexOf(self);
+              i >= 0 && effects.splice(i, 1);
+              revert();
+            },
+            onUpdate: function onUpdate(self) {
+              var y = startY + change * (self.progress - progressOffset),
+                  i = pins.length,
+                  extraY = 0,
+                  pin,
+                  scrollY,
+                  end;
+
+              if (self.offset) {
+                if (i) {
+                  scrollY = -currentY;
+                  end = self.end;
+
+                  while (i--) {
+                    pin = pins[i];
+
+                    if (pin.trig.isActive || scrollY >= pin.start && scrollY <= pin.end) {
+                      if (scrub) {
+                        pin.trig.progress += pin.trig.direction < 0 ? 0.001 : -0.001;
+                        pin.trig.update(0, 0, 1);
+                        scrub.resetTo("y", parseFloat(cache.y), -delta, true);
+                        startupPhase && scrub.progress(1);
+                      }
+
+                      return;
+                    }
+
+                    scrollY > pin.end && (extraY += pin.distance);
+                    end -= pin.distance;
+                  }
+
+                  y = startY + extraY + change * ((gsap.utils.clamp(self.start, self.end, scrollY) - self.start - extraY) / (end - self.start) - progressOffset);
+                }
+
+                markers.length && !autoSpeed && markers.forEach(function (setter) {
+                  return setter(y - extraY);
+                });
+                y = _round(y + yOffset);
+
+                if (scrub) {
+                  scrub.resetTo("y", y, -delta, true);
+                  startupPhase && scrub.progress(1);
+                } else {
+                  cache.y = y + "px";
+                  cache.renderTransform(1);
+                }
+              }
+            }
+          });
+          updateChange(st);
+          gsap.core.getCache(st.trigger).stRevert = revertEffects;
+          st.startY = startY;
+          st.pins = pins;
+          st.markers = markers;
+          st.ratio = ratio;
+          st.autoSpeed = autoSpeed;
+          el.style.willChange = "transform";
+        }
+
+        return st;
+      };
+
+      addOnRefresh();
+      ScrollTrigger.addEventListener("killAll", addOnRefresh);
+      gsap.delayedCall(0.5, function () {
+        return startupPhase = 0;
+      });
+      this.scrollTop = scrollTop;
+
+      this.scrollTo = function (target, smooth, position) {
+        var p = gsap.utils.clamp(0, _maxScroll(), isNaN(target) ? _this.offset(target, position, !!smooth && !paused) : +target);
+        !smooth ? scrollTop(p) : paused ? gsap.to(_this, {
+          duration: smoothDuration,
+          scrollTop: p,
+          overwrite: "auto",
+          ease: _expo
+        }) : scrollFunc(p);
+      };
+
+      this.offset = function (target, position, ignoreSpeed) {
+        target = _toArray(target)[0];
+        var cssText = target.style.cssText,
+            st = ScrollTrigger.create({
+          trigger: target,
+          start: position || "top top"
+        }),
+            y;
+
+        if (effects) {
+          startupPhase ? ScrollTrigger.refresh() : adjustParallaxPosition([st], true);
+        }
+
+        y = st.start / (ignoreSpeed ? speed : 1);
+        st.kill(false);
+        target.style.cssText = cssText;
+        gsap.core.getCache(target).uncache = 1;
+        return y;
+      };
+
+      function refreshHeight() {
+        height = content.clientHeight;
+        content.style.overflow = "visible";
+        _body.style.height = _win.innerHeight + (height - _win.innerHeight) / speed + "px";
+        return height - _win.innerHeight;
+      }
+
+      this.content = function (element) {
+        if (arguments.length) {
+          var newContent = _toArray(element || "#smooth-content")[0] || console.warn("ScrollSmoother needs a valid content element.") || _body.children[0];
+
+          if (newContent !== content) {
+            content = newContent;
+            contentCSS = content.getAttribute("style") || "";
+            resizeObserver && resizeObserver.observe(content);
+            gsap.set(content, {
+              overflow: "visible",
+              width: "100%",
+              boxSizing: "border-box",
+              y: "+=0"
+            });
+            smoothDuration || gsap.set(content, {
+              clearProps: "transform"
+            });
+          }
+
+          return this;
+        }
+
+        return content;
+      };
+
+      this.wrapper = function (element) {
+        if (arguments.length) {
+          wrapper = _toArray(element || "#smooth-wrapper")[0] || _wrap(content);
+          wrapperCSS = wrapper.getAttribute("style") || "";
+          refreshHeight();
+          gsap.set(wrapper, smoothDuration ? {
+            overflow: "hidden",
+            position: "fixed",
+            height: "100%",
+            width: "100%",
+            top: 0,
+            left: 0,
+            right: 0,
+            bottom: 0
+          } : {
+            overflow: "visible",
+            position: "relative",
+            width: "100%",
+            height: "auto",
+            top: "auto",
+            bottom: "auto",
+            left: "auto",
+            right: "auto"
+          });
+          return this;
+        }
+
+        return wrapper;
+      };
+
+      this.effects = function (targets, config) {
+        var _effects;
+
+        effects || (effects = []);
+
+        if (!targets) {
+          return effects.slice(0);
+        }
+
+        targets = _toArray(targets);
+        targets.forEach(function (target) {
+          var i = effects.length;
+
+          while (i--) {
+            effects[i].trigger === target && effects[i].kill();
+          }
+        });
+        config = config || {};
+        var _config = config,
+            speed = _config.speed,
+            lag = _config.lag,
+            effectsPadding = _config.effectsPadding,
+            effectsToAdd = [],
+            i,
+            st;
+
+        for (i = 0; i < targets.length; i++) {
+          st = createEffect(targets[i], speed, lag, i, effectsPadding);
+          st && effectsToAdd.push(st);
+        }
+
+        (_effects = effects).push.apply(_effects, effectsToAdd);
+
+        config.refresh !== false && ScrollTrigger.refresh();
+        return effectsToAdd;
+      };
+
+      this.sections = function (targets, config) {
+        var _sections;
+
+        sections || (sections = []);
+
+        if (!targets) {
+          return sections.slice(0);
+        }
+
+        var newSections = _toArray(targets).map(function (el) {
+          return ScrollTrigger.create({
+            trigger: el,
+            start: "top 120%",
+            end: "bottom -20%",
+            onToggle: function onToggle(self) {
+              el.style.opacity = self.isActive ? "1" : "0";
+              el.style.pointerEvents = self.isActive ? "all" : "none";
+            }
+          });
+        });
+
+        config && config.add ? (_sections = sections).push.apply(_sections, newSections) : sections = newSections.slice(0);
+        return newSections;
+      };
+
+      this.content(vars.content);
+      this.wrapper(vars.wrapper);
+
+      this.render = function (y) {
+        return render(y || y === 0 ? y : currentY);
+      };
+
+      this.getVelocity = function () {
+        return tracker.getVelocity(-currentY);
+      };
+
+      ScrollTrigger.scrollerProxy(wrapper, {
+        scrollTop: scrollTop,
+        scrollHeight: function scrollHeight() {
+          return refreshHeight() && _body.scrollHeight;
+        },
+        fixedMarkers: vars.fixedMarkers !== false && !!smoothDuration,
+        content: content,
+        getBoundingClientRect: function getBoundingClientRect() {
+          return {
+            top: 0,
+            left: 0,
+            width: _win.innerWidth,
+            height: _win.innerHeight
+          };
+        }
+      });
+      ScrollTrigger.defaults({
+        scroller: wrapper
+      });
+      var existingScrollTriggers = ScrollTrigger.getAll().filter(function (st) {
+        return st.scroller === _win || st.scroller === wrapper;
+      });
+      existingScrollTriggers.forEach(function (st) {
+        return st.revert(true, true);
+      });
+      mainST = ScrollTrigger.create({
+        animation: gsap.fromTo(scroll, {
+          y: function y() {
+            allowUpdates = 0;
+            return 0;
+          }
+        }, {
+          y: function y() {
+            allowUpdates = 1;
+            return -refreshHeight();
+          },
+          immediateRender: false,
+          ease: "none",
+          data: "ScrollSmoother",
+          duration: 100,
+          onUpdate: function onUpdate() {
+            if (allowUpdates) {
+              var force = isProxyScrolling;
+
+              if (force) {
+                killScrub(mainST);
+                scroll.y = currentY;
+              }
+
+              render(scroll.y, force);
+              updateVelocity();
+              _onUpdate && !paused && _onUpdate(self);
+            }
+          }
+        }),
+        onRefreshInit: function onRefreshInit(self) {
+          if (ScrollSmoother.isRefreshing) {
+            return;
+          }
+
+          ScrollSmoother.isRefreshing = true;
+
+          if (effects) {
+            var _pins = ScrollTrigger.getAll().filter(function (st) {
+              return !!st.pin;
+            });
+
+            effects.forEach(function (st) {
+              if (!st.vars.pinnedContainer) {
+                _pins.forEach(function (pinST) {
+                  if (pinST.pin.contains(st.trigger)) {
+                    var v = st.vars;
+                    v.pinnedContainer = pinST.pin;
+                    st.vars = null;
+                    st.init(v, st.animation);
+                  }
+                });
+              }
+            });
+          }
+
+          var scrub = self.getTween();
+          recordedRefreshScrub = scrub && scrub._end > scrub._dp._time;
+          recordedRefreshScroll = currentY;
+          scroll.y = 0;
+
+          if (smoothDuration) {
+            ScrollTrigger.isTouch === 1 && (wrapper.style.position = "absolute");
+            wrapper.scrollTop = 0;
+            ScrollTrigger.isTouch === 1 && (wrapper.style.position = "fixed");
+          }
+        },
+        onRefresh: function onRefresh(self) {
+          self.animation.invalidate();
+          self.setPositions(self.start, refreshHeight() / speed);
+          recordedRefreshScrub || killScrub(self);
+          scroll.y = -scrollFunc() * speed;
+          render(scroll.y);
+
+          if (!startupPhase) {
+            recordedRefreshScrub && (isProxyScrolling = false);
+            self.animation.progress(gsap.utils.clamp(0, 1, recordedRefreshScroll / speed / -self.end));
+          }
+
+          if (recordedRefreshScrub) {
+            self.progress -= 0.001;
+            self.update();
+          }
+
+          ScrollSmoother.isRefreshing = false;
+        },
+        id: "ScrollSmoother",
+        scroller: _win,
+        invalidateOnRefresh: true,
+        start: 0,
+        refreshPriority: -9999,
+        end: function end() {
+          return refreshHeight() / speed;
+        },
+        onScrubComplete: function onScrubComplete() {
+          tracker.reset();
+          onStop && onStop(_this);
+        },
+        scrub: smoothDuration || true
+      });
+
+      this.smooth = function (value) {
+        if (arguments.length) {
+          smoothDuration = value || 0;
+          speed = smoothDuration && +vars.speed || 1;
+          mainST.scrubDuration(value);
+        }
+
+        return mainST.getTween() ? mainST.getTween().duration() : 0;
+      };
+
+      mainST.getTween() && (mainST.getTween().vars.ease = vars.ease || _expo);
+      this.scrollTrigger = mainST;
+      vars.effects && this.effects(vars.effects === true ? "[data-" + effectsPrefix + "speed], [data-" + effectsPrefix + "lag]" : vars.effects, {
+        effectsPadding: vars.effectsPadding,
+        refresh: false
+      });
+      vars.sections && this.sections(vars.sections === true ? "[data-section]" : vars.sections);
+      existingScrollTriggers.forEach(function (st) {
+        st.vars.scroller = wrapper;
+        st.revert(false, true);
+        st.init(st.vars, st.animation);
+      });
+
+      this.paused = function (value, allowNestedScroll) {
+        if (arguments.length) {
+          if (!!paused !== value) {
+            if (value) {
+              mainST.getTween() && mainST.getTween().pause();
+              scrollFunc(-currentY / speed);
+              tracker.reset();
+              pausedNormalizer = ScrollTrigger.normalizeScroll();
+              pausedNormalizer && pausedNormalizer.disable();
+              paused = ScrollTrigger.observe({
+                preventDefault: true,
+                type: "wheel,touch,scroll",
+                debounce: false,
+                allowClicks: true,
+                onChangeY: function onChangeY() {
+                  return scrollTop(-currentY);
+                }
+              });
+              paused.nested = _inputObserver(_docEl, "wheel,touch,scroll", true, allowNestedScroll !== false);
+            } else {
+              paused.nested.kill();
+              paused.kill();
+              paused = 0;
+              pausedNormalizer && pausedNormalizer.enable();
+              mainST.progress = (-currentY / speed - mainST.start) / (mainST.end - mainST.start);
+              killScrub(mainST);
+            }
+          }
+
+          return this;
+        }
+
+        return !!paused;
+      };
+
+      this.kill = this.revert = function () {
+        _this.paused(false);
+
+        killScrub(mainST);
+        mainST.kill();
+        var triggers = (effects || []).concat(sections || []),
+            i = triggers.length;
+
+        while (i--) {
+          triggers[i].kill();
+        }
+
+        ScrollTrigger.scrollerProxy(wrapper);
+        ScrollTrigger.removeEventListener("killAll", addOnRefresh);
+        ScrollTrigger.removeEventListener("refresh", onRefresh);
+        wrapper.style.cssText = wrapperCSS;
+        content.style.cssText = contentCSS;
+        var defaults = ScrollTrigger.defaults({});
+        defaults && defaults.scroller === wrapper && ScrollTrigger.defaults({
+          scroller: _win
+        });
+        _this.normalizer && ScrollTrigger.normalizeScroll(false);
+        clearInterval(intervalID);
+        _mainInstance = null;
+        resizeObserver && resizeObserver.disconnect();
+
+        _body.style.removeProperty("height");
+
+        _win.removeEventListener("focusin", _onFocusIn);
+      };
+
+      this.refresh = function (soft, force) {
+        return mainST.refresh(soft, force);
+      };
+
+      if (normalizeScroll) {
+        this.normalizer = ScrollTrigger.normalizeScroll(normalizeScroll === true ? {
+          debounce: true,
+          content: !smoothDuration && content
+        } : normalizeScroll);
+      }
+
+      ScrollTrigger.config(vars);
+      "scrollBehavior" in _win.getComputedStyle(_body) && gsap.set([_body, _docEl], {
+        scrollBehavior: "auto"
+      });
+
+      _win.addEventListener("focusin", _onFocusIn);
+
+      intervalID = setInterval(updateVelocity, 250);
+      _doc.readyState === "loading" || requestAnimationFrame(function () {
+        return ScrollTrigger.refresh();
+      });
+    }
+
+    ScrollSmoother.register = function register(core) {
+      if (!_coreInitted) {
+        gsap = core || _getGSAP();
+
+        if (_windowExists() && window.document) {
+          _win = window;
+          _doc = document;
+          _docEl = _doc.documentElement;
+          _body = _doc.body;
+        }
+
+        if (gsap) {
+          _toArray = gsap.utils.toArray;
+          _clamp = gsap.utils.clamp;
+          _expo = gsap.parseEase("expo");
+
+          _context = gsap.core.context || function () {};
+
+          ScrollTrigger = gsap.core.globals().ScrollTrigger;
+          gsap.core.globals("ScrollSmoother", ScrollSmoother);
+
+          if (_body && ScrollTrigger) {
+            _onResizeDelayedCall = gsap.delayedCall(0.2, function () {
+              return ScrollTrigger.isRefreshing || _mainInstance && _mainInstance.refresh();
+            }).pause();
+            _getVelocityProp = ScrollTrigger.core._getVelocityProp;
+            _inputObserver = ScrollTrigger.core._inputObserver;
+            ScrollSmoother.refresh = ScrollTrigger.refresh;
+            _coreInitted = 1;
+          }
+        }
+      }
+
+      return _coreInitted;
+    };
+
+    _createClass(ScrollSmoother, [{
+      key: "progress",
+      get: function get() {
+        return this.scrollTrigger ? this.scrollTrigger.animation._time / 100 : 0;
+      }
+    }]);
+
+    return ScrollSmoother;
+  }();
+  ScrollSmoother.version = "3.13.0";
+
+  ScrollSmoother.create = function (vars) {
+    return _mainInstance && vars && _mainInstance.content() === _toArray(vars.content)[0] ? _mainInstance : new ScrollSmoother(vars);
+  };
+
+  ScrollSmoother.get = function () {
+    return _mainInstance;
+  };
+
+  _getGSAP() && gsap.registerPlugin(ScrollSmoother);
+
+  exports.ScrollSmoother = ScrollSmoother;
+  exports.default = ScrollSmoother;
+
+  if (typeof(window) === 'undefined' || window !== exports) {Object.defineProperty(exports, '__esModule', { value: true });} else {delete window.default;}
+
+})));

network-visualization/node_modules/gsap/dist/ScrollToPlugin.js

@@ -0,0 +1,285 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = global || self, factory(global.window = global.window || {}));
+}(this, (function (exports) { 'use strict';
+
+	/*!
+	 * ScrollToPlugin 3.13.0
+	 * https://gsap.com
+	 *
+	 * @license Copyright 2008-2025, GreenSock. All rights reserved.
+	 * Subject to the terms at https://gsap.com/standard-license
+	 * @author: Jack Doyle, jack@greensock.com
+	*/
+	var gsap,
+	    _coreInitted,
+	    _window,
+	    _docEl,
+	    _body,
+	    _toArray,
+	    _config,
+	    ScrollTrigger,
+	    _windowExists = function _windowExists() {
+	  return typeof window !== "undefined";
+	},
+	    _getGSAP = function _getGSAP() {
+	  return gsap || _windowExists() && (gsap = window.gsap) && gsap.registerPlugin && gsap;
+	},
+	    _isString = function _isString(value) {
+	  return typeof value === "string";
+	},
+	    _isFunction = function _isFunction(value) {
+	  return typeof value === "function";
+	},
+	    _max = function _max(element, axis) {
+	  var dim = axis === "x" ? "Width" : "Height",
+	      scroll = "scroll" + dim,
+	      client = "client" + dim;
+	  return element === _window || element === _docEl || element === _body ? Math.max(_docEl[scroll], _body[scroll]) - (_window["inner" + dim] || _docEl[client] || _body[client]) : element[scroll] - element["offset" + dim];
+	},
+	    _buildGetter = function _buildGetter(e, axis) {
+	  var p = "scroll" + (axis === "x" ? "Left" : "Top");
+
+	  if (e === _window) {
+	    if (e.pageXOffset != null) {
+	      p = "page" + axis.toUpperCase() + "Offset";
+	    } else {
+	      e = _docEl[p] != null ? _docEl : _body;
+	    }
+	  }
+
+	  return function () {
+	    return e[p];
+	  };
+	},
+	    _clean = function _clean(value, index, target, targets) {
+	  _isFunction(value) && (value = value(index, target, targets));
+
+	  if (typeof value !== "object") {
+	    return _isString(value) && value !== "max" && value.charAt(1) !== "=" ? {
+	      x: value,
+	      y: value
+	    } : {
+	      y: value
+	    };
+	  } else if (value.nodeType) {
+	    return {
+	      y: value,
+	      x: value
+	    };
+	  } else {
+	    var result = {},
+	        p;
+
+	    for (p in value) {
+	      result[p] = p !== "onAutoKill" && _isFunction(value[p]) ? value[p](index, target, targets) : value[p];
+	    }
+
+	    return result;
+	  }
+	},
+	    _getOffset = function _getOffset(element, container) {
+	  element = _toArray(element)[0];
+
+	  if (!element || !element.getBoundingClientRect) {
+	    return console.warn("scrollTo target doesn't exist. Using 0") || {
+	      x: 0,
+	      y: 0
+	    };
+	  }
+
+	  var rect = element.getBoundingClientRect(),
+	      isRoot = !container || container === _window || container === _body,
+	      cRect = isRoot ? {
+	    top: _docEl.clientTop - (_window.pageYOffset || _docEl.scrollTop || _body.scrollTop || 0),
+	    left: _docEl.clientLeft - (_window.pageXOffset || _docEl.scrollLeft || _body.scrollLeft || 0)
+	  } : container.getBoundingClientRect(),
+	      offsets = {
+	    x: rect.left - cRect.left,
+	    y: rect.top - cRect.top
+	  };
+
+	  if (!isRoot && container) {
+	    offsets.x += _buildGetter(container, "x")();
+	    offsets.y += _buildGetter(container, "y")();
+	  }
+
+	  return offsets;
+	},
+	    _parseVal = function _parseVal(value, target, axis, currentVal, offset) {
+	  return !isNaN(value) && typeof value !== "object" ? parseFloat(value) - offset : _isString(value) && value.charAt(1) === "=" ? parseFloat(value.substr(2)) * (value.charAt(0) === "-" ? -1 : 1) + currentVal - offset : value === "max" ? _max(target, axis) - offset : Math.min(_max(target, axis), _getOffset(value, target)[axis] - offset);
+	},
+	    _initCore = function _initCore() {
+	  gsap = _getGSAP();
+
+	  if (_windowExists() && gsap && typeof document !== "undefined" && document.body) {
+	    _window = window;
+	    _body = document.body;
+	    _docEl = document.documentElement;
+	    _toArray = gsap.utils.toArray;
+	    gsap.config({
+	      autoKillThreshold: 7
+	    });
+	    _config = gsap.config();
+	    _coreInitted = 1;
+	  }
+	};
+
+	var ScrollToPlugin = {
+	  version: "3.13.0",
+	  name: "scrollTo",
+	  rawVars: 1,
+	  register: function register(core) {
+	    gsap = core;
+
+	    _initCore();
+	  },
+	  init: function init(target, value, tween, index, targets) {
+	    _coreInitted || _initCore();
+	    var data = this,
+	        snapType = gsap.getProperty(target, "scrollSnapType");
+	    data.isWin = target === _window;
+	    data.target = target;
+	    data.tween = tween;
+	    value = _clean(value, index, target, targets);
+	    data.vars = value;
+	    data.autoKill = !!("autoKill" in value ? value : _config).autoKill;
+	    data.getX = _buildGetter(target, "x");
+	    data.getY = _buildGetter(target, "y");
+	    data.x = data.xPrev = data.getX();
+	    data.y = data.yPrev = data.getY();
+	    ScrollTrigger || (ScrollTrigger = gsap.core.globals().ScrollTrigger);
+	    gsap.getProperty(target, "scrollBehavior") === "smooth" && gsap.set(target, {
+	      scrollBehavior: "auto"
+	    });
+
+	    if (snapType && snapType !== "none") {
+	      data.snap = 1;
+	      data.snapInline = target.style.scrollSnapType;
+	      target.style.scrollSnapType = "none";
+	    }
+
+	    if (value.x != null) {
+	      data.add(data, "x", data.x, _parseVal(value.x, target, "x", data.x, value.offsetX || 0), index, targets);
+
+	      data._props.push("scrollTo_x");
+	    } else {
+	      data.skipX = 1;
+	    }
+
+	    if (value.y != null) {
+	      data.add(data, "y", data.y, _parseVal(value.y, target, "y", data.y, value.offsetY || 0), index, targets);
+
+	      data._props.push("scrollTo_y");
+	    } else {
+	      data.skipY = 1;
+	    }
+	  },
+	  render: function render(ratio, data) {
+	    var pt = data._pt,
+	        target = data.target,
+	        tween = data.tween,
+	        autoKill = data.autoKill,
+	        xPrev = data.xPrev,
+	        yPrev = data.yPrev,
+	        isWin = data.isWin,
+	        snap = data.snap,
+	        snapInline = data.snapInline,
+	        x,
+	        y,
+	        yDif,
+	        xDif,
+	        threshold;
+
+	    while (pt) {
+	      pt.r(ratio, pt.d);
+	      pt = pt._next;
+	    }
+
+	    x = isWin || !data.skipX ? data.getX() : xPrev;
+	    y = isWin || !data.skipY ? data.getY() : yPrev;
+	    yDif = y - yPrev;
+	    xDif = x - xPrev;
+	    threshold = _config.autoKillThreshold;
+
+	    if (data.x < 0) {
+	      data.x = 0;
+	    }
+
+	    if (data.y < 0) {
+	      data.y = 0;
+	    }
+
+	    if (autoKill) {
+	      if (!data.skipX && (xDif > threshold || xDif < -threshold) && x < _max(target, "x")) {
+	        data.skipX = 1;
+	      }
+
+	      if (!data.skipY && (yDif > threshold || yDif < -threshold) && y < _max(target, "y")) {
+	        data.skipY = 1;
+	      }
+
+	      if (data.skipX && data.skipY) {
+	        tween.kill();
+	        data.vars.onAutoKill && data.vars.onAutoKill.apply(tween, data.vars.onAutoKillParams || []);
+	      }
+	    }
+
+	    if (isWin) {
+	      _window.scrollTo(!data.skipX ? data.x : x, !data.skipY ? data.y : y);
+	    } else {
+	      data.skipY || (target.scrollTop = data.y);
+	      data.skipX || (target.scrollLeft = data.x);
+	    }
+
+	    if (snap && (ratio === 1 || ratio === 0)) {
+	      y = target.scrollTop;
+	      x = target.scrollLeft;
+	      snapInline ? target.style.scrollSnapType = snapInline : target.style.removeProperty("scroll-snap-type");
+	      target.scrollTop = y + 1;
+	      target.scrollLeft = x + 1;
+	      target.scrollTop = y;
+	      target.scrollLeft = x;
+	    }
+
+	    data.xPrev = data.x;
+	    data.yPrev = data.y;
+	    ScrollTrigger && ScrollTrigger.update();
+	  },
+	  kill: function kill(property) {
+	    var both = property === "scrollTo",
+	        i = this._props.indexOf(property);
+
+	    if (both || property === "scrollTo_x") {
+	      this.skipX = 1;
+	    }
+
+	    if (both || property === "scrollTo_y") {
+	      this.skipY = 1;
+	    }
+
+	    i > -1 && this._props.splice(i, 1);
+	    return !this._props.length;
+	  }
+	};
+	ScrollToPlugin.max = _max;
+	ScrollToPlugin.getOffset = _getOffset;
+	ScrollToPlugin.buildGetter = _buildGetter;
+
+	ScrollToPlugin.config = function (vars) {
+	  _config || _initCore() || (_config = gsap.config());
+
+	  for (var p in vars) {
+	    _config[p] = vars[p];
+	  }
+	};
+
+	_getGSAP() && gsap.registerPlugin(ScrollToPlugin);
+
+	exports.ScrollToPlugin = ScrollToPlugin;
+	exports.default = ScrollToPlugin;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+})));

network-visualization/node_modules/gsap/dist/ScrollToPlugin.min.js

@@ -0,0 +1,11 @@
+/*!
+ * ScrollToPlugin 3.13.0
+ * https://gsap.com
+ * 
+ * @license Copyright 2025, GreenSock. All rights reserved.
+ * Subject to the terms at https://gsap.com/standard-license.
+ * @author: Jack Doyle, jack@greensock.com
+ */
+
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?t(exports):"function"==typeof define&&define.amd?define(["exports"],t):t((e=e||self).window=e.window||{})}(this,function(e){"use strict";function l(){return"undefined"!=typeof window}function m(){return f||l()&&(f=window.gsap)&&f.registerPlugin&&f}function n(e){return"string"==typeof e}function o(e){return"function"==typeof e}function p(e,t){var o="x"===t?"Width":"Height",n="scroll"+o,r="client"+o;return e===T||e===i||e===c?Math.max(i[n],c[n])-(T["inner"+o]||i[r]||c[r]):e[n]-e["offset"+o]}function q(e,t){var o="scroll"+("x"===t?"Left":"Top");return e===T&&(null!=e.pageXOffset?o="page"+t.toUpperCase()+"Offset":e=null!=i[o]?i:c),function(){return e[o]}}function s(e,t){if(!(e=y(e)[0])||!e.getBoundingClientRect)return console.warn("scrollTo target doesn't exist. Using 0")||{x:0,y:0};var o=e.getBoundingClientRect(),n=!t||t===T||t===c,r=n?{top:i.clientTop-(T.pageYOffset||i.scrollTop||c.scrollTop||0),left:i.clientLeft-(T.pageXOffset||i.scrollLeft||c.scrollLeft||0)}:t.getBoundingClientRect(),l={x:o.left-r.left,y:o.top-r.top};return!n&&t&&(l.x+=q(t,"x")(),l.y+=q(t,"y")()),l}function t(e,t,o,r,l){return isNaN(e)||"object"==typeof e?n(e)&&"="===e.charAt(1)?parseFloat(e.substr(2))*("-"===e.charAt(0)?-1:1)+r-l:"max"===e?p(t,o)-l:Math.min(p(t,o),s(e,t)[o]-l):parseFloat(e)-l}function u(){f=m(),l()&&f&&"undefined"!=typeof document&&document.body&&(T=window,c=document.body,i=document.documentElement,y=f.utils.toArray,f.config({autoKillThreshold:7}),h=f.config(),a=1)}var f,a,T,i,c,y,h,v,r={version:"3.13.0",name:"scrollTo",rawVars:1,register:function register(e){f=e,u()},init:function init(e,r,l,i,s){a||u();var p=this,c=f.getProperty(e,"scrollSnapType");p.isWin=e===T,p.target=e,p.tween=l,r=function _clean(e,t,r,l){if(o(e)&&(e=e(t,r,l)),"object"!=typeof e)return n(e)&&"max"!==e&&"="!==e.charAt(1)?{x:e,y:e}:{y:e};if(e.nodeType)return{y:e,x:e};var i,s={};for(i in e)s[i]="onAutoKill"!==i&&o(e[i])?e[i](t,r,l):e[i];return s}(r,i,e,s),p.vars=r,p.autoKill=!!("autoKill"in r?r:h).autoKill,p.getX=q(e,"x"),p.getY=q(e,"y"),p.x=p.xPrev=p.getX(),p.y=p.yPrev=p.getY(),v=v||f.core.globals().ScrollTrigger,"smooth"===f.getProperty(e,"scrollBehavior")&&f.set(e,{scrollBehavior:"auto"}),c&&"none"!==c&&(p.snap=1,p.snapInline=e.style.scrollSnapType,e.style.scrollSnapType="none"),null!=r.x?(p.add(p,"x",p.x,t(r.x,e,"x",p.x,r.offsetX||0),i,s),p._props.push("scrollTo_x")):p.skipX=1,null!=r.y?(p.add(p,"y",p.y,t(r.y,e,"y",p.y,r.offsetY||0),i,s),p._props.push("scrollTo_y")):p.skipY=1},render:function render(e,t){for(var o,n,r,l,i,s=t._pt,c=t.target,u=t.tween,f=t.autoKill,a=t.xPrev,y=t.yPrev,d=t.isWin,g=t.snap,x=t.snapInline;s;)s.r(e,s.d),s=s._next;o=d||!t.skipX?t.getX():a,r=(n=d||!t.skipY?t.getY():y)-y,l=o-a,i=h.autoKillThreshold,t.x<0&&(t.x=0),t.y<0&&(t.y=0),f&&(!t.skipX&&(i<l||l<-i)&&o<p(c,"x")&&(t.skipX=1),!t.skipY&&(i<r||r<-i)&&n<p(c,"y")&&(t.skipY=1),t.skipX&&t.skipY&&(u.kill(),t.vars.onAutoKill&&t.vars.onAutoKill.apply(u,t.vars.onAutoKillParams||[]))),d?T.scrollTo(t.skipX?o:t.x,t.skipY?n:t.y):(t.skipY||(c.scrollTop=t.y),t.skipX||(c.scrollLeft=t.x)),!g||1!==e&&0!==e||(n=c.scrollTop,o=c.scrollLeft,x?c.style.scrollSnapType=x:c.style.removeProperty("scroll-snap-type"),c.scrollTop=n+1,c.scrollLeft=o+1,c.scrollTop=n,c.scrollLeft=o),t.xPrev=t.x,t.yPrev=t.y,v&&v.update()},kill:function kill(e){var t="scrollTo"===e,o=this._props.indexOf(e);return!t&&"scrollTo_x"!==e||(this.skipX=1),!t&&"scrollTo_y"!==e||(this.skipY=1),-1<o&&this._props.splice(o,1),!this._props.length}};r.max=p,r.getOffset=s,r.buildGetter=q,r.config=function(e){for(var t in h||u()||(h=f.config()),e)h[t]=e[t]},m()&&f.registerPlugin(r),e.ScrollToPlugin=r,e.default=r;if (typeof(window)==="undefined"||window!==e){Object.defineProperty(e,"__esModule",{value:!0})} else {delete e.default}});
+

network-visualization/node_modules/gsap/dist/SplitText.js

@@ -0,0 +1,321 @@
+/*!
+ * SplitText 3.13.0
+ * https://gsap.com
+ *
+ * @license Copyright 2025, GreenSock. All rights reserved. Subject to the terms at https://gsap.com/standard-license.
+ * @author: Jack Doyle
+ */
+
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+	typeof define === 'function' && define.amd ? define(['exports'], factory) :
+	(global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.window = global.window || {}));
+})(this, (function (exports) { 'use strict';
+
+	let gsap, _fonts, _coreInitted, _initIfNecessary = () => _coreInitted || SplitText.register(window.gsap), _charSegmenter = typeof Intl !== "undefined" ? new Intl.Segmenter() : 0, _toArray = (r) => typeof r === "string" ? _toArray(document.querySelectorAll(r)) : "length" in r ? Array.from(r) : [r], _elements = (targets) => _toArray(targets).filter((e) => e instanceof HTMLElement), _emptyArray = [], _context = function() {
+	}, _spacesRegEx = /\s+/g, _emojiSafeRegEx = new RegExp("\\p{RI}\\p{RI}|\\p{Emoji}(\\p{EMod}|\\u{FE0F}\\u{20E3}?|[\\u{E0020}-\\u{E007E}]+\\u{E007F})?(\\u{200D}\\p{Emoji}(\\p{EMod}|\\u{FE0F}\\u{20E3}?|[\\u{E0020}-\\u{E007E}]+\\u{E007F})?)*|.", "gu"), _emptyBounds = { left: 0, top: 0, width: 0, height: 0 }, _stretchToFitSpecialChars = (collection, specialCharsRegEx) => {
+	  if (specialCharsRegEx) {
+	    let charsFound = new Set(collection.join("").match(specialCharsRegEx) || _emptyArray), i = collection.length, slots, word, char, combined;
+	    if (charsFound.size) {
+	      while (--i > -1) {
+	        word = collection[i];
+	        for (char of charsFound) {
+	          if (char.startsWith(word) && char.length > word.length) {
+	            slots = 0;
+	            combined = word;
+	            while (char.startsWith(combined += collection[i + ++slots]) && combined.length < char.length) {
+	            }
+	            if (slots && combined.length === char.length) {
+	              collection[i] = char;
+	              collection.splice(i + 1, slots);
+	              break;
+	            }
+	          }
+	        }
+	      }
+	    }
+	  }
+	  return collection;
+	}, _disallowInline = (element) => window.getComputedStyle(element).display === "inline" && (element.style.display = "inline-block"), _insertNodeBefore = (newChild, parent, existingChild) => parent.insertBefore(typeof newChild === "string" ? document.createTextNode(newChild) : newChild, existingChild), _getWrapper = (type, config, collection) => {
+	  let className = config[type + "sClass"] || "", { tag = "div", aria = "auto", propIndex = false } = config, display = type === "line" ? "block" : "inline-block", incrementClass = className.indexOf("++") > -1, wrapper = (text) => {
+	    let el = document.createElement(tag), i = collection.length + 1;
+	    className && (el.className = className + (incrementClass ? " " + className + i : ""));
+	    propIndex && el.style.setProperty("--" + type, i + "");
+	    aria !== "none" && el.setAttribute("aria-hidden", "true");
+	    if (tag !== "span") {
+	      el.style.position = "relative";
+	      el.style.display = display;
+	    }
+	    el.textContent = text;
+	    collection.push(el);
+	    return el;
+	  };
+	  incrementClass && (className = className.replace("++", ""));
+	  wrapper.collection = collection;
+	  return wrapper;
+	}, _getLineWrapper = (element, nodes, config, collection) => {
+	  let lineWrapper = _getWrapper("line", config, collection), textAlign = window.getComputedStyle(element).textAlign || "left";
+	  return (startIndex, endIndex) => {
+	    let newLine = lineWrapper("");
+	    newLine.style.textAlign = textAlign;
+	    element.insertBefore(newLine, nodes[startIndex]);
+	    for (; startIndex < endIndex; startIndex++) {
+	      newLine.appendChild(nodes[startIndex]);
+	    }
+	    newLine.normalize();
+	  };
+	}, _splitWordsAndCharsRecursively = (element, config, wordWrapper, charWrapper, prepForCharsOnly, deepSlice, ignore, charSplitRegEx, specialCharsRegEx, isNested) => {
+	  var _a;
+	  let nodes = Array.from(element.childNodes), i = 0, { wordDelimiter, reduceWhiteSpace = true, prepareText } = config, elementBounds = element.getBoundingClientRect(), lastBounds = elementBounds, isPreformatted = !reduceWhiteSpace && window.getComputedStyle(element).whiteSpace.substring(0, 3) === "pre", ignoredPreviousSibling = 0, wordsCollection = wordWrapper.collection, wordDelimIsNotSpace, wordDelimString, wordDelimSplitter, curNode, words, curWordEl, startsWithSpace, endsWithSpace, j, bounds, curWordChars, clonedNode, curSubNode, tempSubNode, curTextContent, wordText, lastWordText, k;
+	  if (typeof wordDelimiter === "object") {
+	    wordDelimSplitter = wordDelimiter.delimiter || wordDelimiter;
+	    wordDelimString = wordDelimiter.replaceWith || "";
+	  } else {
+	    wordDelimString = wordDelimiter === "" ? "" : wordDelimiter || " ";
+	  }
+	  wordDelimIsNotSpace = wordDelimString !== " ";
+	  for (; i < nodes.length; i++) {
+	    curNode = nodes[i];
+	    if (curNode.nodeType === 3) {
+	      curTextContent = curNode.textContent || "";
+	      if (reduceWhiteSpace) {
+	        curTextContent = curTextContent.replace(_spacesRegEx, " ");
+	      } else if (isPreformatted) {
+	        curTextContent = curTextContent.replace(/\n/g, wordDelimString + "\n");
+	      }
+	      prepareText && (curTextContent = prepareText(curTextContent, element));
+	      curNode.textContent = curTextContent;
+	      words = wordDelimString || wordDelimSplitter ? curTextContent.split(wordDelimSplitter || wordDelimString) : curTextContent.match(charSplitRegEx) || _emptyArray;
+	      lastWordText = words[words.length - 1];
+	      endsWithSpace = wordDelimIsNotSpace ? lastWordText.slice(-1) === " " : !lastWordText;
+	      lastWordText || words.pop();
+	      lastBounds = elementBounds;
+	      startsWithSpace = wordDelimIsNotSpace ? words[0].charAt(0) === " " : !words[0];
+	      startsWithSpace && _insertNodeBefore(" ", element, curNode);
+	      words[0] || words.shift();
+	      _stretchToFitSpecialChars(words, specialCharsRegEx);
+	      deepSlice && isNested || (curNode.textContent = "");
+	      for (j = 1; j <= words.length; j++) {
+	        wordText = words[j - 1];
+	        if (!reduceWhiteSpace && isPreformatted && wordText.charAt(0) === "\n") {
+	          (_a = curNode.previousSibling) == null ? void 0 : _a.remove();
+	          _insertNodeBefore(document.createElement("br"), element, curNode);
+	          wordText = wordText.slice(1);
+	        }
+	        if (!reduceWhiteSpace && wordText === "") {
+	          _insertNodeBefore(wordDelimString, element, curNode);
+	        } else if (wordText === " ") {
+	          element.insertBefore(document.createTextNode(" "), curNode);
+	        } else {
+	          wordDelimIsNotSpace && wordText.charAt(0) === " " && _insertNodeBefore(" ", element, curNode);
+	          if (ignoredPreviousSibling && j === 1 && !startsWithSpace && wordsCollection.indexOf(ignoredPreviousSibling.parentNode) > -1) {
+	            curWordEl = wordsCollection[wordsCollection.length - 1];
+	            curWordEl.appendChild(document.createTextNode(charWrapper ? "" : wordText));
+	          } else {
+	            curWordEl = wordWrapper(charWrapper ? "" : wordText);
+	            _insertNodeBefore(curWordEl, element, curNode);
+	            ignoredPreviousSibling && j === 1 && !startsWithSpace && curWordEl.insertBefore(ignoredPreviousSibling, curWordEl.firstChild);
+	          }
+	          if (charWrapper) {
+	            curWordChars = _charSegmenter ? _stretchToFitSpecialChars([..._charSegmenter.segment(wordText)].map((s) => s.segment), specialCharsRegEx) : wordText.match(charSplitRegEx) || _emptyArray;
+	            for (k = 0; k < curWordChars.length; k++) {
+	              curWordEl.appendChild(curWordChars[k] === " " ? document.createTextNode(" ") : charWrapper(curWordChars[k]));
+	            }
+	          }
+	          if (deepSlice && isNested) {
+	            curTextContent = curNode.textContent = curTextContent.substring(wordText.length + 1, curTextContent.length);
+	            bounds = curWordEl.getBoundingClientRect();
+	            if (bounds.top > lastBounds.top && bounds.left <= lastBounds.left) {
+	              clonedNode = element.cloneNode();
+	              curSubNode = element.childNodes[0];
+	              while (curSubNode && curSubNode !== curWordEl) {
+	                tempSubNode = curSubNode;
+	                curSubNode = curSubNode.nextSibling;
+	                clonedNode.appendChild(tempSubNode);
+	              }
+	              element.parentNode.insertBefore(clonedNode, element);
+	              prepForCharsOnly && _disallowInline(clonedNode);
+	            }
+	            lastBounds = bounds;
+	          }
+	          if (j < words.length || endsWithSpace) {
+	            _insertNodeBefore(j >= words.length ? " " : wordDelimIsNotSpace && wordText.slice(-1) === " " ? " " + wordDelimString : wordDelimString, element, curNode);
+	          }
+	        }
+	      }
+	      element.removeChild(curNode);
+	      ignoredPreviousSibling = 0;
+	    } else if (curNode.nodeType === 1) {
+	      if (ignore && ignore.indexOf(curNode) > -1) {
+	        wordsCollection.indexOf(curNode.previousSibling) > -1 && wordsCollection[wordsCollection.length - 1].appendChild(curNode);
+	        ignoredPreviousSibling = curNode;
+	      } else {
+	        _splitWordsAndCharsRecursively(curNode, config, wordWrapper, charWrapper, prepForCharsOnly, deepSlice, ignore, charSplitRegEx, specialCharsRegEx, true);
+	        ignoredPreviousSibling = 0;
+	      }
+	      prepForCharsOnly && _disallowInline(curNode);
+	    }
+	  }
+	};
+	const _SplitText = class _SplitText {
+	  constructor(elements, config) {
+	    this.isSplit = false;
+	    _initIfNecessary();
+	    this.elements = _elements(elements);
+	    this.chars = [];
+	    this.words = [];
+	    this.lines = [];
+	    this.masks = [];
+	    this.vars = config;
+	    this._split = () => this.isSplit && this.split(this.vars);
+	    let orig = [], timerId, checkWidths = () => {
+	      let i = orig.length, o;
+	      while (i--) {
+	        o = orig[i];
+	        let w = o.element.offsetWidth;
+	        if (w !== o.width) {
+	          o.width = w;
+	          this._split();
+	          return;
+	        }
+	      }
+	    };
+	    this._data = { orig, obs: typeof ResizeObserver !== "undefined" && new ResizeObserver(() => {
+	      clearTimeout(timerId);
+	      timerId = setTimeout(checkWidths, 200);
+	    }) };
+	    _context(this);
+	    this.split(config);
+	  }
+	  split(config) {
+	    this.isSplit && this.revert();
+	    this.vars = config = config || this.vars || {};
+	    let { type = "chars,words,lines", aria = "auto", deepSlice = true, smartWrap, onSplit, autoSplit = false, specialChars, mask } = this.vars, splitLines = type.indexOf("lines") > -1, splitCharacters = type.indexOf("chars") > -1, splitWords = type.indexOf("words") > -1, onlySplitCharacters = splitCharacters && !splitWords && !splitLines, specialCharsRegEx = specialChars && ("push" in specialChars ? new RegExp("(?:" + specialChars.join("|") + ")", "gu") : specialChars), finalCharSplitRegEx = specialCharsRegEx ? new RegExp(specialCharsRegEx.source + "|" + _emojiSafeRegEx.source, "gu") : _emojiSafeRegEx, ignore = !!config.ignore && _elements(config.ignore), { orig, animTime, obs } = this._data, onSplitResult;
+	    if (splitCharacters || splitWords || splitLines) {
+	      this.elements.forEach((element, index) => {
+	        orig[index] = {
+	          element,
+	          html: element.innerHTML,
+	          ariaL: element.getAttribute("aria-label"),
+	          ariaH: element.getAttribute("aria-hidden")
+	        };
+	        aria === "auto" ? element.setAttribute("aria-label", (element.textContent || "").trim()) : aria === "hidden" && element.setAttribute("aria-hidden", "true");
+	        let chars = [], words = [], lines = [], charWrapper = splitCharacters ? _getWrapper("char", config, chars) : null, wordWrapper = _getWrapper("word", config, words), i, curWord, smartWrapSpan, nextSibling;
+	        _splitWordsAndCharsRecursively(element, config, wordWrapper, charWrapper, onlySplitCharacters, deepSlice && (splitLines || onlySplitCharacters), ignore, finalCharSplitRegEx, specialCharsRegEx, false);
+	        if (splitLines) {
+	          let nodes = _toArray(element.childNodes), wrapLine = _getLineWrapper(element, nodes, config, lines), curNode, toRemove = [], lineStartIndex = 0, allBounds = nodes.map((n) => n.nodeType === 1 ? n.getBoundingClientRect() : _emptyBounds), lastBounds = _emptyBounds;
+	          for (i = 0; i < nodes.length; i++) {
+	            curNode = nodes[i];
+	            if (curNode.nodeType === 1) {
+	              if (curNode.nodeName === "BR") {
+	                toRemove.push(curNode);
+	                wrapLine(lineStartIndex, i + 1);
+	                lineStartIndex = i + 1;
+	                lastBounds = allBounds[lineStartIndex];
+	              } else {
+	                if (i && allBounds[i].top > lastBounds.top && allBounds[i].left <= lastBounds.left) {
+	                  wrapLine(lineStartIndex, i);
+	                  lineStartIndex = i;
+	                }
+	                lastBounds = allBounds[i];
+	              }
+	            }
+	          }
+	          lineStartIndex < i && wrapLine(lineStartIndex, i);
+	          toRemove.forEach((el) => {
+	            var _a;
+	            return (_a = el.parentNode) == null ? void 0 : _a.removeChild(el);
+	          });
+	        }
+	        if (!splitWords) {
+	          for (i = 0; i < words.length; i++) {
+	            curWord = words[i];
+	            if (splitCharacters || !curWord.nextSibling || curWord.nextSibling.nodeType !== 3) {
+	              if (smartWrap && !splitLines) {
+	                smartWrapSpan = document.createElement("span");
+	                smartWrapSpan.style.whiteSpace = "nowrap";
+	                while (curWord.firstChild) {
+	                  smartWrapSpan.appendChild(curWord.firstChild);
+	                }
+	                curWord.replaceWith(smartWrapSpan);
+	              } else {
+	                curWord.replaceWith(...curWord.childNodes);
+	              }
+	            } else {
+	              nextSibling = curWord.nextSibling;
+	              if (nextSibling && nextSibling.nodeType === 3) {
+	                nextSibling.textContent = (curWord.textContent || "") + (nextSibling.textContent || "");
+	                curWord.remove();
+	              }
+	            }
+	          }
+	          words.length = 0;
+	          element.normalize();
+	        }
+	        this.lines.push(...lines);
+	        this.words.push(...words);
+	        this.chars.push(...chars);
+	      });
+	      mask && this[mask] && this.masks.push(...this[mask].map((el) => {
+	        let maskEl = el.cloneNode();
+	        el.replaceWith(maskEl);
+	        maskEl.appendChild(el);
+	        el.className && (maskEl.className = el.className.replace(/(\b\w+\b)/g, "$1-mask"));
+	        maskEl.style.overflow = "clip";
+	        return maskEl;
+	      }));
+	    }
+	    this.isSplit = true;
+	    _fonts && (autoSplit ? _fonts.addEventListener("loadingdone", this._split) : _fonts.status === "loading" && console.warn("SplitText called before fonts loaded"));
+	    if ((onSplitResult = onSplit && onSplit(this)) && onSplitResult.totalTime) {
+	      this._data.anim = animTime ? onSplitResult.totalTime(animTime) : onSplitResult;
+	    }
+	    splitLines && autoSplit && this.elements.forEach((element, index) => {
+	      orig[index].width = element.offsetWidth;
+	      obs && obs.observe(element);
+	    });
+	    return this;
+	  }
+	  revert() {
+	    var _a, _b;
+	    let { orig, anim, obs } = this._data;
+	    obs && obs.disconnect();
+	    orig.forEach(({ element, html, ariaL, ariaH }) => {
+	      element.innerHTML = html;
+	      ariaL ? element.setAttribute("aria-label", ariaL) : element.removeAttribute("aria-label");
+	      ariaH ? element.setAttribute("aria-hidden", ariaH) : element.removeAttribute("aria-hidden");
+	    });
+	    this.chars.length = this.words.length = this.lines.length = orig.length = this.masks.length = 0;
+	    this.isSplit = false;
+	    _fonts == null ? void 0 : _fonts.removeEventListener("loadingdone", this._split);
+	    if (anim) {
+	      this._data.animTime = anim.totalTime();
+	      anim.revert();
+	    }
+	    (_b = (_a = this.vars).onRevert) == null ? void 0 : _b.call(_a, this);
+	    return this;
+	  }
+	  static create(elements, config) {
+	    return new _SplitText(elements, config);
+	  }
+	  static register(core) {
+	    gsap = gsap || core || window.gsap;
+	    if (gsap) {
+	      _toArray = gsap.utils.toArray;
+	      _context = gsap.core.context || _context;
+	    }
+	    if (!_coreInitted && window.innerWidth > 0) {
+	      _fonts = document.fonts;
+	      _coreInitted = true;
+	    }
+	  }
+	};
+	_SplitText.version = "3.13.0";
+	let SplitText = _SplitText;
+
+	exports.SplitText = SplitText;
+	exports.default = SplitText;
+
+	Object.defineProperty(exports, '__esModule', { value: true });
+
+}));

network-visualization/node_modules/gsap/dist/SplitText.min.js

@@ -0,0 +1,11 @@
+/*!
+ * SplitText 3.13.0
+ * https://gsap.com
+ *
+ * @license Copyright 2025, GreenSock. All rights reserved. Subject to the terms at https://gsap.com/standard-license.
+ * @author: Jack Doyle
+ */
+
+(function(B,A){typeof exports=="object"&&typeof module!="undefined"?A(exports):typeof define=="function"&&define.amd?define(["exports"],A):(B=typeof globalThis!="undefined"?globalThis:B||self,A(B.window=B.window||{}))})(this,function(B){"use strict";let A,_,G,re=()=>G||U.register(window.gsap),V=typeof Intl!="undefined"?new Intl.Segmenter:0,P=e=>typeof e=="string"?P(document.querySelectorAll(e)):"length"in e?Array.from(e):[e],X=e=>P(e).filter(t=>t instanceof HTMLElement),J=[],K=function(){},oe=/\s+/g,Y=new RegExp("\\p{RI}\\p{RI}|\\p{Emoji}(\\p{EMod}|\\u{FE0F}\\u{20E3}?|[\\u{E0020}-\\u{E007E}]+\\u{E007F})?(\\u{200D}\\p{Emoji}(\\p{EMod}|\\u{FE0F}\\u{20E3}?|[\\u{E0020}-\\u{E007E}]+\\u{E007F})?)*|.","gu"),Z={left:0,top:0,width:0,height:0},ee=(e,t)=>{if(t){let s=new Set(e.join("").match(t)||J),i=e.length,o,c,n,a;if(s.size)for(;--i>-1;){c=e[i];for(n of s)if(n.startsWith(c)&&n.length>c.length){for(o=0,a=c;n.startsWith(a+=e[i+ ++o])&&a.length<n.length;);if(o&&a.length===n.length){e[i]=n,e.splice(i+1,o);break}}}}return e},te=e=>window.getComputedStyle(e).display==="inline"&&(e.style.display="inline-block"),z=(e,t,s)=>t.insertBefore(typeof e=="string"?document.createTextNode(e):e,s),Q=(e,t,s)=>{let i=t[e+"sClass"]||"",{tag:o="div",aria:c="auto",propIndex:n=!1}=t,a=e==="line"?"block":"inline-block",h=i.indexOf("++")>-1,b=x=>{let g=document.createElement(o),C=s.length+1;return i&&(g.className=i+(h?" "+i+C:"")),n&&g.style.setProperty("--"+e,C+""),c!=="none"&&g.setAttribute("aria-hidden","true"),o!=="span"&&(g.style.position="relative",g.style.display=a),g.textContent=x,s.push(g),g};return h&&(i=i.replace("++","")),b.collection=s,b},ae=(e,t,s,i)=>{let o=Q("line",s,i),c=window.getComputedStyle(e).textAlign||"left";return(n,a)=>{let h=o("");for(h.style.textAlign=c,e.insertBefore(h,t[n]);n<a;n++)h.appendChild(t[n]);h.normalize()}},ie=(e,t,s,i,o,c,n,a,h,b)=>{var x;let g=Array.from(e.childNodes),C=0,{wordDelimiter:R,reduceWhiteSpace:L=!0,prepareText:$}=t,q=e.getBoundingClientRect(),j=q,D=!L&&window.getComputedStyle(e).whiteSpace.substring(0,3)==="pre",E=0,v=s.collection,r,f,H,l,m,y,I,d,u,W,S,O,T,F,w,p,k,N;for(typeof R=="object"?(H=R.delimiter||R,f=R.replaceWith||""):f=R===""?"":R||" ",r=f!==" ";C<g.length;C++)if(l=g[C],l.nodeType===3){for(w=l.textContent||"",L?w=w.replace(oe," "):D&&(w=w.replace(/\n/g,f+`
+`)),$&&(w=$(w,e)),l.textContent=w,m=f||H?w.split(H||f):w.match(a)||J,k=m[m.length-1],d=r?k.slice(-1)===" ":!k,k||m.pop(),j=q,I=r?m[0].charAt(0)===" ":!m[0],I&&z(" ",e,l),m[0]||m.shift(),ee(m,h),c&&b||(l.textContent=""),u=1;u<=m.length;u++)if(p=m[u-1],!L&&D&&p.charAt(0)===`
+`&&((x=l.previousSibling)==null||x.remove(),z(document.createElement("br"),e,l),p=p.slice(1)),!L&&p==="")z(f,e,l);else if(p===" ")e.insertBefore(document.createTextNode(" "),l);else{if(r&&p.charAt(0)===" "&&z(" ",e,l),E&&u===1&&!I&&v.indexOf(E.parentNode)>-1?(y=v[v.length-1],y.appendChild(document.createTextNode(i?"":p))):(y=s(i?"":p),z(y,e,l),E&&u===1&&!I&&y.insertBefore(E,y.firstChild)),i)for(S=V?ee([...V.segment(p)].map(M=>M.segment),h):p.match(a)||J,N=0;N<S.length;N++)y.appendChild(S[N]===" "?document.createTextNode(" "):i(S[N]));if(c&&b){if(w=l.textContent=w.substring(p.length+1,w.length),W=y.getBoundingClientRect(),W.top>j.top&&W.left<=j.left){for(O=e.cloneNode(),T=e.childNodes[0];T&&T!==y;)F=T,T=T.nextSibling,O.appendChild(F);e.parentNode.insertBefore(O,e),o&&te(O)}j=W}(u<m.length||d)&&z(u>=m.length?" ":r&&p.slice(-1)===" "?" "+f:f,e,l)}e.removeChild(l),E=0}else l.nodeType===1&&(n&&n.indexOf(l)>-1?(v.indexOf(l.previousSibling)>-1&&v[v.length-1].appendChild(l),E=l):(ie(l,t,s,i,o,c,n,a,h,!0),E=0),o&&te(l))};const ne=class se{constructor(t,s){this.isSplit=!1,re(),this.elements=X(t),this.chars=[],this.words=[],this.lines=[],this.masks=[],this.vars=s,this._split=()=>this.isSplit&&this.split(this.vars);let i=[],o,c=()=>{let n=i.length,a;for(;n--;){a=i[n];let h=a.element.offsetWidth;if(h!==a.width){a.width=h,this._split();return}}};this._data={orig:i,obs:typeof ResizeObserver!="undefined"&&new ResizeObserver(()=>{clearTimeout(o),o=setTimeout(c,200)})},K(this),this.split(s)}split(t){this.isSplit&&this.revert(),this.vars=t=t||this.vars||{};let{type:s="chars,words,lines",aria:i="auto",deepSlice:o=!0,smartWrap:c,onSplit:n,autoSplit:a=!1,specialChars:h,mask:b}=this.vars,x=s.indexOf("lines")>-1,g=s.indexOf("chars")>-1,C=s.indexOf("words")>-1,R=g&&!C&&!x,L=h&&("push"in h?new RegExp("(?:"+h.join("|")+")","gu"):h),$=L?new RegExp(L.source+"|"+Y.source,"gu"):Y,q=!!t.ignore&&X(t.ignore),{orig:j,animTime:D,obs:E}=this._data,v;return(g||C||x)&&(this.elements.forEach((r,f)=>{j[f]={element:r,html:r.innerHTML,ariaL:r.getAttribute("aria-label"),ariaH:r.getAttribute("aria-hidden")},i==="auto"?r.setAttribute("aria-label",(r.textContent||"").trim()):i==="hidden"&&r.setAttribute("aria-hidden","true");let H=[],l=[],m=[],y=g?Q("char",t,H):null,I=Q("word",t,l),d,u,W,S;if(ie(r,t,I,y,R,o&&(x||R),q,$,L,!1),x){let O=P(r.childNodes),T=ae(r,O,t,m),F,w=[],p=0,k=O.map(M=>M.nodeType===1?M.getBoundingClientRect():Z),N=Z;for(d=0;d<O.length;d++)F=O[d],F.nodeType===1&&(F.nodeName==="BR"?(w.push(F),T(p,d+1),p=d+1,N=k[p]):(d&&k[d].top>N.top&&k[d].left<=N.left&&(T(p,d),p=d),N=k[d]));p<d&&T(p,d),w.forEach(M=>{var le;return(le=M.parentNode)==null?void 0:le.removeChild(M)})}if(!C){for(d=0;d<l.length;d++)if(u=l[d],g||!u.nextSibling||u.nextSibling.nodeType!==3)if(c&&!x){for(W=document.createElement("span"),W.style.whiteSpace="nowrap";u.firstChild;)W.appendChild(u.firstChild);u.replaceWith(W)}else u.replaceWith(...u.childNodes);else S=u.nextSibling,S&&S.nodeType===3&&(S.textContent=(u.textContent||"")+(S.textContent||""),u.remove());l.length=0,r.normalize()}this.lines.push(...m),this.words.push(...l),this.chars.push(...H)}),b&&this[b]&&this.masks.push(...this[b].map(r=>{let f=r.cloneNode();return r.replaceWith(f),f.appendChild(r),r.className&&(f.className=r.className.replace(/(\b\w+\b)/g,"$1-mask")),f.style.overflow="clip",f}))),this.isSplit=!0,_&&(a?_.addEventListener("loadingdone",this._split):_.status==="loading"&&console.warn("SplitText called before fonts loaded")),(v=n&&n(this))&&v.totalTime&&(this._data.anim=D?v.totalTime(D):v),x&&a&&this.elements.forEach((r,f)=>{j[f].width=r.offsetWidth,E&&E.observe(r)}),this}revert(){var t,s;let{orig:i,anim:o,obs:c}=this._data;return c&&c.disconnect(),i.forEach(({element:n,html:a,ariaL:h,ariaH:b})=>{n.innerHTML=a,h?n.setAttribute("aria-label",h):n.removeAttribute("aria-label"),b?n.setAttribute("aria-hidden",b):n.removeAttribute("aria-hidden")}),this.chars.length=this.words.length=this.lines.length=i.length=this.masks.length=0,this.isSplit=!1,_==null||_.removeEventListener("loadingdone",this._split),o&&(this._data.animTime=o.totalTime(),o.revert()),(s=(t=this.vars).onRevert)==null||s.call(t,this),this}static create(t,s){return new se(t,s)}static register(t){A=A||t||window.gsap,A&&(P=A.utils.toArray,K=A.core.context||K),!G&&window.innerWidth>0&&(_=document.fonts,G=!0)}};ne.version="3.13.0";let U=ne;B.SplitText=U,B.default=U,Object.defineProperty(B,"__esModule",{value:!0})});