@graphty/layout 1.2.3 → 1.2.5

package/examples/layout.js

@@ -1,2304 +0,0 @@
-/**
- * Layout
- * ======
- *
- * Node positioning algorithms for graph drawing in TypeScript.
- *
- * For `randomLayout()` the possible resulting shape
- * is a square of side [0, scale] (default: [0, 1])
- * Changing `center` shifts the layout by that amount.
- *
- * For the other layout routines, the extent is
- * [center - scale, center + scale] (default: [-1, 1]).
- *
- * Ported from NetworkX Python library.
- */
-// Utility array manipulation functions (NumPy-like)
-const np = {
-    zeros: function (shape) {
-        if (typeof shape === 'number') {
-            return Array(shape).fill(0);
-        }
-        if (shape.length === 1) {
-            return Array(shape[0]).fill(0);
-        }
-        return Array(shape[0]).fill(0).map(() => this.zeros(shape.slice(1)));
-    },
-    ones: function (shape) {
-        if (typeof shape === 'number') {
-            return Array(shape).fill(1);
-        }
-        if (shape.length === 1) {
-            return Array(shape[0]).fill(1);
-        }
-        return Array(shape[0]).fill(1).map(() => this.ones(shape.slice(1)));
-    },
-    linspace: function (start, stop, num) {
-        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));
-        }
-        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 (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;
-        }
-        return arr.map(row => np.mean(row));
-    },
-    add: function (a, b) {
-        if (!Array.isArray(a) && !Array.isArray(b)) {
-            return a + b;
-        }
-        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]);
-    },
-    subtract: function (a, b) {
-        if (!Array.isArray(a) && !Array.isArray(b)) {
-            return a - b;
-        }
-        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));
-    }
-};
-// Random number generator (for seed-based randomization)
-class RandomNumberGenerator {
-    constructor(seed) {
-        this.seed = seed || Math.floor(Math.random() * 1000000);
-        this.m = 2 ** 35 - 31;
-        this.a = 185852;
-        this.c = 1;
-        this._state = this.seed % this.m;
-    }
-    _next() {
-        this._state = (this.a * this._state + this.c) % this.m;
-        return this._state / this.m;
-    }
-    rand(shape = null) {
-        if (shape === null) {
-            return this._next();
-        }
-        if (typeof shape === 'number') {
-            const result = [];
-            for (let i = 0; i < shape; i++) {
-                result.push(this._next());
-            }
-            return result;
-        }
-        if (shape.length === 1) {
-            const result = [];
-            for (let i = 0; i < shape[0]; i++) {
-                result.push(this._next());
-            }
-            return result;
-        }
-        const result = [];
-        for (let i = 0; i < shape[0]; i++) {
-            result.push(this.rand(shape.slice(1)));
-        }
-        return result;
-    }
-}
-/**
- * Extract nodes from a graph object
- *
- * @param G - Graph or list of nodes
- * @returns Array of nodes
- */
-function getNodesFromGraph(G) {
-    return G.nodes ? G.nodes() : G;
-}
-/**
- * Extract edges from a graph object
- *
- * @param G - Graph or list of nodes
- * @returns Array of edges
- */
-function getEdgesFromGraph(G) {
-    return G.edges ? G.edges() : [];
-}
-// Helper function similar to _process_params in Python version
-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 };
-}
-/**
- * Position nodes uniformly at random in the unit square.
- *
- * @param G - Graph or list of nodes
- * @param center - Coordinate pair around which to center the layout
- * @param dim - Dimension of layout
- * @param seed - Random seed for reproducible layouts
- * @returns Positions dictionary keyed by node
- */
-function randomLayout(G, center = null, dim = 2, seed = null) {
-    const processed = _processParams(G, center, dim);
-    const nodes = getNodesFromGraph(processed.G);
-    center = processed.center;
-    const rng = new RandomNumberGenerator(seed ?? undefined);
-    const pos = {};
-    nodes.forEach((node) => {
-        pos[node] = rng.rand(dim).map((val, i) => val + center[i]);
-    });
-    return pos;
-}
-/**
- * Position nodes on a circle (2D) or sphere (3D).
- *
- * @param G - Graph or list of nodes
- * @param scale - Scale factor for positions
- * @param center - Coordinate pair around which to center the layout
- * @param dim - Dimension of layout (supports 2D circle or 3D sphere)
- * @returns Positions dictionary keyed by node
- */
-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) {
-        // 2D circle layout
-        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) {
-        // 3D sphere layout using Fibonacci spiral
-        const n = nodes.length;
-        const goldenRatio = (1 + Math.sqrt(5)) / 2;
-        nodes.forEach((node, i) => {
-            // Use Fibonacci spiral for even distribution on sphere
-            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 {
-        // For higher dimensions, fall back to random on hypersphere
-        const rng = new RandomNumberGenerator();
-        nodes.forEach((node) => {
-            // Generate random point on unit hypersphere
-            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;
-}
-/**
- * Position nodes in concentric circles.
- *
- * @param G - Graph or list of nodes
- * @param nlist - List of node lists for each shell
- * @param scale - Scale factor for positions
- * @param center - Coordinate pair around which to center the layout
- * @param dim - Dimension of layout (currently only supports dim=2)
- * @returns Positions dictionary keyed by node
- */
-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 no nlist is specified, put all nodes in a single shell
-    if (!nlist) {
-        nlist = [nodes];
-    }
-    const radiusBump = scale / nlist.length;
-    let radius;
-    if (nlist[0].length === 1) {
-        // Single node at center
-        radius = 0;
-        pos[nlist[0][0]] = [...center];
-        radius += radiusBump;
-    }
-    else {
-        // Start at radius 1
-        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) {
-            // Already handled the case of a single center node
-            continue;
-        }
-        // Calculate positions on a circle
-        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;
-}
-/**
- * Position nodes using Fruchterman-Reingold force-directed algorithm.
- *
- * @param {Object} G - Graph or list of nodes
- * @param {number} k - Optimal distance between nodes
- * @param {Object} pos - Initial positions for nodes
- * @param {Array} fixed - Nodes to keep fixed at initial position
- * @param {number} iterations - Maximum number of iterations
- * @param {number} scale - Scale factor for positions
- * @param {Array|null} center - Coordinate pair around which to center the layout
- * @param {number} dim - Dimension of layout
- * @param {number} seed - Random seed for initial positions
- * @returns {Object} Positions dictionary keyed by node
- */
-function springLayout(G, k = null, pos = null, fixed = null, iterations = 50, scale = 1, center = null, dim = 2, seed = null) {
-    // Legacy compatibility alias
-    return fruchtermanReingoldLayout(G, k, pos, fixed, iterations, scale, center, dim, seed);
-}
-/**
- * Position nodes using Fruchterman-Reingold force-directed algorithm.
- *
- * @param {Object} G - Graph or list of nodes
- * @param {number} k - Optimal distance between nodes
- * @param {Object} pos - Initial positions for nodes
- * @param {Array} fixed - Nodes to keep fixed at initial position
- * @param {number} iterations - Maximum number of iterations
- * @param {number} scale - Scale factor for positions
- * @param {Array|null} center - Coordinate pair around which to center the layout
- * @param {number} dim - Dimension of layout
- * @param {number} seed - Random seed for initial positions
- * @returns {Object} Positions dictionary keyed by node
- */
-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;
-    center = processed.center;
-    const nodes = getNodesFromGraph(graph);
-    const edges = getEdgesFromGraph(graph);
-    if (nodes.length === 0) {
-        return {};
-    }
-    if (nodes.length === 1) {
-        const singlePos = {};
-        singlePos[nodes[0]] = center;
-        return singlePos;
-    }
-    // Set up initial positions
-    let positions = {};
-    if (pos) {
-        // Use provided positions
-        for (const node of nodes) {
-            if (pos[node]) {
-                positions[node] = [...pos[node]];
-            }
-            else {
-                const rng = new RandomNumberGenerator(seed ?? undefined);
-                positions[node] = rng.rand(dim);
-            }
-        }
-    }
-    else {
-        // Random initial positions
-        const rng = new RandomNumberGenerator(seed ?? undefined);
-        for (const node of nodes) {
-            positions[node] = rng.rand(dim);
-        }
-    }
-    // Set up fixed nodes
-    const fixedNodes = new Set(fixed || []);
-    // Optimal distance between nodes
-    if (!k) {
-        k = 1.0 / Math.sqrt(nodes.length);
-    }
-    // Initialize temperature
-    let t = 0.1;
-    // Calculate temperature reduction
-    const dt = t / (iterations + 1);
-    // Simple cooling schedule
-    for (let i = 0; i < iterations; i++) {
-        // Calculate repulsive forces
-        const displacement = {};
-        for (const node of nodes) {
-            displacement[node] = Array(dim).fill(0);
-        }
-        // Repulsive forces between nodes
-        for (let v1i = 0; v1i < nodes.length; v1i++) {
-            const v1 = nodes[v1i];
-            for (let v2i = v1i + 1; v2i < nodes.length; v2i++) {
-                const v2 = nodes[v2i];
-                // Difference vector
-                const delta = positions[v1].map((p, i) => p - positions[v2][i]);
-                // Distance
-                const distance = Math.sqrt(delta.reduce((sum, d) => sum + d * d, 0)) || 0.1;
-                // Force
-                const force = (k * k) / distance;
-                // Add force to displacement
-                for (let j = 0; j < dim; j++) {
-                    const direction = delta[j] / distance;
-                    displacement[v1][j] += direction * force;
-                    displacement[v2][j] -= direction * force;
-                }
-            }
-        }
-        // Attractive forces between connected nodes
-        for (const [source, target] of edges) {
-            // Difference vector
-            const delta = positions[source].map((p, i) => p - positions[target][i]);
-            // Distance
-            const distance = Math.sqrt(delta.reduce((sum, d) => sum + d * d, 0)) || 0.1;
-            // Force
-            const force = (distance * distance) / k;
-            // Add force to displacement
-            for (let j = 0; j < dim; j++) {
-                const direction = delta[j] / distance;
-                displacement[source][j] -= direction * force;
-                displacement[target][j] += direction * force;
-            }
-        }
-        // Update positions
-        for (const node of nodes) {
-            if (fixedNodes.has(node))
-                continue;
-            // Calculate displacement magnitude
-            const magnitude = Math.sqrt(displacement[node].reduce((sum, d) => sum + d * d, 0));
-            // Limit maximum displacement by temperature
-            const limitedMagnitude = Math.min(magnitude, t);
-            // Update position
-            for (let j = 0; j < dim; j++) {
-                const direction = magnitude === 0 ? 0 : displacement[node][j] / magnitude;
-                positions[node][j] += direction * limitedMagnitude;
-            }
-        }
-        // Cool temperature
-        t -= dt;
-    }
-    // Rescale positions
-    if (!fixed) {
-        positions = rescaleLayout(positions, scale, center);
-    }
-    return positions;
-}
-/**
- * Position nodes in a spectral layout using eigenvectors of the graph Laplacian.
- *
- * @param G - Graph
- * @param scale - Scale factor for positions
- * @param center - Coordinate pair around which to center the layout
- * @param dim - Dimension of layout
- * @returns Positions dictionary keyed by node
- */
-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)
-            };
-        }
-    }
-    // Create adjacency matrix
-    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; // Make symmetric for undirected graphs
-    }
-    // Create Laplacian matrix: L = D - A where D is degree matrix
-    const L = Array(N).fill(0).map(() => Array(N).fill(0));
-    for (let i = 0; i < N; i++) {
-        // Compute degree (sum of row)
-        L[i][i] = A[i].reduce((sum, val) => sum + val, 0);
-        for (let j = 0; j < N; j++) {
-            L[i][j] -= A[i][j];
-        }
-    }
-    // Compute eigenvectors using power iteration method
-    // We need the smallest non-zero eigenvectors of L
-    const eigenvectors = [];
-    // For each dimension, find an eigenvector
-    for (let d = 0; d < dim; d++) {
-        let vector = Array(N).fill(0).map(() => Math.random() - 0.5);
-        // Orthogonalize against previous eigenvectors
-        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]);
-        }
-        // Normalize
-        const norm = Math.sqrt(vector.reduce((acc, val) => acc + val * val, 0));
-        vector = vector.map(val => val / norm);
-        // Apply shifted inverse iteration to find smallest non-zero eigenvector
-        // This is a simplification of the actual algorithm
-        for (let iter = 0; iter < 100; iter++) {
-            // Apply Laplacian
-            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];
-                }
-            }
-            // Orthogonalize against the constant vector (eigenvector with eigenvalue 0)
-            const mean = newVec.reduce((acc, val) => acc + val, 0) / N;
-            newVec.forEach((val, idx, arr) => { arr[idx] = val - mean; });
-            // Normalize
-            const newNorm = Math.sqrt(newVec.reduce((acc, val) => acc + val * val, 0));
-            if (newNorm < 1e-10)
-                continue; // Skip if vector is close to zero
-            vector = newVec.map(val => val / newNorm);
-        }
-        eigenvectors.push(vector);
-    }
-    // Create position array from eigenvectors
-    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];
-        }
-    }
-    // Rescale and create position dictionary
-    const scaledPositions = rescaleLayout(positions, scale);
-    const pos = {};
-    nodes.forEach((node, i) => {
-        pos[node] = scaledPositions[i].map((val, j) => val + center[j]);
-    });
-    return pos;
-}
-/**
- * Position nodes in a spiral layout.
- *
- * @param G - Graph or list of nodes
- * @param scale - Scale factor for positions
- * @param center - Coordinate pair around which to center the layout
- * @param dim - Dimension of layout
- * @param resolution - Controls the spacing between spiral elements
- * @param equidistant - Whether to place nodes equidistant from each other
- * @returns Positions dictionary keyed by node
- */
-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) {
-        // Create equidistant points along the spiral
-        // This matches the Python implementation logic
-        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 {
-        // Create points with equal angle but increasing distance
-        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
-        ]);
-    }
-    // Convert position array to position matrix for rescaling
-    const posArray = [];
-    for (let i = 0; i < positions.length; i++) {
-        posArray.push(positions[i]);
-    }
-    // Rescale positions and add center offset
-    const scaledPositions = rescaleLayout(posArray, scale);
-    for (let i = 0; i < scaledPositions.length; i++) {
-        scaledPositions[i][0] += center[0];
-        scaledPositions[i][1] += center[1];
-    }
-    // Create position dictionary
-    for (let i = 0; i < nodes.length; i++) {
-        pos[nodes[i]] = scaledPositions[i];
-    }
-    return pos;
-}
-/**
- * Rescale node positions to fit in the specified scale and center.
- *
- * @param pos - Dictionary or array of positions
- * @param scale - Scale factor for positions
- * @param center - Coordinate pair around which to center the layout
- * @returns Rescaled positions dictionary
- */
-function rescaleLayout(pos, scale = 1, center = [0, 0]) {
-    // Check if pos is empty
-    if (Array.isArray(pos)) {
-        if (pos.length === 0)
-            return [];
-    }
-    else {
-        if (Object.keys(pos).length === 0)
-            return {};
-    }
-    // Extract position values
-    const posValues = Array.isArray(pos) ? pos : Object.values(pos);
-    const dim = posValues[0].length;
-    // Calculate center of positions
-    const posCenter = Array(dim).fill(0);
-    for (const p of posValues) {
-        for (let i = 0; i < dim; i++) {
-            posCenter[i] += p[i] / posValues.length;
-        }
-    }
-    // Center positions
-    let centeredPos = {};
-    if (Array.isArray(pos)) {
-        centeredPos = pos.map(p => p.map((val, i) => val - posCenter[i]));
-    }
-    else {
-        for (const [node, p] of Object.entries(pos)) {
-            centeredPos[node] = p.map((val, i) => val - posCenter[i]);
-        }
-    }
-    // Find maximum distance from center
-    let maxDistance = 0;
-    const centeredValues = Array.isArray(centeredPos) ? centeredPos : Object.values(centeredPos);
-    for (const p of centeredValues) {
-        const distance = Math.sqrt(p.reduce((sum, val) => sum + val * val, 0));
-        maxDistance = Math.max(maxDistance, distance);
-    }
-    // Rescale
-    let scaledPos = Array.isArray(pos) ? [] : {};
-    if (maxDistance > 0) {
-        const scaleFactor = scale / maxDistance;
-        if (Array.isArray(pos)) {
-            scaledPos = centeredPos.map(p => p.map((val, i) => val * scaleFactor + center[i]));
-        }
-        else {
-            for (const [node, p] of Object.entries(centeredPos)) {
-                scaledPos[node] = p.map((val, i) => val * scaleFactor + center[i]);
-            }
-        }
-    }
-    else {
-        // All nodes at the same position
-        if (Array.isArray(pos)) {
-            scaledPos = Array(pos.length).fill(0).map(() => [...center]);
-        }
-        else {
-            for (const node of Object.keys(pos)) {
-                scaledPos[node] = [...center];
-            }
-        }
-    }
-    return scaledPos;
-}
-/**
- * Position nodes in two straight lines (bipartite layout).
- *
- * @param G - Graph or list of nodes
- * @param nodes - Nodes in one node set of the graph
- * @param align - The alignment of nodes: 'vertical' or 'horizontal'
- * @param scale - Scale factor for positions
- * @param center - Coordinate pair around which to center the layout
- * @param aspectRatio - The ratio of the width to the height of the layout
- * @returns Positions dictionary keyed by node
- */
-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 not provided, try to determine bipartite sets
-    if (!nodes) {
-        // A simple heuristic for bipartite detection: use nodes with even/odd indices
-        // This is a simplification, in Python NetworkX has bipartite.sets()
-        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 = {};
-    // Position nodes in the left set
-    const leftNodes = [...left];
-    leftNodes.forEach((node, i) => {
-        const x = 0;
-        const y = i * height / (leftNodes.length || 1);
-        pos[node] = [x, y];
-    });
-    // Position nodes in the right set
-    const rightNodes = [...right];
-    rightNodes.forEach((node, i) => {
-        const x = width;
-        const y = i * height / (rightNodes.length || 1);
-        pos[node] = [x, y];
-    });
-    // Center positions around the origin and apply offset
-    for (const node in pos) {
-        pos[node][0] -= offset[0];
-        pos[node][1] -= offset[1];
-    }
-    // Rescale positions
-    const scaledPos = rescaleLayout(pos, scale, center);
-    // Handle horizontal alignment
-    if (align === 'horizontal') {
-        for (const node in scaledPos) {
-            const temp = scaledPos[node][0];
-            scaledPos[node][0] = scaledPos[node][1];
-            scaledPos[node][1] = temp;
-        }
-    }
-    return scaledPos;
-}
-/**
- * Position nodes in layers of straight lines (multipartite layout).
- *
- * @param G - Graph or list of nodes
- * @param subsetKey - Object mapping layers to node sets, or node attribute name
- * @param align - The alignment of nodes: 'vertical' or 'horizontal'
- * @param scale - Scale factor for positions
- * @param center - Coordinate pair around which to center the layout
- * @returns Positions dictionary keyed by node
- */
-function multipartiteLayout(G, subsetKey = 'subset', align = 'vertical', scale = 1, center = null) {
-    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 {};
-    }
-    // Convert subsetKey to a layer mapping if it's a string
-    let layers = {};
-    if (typeof subsetKey === 'string') {
-        // In JS we don't have access to node attributes directly
-        // This is a simplification - in a real implementation we would need
-        // to access node attributes from the graph
-        console.warn("Using string subsetKey requires node attributes, using default partitioning");
-        // Create a simple partitioning as fallback
-        layers = { 0: allNodes };
-    }
-    else {
-        // subsetKey is already a mapping of layers to nodes
-        // Convert single nodes to arrays
-        for (const [key, value] of Object.entries(subsetKey)) {
-            if (Array.isArray(value)) {
-                layers[key] = value;
-            }
-            else {
-                layers[key] = [value];
-            }
-        }
-    }
-    const layerCount = Object.keys(layers).length;
-    let pos = {};
-    // Process each layer
-    Object.entries(layers).forEach(([layer, nodes], layerIdx) => {
-        const layerNodes = Array.isArray(nodes) ? nodes : [nodes];
-        const layerSize = layerNodes.length;
-        layerNodes.forEach((node, nodeIdx) => {
-            // Place nodes in a grid: layerIdx determines x-coordinate (column)
-            // nodeIdx determines y-coordinate (row position within column)
-            const x = layerIdx - (layerCount - 1) / 2;
-            const y = nodeIdx - (layerSize - 1) / 2;
-            pos[node] = [x, y];
-        });
-    });
-    // Rescale positions
-    pos = rescaleLayout(pos, scale, center);
-    // Handle horizontal alignment
-    if (align === 'horizontal') {
-        for (const node in pos) {
-            const temp = pos[node][0];
-            pos[node][0] = pos[node][1];
-            pos[node][1] = temp;
-        }
-    }
-    return pos;
-}
-/**
- * Position nodes according to breadth-first search algorithm.
- *
- * @param G - Graph
- * @param start - Starting node for bfs
- * @param align - The alignment of layers: 'vertical' or 'horizontal'
- * @param scale - Scale factor for positions
- * @param center - Coordinate pair around which to center the layout
- * @returns Positions dictionary keyed by node
- */
-function bfsLayout(G, start, align = 'vertical', scale = 1, center = null) {
-    const processed = _processParams(G, center || [0, 0], 2);
-    const graph = processed.G;
-    center = processed.center;
-    const allNodes = getNodesFromGraph(graph);
-    if (allNodes.length === 0) {
-        return {};
-    }
-    // Compute BFS layers
-    const layers = {};
-    const visited = new Set();
-    let currentLayer = 0;
-    // Starting layer
-    layers[currentLayer] = [start];
-    visited.add(start);
-    // BFS traversal
-    while (Object.values(layers).flat().length < allNodes.length) {
-        const nextLayer = [];
-        const currentNodes = layers[currentLayer];
-        for (const node of currentNodes) {
-            // Get neighbors - this is a simplified approach
-            // In a real implementation, we would get neighbors from the graph
-            const neighbors = getNeighbors(graph, node);
-            for (const neighbor of neighbors) {
-                if (!visited.has(neighbor)) {
-                    nextLayer.push(neighbor);
-                    visited.add(neighbor);
-                }
-            }
-        }
-        if (nextLayer.length === 0) {
-            // No more connected nodes
-            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;
-    }
-    // Use multipartite_layout to position the layers
-    return multipartiteLayout(graph, layers, align, scale, center);
-    // Helper function to get neighbors
-    function getNeighbors(graph, node) {
-        if (!graph.edges)
-            return [];
-        return graph.edges()
-            .filter((edge) => edge[0] === node || edge[1] === node)
-            .map((edge) => edge[0] === node ? edge[1] : edge[0]);
-    }
-}
-/**
- * Position nodes without edge intersections (planar layout).
- *
- * @param G - Graph
- * @param scale - Scale factor for positions
- * @param center - Coordinate pair around which to center the layout
- * @param dim - Dimension of layout (must be 2)
- * @returns Positions dictionary keyed by node
- */
-function planarLayout(G, scale = 1, center = null, dim = 2) {
-    if (dim !== 2) {
-        throw new Error("can only handle 2 dimensions");
-    }
-    const processed = _processParams(G, center || [0, 0], dim);
-    const graph = processed.G;
-    center = processed.center;
-    const nodes = getNodesFromGraph(graph);
-    const edges = getEdgesFromGraph(graph);
-    if (nodes.length === 0) {
-        return {};
-    }
-    // Check if graph is planar and get embedding
-    const { isPlanar, embedding } = checkPlanarity(graph, nodes, edges);
-    if (!isPlanar) {
-        throw new Error("G is not planar.");
-    }
-    if (!embedding) {
-        throw new Error("Failed to generate planar embedding.");
-    }
-    // Convert embedding to positions
-    let pos = combinatorialEmbeddingToPos(embedding, nodes);
-    // Rescale the positions
-    pos = rescaleLayout(pos, scale, center);
-    return pos;
-}
-/**
- * Check if graph is planar using a simplified version of Boyer-Myrvold algorithm.
- * Returns planarity and embedding information.
- *
- * @param G - Graph
- * @param nodes - List of nodes
- * @param edges - List of edges
- * @returns Object containing isPlanar flag and embedding
- */
-function checkPlanarity(G, nodes, edges) {
-    // For small graphs (n <= 4), all are planar
-    if (nodes.length <= 4) {
-        return { isPlanar: true, embedding: createTriangulationEmbedding(nodes, edges) };
-    }
-    // For K5 (complete graph with 5 nodes) and K3,3 (complete bipartite with 3,3 nodes)
-    // these are not planar by Kuratowski's theorem
-    if (isK5(nodes, edges) || isK33(nodes, edges)) {
-        return { isPlanar: false, embedding: null };
-    }
-    // For other graphs, use LR algorithm (Left-Right Planarity Test)
-    const result = lrPlanarityTest(nodes, edges);
-    return result;
-}
-/**
- * Check if graph is K5 (complete graph with 5 nodes)
- *
- * @param nodes - List of nodes
- * @param edges - List of edges
- * @returns True if graph is K5
- */
-function isK5(nodes, edges) {
-    if (nodes.length !== 5)
-        return false;
-    // K5 has exactly 10 edges
-    if (edges.length !== 10)
-        return false;
-    // Check if every pair of distinct nodes is connected
-    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;
-}
-/**
- * Check if graph is K3,3 (complete bipartite with 3,3 nodes)
- *
- * @param nodes - List of nodes
- * @param edges - List of edges
- * @returns True if graph is K3,3
- */
-function isK33(nodes, edges) {
-    if (nodes.length !== 6)
-        return false;
-    // K3,3 has exactly 9 edges
-    if (edges.length !== 9)
-        return false;
-    // Try to find a bipartite partition
-    const nodePartitions = tryFindBipartitePartition(nodes, edges);
-    if (!nodePartitions)
-        return false;
-    const [part1, part2] = nodePartitions;
-    // Check if both partitions have size 3
-    if (part1.length !== 3 || part2.length !== 3)
-        return false;
-    // Check if every node in part1 is connected to every node in part2
-    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;
-}
-/**
- * Try to find a bipartite partition of the nodes
- *
- * @param nodes - List of nodes
- * @param edges - List of edges
- * @returns Array of two partitions, or null if not bipartite
- */
-function tryFindBipartitePartition(nodes, edges) {
-    const colorMap = {};
-    const adjList = {};
-    // Create adjacency list
-    for (const node of nodes) {
-        adjList[node] = [];
-    }
-    for (const [u, v] of edges) {
-        adjList[u].push(v);
-        adjList[v].push(u);
-    }
-    // BFS to color nodes
-    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] === undefined) {
-                colorMap[neighbor] = 1 - nodeColor; // Toggle color (0/1)
-                queue.push(neighbor);
-            }
-            else if (colorMap[neighbor] === nodeColor) {
-                // Conflict: not bipartite
-                return null;
-            }
-        }
-    }
-    // Create partitions
-    const part0 = [];
-    const part1 = [];
-    for (const node of nodes) {
-        if (colorMap[node] === 0) {
-            part0.push(node);
-        }
-        else {
-            part1.push(node);
-        }
-    }
-    return [part0, part1];
-}
-/**
- * Left-Right Planarity Test for general graphs
- *
- * @param nodes - List of nodes
- * @param edges - List of edges
- * @returns Object containing isPlanar flag and embedding
- */
-function lrPlanarityTest(nodes, edges) {
-    // Create adjacency list for the graph
-    const adjList = {};
-    for (const node of nodes) {
-        adjList[node] = [];
-    }
-    for (const [u, v] of edges) {
-        adjList[u].push(v);
-        adjList[v].push(u);
-    }
-    // Step 1: Perform DFS to get an st-numbering (ordering of nodes)
-    const visited = new Set();
-    const ordering = [];
-    function dfs(node) {
-        visited.add(node);
-        ordering.push(node);
-        for (const neighbor of adjList[node]) {
-            if (!visited.has(neighbor)) {
-                dfs(neighbor);
-            }
-        }
-    }
-    // Start DFS from first node
-    dfs(nodes[0]);
-    // If the graph is disconnected, it's still planar but we need to handle each component
-    if (ordering.length < nodes.length) {
-        // Create a simple triangulation embedding for disconnected graphs
-        return { isPlanar: true, embedding: createTriangulationEmbedding(nodes, edges) };
-    }
-    // Step 2: For a general implementation, we'll use a simplified approach
-    // since this would normally require implementing the entire LR algorithm
-    // For this implementation, since we can't fully implement Boyer-Myrvold,
-    // we'll create a reasonable planar embedding for most planar graphs
-    // We assume the graph is planar if it's sparse enough (|E| <= 3|V| - 6)
-    // This is a necessary but not sufficient condition for planar graphs
-    if (edges.length > 3 * nodes.length - 6) {
-        return { isPlanar: false, embedding: null };
-    }
-    // Create a planar embedding using a triangulation approach
-    const embedding = createTriangulationEmbedding(nodes, edges);
-    return { isPlanar: true, embedding };
-}
-/**
- * Create a triangulation-based embedding for a planar graph
- *
- * @param nodes - List of nodes
- * @param edges - List of edges
- * @returns Embedding object
- */
-function createTriangulationEmbedding(nodes, edges) {
-    // Create a simple embedding using the incremental approach
-    const embedding = {
-        nodeOrder: [...nodes],
-        faceList: [],
-        nodePositions: {}
-    };
-    // Create a map of adjacent nodes
-    const adjMap = {};
-    for (const node of nodes) {
-        adjMap[node] = new Set();
-    }
-    for (const [u, v] of edges) {
-        adjMap[u].add(v);
-        adjMap[v].add(u);
-    }
-    // Create outer face as a cycle (if possible)
-    const outerFace = findCycle(nodes, edges, adjMap) || nodes;
-    embedding.faceList.push(outerFace);
-    // Position nodes on a convex polygon (outer face)
-    const n = outerFace.length;
-    for (let i = 0; i < n; i++) {
-        const angle = 2 * Math.PI * i / n;
-        embedding.nodePositions[outerFace[i]] = [Math.cos(angle), Math.sin(angle)];
-    }
-    // Position interior nodes using barycentric coordinates
-    const interiorNodes = nodes.filter(node => !embedding.nodePositions[node]);
-    for (const node of interiorNodes) {
-        const neighbors = Array.from(adjMap[node]);
-        if (neighbors.length === 0) {
-            // Isolated node, place at center
-            embedding.nodePositions[node] = [0, 0];
-        }
-        else {
-            // Average position of neighbors that have positions
-            let xSum = 0, ySum = 0, count = 0;
-            for (const neighbor of neighbors) {
-                if (embedding.nodePositions[neighbor]) {
-                    xSum += embedding.nodePositions[neighbor][0];
-                    ySum += embedding.nodePositions[neighbor][1];
-                    count++;
-                }
-            }
-            if (count > 0) {
-                // Place slightly away from center to avoid overlaps
-                const jitter = 0.1 * Math.random();
-                embedding.nodePositions[node] = [
-                    xSum / count + jitter * (Math.random() - 0.5),
-                    ySum / count + jitter * (Math.random() - 0.5)
-                ];
-            }
-            else {
-                // No neighbors have positions yet, place randomly inside unit circle
-                const r = 0.5 * Math.random();
-                const angle = 2 * Math.PI * Math.random();
-                embedding.nodePositions[node] = [r * Math.cos(angle), r * Math.sin(angle)];
-            }
-        }
-    }
-    return embedding;
-}
-/**
- * Find a simple cycle in the graph (for outer face)
- *
- * @param nodes - List of nodes
- * @param edges - List of edges
- * @param adjMap - Adjacency map
- * @returns Cycle as array of nodes, or null if none found
- */
-function findCycle(nodes, edges, adjMap) {
-    if (nodes.length === 0)
-        return null;
-    if (nodes.length <= 2)
-        return nodes; // Not a real cycle but handle it
-    // Try to find a Hamiltonian cycle for simplicity (for small graphs)
-    if (nodes.length <= 8) {
-        const visited = new Set();
-        const path = [];
-        function hamiltonianCycleDFS(node) {
-            path.push(node);
-            visited.add(node);
-            if (path.length === nodes.length) {
-                // Check if it's a cycle (last node connects to first)
-                if (adjMap[node].has(path[0])) {
-                    return true;
-                }
-                // Not a cycle
-                visited.delete(node);
-                path.pop();
-                return false;
-            }
-            for (const neighbor of adjMap[node]) {
-                if (!visited.has(neighbor)) {
-                    if (hamiltonianCycleDFS(neighbor)) {
-                        return true;
-                    }
-                }
-            }
-            visited.delete(node);
-            path.pop();
-            return false;
-        }
-        if (hamiltonianCycleDFS(nodes[0])) {
-            return path;
-        }
-    }
-    // Fallback: try to find any cycle using DFS
-    const visited = new Set();
-    const parent = {};
-    let cycleFound = null;
-    function findCycleDFS(node, parentNode) {
-        visited.add(node);
-        for (const neighbor of adjMap[node]) {
-            if (neighbor === parentNode)
-                continue;
-            if (visited.has(neighbor)) {
-                // Found a cycle
-                cycleFound = constructCycle(node, neighbor, parent);
-                return true;
-            }
-            parent[neighbor] = node;
-            if (findCycleDFS(neighbor, node)) {
-                return true;
-            }
-        }
-        return false;
-    }
-    function constructCycle(u, v, parent) {
-        const cycle = [v, u];
-        let current = u;
-        while (parent[current] !== undefined && parent[current] !== v) {
-            current = parent[current];
-            cycle.push(current);
-        }
-        return cycle;
-    }
-    // Try to find a cycle
-    for (const node of nodes) {
-        if (!visited.has(node)) {
-            parent[node] = null;
-            if (findCycleDFS(node, null)) {
-                break;
-            }
-        }
-    }
-    return cycleFound || nodes; // Fallback to all nodes if no cycle found
-}
-/**
- * Convert a combinatorial embedding to node positions
- *
- * @param embedding - The embedding object
- * @param nodes - List of nodes
- * @returns Dictionary mapping nodes to positions
- */
-function combinatorialEmbeddingToPos(embedding, nodes) {
-    const pos = {};
-    // Use the positions from the embedding
-    for (const node of nodes) {
-        if (embedding.nodePositions[node]) {
-            pos[node] = embedding.nodePositions[node];
-        }
-        else {
-            // Fallback for any nodes without positions
-            pos[node] = [0, 0];
-        }
-    }
-    return pos;
-}
-/**
- * Position nodes using Kamada-Kawai path-length cost-function.
- *
- * @param G - NetworkX graph or list of nodes
- * @param dist - A two-level dictionary of optimal distances between nodes
- * @param pos - Initial positions for nodes
- * @param weight - The edge attribute used for edge weights
- * @param scale - Scale factor for positions
- * @param center - Coordinate pair around which to center the layout
- * @param dim - Dimension of layout
- * @returns Positions dictionary keyed by node
- */
-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 };
-    }
-    // Initialize distance matrix
-    if (!dist) {
-        dist = _computeShortestPathDistances(graph, weight);
-    }
-    // Convert distances to a matrix
-    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] !== undefined) {
-                distMatrix[i][j] = dist[nodeI][nodeJ];
-            }
-        }
-    }
-    // Initialize positions if not provided
-    if (!pos) {
-        if (dim >= 2) {
-            // Use circular/spherical layout for 2D and 3D
-            pos = circularLayout(G, 1, center, dim);
-        }
-        else {
-            // For 1D, use a linear layout
-            const posArray = {};
-            nodesArray.forEach((node, i) => {
-                posArray[node] = [i / (nNodes - 1 || 1)];
-            });
-            pos = posArray;
-        }
-    }
-    // Convert positions to array for computation
-    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);
-        // Ensure correct dimensionality
-        while (posArray[i].length < dim) {
-            posArray[i].push(0);
-        }
-    }
-    // Run the Kamada-Kawai algorithm
-    const newPositions = _kamadaKawaiSolve(distMatrix, posArray, dim);
-    // Convert positions array back to dictionary and rescale
-    const finalPos = {};
-    for (let i = 0; i < nNodes; i++) {
-        finalPos[nodesArray[i]] = newPositions[i];
-    }
-    return rescaleLayout(finalPos, scale, center);
-}
-/**
- * Compute all-pairs shortest path distances for the graph
- *
- * @param G - NetworkX graph
- * @param weight - Edge attribute for weight
- * @returns Dictionary of dictionaries of shortest path distances
- */
-function _computeShortestPathDistances(G, weight) {
-    const distances = {};
-    const nodes = G.nodes ? G.nodes() : G;
-    const edges = G.edges ? G.edges() : [];
-    // Initialize distances with direct edges
-    for (const node of nodes) {
-        distances[node] = {};
-        distances[node][node] = 0;
-        for (const other of nodes) {
-            if (node !== other) {
-                distances[node][other] = Infinity;
-            }
-        }
-    }
-    // Add direct edges
-    for (const [source, target] of edges) {
-        // In a real implementation, we would get the weight from the graph
-        // For now, assume weight = 1 or use weight attribute if available
-        let edgeWeight = 1;
-        if (G.getEdgeData) {
-            edgeWeight = G.getEdgeData(source, target, weight) || 1;
-        }
-        distances[source][target] = edgeWeight;
-        distances[target][source] = edgeWeight; // Assuming undirected graph
-    }
-    // Floyd-Warshall algorithm for all-pairs shortest paths
-    for (const k of nodes) {
-        for (const i of nodes) {
-            for (const j of nodes) {
-                if (distances[i][k] + distances[k][j] < distances[i][j]) {
-                    distances[i][j] = distances[i][k] + distances[k][j];
-                }
-            }
-        }
-    }
-    return distances;
-}
-/**
- * Solve the Kamada-Kawai layout optimization problem
- *
- * @param distMatrix - Matrix of desired distances between nodes
- * @param positions - Initial node positions
- * @param dim - Dimension of layout
- * @returns Optimized node positions
- */
-function _kamadaKawaiSolve(distMatrix, positions, dim) {
-    // Implementation of L-BFGS optimization for Kamada-Kawai
-    const nNodes = positions.length;
-    const meanWeight = 1e-3;
-    // Convert distances to inverse distances (with protection against division by zero)
-    const invDistMatrix = distMatrix.map(row => row.map(d => d === 0 ? 0 : 1 / (d + 1e-3)));
-    // Flatten positions for optimization
-    let posVec = positions.flat();
-    // Optimization parameters
-    const maxIter = 500;
-    const gtol = 1e-5;
-    const m = 10; // L-BFGS memory size
-    // Implement a simplified L-BFGS-B algorithm
-    let alpha = 1.0;
-    const oldValues = [];
-    const oldGrads = [];
-    for (let iter = 0; iter < maxIter; iter++) {
-        // Calculate cost and gradient
-        const [cost, grad] = _kamadaKawaiCostfn(posVec, invDistMatrix, meanWeight, dim);
-        // Compute search direction using L-BFGS approximation
-        const direction = _lbfgsDirection(grad, oldValues, oldGrads, m);
-        // Simple line search for step size
-        alpha = _backtrackingLineSearch(posVec, direction, cost, grad, (x) => _kamadaKawaiCostfn(x, invDistMatrix, meanWeight, dim)[0], alpha);
-        // Save current position and gradient for next iteration
-        const oldPos = [...posVec];
-        // Update position
-        for (let i = 0; i < posVec.length; i++) {
-            posVec[i] += alpha * direction[i];
-        }
-        // Calculate new gradient
-        const [, newGrad] = _kamadaKawaiCostfn(posVec, invDistMatrix, meanWeight, dim);
-        // Update L-BFGS memory
-        oldValues.push(posVec.map((val, i) => val - oldPos[i]));
-        oldGrads.push(newGrad.map((val, i) => val - grad[i]));
-        // Keep only m most recent updates
-        if (oldValues.length > m) {
-            oldValues.shift();
-            oldGrads.shift();
-        }
-        // Check convergence
-        const gradNorm = Math.sqrt(newGrad.reduce((sum, g) => sum + g * g, 0));
-        if (gradNorm < gtol) {
-            break;
-        }
-    }
-    // Reshape result back into positions array
-    const result = [];
-    for (let i = 0; i < nNodes; i++) {
-        result.push(posVec.slice(i * dim, (i + 1) * dim));
-    }
-    return result;
-}
-/**
- * Cost function and gradient for Kamada-Kawai layout algorithm
- *
- * @param posVec - Flattened position array
- * @param invDist - Inverse distance matrix
- * @param meanWeight - Weight for centering positions
- * @param dim - Dimension of layout
- * @returns Array with [cost, gradient]
- */
-function _kamadaKawaiCostfn(posVec, invDist, meanWeight, dim) {
-    const nNodes = invDist.length;
-    const positions = [];
-    // Reshape flat vector into positions array
-    for (let i = 0; i < nNodes; i++) {
-        positions.push(posVec.slice(i * dim, (i + 1) * dim));
-    }
-    // Calculate cost
-    let cost = 0;
-    // Add mean position penalty term
-    const sumPos = Array(dim).fill(0);
-    for (let i = 0; i < nNodes; i++) {
-        for (let d = 0; d < dim; d++) {
-            sumPos[d] += positions[i][d];
-        }
-    }
-    cost += 0.5 * meanWeight * sumPos.reduce((sum, val) => sum + val * val, 0);
-    // Add distance penalty terms
-    for (let i = 0; i < nNodes; i++) {
-        for (let j = i + 1; j < nNodes; j++) {
-            // Calculate actual distance
-            const diff = positions[i].map((val, d) => val - positions[j][d]);
-            const distance = Math.sqrt(diff.reduce((sum, d) => sum + d * d, 0));
-            // Add penalty for difference between actual and ideal distance
-            const idealInvDist = invDist[i][j];
-            const offset = distance * idealInvDist - 1.0;
-            cost += 0.5 * offset * offset;
-        }
-    }
-    // Calculate gradient
-    const grad = new Array(posVec.length).fill(0);
-    // Add gradient of mean position penalty
-    for (let i = 0; i < nNodes; i++) {
-        for (let d = 0; d < dim; d++) {
-            grad[i * dim + d] += meanWeight * sumPos[d];
-        }
-    }
-    // Add gradient of distance penalties
-    for (let i = 0; i < nNodes; i++) {
-        for (let j = i + 1; j < nNodes; j++) {
-            // Calculate actual distance and direction
-            const diff = positions[i].map((val, d) => val - positions[j][d]);
-            const distance = Math.sqrt(diff.reduce((sum, d) => sum + d * d, 0)) || 1e-10;
-            const direction = diff.map(d => d / distance);
-            // Calculate contribution to gradient
-            const idealInvDist = invDist[i][j];
-            const offset = distance * idealInvDist - 1.0;
-            for (let d = 0; d < dim; d++) {
-                const force = idealInvDist * offset * direction[d];
-                grad[i * dim + d] += force;
-                grad[j * dim + d] -= force;
-            }
-        }
-    }
-    return [cost, grad];
-}
-/**
- * Compute the search direction using L-BFGS approximation
- *
- * @param grad - Current gradient
- * @param sList - List of position differences (s_k)
- * @param yList - List of gradient differences (y_k)
- * @param m - Memory size
- * @returns Direction vector
- */
-function _lbfgsDirection(grad, sList, yList, m) {
-    if (sList.length === 0) {
-        // First iteration - use negative gradient
-        return grad.map(g => -g);
-    }
-    const q = grad.slice();
-    const alpha = Array(sList.length).fill(0);
-    const rho = [];
-    // Compute rho values
-    for (let i = 0; i < sList.length; i++) {
-        const s = sList[i];
-        const y = yList[i];
-        rho.push(1 / y.reduce((sum, val, j) => sum + val * s[j], 0));
-    }
-    // Forward pass
-    for (let i = sList.length - 1; i >= 0; i--) {
-        const s = sList[i];
-        alpha[i] = rho[i] * s.reduce((sum, val, j) => sum + val * q[j], 0);
-        for (let j = 0; j < q.length; j++) {
-            q[j] -= alpha[i] * yList[i][j];
-        }
-    }
-    // Scale initial Hessian approximation
-    let gamma = 1;
-    if (sList.length > 0 && yList.length > 0) {
-        const y = yList[yList.length - 1];
-        const s = sList[sList.length - 1];
-        gamma = s.reduce((sum, val, i) => sum + val * y[i], 0) /
-            y.reduce((sum, val) => sum + val * val, 0);
-    }
-    // Initialize direction with scaled negative gradient
-    const direction = q.map(val => -gamma * val);
-    // Backward pass
-    for (let i = 0; i < sList.length; i++) {
-        const s = sList[i];
-        const y = yList[i];
-        const beta = rho[i] * y.reduce((sum, val, j) => sum + val * direction[j], 0);
-        for (let j = 0; j < direction.length; j++) {
-            direction[j] += s[j] * (alpha[i] - beta);
-        }
-    }
-    return direction;
-}
-/**
- * Backtracking line search to find step size
- *
- * @param x - Current position
- * @param direction - Search direction
- * @param f - Function value at current position
- * @param grad - Gradient at current position
- * @param func - Function to evaluate cost
- * @param alpha0 - Initial step size
- * @returns Optimal step size
- */
-function _backtrackingLineSearch(x, direction, f, grad, func, alpha0) {
-    const c1 = 1e-4;
-    const c2 = 0.9;
-    const initialSlope = grad.reduce((sum, g, i) => sum + g * direction[i], 0);
-    if (initialSlope >= 0) {
-        return 1e-8; // Direction is not a descent direction
-    }
-    let alpha = alpha0;
-    const maxIter = 20;
-    for (let i = 0; i < maxIter; i++) {
-        // Try step
-        const newX = x.map((val, i) => val + alpha * direction[i]);
-        const newF = func(newX);
-        // Check sufficient decrease condition (Armijo condition)
-        if (newF <= f + c1 * alpha * initialSlope) {
-            return alpha;
-        }
-        // Reduce step size
-        alpha *= c2;
-    }
-    return alpha; // Return last alpha even if not optimal
-}
-/**
- * Position nodes using the ForceAtlas2 force-directed algorithm.
- *
- * @param G - Graph
- * @param pos - Initial positions for nodes
- * @param maxIter - Maximum number of iterations
- * @param jitterTolerance - Controls tolerance for node speed adjustments
- * @param scalingRatio - Scaling of attraction and repulsion forces
- * @param gravity - Attraction to center to prevent disconnected components from drifting
- * @param distributedAction - Distributes attraction force among nodes
- * @param strongGravity - Uses a stronger gravity model
- * @param nodeMass - Dictionary mapping nodes to their masses
- * @param nodeSize - Dictionary mapping nodes to their sizes
- * @param weight - Edge attribute for weight
- * @param dissuadeHubs - Whether to prevent hub nodes from clustering
- * @param linlog - Whether to use logarithmic attraction
- * @param seed - Random seed for initial positions
- * @param dim - Dimension of layout
- * @returns Positions dictionary keyed by node
- */
-function forceatlas2Layout(G, pos = null, maxIter = 100, jitterTolerance = 1.0, scalingRatio = 2.0, gravity = 1.0, 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 {};
-    }
-    // Initialize random number generator
-    const rng = new RandomNumberGenerator(seed ?? undefined);
-    // Initialize positions if not provided
-    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) {
-        // Use provided positions
-        posArray = new Array(nodes.length);
-        for (let i = 0; i < nodes.length; i++) {
-            posArray[i] = [...pos[nodes[i]]];
-        }
-    }
-    else {
-        // Some nodes don't have positions, initialize within the range of existing positions
-        let minPos = Array(dim).fill(Number.POSITIVE_INFINITY);
-        let maxPos = Array(dim).fill(Number.NEGATIVE_INFINITY);
-        // Find min and max of existing positions
-        for (const node in pos) {
-            for (let d = 0; d < dim; d++) {
-                minPos[d] = Math.min(minPos[d], pos[node][d]);
-                maxPos[d] = Math.max(maxPos[d], pos[node][d]);
-            }
-        }
-        posArray = new Array(nodes.length);
-        for (let i = 0; i < nodes.length; i++) {
-            const node = nodes[i];
-            if (pos[node]) {
-                posArray[i] = [...pos[node]];
-            }
-            else {
-                posArray[i] = Array(dim).fill(0).map((_, d) => minPos[d] + rng.rand() * (maxPos[d] - minPos[d]));
-                pos[node] = posArray[i];
-            }
-        }
-    }
-    // Initialize mass and size arrays
-    const mass = new Array(nodes.length).fill(0);
-    const size = new Array(nodes.length).fill(0);
-    // Flag to track whether to adjust for node sizes
-    const adjustSizes = nodeSize !== null;
-    // Set node masses and sizes
-    for (let i = 0; i < nodes.length; i++) {
-        const node = nodes[i];
-        mass[i] = nodeMass && nodeMass[node] ?
-            nodeMass[node] :
-            (graph.edges ? getNodeDegree(graph, node) + 1 : 1);
-        size[i] = nodeSize && nodeSize[node] ? nodeSize[node] : 1;
-    }
-    // Create adjacency matrix
-    const n = nodes.length;
-    const A = Array(n).fill(0).map(() => Array(n).fill(0));
-    // Populate adjacency matrix with edge weights
-    const edges = graph.edges ? 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];
-        // Use edge weight if provided, otherwise default to 1
-        let edgeWeight = 1;
-        if (weight && graph.getEdgeData) {
-            edgeWeight = graph.getEdgeData(source, target, weight) || 1;
-        }
-        A[i][j] = edgeWeight;
-        A[j][i] = edgeWeight; // For undirected graphs
-    }
-    // Initialize force arrays
-    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));
-    // Simulation parameters
-    let speed = 1;
-    let speedEfficiency = 1;
-    let swing = 1;
-    let traction = 1;
-    // Helper function to estimate factor for force scaling
-    function estimateFactor(n, swing, traction, speed, speedEfficiency, jitterTolerance) {
-        // Optimal jitter parameters
-        const optJitter = 0.05 * Math.sqrt(n);
-        const minJitter = Math.sqrt(optJitter);
-        const maxJitter = 10;
-        const minSpeedEfficiency = 0.05;
-        // Estimate jitter based on current state
-        const other = Math.min(maxJitter, optJitter * traction / (n * n));
-        let jitter = jitterTolerance * Math.max(minJitter, other);
-        // Adjust speed efficiency based on swing/traction ratio
-        if (swing / traction > 2.0) {
-            if (speedEfficiency > minSpeedEfficiency) {
-                speedEfficiency *= 0.5;
-            }
-            jitter = Math.max(jitter, jitterTolerance);
-        }
-        // Calculate target speed
-        let targetSpeed = swing === 0 ?
-            Number.POSITIVE_INFINITY :
-            jitter * speedEfficiency * traction / swing;
-        // Further adjust speed efficiency
-        if (swing > jitter * traction) {
-            if (speedEfficiency > minSpeedEfficiency) {
-                speedEfficiency *= 0.7;
-            }
-        }
-        else if (speed < 1000) {
-            speedEfficiency *= 1.3;
-        }
-        // Limit the speed increase
-        const maxRise = 0.5;
-        speed = speed + Math.min(targetSpeed - speed, maxRise * speed);
-        return [speed, speedEfficiency];
-    }
-    // Main simulation loop
-    for (let iter = 0; iter < maxIter; iter++) {
-        // Reset forces for this iteration
-        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;
-            }
-        }
-        // Compute pairwise differences and distances
-        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));
-                // Prevent division by zero
-                if (distance[i][j] < 0.01)
-                    distance[i][j] = 0.01;
-            }
-        }
-        // Calculate attraction forces
-        if (linlog) {
-            // Logarithmic attraction model
-            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 {
-            // Linear attraction model
-            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;
-                    }
-                }
-            }
-        }
-        // Apply distributed attraction if enabled
-        if (distributedAction) {
-            for (let i = 0; i < n; i++) {
-                for (let d = 0; d < dim; d++) {
-                    attraction[i][d] /= mass[i];
-                }
-            }
-        }
-        // Calculate repulsion forces
-        for (let i = 0; i < n; i++) {
-            for (let j = 0; j < n; j++) {
-                if (i === j)
-                    continue;
-                let dist = distance[i][j];
-                // Adjust distance for node sizes if needed
-                if (adjustSizes) {
-                    dist -= size[i] - size[j];
-                    dist = Math.max(dist, 0.01); // Prevent negative or zero distances
-                }
-                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;
-                }
-            }
-        }
-        // Calculate gravity forces
-        // First find the center of mass
-        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) {
-                // Strong gravity model
-                for (let d = 0; d < dim; d++) {
-                    gravities[i][d] = -gravity * mass[i] * posCentered[d];
-                }
-            }
-            else {
-                // Regular gravity model
-                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;
-                    }
-                }
-            }
-        }
-        // Calculate total forces and update positions
-        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];
-            }
-            // Calculate swing and traction for this node
-            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;
-        }
-        // Update speed and efficiency
-        [speed, speedEfficiency] = estimateFactor(n, totalSwing, totalTraction, speed, speedEfficiency, jitterTolerance);
-        // Apply forces to update positions
-        let totalMovement = 0;
-        for (let i = 0; i < n; i++) {
-            let factor;
-            if (adjustSizes) {
-                // Calculate displacement magnitude
-                const df = Math.sqrt(update[i].reduce((sum, val) => sum + val * val, 0));
-                const swinging = mass[i] * df;
-                // Determine scaling factor with size adjustments
-                factor = 0.1 * speed / (1 + Math.sqrt(speed * swinging));
-                factor = Math.min(factor * df, 10) / df;
-            }
-            else {
-                // Standard scaling factor
-                const swinging = mass[i] * Math.sqrt(update[i].reduce((sum, val) => sum + val * val, 0));
-                factor = speed / (1 + Math.sqrt(speed * swinging));
-            }
-            // Apply factor to update position
-            for (let d = 0; d < dim; d++) {
-                const movement = update[i][d] * factor;
-                posArray[i][d] += movement;
-                totalMovement += Math.abs(movement);
-            }
-        }
-        // Check for convergence
-        if (totalMovement < 1e-10) {
-            break;
-        }
-    }
-    // Create position dictionary
-    const positions = {};
-    for (let i = 0; i < n; i++) {
-        positions[nodes[i]] = posArray[i];
-    }
-    return rescaleLayout(positions);
-    // Helper function to get node degree
-    function getNodeDegree(graph, node) {
-        if (!graph.edges)
-            return 0;
-        return graph.edges().filter((edge) => edge[0] === node || edge[1] === node).length;
-    }
-}
-/**
- * Layout algorithm with attractive and repulsive forces (ARF).
- *
- * @param G - Graph
- * @param pos - Initial positions for nodes
- * @param scaling - Scale factor for positions
- * @param a - Strength of springs between connected nodes (should be > 1)
- * @param maxIter - Maximum number of iterations
- * @param seed - Random seed for initial positions
- * @returns Positions dictionary keyed by node
- */
-function arfLayout(G, pos = null, scaling = 1, a = 1.1, maxIter = 1000, 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 {};
-    }
-    // Initialize positions if not provided
-    if (!pos) {
-        pos = randomLayout(G, null, 2, seed);
-    }
-    else {
-        // Make sure all nodes have positions
-        const rng = new RandomNumberGenerator(seed ?? undefined);
-        const defaultPos = {};
-        nodes.forEach((node) => {
-            if (!pos[node]) {
-                defaultPos[node] = [rng.rand(), rng.rand()];
-            }
-        });
-        pos = { ...pos, ...defaultPos };
-    }
-    // Create node index mapping
-    const nodeIndex = {};
-    nodes.forEach((node, i) => {
-        nodeIndex[node] = i;
-    });
-    // Create positions array
-    const positions = nodes.map((node) => [...pos[node]]);
-    // Initialize spring constant matrix
-    const N = nodes.length;
-    const K = Array(N).fill(0).map(() => Array(N).fill(1));
-    // Set diagonal to zero (no self-attraction)
-    for (let i = 0; i < N; i++) {
-        K[i][i] = 0;
-    }
-    // Set stronger attraction between connected 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;
-    }
-    // Calculate rho (scale factor)
-    const rho = scaling * Math.sqrt(N);
-    // Optimization loop
-    const dt = 1e-3; // Time step
-    const etol = 1e-6; // Error tolerance
-    let error = etol + 1;
-    let nIter = 0;
-    while (error > etol && nIter < maxIter) {
-        // Calculate changes for each node
-        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;
-                // Calculate difference vector
-                const diff = positions[i].map((coord, dim) => coord - positions[j][dim]);
-                // Calculate distance (with minimum to avoid division by zero)
-                const dist = Math.sqrt(diff.reduce((sum, d) => sum + d * d, 0)) || 0.01;
-                // Calculate attractive and repulsive forces
-                for (let d = 0; d < diff.length; d++) {
-                    change[i][d] += K[i][j] * diff[d] - (rho / dist) * diff[d];
-                }
-            }
-        }
-        // Update positions
-        for (let i = 0; i < N; i++) {
-            for (let d = 0; d < positions[i].length; d++) {
-                positions[i][d] += change[i][d] * dt;
-            }
-        }
-        // Calculate error (sum of force magnitudes)
-        error = change.reduce((sum, c) => sum + Math.sqrt(c.reduce((s, v) => s + v * v, 0)), 0);
-        nIter++;
-    }
-    // Convert positions array back to object
-    const finalPos = {};
-    nodes.forEach((node, i) => {
-        finalPos[node] = positions[i];
-    });
-    return finalPos;
-}
-/**
- * Return a dictionary of scaled positions keyed by node.
- *
- * @param pos - Dictionary of positions keyed by node
- * @param scale - Scale factor for positions
- * @returns Dictionary of scaled positions
- */
-function rescaleLayoutDict(pos, scale = 1) {
-    if (Object.keys(pos).length === 0) {
-        return {};
-    }
-    // Extract positions as array
-    const posArray = Object.values(pos);
-    // Find center of positions
-    const center = [];
-    for (let d = 0; d < posArray[0].length; d++) {
-        center[d] = posArray.reduce((sum, p) => sum + p[d], 0) / posArray.length;
-    }
-    // Center positions
-    const centeredPos = {};
-    for (const [node, p] of Object.entries(pos)) {
-        centeredPos[node] = p.map((val, d) => val - center[d]);
-    }
-    // Find maximum distance from center
-    let maxDist = 0;
-    for (const p of Object.values(centeredPos)) {
-        const dist = Math.sqrt(p.reduce((sum, val) => sum + val * val, 0));
-        maxDist = Math.max(maxDist, dist);
-    }
-    // Scale positions
-    const scaledPos = {};
-    if (maxDist > 0) {
-        for (const [node, p] of Object.entries(centeredPos)) {
-            scaledPos[node] = p.map(val => val * scale / maxDist);
-        }
-    }
-    else {
-        // All points at the center
-        for (const node of Object.keys(centeredPos)) {
-            scaledPos[node] = Array(centeredPos[node].length).fill(0);
-        }
-    }
-    return scaledPos;
-}
-// Graph generation utilities
-/**
- * Create a complete graph with n nodes
- * @param n - Number of nodes
- * @returns Graph object with all nodes connected to all other nodes
- */
-function completeGraph(n) {
-    const nodes = Array.from({ length: n }, (_, i) => i);
-    const edges = [];
-    for (let i = 0; i < n; i++) {
-        for (let j = i + 1; j < n; j++) {
-            edges.push([i, j]);
-        }
-    }
-    return {
-        nodes: () => nodes,
-        edges: () => edges
-    };
-}
-/**
- * Create a cycle graph with n nodes
- * @param n - Number of nodes
- * @returns Graph object with nodes connected in a cycle
- */
-function cycleGraph(n) {
-    const nodes = Array.from({ length: n }, (_, i) => i);
-    const edges = [];
-    for (let i = 0; i < n; i++) {
-        edges.push([i, (i + 1) % n]);
-    }
-    return {
-        nodes: () => nodes,
-        edges: () => edges
-    };
-}
-/**
- * Create a star graph with n nodes (1 center + n-1 leaves)
- * @param n - Total number of nodes
- * @returns Graph object with star topology
- */
-function starGraph(n) {
-    const nodes = Array.from({ length: n }, (_, i) => i);
-    const edges = [];
-    // Connect all nodes to node 0 (center)
-    for (let i = 1; i < n; i++) {
-        edges.push([0, i]);
-    }
-    return {
-        nodes: () => nodes,
-        edges: () => edges
-    };
-}
-/**
- * Create a wheel graph with n nodes (1 center + n-1 rim nodes)
- * @param n - Total number of nodes
- * @returns Graph object with wheel topology
- */
-function wheelGraph(n) {
-    const nodes = Array.from({ length: n }, (_, i) => i);
-    const edges = [];
-    // Connect all rim nodes to center (node 0)
-    for (let i = 1; i < n; i++) {
-        edges.push([0, i]);
-    }
-    // Connect rim nodes in a cycle
-    for (let i = 1; i < n - 1; i++) {
-        edges.push([i, i + 1]);
-    }
-    if (n > 2) {
-        edges.push([n - 1, 1]);
-    }
-    return {
-        nodes: () => nodes,
-        edges: () => edges
-    };
-}
-/**
- * Create a grid graph with rows x cols nodes
- * @param rows - Number of rows
- * @param cols - Number of columns
- * @returns Graph object with grid topology
- */
-function gridGraph(rows, cols) {
-    const nodes = [];
-    const edges = [];
-    // Create nodes
-    for (let i = 0; i < rows; i++) {
-        for (let j = 0; j < cols; j++) {
-            nodes.push(`${i},${j}`);
-        }
-    }
-    // Create edges
-    for (let i = 0; i < rows; i++) {
-        for (let j = 0; j < cols; j++) {
-            // Connect to right neighbor
-            if (j < cols - 1) {
-                edges.push([`${i},${j}`, `${i},${j + 1}`]);
-            }
-            // Connect to bottom neighbor
-            if (i < rows - 1) {
-                edges.push([`${i},${j}`, `${i + 1},${j}`]);
-            }
-        }
-    }
-    return {
-        nodes: () => nodes,
-        edges: () => edges
-    };
-}
-/**
- * Create a random graph with n nodes and given edge probability
- * @param n - Number of nodes
- * @param p - Probability of edge between any two nodes (0-1)
- * @param seed - Random seed for reproducibility
- * @returns Graph object with random edges
- */
-function randomGraph(n, p, seed) {
-    const nodes = Array.from({ length: n }, (_, i) => i);
-    const edges = [];
-    // Simple deterministic pseudo-random if seed provided
-    let currentSeed = seed;
-    let random = seed !== undefined
-        ? () => {
-            currentSeed = (currentSeed * 9301 + 49297) % 233280;
-            return currentSeed / 233280;
-        }
-        : Math.random;
-    for (let i = 0; i < n; i++) {
-        for (let j = i + 1; j < n; j++) {
-            if (random() < p) {
-                edges.push([i, j]);
-            }
-        }
-    }
-    return {
-        nodes: () => nodes,
-        edges: () => edges
-    };
-}
-/**
- * Create a bipartite graph with two sets of nodes
- * @param n1 - Number of nodes in first set
- * @param n2 - Number of nodes in second set
- * @param p - Probability of edge between nodes in different sets
- * @param seed - Random seed for reproducibility
- * @returns Graph object with bipartite structure and setA/setB properties
- */
-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 = [];
-    // Simple deterministic pseudo-random if seed provided
-    let currentSeed = seed;
-    let random = seed !== undefined
-        ? () => {
-            currentSeed = (currentSeed * 9301 + 49297) % 233280;
-            return currentSeed / 233280;
-        }
-        : Math.random;
-    // Only connect nodes between sets
-    for (const a of setA) {
-        for (const b of setB) {
-            if (random() < p) {
-                edges.push([a, b]);
-            }
-        }
-    }
-    return {
-        nodes: () => nodes,
-        edges: () => edges,
-        setA,
-        setB
-    };
-}
-/**
- * Create a scale-free graph using Barabási-Albert model
- * @param n - Total number of nodes
- * @param m - Number of edges to attach from new node
- * @param seed - Random seed for reproducibility
- * @returns Graph object with scale-free properties
- */
-function scaleFreeGraph(n, m, seed) {
-    if (m >= n) {
-        throw new Error('m must be less than n');
-    }
-    const nodes = Array.from({ length: n }, (_, i) => i);
-    const edges = [];
-    const degrees = new Array(n).fill(0);
-    // Simple deterministic pseudo-random if seed provided
-    let currentSeed = seed;
-    let random = seed !== undefined
-        ? () => {
-            currentSeed = (currentSeed * 9301 + 49297) % 233280;
-            return currentSeed / 233280;
-        }
-        : Math.random;
-    // Start with complete graph of m+1 nodes
-    for (let i = 0; i <= m; i++) {
-        for (let j = i + 1; j <= m; j++) {
-            edges.push([i, j]);
-            degrees[i]++;
-            degrees[j]++;
-        }
-    }
-    // Add remaining nodes
-    for (let i = m + 1; i < n; i++) {
-        const targets = new Set();
-        const totalDegree = degrees.reduce((sum, d) => sum + d, 0);
-        // Choose m targets based on preferential attachment
-        while (targets.size < m) {
-            let r = random() * totalDegree;
-            let cumSum = 0;
-            for (let j = 0; j < i; j++) {
-                cumSum += degrees[j];
-                if (r <= cumSum && !targets.has(j)) {
-                    targets.add(j);
-                    break;
-                }
-            }
-        }
-        // Add edges to targets
-        for (const target of targets) {
-            edges.push([i, target]);
-            degrees[i]++;
-            degrees[target]++;
-        }
-    }
-    return {
-        nodes: () => nodes,
-        edges: () => edges
-    };
-}
-// Export the layout functions
-export { randomLayout, circularLayout, shellLayout, springLayout, fruchtermanReingoldLayout, spectralLayout, spiralLayout, bipartiteLayout, multipartiteLayout, bfsLayout, planarLayout, kamadaKawaiLayout, forceatlas2Layout, arfLayout, rescaleLayout, rescaleLayoutDict, 
-// Graph generation utilities
-completeGraph, cycleGraph, starGraph, wheelGraph, gridGraph, randomGraph, bipartiteGraph, scaleFreeGraph };
-//# sourceMappingURL=layout.js.map