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

package/dist/index.js

@@ -357,975 +357,1012 @@
         return result;
     });
 
-    /**
-     * @license
-     * Copyright 2019 Google LLC
-     * SPDX-License-Identifier: Apache-2.0
-     */
-    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";
-    /**
-     * Internal transfer handle to handle objects marked to proxy.
-     */
-    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);
-        },
-    };
-    /**
-     * Internal transfer handler to handle thrown exceptions.
-     */
-    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;
-        },
-    };
-    /**
-     * 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;
-            }
+    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));
         }
-        return false;
-    }
-    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;
+        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 { 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;
-                }
+            const nodeId = this.indexNodeCache.get(index);
+            return nodeId ? this.nodeMap.get(nodeId) : undefined;
+        }
+        nodeIndexOf(id) {
+            var _a;
+            if (!this.nodeIndexCache) {
+                this.buildNodeIndexCache();
             }
-            catch (value) {
-                returnValue = { value, [throwMarker]: 0 };
+            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();
             }
-            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();
+            const degree = this.degreeCache.get(nodeId);
+            if (!degree)
+                return 0;
+            return degree[direction];
         }
-    }
-    function isMessagePort(endpoint) {
-        return endpoint.constructor.name === "MessagePort";
-    }
-    function closeEndPoint(endpoint) {
-        if (isMessagePort(endpoint))
-            endpoint.close();
-    }
-    function wrap(ep, target) {
-        const pendingListeners = new Map();
-        ep.addEventListener("message", function handleMessage(ev) {
-            const { data } = ev;
-            if (!data || !data.id) {
-                return;
+        neighbors(nodeId, direction = 'both') {
+            if (!this.outAdjacencyCache || !this.inAdjacencyCache) {
+                this.buildAdjacencyCache();
             }
-            const resolver = pendingListeners.get(data.id);
-            if (!resolver) {
-                return;
+            if (direction === 'out') {
+                return Array.from(this.outAdjacencyCache.get(nodeId) || []);
             }
-            try {
-                resolver(data);
+            if (direction === 'in') {
+                return Array.from(this.inAdjacencyCache.get(nodeId) || []);
             }
-            finally {
-                pendingListeners.delete(data.id);
+            if (this.bothAdjacencyCache) {
+                return Array.from(this.bothAdjacencyCache.get(nodeId) || []);
             }
-        });
-        return createProxy(ep, pendingListeners, [], target);
-    }
-    function throwIfProxyReleased(isReleased) {
-        if (isReleased) {
-            throw new Error("Proxy has been released and is not useable");
+            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 releaseEndpoint(ep) {
-        return requestResponseMessage(ep, new Map(), {
-            type: "RELEASE" /* MessageType.RELEASE */,
-        }).then(() => {
-            closeEndPoint(ep);
-        });
-    }
-    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);
-            }
-        });
-    function registerProxy(proxy, ep) {
-        const newCount = (proxyCounter.get(ep) || 0) + 1;
-        proxyCounter.set(ep, newCount);
-        if (proxyFinalizers) {
-            proxyFinalizers.register(proxy, ep, proxy);
+        successors(nodeId) {
+            return this.neighbors(nodeId, 'out');
         }
-    }
-    function unregisterProxy(proxy) {
-        if (proxyFinalizers) {
-            proxyFinalizers.unregister(proxy);
+        predecessors(nodeId) {
+            return this.neighbors(nodeId, 'in');
         }
-    }
-    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;
-                    };
+        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());
                 }
-                const result = yield this.workerApi.execute(layoutId, data, options);
-                return result;
+                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 worker
-         */
         destroy() {
-            if (this.workerApi) {
-                this.workerApi.destroy();
-            }
-            if (this.worker) {
-                this.worker.terminate();
-                this.worker = null;
-                this.workerApi = null;
-            }
+            this.clearCache();
+            this.nodeMap.clear();
+            this.edgeMap.clear();
+            this.edgeIdCounter.clear();
         }
-        /**
-         * 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);
-            });
+    }
+    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');
         }
-        /**
-         * 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)));
-                return currentUrl.href.replace(/\/[^/]+\.js$/, '/worker.js');
+        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;
                 }
             }
+            if (isNil(edgeData.source) || isNil(edgeData.target)) {
+                throw new Error(`Edge is missing source or target field`);
+            }
+            if (isNil(edgeData.id)) {
+                edgeData.id = getEdgeId === null || getEdgeId === void 0 ? void 0 : getEdgeId(datum);
+            }
+            result.set(edgeData.id, edgeData);
         }
-        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;
+        return result;
+    }
+    function initNodePosition(model, width, height, dimensions = 2) {
         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(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);
             }
         });
-        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;
-    };
+    }
+
+    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();
+        }
+    }
+
     /**
-     * scale matrix
-     * @param matrix [ [], [], [] ]
-     * @param ratio
+     * @license
+     * Copyright 2019 Google LLC
+     * SPDX-License-Identifier: Apache-2.0
      */
