@antv/layout 2.0.0-alpha.2 → 2.0.0-alpha.3

package/dist/index.js

@@ -357,1195 +357,1257 @@
         return result;
     });
 
-    class GraphLib {
-        constructor(data, options = {}) {
-            this.edgeIdCounter = new Map();
-            this.nodeMap = extractNodeData(data.nodes, options.node);
-            this.edgeMap = extractEdgeData(data.edges || [], options.edge, this.getEdgeId.bind(this));
-        }
-        data() {
-            return { nodes: this.nodeMap, edges: this.edgeMap };
-        }
-        replace(result) {
-            this.nodeMap = result.nodes;
-            this.edgeMap = result.edges;
-            this.clearCache();
-        }
-        nodes() {
-            return Array.from(this.nodeMap.values());
-        }
-        node(id) {
-            return this.nodeMap.get(id);
-        }
-        nodeAt(index) {
-            if (!this.indexNodeCache) {
-                this.buildNodeIndexCache();
-            }
-            const nodeId = this.indexNodeCache.get(index);
-            return nodeId ? this.nodeMap.get(nodeId) : undefined;
-        }
-        nodeIndexOf(id) {
-            var _a;
-            if (!this.nodeIndexCache) {
-                this.buildNodeIndexCache();
-            }
-            return (_a = this.nodeIndexCache.get(id)) !== null && _a !== void 0 ? _a : -1;
-        }
-        firstNode() {
-            return this.nodeMap.values().next().value;
-        }
-        forEachNode(callback) {
-            let i = 0;
-            this.nodeMap.forEach((node) => callback(node, i++));
-        }
-        originalNode(id) {
-            const node = this.nodeMap.get(id);
-            return node === null || node === void 0 ? void 0 : node._original;
-        }
-        nodeCount() {
-            return this.nodeMap.size;
-        }
-        edges() {
-            return Array.from(this.edgeMap.values());
-        }
-        edge(id) {
-            return this.edgeMap.get(id);
-        }
-        firstEdge() {
-            return this.edgeMap.values().next().value;
-        }
-        forEachEdge(callback) {
-            let i = 0;
-            this.edgeMap.forEach((edge) => callback(edge, i++));
-        }
-        originalEdge(id) {
-            const edge = this.edgeMap.get(id);
-            return edge === null || edge === void 0 ? void 0 : edge._original;
-        }
-        edgeCount() {
-            return this.edgeMap.size;
-        }
-        getEdgeId(edge) {
-            if (edge.id)
-                return edge.id;
-            const baseId = `${edge.source}-${edge.target}`;
-            const count = this.edgeIdCounter.get(baseId) || 0;
-            const id = count === 0 ? baseId : `${baseId}-${count}`;
-            this.edgeIdCounter.set(baseId, count + 1);
-            return id;
-        }
-        degree(nodeId, direction = 'both') {
-            if (!this.degreeCache) {
-                this.buildDegreeCache();
-            }
-            const degree = this.degreeCache.get(nodeId);
-            if (!degree)
-                return 0;
-            return degree[direction];
-        }
-        neighbors(nodeId, direction = 'both') {
-            if (!this.outAdjacencyCache || !this.inAdjacencyCache) {
-                this.buildAdjacencyCache();
-            }
-            if (direction === 'out') {
-                return Array.from(this.outAdjacencyCache.get(nodeId) || []);
-            }
-            if (direction === 'in') {
-                return Array.from(this.inAdjacencyCache.get(nodeId) || []);
-            }
-            if (this.bothAdjacencyCache) {
-                return Array.from(this.bothAdjacencyCache.get(nodeId) || []);
+    const isArray = Array.isArray;
+
+    /**
+     * Return the layout result for a graph with zero or one node.
+     * @param graph original graph
+     * @param center the layout center
+     * @returns layout result
+     */
+    function applySingleNodeLayout(model, center, dimensions = 2) {
+        const n = model.nodeCount();
+        if (n === 1) {
+            const first = model.firstNode();
+            first.x = center[0];
+            first.y = center[1];
+            if (dimensions === 3) {
+                first.z = center[2] || 0;
             }
-            const inSet = this.inAdjacencyCache.get(nodeId);
-            const outSet = this.outAdjacencyCache.get(nodeId);
-            if (!inSet && !outSet)
-                return [];
-            if (!inSet)
-                return Array.from(outSet);
-            if (!outSet)
-                return Array.from(inSet);
-            const merged = new Set();
-            inSet.forEach((id) => merged.add(id));
-            outSet.forEach((id) => merged.add(id));
-            return Array.from(merged);
-        }
-        successors(nodeId) {
-            return this.neighbors(nodeId, 'out');
-        }
-        predecessors(nodeId) {
-            return this.neighbors(nodeId, 'in');
-        }
-        setNodeOrder(nodes) {
-            const next = new Map();
-            for (const node of nodes)
-                next.set(node.id, node);
-            this.nodeMap = next;
-            this.nodeIndexCache = undefined;
-            this.indexNodeCache = undefined;
-        }
-        clearCache() {
-            this.degreeCache = undefined;
-            this.inAdjacencyCache = undefined;
-            this.outAdjacencyCache = undefined;
-            this.bothAdjacencyCache = undefined;
-            this.nodeIndexCache = undefined;
-            this.indexNodeCache = undefined;
         }
-        buildDegreeCache() {
-            this.degreeCache = new Map();
-            for (const edge of this.edges()) {
-                const { source, target } = edge;
-                if (edge.source === edge.target)
-                    continue;
-                if (!this.degreeCache.has(source)) {
-                    this.degreeCache.set(source, { in: 0, out: 0, both: 0 });
-                }
-                const sourceDeg = this.degreeCache.get(edge.source);
-                if (sourceDeg) {
-                    sourceDeg.out++;
-                    sourceDeg.both++;
-                }
-                if (!this.degreeCache.has(target)) {
-                    this.degreeCache.set(target, { in: 0, out: 0, both: 0 });
-                }
-                const targetDeg = this.degreeCache.get(edge.target);
-                if (targetDeg) {
-                    targetDeg.in++;
-                    targetDeg.both++;
-                }
+    }
+
+    /**
+     * Floyd-Warshall algorithm to find shortest paths (but with no negative cycles).
+     */
+    const floydWarshall = (adjMatrix) => {
+        // initialize
+        const n = adjMatrix.length;
+        const dist = Array.from({ length: n }, () => new Array(n));
+        for (let i = 0; i < n; i++) {
+            const row = adjMatrix[i];
+            const drow = dist[i];
+            for (let j = 0; j < n; j++) {
+                drow[j] = i === j ? 0 : row[j] > 0 ? row[j] : Infinity;
             }
         }
-        buildAdjacencyCache() {
-            this.inAdjacencyCache = new Map();
-            this.outAdjacencyCache = new Map();
-            for (const edge of this.edges()) {
-                if (!this.nodeMap.has(edge.source) || !this.nodeMap.has(edge.target))
+        // floyd
+        for (let k = 0; k < n; k++) {
+            const dk = dist[k];
+            for (let i = 0; i < n; i++) {
+                const di = dist[i];
+                const dik = di[k];
+                if (dik === Infinity)
                     continue;
-                if (!this.outAdjacencyCache.has(edge.source)) {
-                    this.outAdjacencyCache.set(edge.source, new Set());
-                }
-                this.outAdjacencyCache.get(edge.source).add(edge.target);
-                if (!this.inAdjacencyCache.has(edge.target)) {
-                    this.inAdjacencyCache.set(edge.target, new Set());
+                for (let j = 0; j < n; j++) {
+                    const dkj = dk[j];
+                    if (dkj === Infinity)
+                        continue;
+                    const next = dik + dkj;
+                    if (next < di[j]) {
+                        di[j] = next;
+                    }
                 }
-                this.inAdjacencyCache.get(edge.target).add(edge.source);
             }
         }
-        buildNodeIndexCache() {
-            this.nodeIndexCache = new Map();
-            this.indexNodeCache = new Map();
-            let index = 0;
-            this.nodeMap.forEach((_node, nodeId) => {
-                this.nodeIndexCache.set(nodeId, index);
-                this.indexNodeCache.set(index, nodeId);
-                index++;
-            });
-        }
-        destroy() {
-            this.clearCache();
-            this.nodeMap.clear();
-            this.edgeMap.clear();
-            this.edgeIdCounter.clear();
-        }
-    }
-    const nodeFields = [
-        'id',
-        'x',
-        'y',
-        'z',
-        'vx',
-        'vy',
-        'vz',
-        'fx',
-        'fy',
-        'fz',
-        'parentId',
-    ];
-    const edgeFields = ['id', 'source', 'target', 'points'];
-    function extractNodeData(nodes, node) {
-        if (!nodes) {
-            throw new Error('Data.nodes is required');
-        }
-        const result = new Map();
-        for (const datum of nodes) {
-            const nodeData = { _original: datum };
-            for (const field of nodeFields) {
-                const value = datum[field];
-                if (isNil(value))
-                    continue;
-                nodeData[field] = value;
-            }
-            if (node) {
-                const customFields = node(datum);
-                for (const key in customFields) {
-                    const value = customFields[key];
-                    if (isNil(value))
-                        continue;
-                    nodeData[key] = value;
-                }
+        return dist;
+    };
+    /**
+     * Get the adjacency matrix of the graph model.
+     */
+    const getAdjMatrix = (model, directed) => {
+        const n = model.nodeCount();
+        const matrix = Array.from({ length: n }, () => new Array(n));
+        // map node with index in data.nodes
+        const nodeMap = {};
+        let i = 0;
+        model.forEachNode((node) => {
+            nodeMap[node.id] = i++;
+        });
+        model.forEachEdge((e) => {
+            const sIndex = nodeMap[e.source];
+            const tIndex = nodeMap[e.target];
+            if (sIndex === undefined || tIndex === undefined)
+                return;
+            matrix[sIndex][tIndex] = 1;
+            if (!directed) {
+                matrix[tIndex][sIndex] = 1;
             }
-            if (isNil(nodeData.id)) {
-                throw new Error(`Node is missing id field`);
+        });
+        return matrix;
+    };
+    /**
+     * Get the adjacency list of the graph model.
+     */
+    const getAdjList = (model, directed) => {
+        const n = model.nodeCount();
+        const adjList = Array.from({ length: n }, () => []);
+        // map node with index
+        const nodeMap = {};
+        let idx = 0;
+        model.forEachNode((node) => {
+            nodeMap[node.id] = idx++;
+        });
+        model.forEachEdge((e) => {
+            const s = nodeMap[e.source];
+            const t = nodeMap[e.target];
+            if (s == null || t == null)
+                return;
+            adjList[s].push(t);
+            if (!directed)
+                adjList[t].push(s);
+        });
+        return adjList;
+    };
+    /**
+     * scale matrix
+     * @param matrix [ [], [], [] ]
+     * @param ratio
+     */
+    const scaleMatrix = (matrix, ratio) => {
+        const n = matrix.length;
+        const result = new Array(n);
+        for (let i = 0; i < n; i++) {
+            const row = matrix[i];
+            const m = row.length;
+            const newRow = new Array(m);
+            for (let j = 0; j < m; j++) {
+                newRow[j] = row[j] * ratio;
             }
-            result.set(nodeData.id, nodeData);
+            result[i] = newRow;
         }
         return result;
-    }
-    function extractEdgeData(edges, edge, getEdgeId) {
-        const result = new Map();
-        for (const datum of edges) {
-            const edgeData = { _original: datum };
-            for (const field of edgeFields) {
-                const value = datum[field];
-                if (isNil(value))
-                    continue;
-                edgeData[field] = value;
-            }
-            if (edge) {
-                const customFields = edge(datum);
-                for (const key in customFields) {
-                    const value = customFields[key];
-                    if (isNil(value))
-                        continue;
-                    edgeData[key] = value;
-                }
+    };
+    /**
+     * calculate the bounding box for the nodes according to their x, y, and size
+     * @param nodes nodes in the layout
+     * @returns
+     */
+    const getLayoutBBox = (nodes) => {
+        let minX = Infinity;
+        let minY = Infinity;
+        let maxX = -Infinity;
+        let maxY = -Infinity;
+        nodes.forEach((node) => {
+            let size = node.data.size;
+            if (isArray(size)) {
+                if (size.length === 1)
+                    size = [size[0], size[0]];
             }
-            if (isNil(edgeData.source) || isNil(edgeData.target)) {
-                throw new Error(`Edge is missing source or target field`);
+            else if (size === undefined || isNaN(size)) {
+                size = [30, 30];
             }
-            if (isNil(edgeData.id)) {
-                edgeData.id = getEdgeId === null || getEdgeId === void 0 ? void 0 : getEdgeId(datum);
+            else if (isNumber(size)) {
+                size = [size, size];
             }
-            result.set(edgeData.id, edgeData);
+            const halfSize = [size[0] / 2, size[1] / 2];
+            const left = node.data.x - halfSize[0];
+            const right = node.data.x + halfSize[0];
+            const top = node.data.y - halfSize[1];
+            const bottom = node.data.y + halfSize[1];
+            if (minX > left)
+                minX = left;
+            if (minY > top)
+                minY = top;
+            if (maxX < right)
+                maxX = right;
+            if (maxY < bottom)
+                maxY = bottom;
+        });
+        return { minX, minY, maxX, maxY };
+    };
+    /**
+     * calculate the euclidean distance form p1 to p2
+     * @param p1
+     * @param p2
+     * @returns
+     */
+    const getEuclideanDistance = (p1, p2) => Math.sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y));
+    /**
+     * Depth first search begin from nodes in graphCore data.
+     * @param graphCore graphlib data structure
+     * @param nodes begin nodes
+     * @param fn will be called while visiting each node
+     * @param mode 'TB' - visit from top to bottom; 'BT' - visit from bottom to top;
+     * @returns
+     */
+    const graphTreeDfs = (graph, nodes, fn, mode = 'TB', treeKey, stopFns = {}) => {
+        if (!(nodes === null || nodes === void 0 ? void 0 : nodes.length))
+            return;
+        const { stopBranchFn, stopAllFn } = stopFns;
+        for (let i = 0; i < nodes.length; i++) {
+            const node = nodes[i];
+            if (!graph.hasNode(node.id))
+                continue;
+            if (stopBranchFn === null || stopBranchFn === void 0 ? void 0 : stopBranchFn(node))
+                continue; // Stop this branch
+            if (stopAllFn === null || stopAllFn === void 0 ? void 0 : stopAllFn(node))
+                return; // Stop all
+            if (mode === 'TB')
+                fn(node); // Traverse from top to bottom
+            graphTreeDfs(graph, graph.getChildren(node.id, treeKey), fn, mode, treeKey, stopFns);
+            if (mode !== 'TB')
+                fn(node); // Traverse from bottom to top
         }
-        return result;
+    };
+    /**
+     * Use Johnson + Dijkstra to compute APSP for sparse graph.
+     * Fully compatible with floydWarshall(adjMatrix).
+     */
+    function johnson(adjList) {
+        const n = adjList.length;
+        // Step 1: add a dummy node q connected to all nodes with weight 0
+        new Array(n).fill(0);
+        // Bellman-Ford to compute potentials h(v)
+        // 因为权重全是 1，无负边，可直接跳过 BF，h 全 0 即可
+        // Step 2: reweight edges
+        // 因为 h(u)=h(v)=0，reweight 后仍然是 1，省略 reweight 过程
+        // Step 3: run Dijkstra from each node
+        const distAll = Array.from({ length: n }, () => new Array(n).fill(Infinity));
+        for (let s = 0; s < n; s++) {
+            distAll[s] = dijkstra(adjList, s);
+        }
+        return distAll;
     }
-    function initNodePosition(model, width, height, dimensions = 2) {
-        model.forEachNode((node) => {
-            if (isNil(node.x)) {
-                node.x = Math.random() * width;
-            }
-            if (isNil(node.y)) {
-                node.y = Math.random() * height;
-            }
-            if (dimensions === 3 && isNil(node.z)) {
-                node.z = Math.random() * Math.min(width, height);
+    /**
+     * Dijkstra algorithm to find shortest paths from source to all nodes.
+     */
+    function dijkstra(adjList, source) {
+        const n = adjList.length;
+        const dist = new Array(n).fill(Infinity);
+        dist[source] = 0;
+        // Minimal binary heap
+        const heap = new MinHeap();
+        heap.push([0, source]); // [distance, node]
+        while (!heap.empty()) {
+            const [d, u] = heap.pop();
+            if (d !== dist[u])
+                continue;
+            const neighbors = adjList[u];
+            for (let i = 0; i < neighbors.length; i++) {
+                const v = neighbors[i];
+                const nd = d + 1;
+                if (nd < dist[v]) {
+                    dist[v] = nd;
+                    heap.push([nd, v]);
+                }
             }
-        });
+        }
+        return dist;
     }
-
-    class RuntimeContext {
-        constructor(data, options = {}) {
-            this.graph = new GraphLib(data, options);
+    class MinHeap {
+        constructor() {
+            this.data = [];
         }
-        export() {
-            return this.graph.data();
+        push(item) {
+            this.data.push(item);
+            this.bubbleUp(this.data.length - 1);
         }
-        replace(result) {
-            this.graph.replace(result);
+        pop() {
+            const top = this.data[0];
+            const end = this.data.pop();
+            if (this.data.length > 0) {
+                this.data[0] = end;
+                this.bubbleDown(0);
+            }
+            return top;
         }
-        forEachNode(callback) {
-            this.graph.forEachNode(callback);
+        empty() {
+            return this.data.length === 0;
         }
-        forEachEdge(callback) {
-            this.graph.forEachEdge((edge, i) => {
-                edge.sourceNode = this.graph.node(edge.source);
-                edge.targetNode = this.graph.node(edge.target);
-                callback(edge, i);
-            });
+        bubbleUp(pos) {
+            const data = this.data;
+            while (pos > 0) {
+                const parent = (pos - 1) >> 1;
+                if (data[parent][0] <= data[pos][0])
+                    break;
+                [data[parent], data[pos]] = [data[pos], data[parent]];
+                pos = parent;
+            }
         }
-        destroy() {
-            this.graph.destroy();
+        bubbleDown(pos) {
+            const data = this.data;
+            const length = data.length;
+            while (true) {
+                const left = pos * 2 + 1;
+                const right = pos * 2 + 2;
+                let min = pos;
+                if (left < length && data[left][0] < data[min][0])
+                    min = left;
+                if (right < length && data[right][0] < data[min][0])
+                    min = right;
+                if (min === pos)
+                    break;
+                [data[pos], data[min]] = [data[min], data[pos]];
+                pos = min;
+            }
         }
     }
 
     /**
-     * @license
-     * Copyright 2019 Google LLC
-     * SPDX-License-Identifier: Apache-2.0
+     * Get nested property value
+     * For example: getNestedValue(obj, 'a.b.c') will return obj.a.b.c
      */
-    const proxyMarker = Symbol("Comlink.proxy");
-    const createEndpoint = Symbol("Comlink.endpoint");
-    const releaseProxy = Symbol("Comlink.releaseProxy");
-    const finalizer = Symbol("Comlink.finalizer");
-    const throwMarker = Symbol("Comlink.thrown");
-    const isObject = (val) => (typeof val === "object" && val !== null) || typeof val === "function";
+    function getNestedValue(obj, path) {
+        const keys = String(path).split('.');
+        return get$1(obj, keys);
+    }
     /**
-     * Internal transfer handle to handle objects marked to proxy.
+     * Set nested property value
+     * For example: setNestedValue(obj, 'a.b.c', value) will set obj.a.b.c = value
      */
-    const proxyTransferHandler = {
-        canHandle: (val) => isObject(val) && val[proxyMarker],
-        serialize(obj) {
-            const { port1, port2 } = new MessageChannel();
-            expose(obj, port1);
-            return [port2, [port2]];
-        },
-        deserialize(port) {
-            port.start();
-            return wrap(port);
-        },
-    };
+    function setNestedValue(obj, path, value) {
+        const keys = String(path).split('.');
+        set$1(obj, keys, value);
+    }
     /**
-     * Internal transfer handler to handle thrown exceptions.
+     * Merge objects, but undefined values in source objects will not override existing values
+     * @param target - The target object
+     * @param sources - Source objects to merge
+     * @returns A new merged object
+     *
+     * @example
+     * assignDefined({ a: 1, b: 2 }, { b: undefined, c: 3 })
+     * // Returns: { a: 1, b: 2, c: 3 }
      */
-    const throwTransferHandler = {
-        canHandle: (value) => isObject(value) && throwMarker in value,
-        serialize({ value }) {
-            let serialized;
-            if (value instanceof Error) {
-                serialized = {
-                    isError: true,
-                    value: {
-                        message: value.message,
-                        name: value.name,
-                        stack: value.stack,
-                    },
-                };
-            }
-            else {
-                serialized = { isError: false, value };
-            }
-            return [serialized, []];
-        },
-        deserialize(serialized) {
-            if (serialized.isError) {
-                throw Object.assign(new Error(serialized.value.message), serialized.value);
+    function assignDefined(target, ...sources) {
+        sources.forEach((source) => {
+            if (source) {
+                Object.keys(source).forEach((key) => {
+                    const value = source[key];
+                    if (value !== undefined) {
+                        target[key] = value;
+                    }
+                });
             }
-            throw serialized.value;
-        },
-    };
+        });
+        return target;
+    }
+
     /**
-     * Allows customizing the serialization of certain values.
+     * 通用排序核心函数
      */
-    const transferHandlers = new Map([
-        ["proxy", proxyTransferHandler],
-        ["throw", throwTransferHandler],
-    ]);
-    function isAllowedOrigin(allowedOrigins, origin) {
-        for (const allowedOrigin of allowedOrigins) {
-            if (origin === allowedOrigin || allowedOrigin === "*") {
-                return true;
-            }
-            if (allowedOrigin instanceof RegExp && allowedOrigin.test(origin)) {
-                return true;
-            }
-        }
-        return false;
+    function sort$1(model, compareFn) {
+        const nodes = model.nodes();
+        nodes.sort(compareFn);
+        model.setNodeOrder(nodes);
+        return model;
     }
-    function expose(obj, ep = globalThis, allowedOrigins = ["*"]) {
-        ep.addEventListener("message", function callback(ev) {
-            if (!ev || !ev.data) {
-                return;
-            }
-            if (!isAllowedOrigin(allowedOrigins, ev.origin)) {
-                console.warn(`Invalid origin '${ev.origin}' for comlink proxy`);
-                return;
+    function orderByDegree(model) {
+        return sort$1(model, (nodeA, nodeB) => {
+            const degreeA = model.degree(nodeA.id);
+            const degreeB = model.degree(nodeB.id);
+            return degreeB - degreeA; // descending order
+        });
+    }
+    /**
+     * 按 ID 排序
+     */
+    function orderById(model) {
+        return sort$1(model, (nodeA, nodeB) => {
+            const idA = nodeA.id;
+            const idB = nodeB.id;
+            if (typeof idA === 'number' && typeof idB === 'number') {
+                return idA - idB;
             }
-            const { id, type, path } = Object.assign({ path: [] }, ev.data);
-            const argumentList = (ev.data.argumentList || []).map(fromWireValue);
-            let returnValue;
-            try {
-                const parent = path.slice(0, -1).reduce((obj, prop) => obj[prop], obj);
-                const rawValue = path.reduce((obj, prop) => obj[prop], obj);
-                switch (type) {
-                    case "GET" /* MessageType.GET */:
-                        {
-                            returnValue = rawValue;
-                        }
-                        break;
-                    case "SET" /* MessageType.SET */:
-                        {
-                            parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);
-                            returnValue = true;
-                        }
-                        break;
-                    case "APPLY" /* MessageType.APPLY */:
-                        {
-                            returnValue = rawValue.apply(parent, argumentList);
-                        }
-                        break;
-                    case "CONSTRUCT" /* MessageType.CONSTRUCT */:
-                        {
-                            const value = new rawValue(...argumentList);
-                            returnValue = proxy(value);
-                        }
-                        break;
-                    case "ENDPOINT" /* MessageType.ENDPOINT */:
-                        {
-                            const { port1, port2 } = new MessageChannel();
-                            expose(obj, port2);
-                            returnValue = transfer(port1, [port1]);
-                        }
-                        break;
-                    case "RELEASE" /* MessageType.RELEASE */:
-                        {
-                            returnValue = undefined;
-                        }
-                        break;
-                    default:
-                        return;
+            return String(idA).localeCompare(String(idB));
+        });
+    }
+    /**
+     * 按自定义比较函数排序
+     */
+    function orderBySorter(model, sorter) {
+        return sort$1(model, (nodeA, nodeB) => {
+            const a = model.originalNode(nodeA.id);
+            const b = model.originalNode(nodeB.id);
+            return sorter(a, b);
+        });
+    }
+    /**
+     * Order nodes according to graph topology
+     */
+    function orderByTopology(model, directed = false) {
+        const n = model.nodeCount();
+        if (n === 0)
+            return model;
+        const nodes = model.nodes();
+        const orderedNodes = [nodes[0]];
+        const pickFlags = {};
+        pickFlags[nodes[0].id] = true;
+        let k = 0;
+        let i = 0;
+        model.forEachNode((node) => {
+            if (i !== 0) {
+                const currentDegree = model.degree(node.id, 'both');
+                const nextDegree = i < n - 1 ? model.degree(nodes[i + 1].id, 'both') : 0;
+                const currentNodeId = orderedNodes[k].id;
+                const isNeighbor = model
+                    .neighbors(currentNodeId, 'both')
+                    .includes(node.id);
+                if ((i === n - 1 || currentDegree !== nextDegree || isNeighbor) &&
+                    !pickFlags[node.id]) {
+                    orderedNodes.push(node);
+                    pickFlags[node.id] = true;
+                    k++;
                 }
-            }
-            catch (value) {
-                returnValue = { value, [throwMarker]: 0 };
-            }
-            Promise.resolve(returnValue)
-                .catch((value) => {
-                return { value, [throwMarker]: 0 };
-            })
-                .then((returnValue) => {
-                const [wireValue, transferables] = toWireValue(returnValue);
-                ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
-                if (type === "RELEASE" /* MessageType.RELEASE */) {
-                    // detach and deactive after sending release response above.
-                    ep.removeEventListener("message", callback);
-                    closeEndPoint(ep);
-                    if (finalizer in obj && typeof obj[finalizer] === "function") {
-                        obj[finalizer]();
+                else {
+                    const children = directed
+                        ? model.successors(currentNodeId)
+                        : model.neighbors(currentNodeId);
+                    let foundChild = false;
+                    for (let j = 0; j < children.length; j++) {
+                        const childId = children[j];
+                        const child = model.node(childId);
+                        if (child &&
+                            model.degree(childId) === model.degree(node.id) &&
+                            !pickFlags[childId]) {
+                            orderedNodes.push(child);
+                            pickFlags[childId] = true;
+                            foundChild = true;
+                            break;
+                        }
+                    }
+                    let ii = 0;
+                    while (!foundChild) {
+                        if (!pickFlags[nodes[ii].id]) {
+                            orderedNodes.push(nodes[ii]);
+                            pickFlags[nodes[ii].id] = true;
+                            foundChild = true;
+                        }
+                        ii++;
+                        if (ii === n) {
+                            break;
+                        }
                     }
                 }
-            })
-                .catch((error) => {
-                // Send Serialization Error To Caller
-                const [wireValue, transferables] = toWireValue({
-                    value: new TypeError("Unserializable return value"),
-                    [throwMarker]: 0,
-                });
-                ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
-            });
+            }
+            i++;
         });
-        if (ep.start) {
-            ep.start();
-        }
+        // Update model with ordered nodes
+        model.setNodeOrder(orderedNodes);
+        return model;
     }
-    function isMessagePort(endpoint) {
-        return endpoint.constructor.name === "MessagePort";
+
+    function parsePoint(point) {
+        var _a;
+        return [point.x, point.y, (_a = point.z) !== null && _a !== void 0 ? _a : 0];
     }
-    function closeEndPoint(endpoint) {
-        if (isMessagePort(endpoint))
-            endpoint.close();
+    function toPointObject(point) {
+        var _a;
+        return { x: point[0], y: point[1], z: (_a = point[2]) !== null && _a !== void 0 ? _a : 0 };
     }
-    function wrap(ep, target) {
-        const pendingListeners = new Map();
-        ep.addEventListener("message", function handleMessage(ev) {
-            const { data } = ev;
-            if (!data || !data.id) {
-                return;
-            }
-            const resolver = pendingListeners.get(data.id);
-            if (!resolver) {
-                return;
-            }
-            try {
-                resolver(data);
-            }
-            finally {
-                pendingListeners.delete(data.id);
-            }
-        });
-        return createProxy(ep, pendingListeners, [], target);
+
+    function parseSize(size) {
+        if (!size)
+            return [0, 0, 0];
+        if (isNumber(size))
+            return [size, size, size];
+        else if (Array.isArray(size) && size.length === 0)
+            return [0, 0, 0];
+        const [x, y = x, z = x] = size;
+        return [x, y, z];
     }
-    function throwIfProxyReleased(isReleased) {
-        if (isReleased) {
-            throw new Error("Proxy has been released and is not useable");
+
+    /**
+     * Viewport configuration such as width, height and center point.
+     */
+    const normalizeViewport = (options) => {
+        const { width, height, center } = options;
+        const normalizedWidth = width !== null && width !== void 0 ? width : (typeof window !== 'undefined' ? window.innerWidth : 0);
+        const normalizedHeight = height !== null && height !== void 0 ? height : (typeof window !== 'undefined' ? window.innerHeight : 0);
+        const centerPoint = center !== null && center !== void 0 ? center : [normalizedWidth / 2, normalizedHeight / 2];
+        return {
+            width: normalizedWidth,
+            height: normalizedHeight,
+            center: centerPoint,
+        };
+    };
+
+    /**
+     * Format value with multiple types into a function that returns a number
+     * @param value The value to be formatted
+     * @param defaultValue The default value when value is invalid
+     * @returns A function that returns a number
+     */
+    function formatNumberFn(value, defaultValue) {
+        // If value is a function, return it directly
+        if (isFunction(value)) {
+            return value;
+        }
+        // If value is a number, return a function that returns this number
+        if (isNumber(value)) {
+            return () => value;
         }
+        // For other cases (undefined or invalid values), return default value function
+        return () => defaultValue;
     }
-    function releaseEndpoint(ep) {
-        return requestResponseMessage(ep, new Map(), {
-            type: "RELEASE" /* MessageType.RELEASE */,
-        }).then(() => {
-            closeEndPoint(ep);
-        });
+    /**
+     * Format size config with multiple types into a function that returns a size
+     * @param value The value to be formatted
+     * @param defaultValue The default value when value is invalid
+     * @param resultIsNumber Whether to return a number (max of width/height) or size array
+     * @returns A function that returns a size
+     */
+    function formatSizeFn(value, defaultValue = 10) {
+        // If value is undefined, return default value function
+        if (!value) {
+            return () => defaultValue;
+        }
+        // If value is a function, return it directly
+        if (isFunction(value)) {
+            return value;
+        }
+        // If value is a number, return a function that returns this number
+        if (isNumber(value)) {
+            return () => value;
+        }
+        // If value is an array, return max or the array itself
+        if (Array.isArray(value)) {
+            return () => value;
+        }
+        // If value is an object with width and height
+        if (isObject$1(value) && value.width && value.height) {
+            return () => [value.width, value.height];
+        }
+        return () => defaultValue;
     }
-    const proxyCounter = new WeakMap();
-    const proxyFinalizers = "FinalizationRegistry" in globalThis &&
-        new FinalizationRegistry((ep) => {
-            const newCount = (proxyCounter.get(ep) || 0) - 1;
-            proxyCounter.set(ep, newCount);
-            if (newCount === 0) {
-                releaseEndpoint(ep);
+    /**
+     * Format nodeSize and nodeSpacing into a function that returns the total size
+     * @param nodeSize The size of the node
+     * @param nodeSpacing The spacing around the node
+     * @param defaultNodeSize The default node size when value is invalid
+     * @returns A function that returns the total size (node size + spacing)
+     */
+    const formatNodeSizeFn = (nodeSize, nodeSpacing, defaultNodeSize = 10) => {
+        const nodeSpacingFunc = formatNumberFn(nodeSpacing, 0);
+        const nodeSizeFunc = formatSizeFn(nodeSize, defaultNodeSize);
+        return (node) => {
+            const size = nodeSizeFunc(node);
+            const spacing = nodeSpacingFunc(node);
+            return Math.max(...parseSize(size)) + spacing;
+        };
+    };
+
+    class GraphLib {
+        constructor(data, options = {}) {
+            this.edgeIdCounter = new Map();
+            this.nodeMap = extractNodeData(data.nodes, options.node);
+            this.edgeMap = extractEdgeData(data.edges || [], options.edge, this.getEdgeId.bind(this));
+        }
+        data() {
+            return { nodes: this.nodeMap, edges: this.edgeMap };
+        }
+        replace(result) {
+            this.nodeMap = result.nodes;
+            this.edgeMap = result.edges;
+            this.clearCache();
+        }
+        nodes() {
+            return Array.from(this.nodeMap.values());
+        }
+        node(id) {
+            return this.nodeMap.get(id);
+        }
+        nodeAt(index) {
+            if (!this.indexNodeCache) {
+                this.buildNodeIndexCache();
+            }
+            const nodeId = this.indexNodeCache.get(index);
+            return nodeId ? this.nodeMap.get(nodeId) : undefined;
+        }
+        nodeIndexOf(id) {
+            var _a;
+            if (!this.nodeIndexCache) {
+                this.buildNodeIndexCache();
+            }
+            return (_a = this.nodeIndexCache.get(id)) !== null && _a !== void 0 ? _a : -1;
+        }
+        firstNode() {
+            return this.nodeMap.values().next().value;
+        }
+        forEachNode(callback) {
+            let i = 0;
+            this.nodeMap.forEach((node) => callback(node, i++));
+        }
+        originalNode(id) {
+            const node = this.nodeMap.get(id);
+            return node === null || node === void 0 ? void 0 : node._original;
+        }
+        nodeCount() {
+            return this.nodeMap.size;
+        }
+        edges() {
+            return Array.from(this.edgeMap.values());
+        }
+        edge(id) {
+            return this.edgeMap.get(id);
+        }
+        firstEdge() {
+            return this.edgeMap.values().next().value;
+        }
+        forEachEdge(callback) {
+            let i = 0;
+            this.edgeMap.forEach((edge) => callback(edge, i++));
+        }
+        originalEdge(id) {
+            const edge = this.edgeMap.get(id);
+            return edge === null || edge === void 0 ? void 0 : edge._original;
+        }
+        edgeCount() {
+            return this.edgeMap.size;
+        }
+        getEdgeId(edge) {
+            if (edge.id)
+                return edge.id;
+            const baseId = `${edge.source}-${edge.target}`;
+            const count = this.edgeIdCounter.get(baseId) || 0;
+            const id = count === 0 ? baseId : `${baseId}-${count}`;
+            this.edgeIdCounter.set(baseId, count + 1);
+            return id;
+        }
+        degree(nodeId, direction = 'both') {
+            if (!this.degreeCache) {
+                this.buildDegreeCache();
+            }
+            const degree = this.degreeCache.get(nodeId);
+            if (!degree)
+                return 0;
+            return degree[direction];
+        }
+        neighbors(nodeId, direction = 'both') {
+            if (!this.outAdjacencyCache || !this.inAdjacencyCache) {
+                this.buildAdjacencyCache();
             }
-        });
-    function registerProxy(proxy, ep) {
-        const newCount = (proxyCounter.get(ep) || 0) + 1;
-        proxyCounter.set(ep, newCount);
-        if (proxyFinalizers) {
-            proxyFinalizers.register(proxy, ep, proxy);
+            if (direction === 'out') {
+                return Array.from(this.outAdjacencyCache.get(nodeId) || []);
+            }
+            if (direction === 'in') {
+                return Array.from(this.inAdjacencyCache.get(nodeId) || []);
+            }
+            if (this.bothAdjacencyCache) {
+                return Array.from(this.bothAdjacencyCache.get(nodeId) || []);
+            }
+            const inSet = this.inAdjacencyCache.get(nodeId);
+            const outSet = this.outAdjacencyCache.get(nodeId);
+            if (!inSet && !outSet)
+                return [];
+            if (!inSet)
+                return Array.from(outSet);
+            if (!outSet)
+                return Array.from(inSet);
+            const merged = new Set();
+            inSet.forEach((id) => merged.add(id));
+            outSet.forEach((id) => merged.add(id));
+            return Array.from(merged);
         }
-    }
-    function unregisterProxy(proxy) {
-        if (proxyFinalizers) {
-            proxyFinalizers.unregister(proxy);
+        successors(nodeId) {
+            return this.neighbors(nodeId, 'out');
         }
-    }
-    function createProxy(ep, pendingListeners, path = [], target = function () { }) {
-        let isProxyReleased = false;
-        const proxy = new Proxy(target, {
-            get(_target, prop) {
-                throwIfProxyReleased(isProxyReleased);
-                if (prop === releaseProxy) {
-                    return () => {
-                        unregisterProxy(proxy);
-                        releaseEndpoint(ep);
-                        pendingListeners.clear();
-                        isProxyReleased = true;
-                    };
+        predecessors(nodeId) {
+            return this.neighbors(nodeId, 'in');
+        }
+        setNodeOrder(nodes) {
+            const next = new Map();
+            for (const node of nodes)
+                next.set(node.id, node);
+            this.nodeMap = next;
+            this.nodeIndexCache = undefined;
+            this.indexNodeCache = undefined;
+        }
+        clearCache() {
+            this.degreeCache = undefined;
+            this.inAdjacencyCache = undefined;
+            this.outAdjacencyCache = undefined;
+            this.bothAdjacencyCache = undefined;
+            this.nodeIndexCache = undefined;
+            this.indexNodeCache = undefined;
+        }
+        buildDegreeCache() {
+            this.degreeCache = new Map();
+            for (const edge of this.edges()) {
+                const { source, target } = edge;
+                if (edge.source === edge.target)
+                    continue;
+                if (!this.degreeCache.has(source)) {
+                    this.degreeCache.set(source, { in: 0, out: 0, both: 0 });
                 }
-                if (prop === "then") {
-                    if (path.length === 0) {
-                        return { then: () => proxy };
-                    }
-                    const r = requestResponseMessage(ep, pendingListeners, {
-                        type: "GET" /* MessageType.GET */,
-                        path: path.map((p) => p.toString()),
-                    }).then(fromWireValue);
-                    return r.then.bind(r);
+                const sourceDeg = this.degreeCache.get(edge.source);
+                if (sourceDeg) {
+                    sourceDeg.out++;
+                    sourceDeg.both++;
                 }
-                return createProxy(ep, pendingListeners, [...path, prop]);
-            },
-            set(_target, prop, rawValue) {
-                throwIfProxyReleased(isProxyReleased);
-                // FIXME: ES6 Proxy Handler `set` methods are supposed to return a
-                // boolean. To show good will, we return true asynchronously ¯\_(ツ)_/¯
-                const [value, transferables] = toWireValue(rawValue);
-                return requestResponseMessage(ep, pendingListeners, {
-                    type: "SET" /* MessageType.SET */,
-                    path: [...path, prop].map((p) => p.toString()),
-                    value,
-                }, transferables).then(fromWireValue);
-            },
-            apply(_target, _thisArg, rawArgumentList) {
-                throwIfProxyReleased(isProxyReleased);
-                const last = path[path.length - 1];
-                if (last === createEndpoint) {
-                    return requestResponseMessage(ep, pendingListeners, {
-                        type: "ENDPOINT" /* MessageType.ENDPOINT */,
-                    }).then(fromWireValue);
+                if (!this.degreeCache.has(target)) {
+                    this.degreeCache.set(target, { in: 0, out: 0, both: 0 });
                 }
-                // We just pretend that `bind()` didn’t happen.
-                if (last === "bind") {
-                    return createProxy(ep, pendingListeners, path.slice(0, -1));
+                const targetDeg = this.degreeCache.get(edge.target);
+                if (targetDeg) {
+                    targetDeg.in++;
+                    targetDeg.both++;
                 }
-                const [argumentList, transferables] = processArguments(rawArgumentList);
-                return requestResponseMessage(ep, pendingListeners, {
-                    type: "APPLY" /* MessageType.APPLY */,
-                    path: path.map((p) => p.toString()),
-                    argumentList,
-                }, transferables).then(fromWireValue);
-            },
-            construct(_target, rawArgumentList) {
-                throwIfProxyReleased(isProxyReleased);
-                const [argumentList, transferables] = processArguments(rawArgumentList);
-                return requestResponseMessage(ep, pendingListeners, {
-                    type: "CONSTRUCT" /* MessageType.CONSTRUCT */,
-                    path: path.map((p) => p.toString()),
-                    argumentList,
-                }, transferables).then(fromWireValue);
-            },
-        });
-        registerProxy(proxy, ep);
-        return proxy;
-    }
-    function myFlat(arr) {
-        return Array.prototype.concat.apply([], arr);
-    }
-    function processArguments(argumentList) {
-        const processed = argumentList.map(toWireValue);
-        return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];
-    }
-    const transferCache = new WeakMap();
-    function transfer(obj, transfers) {
-        transferCache.set(obj, transfers);
-        return obj;
-    }
-    function proxy(obj) {
-        return Object.assign(obj, { [proxyMarker]: true });
-    }
-    function toWireValue(value) {
-        for (const [name, handler] of transferHandlers) {
-            if (handler.canHandle(value)) {
-                const [serializedValue, transferables] = handler.serialize(value);
-                return [
-                    {
-                        type: "HANDLER" /* WireValueType.HANDLER */,
-                        name,
-                        value: serializedValue,
-                    },
-                    transferables,
-                ];
-            }
-        }
-        return [
-            {
-                type: "RAW" /* WireValueType.RAW */,
-                value,
-            },
-            transferCache.get(value) || [],
-        ];
-    }
-    function fromWireValue(value) {
-        switch (value.type) {
-            case "HANDLER" /* WireValueType.HANDLER */:
-                return transferHandlers.get(value.name).deserialize(value.value);
-            case "RAW" /* WireValueType.RAW */:
-                return value.value;
-        }
-    }
-    function requestResponseMessage(ep, pendingListeners, msg, transfers) {
-        return new Promise((resolve) => {
-            const id = generateUUID();
-            pendingListeners.set(id, resolve);
-            if (ep.start) {
-                ep.start();
             }
-            ep.postMessage(Object.assign({ id }, msg), transfers);
-        });
-    }
-    function generateUUID() {
-        return new Array(4)
-            .fill(0)
-            .map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16))
-            .join("-");
-    }
-
-    class Supervisor {
-        constructor() {
-            this.worker = null;
-            this.workerApi = null;
         }
-        /**
-         * Execute layout in worker
-         */
-        execute(layoutId, data, options) {
-            return __awaiter(this, void 0, void 0, function* () {
-                if (!this.worker) {
-                    yield this.initWorker();
+        buildAdjacencyCache() {
+            this.inAdjacencyCache = new Map();
+            this.outAdjacencyCache = new Map();
+            for (const edge of this.edges()) {
+                if (!this.nodeMap.has(edge.source) || !this.nodeMap.has(edge.target))
+                    continue;
+                if (!this.outAdjacencyCache.has(edge.source)) {
+                    this.outAdjacencyCache.set(edge.source, new Set());
                 }
-                if (!this.workerApi) {
-                    throw new Error('Worker API not initialized');
+                this.outAdjacencyCache.get(edge.source).add(edge.target);
+                if (!this.inAdjacencyCache.has(edge.target)) {
+                    this.inAdjacencyCache.set(edge.target, new Set());
                 }
-                return yield this.workerApi.execute(layoutId, data, options);
-            });
-        }
-        /**
-         * Destroy worker
-         */
-        destroy() {
-            if (this.workerApi) {
-                this.workerApi.destroy();
-            }
-            if (this.worker) {
-                this.worker.terminate();
-                this.worker = null;
-                this.workerApi = null;
+                this.inAdjacencyCache.get(edge.target).add(edge.source);
             }
         }
-        /**
-         * Initialize worker
-         */
-        initWorker() {
-            return __awaiter(this, void 0, void 0, function* () {
-                const workerPath = this.resolveWorkerPath();
-                const isESM = workerPath.includes('/lib/') || workerPath.endsWith('.mjs');
-                const type = isESM ? 'module' : 'classic';
-                this.worker = new Worker(workerPath, { type });
-                this.workerApi = wrap(this.worker);
+        buildNodeIndexCache() {
+            this.nodeIndexCache = new Map();
+            this.indexNodeCache = new Map();
+            let index = 0;
+            this.nodeMap.forEach((_node, nodeId) => {
+                this.nodeIndexCache.set(nodeId, index);
+                this.indexNodeCache.set(index, nodeId);
+                index++;
             });
         }
-        /**
-         * Resolve worker script path which works in both ESM and UMD environments
-         */
-        resolveWorkerPath() {
-            if (typeof ({ url: (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)) }) !== 'undefined' && (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href))) {
-                const currentUrl = new URL((typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)));
-                // e.g. `.../lib/runtime/supervisor.js` -> `.../lib/worker.js`
-                const asRoot = currentUrl.href.replace(/\/runtime\/[^/]+\.js$/, '/worker.js');
-                if (asRoot !== currentUrl.href)
-                    return asRoot;
-                // Fallback: keep legacy behavior (same directory)
-                return currentUrl.href.replace(/\/[^/]+\.js$/, '/worker.js');
+        destroy() {
+            this.clearCache();
+            this.nodeMap.clear();
+            this.edgeMap.clear();
+            this.edgeIdCounter.clear();
+        }
+    }
+    const nodeFields = [
+        'id',
+        'x',
+        'y',
+        'z',
+        'vx',
+        'vy',
+        'vz',
+        'fx',
+        'fy',
+        'fz',
+        'parentId',
+    ];
+    const edgeFields = ['id', 'source', 'target', 'points'];
+    function extractNodeData(nodes, node) {
+        if (!nodes) {
+            throw new Error('Data.nodes is required');
+        }
+        const result = new Map();
+        for (const datum of nodes) {
+            const nodeData = { _original: datum };
+            for (const field of nodeFields) {
+                const value = datum[field];
+                if (isNil(value))
+                    continue;
+                nodeData[field] = value;
             }
-            if (typeof document !== 'undefined') {
-                const scripts = document.getElementsByTagName('script');
-                for (let i = scripts.length - 1; i >= 0; i--) {
-                    const src = scripts[i].src;
-                    if (src && (src.includes('index.js') || src.includes('index.min.js'))) {
-                        return src.replace(/index(\.min)?\.js/, 'worker.js');
-                    }
+            if (node) {
+                const customFields = node(datum);
+                for (const key in customFields) {
+                    const value = customFields[key];
+                    if (isNil(value))
+                        continue;
+                    nodeData[key] = value;
                 }
             }
-            return './worker.js';
-        }
-    }
-
-    const isArray = Array.isArray;
-
-    /**
-     * Return the layout result for a graph with zero or one node.
-     * @param graph original graph
-     * @param center the layout center
-     * @returns layout result
-     */
-    function applySingleNodeLayout(model, center, dimensions = 2) {
-        const n = model.nodeCount();
-        if (n === 1) {
-            const first = model.firstNode();
-            first.x = center[0];
-            first.y = center[1];
-            if (dimensions === 3) {
-                first.z = center[2] || 0;
+            if (isNil(nodeData.id)) {
+                throw new Error(`Node is missing id field`);
             }
+            result.set(nodeData.id, nodeData);
         }
+        return result;
     }
-
-    /**
-     * Floyd-Warshall algorithm to find shortest paths (but with no negative cycles).
-     */
-    const floydWarshall = (adjMatrix) => {
-        // initialize
-        const n = adjMatrix.length;
-        const dist = Array.from({ length: n }, () => new Array(n));
-        for (let i = 0; i < n; i++) {
-            const row = adjMatrix[i];
-            const drow = dist[i];
-            for (let j = 0; j < n; j++) {
-                drow[j] = i === j ? 0 : row[j] > 0 ? row[j] : Infinity;
-            }
-        }
-        // floyd
-        for (let k = 0; k < n; k++) {
-            const dk = dist[k];
-            for (let i = 0; i < n; i++) {
-                const di = dist[i];
-                const dik = di[k];
-                if (dik === Infinity)
+    function extractEdgeData(edges, edge, getEdgeId) {
+        const result = new Map();
+        for (const datum of edges) {
+            const edgeData = { _original: datum };
+            for (const field of edgeFields) {
+                const value = datum[field];
+                if (isNil(value))
                     continue;
-                for (let j = 0; j < n; j++) {
-                    const dkj = dk[j];
-                    if (dkj === Infinity)
+                edgeData[field] = value;
+            }
+            if (edge) {
+                const customFields = edge(datum);
+                for (const key in customFields) {
+                    const value = customFields[key];
+                    if (isNil(value))
                         continue;
-                    const next = dik + dkj;
-                    if (next < di[j]) {
-                        di[j] = next;
-                    }
+                    edgeData[key] = value;
                 }
             }
-        }
-        return dist;
-    };
-    /**
-     * Get the adjacency matrix of the graph model.
-     */
-    const getAdjMatrix = (model, directed) => {
-        const n = model.nodeCount();
-        const matrix = Array.from({ length: n }, () => new Array(n));
-        // map node with index in data.nodes
-        const nodeMap = {};
-        let i = 0;
-        model.forEachNode((node) => {
-            nodeMap[node.id] = i++;
-        });
-        model.forEachEdge((e) => {
-            const sIndex = nodeMap[e.source];
-            const tIndex = nodeMap[e.target];
-            if (sIndex === undefined || tIndex === undefined)
-                return;
-            matrix[sIndex][tIndex] = 1;
-            if (!directed) {
-                matrix[tIndex][sIndex] = 1;
+            if (isNil(edgeData.source) || isNil(edgeData.target)) {
+                throw new Error(`Edge is missing source or target field`);
             }
-        });
-        return matrix;
-    };
-    /**
-     * Get the adjacency list of the graph model.
-     */
-    const getAdjList = (model, directed) => {
-        const n = model.nodeCount();
-        const adjList = Array.from({ length: n }, () => []);
-        // map node with index
-        const nodeMap = {};
-        let idx = 0;
-        model.forEachNode((node) => {
-            nodeMap[node.id] = idx++;
-        });
-        model.forEachEdge((e) => {
-            const s = nodeMap[e.source];
-            const t = nodeMap[e.target];
-            if (s == null || t == null)
-                return;
-            adjList[s].push(t);
-            if (!directed)
-                adjList[t].push(s);
-        });
-        return adjList;
-    };
-    /**
-     * scale matrix
-     * @param matrix [ [], [], [] ]
-     * @param ratio
-     */
-    const scaleMatrix = (matrix, ratio) => {
-        const n = matrix.length;
-        const result = new Array(n);
-        for (let i = 0; i < n; i++) {
-            const row = matrix[i];
-            const m = row.length;
-            const newRow = new Array(m);
-            for (let j = 0; j < m; j++) {
-                newRow[j] = row[j] * ratio;
+            if (isNil(edgeData.id)) {
+                edgeData.id = getEdgeId === null || getEdgeId === void 0 ? void 0 : getEdgeId(datum);
             }
-            result[i] = newRow;
+            result.set(edgeData.id, edgeData);
         }
         return result;
-    };
-    /**
-     * calculate the bounding box for the nodes according to their x, y, and size
-     * @param nodes nodes in the layout
-     * @returns
-     */
-    const getLayoutBBox = (nodes) => {
-        let minX = Infinity;
-        let minY = Infinity;
-        let maxX = -Infinity;
-        let maxY = -Infinity;
-        nodes.forEach((node) => {
-            let size = node.data.size;
-            if (isArray(size)) {
-                if (size.length === 1)
-                    size = [size[0], size[0]];
+    }
+    function initNodePosition(model, width, height, dimensions = 2) {
+        model.forEachNode((node) => {
+            if (isNil(node.x)) {
+                node.x = Math.random() * width;
             }
-            else if (size === undefined || isNaN(size)) {
-                size = [30, 30];
+            if (isNil(node.y)) {
+                node.y = Math.random() * height;
             }
-            else if (isNumber(size)) {
-                size = [size, size];
+            if (dimensions === 3 && isNil(node.z)) {
+                node.z = Math.random() * Math.min(width, height);
             }
-            const halfSize = [size[0] / 2, size[1] / 2];
-            const left = node.data.x - halfSize[0];
-            const right = node.data.x + halfSize[0];
-            const top = node.data.y - halfSize[1];
-            const bottom = node.data.y + halfSize[1];
-            if (minX > left)
-                minX = left;
-            if (minY > top)
-                minY = top;
-            if (maxX < right)
-                maxX = right;
-            if (maxY < bottom)
-                maxY = bottom;
         });
-        return { minX, minY, maxX, maxY };
-    };
+    }
+
+    class RuntimeContext {
+        constructor(data, options = {}) {
+            this.graph = new GraphLib(data, options);
+        }
+        export() {
+            return this.graph.data();
+        }
+        replace(result) {
+            this.graph.replace(result);
+        }
+        forEachNode(callback) {
+            this.graph.forEachNode(callback);
+        }
+        forEachEdge(callback) {
+            this.graph.forEachEdge((edge, i) => {
+                edge.sourceNode = this.graph.node(edge.source);
+                edge.targetNode = this.graph.node(edge.target);
+                callback(edge, i);
+            });
+        }
+        destroy() {
+            this.graph.destroy();
+        }
+    }
+
     /**
-     * calculate the euclidean distance form p1 to p2
-     * @param p1
-     * @param p2
-     * @returns
+     * @license
+     * Copyright 2019 Google LLC
+     * SPDX-License-Identifier: Apache-2.0
      */
-    const getEuclideanDistance = (p1, p2) => Math.sqrt((p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y));
+    const proxyMarker = Symbol("Comlink.proxy");
+    const createEndpoint = Symbol("Comlink.endpoint");
+    const releaseProxy = Symbol("Comlink.releaseProxy");
+    const finalizer = Symbol("Comlink.finalizer");
+    const throwMarker = Symbol("Comlink.thrown");
+    const isObject = (val) => (typeof val === "object" && val !== null) || typeof val === "function";
     /**
-     * Depth first search begin from nodes in graphCore data.
-     * @param graphCore graphlib data structure
-     * @param nodes begin nodes
-     * @param fn will be called while visiting each node
-     * @param mode 'TB' - visit from top to bottom; 'BT' - visit from bottom to top;
-     * @returns
+     * Internal transfer handle to handle objects marked to proxy.
      */
-    const graphTreeDfs = (graph, nodes, fn, mode = 'TB', treeKey, stopFns = {}) => {
-        if (!(nodes === null || nodes === void 0 ? void 0 : nodes.length))
-            return;
-        const { stopBranchFn, stopAllFn } = stopFns;
-        for (let i = 0; i < nodes.length; i++) {
-            const node = nodes[i];
-            if (!graph.hasNode(node.id))
-                continue;
-            if (stopBranchFn === null || stopBranchFn === void 0 ? void 0 : stopBranchFn(node))
-                continue; // Stop this branch
-            if (stopAllFn === null || stopAllFn === void 0 ? void 0 : stopAllFn(node))
-                return; // Stop all
-            if (mode === 'TB')
-                fn(node); // Traverse from top to bottom
-            graphTreeDfs(graph, graph.getChildren(node.id, treeKey), fn, mode, treeKey, stopFns);
-            if (mode !== 'TB')
-                fn(node); // Traverse from bottom to top
-        }
+    const proxyTransferHandler = {
+        canHandle: (val) => isObject(val) && val[proxyMarker],
+        serialize(obj) {
+            const { port1, port2 } = new MessageChannel();
+            expose(obj, port1);
+            return [port2, [port2]];
+        },
+        deserialize(port) {
+            port.start();
+            return wrap(port);
+        },
     };
     /**
-     * Use Johnson + Dijkstra to compute APSP for sparse graph.
-     * Fully compatible with floydWarshall(adjMatrix).
+     * Internal transfer handler to handle thrown exceptions.
      */
-    function johnson(adjList) {
-        const n = adjList.length;
-        // Step 1: add a dummy node q connected to all nodes with weight 0
-        new Array(n).fill(0);
-        // Bellman-Ford to compute potentials h(v)
-        // 因为权重全是 1，无负边，可直接跳过 BF，h 全 0 即可
-        // Step 2: reweight edges
-        // 因为 h(u)=h(v)=0，reweight 后仍然是 1，省略 reweight 过程
-        // Step 3: run Dijkstra from each node
-        const distAll = Array.from({ length: n }, () => new Array(n).fill(Infinity));
-        for (let s = 0; s < n; s++) {
-            distAll[s] = dijkstra(adjList, s);
-        }
-        return distAll;
-    }
+    const throwTransferHandler = {
+        canHandle: (value) => isObject(value) && throwMarker in value,
+        serialize({ value }) {
+            let serialized;
+            if (value instanceof Error) {
+                serialized = {
+                    isError: true,
+                    value: {
+                        message: value.message,
+                        name: value.name,
+                        stack: value.stack,
+                    },
+                };
+            }
+            else {
+                serialized = { isError: false, value };
+            }
+            return [serialized, []];
+        },
+        deserialize(serialized) {
+            if (serialized.isError) {
+                throw Object.assign(new Error(serialized.value.message), serialized.value);
+            }
+            throw serialized.value;
+        },
+    };
     /**
-     * Dijkstra algorithm to find shortest paths from source to all nodes.
+     * Allows customizing the serialization of certain values.
      */
-    function dijkstra(adjList, source) {
-        const n = adjList.length;
-        const dist = new Array(n).fill(Infinity);
-        dist[source] = 0;
-        // Minimal binary heap
-        const heap = new MinHeap();
-        heap.push([0, source]); // [distance, node]
-        while (!heap.empty()) {
-            const [d, u] = heap.pop();
-            if (d !== dist[u])
-                continue;
-            const neighbors = adjList[u];
-            for (let i = 0; i < neighbors.length; i++) {
-                const v = neighbors[i];
-                const nd = d + 1;
-                if (nd < dist[v]) {
-                    dist[v] = nd;
-                    heap.push([nd, v]);
-                }
+    const transferHandlers = new Map([
+        ["proxy", proxyTransferHandler],
+        ["throw", throwTransferHandler],
+    ]);
+    function isAllowedOrigin(allowedOrigins, origin) {
+        for (const allowedOrigin of allowedOrigins) {
+            if (origin === allowedOrigin || allowedOrigin === "*") {
+                return true;
+            }
+            if (allowedOrigin instanceof RegExp && allowedOrigin.test(origin)) {
+                return true;
             }
         }
-        return dist;
+        return false;
     }
-    class MinHeap {
-        constructor() {
-            this.data = [];
-        }
-        push(item) {
-            this.data.push(item);
-            this.bubbleUp(this.data.length - 1);
-        }
-        pop() {
-            const top = this.data[0];
-            const end = this.data.pop();
-            if (this.data.length > 0) {
-                this.data[0] = end;
-                this.bubbleDown(0);
+    function expose(obj, ep = globalThis, allowedOrigins = ["*"]) {
+        ep.addEventListener("message", function callback(ev) {
+            if (!ev || !ev.data) {
+                return;
             }
-            return top;
-        }
-        empty() {
-            return this.data.length === 0;
-        }
-        bubbleUp(pos) {
-            const data = this.data;
-            while (pos > 0) {
-                const parent = (pos - 1) >> 1;
-                if (data[parent][0] <= data[pos][0])
-                    break;
-                [data[parent], data[pos]] = [data[pos], data[parent]];
-                pos = parent;
+            if (!isAllowedOrigin(allowedOrigins, ev.origin)) {
+                console.warn(`Invalid origin '${ev.origin}' for comlink proxy`);
+                return;
             }
-        }
-        bubbleDown(pos) {
-            const data = this.data;
-            const length = data.length;
-            while (true) {
-                const left = pos * 2 + 1;
-                const right = pos * 2 + 2;
-                let min = pos;
-                if (left < length && data[left][0] < data[min][0])
-                    min = left;
-                if (right < length && data[right][0] < data[min][0])
-                    min = right;
-                if (min === pos)
-                    break;
-                [data[pos], data[min]] = [data[min], data[pos]];
-                pos = min;
+            const { id, type, path } = Object.assign({ path: [] }, ev.data);
+            const argumentList = (ev.data.argumentList || []).map(fromWireValue);
+            let returnValue;
+            try {
+                const parent = path.slice(0, -1).reduce((obj, prop) => obj[prop], obj);
+                const rawValue = path.reduce((obj, prop) => obj[prop], obj);
+                switch (type) {
+                    case "GET" /* MessageType.GET */:
+                        {
+                            returnValue = rawValue;
+                        }
+                        break;
+                    case "SET" /* MessageType.SET */:
+                        {
+                            parent[path.slice(-1)[0]] = fromWireValue(ev.data.value);
+                            returnValue = true;
+                        }
+                        break;
+                    case "APPLY" /* MessageType.APPLY */:
+                        {
+                            returnValue = rawValue.apply(parent, argumentList);
+                        }
+                        break;
+                    case "CONSTRUCT" /* MessageType.CONSTRUCT */:
+                        {
+                            const value = new rawValue(...argumentList);
+                            returnValue = proxy(value);
+                        }
+                        break;
+                    case "ENDPOINT" /* MessageType.ENDPOINT */:
+                        {
+                            const { port1, port2 } = new MessageChannel();
+                            expose(obj, port2);
+                            returnValue = transfer(port1, [port1]);
+                        }
+                        break;
+                    case "RELEASE" /* MessageType.RELEASE */:
+                        {
+                            returnValue = undefined;
+                        }
+                        break;
+                    default:
+                        return;
+                }
+            }
+            catch (value) {
+                returnValue = { value, [throwMarker]: 0 };
             }
+            Promise.resolve(returnValue)
+                .catch((value) => {
+                return { value, [throwMarker]: 0 };
+            })
+                .then((returnValue) => {
+                const [wireValue, transferables] = toWireValue(returnValue);
+                ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+                if (type === "RELEASE" /* MessageType.RELEASE */) {
+                    // detach and deactive after sending release response above.
+                    ep.removeEventListener("message", callback);
+                    closeEndPoint(ep);
+                    if (finalizer in obj && typeof obj[finalizer] === "function") {
+                        obj[finalizer]();
+                    }
+                }
+            })
+                .catch((error) => {
+                // Send Serialization Error To Caller
+                const [wireValue, transferables] = toWireValue({
+                    value: new TypeError("Unserializable return value"),
+                    [throwMarker]: 0,
+                });
+                ep.postMessage(Object.assign(Object.assign({}, wireValue), { id }), transferables);
+            });
+        });
+        if (ep.start) {
+            ep.start();
         }
     }
-
-    /**
-     * Get nested property value
-     * For example: getNestedValue(obj, 'a.b.c') will return obj.a.b.c
-     */
-    function getNestedValue(obj, path) {
-        const keys = String(path).split('.');
-        return get$1(obj, keys);
+    function isMessagePort(endpoint) {
+        return endpoint.constructor.name === "MessagePort";
     }
-    /**
-     * Set nested property value
-     * For example: setNestedValue(obj, 'a.b.c', value) will set obj.a.b.c = value
-     */
-    function setNestedValue(obj, path, value) {
-        const keys = String(path).split('.');
-        set$1(obj, keys, value);
+    function closeEndPoint(endpoint) {
+        if (isMessagePort(endpoint))
+            endpoint.close();
     }
-    /**
-     * Merge objects, but undefined values in source objects will not override existing values
-     * @param target - The target object
-     * @param sources - Source objects to merge
-     * @returns A new merged object
-     *
-     * @example
-     * assignDefined({ a: 1, b: 2 }, { b: undefined, c: 3 })
-     * // Returns: { a: 1, b: 2, c: 3 }
-     */
-    function assignDefined(target, ...sources) {
-        sources.forEach((source) => {
-            if (source) {
-                Object.keys(source).forEach((key) => {
-                    const value = source[key];
-                    if (value !== undefined) {
-                        target[key] = value;
-                    }
-                });
+    function wrap(ep, target) {
+        const pendingListeners = new Map();
+        ep.addEventListener("message", function handleMessage(ev) {
+            const { data } = ev;
+            if (!data || !data.id) {
+                return;
+            }
+            const resolver = pendingListeners.get(data.id);
+            if (!resolver) {
+                return;
+            }
+            try {
+                resolver(data);
+            }
+            finally {
+                pendingListeners.delete(data.id);
             }
         });
-        return target;
-    }
-    function mergeOptions(base, patch) {
-        return Object.assign({}, base, patch || {});
+        return createProxy(ep, pendingListeners, [], target);
     }
-
-    /**
-     * 通用排序核心函数
-     */
-    function sort$1(model, compareFn) {
-        const nodes = model.nodes();
-        nodes.sort(compareFn);
-        model.setNodeOrder(nodes);
-        return model;
+    function throwIfProxyReleased(isReleased) {
+        if (isReleased) {
+            throw new Error("Proxy has been released and is not useable");
+        }
     }
-    function orderByDegree(model) {
-        return sort$1(model, (nodeA, nodeB) => {
-            const degreeA = model.degree(nodeA.id);
-            const degreeB = model.degree(nodeB.id);
-            return degreeB - degreeA; // descending order
+    function releaseEndpoint(ep) {
+        return requestResponseMessage(ep, new Map(), {
+            type: "RELEASE" /* MessageType.RELEASE */,
+        }).then(() => {
+            closeEndPoint(ep);
         });
     }
-    /**
-     * 按 ID 排序
-     */
-    function orderById(model) {
-        return sort$1(model, (nodeA, nodeB) => {
-            const idA = nodeA.id;
-            const idB = nodeB.id;
-            if (typeof idA === 'number' && typeof idB === 'number') {
-                return idA - idB;
+    const proxyCounter = new WeakMap();
+    const proxyFinalizers = "FinalizationRegistry" in globalThis &&
+        new FinalizationRegistry((ep) => {
+            const newCount = (proxyCounter.get(ep) || 0) - 1;
+            proxyCounter.set(ep, newCount);
+            if (newCount === 0) {
+                releaseEndpoint(ep);
             }
-            return String(idA).localeCompare(String(idB));
         });
+    function registerProxy(proxy, ep) {
+        const newCount = (proxyCounter.get(ep) || 0) + 1;
+        proxyCounter.set(ep, newCount);
+        if (proxyFinalizers) {
+            proxyFinalizers.register(proxy, ep, proxy);
+        }
     }
-    /**
-     * 按自定义比较函数排序
-     */
-    function orderBySorter(model, sorter) {
-        return sort$1(model, (nodeA, nodeB) => {
-            const a = model.originalNode(nodeA.id);
-            const b = model.originalNode(nodeB.id);
-            return sorter(a, b);
-        });
+    function unregisterProxy(proxy) {
+        if (proxyFinalizers) {
+            proxyFinalizers.unregister(proxy);
+        }
     }
-    /**
-     * Order nodes according to graph topology
-     */
-    function orderByTopology(model, directed = false) {
-        const n = model.nodeCount();
-        if (n === 0)
-            return model;
-        const nodes = model.nodes();
-        const orderedNodes = [nodes[0]];
-        const pickFlags = {};
-        pickFlags[nodes[0].id] = true;
-        let k = 0;
-        let i = 0;
-        model.forEachNode((node) => {
-            if (i !== 0) {
-                const currentDegree = model.degree(node.id, 'both');
-                const nextDegree = i < n - 1 ? model.degree(nodes[i + 1].id, 'both') : 0;
-                const currentNodeId = orderedNodes[k].id;
-                const isNeighbor = model
-                    .neighbors(currentNodeId, 'both')
-                    .includes(node.id);
-                if ((i === n - 1 || currentDegree !== nextDegree || isNeighbor) &&
-                    !pickFlags[node.id]) {
-                    orderedNodes.push(node);
-                    pickFlags[node.id] = true;
-                    k++;
+    function createProxy(ep, pendingListeners, path = [], target = function () { }) {
+        let isProxyReleased = false;
+        const proxy = new Proxy(target, {
+            get(_target, prop) {
+                throwIfProxyReleased(isProxyReleased);
+                if (prop === releaseProxy) {
+                    return () => {
+                        unregisterProxy(proxy);
+                        releaseEndpoint(ep);
+                        pendingListeners.clear();
+                        isProxyReleased = true;
+                    };
                 }
-                else {
-                    const children = directed
-                        ? model.successors(currentNodeId)
-                        : model.neighbors(currentNodeId);
-                    let foundChild = false;
-                    for (let j = 0; j < children.length; j++) {
-                        const childId = children[j];
-                        const child = model.node(childId);
-                        if (child &&
-                            model.degree(childId) === model.degree(node.id) &&
-                            !pickFlags[childId]) {
-                            orderedNodes.push(child);
-                            pickFlags[childId] = true;
-                            foundChild = true;
-                            break;
-                        }
-                    }
-                    let ii = 0;
-                    while (!foundChild) {
-                        if (!pickFlags[nodes[ii].id]) {
-                            orderedNodes.push(nodes[ii]);
-                            pickFlags[nodes[ii].id] = true;
-                            foundChild = true;
-                        }
-                        ii++;
-                        if (ii === n) {
-                            break;
-                        }
+                if (prop === "then") {
+                    if (path.length === 0) {
+                        return { then: () => proxy };
                     }
+                    const r = requestResponseMessage(ep, pendingListeners, {
+                        type: "GET" /* MessageType.GET */,
+                        path: path.map((p) => p.toString()),
+                    }).then(fromWireValue);
+                    return r.then.bind(r);
+                }
+                return createProxy(ep, pendingListeners, [...path, prop]);
+            },
+            set(_target, prop, rawValue) {
+                throwIfProxyReleased(isProxyReleased);
+                // FIXME: ES6 Proxy Handler `set` methods are supposed to return a
+                // boolean. To show good will, we return true asynchronously ¯\_(ツ)_/¯
+                const [value, transferables] = toWireValue(rawValue);
+                return requestResponseMessage(ep, pendingListeners, {
+                    type: "SET" /* MessageType.SET */,
+                    path: [...path, prop].map((p) => p.toString()),
+                    value,
+                }, transferables).then(fromWireValue);
+            },
+            apply(_target, _thisArg, rawArgumentList) {
+                throwIfProxyReleased(isProxyReleased);
+                const last = path[path.length - 1];
+                if (last === createEndpoint) {
+                    return requestResponseMessage(ep, pendingListeners, {
+                        type: "ENDPOINT" /* MessageType.ENDPOINT */,
+                    }).then(fromWireValue);
+                }
+                // We just pretend that `bind()` didn’t happen.
+                if (last === "bind") {
+                    return createProxy(ep, pendingListeners, path.slice(0, -1));
                 }
+                const [argumentList, transferables] = processArguments(rawArgumentList);
+                return requestResponseMessage(ep, pendingListeners, {
+                    type: "APPLY" /* MessageType.APPLY */,
+                    path: path.map((p) => p.toString()),
+                    argumentList,
+                }, transferables).then(fromWireValue);
+            },
+            construct(_target, rawArgumentList) {
+                throwIfProxyReleased(isProxyReleased);
+                const [argumentList, transferables] = processArguments(rawArgumentList);
+                return requestResponseMessage(ep, pendingListeners, {
+                    type: "CONSTRUCT" /* MessageType.CONSTRUCT */,
+                    path: path.map((p) => p.toString()),
+                    argumentList,
+                }, transferables).then(fromWireValue);
+            },
+        });
+        registerProxy(proxy, ep);
+        return proxy;
+    }
+    function myFlat(arr) {
+        return Array.prototype.concat.apply([], arr);
+    }
+    function processArguments(argumentList) {
+        const processed = argumentList.map(toWireValue);
+        return [processed.map((v) => v[0]), myFlat(processed.map((v) => v[1]))];
+    }
+    const transferCache = new WeakMap();
+    function transfer(obj, transfers) {
+        transferCache.set(obj, transfers);
+        return obj;
+    }
+    function proxy(obj) {
+        return Object.assign(obj, { [proxyMarker]: true });
+    }
+    function toWireValue(value) {
+        for (const [name, handler] of transferHandlers) {
+            if (handler.canHandle(value)) {
+                const [serializedValue, transferables] = handler.serialize(value);
+                return [
+                    {
+                        type: "HANDLER" /* WireValueType.HANDLER */,
+                        name,
+                        value: serializedValue,
+                    },
+                    transferables,
+                ];
             }
-            i++;
-        });
-        // Update model with ordered nodes
-        model.setNodeOrder(orderedNodes);
-        return model;
+        }
+        return [
+            {
+                type: "RAW" /* WireValueType.RAW */,
+                value,
+            },
+            transferCache.get(value) || [],
+        ];
     }
-
-    function parsePoint(point) {
-        var _a;
-        return [point.x, point.y, (_a = point.z) !== null && _a !== void 0 ? _a : 0];
+    function fromWireValue(value) {
+        switch (value.type) {
+            case "HANDLER" /* WireValueType.HANDLER */:
+                return transferHandlers.get(value.name).deserialize(value.value);
+            case "RAW" /* WireValueType.RAW */:
+                return value.value;
+        }
     }
-    function toPointObject(point) {
-        var _a;
-        return { x: point[0], y: point[1], z: (_a = point[2]) !== null && _a !== void 0 ? _a : 0 };
+    function requestResponseMessage(ep, pendingListeners, msg, transfers) {
+        return new Promise((resolve) => {
+            const id = generateUUID();
+            pendingListeners.set(id, resolve);
+            if (ep.start) {
+                ep.start();
+            }
+            ep.postMessage(Object.assign({ id }, msg), transfers);
+        });
     }
-
-    function parseSize(size) {
-        if (!size)
-            return [0, 0, 0];
-        if (isNumber(size))
-            return [size, size, size];
-        else if (Array.isArray(size) && size.length === 0)
-            return [0, 0, 0];
-        const [x, y = x, z = x] = size;
-        return [x, y, z];
+    function generateUUID() {
+        return new Array(4)
+            .fill(0)
+            .map(() => Math.floor(Math.random() * Number.MAX_SAFE_INTEGER).toString(16))
+            .join("-");
     }
 
-    /**
-     * Viewport configuration such as width, height and center point.
-     */
-    const normalizeViewport = (options) => {
-        const { width, height, center } = options;
-        const normalizedWidth = width !== null && width !== void 0 ? width : (typeof window !== 'undefined' ? window.innerWidth : 0);
-        const normalizedHeight = height !== null && height !== void 0 ? height : (typeof window !== 'undefined' ? window.innerHeight : 0);
-        const centerPoint = center !== null && center !== void 0 ? center : [normalizedWidth / 2, normalizedHeight / 2];
-        return {
-            width: normalizedWidth,
-            height: normalizedHeight,
-            center: centerPoint,
-        };
-    };
+    class Supervisor {
+        constructor() {
+            this.worker = null;
+            this.workerApi = null;
+        }
+        /**
+         * Execute layout in worker
+         */
+        execute(layoutId, data, options) {
+            return __awaiter(this, void 0, void 0, function* () {
+                if (!this.worker) {
+                    yield this.initWorker();
+                }
+                if (!this.workerApi) {
+                    throw new Error('Worker API not initialized');
+                }
+                return yield this.workerApi.execute(layoutId, data, options);
+            });
+        }
+        /**
+         * Destroy worker
+         */
+        destroy() {
+            if (this.workerApi) {
+                this.workerApi.destroy();
+            }
+            if (this.worker) {
+                this.worker.terminate();
+                this.worker = null;
+                this.workerApi = null;
+            }
+        }
+        /**
+         * Initialize worker
+         */
+        initWorker() {
+            return __awaiter(this, void 0, void 0, function* () {
+                const workerPath = this.resolveWorkerPath();
+                const isESM = workerPath.includes('/lib/') || workerPath.endsWith('.mjs');
+                const type = isESM ? 'module' : 'classic';
+                this.worker = new Worker(workerPath, { type });
+                this.workerApi = wrap(this.worker);
+            });
+        }
+        /**
+         * Resolve worker script path which works in both ESM and UMD environments
+         */
+        resolveWorkerPath() {
+            if (typeof ({ url: (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)) }) !== 'undefined' && (typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href))) {
+                const currentUrl = new URL((typeof document === 'undefined' && typeof location === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : typeof document === 'undefined' ? location.href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('index.js', document.baseURI).href)));
+                // e.g. `.../lib/runtime/supervisor.js` -> `.../lib/worker.js`
+                const asRoot = currentUrl.href.replace(/\/runtime\/[^/]+\.js$/, '/worker.js');
+                if (asRoot !== currentUrl.href)
+                    return asRoot;
+                // Fallback: keep legacy behavior (same directory)
+                return currentUrl.href.replace(/\/[^/]+\.js$/, '/worker.js');
+            }
+            if (typeof document !== 'undefined') {
+                const scripts = document.getElementsByTagName('script');
+                for (let i = scripts.length - 1; i >= 0; i--) {
+                    const src = scripts[i].src;
+                    if (src && (src.includes('index.js') || src.includes('index.min.js'))) {
+                        return src.replace(/index(\.min)?\.js/, 'worker.js');
+                    }
+                }
+            }
+            return './worker.js';
+        }
+    }
 
     /**
      * <zh/> 布局基类
@@ -1555,14 +1617,17 @@
     class BaseLayout {
         constructor(options) {
             this.supervisor = null;
-            this.initialOptions = mergeOptions(this.getDefaultOptions(), options);
+            this.initialOptions = this.mergeOptions(this.getDefaultOptions(), options);
         }
         get options() {
             return this.runtimeOptions || this.initialOptions;
         }
+        mergeOptions(base, patch) {
+            return Object.assign({}, base, patch || {});
+        }
         execute(data, userOptions) {
             return __awaiter(this, void 0, void 0, function* () {
-                this.runtimeOptions = mergeOptions(this.initialOptions, userOptions);
+                this.runtimeOptions = this.mergeOptions(this.initialOptions, userOptions);
                 const { node, edge, enableWorker } = this.runtimeOptions;
                 this.context = new RuntimeContext(data, { node, edge });
                 this.model = this.context.graph;
@@ -1627,71 +1692,6 @@
         return !!layout.tick && !!layout.stop;
     }
 
-    /**
-     * Format value with multiple types into a function that returns a number
-     * @param value The value to be formatted
-     * @param defaultValue The default value when value is invalid
-     * @returns A function that returns a number
-     */
-    function formatNumberFn(value, defaultValue) {
-        // If value is a function, return it directly
-        if (isFunction(value)) {
-            return value;
-        }
-        // If value is a number, return a function that returns this number
-        if (isNumber(value)) {
-            return () => value;
-        }
-        // For other cases (undefined or invalid values), return default value function
-        return () => defaultValue;
-    }
-    /**
-     * Format size config with multiple types into a function that returns a size
-     * @param value The value to be formatted
-     * @param defaultValue The default value when value is invalid
-     * @param resultIsNumber Whether to return a number (max of width/height) or size array
-     * @returns A function that returns a size
-     */
-    function formatSizeFn(value, defaultValue = 10) {
-        // If value is undefined, return default value function
-        if (!value) {
-            return () => defaultValue;
-        }
-        // If value is a function, return it directly
-        if (isFunction(value)) {
-            return value;
-        }
-        // If value is a number, return a function that returns this number
-        if (isNumber(value)) {
-            return () => value;
-        }
-        // If value is an array, return max or the array itself
-        if (Array.isArray(value)) {
-            return () => value;
-        }
-        // If value is an object with width and height
-        if (isObject$1(value) && value.width && value.height) {
-            return () => [value.width, value.height];
-        }
-        return () => defaultValue;
-    }
-    /**
-     * Format nodeSize and nodeSpacing into a function that returns the total size
-     * @param nodeSize The size of the node
-     * @param nodeSpacing The spacing around the node
-     * @param defaultNodeSize The default node size when value is invalid
-     * @returns A function that returns the total size (node size + spacing)
-     */
-    const formatNodeSizeFn = (nodeSize, nodeSpacing, defaultNodeSize = 10) => {
-        const nodeSpacingFunc = formatNumberFn(nodeSpacing, 0);
-        const nodeSizeFunc = formatSizeFn(nodeSize, defaultNodeSize);
-        return (node) => {
-            const size = nodeSizeFunc(node);
-            const spacing = nodeSpacingFunc(node);
-            return Math.max(...parseSize(size)) + spacing;
-        };
-    };
-
     /**
      * <zh/> 内部图数据结构，用于 antv-dagre 布局算法
      *
@@ -5131,9 +5131,9 @@
             return __awaiter(this, void 0, void 0, function* () {
                 const { nodeSize, align, rankdir = 'TB', ranksep, nodesep, edgeLabelSpace, ranker = 'tight-tree', nodeOrder, begin, controlPoints, radial, sortByCombo, 
                 // focusNode,
-                preset, } = options;
-                const ranksepfunc = formatNumberFn(ranksep, DEFAULTS_LAYOUT_OPTIONS$8.ranksep);
-                const nodesepfunc = formatNumberFn(nodesep, DEFAULTS_LAYOUT_OPTIONS$8.nodesep);
+                preset, ranksepFunc, nodesepFunc, } = options;
+                const ranksepfunc = formatNumberFn(ranksepFunc, ranksep !== null && ranksep !== void 0 ? ranksep : 50);
+                const nodesepfunc = formatNumberFn(nodesepFunc, nodesep !== null && nodesep !== void 0 ? nodesep : 50);
                 let horisep = nodesepfunc;
                 let vertisep = ranksepfunc;
                 if (rankdir === 'LR' || rankdir === 'RL') {
@@ -5148,9 +5148,10 @@
                 const edges = this.model.edges();
                 nodes.forEach((node) => {
                     var _a;
-                    const size = parseSize(nodeSizeFunc(node));
-                    const verti = vertisep(node);
-                    const hori = horisep(node);
+                    const raw = node._original;
+                    const size = parseSize(nodeSizeFunc(raw));
+                    const verti = vertisep(raw);
+                    const hori = horisep(raw);
                     const width = size[0] + 2 * hori;
                     const height = size[1] + 2 * verti;
                     const layer = (_a = node.data) === null || _a === void 0 ? void 0 : _a.layer;
@@ -5216,6 +5217,7 @@
                     acyclicer: 'greedy',
                     ranker,
                     rankdir,
+                    nodesep,
                     align,
                 });
                 const layoutTopLeft = [0, 0];
@@ -7320,25 +7322,17 @@
     }
 
     const DEFAULTS_LAYOUT_OPTIONS$6 = {
-        centerStrength: 1,
-        edgeId: (d) => String(d.id),
-        linkDistance: 30,
-        edgeStrength: undefined,
-        edgeIterations: 1,
+        link: {
+            id: (d) => String(d.id),
+        },
+        manyBody: {
+            strength: -30,
+        },
         preventOverlap: false,
         nodeSize: 10,
         nodeSpacing: 0,
-        collideStrength: 1,
-        collideIterations: 1,
-        nodeStrength: -30,
-        distanceMin: undefined,
-        distanceMax: undefined,
-        theta: undefined,
-        alpha: 1,
-        alphaMin: 0.001,
-        alphaDecay: 1 - Math.pow(0.001, 1 / 300),
-        alphaTarget: 0,
-        velocityDecay: 0.4,
+        x: false,
+        y: false,
         clustering: false,
         clusterNodeStrength: -1,
         clusterEdgeStrength: 0.1,
@@ -7555,20 +7549,17 @@
             this.setupClusterForce(simulation, options);
         }
         getCenterOptions(options) {
-            if (!options.width ||
-                !options.height ||
-                options.centerStrength !== undefined) {
-                const viewport = normalizeViewport({
-                    width: options.width,
-                    height: options.height,
-                });
-                return assignDefined({}, options.center || {}, {
-                    x: viewport.width / 2,
-                    y: viewport.height / 2,
-                    strength: options.centerStrength,
-                });
-            }
-            return undefined;
+            if (options.center === false)
+                return undefined;
+            const viewport = normalizeViewport({
+                width: options.width,
+                height: options.height,
+            });
+            return assignDefined({}, options.center || {}, {
+                x: viewport.width / 2,
+                y: viewport.height / 2,
+                strength: options.centerStrength,
+            });
         }
         setupCenterForce(simulation, options) {
             const center = this.getCenterOptions(options);
@@ -7592,19 +7583,14 @@
             }
         }
         getManyBodyOptions(options) {
-            if (options.manyBody !== undefined ||
-                options.nodeStrength !== undefined ||
-                options.distanceMin !== undefined ||
-                options.distanceMax !== undefined ||
-                options.theta !== undefined) {
-                return assignDefined({}, options.manyBody || {}, {
-                    strength: options.nodeStrength,
-                    distanceMin: options.distanceMin,
-                    distanceMax: options.distanceMax,
-                    theta: options.theta,
-                });
-            }
-            return undefined;
+            if (options.manyBody === false)
+                return undefined;
+            return assignDefined({}, options.manyBody || {}, {
+                strength: options.nodeStrength,
+                distanceMin: options.distanceMin,
+                distanceMax: options.distanceMax,
+                theta: options.theta,
+            });
         }
         setupManyBodyForce(simulation, options) {
             const manyBody = this.getManyBodyOptions(options);
@@ -7630,19 +7616,14 @@
             }
         }
         getLinkOptions(options) {
-            if (options.link ||
-                options.edgeId !== undefined ||
-                options.linkDistance !== undefined ||
-                options.edgeStrength !== undefined ||
-                options.edgeIterations !== undefined) {
-                return assignDefined({}, options.link || {}, {
-                    id: options.edgeId,
-                    distance: options.linkDistance,
-                    strength: options.edgeStrength,
-                    iterations: options.edgeIterations,
-                });
-            }
-            return undefined;
+            if (options.link === false)
+                return undefined;
+            return assignDefined({}, options.link || {}, {
+                id: options.edgeId,
+                distance: options.linkDistance,
+                strength: options.edgeStrength,
+                iterations: options.edgeIterations,
+            });
         }
         setupLinkForce(simulation, options) {
             const edges = this.model.edges();
@@ -7669,23 +7650,16 @@
             }
         }
         getCollisionOptions(options) {
-            if (!options.preventOverlap)
+            if (options.preventOverlap === false || options.collide === false)
                 return undefined;
-            if (options.collide !== undefined ||
-                options.nodeSize !== undefined ||
-                options.nodeSpacing !== undefined ||
-                options.collideStrength !== undefined ||
-                options.collideIterations !== undefined) {
-                const radius = options.nodeSize || options.nodeSpacing
-                    ? (d) => formatNodeSizeFn(options.nodeSize, options.nodeSpacing)(d._original) / 2
-                    : undefined;
-                return assignDefined({}, options.collide || {}, {
-                    radius,
-                    strength: options.collideStrength,
-                    iterations: options.collideIterations,
-                });
-            }
-            return undefined;
+            const radius = options.nodeSize || options.nodeSpacing
+                ? (d) => formatNodeSizeFn(options.nodeSize, options.nodeSpacing)(d._original) / 2
+                : undefined;
+            return assignDefined({}, options.collide || {}, {
+                radius: options.collide || radius,
+                strength: options.collideStrength,
+                iterations: options.collideIterations,
+            });
         }
         setupCollisionForce(simulation, options) {
             const collide = this.getCollisionOptions(options);
@@ -7710,18 +7684,13 @@
         }
         getXForceOptions(options) {
             var _a;
-            if (options.x !== undefined ||
-                options.forceXPosition !== undefined ||
-                options.forceXStrength !== undefined ||
-                options.width !== undefined ||
-                options.height !== undefined) {
-                const center = this.getCenterOptions(options);
-                return assignDefined({}, options.x || {}, {
-                    x: (_a = options.forceXPosition) !== null && _a !== void 0 ? _a : (center && center.x),
-                    strength: options.forceXStrength,
-                });
-            }
-            return undefined;
+            if (options.x === false)
+                return undefined;
+            const center = this.getCenterOptions(options);
+            return assignDefined({}, options.x || {}, {
+                x: (_a = options.forceXPosition) !== null && _a !== void 0 ? _a : (center && center.x),
+                strength: options.forceXStrength,
+            });
         }
         setupXForce(simulation, options) {
             const x = this.getXForceOptions(options);
@@ -7744,18 +7713,13 @@
         }
         getYForceOptions(options) {
             var _a;
-            if (options.y !== undefined ||
-                options.forceYPosition !== undefined ||
-                options.forceYStrength !== undefined ||
-                options.width !== undefined ||
-                options.height !== undefined) {
-                const center = this.getCenterOptions(options);
-                return assignDefined({}, options.y || {}, {
-                    y: (_a = options.forceYPosition) !== null && _a !== void 0 ? _a : (center && center.y),
-                    strength: options.forceYStrength,
-                });
-            }
-            return undefined;
+            if (options.y === false)
+                return undefined;
+            const center = this.getCenterOptions(options);
+            return assignDefined({}, options.y || {}, {
+                y: (_a = options.forceYPosition) !== null && _a !== void 0 ? _a : (center && center.y),
+                strength: options.forceYStrength,
+            });
         }
         setupYForce(simulation, options) {
             const y = this.getYForceOptions(options);
@@ -32799,7 +32763,6 @@ ${indent}columns: ${matrix.columns}
     exports.isArray = isArray;
     exports.isLayoutWithIterations = isLayoutWithIterations;
     exports.johnson = johnson;
-    exports.mergeOptions = mergeOptions;
     exports.normalizeViewport = normalizeViewport;
     exports.orderByDegree = orderByDegree;
     exports.orderById = orderById;