@graphty/layout 1.2.8 → 1.3.2

package/dist/layout.js

@@ -1,8 +1,12 @@
 function rescaleLayout(pos, scale = 1, center = null) {
   if (Array.isArray(pos)) {
-    if (pos.length === 0) return [];
+    if (pos.length === 0) {
+      return [];
+    }
   } else {
-    if (Object.keys(pos).length === 0) return {};
+    if (Object.keys(pos).length === 0) {
+      return {};
+    }
   }
   const posValues = Array.isArray(pos) ? pos : Object.values(pos);
   const dim = posValues[0].length;
@@ -65,7 +69,9 @@ function rescaleLayout(pos, scale = 1, center = null) {
           if (i >= origPos.length) {
             return center[i];
           }
-          if (isNaN(val)) return NaN;
+          if (isNaN(val)) {
+            return NaN;
+          }
           return val * scaleFactor + center[i];
         })
       );
@@ -76,7 +82,9 @@ function rescaleLayout(pos, scale = 1, center = null) {
           if (i >= origPos.length) {
             return center[i];
           }
-          if (isNaN(val)) return NaN;
+          if (isNaN(val)) {
+            return NaN;
+          }
           return val * scaleFactor + center[i];
         });
       }
@@ -140,15 +148,6 @@ function rescaleLayoutDict(pos, scale = 1) {
   }
   return scaledPos;
 }
