polly-graph 0.2.1 → 0.2.3

package/dist/index.js

@@ -374,14 +374,14 @@ var CanvasUtils = {
   /**
    * Safe image data extraction
    */
-  getPixelData(ctx, x2, y2, pixelRatio = window.devicePixelRatio || 1) {
+  getPixelData(ctx, x3, y3, pixelRatio = window.devicePixelRatio || 1) {
     try {
-      if (x2 <= 0 || y2 <= 0) {
+      if (x3 <= 0 || y3 <= 0) {
         return null;
       }
       const imageData = ctx.getImageData(
-        x2 * pixelRatio,
-        y2 * pixelRatio,
+        x3 * pixelRatio,
+        y3 * pixelRatio,
         1,
         1
       );
@@ -391,8 +391,8 @@ var CanvasUtils = {
         return null;
       }
       ErrorHandler.logError(error, {
-        x: x2,
-        y: y2,
+        x: x3,
+        y: y3,
         pixelRatio
       });
       return null;
@@ -1121,16 +1121,16 @@ var CanvasManager = class {
 };
 
 // node_modules/d3-force/src/center.js
-function center_default(x2, y2) {
+function center_default(x3, y3) {
   var nodes, strength = 1;
-  if (x2 == null) x2 = 0;
-  if (y2 == null) y2 = 0;
+  if (x3 == null) x3 = 0;
+  if (y3 == null) y3 = 0;
   function force() {
     var i, n = nodes.length, node, sx = 0, sy = 0;
     for (i = 0; i < n; ++i) {
       node = nodes[i], sx += node.x, sy += node.y;
     }
-    for (sx = (sx / n - x2) * strength, sy = (sy / n - y2) * strength, i = 0; i < n; ++i) {
+    for (sx = (sx / n - x3) * strength, sy = (sy / n - y3) * strength, i = 0; i < n; ++i) {
       node = nodes[i], node.x -= sx, node.y -= sy;
     }
   }
@@ -1138,10 +1138,10 @@ function center_default(x2, y2) {
     nodes = _;
   };
   force.x = function(_) {
-    return arguments.length ? (x2 = +_, force) : x2;
+    return arguments.length ? (x3 = +_, force) : x3;
   };
   force.y = function(_) {
-    return arguments.length ? (y2 = +_, force) : y2;
+    return arguments.length ? (y3 = +_, force) : y3;
   };
   force.strength = function(_) {
     return arguments.length ? (strength = +_, force) : strength;
@@ -1151,42 +1151,42 @@ function center_default(x2, y2) {
 
 // node_modules/d3-quadtree/src/add.js
 function add_default(d) {
-  const x2 = +this._x.call(null, d), y2 = +this._y.call(null, d);
-  return add(this.cover(x2, y2), x2, y2, d);
+  const x3 = +this._x.call(null, d), y3 = +this._y.call(null, d);
+  return add(this.cover(x3, y3), x3, y3, d);
 }
-function add(tree, x2, y2, d) {
-  if (isNaN(x2) || isNaN(y2)) return tree;
+function add(tree, x3, y3, d) {
+  if (isNaN(x3) || isNaN(y3)) return tree;
   var parent, node = tree._root, leaf = { data: d }, x0 = tree._x0, y0 = tree._y0, x1 = tree._x1, y1 = tree._y1, xm, ym, xp, yp, right, bottom, i, j;
   if (!node) return tree._root = leaf, tree;
   while (node.length) {
-    if (right = x2 >= (xm = (x0 + x1) / 2)) x0 = xm;
+    if (right = x3 >= (xm = (x0 + x1) / 2)) x0 = xm;
     else x1 = xm;
-    if (bottom = y2 >= (ym = (y0 + y1) / 2)) y0 = ym;
+    if (bottom = y3 >= (ym = (y0 + y1) / 2)) y0 = ym;
     else y1 = ym;
     if (parent = node, !(node = node[i = bottom << 1 | right])) return parent[i] = leaf, tree;
   }
   xp = +tree._x.call(null, node.data);
   yp = +tree._y.call(null, node.data);
-  if (x2 === xp && y2 === yp) return leaf.next = node, parent ? parent[i] = leaf : tree._root = leaf, tree;
+  if (x3 === xp && y3 === yp) return leaf.next = node, parent ? parent[i] = leaf : tree._root = leaf, tree;
   do {
     parent = parent ? parent[i] = new Array(4) : tree._root = new Array(4);
-    if (right = x2 >= (xm = (x0 + x1) / 2)) x0 = xm;
+    if (right = x3 >= (xm = (x0 + x1) / 2)) x0 = xm;
     else x1 = xm;
-    if (bottom = y2 >= (ym = (y0 + y1) / 2)) y0 = ym;
+    if (bottom = y3 >= (ym = (y0 + y1) / 2)) y0 = ym;
     else y1 = ym;
   } while ((i = bottom << 1 | right) === (j = (yp >= ym) << 1 | xp >= xm));
   return parent[j] = node, parent[i] = leaf, tree;
 }
 function addAll(data) {
-  var d, i, n = data.length, x2, y2, xz = new Array(n), yz = new Array(n), x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
+  var d, i, n = data.length, x3, y3, xz = new Array(n), yz = new Array(n), x0 = Infinity, y0 = Infinity, x1 = -Infinity, y1 = -Infinity;
   for (i = 0; i < n; ++i) {
-    if (isNaN(x2 = +this._x.call(null, d = data[i])) || isNaN(y2 = +this._y.call(null, d))) continue;
-    xz[i] = x2;
-    yz[i] = y2;
-    if (x2 < x0) x0 = x2;
-    if (x2 > x1) x1 = x2;
-    if (y2 < y0) y0 = y2;
-    if (y2 > y1) y1 = y2;
+    if (isNaN(x3 = +this._x.call(null, d = data[i])) || isNaN(y3 = +this._y.call(null, d))) continue;
+    xz[i] = x3;
+    yz[i] = y3;
+    if (x3 < x0) x0 = x3;
+    if (x3 > x1) x1 = x3;
+    if (y3 < y0) y0 = y3;
+    if (y3 > y1) y1 = y3;
   }
   if (x0 > x1 || y0 > y1) return this;
   this.cover(x0, y0).cover(x1, y1);
@@ -1197,16 +1197,16 @@ function addAll(data) {
 }
 
 // node_modules/d3-quadtree/src/cover.js
-function cover_default(x2, y2) {
-  if (isNaN(x2 = +x2) || isNaN(y2 = +y2)) return this;
+function cover_default(x3, y3) {
+  if (isNaN(x3 = +x3) || isNaN(y3 = +y3)) return this;
   var x0 = this._x0, y0 = this._y0, x1 = this._x1, y1 = this._y1;
   if (isNaN(x0)) {
-    x1 = (x0 = Math.floor(x2)) + 1;
-    y1 = (y0 = Math.floor(y2)) + 1;
+    x1 = (x0 = Math.floor(x3)) + 1;
+    y1 = (y0 = Math.floor(y3)) + 1;
   } else {
     var z = x1 - x0 || 1, node = this._root, parent, i;
-    while (x0 > x2 || x2 >= x1 || y0 > y2 || y2 >= y1) {
-      i = (y2 < y0) << 1 | x2 < x0;
+    while (x0 > x3 || x3 >= x1 || y0 > y3 || y3 >= y1) {
+      i = (y3 < y0) << 1 | x3 < x0;
       parent = new Array(4), parent[i] = node, node = parent, z *= 2;
       switch (i) {
         case 0:
@@ -1258,17 +1258,17 @@ function quad_default(node, x0, y0, x1, y1) {
 }
 
 // node_modules/d3-quadtree/src/find.js
-function find_default(x2, y2, radius) {
-  var data, x0 = this._x0, y0 = this._y0, x1, y1, x22, y22, x3 = this._x1, y3 = this._y1, quads = [], node = this._root, q, i;
-  if (node) quads.push(new quad_default(node, x0, y0, x3, y3));
+function find_default(x3, y3, radius) {
+  var data, x0 = this._x0, y0 = this._y0, x1, y1, x22, y22, x32 = this._x1, y32 = this._y1, quads = [], node = this._root, q, i;
+  if (node) quads.push(new quad_default(node, x0, y0, x32, y32));
   if (radius == null) radius = Infinity;
   else {
-    x0 = x2 - radius, y0 = y2 - radius;
-    x3 = x2 + radius, y3 = y2 + radius;
+    x0 = x3 - radius, y0 = y3 - radius;
+    x32 = x3 + radius, y32 = y3 + radius;
     radius *= radius;
   }
   while (q = quads.pop()) {
-    if (!(node = q.node) || (x1 = q.x0) > x3 || (y1 = q.y0) > y3 || (x22 = q.x1) < x0 || (y22 = q.y1) < y0) continue;
+    if (!(node = q.node) || (x1 = q.x0) > x32 || (y1 = q.y0) > y32 || (x22 = q.x1) < x0 || (y22 = q.y1) < y0) continue;
     if (node.length) {
       var xm = (x1 + x22) / 2, ym = (y1 + y22) / 2;
       quads.push(
@@ -1277,17 +1277,17 @@ function find_default(x2, y2, radius) {
         new quad_default(node[1], xm, y1, x22, ym),
         new quad_default(node[0], x1, y1, xm, ym)
       );
-      if (i = (y2 >= ym) << 1 | x2 >= xm) {
+      if (i = (y3 >= ym) << 1 | x3 >= xm) {
         q = quads[quads.length - 1];
         quads[quads.length - 1] = quads[quads.length - 1 - i];
         quads[quads.length - 1 - i] = q;
       }
     } else {
-      var dx = x2 - +this._x.call(null, node.data), dy = y2 - +this._y.call(null, node.data), d2 = dx * dx + dy * dy;
+      var dx = x3 - +this._x.call(null, node.data), dy = y3 - +this._y.call(null, node.data), d2 = dx * dx + dy * dy;
       if (d2 < radius) {
         var d = Math.sqrt(radius = d2);
-        x0 = x2 - d, y0 = y2 - d;
-        x3 = x2 + d, y3 = y2 + d;
+        x0 = x3 - d, y0 = y3 - d;
+        x32 = x3 + d, y32 = y3 + d;
         data = node.data;
       }
     }
@@ -1297,13 +1297,13 @@ function find_default(x2, y2, radius) {
 
 // node_modules/d3-quadtree/src/remove.js
 function remove_default(d) {
-  if (isNaN(x2 = +this._x.call(null, d)) || isNaN(y2 = +this._y.call(null, d))) return this;
-  var parent, node = this._root, retainer, previous, next, x0 = this._x0, y0 = this._y0, x1 = this._x1, y1 = this._y1, x2, y2, xm, ym, right, bottom, i, j;
+  if (isNaN(x3 = +this._x.call(null, d)) || isNaN(y3 = +this._y.call(null, d))) return this;
+  var parent, node = this._root, retainer, previous, next, x0 = this._x0, y0 = this._y0, x1 = this._x1, y1 = this._y1, x3, y3, xm, ym, right, bottom, i, j;
   if (!node) return this;
   if (node.length) while (true) {
-    if (right = x2 >= (xm = (x0 + x1) / 2)) x0 = xm;
+    if (right = x3 >= (xm = (x0 + x1) / 2)) x0 = xm;
     else x1 = xm;
-    if (bottom = y2 >= (ym = (y0 + y1) / 2)) y0 = ym;
+    if (bottom = y3 >= (ym = (y0 + y1) / 2)) y0 = ym;
     else y1 = ym;
     if (!(parent = node, node = node[i = bottom << 1 | right])) return this;
     if (!node.length) break;
@@ -1395,13 +1395,13 @@ function y_default(_) {
 }
 
 // node_modules/d3-quadtree/src/quadtree.js
-function quadtree(nodes, x2, y2) {
-  var tree = new Quadtree(x2 == null ? defaultX : x2, y2 == null ? defaultY : y2, NaN, NaN, NaN, NaN);
+function quadtree(nodes, x3, y3) {
+  var tree = new Quadtree(x3 == null ? defaultX : x3, y3 == null ? defaultY : y3, NaN, NaN, NaN, NaN);
   return nodes == null ? tree : tree.addAll(nodes);
 }
-function Quadtree(x2, y2, x0, y0, x1, y1) {
-  this._x = x2;
-  this._y = y2;
+function Quadtree(x3, y3, x0, y0, x1, y1) {
+  this._x = x3;
+  this._y = y3;
   this._x0 = x0;
   this._y0 = y0;
   this._x1 = x1;
@@ -1445,9 +1445,9 @@ treeProto.x = x_default;
 treeProto.y = y_default;
 
 // node_modules/d3-force/src/constant.js
-function constant_default(x2) {
+function constant_default(x3) {
   return function() {
-    return x2;
+    return x3;
   };
 }
 
@@ -1456,6 +1456,79 @@ function jiggle_default(random) {
   return (random() - 0.5) * 1e-6;
 }
 
+// node_modules/d3-force/src/collide.js
+function x(d) {
+  return d.x + d.vx;
+}
+function y(d) {
+  return d.y + d.vy;
+}
+function collide_default(radius) {
+  var nodes, radii, random, strength = 1, iterations = 1;
+  if (typeof radius !== "function") radius = constant_default(radius == null ? 1 : +radius);
+  function force() {
+    var i, n = nodes.length, tree, node, xi, yi, ri, ri2;
+    for (var k = 0; k < iterations; ++k) {
+      tree = quadtree(nodes, x, y).visitAfter(prepare);
+      for (i = 0; i < n; ++i) {
+        node = nodes[i];
+        ri = radii[node.index], ri2 = ri * ri;
+        xi = node.x + node.vx;
+        yi = node.y + node.vy;
+        tree.visit(apply);
+      }
+    }
+    function apply(quad, x0, y0, x1, y1) {
+      var data = quad.data, rj = quad.r, r = ri + rj;
+      if (data) {
+        if (data.index > node.index) {
+          var x3 = xi - data.x - data.vx, y3 = yi - data.y - data.vy, l = x3 * x3 + y3 * y3;
+          if (l < r * r) {
+            if (x3 === 0) x3 = jiggle_default(random), l += x3 * x3;
+            if (y3 === 0) y3 = jiggle_default(random), l += y3 * y3;
+            l = (r - (l = Math.sqrt(l))) / l * strength;
+            node.vx += (x3 *= l) * (r = (rj *= rj) / (ri2 + rj));
+            node.vy += (y3 *= l) * r;
+            data.vx -= x3 * (r = 1 - r);
+            data.vy -= y3 * r;
+          }
+        }
+        return;
+      }
+      return x0 > xi + r || x1 < xi - r || y0 > yi + r || y1 < yi - r;
+    }
+  }
+  function prepare(quad) {
+    if (quad.data) return quad.r = radii[quad.data.index];
+    for (var i = quad.r = 0; i < 4; ++i) {
+      if (quad[i] && quad[i].r > quad.r) {
+        quad.r = quad[i].r;
+      }
+    }
+  }
+  function initialize() {
+    if (!nodes) return;
+    var i, n = nodes.length, node;
+    radii = new Array(n);
+    for (i = 0; i < n; ++i) node = nodes[i], radii[node.index] = +radius(node, i, nodes);
+  }
+  force.initialize = function(_nodes, _random) {
+    nodes = _nodes;
+    random = _random;
+    initialize();
+  };
+  force.iterations = function(_) {
+    return arguments.length ? (iterations = +_, force) : iterations;
+  };
+  force.strength = function(_) {
+    return arguments.length ? (strength = +_, force) : strength;
+  };
+  force.radius = function(_) {
+    return arguments.length ? (radius = typeof _ === "function" ? _ : constant_default(+_), initialize(), force) : radius;
+  };
+  return force;
+}
+
 // node_modules/d3-force/src/link.js
 function index(d) {
   return d.index;
@@ -1473,17 +1546,17 @@ function link_default(links) {
   }
   function force(alpha) {
     for (var k = 0, n = links.length; k < iterations; ++k) {
-      for (var i = 0, link, source, target, x2, y2, l, b; i < n; ++i) {
+      for (var i = 0, link, source, target, x3, y3, l, b; i < n; ++i) {
         link = links[i], source = link.source, target = link.target;
-        x2 = target.x + target.vx - source.x - source.vx || jiggle_default(random);
-        y2 = target.y + target.vy - source.y - source.vy || jiggle_default(random);
-        l = Math.sqrt(x2 * x2 + y2 * y2);
+        x3 = target.x + target.vx - source.x - source.vx || jiggle_default(random);
+        y3 = target.y + target.vy - source.y - source.vy || jiggle_default(random);
+        l = Math.sqrt(x3 * x3 + y3 * y3);
         l = (l - distances[i]) / l * alpha * strengths[i];
-        x2 *= l, y2 *= l;
-        target.vx -= x2 * (b = bias[i]);
-        target.vy -= y2 * b;
-        source.vx += x2 * (b = 1 - b);
-        source.vy += y2 * b;
+        x3 *= l, y3 *= l;
+        target.vx -= x3 * (b = bias[i]);
+        target.vy -= y3 * b;
+        source.vx += x3 * (b = 1 - b);
+        source.vy += y3 * b;
       }
     }
   }
@@ -1731,10 +1804,10 @@ function lcg_default() {
 }
 
 // node_modules/d3-force/src/simulation.js
-function x(d) {
+function x2(d) {
   return d.x;
 }
-function y(d) {
+function y2(d) {
   return d.y;
 }
 var initialRadius = 10;
@@ -1820,14 +1893,14 @@ function simulation_default(nodes) {
     force: function(name, _) {
       return arguments.length > 1 ? (_ == null ? forces.delete(name) : forces.set(name, initializeForce(_)), simulation) : forces.get(name);
     },
-    find: function(x2, y2, radius) {
+    find: function(x3, y3, radius) {
       var i = 0, n = nodes.length, dx, dy, d2, node, closest;
       if (radius == null) radius = Infinity;
       else radius *= radius;
       for (i = 0; i < n; ++i) {
         node = nodes[i];
-        dx = x2 - node.x;
-        dy = y2 - node.y;
+        dx = x3 - node.x;
+        dy = y3 - node.y;
         d2 = dx * dx + dy * dy;
         if (d2 < radius) closest = node, radius = d2;
       }
@@ -1843,7 +1916,7 @@ function simulation_default(nodes) {
 function manyBody_default() {
   var nodes, node, random, alpha, strength = constant_default(-30), strengths, distanceMin2 = 1, distanceMax2 = Infinity, theta2 = 0.81;
   function force(_) {
-    var i, n = nodes.length, tree = quadtree(nodes, x, y).visitAfter(accumulate);
+    var i, n = nodes.length, tree = quadtree(nodes, x2, y2).visitAfter(accumulate);
     for (alpha = _, i = 0; i < n; ++i) node = nodes[i], tree.visit(apply);
   }
   function initialize() {
@@ -1853,15 +1926,15 @@ function manyBody_default() {
     for (i = 0; i < n; ++i) node2 = nodes[i], strengths[node2.index] = +strength(node2, i, nodes);
   }
   function accumulate(quad) {
-    var strength2 = 0, q, c2, weight = 0, x2, y2, i;
+    var strength2 = 0, q, c2, weight = 0, x3, y3, i;
     if (quad.length) {
-      for (x2 = y2 = i = 0; i < 4; ++i) {
+      for (x3 = y3 = i = 0; i < 4; ++i) {
         if ((q = quad[i]) && (c2 = Math.abs(q.value))) {
-          strength2 += q.value, weight += c2, x2 += c2 * q.x, y2 += c2 * q.y;
+          strength2 += q.value, weight += c2, x3 += c2 * q.x, y3 += c2 * q.y;
         }
       }
-      quad.x = x2 / weight;
-      quad.y = y2 / weight;
+      quad.x = x3 / weight;
+      quad.y = y3 / weight;
     } else {
       q = quad;
       q.x = q.data.x;
@@ -1872,29 +1945,29 @@ function manyBody_default() {
     }
     quad.value = strength2;
   }
-  function apply(quad, x1, _, x2) {
+  function apply(quad, x1, _, x22) {
     if (!quad.value) return true;
-    var x3 = quad.x - node.x, y2 = quad.y - node.y, w = x2 - x1, l = x3 * x3 + y2 * y2;
+    var x3 = quad.x - node.x, y3 = quad.y - node.y, w = x22 - x1, l = x3 * x3 + y3 * y3;
     if (w * w / theta2 < l) {
       if (l < distanceMax2) {
         if (x3 === 0) x3 = jiggle_default(random), l += x3 * x3;
-        if (y2 === 0) y2 = jiggle_default(random), l += y2 * y2;
+        if (y3 === 0) y3 = jiggle_default(random), l += y3 * y3;
         if (l < distanceMin2) l = Math.sqrt(distanceMin2 * l);
         node.vx += x3 * quad.value * alpha / l;
-        node.vy += y2 * quad.value * alpha / l;
+        node.vy += y3 * quad.value * alpha / l;
       }
       return true;
     } else if (quad.length || l >= distanceMax2) return;
     if (quad.data !== node || quad.next) {
       if (x3 === 0) x3 = jiggle_default(random), l += x3 * x3;
-      if (y2 === 0) y2 = jiggle_default(random), l += y2 * y2;
+      if (y3 === 0) y3 = jiggle_default(random), l += y3 * y3;
       if (l < distanceMin2) l = Math.sqrt(distanceMin2 * l);
     }
     do
       if (quad.data !== node) {
         w = strengths[quad.data.index] * alpha / l;
         node.vx += x3 * w;
-        node.vy += y2 * w;
+        node.vy += y3 * w;
       }
     while (quad = quad.next);
   }
@@ -1943,38 +2016,29 @@ var PhysicsManager = class {
       this.config = config;
       this.simulationStartTime = performance.now();
       const nodeCount = config.nodes.length;
-      const linkCount = config.links.length;
       const graphArea = config.width * config.height;
-      const baseChargeStrength = -600;
       const nodeDensity = nodeCount / (graphArea / 1e5);
       const densityFactor = Math.min(nodeDensity, 2);
-      const adaptiveChargeStrength = baseChargeStrength / (1 + densityFactor * 0.4);
       const baseVelocityDecay = 0.4;
       const adaptiveVelocityDecay = Math.min(baseVelocityDecay + densityFactor * 0.2, 0.8);
       const baseAlphaDecay = 0.02;
       const adaptiveAlphaDecay = Math.min(baseAlphaDecay + densityFactor * 0.01, 0.05);
-      console.log("\u{1F52C} Adaptive Physics:", {
-        nodeCount,
-        linkCount,
-        graphArea: Math.round(graphArea),
-        nodeDensity: nodeDensity.toFixed(3),
-        densityFactor: densityFactor.toFixed(2),
-        chargeStrength: adaptiveChargeStrength.toFixed(0),
-        velocityDecay: adaptiveVelocityDecay.toFixed(2),
-        alphaDecay: adaptiveAlphaDecay.toFixed(3),
-        maxDistance: Math.max(300, 600 - densityFactor * 100)
-      });
       this.simulation = simulation_default(config.nodes).force(
         "link",
-        link_default(config.links).id((d) => d.id).distance(100).strength(0.2)
+        link_default(config.links).id((d) => d.id).distance(150).strength(0.4)
         // Much weaker link strength to allow repulsion to work
       ).force(
         "charge",
-        manyBody_default().strength(adaptiveChargeStrength).distanceMin(1).distanceMax(Math.max(300, 600 - densityFactor * 100))
-        // Reduce max distance for dense graphs
+        manyBody_default().strength(-500)
+        // Adaptive repulsion strength
+        // .distanceMin(1) // Minimum distance for repulsion
+        // .distanceMax(Math.max(300, 600 - densityFactor * 100)) // Reduce max distance for dense graphs
+      ).force(
+        "collision",
+        collide_default().radius((node) => this.getNodeRadius(node) + 2).strength(1)
       ).force(
         "center",
-        center_default(0, 0).strength(0.1)
+        center_default(0, 0).strength(0.5)
         // Center around origin like force-graph
       ).velocityDecay(adaptiveVelocityDecay).alphaDecay(adaptiveAlphaDecay).on("tick", config.onTick).on("end", () => this.handleSimulationEnd());
       if (config.cooldownTime) {
@@ -2101,12 +2165,12 @@ var PhysicsManager = class {
    * Update center force position for new canvas dimensions
    * Following force-graph pattern for container resizing
    */
-  updateCenterForce(x2, y2) {
+  updateCenterForce(x3, y3) {
     if (!this.simulation) return;
     try {
-      this.simulation.force("center", center_default(x2, y2).strength(0.1));
+      this.simulation.force("center", center_default(x3, y3).strength(0.1));
     } catch (error) {
-      ErrorHandler.logError(error, { x: x2, y: y2 });
+      ErrorHandler.logError(error, { x: x3, y: y3 });
     }
   }
   /**
@@ -2323,8 +2387,8 @@ function select_default(select) {
 }
 
 // node_modules/d3-selection/src/array.js
-function array(x2) {
-  return x2 == null ? [] : Array.isArray(x2) ? x2 : Array.from(x2);
+function array(x3) {
+  return x3 == null ? [] : Array.isArray(x3) ? x3 : Array.from(x3);
 }
 
 // node_modules/d3-selection/src/selectorAll.js
@@ -2443,9 +2507,9 @@ EnterNode.prototype = {
 };
 
 // node_modules/d3-selection/src/constant.js
-function constant_default2(x2) {
+function constant_default2(x3) {
   return function() {
-    return x2;
+    return x3;
   };
 }
 
@@ -3118,7 +3182,7 @@ function yesdrag(view, noclick) {
 }
 
 // node_modules/d3-drag/src/constant.js
-var constant_default3 = (x2) => () => x2;
+var constant_default3 = (x3) => () => x3;
 
 // node_modules/d3-drag/src/event.js
 function DragEvent(type, {
@@ -3127,8 +3191,8 @@ function DragEvent(type, {
   target,
   identifier,
   active,
-  x: x2,
-  y: y2,
+  x: x3,
+  y: y3,
   dx,
   dy,
   dispatch: dispatch2
@@ -3140,8 +3204,8 @@ function DragEvent(type, {
     target: { value: target, enumerable: true, configurable: true },
     identifier: { value: identifier, enumerable: true, configurable: true },
     active: { value: active, enumerable: true, configurable: true },
-    x: { value: x2, enumerable: true, configurable: true },
-    y: { value: y2, enumerable: true, configurable: true },
+    x: { value: x3, enumerable: true, configurable: true },
+    y: { value: y3, enumerable: true, configurable: true },
     dx: { value: dx, enumerable: true, configurable: true },
     dy: { value: dy, enumerable: true, configurable: true },
     _: { value: dispatch2 }
@@ -3668,7 +3732,7 @@ function basisClosed_default(values) {
 }
 
 // node_modules/d3-interpolate/src/constant.js
-var constant_default4 = (x2) => () => x2;
+var constant_default4 = (x3) => () => x3;
 
 // node_modules/d3-interpolate/src/color.js
 function linear(a2, d) {
@@ -3676,14 +3740,14 @@ function linear(a2, d) {
     return a2 + t * d;
   };
 }
-function exponential(a2, b, y2) {
-  return a2 = Math.pow(a2, y2), b = Math.pow(b, y2) - a2, y2 = 1 / y2, function(t) {
-    return Math.pow(a2 + t * b, y2);
+function exponential(a2, b, y3) {
+  return a2 = Math.pow(a2, y3), b = Math.pow(b, y3) - a2, y3 = 1 / y3, function(t) {
+    return Math.pow(a2 + t * b, y3);
   };
 }
-function gamma(y2) {
-  return (y2 = +y2) === 1 ? nogamma : function(a2, b) {
-    return b - a2 ? exponential(a2, b, y2) : constant_default4(isNaN(a2) ? b : a2);
+function gamma(y3) {
+  return (y3 = +y3) === 1 ? nogamma : function(a2, b) {
+    return b - a2 ? exponential(a2, b, y3) : constant_default4(isNaN(a2) ? b : a2);
   };
 }
 function nogamma(a2, b) {
@@ -3692,8 +3756,8 @@ function nogamma(a2, b) {
 }
 
 // node_modules/d3-interpolate/src/rgb.js
-var rgb_default = (function rgbGamma(y2) {
-  var color2 = gamma(y2);
+var rgb_default = (function rgbGamma(y3) {
+  var color2 = gamma(y3);
   function rgb2(start2, end) {
     var r = color2((start2 = rgb(start2)).r, (end = rgb(end)).r), g = color2(start2.g, end.g), b = color2(start2.b, end.b), opacity = nogamma(start2.opacity, end.opacity);
     return function(t) {
@@ -3878,14 +3942,14 @@ var interpolateTransformSvg = interpolateTransform(parseSvg, ", ", ")", ")");
 
 // node_modules/d3-interpolate/src/zoom.js
 var epsilon2 = 1e-12;
-function cosh(x2) {
-  return ((x2 = Math.exp(x2)) + 1 / x2) / 2;
+function cosh(x3) {
+  return ((x3 = Math.exp(x3)) + 1 / x3) / 2;
 }
-function sinh(x2) {
-  return ((x2 = Math.exp(x2)) - 1 / x2) / 2;
+function sinh(x3) {
+  return ((x3 = Math.exp(x3)) - 1 / x3) / 2;
 }
-function tanh(x2) {
-  return ((x2 = Math.exp(2 * x2)) - 1) / (x2 + 1);
+function tanh(x3) {
+  return ((x3 = Math.exp(2 * x3)) - 1) / (x3 + 1);
 }
 var zoom_default = (function zoomRho(rho, rho2, rho4) {
   function zoom(p0, p1) {
@@ -4613,7 +4677,7 @@ selection_default.prototype.interrupt = interrupt_default2;
 selection_default.prototype.transition = transition_default2;
 
 // node_modules/d3-zoom/src/constant.js
-var constant_default5 = (x2) => () => x2;
+var constant_default5 = (x3) => () => x3;
 
 // node_modules/d3-zoom/src/event.js
 function ZoomEvent(type, {
@@ -4632,42 +4696,42 @@ function ZoomEvent(type, {
 }
 
 // node_modules/d3-zoom/src/transform.js
-function Transform(k, x2, y2) {
+function Transform(k, x3, y3) {
   this.k = k;
-  this.x = x2;
-  this.y = y2;
+  this.x = x3;
+  this.y = y3;
 }
 Transform.prototype = {
   constructor: Transform,
   scale: function(k) {
     return k === 1 ? this : new Transform(this.k * k, this.x, this.y);
   },
-  translate: function(x2, y2) {
-    return x2 === 0 & y2 === 0 ? this : new Transform(this.k, this.x + this.k * x2, this.y + this.k * y2);
+  translate: function(x3, y3) {
+    return x3 === 0 & y3 === 0 ? this : new Transform(this.k, this.x + this.k * x3, this.y + this.k * y3);
   },
   apply: function(point) {
     return [point[0] * this.k + this.x, point[1] * this.k + this.y];
   },
-  applyX: function(x2) {
-    return x2 * this.k + this.x;
+  applyX: function(x3) {
+    return x3 * this.k + this.x;
   },
-  applyY: function(y2) {
-    return y2 * this.k + this.y;
+  applyY: function(y3) {
+    return y3 * this.k + this.y;
   },
   invert: function(location) {
     return [(location[0] - this.x) / this.k, (location[1] - this.y) / this.k];
   },
-  invertX: function(x2) {
-    return (x2 - this.x) / this.k;
+  invertX: function(x3) {
+    return (x3 - this.x) / this.k;
   },
-  invertY: function(y2) {
-    return (y2 - this.y) / this.k;
+  invertY: function(y3) {
+    return (y3 - this.y) / this.k;
   },
-  rescaleX: function(x2) {
-    return x2.copy().domain(x2.range().map(this.invertX, this).map(x2.invert, x2));
+  rescaleX: function(x3) {
+    return x3.copy().domain(x3.range().map(this.invertX, this).map(x3.invert, x3));
   },
-  rescaleY: function(y2) {
-    return y2.copy().domain(y2.range().map(this.invertY, this).map(y2.invert, y2));
+  rescaleY: function(y3) {
+    return y3.copy().domain(y3.range().map(this.invertY, this).map(y3.invert, y3));
   },
   toString: function() {
     return "translate(" + this.x + "," + this.y + ") scale(" + this.k + ")";
@@ -4749,20 +4813,20 @@ function zoom_default2() {
       return constrain(translate(scale(t0, k1), p0, p1), e, translateExtent);
     }, p, event);
   };
-  zoom.translateBy = function(selection2, x2, y2, event) {
+  zoom.translateBy = function(selection2, x3, y3, event) {
     zoom.transform(selection2, function() {
       return constrain(this.__zoom.translate(
-        typeof x2 === "function" ? x2.apply(this, arguments) : x2,
-        typeof y2 === "function" ? y2.apply(this, arguments) : y2
+        typeof x3 === "function" ? x3.apply(this, arguments) : x3,
+        typeof y3 === "function" ? y3.apply(this, arguments) : y3
       ), extent.apply(this, arguments), translateExtent);
     }, null, event);
   };
-  zoom.translateTo = function(selection2, x2, y2, p, event) {
+  zoom.translateTo = function(selection2, x3, y3, p, event) {
     zoom.transform(selection2, function() {
       var e = extent.apply(this, arguments), t = this.__zoom, p0 = p == null ? centroid(e) : typeof p === "function" ? p.apply(this, arguments) : p;
       return constrain(identity2.translate(p0[0], p0[1]).scale(t.k).translate(
-        typeof x2 === "function" ? -x2.apply(this, arguments) : -x2,
-        typeof y2 === "function" ? -y2.apply(this, arguments) : -y2
+        typeof x3 === "function" ? -x3.apply(this, arguments) : -x3,
+        typeof y3 === "function" ? -y3.apply(this, arguments) : -y3
       ), e, translateExtent);
     }, p, event);
   };
@@ -4771,8 +4835,8 @@ function zoom_default2() {
     return k === transform2.k ? transform2 : new Transform(k, transform2.x, transform2.y);
   }
   function translate(transform2, p0, p1) {
-    var x2 = p0[0] - p1[0] * transform2.k, y2 = p0[1] - p1[1] * transform2.k;
-    return x2 === transform2.x && y2 === transform2.y ? transform2 : new Transform(transform2.k, x2, y2);
+    var x3 = p0[0] - p1[0] * transform2.k, y3 = p0[1] - p1[1] * transform2.k;
+    return x3 === transform2.x && y3 === transform2.y ? transform2 : new Transform(transform2.k, x3, y3);
   }
   function centroid(extent2) {
     return [(+extent2[0][0] + +extent2[1][0]) / 2, (+extent2[0][1] + +extent2[1][1]) / 2];
@@ -5213,7 +5277,9 @@ var ZoomManager = class {
         event.stopPropagation();
         event.preventDefault();
         if (event.button) return false;
-        if (config.isOverEntity && config.isOverEntity()) return false;
+        if (config.isOverEntity && config.isOverEntity() && event.type !== "wheel") {
+          return false;
+        }
         return true;
       }).on("start", (event) => this.handleZoomStart(event)).on("zoom", (event) => this.handleZoom(event)).on("end", (event) => this.handleZoomEnd(event));
     } catch (error) {
@@ -5804,9 +5870,9 @@ var SelectionManager = class {
     if (!this.canvasState) return;
     try {
       const rect = this.container.getBoundingClientRect();
-      const x2 = event.clientX - rect.left;
-      const y2 = event.clientY - rect.top;
-      const obj = this.getObjUnderPointer(x2, y2);
+      const x3 = event.clientX - rect.left;
+      const y3 = event.clientY - rect.top;
+      const obj = this.getObjUnderPointer(x3, y3);
       if (obj) {
         if (obj.d.entityType === "Node") {
           this.selectNode(obj.d);
@@ -5826,19 +5892,19 @@ var SelectionManager = class {
   /**
    * Get object under pointer coordinates (using shadow canvas)
    */
-  getObjUnderPointer(x2, y2) {
+  getObjUnderPointer(x3, y3) {
     if (!this.canvasState) return null;
     try {
       const { shadowCtx, colorTracker } = this.canvasState;
       const pxScale = window.devicePixelRatio;
-      const px = x2 > 0 && y2 > 0 ? shadowCtx.getImageData(x2 * pxScale, y2 * pxScale, 1, 1) : null;
+      const px = x3 > 0 && y3 > 0 ? shadowCtx.getImageData(x3 * pxScale, y3 * pxScale, 1, 1) : null;
       if (px && px.data.length >= 3) {
         const rgb2 = [px.data[0] ?? 0, px.data[1] ?? 0, px.data[2] ?? 0];
         return colorTracker.lookup(rgb2);
       }
       return null;
     } catch (error) {
-      ErrorHandler.logError(error, { x: x2, y: y2 });
+      ErrorHandler.logError(error, { x: x3, y: y3 });
       return null;
     }
   }
@@ -6056,8 +6122,8 @@ var NodesRenderer = class {
   static renderWithOptimizedStates(ctx, nodes, styleResolver, hoveredNodeId, selectedNodeId) {
     try {
       for (const node of nodes) {
-        const x2 = node.x;
-        const y2 = node.y;
+        const x3 = node.x;
+        const y3 = node.y;
         const isHovered = hoveredNodeId === node.id;
         const isSelected = selectedNodeId === node.id;
         const style = styleResolver.resolveNodeStyle({
@@ -6066,7 +6132,7 @@ var NodesRenderer = class {
           isSelected
         });
         ctx.beginPath();
-        ctx.arc(x2, y2, style.radius, 0, 2 * Math.PI);
+        ctx.arc(x3, y3, style.radius, 0, 2 * Math.PI);
         ctx.fillStyle = style.fill;
         ctx.globalAlpha = style.opacity;
         ctx.fill();
@@ -6088,12 +6154,12 @@ var NodesRenderer = class {
   static render(ctx, nodes, nodeStyle, hoverNodeStyle, isNodeHovered) {
     try {
       for (const node of nodes) {
-        const x2 = node.x;
-        const y2 = node.y;
+        const x3 = node.x;
+        const y3 = node.y;
         const isHovered = isNodeHovered(node.id);
         const style = isHovered ? hoverNodeStyle : nodeStyle;
         ctx.beginPath();
-        ctx.arc(x2, y2, style.radius, 0, 2 * Math.PI);
+        ctx.arc(x3, y3, style.radius, 0, 2 * Math.PI);
         ctx.fillStyle = style.fill;
         ctx.globalAlpha = style.opacity;
         ctx.fill();
@@ -6115,8 +6181,8 @@ var NodesRenderer = class {
   static renderWithStyleResolver(ctx, nodes, styleResolver, isNodeHovered, isNodeSelected, performanceMetrics) {
     try {
       for (const node of nodes) {
-        const x2 = node.x;
-        const y2 = node.y;
+        const x3 = node.x;
+        const y3 = node.y;
         const hoverStart = performance.now();
         const isHovered = isNodeHovered(node.id);
         const isSelected = isNodeSelected ? isNodeSelected(node.id) : false;
@@ -6134,7 +6200,7 @@ var NodesRenderer = class {
         }
         const canvasStart = performance.now();
         ctx.beginPath();
-        ctx.arc(x2, y2, style.radius, 0, 2 * Math.PI);
+        ctx.arc(x3, y3, style.radius, 0, 2 * Math.PI);
         ctx.fillStyle = style.fill;
         ctx.globalAlpha = style.opacity;
         ctx.fill();
@@ -6160,14 +6226,14 @@ var NodesRenderer = class {
     try {
       for (const node of nodes) {
         if (!node.__indexColorRGB) continue;
-        const x2 = node.x;
-        const y2 = node.y;
+        const x3 = node.x;
+        const y3 = node.y;
         const [r, g, b] = node.__indexColorRGB;
         const rgbColor = `rgb(${r},${g},${b})`;
         const hitRadius = nodeRadius + 0.5 + 0.1;
         shadowCtx.fillStyle = rgbColor;
         shadowCtx.beginPath();
-        shadowCtx.arc(x2, y2, hitRadius, 0, 2 * Math.PI);
+        shadowCtx.arc(x3, y3, hitRadius, 0, 2 * Math.PI);
         shadowCtx.fill();
       }
     } catch (error) {
@@ -6202,13 +6268,13 @@ var NodeLabelsRenderer = class {
       ctx.textBaseline = resolvedStyle.textBaseline;
       ctx.fillStyle = resolvedStyle.fillStyle;
       for (const node of nodes) {
-        const x2 = node.x;
-        const y2 = node.y;
+        const x3 = node.x;
+        const y3 = node.y;
         const fullLabel = node.label || node.id;
         const maxWidth = nodeRadius * 2 - 6;
         const truncatedLabel = this.truncateLabel(ctx, fullLabel, maxWidth);
-        const labelY = y2 + resolvedStyle.offsetY;
-        ctx.fillText(truncatedLabel, x2, labelY);
+        const labelY = y3 + resolvedStyle.offsetY;
+        ctx.fillText(truncatedLabel, x3, labelY);
       }
     } catch (error) {
       ErrorHandler.logError(error);
@@ -6391,15 +6457,15 @@ var LinkLabelsRenderer = class {
   /**
    * Render a single label at given coordinates
    */
-  static renderSingleLabel(ctx, text, x2, y2, style) {
+  static renderSingleLabel(ctx, text, x3, y3, style) {
     ctx.font = style.font ?? "10px Arial";
     const metrics = ctx.measureText(text);
     const textWidth = metrics.width;
     const textHeight = (metrics.actualBoundingBoxAscent || 10) + (metrics.actualBoundingBoxDescent || 4);
     const rectWidth = textWidth + (style.paddingX ?? 8) * 2;
     const rectHeight = textHeight + (style.paddingY ?? 4) * 2;
-    const rectX = x2 - rectWidth / 2;
-    const rectY = y2 - rectHeight / 2;
+    const rectX = x3 - rectWidth / 2;
+    const rectY = y3 - rectHeight / 2;
     if (style.backgroundColor && style.backgroundColor !== "transparent") {
       ctx.fillStyle = style.backgroundColor;
       this.roundRect(ctx, rectX, rectY, rectWidth, rectHeight, style.borderRadius ?? 4);
@@ -6414,26 +6480,26 @@ var LinkLabelsRenderer = class {
     ctx.fillStyle = style.textColor ?? "#000000";
     ctx.textAlign = "center";
     ctx.textBaseline = "middle";
-    ctx.fillText(text, x2, y2);
+    ctx.fillText(text, x3, y3);
   }
   /**
    * Helper to draw rounded rectangle
    */
-  static roundRect(ctx, x2, y2, width, height, radius) {
+  static roundRect(ctx, x3, y3, width, height, radius) {
     if (radius === 0) {
-      ctx.rect(x2, y2, width, height);
+      ctx.rect(x3, y3, width, height);
       return;
     }
     ctx.beginPath();
-    ctx.moveTo(x2 + radius, y2);
-    ctx.lineTo(x2 + width - radius, y2);
-    ctx.quadraticCurveTo(x2 + width, y2, x2 + width, y2 + radius);
-    ctx.lineTo(x2 + width, y2 + height - radius);
-    ctx.quadraticCurveTo(x2 + width, y2 + height, x2 + width - radius, y2 + height);
-    ctx.lineTo(x2 + radius, y2 + height);
-    ctx.quadraticCurveTo(x2, y2 + height, x2, y2 + height - radius);
-    ctx.lineTo(x2, y2 + radius);
-    ctx.quadraticCurveTo(x2, y2, x2 + radius, y2);
+    ctx.moveTo(x3 + radius, y3);
+    ctx.lineTo(x3 + width - radius, y3);
+    ctx.quadraticCurveTo(x3 + width, y3, x3 + width, y3 + radius);
+    ctx.lineTo(x3 + width, y3 + height - radius);
+    ctx.quadraticCurveTo(x3 + width, y3 + height, x3 + width - radius, y3 + height);
+    ctx.lineTo(x3 + radius, y3 + height);
+    ctx.quadraticCurveTo(x3, y3 + height, x3, y3 + height - radius);
+    ctx.lineTo(x3, y3 + radius);
+    ctx.quadraticCurveTo(x3, y3, x3 + radius, y3);
     ctx.closePath();
   }
   /**
@@ -7074,13 +7140,13 @@ var Renderer = class {
       const arrowTipY = targetPoint.y + arrowLength * Math.sin(angle);
       const x1 = arrowTipX - arrowLength * Math.cos(angle - Math.PI / 6);
       const y1 = arrowTipY - arrowLength * Math.sin(angle - Math.PI / 6);
-      const x2 = arrowTipX - arrowLength * Math.cos(angle + Math.PI / 6);
-      const y2 = arrowTipY - arrowLength * Math.sin(angle + Math.PI / 6);
+      const x22 = arrowTipX - arrowLength * Math.cos(angle + Math.PI / 6);
+      const y22 = arrowTipY - arrowLength * Math.sin(angle + Math.PI / 6);
       ctx.fillStyle = arrowStyle.fill ?? "#000000";
       ctx.beginPath();
       ctx.moveTo(arrowTipX, arrowTipY);
       ctx.lineTo(x1, y1);
-      ctx.lineTo(x2, y2);
+      ctx.lineTo(x22, y22);
       ctx.closePath();
       ctx.fill();
     } catch (error) {
@@ -8489,7 +8555,7 @@ var V2Graph = class {
   /**
    * Draw legend on export canvas
    */
-  drawLegendOnExportCanvas(ctx, legendElement, x2, y2) {
+  drawLegendOnExportCanvas(ctx, legendElement, x3, y3) {
     const legendItems = legendElement.querySelectorAll(".pg-legend-item");
     const padding = 16;
     const itemHeight = 24;
@@ -8499,8 +8565,8 @@ var V2Graph = class {
     ctx.fillStyle = "#ffffff";
     ctx.strokeStyle = "#e2e8f0";
     ctx.lineWidth = 1;
-    ctx.fillRect(x2, y2, legendWidth, legendHeight);
-    ctx.strokeRect(x2, y2, legendWidth, legendHeight);
+    ctx.fillRect(x3, y3, legendWidth, legendHeight);
+    ctx.strokeRect(x3, y3, legendWidth, legendHeight);
     ctx.font = "12px Arial, sans-serif";
     ctx.textAlign = "left";
     ctx.textBaseline = "middle";
@@ -8508,8 +8574,8 @@ var V2Graph = class {
       const swatch = item.querySelector(".pg-legend-swatch");
       const label = item.querySelector(".pg-legend-label");
       if (swatch && label) {
-        const itemY = y2 + padding + index2 * (itemHeight + itemSpacing) + itemHeight / 2;
-        const swatchX = x2 + padding;
+        const itemY = y3 + padding + index2 * (itemHeight + itemSpacing) + itemHeight / 2;
+        const swatchX = x3 + padding;
         const textX = swatchX + 14 + 8;
         const swatchColor = swatch.style.backgroundColor || "#94a3b8";
         ctx.fillStyle = swatchColor;