-    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[i] = newRow;
-        }
-        return result;
+    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";
+    /**
+     * Internal transfer handle to handle objects marked to proxy.
+     */
+    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);
+        },
     };
     /**
-     * calculate the bounding box for the nodes according to their x, y, and size
-     * @param nodes nodes in the layout
-     * @returns
+     * Internal transfer handler to handle thrown exceptions.
      */
-    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]];
+    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 if (size === undefined || isNaN(size)) {
-                size = [30, 30];
+            else {
+                serialized = { isError: false, value };
             }
-            else if (isNumber(size)) {
-                size = [size, size];
+            return [serialized, []];
+        },
+        deserialize(serialized) {
+            if (serialized.isError) {
+                throw Object.assign(new Error(serialized.value.message), serialized.value);
             }
-            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
-        }
+            throw serialized.value;
+        },
     };
     /**
-     * Use Johnson + Dijkstra to compute APSP for sparse graph.
-     * Fully compatible with floydWarshall(adjMatrix).
+     * Allows customizing the serialization of certain values.
      */
-    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);
+    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 distAll;
+        return false;
     }
-    /**
-     * 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]);
+    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;
+            }
+            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();
         }
-        return dist;
     }
-    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 isMessagePort(endpoint) {
+        return endpoint.constructor.name === "MessagePort";
+    }
+    function closeEndPoint(endpoint) {
+        if (isMessagePort(endpoint))
+            endpoint.close();
+    }
+    function wrap(ep, target) {
+        const pendingListeners = new Map();
+        ep.addEventListener("message", function handleMessage(ev) {
+            const { data } = ev;
+            if (!data || !data.id) {
+                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;
+            const resolver = pendingListeners.get(data.id);
+            if (!resolver) {
+                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;
+            try {
+                resolver(data);
             }
-        }
-    }
-
-    class LayoutModel {
-        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 };
-        }
-        apply(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();
+            finally {
+                pendingListeners.delete(data.id);
             }
-            const nodeId = this.indexNodeCache.get(index);
-            return nodeId ? this.nodeMap.get(nodeId) : undefined;
+        });
+        return createProxy(ep, pendingListeners, [], target);
+    }
+    function throwIfProxyReleased(isReleased) {
+        if (isReleased) {
+            throw new Error("Proxy has been released and is not useable");
         }
-        nodeIndexOf(id) {
-            var _a;
-            if (!this.nodeIndexCache) {
-                this.buildNodeIndexCache();
+    }
+    function releaseEndpoint(ep) {
+        return requestResponseMessage(ep, new Map(), {
+            type: "RELEASE" /* MessageType.RELEASE */,
+        }).then(() => {
+            closeEndPoint(ep);
+        });
+    }
+    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 (_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++));
+        });
+    function registerProxy(proxy, ep) {
+        const newCount = (proxyCounter.get(ep) || 0) + 1;
+        proxyCounter.set(ep, newCount);
+        if (proxyFinalizers) {
+            proxyFinalizers.register(proxy, ep, proxy);
         }
-        originalEdge(id) {
-            const edge = this.edgeMap.get(id);
-            return edge === null || edge === void 0 ? void 0 : edge._original;
+    }
+    function unregisterProxy(proxy) {
+        if (proxyFinalizers) {
+            proxyFinalizers.unregister(proxy);
         }
-        edgeCount() {
-            return this.edgeMap.size;
+    }
+    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;
+                    };
+                }
+                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,
+                ];
+            }
         }
-        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;
+        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;
         }
