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

package/dist/index.js

@@ -357,421 +357,6 @@
         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;
-            }
-        }
-        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;
-            }
-            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();
-        }
-    }
-    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;
-            }
-            const resolver = pendingListeners.get(data.id);
-            if (!resolver) {
-                return;
-            }
-            try {
-                resolver(data);
-            }
-            finally {
-                pendingListeners.delete(data.id);
-            }
-        });
-        return createProxy(ep, pendingListeners, [], target);
-    }
-    function throwIfProxyReleased(isReleased) {
-        if (isReleased) {
-            throw new Error("Proxy has been released and is not useable");
-        }
-    }
-    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);
-        }
-    }
-    function unregisterProxy(proxy) {
-        if (proxyFinalizers) {
-            proxyFinalizers.unregister(proxy);
-        }
-    }
-    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,
-                ];
-            }
-        }
-        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();
-                }
-                if (!this.workerApi) {
-                    throw new Error('Worker API not initialized');
-                }
-                const result = yield this.workerApi.execute(layoutId, data, options);
-                return result;
-            });
-        }
-        /**
-         * 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)));
-                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';
-        }
-    }
-
     const isArray = Array.isArray;
 
     /**
@@ -1008,58 +593,302 @@
                 }
             }
         }
-        return dist;
+        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);
+            }
+            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;
+            }
+        }
+        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;
+            }
+        }
+    }
+
+    /**
+     * 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);
+    }
+    /**
+     * 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);
+    }
+    /**
+     * 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;
+                    }
+                });
+            }
+        });
+        return target;
+    }
+
+    /**
+     * 通用排序核心函数
+     */
+    function sort$1(model, compareFn) {
+        const nodes = model.nodes();
+        nodes.sort(compareFn);
+        model.setNodeOrder(nodes);
+        return model;
+    }
+    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;
+            }
+            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++;
+                }
+                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;
+                        }
+                    }
+                }
+            }
+            i++;
+        });
+        // Update model with ordered nodes
+        model.setNodeOrder(orderedNodes);
+        return model;
+    }
+
+    function parsePoint(point) {
+        var _a;
+        return [point.x, point.y, (_a = point.z) !== null && _a !== void 0 ? _a : 0];
+    }
+    function toPointObject(point) {
+        var _a;
+        return { x: point[0], y: point[1], z: (_a = point[2]) !== null && _a !== void 0 ? _a : 0 };
+    }
+
+    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];
+    }
+
+    /**
+     * 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;
     }
-    class MinHeap {
-        constructor() {
-            this.data = [];
-        }
-        push(item) {
-            this.data.push(item);
-            this.bubbleUp(this.data.length - 1);
+    /**
+     * 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;
         }
-        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;
+        // If value is a function, return it directly
+        if (isFunction(value)) {
+            return value;
         }
-        empty() {
-            return this.data.length === 0;
+        // If value is a number, return a function that returns this number
+        if (isNumber(value)) {
+            return () => value;
         }
-        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 value is an array, return max or the array itself
+        if (Array.isArray(value)) {
+            return () => value;
         }
-        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;
-            }
+        // 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;
+        };
+    };
 
-    class LayoutModel {
+    class GraphLib {
         constructor(data, options = {}) {
             this.edgeIdCounter = new Map();
             this.nodeMap = extractNodeData(data.nodes, options.node);
@@ -1068,7 +897,7 @@
         data() {
             return { nodes: this.nodeMap, edges: this.edgeMap };
         }
-        apply(result) {
+        replace(result) {
             this.nodeMap = result.nodes;
             this.edgeMap = result.edges;
             this.clearCache();
@@ -1177,6 +1006,14 @@
         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;
@@ -1314,7 +1151,7 @@
         }
         return result;
     }
-    function initModelNodePosition(model, width, height, dimensions = 2) {
+    function initNodePosition(model, width, height, dimensions = 2) {
         model.forEachNode((node) => {
             if (isNil(node.x)) {
                 node.x = Math.random() * width;
@@ -1327,194 +1164,450 @@
             }
         });
     }
-
-    /**
-     * 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);
+
+    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();
+        }
+    }
+
+    /**
+     * @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;
+            }
+        }
+        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;
+            }
+            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();
+        }
+    }
+    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.nodeMap.clear();
-        nodes.forEach((node) => {
-            model.nodeMap.set(node.id, node);
-        });
-        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.nodeMap.clear();
-        orderedNodes.forEach((node) => {
-            model.nodeMap.set(node.id, node);
-        });
-        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/> 布局基类
@@ -1524,16 +1617,20 @@
     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.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 +1648,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 +1658,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;
@@ -1597,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 布局算法
      *
@@ -5101,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') {
@@ -5118,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;
@@ -5186,6 +5217,7 @@
                     acyclicer: 'greedy',
                     ranker,
                     rankdir,
+                    nodesep,
                     align,
                 });
                 const layoutTopLeft = [0, 0];
@@ -7290,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,
@@ -7525,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);
@@ -7562,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);
@@ -7600,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();
@@ -7639,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);
@@ -7680,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);
@@ -7714,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);
@@ -24213,7 +24207,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 +25299,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 +25803,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 +32407,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 +32414,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 +32743,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,10 +32759,10 @@ ${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;
     exports.orderByDegree = orderByDegree;
     exports.orderById = orderById;