-function _processParams(G, center, dim) {
-  if (!center) {
-    center = Array(dim).fill(0);
-  }
-  if (center.length !== dim) {
-    throw new Error("length of center coordinates must match dimension of layout");
-  }
-  return { G, center };
-}
 function getNodesFromGraph(G) {
   if (Array.isArray(G)) {
     return G;
@@ -162,7 +161,9 @@ function getEdgesFromGraph(G) {
   return G.edges();
 }
 function getNeighbors(graph, node) {
-  if (!graph.edges) return [];
+  if (!graph.edges) {
+    return [];
+  }
   const neighbors = /* @__PURE__ */ new Set();
   const edges = graph.edges();
   for (const [source, target] of edges) {
@@ -174,7 +175,20 @@ function getNeighbors(graph, node) {
   }
   return Array.from(neighbors);
 }
+function _processParams(G, center, dim) {
+  if (!center) {
+    center = Array(dim).fill(0);
+  }
+  if (center.length !== dim) {
+    throw new Error("length of center coordinates must match dimension of layout");
+  }
+  return { G, center };
+}
 class RandomNumberGenerator {
+  /**
+   * Creates a new random number generator instance.
+   * @param seed - Initial seed value for the generator. If not provided, uses a random seed.
+   */
   constructor(seed) {
     this.seed = seed || Math.floor(Math.random() * 1e6);
     this.m = 2 ** 35 - 31;
@@ -182,10 +196,19 @@ class RandomNumberGenerator {
     this.c = 1;
     this._state = this.seed % this.m;
   }
+  /**
+   * Generates the next random number in the sequence.
+   * @returns A random number between 0 and 1.
+   */
   _next() {
     this._state = (this.a * this._state + this.c) % this.m;
     return this._state / this.m;
   }
+  /**
+   * Generates random numbers according to the specified shape.
+   * @param shape - Determines the output format: null for single number, number for 1D array, array for multi-dimensional array.
+   * @returns A random number, 1D array, or multi-dimensional array depending on the shape parameter.
+   */
   rand(shape = null) {
     if (shape === null) {
       return this._next();
@@ -222,235 +245,354 @@ function randomLayout(G, center = null, dim = 2, seed = null) {
   });
   return pos;
 }
-const np = {
-  zeros: function(shape) {
-    if (typeof shape === "number") {
-      return Array(shape).fill(0);
+function arfLayout(G, pos = null, scaling = 1, a = 1.1, maxIter = 1e3, seed = null) {
+  if (a <= 1) {
+    throw new Error("The parameter a should be larger than 1");
+  }
+  const nodes = getNodesFromGraph(G);
+  const edges = getEdgesFromGraph(G);
+  if (nodes.length === 0) {
+    return {};
+  }
+  if (!pos) {
+    pos = randomLayout(G, null, 2, seed);
+  } else {
+    const rng = new RandomNumberGenerator(seed ?? void 0);
+    const defaultPos = {};
+    nodes.forEach((node) => {
+      if (!pos[node]) {
+        defaultPos[node] = [rng.rand(), rng.rand()];
+      }
+    });
+    pos = { ...pos, ...defaultPos };
+  }
+  const nodeIndex = {};
+  nodes.forEach((node, i) => {
+    nodeIndex[node] = i;
+  });
+  const positions = nodes.map((node) => [...pos[node]]);
+  const N = nodes.length;
+  const K = Array(N).fill(0).map(() => Array(N).fill(1));
+  for (let i = 0; i < N; i++) {
+    K[i][i] = 0;
+  }
+  for (const [source, target] of edges) {
+    if (source === target) {
+      continue;
     }
-    if (shape.length === 1) {
-      return Array(shape[0]).fill(0);
+    const i = nodeIndex[source];
+    const j = nodeIndex[target];
+    K[i][j] = a;
+    K[j][i] = a;
+  }
+  const rho = scaling * Math.sqrt(N);
+  const dt = 1e-3;
+  const etol = 1e-6;
+  let error = etol + 1;
+  let nIter = 0;
+  while (error > etol && nIter < maxIter) {
+    const change = Array(N).fill(0).map(() => [0, 0]);
+    for (let i = 0; i < N; i++) {
+      for (let j = 0; j < N; j++) {
+        if (i === j) {
+          continue;
+        }
+        const diff = positions[i].map((coord, dim) => coord - positions[j][dim]);
+        const dist = Math.sqrt(diff.reduce((sum, d) => sum + d * d, 0)) || 0.01;
+        for (let d = 0; d < diff.length; d++) {
+          change[i][d] += K[i][j] * diff[d] - rho / dist * diff[d];
+        }
+      }
     }
-    return Array(shape[0]).fill(0).map(() => this.zeros(shape.slice(1)));
-  },
-  ones: function(shape) {
-    if (typeof shape === "number") {
-      return Array(shape).fill(1);
+    for (let i = 0; i < N; i++) {
+      for (let d = 0; d < positions[i].length; d++) {
+        positions[i][d] += change[i][d] * dt;
+      }
     }
-    if (shape.length === 1) {
-      return Array(shape[0]).fill(1);
+    error = change.reduce((sum, c) => sum + Math.sqrt(c.reduce((s, v) => s + v * v, 0)), 0);
+    nIter++;
+  }
+  const finalPos = {};
+  nodes.forEach((node, i) => {
+    finalPos[node] = positions[i];
+  });
+  return finalPos;
+}
+function forceatlas2Layout(G, pos = null, maxIter = 100, jitterTolerance = 1, scalingRatio = 2, gravity = 1, distributedAction = false, strongGravity = false, nodeMass = null, nodeSize = null, weight = null, dissuadeHubs = false, linlog = false, seed = null, dim = 2) {
+  const processed = _processParams(G, null, dim);
+  const graph = processed.G;
+  const nodes = getNodesFromGraph(graph);
+  if (nodes.length === 0) {
+    return {};
+  }
+  const rng = new RandomNumberGenerator(seed ?? void 0);
+  let posArray;
+  if (pos === null) {
+    pos = {};
+    posArray = new Array(nodes.length);
+    for (let i = 0; i < nodes.length; i++) {
+      posArray[i] = Array(dim).fill(0).map(() => rng.rand() * 2 - 1);
+      pos[nodes[i]] = posArray[i];
     }
-    return Array(shape[0]).fill(1).map(() => this.ones(shape.slice(1)));
-  },
-  linspace: function(start, stop, num) {
-    if (num === 1) {
-      return [start];
+  } else if (Object.keys(pos).length === nodes.length) {
+    posArray = new Array(nodes.length);
+    for (let i = 0; i < nodes.length; i++) {
+      const nodePos = pos[nodes[i]];
+      posArray[i] = new Array(dim);
+      for (let d = 0; d < dim; d++) {
+        posArray[i][d] = d < nodePos.length ? nodePos[d] : rng.rand() * 2 - 1;
+      }
     }
-    const step = (stop - start) / (num - 1);
-    return Array.from({ length: num }, (_, i) => start + i * step);
-  },
-  array: function(arr) {
-    return Array.isArray(arr) ? [...arr] : [arr];
-  },
-  repeat: function(a, repeats) {
-    const result = [];
-    for (let i = 0; i < repeats; i++) {
-      result.push(...np.array(a));
+  } else {
+    const minPos = Array(dim).fill(Number.POSITIVE_INFINITY);
+    const maxPos = Array(dim).fill(Number.NEGATIVE_INFINITY);
+    for (const node in pos) {
+      const nodePos = pos[node];
+      for (let d = 0; d < dim; d++) {
+        if (d < nodePos.length) {
+          minPos[d] = Math.min(minPos[d], nodePos[d]);
+          maxPos[d] = Math.max(maxPos[d], nodePos[d]);
+        }
+      }
     }
-    return result;
-  },
-  mean: function(arr, axis = null) {
-    if (axis === null) {
-      const flatArr = Array.isArray(arr[0]) ? arr.flat(Infinity) : arr;
-      const sum = flatArr.reduce((a, b) => a + b, 0);
-      return sum / flatArr.length;
+    for (let d = 0; d < dim; d++) {
+      if (!isFinite(minPos[d]) || !isFinite(maxPos[d])) {
+        minPos[d] = -1;
+        maxPos[d] = 1;
+      }
     }
-    if (axis === 0) {
-      const result = [];
-      const matrix = arr;
-      for (let i = 0; i < matrix[0].length; i++) {
-        let sum = 0;
-        for (let j = 0; j < matrix.length; j++) {
-          sum += matrix[j][i];
+    posArray = new Array(nodes.length);
+    for (let i = 0; i < nodes.length; i++) {
+      const node = nodes[i];
+      if (pos[node]) {
+        const nodePos = pos[node];
+        posArray[i] = new Array(dim);
+        for (let d = 0; d < dim; d++) {
+          posArray[i][d] = d < nodePos.length ? nodePos[d] : rng.rand() * 2 - 1;
         }
-        result.push(sum / matrix.length);
+      } else {
+        posArray[i] = Array(dim).fill(0).map((_, d) => minPos[d] + rng.rand() * (maxPos[d] - minPos[d]));
+        pos[node] = posArray[i];
       }
-      return result;
     }
-    return arr.map((row) => np.mean(row));
-  },
-  add: function(a, b) {
-    if (!Array.isArray(a) && !Array.isArray(b)) {
-      return a + b;
+  }
+  const mass = new Array(nodes.length).fill(0);
+  const size = new Array(nodes.length).fill(0);
+  const adjustSizes = nodeSize !== null;
+  for (let i = 0; i < nodes.length; i++) {
+    const node = nodes[i];
+    mass[i] = nodeMass && nodeMass[node] ? nodeMass[node] : Array.isArray(graph) ? 1 : getNodeDegree(graph, node) + 1;
+    size[i] = nodeSize && nodeSize[node] ? nodeSize[node] : 1;
+  }
+  const n = nodes.length;
+  const A = Array(n).fill(0).map(() => Array(n).fill(0));
+  const edges = Array.isArray(graph) ? [] : graph.edges();
+  const nodeIndices = {};
+  nodes.forEach((node, i) => {
+    nodeIndices[node] = i;
+  });
+  for (const [source, target] of edges) {
+    const i = nodeIndices[source];
+    const j = nodeIndices[target];
+    let edgeWeight = 1;
+    if (weight && !Array.isArray(graph) && graph.getEdgeData) {
+      edgeWeight = graph.getEdgeData(source, target, weight) || 1;
     }
-    if (!Array.isArray(a)) {
-      return b.map((val) => a + val);
+    A[i][j] = edgeWeight;
+    A[j][i] = edgeWeight;
+  }
+  const gravities = Array(n).fill(0).map(() => Array(dim).fill(0));
+  const attraction = Array(n).fill(0).map(() => Array(dim).fill(0));
+  const repulsion = Array(n).fill(0).map(() => Array(dim).fill(0));
+  let speed = 1;
+  let speedEfficiency = 1;
+  function estimateFactor(n2, swing2, traction2, speed2, speedEfficiency2, jitterTolerance2) {
+    const optJitter = 0.05 * Math.sqrt(n2);
+    const minJitter = Math.sqrt(optJitter);
+    const maxJitter = 10;
+    const minSpeedEfficiency = 0.05;
+    const other = Math.min(maxJitter, optJitter * traction2 / (n2 * n2));
+    let jitter = jitterTolerance2 * Math.max(minJitter, other);
+    if (swing2 / traction2 > 2) {
+      if (speedEfficiency2 > minSpeedEfficiency) {
+        speedEfficiency2 *= 0.5;
+      }
+      jitter = Math.max(jitter, jitterTolerance2);
     }
-    if (!Array.isArray(b)) {
-      return a.map((val) => val + b);
+    const targetSpeed = swing2 === 0 ? Number.POSITIVE_INFINITY : jitter * speedEfficiency2 * traction2 / swing2;
+    if (swing2 > jitter * traction2) {
+      if (speedEfficiency2 > minSpeedEfficiency) {
+        speedEfficiency2 *= 0.7;
+      }
+    } else if (speed2 < 1e3) {
+      speedEfficiency2 *= 1.3;
     }
-    return a.map((val, i) => val + b[i]);
-  },
-  subtract: function(a, b) {
-    if (!Array.isArray(a) && !Array.isArray(b)) {
-      return a - b;
+    const maxRise = 0.5;
+    speed2 = speed2 + Math.min(targetSpeed - speed2, maxRise * speed2);
+    return [speed2, speedEfficiency2];
+  }
+  for (let iter = 0; iter < maxIter; iter++) {
+    for (let i = 0; i < n; i++) {
+      for (let d = 0; d < dim; d++) {
+        attraction[i][d] = 0;
+        repulsion[i][d] = 0;
+        gravities[i][d] = 0;
+      }
     }
-    if (!Array.isArray(a)) {
-      return b.map((val) => a - val);
+    const diff = Array(n).fill(0).map(
+      () => Array(n).fill(0).map(() => Array(dim).fill(0))
+    );
+    const distance = Array(n).fill(0).map(() => Array(n).fill(0));
+    for (let i = 0; i < n; i++) {
+      for (let j = 0; j < n; j++) {
+        if (i === j) {
+          continue;
+        }
+        for (let d = 0; d < dim; d++) {
+          diff[i][j][d] = posArray[i][d] - posArray[j][d];
+        }
+        distance[i][j] = Math.sqrt(diff[i][j].reduce((sum, d) => sum + d * d, 0));
+        if (distance[i][j] < 0.01) {
+          distance[i][j] = 0.01;
+        }
+      }
     }
-    if (!Array.isArray(b)) {
-      return a.map((val) => val - b);
+    if (linlog) {
+      for (let i = 0; i < n; i++) {
+        for (let j = 0; j < n; j++) {
+          if (i === j || A[i][j] === 0) {
+            continue;
+          }
+          const dist = distance[i][j];
+          const factor = -Math.log(1 + dist) / dist * A[i][j];
+          for (let d = 0; d < dim; d++) {
+            const force = factor * diff[i][j][d];
+            attraction[i][d] += force;
+          }
+        }
+      }
+    } else {
+      for (let i = 0; i < n; i++) {
+        for (let j = 0; j < n; j++) {
+          if (i === j || A[i][j] === 0) {
+            continue;
+          }
+          for (let d = 0; d < dim; d++) {
+            const force = -diff[i][j][d] * A[i][j];
+            attraction[i][d] += force;
+          }
+        }
+      }
     }
-    return a.map((val, i) => val - b[i]);
-  },
-  max: function(arr) {
-    if (!Array.isArray(arr)) return arr;
-    return Math.max(...arr.flat(Infinity));
-  },
-  min: function(arr) {
-    if (!Array.isArray(arr)) return arr;
-    return Math.min(...arr.flat(Infinity));
-  },
-  norm: function(arr) {
-    return Math.sqrt(arr.reduce((sum, val) => sum + val * val, 0));
-  }
-};
-function circularLayout(G, scale = 1, center = null, dim = 2) {
-  if (dim < 2) {
-    throw new Error("cannot handle dimensions < 2");
-  }
-  const processed = _processParams(G, center, dim);
-  const nodes = getNodesFromGraph(processed.G);
-  center = processed.center;
-  const pos = {};
-  if (nodes.length === 0) {
-    return pos;
-  }
-  if (nodes.length === 1) {
-    pos[nodes[0]] = center;
-    return pos;
-  }
-  if (dim === 2) {
-    const theta = np.linspace(0, 2 * Math.PI, nodes.length + 1).slice(0, -1);
-    nodes.forEach((node, i) => {
-      const x = Math.cos(theta[i]) * scale + center[0];
-      const y = Math.sin(theta[i]) * scale + center[1];
-      pos[node] = [x, y];
-    });
-  } else if (dim === 3) {
-    const n = nodes.length;
-    const goldenRatio = (1 + Math.sqrt(5)) / 2;
-    nodes.forEach((node, i) => {
-      const theta = 2 * Math.PI * i / goldenRatio;
-      const phi = Math.acos(1 - 2 * (i + 0.5) / n);
-      const x = Math.sin(phi) * Math.cos(theta) * scale + center[0];
-      const y = Math.sin(phi) * Math.sin(theta) * scale + center[1];
-      const z = Math.cos(phi) * scale + center[2];
-      pos[node] = [x, y, z];
-    });
-  } else {
-    const rng = new RandomNumberGenerator();
-    nodes.forEach((node) => {
-      const coords = Array(dim).fill(0).map(() => rng.rand() * 2 - 1);
-      const norm = Math.sqrt(coords.reduce((sum, c) => sum + c * c, 0));
-      pos[node] = coords.map((c, j) => c / norm * scale + center[j]);
-    });
-  }
-  return pos;
-}
-function shellLayout(G, nlist = null, scale = 1, center = null, dim = 2) {
-  if (dim !== 2) {
-    throw new Error("can only handle 2 dimensions");
-  }
-  const processed = _processParams(G, center, dim);
-  const nodes = getNodesFromGraph(processed.G);
-  center = processed.center;
-  const pos = {};
-  if (nodes.length === 0) {
-    return pos;
-  }
-  if (nodes.length === 1) {
-    pos[nodes[0]] = center;
-    return pos;
-  }
-  if (!nlist) {
-    nlist = [nodes];
-  }
-  const radiusBump = scale / nlist.length;
-  let radius;
-  if (nlist[0].length === 1) {
-    radius = 0;
-    pos[nlist[0][0]] = [...center];
-    radius += radiusBump;
-  } else {
-    radius = radiusBump;
-  }
-  for (let i = 0; i < nlist.length; i++) {
-    const shell = nlist[i];
-    if (shell.length === 0) continue;
-    if (shell.length === 1 && i === 0) {
-      continue;
+    if (distributedAction) {
+      for (let i = 0; i < n; i++) {
+        for (let d = 0; d < dim; d++) {
+          attraction[i][d] /= mass[i];
+        }
+      }
     }
-    const theta = np.linspace(0, 2 * Math.PI, shell.length + 1).slice(0, -1);
-    shell.forEach((node, j) => {
-      const x = Math.cos(theta[j]) * radius + center[0];
-      const y = Math.sin(theta[j]) * radius + center[1];
-      pos[node] = [x, y];
-    });
-    radius += radiusBump;
-  }
-  return pos;
-}
-function spiralLayout(G, scale = 1, center = null, dim = 2, resolution = 0.35, equidistant = false) {
-  if (dim !== 2) {
-    throw new Error("can only handle 2 dimensions");
-  }
-  const processed = _processParams(G, center || [0, 0], dim);
-  const nodes = getNodesFromGraph(processed.G);
-  center = processed.center;
-  const pos = {};
-  if (nodes.length === 0) {
-    return pos;
-  }
-  if (nodes.length === 1) {
-    pos[nodes[0]] = [...center];
-    return pos;
-  }
-  let positions = [];
-  if (equidistant) {
-    const chord = 1;
-    const step = 0.5;
-    let theta = resolution;
-    theta += chord / (step * theta);
-    for (let i = 0; i < nodes.length; i++) {
-      const r = step * theta;
-      theta += chord / r;
-      positions.push([Math.cos(theta) * r, Math.sin(theta) * r]);
+    for (let i = 0; i < n; i++) {
+      for (let j = 0; j < n; j++) {
+        if (i === j) {
+          continue;
+        }
+        let dist = distance[i][j];
+        if (adjustSizes) {
+          dist -= size[i] - size[j];
+          dist = Math.max(dist, 0.01);
+        }
+        const distSquared = dist * dist;
+        const massProduct = mass[i] * mass[j];
+        const factor = massProduct / distSquared * scalingRatio;
+        for (let d = 0; d < dim; d++) {
+          const direction = diff[i][j][d] / dist;
+          repulsion[i][d] += direction * factor;
+        }
+      }
+    }
+    const centerOfMass = Array(dim).fill(0);
+    for (let i = 0; i < n; i++) {
+      for (let d = 0; d < dim; d++) {
+        centerOfMass[d] += posArray[i][d] / n;
+      }
+    }
+    for (let i = 0; i < n; i++) {
+      const posCentered = Array(dim);
+      for (let d = 0; d < dim; d++) {
+        posCentered[d] = posArray[i][d] - centerOfMass[d];
+      }
+      if (strongGravity) {
+        for (let d = 0; d < dim; d++) {
+          gravities[i][d] = -gravity * mass[i] * posCentered[d];
+        }
+      } else {
+        const dist = Math.sqrt(posCentered.reduce((sum, val) => sum + val * val, 0));
+        if (dist > 0.01) {
+          for (let d = 0; d < dim; d++) {
+            const direction = posCentered[d] / dist;
+            gravities[i][d] = -gravity * mass[i] * direction;
+          }
+        }
+      }
+    }
+    const update = Array(n).fill(0).map(() => Array(dim).fill(0));
+    let totalSwing = 0;
+    let totalTraction = 0;
+    for (let i = 0; i < n; i++) {
+      for (let d = 0; d < dim; d++) {
+        update[i][d] = attraction[i][d] + repulsion[i][d] + gravities[i][d];
+      }
+      const oldPos = [...posArray[i]];
+      const newPos = oldPos.map((p, d) => p + update[i][d]);
+      const swingVector = oldPos.map((p, d) => p - newPos[d]);
+      const tractionVector = oldPos.map((p, d) => p + newPos[d]);
+      const swingMagnitude = Math.sqrt(swingVector.reduce((sum, val) => sum + val * val, 0));
+      const tractionMagnitude = Math.sqrt(tractionVector.reduce((sum, val) => sum + val * val, 0));
+      totalSwing += mass[i] * swingMagnitude;
+      totalTraction += 0.5 * mass[i] * tractionMagnitude;
+    }
+    [speed, speedEfficiency] = estimateFactor(
+      n,
+      totalSwing,
+      totalTraction,
+      speed,
+      speedEfficiency,
+      jitterTolerance
+    );
+    let totalMovement = 0;
+    for (let i = 0; i < n; i++) {
+      let factor;
+      if (adjustSizes) {
+        const df = Math.sqrt(update[i].reduce((sum, val) => sum + val * val, 0));
+        const swinging = mass[i] * df;
+        factor = 0.1 * speed / (1 + Math.sqrt(speed * swinging));
+        factor = Math.min(factor * df, 10) / df;
+      } else {
+        const swinging = mass[i] * Math.sqrt(update[i].reduce((sum, val) => sum + val * val, 0));
+        factor = speed / (1 + Math.sqrt(speed * swinging));
+      }
+      for (let d = 0; d < dim; d++) {
+        const movement = update[i][d] * factor;
+        posArray[i][d] += movement;
+        totalMovement += Math.abs(movement);
+      }
+    }
+    if (totalMovement < 1e-10) {
+      break;
     }
-  } else {
-    const dist = Array.from({ length: nodes.length }, (_, i) => parseFloat(String(i)));
-    const angle = dist.map((d) => resolution * d);
-    positions = dist.map((d, i) => [
-      Math.cos(angle[i]) * d,
-      Math.sin(angle[i]) * d
-    ]);
-  }
-  const posArray = [];
-  for (let i = 0; i < positions.length; i++) {
-    posArray.push(positions[i]);
-  }
-  const scaledPositions = rescaleLayout(posArray, scale);
-  for (let i = 0; i < scaledPositions.length; i++) {
-    scaledPositions[i][0] += center[0];
-    scaledPositions[i][1] += center[1];
   }
-  for (let i = 0; i < nodes.length; i++) {
-    pos[nodes[i]] = scaledPositions[i];
+  const positions = {};
+  for (let i = 0; i < n; i++) {
+    positions[nodes[i]] = posArray[i];
   }
-  return pos;
+  return rescaleLayout(positions);
+}
+function getNodeDegree(graph, node) {
+  return graph.edges().filter((edge) => edge[0] === node || edge[1] === node).length;
 }
 function fruchtermanReingoldLayout(G, k = null, pos = null, fixed = null, iterations = 50, scale = 1, center = null, dim = 2, seed = null) {
   const processed = _processParams(G, center, dim);
-  let graph = processed.G;
+  const graph = processed.G;
   center = processed.center;
   const nodes = getNodesFromGraph(graph);
   const edges = getEdgesFromGraph(graph);
@@ -514,7 +656,9 @@ function fruchtermanReingoldLayout(G, k = null, pos = null, fixed = null, iterat
       }
     }
     for (const node of nodes) {
-      if (fixedNodes.has(node)) continue;
+      if (fixedNodes.has(node)) {
+        continue;
+      }
       const magnitude = Math.sqrt(displacement[node].reduce((sum, d) => sum + d * d, 0));
       const limitedMagnitude = Math.min(magnitude, t);
       for (let j = 0; j < dim; j++) {
@@ -529,9 +673,6 @@ function fruchtermanReingoldLayout(G, k = null, pos = null, fixed = null, iterat
   }
   return positions;
 }
-function springLayout(G, k = null, pos = null, fixed = null, iterations = 50, scale = 1, center = null, dim = 2, seed = null) {
-  return fruchtermanReingoldLayout(G, k, pos, fixed, iterations, scale, center, dim, seed);
-}
 function _lbfgsDirection(grad, sList, yList, m) {
   if (sList.length === 0) {
     return grad.map((g) => -g);
@@ -622,10 +763,8 @@ function _computeShortestPathDistances(G, weight) {
 function _kamadaKawaiSolve(distMatrix, positions, dim) {
   const nNodes = positions.length;
   const meanWeight = 1e-3;
-  const invDistMatrix = distMatrix.map(
-    (row) => row.map((d) => d === 0 ? 0 : 1 / (d + 1e-3))
-  );
-  let posVec = positions.flat();
+  const invDistMatrix = distMatrix.map((row) => row.map((d) => d === 0 ? 0 : 1 / (d + 1e-3)));
+  const posVec = positions.flat();
   const maxIter = 500;
   const gtol = 1e-5;
   const m = 10;
@@ -710,443 +849,296 @@ function _kamadaKawaiCostfn(posVec, invDist, meanWeight, dim) {
   }
   return [cost, grad];
 }
-function kamadaKawaiLayout(G, dist = null, pos = null, weight = "weight", scale = 1, center = null, dim = 2) {
-  const processed = _processParams(G, center, dim);
-  const graph = processed.G;
-  center = processed.center;
-  const nodes = getNodesFromGraph(graph);
-  if (nodes.length === 0) {
-    return {};
-  }
-  if (nodes.length === 1) {
-    return { [nodes[0]]: center };
-  }
-  if (!dist) {
-    if (Array.isArray(graph)) {
-      throw new Error("Kamada-Kawai layout requires a Graph with edges, not just a list of nodes");
-    }
-    dist = _computeShortestPathDistances(graph, weight);
-  }
-  const nodesArray = Array.from(nodes);
-  const nNodes = nodesArray.length;
-  const distMatrix = Array(nNodes).fill(0).map(() => Array(nNodes).fill(1e6));
-  for (let i = 0; i < nNodes; i++) {
-    const nodeI = nodesArray[i];
-    distMatrix[i][i] = 0;
-    if (!dist[nodeI]) continue;
-    for (let j = 0; j < nNodes; j++) {
-      const nodeJ = nodesArray[j];
-      if (dist[nodeI][nodeJ] !== void 0) {
-        distMatrix[i][j] = dist[nodeI][nodeJ];
-      }
-    }
-  }
-  if (!pos) {
-    if (dim >= 2) {
-      pos = circularLayout(G, 1, center, dim);
-    } else {
-      const posArray2 = {};
-      nodesArray.forEach((node, i) => {
-        posArray2[node] = [i / (nNodes - 1 || 1)];
-      });
-      pos = posArray2;
-    }
-  }
-  const posArray = new Array(nNodes);
-  for (let i = 0; i < nNodes; i++) {
-    const node = nodesArray[i];
-    posArray[i] = pos[node] ? [...pos[node]] : Array(dim).fill(0);
-    while (posArray[i].length < dim) {
-      posArray[i].push(0);
-    }
-  }
-  const newPositions = _kamadaKawaiSolve(distMatrix, posArray, dim);
-  const finalPos = {};
-  for (let i = 0; i < nNodes; i++) {
-    finalPos[nodesArray[i]] = newPositions[i];
-  }
-  return rescaleLayout(finalPos, scale, center);
-}
-function forceatlas2Layout(G, pos = null, maxIter = 100, jitterTolerance = 1, scalingRatio = 2, gravity = 1, distributedAction = false, strongGravity = false, nodeMass = null, nodeSize = null, weight = null, dissuadeHubs = false, linlog = false, seed = null, dim = 2) {
-  const processed = _processParams(G, null, dim);
-  const graph = processed.G;
-  const nodes = getNodesFromGraph(graph);
-  if (nodes.length === 0) {
-    return {};
-  }
-  const rng = new RandomNumberGenerator(seed ?? void 0);
-  let posArray;
-  if (pos === null) {
-    pos = {};
-    posArray = new Array(nodes.length);
-    for (let i = 0; i < nodes.length; i++) {
-      posArray[i] = Array(dim).fill(0).map(() => rng.rand() * 2 - 1);
-      pos[nodes[i]] = posArray[i];
-    }
-  } else if (Object.keys(pos).length === nodes.length) {
-    posArray = new Array(nodes.length);
-    for (let i = 0; i < nodes.length; i++) {
-      const nodePos = pos[nodes[i]];
-      posArray[i] = new Array(dim);
-      for (let d = 0; d < dim; d++) {
-        posArray[i][d] = d < nodePos.length ? nodePos[d] : rng.rand() * 2 - 1;
-      }
-    }
-  } else {
-    let minPos = Array(dim).fill(Number.POSITIVE_INFINITY);
-    let maxPos = Array(dim).fill(Number.NEGATIVE_INFINITY);
-    for (const node in pos) {
-      const nodePos = pos[node];
-      for (let d = 0; d < dim; d++) {
-        if (d < nodePos.length) {
-          minPos[d] = Math.min(minPos[d], nodePos[d]);
-          maxPos[d] = Math.max(maxPos[d], nodePos[d]);
-        }
-      }
-    }
-    for (let d = 0; d < dim; d++) {
-      if (!isFinite(minPos[d]) || !isFinite(maxPos[d])) {
-        minPos[d] = -1;
-        maxPos[d] = 1;
-      }
-    }
-    posArray = new Array(nodes.length);
-    for (let i = 0; i < nodes.length; i++) {
-      const node = nodes[i];
-      if (pos[node]) {
-        const nodePos = pos[node];
-        posArray[i] = new Array(dim);
-        for (let d = 0; d < dim; d++) {
-          posArray[i][d] = d < nodePos.length ? nodePos[d] : rng.rand() * 2 - 1;
-        }
-      } else {
-        posArray[i] = Array(dim).fill(0).map(
-          (_, d) => minPos[d] + rng.rand() * (maxPos[d] - minPos[d])
-        );
-        pos[node] = posArray[i];
-      }
+const np = {
+  zeros: function(shape) {
+    if (typeof shape === "number") {
+      return Array(shape).fill(0);
     }
-  }
-  const mass = new Array(nodes.length).fill(0);
-  const size = new Array(nodes.length).fill(0);
-  const adjustSizes = nodeSize !== null;
-  for (let i = 0; i < nodes.length; i++) {
-    const node = nodes[i];
-    mass[i] = nodeMass && nodeMass[node] ? nodeMass[node] : Array.isArray(graph) ? 1 : getNodeDegree(graph, node) + 1;
-    size[i] = nodeSize && nodeSize[node] ? nodeSize[node] : 1;
-  }
-  const n = nodes.length;
-  const A = Array(n).fill(0).map(() => Array(n).fill(0));
-  const edges = Array.isArray(graph) ? [] : graph.edges();
-  const nodeIndices = {};
-  nodes.forEach((node, i) => {
-    nodeIndices[node] = i;
-  });
-  for (const [source, target] of edges) {
-    const i = nodeIndices[source];
-    const j = nodeIndices[target];
-    let edgeWeight = 1;
-    if (weight && !Array.isArray(graph) && graph.getEdgeData) {
-      edgeWeight = graph.getEdgeData(source, target, weight) || 1;
+    if (shape.length === 1) {
+      return Array(shape[0]).fill(0);
     }
-    A[i][j] = edgeWeight;
-    A[j][i] = edgeWeight;
-  }
-  const gravities = Array(n).fill(0).map(() => Array(dim).fill(0));
-  const attraction = Array(n).fill(0).map(() => Array(dim).fill(0));
-  const repulsion = Array(n).fill(0).map(() => Array(dim).fill(0));
-  let speed = 1;
-  let speedEfficiency = 1;
-  function estimateFactor(n2, swing2, traction2, speed2, speedEfficiency2, jitterTolerance2) {
-    const optJitter = 0.05 * Math.sqrt(n2);
-    const minJitter = Math.sqrt(optJitter);
-    const maxJitter = 10;
-    const minSpeedEfficiency = 0.05;
-    const other = Math.min(maxJitter, optJitter * traction2 / (n2 * n2));
-    let jitter = jitterTolerance2 * Math.max(minJitter, other);
-    if (swing2 / traction2 > 2) {
-      if (speedEfficiency2 > minSpeedEfficiency) {
-        speedEfficiency2 *= 0.5;
-      }
-      jitter = Math.max(jitter, jitterTolerance2);
+    return Array(shape[0]).fill(0).map(() => this.zeros(shape.slice(1)));
+  },
+  ones: function(shape) {
+    if (typeof shape === "number") {
+      return Array(shape).fill(1);
     }
-    let targetSpeed = swing2 === 0 ? Number.POSITIVE_INFINITY : jitter * speedEfficiency2 * traction2 / swing2;
-    if (swing2 > jitter * traction2) {
-      if (speedEfficiency2 > minSpeedEfficiency) {
-        speedEfficiency2 *= 0.7;
-      }
-    } else if (speed2 < 1e3) {
-      speedEfficiency2 *= 1.3;
+    if (shape.length === 1) {
+      return Array(shape[0]).fill(1);
     }
-    const maxRise = 0.5;
-    speed2 = speed2 + Math.min(targetSpeed - speed2, maxRise * speed2);
-    return [speed2, speedEfficiency2];
-  }
-  for (let iter = 0; iter < maxIter; iter++) {
-    for (let i = 0; i < n; i++) {
-      for (let d = 0; d < dim; d++) {
-        attraction[i][d] = 0;
-        repulsion[i][d] = 0;
-        gravities[i][d] = 0;
-      }
+    return Array(shape[0]).fill(1).map(() => this.ones(shape.slice(1)));
+  },
+  linspace: function(start, stop, num) {
+    if (num === 1) {
+      return [start];
     }
-    const diff = Array(n).fill(0).map(
-      () => Array(n).fill(0).map(() => Array(dim).fill(0))
-    );
-    const distance = Array(n).fill(0).map(() => Array(n).fill(0));
-    for (let i = 0; i < n; i++) {
-      for (let j = 0; j < n; j++) {
-        if (i === j) continue;
-        for (let d = 0; d < dim; d++) {
-          diff[i][j][d] = posArray[i][d] - posArray[j][d];
-        }
-        distance[i][j] = Math.sqrt(diff[i][j].reduce((sum, d) => sum + d * d, 0));
-        if (distance[i][j] < 0.01) distance[i][j] = 0.01;
-      }
+    const step = (stop - start) / (num - 1);
+    return Array.from({ length: num }, (_, i) => start + i * step);
+  },
+  array: function(arr) {
+    return Array.isArray(arr) ? [...arr] : [arr];
+  },
+  repeat: function(a, repeats) {
+    const result = [];
+    for (let i = 0; i < repeats; i++) {
+      result.push(...np.array(a));
     }
-    if (linlog) {
-      for (let i = 0; i < n; i++) {
-        for (let j = 0; j < n; j++) {
-          if (i === j || A[i][j] === 0) continue;
-          const dist = distance[i][j];
-          const factor = -Math.log(1 + dist) / dist * A[i][j];
-          for (let d = 0; d < dim; d++) {
-            const force = factor * diff[i][j][d];
-            attraction[i][d] += force;
-          }
-        }
-      }
-    } else {
-      for (let i = 0; i < n; i++) {
-        for (let j = 0; j < n; j++) {
-          if (i === j || A[i][j] === 0) continue;
-          for (let d = 0; d < dim; d++) {
-            const force = -diff[i][j][d] * A[i][j];
-            attraction[i][d] += force;
-          }
-        }
-      }
+    return result;
+  },
+  mean: function(arr, axis = null) {
+    if (axis === null) {
+      const flatArr = Array.isArray(arr[0]) ? arr.flat(Infinity) : arr;
+      const sum = flatArr.reduce((a, b) => a + b, 0);
+      return sum / flatArr.length;
     }
-    if (distributedAction) {
-      for (let i = 0; i < n; i++) {
-        for (let d = 0; d < dim; d++) {
-          attraction[i][d] /= mass[i];
+    if (axis === 0) {
+      const result = [];
+      const matrix = arr;
+      for (let i = 0; i < matrix[0].length; i++) {
+        let sum = 0;
+        for (let j = 0; j < matrix.length; j++) {
+          sum += matrix[j][i];
         }
+        result.push(sum / matrix.length);
       }
+      return result;
     }
-    for (let i = 0; i < n; i++) {
-      for (let j = 0; j < n; j++) {
-        if (i === j) continue;
-        let dist = distance[i][j];
-        if (adjustSizes) {
-          dist -= size[i] - size[j];
-          dist = Math.max(dist, 0.01);
-        }
-        const distSquared = dist * dist;
-        const massProduct = mass[i] * mass[j];
-        const factor = massProduct / distSquared * scalingRatio;
-        for (let d = 0; d < dim; d++) {
-          const direction = diff[i][j][d] / dist;
-          repulsion[i][d] += direction * factor;
-        }
-      }
+    return arr.map((row) => np.mean(row));
+  },
+  add: function(a, b) {
+    if (!Array.isArray(a) && !Array.isArray(b)) {
+      return a + b;
     }
-    const centerOfMass = Array(dim).fill(0);
-    for (let i = 0; i < n; i++) {
-      for (let d = 0; d < dim; d++) {
-        centerOfMass[d] += posArray[i][d] / n;
-      }
+    if (!Array.isArray(a)) {
+      return b.map((val) => a + val);
     }
-    for (let i = 0; i < n; i++) {
-      const posCentered = Array(dim);
-      for (let d = 0; d < dim; d++) {
-        posCentered[d] = posArray[i][d] - centerOfMass[d];
-      }
-      if (strongGravity) {
-        for (let d = 0; d < dim; d++) {
-          gravities[i][d] = -gravity * mass[i] * posCentered[d];
-        }
-      } else {
-        const dist = Math.sqrt(posCentered.reduce((sum, val) => sum + val * val, 0));
-        if (dist > 0.01) {
-          for (let d = 0; d < dim; d++) {
-            const direction = posCentered[d] / dist;
-            gravities[i][d] = -gravity * mass[i] * direction;
-          }
-        }
-      }
+    if (!Array.isArray(b)) {
+      return a.map((val) => val + b);
     }
-    const update = Array(n).fill(0).map(() => Array(dim).fill(0));
-    let totalSwing = 0;
-    let totalTraction = 0;
-    for (let i = 0; i < n; i++) {
-      for (let d = 0; d < dim; d++) {
-        update[i][d] = attraction[i][d] + repulsion[i][d] + gravities[i][d];
-      }
-      const oldPos = [...posArray[i]];
-      const newPos = oldPos.map((p, d) => p + update[i][d]);
-      const swingVector = oldPos.map((p, d) => p - newPos[d]);
-      const tractionVector = oldPos.map((p, d) => p + newPos[d]);
-      const swingMagnitude = Math.sqrt(swingVector.reduce((sum, val) => sum + val * val, 0));
-      const tractionMagnitude = Math.sqrt(tractionVector.reduce((sum, val) => sum + val * val, 0));
-      totalSwing += mass[i] * swingMagnitude;
-      totalTraction += 0.5 * mass[i] * tractionMagnitude;
+    return a.map((val, i) => val + b[i]);
+  },
+  subtract: function(a, b) {
+    if (!Array.isArray(a) && !Array.isArray(b)) {
+      return a - b;
     }
-    [speed, speedEfficiency] = estimateFactor(
-      n,
-      totalSwing,
-      totalTraction,
-      speed,
-      speedEfficiency,
-      jitterTolerance
-    );
-    let totalMovement = 0;
-    for (let i = 0; i < n; i++) {
-      let factor;
-      if (adjustSizes) {
-        const df = Math.sqrt(update[i].reduce((sum, val) => sum + val * val, 0));
-        const swinging = mass[i] * df;
-        factor = 0.1 * speed / (1 + Math.sqrt(speed * swinging));
-        factor = Math.min(factor * df, 10) / df;
-      } else {
-        const swinging = mass[i] * Math.sqrt(update[i].reduce((sum, val) => sum + val * val, 0));
-        factor = speed / (1 + Math.sqrt(speed * swinging));
-      }
-      for (let d = 0; d < dim; d++) {
-        const movement = update[i][d] * factor;
-        posArray[i][d] += movement;
-        totalMovement += Math.abs(movement);
+    if (!Array.isArray(a)) {
+      return b.map((val) => a - val);
+    }
+    if (!Array.isArray(b)) {
+      return a.map((val) => val - b);
+    }
+    return a.map((val, i) => val - b[i]);
+  },
+  max: function(arr) {
+    if (!Array.isArray(arr)) {
+      return arr;
+    }
+    return Math.max(...arr.flat(Infinity));
+  },
+  min: function(arr) {
+    if (!Array.isArray(arr)) {
+      return arr;
+    }
+    return Math.min(...arr.flat(Infinity));
+  },
+  norm: function(arr) {
+    return Math.sqrt(arr.reduce((sum, val) => sum + val * val, 0));
+  }
+};
+function circularLayout(G, scale = 1, center = null, dim = 2) {
+  if (dim < 2) {
+    throw new Error("cannot handle dimensions < 2");
+  }
+  const processed = _processParams(G, center, dim);
+  const nodes = getNodesFromGraph(processed.G);
+  center = processed.center;
+  const pos = {};
+  if (nodes.length === 0) {
+    return pos;
+  }
+  if (nodes.length === 1) {
+    pos[nodes[0]] = center;
+    return pos;
+  }
+  if (dim === 2) {
+    const theta = np.linspace(0, 2 * Math.PI, nodes.length + 1).slice(0, -1);
+    nodes.forEach((node, i) => {
+      const x = Math.cos(theta[i]) * scale + center[0];
+      const y = Math.sin(theta[i]) * scale + center[1];
+      pos[node] = [x, y];
+    });
+  } else if (dim === 3) {
+    const n = nodes.length;
+    const goldenRatio = (1 + Math.sqrt(5)) / 2;
+    nodes.forEach((node, i) => {
+      const theta = 2 * Math.PI * i / goldenRatio;
+      const phi = Math.acos(1 - 2 * (i + 0.5) / n);
+      const x = Math.sin(phi) * Math.cos(theta) * scale + center[0];
+      const y = Math.sin(phi) * Math.sin(theta) * scale + center[1];
+      const z = Math.cos(phi) * scale + center[2];
+      pos[node] = [x, y, z];
+    });
+  } else {
+    const rng = new RandomNumberGenerator();
+    nodes.forEach((node) => {
+      const coords = Array(dim).fill(0).map(() => rng.rand() * 2 - 1);
+      const norm = Math.sqrt(coords.reduce((sum, c) => sum + c * c, 0));
+      pos[node] = coords.map((c, j) => c / norm * scale + center[j]);
+    });
+  }
+  return pos;
+}
+function kamadaKawaiLayout(G, dist = null, pos = null, weight = "weight", scale = 1, center = null, dim = 2) {
+  const processed = _processParams(G, center, dim);
+  const graph = processed.G;
+  center = processed.center;
+  const nodes = getNodesFromGraph(graph);
+  if (nodes.length === 0) {
+    return {};
+  }
+  if (nodes.length === 1) {
+    return { [nodes[0]]: center };
+  }
+  if (!dist) {
+    if (Array.isArray(graph)) {
+      throw new Error("Kamada-Kawai layout requires a Graph with edges, not just a list of nodes");
+    }
+    dist = _computeShortestPathDistances(graph, weight);
+  }
+  const nodesArray = Array.from(nodes);
+  const nNodes = nodesArray.length;
+  const distMatrix = Array(nNodes).fill(0).map(() => Array(nNodes).fill(1e6));
+  for (let i = 0; i < nNodes; i++) {
+    const nodeI = nodesArray[i];
+    distMatrix[i][i] = 0;
+    if (!dist[nodeI]) {
+      continue;
+    }
+    for (let j = 0; j < nNodes; j++) {
+      const nodeJ = nodesArray[j];
+      if (dist[nodeI][nodeJ] !== void 0) {
+        distMatrix[i][j] = dist[nodeI][nodeJ];
       }
     }
-    if (totalMovement < 1e-10) {
-      break;
+  }
+  if (!pos) {
+    if (dim >= 2) {
+      pos = circularLayout(G, 1, center, dim);
+    } else {
+      const posArray2 = {};
+      nodesArray.forEach((node, i) => {
+        posArray2[node] = [i / (nNodes - 1 || 1)];
+      });
+      pos = posArray2;
     }
   }
-  const positions = {};
-  for (let i = 0; i < n; i++) {
-    positions[nodes[i]] = posArray[i];
+  const posArray = new Array(nNodes);
+  for (let i = 0; i < nNodes; i++) {
+    const node = nodesArray[i];
+    posArray[i] = pos[node] ? [...pos[node]] : Array(dim).fill(0);
+    while (posArray[i].length < dim) {
+      posArray[i].push(0);
+    }
   }
-  return rescaleLayout(positions);
+  const newPositions = _kamadaKawaiSolve(distMatrix, posArray, dim);
+  const finalPos = {};
+  for (let i = 0; i < nNodes; i++) {
+    finalPos[nodesArray[i]] = newPositions[i];
+  }
+  return rescaleLayout(finalPos, scale, center);
 }
-function getNodeDegree(graph, node) {
-  return graph.edges().filter(
-    (edge) => edge[0] === node || edge[1] === node
-  ).length;
+function springLayout(G, k = null, pos = null, fixed = null, iterations = 50, scale = 1, center = null, dim = 2, seed = null) {
+  return fruchtermanReingoldLayout(G, k, pos, fixed, iterations, scale, center, dim, seed);
 }
-function arfLayout(G, pos = null, scaling = 1, a = 1.1, maxIter = 1e3, seed = null) {
-  if (a <= 1) {
-    throw new Error("The parameter a should be larger than 1");
+function shellLayout(G, nlist = null, scale = 1, center = null, dim = 2) {
+  if (dim !== 2) {
+    throw new Error("can only handle 2 dimensions");
   }
-  const nodes = getNodesFromGraph(G);
-  const edges = getEdgesFromGraph(G);
+  const processed = _processParams(G, center, dim);
+  const nodes = getNodesFromGraph(processed.G);
+  center = processed.center;
+  const pos = {};
   if (nodes.length === 0) {
-    return {};
+    return pos;
   }
-  if (!pos) {
-    pos = randomLayout(G, null, 2, seed);
-  } else {
-    const rng = new RandomNumberGenerator(seed ?? void 0);
-    const defaultPos = {};
-    nodes.forEach((node) => {
-      if (!pos[node]) {
-        defaultPos[node] = [rng.rand(), rng.rand()];
-      }
-    });
-    pos = { ...pos, ...defaultPos };
+  if (nodes.length === 1) {
+    pos[nodes[0]] = center;
+    return pos;
   }
-  const nodeIndex = {};
-  nodes.forEach((node, i) => {
-    nodeIndex[node] = i;
-  });
-  const positions = nodes.map((node) => [...pos[node]]);
-  const N = nodes.length;
-  const K = Array(N).fill(0).map(() => Array(N).fill(1));
-  for (let i = 0; i < N; i++) {
-    K[i][i] = 0;
+  if (!nlist) {
+    nlist = [nodes];
   }
-  for (const [source, target] of edges) {
-    if (source === target) continue;
-    const i = nodeIndex[source];
-    const j = nodeIndex[target];
-    K[i][j] = a;
-    K[j][i] = a;
+  const radiusBump = scale / nlist.length;
+  let radius;
+  if (nlist[0].length === 1) {
+    radius = 0;
+    pos[nlist[0][0]] = [...center];
+    radius += radiusBump;
+  } else {
+    radius = radiusBump;
   }
-  const rho = scaling * Math.sqrt(N);
-  const dt = 1e-3;
-  const etol = 1e-6;
-  let error = etol + 1;
-  let nIter = 0;
-  while (error > etol && nIter < maxIter) {
-    const change = Array(N).fill(0).map(() => [0, 0]);
-    for (let i = 0; i < N; i++) {
-      for (let j = 0; j < N; j++) {
-        if (i === j) continue;
-        const diff = positions[i].map((coord, dim) => coord - positions[j][dim]);
-        const dist = Math.sqrt(diff.reduce((sum, d) => sum + d * d, 0)) || 0.01;
-        for (let d = 0; d < diff.length; d++) {
-          change[i][d] += K[i][j] * diff[d] - rho / dist * diff[d];
-        }
-      }
+  for (let i = 0; i < nlist.length; i++) {
+    const shell = nlist[i];
+    if (shell.length === 0) {
+      continue;
     }
-    for (let i = 0; i < N; i++) {
-      for (let d = 0; d < positions[i].length; d++) {
-        positions[i][d] += change[i][d] * dt;
-      }
+    if (shell.length === 1 && i === 0) {
+      continue;
     }
-    error = change.reduce((sum, c) => sum + Math.sqrt(c.reduce((s, v) => s + v * v, 0)), 0);
-    nIter++;
+    const theta = np.linspace(0, 2 * Math.PI, shell.length + 1).slice(0, -1);
+    shell.forEach((node, j) => {
+      const x = Math.cos(theta[j]) * radius + center[0];
+      const y = Math.sin(theta[j]) * radius + center[1];
+      pos[node] = [x, y];
+    });
+    radius += radiusBump;
   }
-  const finalPos = {};
-  nodes.forEach((node, i) => {
-    finalPos[node] = positions[i];
-  });
-  return finalPos;
+  return pos;
 }
-function bipartiteLayout(G, nodes = null, align = "vertical", scale = 1, center = null, aspectRatio = 4 / 3) {
-  if (align !== "vertical" && align !== "horizontal") {
-    throw new Error("align must be either vertical or horizontal");
+function spiralLayout(G, scale = 1, center = null, dim = 2, resolution = 0.35, equidistant = false) {
+  if (dim !== 2) {
+    throw new Error("can only handle 2 dimensions");
   }
-  const processed = _processParams(G, center || [0, 0], 2);
-  const graph = processed.G;
+  const processed = _processParams(G, center || [0, 0], dim);
+  const nodes = getNodesFromGraph(processed.G);
   center = processed.center;
-  const allNodes = getNodesFromGraph(graph);
-  if (allNodes.length === 0) {
-    return {};
-  }
-  if (!nodes) {
-    nodes = allNodes.filter((_, i) => i % 2 === 0);
-  }
-  const left = new Set(nodes);
-  const right = new Set(allNodes.filter((n) => !left.has(n)));
-  const height = 1;
-  const width = aspectRatio * height;
-  const offset = [width / 2, height / 2];
   const pos = {};
-  const leftNodes = [...left];
-  leftNodes.forEach((node, i) => {
-    const x = 0;
-    const y = i * height / (leftNodes.length || 1);
-    pos[node] = [x, y];
-  });
-  const rightNodes = [...right];
-  rightNodes.forEach((node, i) => {
-    const x = width;
-    const y = i * height / (rightNodes.length || 1);
-    pos[node] = [x, y];
-  });
-  for (const node in pos) {
-    pos[node][0] -= offset[0];
-    pos[node][1] -= offset[1];
+  if (nodes.length === 0) {
+    return pos;
   }
-  const scaledPos = rescaleLayout(pos, scale, center);
-  if (align === "horizontal") {
-    for (const node in scaledPos) {
-      const temp = scaledPos[node][0];
-      scaledPos[node][0] = scaledPos[node][1];
-      scaledPos[node][1] = temp;
+  if (nodes.length === 1) {
+    pos[nodes[0]] = [...center];
+    return pos;
+  }
+  let positions = [];
+  if (equidistant) {
+    const chord = 1;
+    const step = 0.5;
+    let theta = resolution;
+    theta += chord / (step * theta);
+    for (let i = 0; i < nodes.length; i++) {
+      const r = step * theta;
+      theta += chord / r;
+      positions.push([Math.cos(theta) * r, Math.sin(theta) * r]);
     }
+  } else {
+    const dist = Array.from({ length: nodes.length }, (_, i) => parseFloat(String(i)));
+    const angle = dist.map((d) => resolution * d);
+    positions = dist.map((d, i) => [Math.cos(angle[i]) * d, Math.sin(angle[i]) * d]);
   }
-  return scaledPos;
+  const posArray = [];
+  for (let i = 0; i < positions.length; i++) {
+    posArray.push(positions[i]);
+  }
+  const scaledPositions = rescaleLayout(posArray, scale);
+  for (let i = 0; i < scaledPositions.length; i++) {
+    scaledPositions[i][0] += center[0];
+    scaledPositions[i][1] += center[1];
+  }
+  for (let i = 0; i < nodes.length; i++) {
+    pos[nodes[i]] = scaledPositions[i];
+  }
+  return pos;
 }
 function multipartiteLayout(G, subsetKey = "subset", align = "vertical", scale = 1, center = null) {
   if (align !== "vertical" && align !== "horizontal") {
@@ -1221,160 +1213,66 @@ function bfsLayout(G, start, align = "vertical", scale = 1, center = null) {
         }
       }
     }
-    if (nextLayer.length === 0) {
-      const unvisited = allNodes.filter((node) => !visited.has(node));
-      if (unvisited.length > 0) {
-        throw new Error("bfs_layout didn't include all nodes. Graph may be disconnected.");
-      }
-      break;
-    }
-    currentLayer++;
-    layers[currentLayer] = nextLayer;
-  }
-  return multipartiteLayout(graph, layers, align, scale, center);
-}
-function spectralLayout(G, scale = 1, center = null, dim = 2) {
-  const processed = _processParams(G, center, dim);
-  const graph = processed.G;
-  center = processed.center;
-  const nodes = getNodesFromGraph(graph);
-  if (nodes.length <= 2) {
-    if (nodes.length === 0) {
-      return {};
-    } else if (nodes.length === 1) {
-      return { [nodes[0]]: center };
-    } else {
-      return {
-        [nodes[0]]: center.map((v) => v - scale),
-        [nodes[1]]: center.map((v) => v + scale)
-      };
-    }
-  }
-  const N = nodes.length;
-  const nodeIndices = {};
-  nodes.forEach((node, i) => {
-    nodeIndices[node] = i;
-  });
-  const A = Array(N).fill(0).map(() => Array(N).fill(0));
-  const edges = getEdgesFromGraph(graph);
-  for (const [source, target] of edges) {
-    const i = nodeIndices[source];
-    const j = nodeIndices[target];
-    A[i][j] = 1;
-    A[j][i] = 1;
-  }
-  const L = Array(N).fill(0).map(() => Array(N).fill(0));
-  for (let i = 0; i < N; i++) {
-    L[i][i] = A[i].reduce((sum, val) => sum + val, 0);
-    for (let j = 0; j < N; j++) {
-      L[i][j] -= A[i][j];
-    }
-  }
-  const eigenvectors = [];
-  for (let d = 0; d < dim; d++) {
-    let vector = Array(N).fill(0).map(() => Math.random() - 0.5);
-    for (const ev of eigenvectors) {
-      const dot = vector.reduce((acc, val, idx) => acc + val * ev[idx], 0);
-      vector = vector.map((val, idx) => val - dot * ev[idx]);
-    }
-    const norm = Math.sqrt(vector.reduce((acc, val) => acc + val * val, 0));
-    vector = vector.map((val) => val / norm);
-    for (let iter = 0; iter < 100; iter++) {
-      const newVec = Array(N).fill(0);
-      for (let i = 0; i < N; i++) {
-        for (let j = 0; j < N; j++) {
-          newVec[i] += L[i][j] * vector[j];
-        }
-      }
-      const mean = newVec.reduce((acc, val) => acc + val, 0) / N;
-      newVec.forEach((val, idx, arr) => {
-        arr[idx] = val - mean;
-      });
-      const newNorm = Math.sqrt(newVec.reduce((acc, val) => acc + val * val, 0));
-      if (newNorm < 1e-10) continue;
-      vector = newVec.map((val) => val / newNorm);
-    }
-    eigenvectors.push(vector);
-  }
-  const positions = Array(N).fill(0).map(() => Array(dim).fill(0));
-  for (let i = 0; i < N; i++) {
-    for (let d = 0; d < dim; d++) {
-      positions[i][d] = eigenvectors[d][i];
-    }
-  }
-  const scaledPositions = rescaleLayout(positions, scale);
-  const pos = {};
-  nodes.forEach((node, i) => {
-    pos[node] = scaledPositions[i].map((val, j) => val + center[j]);
-  });
-  return pos;
-}
-function isK5(nodes, edges) {
-  if (nodes.length !== 5) return false;
-  if (edges.length !== 10) return false;
-  for (let i = 0; i < nodes.length; i++) {
-    for (let j = i + 1; j < nodes.length; j++) {
-      const hasEdge = edges.some(
-        (e) => e[0] === nodes[i] && e[1] === nodes[j] || e[0] === nodes[j] && e[1] === nodes[i]
-      );
-      if (!hasEdge) return false;
-    }
-  }
-  return true;
-}
-function isK33(nodes, edges) {
-  if (nodes.length !== 6) return false;
-  if (edges.length !== 9) return false;
-  const nodePartitions = tryFindBipartitePartition(nodes, edges);
-  if (!nodePartitions) return false;
-  const [part1, part2] = nodePartitions;
-  if (part1.length !== 3 || part2.length !== 3) return false;
-  for (const n1 of part1) {
-    for (const n2 of part2) {
-      const hasEdge = edges.some(
-        (e) => e[0] === n1 && e[1] === n2 || e[0] === n2 && e[1] === n1
-      );
-      if (!hasEdge) return false;
-    }
-  }
-  return true;
-}
-function tryFindBipartitePartition(nodes, edges) {
-  const colorMap = {};
-  const adjList = {};
-  for (const node of nodes) {
-    adjList[node] = [];
-  }
-  for (const [u, v] of edges) {
-    adjList[u].push(v);
-    adjList[v].push(u);
-  }
-  const queue = [nodes[0]];
-  colorMap[nodes[0]] = 0;
-  while (queue.length > 0) {
-    const node = queue.shift();
-    const nodeColor = colorMap[node];
-    for (const neighbor of adjList[node]) {
-      if (colorMap[neighbor] === void 0) {
-        colorMap[neighbor] = 1 - nodeColor;
-        queue.push(neighbor);
-      } else if (colorMap[neighbor] === nodeColor) {
-        return null;
-      }
-    }
+    if (nextLayer.length === 0) {
+      const unvisited = allNodes.filter((node) => !visited.has(node));
+      if (unvisited.length > 0) {
+        throw new Error("bfs_layout didn't include all nodes. Graph may be disconnected.");
+      }
+      break;
+    }
+    currentLayer++;
+    layers[currentLayer] = nextLayer;
   }
-  const part0 = [];
-  const part1 = [];
-  for (const node of nodes) {
-    if (colorMap[node] === 0) {
-      part0.push(node);
-    } else {
-      part1.push(node);
+  return multipartiteLayout(graph, layers, align, scale, center);
+}
+function bipartiteLayout(G, nodes = null, align = "vertical", scale = 1, center = null, aspectRatio = 4 / 3) {
+  if (align !== "vertical" && align !== "horizontal") {
+    throw new Error("align must be either vertical or horizontal");
+  }
+  const processed = _processParams(G, center || [0, 0], 2);
+  const graph = processed.G;
+  center = processed.center;
+  const allNodes = getNodesFromGraph(graph);
+  if (allNodes.length === 0) {
+    return {};
+  }
+  if (!nodes) {
+    nodes = allNodes.filter((_, i) => i % 2 === 0);
+  }
+  const left = new Set(nodes);
+  const right = new Set(allNodes.filter((n) => !left.has(n)));
+  const height = 1;
+  const width = aspectRatio * height;
+  const offset = [width / 2, height / 2];
+  const pos = {};
+  const leftNodes = [...left];
+  leftNodes.forEach((node, i) => {
+    const x = 0;
+    const y = i * height / (leftNodes.length || 1);
+    pos[node] = [x, y];
+  });
+  const rightNodes = [...right];
+  rightNodes.forEach((node, i) => {
+    const x = width;
+    const y = i * height / (rightNodes.length || 1);
+    pos[node] = [x, y];
+  });
+  for (const node in pos) {
+    pos[node][0] -= offset[0];
+    pos[node][1] -= offset[1];
+  }
+  const scaledPos = rescaleLayout(pos, scale, center);
+  if (align === "horizontal") {
+    for (const node in scaledPos) {
+      const temp = scaledPos[node][0];
+      scaledPos[node][0] = scaledPos[node][1];
+      scaledPos[node][1] = temp;
     }
   }
-  return [part0, part1];
+  return scaledPos;
 }
-function createTriangulationEmbedding(nodes, edges) {
+function createTriangulationEmbedding(nodes, edges, seed = null) {
+  const rng = new RandomNumberGenerator(seed ?? void 0);
   const embedding = {
     nodeOrder: [...nodes],
     faceList: [],
@@ -1410,14 +1308,14 @@ function createTriangulationEmbedding(nodes, edges) {
         }
       }
       if (count > 0) {
-        const jitter = 0.1 * Math.random();
+        const jitter = 0.1 * rng.rand();
         embedding.nodePositions[node] = [
-          xSum / count + jitter * (Math.random() - 0.5),
-          ySum / count + jitter * (Math.random() - 0.5)
+          xSum / count + jitter * (rng.rand() - 0.5),
+          ySum / count + jitter * (rng.rand() - 0.5)
         ];
       } else {
-        const r = 0.5 * Math.random();
-        const angle = 2 * Math.PI * Math.random();
+        const r = 0.5 * rng.rand();
+        const angle = 2 * Math.PI * rng.rand();
         embedding.nodePositions[node] = [r * Math.cos(angle), r * Math.sin(angle)];
       }
     }
@@ -1425,8 +1323,12 @@ function createTriangulationEmbedding(nodes, edges) {
   return embedding;
 }
 function findCycle(nodes, edges, adjMap) {
-  if (nodes.length === 0) return null;
-  if (nodes.length <= 2) return nodes;
+  if (nodes.length === 0) {
+    return null;
+  }
+  if (nodes.length <= 2) {
+    return nodes;
+  }
   if (nodes.length <= 8) {
     let hamiltonianCycleDFS = function(node) {
       path.push(node);
@@ -1462,7 +1364,9 @@ function findCycle(nodes, edges, adjMap) {
   function findCycleDFS(node, parentNode) {
     visited.add(node);
     for (const neighbor of adjMap[node]) {
-      if (neighbor === parentNode) continue;
+      if (neighbor === parentNode) {
+        continue;
+      }
       if (visited.has(neighbor)) {
         cycleFound = constructCycle(node, neighbor, parent);
         return true;
@@ -1504,7 +1408,7 @@ function combinatorialEmbeddingToPos(embedding, nodes) {
   }
   return pos;
 }
-function lrPlanarityTest(nodes, edges) {
+function lrPlanarityTest(nodes, edges, seed = null) {
   const adjList = {};
   for (const node of nodes) {
     adjList[node] = [];
@@ -1526,25 +1430,104 @@ function lrPlanarityTest(nodes, edges) {
   }
   dfs(nodes[0]);
   if (ordering.length < nodes.length) {
-    return { isPlanar: true, embedding: createTriangulationEmbedding(nodes, edges) };
+    return { isPlanar: true, embedding: createTriangulationEmbedding(nodes, edges, seed) };
   }
   if (edges.length > 3 * nodes.length - 6) {
     return { isPlanar: false, embedding: null };
   }
-  const embedding = createTriangulationEmbedding(nodes, edges);
+  const embedding = createTriangulationEmbedding(nodes, edges, seed);
   return { isPlanar: true, embedding };
 }
-function checkPlanarity(G, nodes, edges) {
+function isK5(nodes, edges) {
+  if (nodes.length !== 5) {
+    return false;
+  }
+  if (edges.length !== 10) {
+    return false;
+  }
+  for (let i = 0; i < nodes.length; i++) {
+    for (let j = i + 1; j < nodes.length; j++) {
+      const hasEdge = edges.some(
+        (e) => e[0] === nodes[i] && e[1] === nodes[j] || e[0] === nodes[j] && e[1] === nodes[i]
+      );
+      if (!hasEdge) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function isK33(nodes, edges) {
+  if (nodes.length !== 6) {
+    return false;
+  }
+  if (edges.length !== 9) {
+    return false;
+  }
+  const nodePartitions = tryFindBipartitePartition(nodes, edges);
+  if (!nodePartitions) {
+    return false;
+  }
+  const [part1, part2] = nodePartitions;
+  if (part1.length !== 3 || part2.length !== 3) {
+    return false;
+  }
+  for (const n1 of part1) {
+    for (const n2 of part2) {
+      const hasEdge = edges.some((e) => e[0] === n1 && e[1] === n2 || e[0] === n2 && e[1] === n1);
+      if (!hasEdge) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+function tryFindBipartitePartition(nodes, edges) {
+  const colorMap = {};
+  const adjList = {};
+  for (const node of nodes) {
+    adjList[node] = [];
+  }
+  for (const [u, v] of edges) {
+    adjList[u].push(v);
+    adjList[v].push(u);
+  }
+  const queue = [nodes[0]];
+  colorMap[nodes[0]] = 0;
+  while (queue.length > 0) {
+    const node = queue.shift();
+    const nodeColor = colorMap[node];
+    for (const neighbor of adjList[node]) {
+      if (colorMap[neighbor] === void 0) {
+        colorMap[neighbor] = 1 - nodeColor;
+        queue.push(neighbor);
+      } else if (colorMap[neighbor] === nodeColor) {
+        return null;
+      }
+    }
+  }
+  const part0 = [];
+  const part1 = [];
+  for (const node of nodes) {
+    if (colorMap[node] === 0) {
+      part0.push(node);
+    } else {
+      part1.push(node);
+    }
+  }
+  return [part0, part1];
+}
+function checkPlanarity(G, nodes, edges, seed = null) {
   if (nodes.length <= 4) {
-    return { isPlanar: true, embedding: createTriangulationEmbedding(nodes, edges) };
+    return { isPlanar: true, embedding: createTriangulationEmbedding(nodes, edges, seed) };
   }
   if (isK5(nodes, edges) || isK33(nodes, edges)) {
     return { isPlanar: false, embedding: null };
   }
-  const result = lrPlanarityTest(nodes, edges);
+  const result = lrPlanarityTest(nodes, edges, seed);
   return result;
 }
-function planarLayout(G, scale = 1, center = null, dim = 2) {
+function planarLayout(G, scale = 1, center = null, dim = 2, seed = null) {
   if (dim !== 2) {
     throw new Error("can only handle 2 dimensions");
   }
@@ -1559,7 +1542,7 @@ function planarLayout(G, scale = 1, center = null, dim = 2) {
   if (nodes.length === 0) {
     return {};
   }
-  const { isPlanar, embedding } = checkPlanarity(graph, nodes, edges);
+  const { isPlanar, embedding } = checkPlanarity(graph, nodes, edges, seed);
   if (!isPlanar) {
     throw new Error("G is not planar.");
   }
@@ -1570,6 +1553,83 @@ function planarLayout(G, scale = 1, center = null, dim = 2) {
   pos = rescaleLayout(pos, scale, center);
   return pos;
 }
+function spectralLayout(G, scale = 1, center = null, dim = 2) {
+  const processed = _processParams(G, center, dim);
+  const graph = processed.G;
+  center = processed.center;
+  const nodes = getNodesFromGraph(graph);
+  if (nodes.length <= 2) {
+    if (nodes.length === 0) {
+      return {};
+    } else if (nodes.length === 1) {
+      return { [nodes[0]]: center };
+    }
+    return {
+      [nodes[0]]: center.map((v) => v - scale),
+      [nodes[1]]: center.map((v) => v + scale)
+    };
+  }
+  const N = nodes.length;
+  const nodeIndices = {};
+  nodes.forEach((node, i) => {
+    nodeIndices[node] = i;
+  });
+  const A = Array(N).fill(0).map(() => Array(N).fill(0));
+  const edges = getEdgesFromGraph(graph);
+  for (const [source, target] of edges) {
+    const i = nodeIndices[source];
+    const j = nodeIndices[target];
+    A[i][j] = 1;
+    A[j][i] = 1;
+  }
+  const L = Array(N).fill(0).map(() => Array(N).fill(0));
+  for (let i = 0; i < N; i++) {
+    L[i][i] = A[i].reduce((sum, val) => sum + val, 0);
+    for (let j = 0; j < N; j++) {
+      L[i][j] -= A[i][j];
+    }
+  }
+  const eigenvectors = [];
+  for (let d = 0; d < dim; d++) {
+    let vector = Array(N).fill(0).map(() => Math.random() - 0.5);
+    for (const ev of eigenvectors) {
+      const dot = vector.reduce((acc, val, idx) => acc + val * ev[idx], 0);
+      vector = vector.map((val, idx) => val - dot * ev[idx]);
+    }
+    const norm = Math.sqrt(vector.reduce((acc, val) => acc + val * val, 0));
+    vector = vector.map((val) => val / norm);
+    for (let iter = 0; iter < 100; iter++) {
+      const newVec = Array(N).fill(0);
+      for (let i = 0; i < N; i++) {
+        for (let j = 0; j < N; j++) {
+          newVec[i] += L[i][j] * vector[j];
+        }
+      }
+      const mean = newVec.reduce((acc, val) => acc + val, 0) / N;
+      newVec.forEach((val, idx, arr) => {
+        arr[idx] = val - mean;
+      });
+      const newNorm = Math.sqrt(newVec.reduce((acc, val) => acc + val * val, 0));
+      if (newNorm < 1e-10) {
+        continue;
+      }
+      vector = newVec.map((val) => val / newNorm);
+    }
+    eigenvectors.push(vector);
+  }
+  const positions = Array(N).fill(0).map(() => Array(dim).fill(0));
+  for (let i = 0; i < N; i++) {
+    for (let d = 0; d < dim; d++) {
+      positions[i][d] = eigenvectors[d][i];
+    }
+  }
+  const scaledPositions = rescaleLayout(positions, scale);
+  const pos = {};
+  nodes.forEach((node, i) => {
+    pos[node] = scaledPositions[i].map((val, j) => val + center[j]);
+  });
+  return pos;
+}
 function completeGraph(n) {
   const nodes = Array.from({ length: n }, (_, i) => i);
   const edges = [];
@@ -1622,6 +1682,30 @@ function wheelGraph(n) {
     edges: () => edges
   };
 }
+function bipartiteGraph(n1, n2, p, seed) {
+  const setA = Array.from({ length: n1 }, (_, i) => `A${i}`);
+  const setB = Array.from({ length: n2 }, (_, i) => `B${i}`);
+  const nodes = [...setA, ...setB];
+  const edges = [];
+  let currentSeed = seed;
+  const random = seed !== void 0 ? () => {
+    currentSeed = (currentSeed * 9301 + 49297) % 233280;
+    return currentSeed / 233280;
+  } : Math.random;
+  for (const a of setA) {
+    for (const b of setB) {
+      if (random() < p) {
+        edges.push([a, b]);
+      }
+    }
+  }
+  return {
+    nodes: () => nodes,
+    edges: () => edges,
+    setA,
+    setB
+  };
+}
 function gridGraph(rows, cols) {
   const nodes = [];
   const edges = [];
@@ -1649,7 +1733,7 @@ function randomGraph(n, p, seed) {
   const nodes = Array.from({ length: n }, (_, i) => i);
   const edges = [];
   let currentSeed = seed;
-  let random = seed !== void 0 ? () => {
+  const random = seed !== void 0 ? () => {
     currentSeed = (currentSeed * 9301 + 49297) % 233280;
     return currentSeed / 233280;
   } : Math.random;
@@ -1665,30 +1749,6 @@ function randomGraph(n, p, seed) {
     edges: () => edges
   };
 }
-function bipartiteGraph(n1, n2, p, seed) {
-  const setA = Array.from({ length: n1 }, (_, i) => `A${i}`);
-  const setB = Array.from({ length: n2 }, (_, i) => `B${i}`);
-  const nodes = [...setA, ...setB];
-  const edges = [];
-  let currentSeed = seed;
-  let random = seed !== void 0 ? () => {
-    currentSeed = (currentSeed * 9301 + 49297) % 233280;
-    return currentSeed / 233280;
-  } : Math.random;
-  for (const a of setA) {
-    for (const b of setB) {
-      if (random() < p) {
-        edges.push([a, b]);
-      }
-    }
-  }
-  return {
-    nodes: () => nodes,
-    edges: () => edges,
-    setA,
-    setB
-  };
-}
 function scaleFreeGraph(n, m, seed) {
   if (m >= n) {
     throw new Error("m must be less than n");
@@ -1697,7 +1757,7 @@ function scaleFreeGraph(n, m, seed) {
   const edges = [];
   const degrees = new Array(n).fill(0);
   let currentSeed = seed;
-  let random = seed !== void 0 ? () => {
+  const random = seed !== void 0 ? () => {
     currentSeed = (currentSeed * 9301 + 49297) % 233280;
     return currentSeed / 233280;
   } : Math.random;
@@ -1712,7 +1772,7 @@ function scaleFreeGraph(n, m, seed) {
     const targets = /* @__PURE__ */ new Set();
     const totalDegree = degrees.reduce((sum, d) => sum + d, 0);
     while (targets.size < m) {
-      let r = random() * totalDegree;
+      const r = random() * totalDegree;
       let cumSum = 0;
       for (let j = 0; j < i; j++) {
         cumSum += degrees[j];