-        degree(nodeId, direction = 'both') {
-            if (!this.degreeCache) {
-                this.buildDegreeCache();
+    }
+    function requestResponseMessage(ep, pendingListeners, msg, transfers) {
+        return new Promise((resolve) => {
+            const id = generateUUID();
+            pendingListeners.set(id, resolve);
+            if (ep.start) {
+                ep.start();
             }
-            const degree = this.degreeCache.get(nodeId);
-            if (!degree)
-                return 0;
-            return degree[direction];
+            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;
         }
-        neighbors(nodeId, direction = 'both') {
-            if (!this.outAdjacencyCache || !this.inAdjacencyCache) {
-                this.buildAdjacencyCache();
+        /**
+         * 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 (direction === 'out') {
-                return Array.from(this.outAdjacencyCache.get(nodeId) || []);
+            if (this.worker) {
+                this.worker.terminate();
+                this.worker = null;
+                this.workerApi = null;
             }
-            if (direction === 'in') {
-                return Array.from(this.inAdjacencyCache.get(nodeId) || []);
+        }
+        /**
+         * 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 (this.bothAdjacencyCache) {
-                return Array.from(this.bothAdjacencyCache.get(nodeId) || []);
+            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');
+                    }
+                }
             }
-            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');
+            return './worker.js';
         }
-        predecessors(nodeId) {
-            return this.neighbors(nodeId, 'in');
+    }
+
+    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;
+            }
         }
-        clearCache() {
-            this.degreeCache = undefined;
-            this.inAdjacencyCache = undefined;
-            this.outAdjacencyCache = undefined;
-            this.bothAdjacencyCache = undefined;
-            this.nodeIndexCache = undefined;
-            this.indexNodeCache = undefined;
+    }
+
+    /**
+     * 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;
+            }
         }
-        buildDegreeCache() {
-            this.degreeCache = new Map();
-            for (const edge of this.edges()) {
-                const { source, target } = edge;
-                if (edge.source === 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.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++;
+                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;
+                    }
                 }
             }
         }
-        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());
-                }
-                this.outAdjacencyCache.get(edge.source).add(edge.target);
-                if (!this.inAdjacencyCache.has(edge.target)) {
-                    this.inAdjacencyCache.set(edge.target, new Set());
-                }
-                this.inAdjacencyCache.get(edge.target).add(edge.source);
+        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;
+            }
+        });
+        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[i] = newRow;
         }
-        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;
+        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]];
             }
-            if (node) {
-                const customFields = node(datum);
-                for (const key in customFields) {
-                    const value = customFields[key];
-                    if (isNil(value))
-                        continue;
-                    nodeData[key] = value;
-                }
+            else if (size === undefined || isNaN(size)) {
+                size = [30, 30];
             }
-            if (isNil(nodeData.id)) {
-                throw new Error(`Node is missing id field`);
+            else if (isNumber(size)) {
+                size = [size, size];
             }
-            result.set(nodeData.id, nodeData);
+            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 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;
+    /**
+     * 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]);
                 }
             }
-            if (isNil(edgeData.source) || isNil(edgeData.target)) {
-                throw new Error(`Edge is missing source or target field`);
-            }
-            if (isNil(edgeData.id)) {
-                edgeData.id = getEdgeId === null || getEdgeId === void 0 ? void 0 : getEdgeId(datum);
-            }
-            result.set(edgeData.id, edgeData);
         }
-        return result;
+        return dist;
     }
-    function initModelNodePosition(model, width, height, dimensions = 2) {
-        model.forEachNode((node) => {
-            if (isNil(node.x)) {
-                node.x = Math.random() * width;
+    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);
             }
-            if (isNil(node.y)) {
-                node.y = Math.random() * height;
+            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 (dimensions === 3 && isNil(node.z)) {
-                node.z = Math.random() * Math.min(width, height);
+        }
+        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;
             }
-        });
+        }
     }
 
     /**
@@ -1377,10 +1414,7 @@
     function sort$1(model, compareFn) {
         const nodes = model.nodes();
         nodes.sort(compareFn);
-        model.nodeMap.clear();
-        nodes.forEach((node) => {
-            model.nodeMap.set(node.id, node);
-        });
+        model.setNodeOrder(nodes);
         return model;
     }
     function orderByDegree(model) {
@@ -1474,10 +1508,7 @@
             i++;
         });
         // Update model with ordered nodes
-        model.nodeMap.clear();
-        orderedNodes.forEach((node) => {
-            model.nodeMap.set(node.id, node);
-        });
+        model.setNodeOrder(orderedNodes);
         return model;
     }
 
@@ -1533,7 +1564,8 @@
             return __awaiter(this, void 0, void 0, function* () {
                 this.runtimeOptions = mergeOptions(this.initialOptions, userOptions);
                 const { node, edge, enableWorker } = this.runtimeOptions;
-                this.model = new LayoutModel(data, { node, edge });
+                this.context = new RuntimeContext(data, { node, edge });
+                this.model = this.context.graph;
                 const shouldUseWorker = enableWorker && typeof Worker !== 'undefined';
                 if (shouldUseWorker) {
                     yield this.layoutInWorker(data, this.runtimeOptions);
@@ -1551,7 +1583,7 @@
                         this.supervisor = new Supervisor();
                     }
                     const result = yield this.supervisor.execute(this.id, data, options);
-                    (_a = this.model) === null || _a === void 0 ? void 0 : _a.apply(result);
+                    (_a = this.context) === null || _a === void 0 ? void 0 : _a.replace(result);
                 }
                 catch (error) {
                     console.error('Layout in worker failed, fallback to main thread layout.', error);
@@ -1561,20 +1593,18 @@
             });
         }
         forEachNode(callback) {
-            this.model.forEachNode(callback);
+            this.context.forEachNode(callback);
         }
         forEachEdge(callback) {
-            this.model.forEachEdge((edge, i) => {
-                edge.sourceNode = this.model.nodeMap.get(edge.source);
-                edge.targetNode = this.model.nodeMap.get(edge.target);
-                callback(edge, i);
-            });
+            this.context.forEachEdge(callback);
         }
         destroy() {
             var _a;
-            (_a = this.model) === null || _a === void 0 ? void 0 : _a.destroy();
+            (_a = this.context) === null || _a === void 0 ? void 0 : _a.destroy();
             // @ts-ignore
             this.model = null;
+            // @ts-ignore
+            this.context = null;
             if (this.supervisor) {
                 this.supervisor.destroy();
                 this.supervisor = null;
@@ -24213,7 +24243,7 @@
                 const options = this.parseOptions(this.options);
                 const { width, height, dimensions } = options;
                 this.initializePhysicsData(this.model, options);
-                initModelNodePosition(this.model, width, height, dimensions);
+                initNodePosition(this.model, width, height, dimensions);
                 if (!((_a = this.model.nodes()) === null || _a === void 0 ? void 0 : _a.length))
                     return;
                 const simulation = this.setSimulation(options);
@@ -25305,7 +25335,7 @@
                 if (!n || n === 1) {
                     return applySingleNodeLayout(this.model, center);
                 }
-                initModelNodePosition(this.model, width, height);
+                initNodePosition(this.model, width, height);
                 const sizes = this.getSizes(merged.nodeSize, merged.nodeSpacing);
                 const simulation = this.setSimulation();
                 simulation.data(this.model, sizes);
@@ -25809,7 +25839,7 @@
                     applySingleNodeLayout(this.model, center, dimensions);
                     return;
                 }
-                initModelNodePosition(this.model, width, height, dimensions);
+                initNodePosition(this.model, width, height, dimensions);
                 const simulation = this.setSimulation();
                 simulation.data(this.model);
                 simulation.initialize(options);
@@ -32413,8 +32443,6 @@ ${indent}columns: ${matrix.columns}
         layout() {
             return __awaiter(this, void 0, void 0, function* () {
                 const { width, height, center } = normalizeViewport(this.options);
-                const layoutScale = 0.9;
-                const randomCoord = (size) => (Math.random() - 0.5) * layoutScale * size;
                 this.model.forEachNode((node) => {
                     node.x = randomCoord(width) + center[0];
                     node.y = randomCoord(height) + center[1];
@@ -32422,6 +32450,13 @@ ${indent}columns: ${matrix.columns}
             });
         }
     }
+    const layoutScale = 0.9;
+    /**
+     * <zh/> 生成随机坐标
+     *
+     * <en/> Generate random coordinates
+     */
+    const randomCoord = (size) => (Math.random() - 0.5) * layoutScale * size;
 
     const registry = {
         'antv-dagre': AntVDagreLayout,
@@ -32744,11 +32779,13 @@ ${indent}columns: ${matrix.columns}
     exports.ForceAtlas2Layout = ForceAtlas2Layout;
     exports.ForceLayout = ForceLayout;
     exports.FruchtermanLayout = FruchtermanLayout;
+    exports.GraphLib = GraphLib;
     exports.GridLayout = GridLayout;
-    exports.LayoutModel = LayoutModel;
     exports.MDSLayout = MDSLayout;
     exports.RadialLayout = RadialLayout;
     exports.RandomLayout = RandomLayout;
+    exports.RuntimeContext = RuntimeContext;
+    exports.Supervisor = Supervisor;
     exports.applySingleNodeLayout = applySingleNodeLayout;
     exports.assignDefined = assignDefined;
     exports.floydWarshall = floydWarshall;
@@ -32758,8 +32795,9 @@ ${indent}columns: ${matrix.columns}
     exports.getLayoutBBox = getLayoutBBox;
     exports.getNestedValue = getNestedValue;
     exports.graphTreeDfs = graphTreeDfs;
-    exports.initModelNodePosition = initModelNodePosition;
+    exports.initNodePosition = initNodePosition;
     exports.isArray = isArray;
+    exports.isLayoutWithIterations = isLayoutWithIterations;
     exports.johnson = johnson;
     exports.mergeOptions = mergeOptions;
     exports.normalizeViewport = normalizeViewport;