@antv/layout 2.0.0-beta.0 → 2.0.0-beta.2

package/dist/index.js

@@ -4,7 +4,6 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.Layout = {}));
 })(this, (function (exports) { 'use strict';
 
-    var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
     /******************************************************************************
     Copyright (c) Microsoft Corporation.
 
@@ -377,6 +376,156 @@
         }
     }
 
+    const e={abs:Math.abs,ceil:Math.ceil,floor:Math.floor,max:Math.max,min:Math.min,round:Math.round,sqrt:Math.sqrt,pow:Math.pow};class n extends Error{constructor(e,t,n){super(e),this.position=t,this.token=n,this.name="ExpressionError";}}var r;!function(e){e[e.STRING=0]="STRING",e[e.NUMBER=1]="NUMBER",e[e.BOOLEAN=2]="BOOLEAN",e[e.NULL=3]="NULL",e[e.IDENTIFIER=4]="IDENTIFIER",e[e.OPERATOR=5]="OPERATOR",e[e.FUNCTION=6]="FUNCTION",e[e.DOT=7]="DOT",e[e.BRACKET_LEFT=8]="BRACKET_LEFT",e[e.BRACKET_RIGHT=9]="BRACKET_RIGHT",e[e.PAREN_LEFT=10]="PAREN_LEFT",e[e.PAREN_RIGHT=11]="PAREN_RIGHT",e[e.COMMA=12]="COMMA",e[e.QUESTION=13]="QUESTION",e[e.COLON=14]="COLON",e[e.DOLLAR=15]="DOLLAR";}(r||(r={}));const o=new Set([32,9,10,13]),a$2=new Set([43,45,42,47,37,33,38,124,61,60,62]),s=new Map([["true",r.BOOLEAN],["false",r.BOOLEAN],["null",r.NULL]]),i=new Map([["===",true],["!==",true],["<=",true],[">=",true],["&&",true],["||",true],["+",true],["-",true],["*",true],["/",true],["%",true],["!",true],["<",true],[">",true]]),u=new Map([[46,r.DOT],[91,r.BRACKET_LEFT],[93,r.BRACKET_RIGHT],[40,r.PAREN_LEFT],[41,r.PAREN_RIGHT],[44,r.COMMA],[63,r.QUESTION],[58,r.COLON],[36,r.DOLLAR]]),c$2=new Map;for(const[e,t]of u.entries())c$2.set(e,{type:t,value:String.fromCharCode(e)});function p(e){return e>=48&&e<=57}function l(e){return e>=97&&e<=122||e>=65&&e<=90||95===e}function f(e){return l(e)||p(e)}function E(e){return a$2.has(e)}var h;!function(e){e[e.Program=0]="Program",e[e.Literal=1]="Literal",e[e.Identifier=2]="Identifier",e[e.MemberExpression=3]="MemberExpression",e[e.CallExpression=4]="CallExpression",e[e.BinaryExpression=5]="BinaryExpression",e[e.UnaryExpression=6]="UnaryExpression",e[e.ConditionalExpression=7]="ConditionalExpression";}(h||(h={}));const d=new Map([["||",2],["&&",3],["===",4],["!==",4],[">",5],[">=",5],["<",5],["<=",5],["+",6],["-",6],["*",7],["/",7],["%",7],["!",8]]),R={type:h.Literal,value:null},T={type:h.Literal,value:true},w={type:h.Literal,value:false},y$4=e=>{let t=0;const o=e.length,a=()=>t>=o?null:e[t],s=()=>e[t++],i=e=>{const t=a();return null!==t&&t.type===e},u=e=>e.type===r.OPERATOR?d.get(e.value)||-1:e.type===r.DOT||e.type===r.BRACKET_LEFT?9:e.type===r.QUESTION?1:-1,c=e=>{let o,u;if(s().type===r.DOT){if(!i(r.IDENTIFIER)){const e=a();throw new n("Expected property name",t,e?e.value:"<end of input>")}const e=s();o={type:h.Identifier,name:e.value},u=false;}else {if(o=l(0),!i(r.BRACKET_RIGHT)){const e=a();throw new n("Expected closing bracket",t,e?e.value:"<end of input>")}s(),u=true;}return {type:h.MemberExpression,object:e,property:o,computed:u}},p=()=>{const e=a();if(!e)throw new n("Unexpected end of input",t,"<end of input>");if(e.type===r.OPERATOR&&("!"===e.value||"-"===e.value)){s();const t=p();return {type:h.UnaryExpression,operator:e.value,argument:t,prefix:true}}switch(e.type){case r.NUMBER:return s(),{type:h.Literal,value:Number(e.value)};case r.STRING:return s(),{type:h.Literal,value:e.value};case r.BOOLEAN:return s(),"true"===e.value?T:w;case r.NULL:return s(),R;case r.IDENTIFIER:return s(),{type:h.Identifier,name:e.value};case r.FUNCTION:return (()=>{const e=s(),o=[];if(!i(r.PAREN_LEFT)){const e=a();throw new n("Expected opening parenthesis after function name",t,e?e.value:"<end of input>")}for(s();;){if(i(r.PAREN_RIGHT)){s();break}if(!a()){const e=a();throw new n("Expected closing parenthesis",t,e?e.value:"<end of input>")}if(o.length>0){if(!i(r.COMMA)){const e=a();throw new n("Expected comma between function arguments",t,e?e.value:"<end of input>")}s();}const e=l(0);o.push(e);}return {type:h.CallExpression,callee:{type:h.Identifier,name:e.value},arguments:o}})();case r.PAREN_LEFT:{s();const e=l(0);if(!i(r.PAREN_RIGHT)){const e=a();throw new n("Expected closing parenthesis",t,e?e.value:"<end of input>")}return s(),e}default:throw new n(`Unexpected token: ${e.type}`,t,e.value)}},l=(f=0)=>{let E=p();for(;t<o;){const o=e[t],p=u(o);if(p<=f)break;if(o.type!==r.QUESTION)if(o.type!==r.OPERATOR){if(o.type!==r.DOT&&o.type!==r.BRACKET_LEFT)break;E=c(E);}else {s();const e=l(p);E={type:h.BinaryExpression,operator:o.value,left:E,right:e};}else {s();const e=l(0);if(!i(r.COLON)){const e=a();throw new n("Expected : in conditional expression",t,e?e.value:"<end of input>")}s();const o=l(0);E={type:h.ConditionalExpression,test:E,consequent:e,alternate:o};}}return E},f=l();return {type:h.Program,body:f}},O=(e,t,r)=>{let o=t;r&&(o={...t,context:{...t.context,...r}});const a=e=>{switch(e.type){case h.Literal:return (e=>e.value)(e);case h.Identifier:return (e=>{if(!(e.name in o.context))throw new n(`Undefined variable: ${e.name}`);return o.context[e.name]})(e);case h.MemberExpression:return (e=>{const t=a(e.object);if(null==t)throw new n("Cannot access property of null or undefined");return t[e.computed?a(e.property):e.property.name]})(e);case h.CallExpression:return (e=>{const t=o.functions[e.callee.name];if(!t)throw new n(`Undefined function: ${e.callee.name}`);return t(...e.arguments.map((e=>a(e))))})(e);case h.BinaryExpression:return (e=>{if("&&"===e.operator){const t=a(e.left);return t?a(e.right):t}if("||"===e.operator){return a(e.left)||a(e.right)}const t=a(e.left),r=a(e.right);switch(e.operator){case "+":return t+r;case "-":return t-r;case "*":return t*r;case "/":return t/r;case "%":return t%r;case "===":return t===r;case "!==":return t!==r;case ">":return t>r;case ">=":return t>=r;case "<":return t<r;case "<=":return t<=r;default:throw new n(`Unknown operator: ${e.operator}`)}})(e);case h.UnaryExpression:return (e=>{const t=a(e.argument);if(e.prefix)switch(e.operator){case "!":return !t;case "-":if("number"!=typeof t)throw new n(`Cannot apply unary - to non-number: ${t}`);return -t;default:throw new n(`Unknown operator: ${e.operator}`)}throw new n(`Postfix operators are not supported: ${e.operator}`)})(e);case h.ConditionalExpression:return (e=>{const t=a(e.test);return a(t?e.consequent:e.alternate)})(e);default:throw new n(`Evaluation error: Unsupported node type: ${e.type}`)}};return a(e.body)};function A(t){const a=(e=>{const t=e,a=t.length,u=new Array(Math.ceil(a/3));let h=0,d=0;function R(e){const o=d+1;d++;let s="",i=false;for(;d<a;){const n=t.charCodeAt(d);if(n===e)return i||(s=t.substring(o,d)),d++,{type:r.STRING,value:s};92===n?(i||(s=t.substring(o,d),i=true),d++,s+=t[d]):i&&(s+=t[d]),d++;}throw new n(`Unterminated string starting with ${String.fromCharCode(e)}`,d,t.substring(Math.max(0,d-10),d))}function T(){const e=d;for(45===t.charCodeAt(d)&&d++;d<a&&p(t.charCodeAt(d));)d++;if(d<a&&46===t.charCodeAt(d))for(d++;d<a&&p(t.charCodeAt(d));)d++;const n=t.slice(e,d);return {type:r.NUMBER,value:n}}function w(){d++;const e=d;if(d<a&&l(t.charCodeAt(d)))for(d++;d<a&&f(t.charCodeAt(d));)d++;const n=t.slice(e,d);return {type:r.FUNCTION,value:n}}function y(){const e=d++;for(;d<a&&f(t.charCodeAt(d));)d++;const n=t.slice(e,d),o=s.get(n);return o?{type:o,value:n}:{type:r.IDENTIFIER,value:n}}function O(){if(d+2<a){const e=t.substring(d,d+3);if(i.has(e))return d+=3,{type:r.OPERATOR,value:e}}if(d+1<a){const e=t.substring(d,d+2);if(i.has(e))return d+=2,{type:r.OPERATOR,value:e}}const e=t[d];if(i.has(e))return d++,{type:r.OPERATOR,value:e};throw new n(`Unknown operator at position ${d}: ${t.substring(d,d+1)}`,d,t.substring(Math.max(0,d-10),d))}for(;d<a;){const e=t.charCodeAt(d);if(A=e,o.has(A)){d++;continue}const r=c$2.get(e);if(r)u[h++]=r,d++;else if(34!==e&&39!==e)if(p(e)||45===e&&d+1<a&&p(t.charCodeAt(d+1)))u[h++]=T();else if(64!==e)if(l(e))u[h++]=y();else {if(!E(e))throw new n(`Unexpected character: ${t[d]}`,d,t.substring(Math.max(0,d-10),d));u[h++]=O();}else u[h++]=w();else u[h++]=R(e);}var A;return h===u.length?u:u.slice(0,h)})(t),u=y$4(a),h=((e={},t={})=>({context:e,functions:t}))({},e);return (e={})=>O(u,h,e)}function N(e,t={}){return A(e)(t)}
+
+    /**
+     * Evaluate an expression if (and only if) it's a valid string expression.
+     * - Returns `undefined` when `expression` is not a string, empty, or invalid.
+     *
+     * @example
+     * evaluateExpression('x + y', { x: 10, y: 20 }) // 30
+     */
+    function evaluateExpression(expression, context) {
+        if (typeof expression !== 'string')
+            return undefined;
+        const source = expression.trim();
+        if (!source)
+            return undefined;
+        try {
+            A(source);
+            return N(source, context);
+        }
+        catch (_a) {
+            return undefined;
+        }
+    }
+
+    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 isSize(value) {
+        if (isNumber(value))
+            return true;
+        if (Array.isArray(value)) {
+            return value.every((item) => isNumber(item));
+        }
+        return false;
+    }
+
+    /**
+     * Format a value into a callable function when it is a string expression.
+     * - `string` => `(context) => evaluateExpression(string, context)`
+     * - `function` => returned as-is
+     * - other => returned as-is
+     */
+    function formatFn(value, argNames) {
+        if (typeof value === 'function')
+            return value;
+        if (typeof value === 'string') {
+            const expr = value;
+            return (...argv) => {
+                const ctx = {};
+                for (let i = 0; i < argNames.length; i++) {
+                    ctx[argNames[i]] = argv[i];
+                }
+                return evaluateExpression(expr, ctx);
+            };
+        }
+        return () => value;
+    }
+    /**
+     * 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, type = 'node') {
+        // If value is undefined, return default value function
+        if (isNil(value)) {
+            return () => defaultValue;
+        }
+        // If value is an expression, return a function that evaluates the expression
+        if (isString(value)) {
+            const numberFn = formatFn(value, [type]);
+            return (d) => {
+                const evaluated = numberFn(d);
+                if (isNumber(evaluated))
+                    return evaluated;
+                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;
+        }
+        // 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, type = 'node') {
+        // If value is undefined, return default value function
+        if (isNil(value)) {
+            return () => defaultValue;
+        }
+        // If value is an expression, return a function that evaluates the expression
+        if (isString(value)) {
+            const sizeFn = formatFn(value, [type]);
+            return (d) => {
+                const evaluated = sizeFn(d);
+                if (isSize(evaluated))
+                    return evaluated;
+                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;
+        }
+        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
+     * @param defaultNodeSpacing The default node spacing when value is invalid
+     * @returns A function that returns the total size (node size + spacing)
+     */
+    const formatNodeSizeFn = (nodeSize, nodeSpacing, defaultNodeSize = 10, defaultNodeSpacing = 0) => {
+        const nodeSpacingFunc = formatSizeFn(nodeSpacing, defaultNodeSpacing);
+        const nodeSizeFunc = formatSizeFn(nodeSize, defaultNodeSize);
+        return (d) => {
+            const [sizeW, sizeH, sizeD] = parseSize(nodeSizeFunc(d));
+            const [spacingW, spacingH, spacingD] = parseSize(nodeSpacingFunc(d));
+            return [sizeW + spacingW, sizeH + spacingH, sizeD + spacingD];
+        };
+    };
+
     /**
      * Floyd-Warshall algorithm to find shortest paths (but with no negative cycles).
      */
@@ -800,17 +949,6 @@
         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.
      */
@@ -826,71 +964,6 @@
         };
     };
 
-    /**
-     * 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;
-        };
-    };
-
     class GraphLib {
         constructor(data, options = {}) {
             this.edgeIdCounter = new Map();
@@ -1590,23 +1663,37 @@
          * 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 scriptUrl = (() => {
+                if (typeof document === 'undefined')
+                    return null;
+                const currentScript = document.currentScript;
+                if (currentScript === null || currentScript === void 0 ? void 0 : currentScript.src)
+                    return currentScript.src;
                 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 (!src)
+                        continue;
+                    if (src.includes('index.js') || src.includes('index.min.js')) {
+                        return src;
                     }
                 }
+                return null;
+            })();
+            if (scriptUrl) {
+                if (scriptUrl.includes('index.js') || scriptUrl.includes('index.min.js')) {
+                    const asIndex = scriptUrl.replace(/index(\.min)?\.(m?js)(\?.*)?$/, 'worker.js');
+                    if (asIndex !== scriptUrl)
+                        return asIndex;
+                }
+                // e.g. `.../lib/runtime/supervisor.js` -> `.../lib/worker.js`
+                const asRoot = scriptUrl.replace(/\/runtime\/[^/]+\.(m?js)(\?.*)?$/, '/worker.js');
+                if (asRoot !== scriptUrl)
+                    return asRoot;
+                // Fallback: keep legacy behavior (same directory)
+                const asSibling = scriptUrl.replace(/\/[^/]+\.(m?js)(\?.*)?$/, '/worker.js');
+                if (asSibling !== scriptUrl)
+                    return asSibling;
             }
             return './worker.js';
         }
@@ -5108,6 +5195,7 @@
 
     const DEFAULTS_LAYOUT_OPTIONS$8 = {
         nodeSize: 10,
+        nodeSpacing: 0,
         rankdir: 'TB',
         nodesep: 50,
         ranksep: 50,
@@ -5132,27 +5220,27 @@
         }
         layout(options) {
             return __awaiter(this, void 0, void 0, function* () {
-                const { nodeSize, align, rankdir = 'TB', ranksep, nodesep, edgeLabelSpace, ranker = 'tight-tree', nodeOrder, begin, controlPoints, radial, sortByCombo, 
+                const { nodeSize, nodeSpacing, align, rankdir = 'TB', ranksep, nodesep, edgeLabelSpace, ranker = 'tight-tree', nodeOrder, begin, controlPoints, radial, sortByCombo, 
                 // focusNode,
                 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);
+                const ranksepfunc = formatNumberFn(ranksepFunc, ranksep !== null && ranksep !== void 0 ? ranksep : 50, 'node');
+                const nodesepfunc = formatNumberFn(nodesepFunc, nodesep !== null && nodesep !== void 0 ? nodesep : 50, 'node');
                 let horisep = nodesepfunc;
                 let vertisep = ranksepfunc;
                 if (rankdir === 'LR' || rankdir === 'RL') {
                     horisep = ranksepfunc;
                     vertisep = nodesepfunc;
                 }
-                const nodeSizeFunc = formatSizeFn(nodeSize, DEFAULTS_LAYOUT_OPTIONS$8.nodeSize);
                 // Create internal graph
                 const g = new DagreGraph({ tree: [] });
                 // copy graph to g
                 const nodes = this.model.nodes();
                 const edges = this.model.edges();
+                const sizeFn = formatNodeSizeFn(nodeSize, nodeSpacing, DEFAULTS_LAYOUT_OPTIONS$8.nodeSize, DEFAULTS_LAYOUT_OPTIONS$8.nodeSpacing);
                 nodes.forEach((node) => {
                     var _a;
                     const raw = node._original;
-                    const size = parseSize(nodeSizeFunc(raw));
+                    const size = sizeFn(raw);
                     const verti = vertisep(raw);
                     const hori = horisep(raw);
                     const width = size[0] + 2 * hori;
@@ -5434,7 +5522,7 @@
         return controlPoints;
     };
 
-    const DEFAULT_LAYOUT_OPTIONS = {
+    const DEFAULT_LAYOUT_OPTIONS$1 = {
         radius: null,
         startRadius: null,
         endRadius: null,
@@ -5445,6 +5533,7 @@
         ordering: null,
         angleRatio: 1,
         nodeSize: 10,
+        nodeSpacing: 0,
     };
     /**
      * <zh/> 环形布局
@@ -5457,7 +5546,7 @@
             this.id = 'circular';
         }
         getDefaultOptions() {
-            return DEFAULT_LAYOUT_OPTIONS;
+            return DEFAULT_LAYOUT_OPTIONS$1;
         }
         layout() {
             return __awaiter(this, void 0, void 0, function* () {
@@ -5483,11 +5572,11 @@
                 }
                 let { radius, startRadius, endRadius } = this.options;
                 const nodes = this.model.nodes();
-                const format = formatNodeSizeFn(nodeSize, nodeSpacing, DEFAULT_LAYOUT_OPTIONS.nodeSize);
-                if (!isNil(nodeSpacing)) {
+                const sizeFn = formatNodeSizeFn(nodeSize, nodeSpacing, DEFAULT_LAYOUT_OPTIONS$1.nodeSize, DEFAULT_LAYOUT_OPTIONS$1.nodeSpacing);
+                if (nodeSpacing) {
                     let perimeter = 0;
                     for (const node of nodes) {
-                        perimeter += format(node._original);
+                        perimeter += Math.max(...sizeFn(node._original));
                     }
                     radius = perimeter / (2 * Math.PI);
                 }
@@ -5564,17 +5653,10 @@
                     applySingleNodeLayout(this.model, center);
                     return;
                 }
-                const { sortBy: propsSortBy, maxLevelDiff: propsMaxLevelDiff, sweep: propsSweep, clockwise, equidistant, preventOverlap, startAngle = DEFAULTS_LAYOUT_OPTIONS$7.startAngle, nodeSize = DEFAULTS_LAYOUT_OPTIONS$7.nodeSize, nodeSpacing, } = this.options;
-                let sortBy = propsSortBy;
-                if (propsSortBy && typeof propsSortBy === 'function') {
-                    const testNode = this.model.firstNode();
-                    const testValue = propsSortBy(testNode._original);
-                    if (typeof testValue !== 'number')
-                        sortBy = 'degree';
-                }
-                else {
-                    sortBy = 'degree';
-                }
+                const { sortBy: propsSortBy, maxLevelDiff: propsMaxLevelDiff, sweep: propsSweep, clockwise, equidistant, preventOverlap, startAngle = DEFAULTS_LAYOUT_OPTIONS$7.startAngle, nodeSize, nodeSpacing, } = this.options;
+                const sortBy = !propsSortBy || propsSortBy === 'degree'
+                    ? 'degree'
+                    : formatFn(propsSortBy, ['node']);
                 if (sortBy === 'degree') {
                     orderByDegree(this.model);
                 }
@@ -5591,15 +5673,15 @@
                 for (const node of nodes) {
                     const v = sortBy === 'degree'
                         ? this.model.degree(node.id)
-                        : sortBy === null || sortBy === void 0 ? void 0 : sortBy(node._original);
+                        : sortBy(node._original);
                     sortKeys.set(node.id, v);
                 }
                 const maxValueNode = this.model.firstNode();
                 const maxLevelDiff = propsMaxLevelDiff || sortKeys.get(maxValueNode.id) / 4;
-                const nodeSizeFn = formatNodeSizeFn(nodeSize, nodeSpacing);
+                const sizeFn = formatNodeSizeFn(nodeSize, nodeSpacing, DEFAULTS_LAYOUT_OPTIONS$7.nodeSize, DEFAULTS_LAYOUT_OPTIONS$7.nodeSpacing);
                 const nodeDistances = new Map();
                 for (const node of nodes) {
-                    nodeDistances.set(node.id, nodeSizeFn(node._original));
+                    nodeDistances.set(node.id, Math.max(...sizeFn(node._original)));
                 }
                 // put the values into levels
                 const levels = [{ nodes: [] }];
@@ -7325,9 +7407,7 @@
     }
 
     const DEFAULTS_LAYOUT_OPTIONS$6 = {
-        link: {
-            id: (d) => String(d.id),
-        },
+        edgeId: 'edge.id',
         manyBody: {
             strength: -30,
         },
@@ -7582,7 +7662,9 @@
             if (options.manyBody === false)
                 return undefined;
             return assignDefined({}, options.manyBody || {}, {
-                strength: options.nodeStrength,
+                strength: options.nodeStrength
+                    ? formatFn(options.nodeStrength, ['node'])
+                    : undefined,
                 distanceMin: options.distanceMin,
                 distanceMax: options.distanceMax,
                 theta: options.theta,
@@ -7615,9 +7697,13 @@
             if (options.link === false)
                 return undefined;
             return assignDefined({}, options.link || {}, {
-                id: options.edgeId,
-                distance: options.linkDistance,
-                strength: options.edgeStrength,
+                id: options.edgeId ? formatFn(options.edgeId, ['edge']) : undefined,
+                distance: options.linkDistance
+                    ? formatFn(options.linkDistance, ['edge'])
+                    : undefined,
+                strength: options.edgeStrength
+                    ? formatFn(options.edgeStrength, ['edge'])
+                    : undefined,
                 iterations: options.edgeIterations,
             });
         }
@@ -7649,9 +7735,8 @@
             if (options.preventOverlap === false &&
                 (options.collide === false || options.collide === undefined))
                 return undefined;
-            const radius = options.nodeSize || options.nodeSpacing
-                ? (d) => formatNodeSizeFn(options.nodeSize, options.nodeSpacing)(d._original) / 2
-                : undefined;
+            const sizeFn = formatNodeSizeFn(options.nodeSize, options.nodeSpacing, DEFAULTS_LAYOUT_OPTIONS$6.nodeSize, DEFAULTS_LAYOUT_OPTIONS$6.nodeSpacing);
+            const radius = (d) => Math.max(...sizeFn(d._original)) / 2;
             return assignDefined({}, options.collide || {}, {
                 radius: (options.collide && options.collide.radius) || radius,
                 strength: options.collideStrength,
@@ -7792,7 +7877,7 @@
                     ['centerY', center && center.y],
                     ['template', 'force'],
                     ['strength', clusterFociStrength],
-                    ['groupBy', clusterBy],
+                    ['groupBy', clusterBy ? formatFn(clusterBy, ['node']) : undefined],
                     ['nodes', this.model.nodes()],
                     ['links', this.model.edges()],
                     ['forceLinkDistance', clusterEdgeDistance],
@@ -9524,7 +9609,7 @@
             return {
                 numDimensions: 3,
                 link: {
-                    id: (edge) => String(edge.id),
+                    id: (edge) => edge.id,
                 },
                 manyBody: {},
                 center: {
@@ -23305,11 +23390,13 @@
                     }
                 });
                 const { edgeLabelSize, edgeLabelOffset, edgeLabelPos, edgeMinLen, edgeWeight, } = this.options;
-                const edgeLabelSizeFn = formatSizeFn(edgeLabelSize, 0);
-                const edgeLabelOffsetFn = formatNumberFn(edgeLabelOffset, 10);
-                const edgeLabelPosFn = typeof edgeLabelPos === 'function' ? edgeLabelPos : () => edgeLabelPos;
-                const edgeMinLenFn = formatNumberFn(edgeMinLen, 1);
-                const edgeWeightFn = formatNumberFn(edgeWeight, 1);
+                const edgeLabelSizeFn = formatSizeFn(edgeLabelSize, 0, 'edge');
+                const edgeLabelOffsetFn = formatNumberFn(edgeLabelOffset, 10, 'edge');
+                const edgeLabelPosFn = typeof edgeLabelPos === 'string'
+                    ? () => edgeLabelPos
+                    : formatFn(edgeLabelPos, ['edge']);
+                const edgeMinLenFn = formatNumberFn(edgeMinLen, 1, 'edge');
+                const edgeWeightFn = formatNumberFn(edgeWeight, 1, 'edge');
                 this.model.forEachEdge((edge) => {
                     const raw = edge._original;
                     const [lw, lh] = parseSize(edgeLabelSizeFn(raw));
@@ -24359,28 +24446,43 @@
          */
         parseOptions(options) {
             const _ = Object.assign(Object.assign({}, options), normalizeViewport(options));
+            // Format nodeClusterBy (for clustering / leafCluster)
+            if (_.nodeClusterBy) {
+                _.nodeClusterBy = formatFn(_.nodeClusterBy, ['node']);
+            }
             // Format node mass
             if (!options.getMass) {
-                _.getMass = (d) => {
-                    if (!d)
+                _.getMass = (node) => {
+                    if (!node)
                         return 1;
                     const massWeight = 1;
-                    const degree = this.model.degree(d.id, 'both');
+                    const degree = this.model.degree(node.id, 'both');
                     return !degree || degree < 5 ? massWeight : degree * 5 * massWeight;
                 };
             }
+            else {
+                _.getMass = formatNumberFn(options.getMass, 1);
+            }
+            // Format per-node center force callback
+            if (options.getCenter) {
+                const params = ['node', 'degree'];
+                _.getCenter = formatFn(options.getCenter, params);
+            }
             // Format node size
-            _.nodeSize = formatNodeSizeFn(options.nodeSize, options.nodeSpacing);
+            const nodeSizeVec = formatNodeSizeFn(options.nodeSize, options.nodeSpacing);
+            _.nodeSize = (node) => {
+                if (!node)
+                    return 0;
+                const [w, h, z] = nodeSizeVec(node);
+                return Math.max(w, h, z);
+            };
             // Format node / edge strengths
             _.linkDistance = options.linkDistance
-                ? formatNumberFn(options.linkDistance, 1)
-                : (edge) => {
-                    return (1 +
-                        _.nodeSize(this.model.node(edge.source)._original) +
-                        _.nodeSize(this.model.node(edge.target)._original));
-                };
+                ? formatFn(options.linkDistance, ['edge', 'source', 'target'])
+                : (_, source, target) => 1 + _.nodeSize(source) + _.nodeSize(target);
             _.nodeStrength = formatNumberFn(options.nodeStrength, 1);
-            _.edgeStrength = formatNumberFn(options.edgeStrength, 1);
+            _.edgeStrength = formatNumberFn(options.edgeStrength, 1, 'edge');
+            _.clusterNodeStrength = formatNumberFn(options.clusterNodeStrength, 1);
             // Format centripetal options
             this.formatCentripetal(_);
             return _;
@@ -24389,23 +24491,30 @@
          * Format centripetal options
          */
         formatCentripetal(options) {
-            var _a;
-            const { dimensions, centripetalOptions, center, clusterNodeStrength, leafCluster, clustering, nodeClusterBy, } = options;
-            // Basic centripetal settings
-            const basicCentripetal = centripetalOptions || {
-                leaf: 2,
-                single: 2,
-                others: 1,
-                center: (_) => {
-                    return {
-                        x: center[0],
-                        y: center[1],
-                        z: dimensions === 3 ? center[2] : undefined,
-                    };
-                },
-            };
-            if (typeof clusterNodeStrength !== 'function') {
-                options.clusterNodeStrength = () => clusterNodeStrength;
+            var _a, _b;
+            const { dimensions, centripetalOptions, center, leafCluster, clustering, nodeClusterBy, } = options;
+            const leafParams = ['node', 'nodes', 'edges'];
+            const leafFn = formatFn(centripetalOptions === null || centripetalOptions === void 0 ? void 0 : centripetalOptions.leaf, leafParams);
+            const singleFn = formatNumberFn(centripetalOptions === null || centripetalOptions === void 0 ? void 0 : centripetalOptions.single, 2);
+            const othersFn = formatNumberFn(centripetalOptions === null || centripetalOptions === void 0 ? void 0 : centripetalOptions.others, 1);
+            const centerRaw = (_a = centripetalOptions === null || centripetalOptions === void 0 ? void 0 : centripetalOptions.center) !== null && _a !== void 0 ? _a : ((_) => {
+                return {
+                    x: center[0],
+                    y: center[1],
+                    z: dimensions === 3 ? center[2] : undefined,
+                };
+            });
+            const centerFn = formatFn(centerRaw, [
+                'node',
+                'nodes',
+                'edges',
+                'width',
+                'height',
+            ]);
+            const basicCentripetal = Object.assign(Object.assign({}, centripetalOptions), { leaf: leafFn, single: singleFn, others: othersFn, center: centerFn });
+            // If user provided centripetalOptions, normalize them even without clustering modes.
+            if (centripetalOptions) {
+                options.centripetalOptions = basicCentripetal;
             }
             let sameTypeLeafMap;
             let clusters;
@@ -24413,8 +24522,8 @@
             if (leafCluster && nodeClusterBy) {
                 sameTypeLeafMap = this.getSameTypeLeafMap(nodeClusterBy);
                 clusters =
-                    Array.from(new Set((_a = this.model
-                        .nodes()) === null || _a === void 0 ? void 0 : _a.map((node) => nodeClusterBy(node._original)))) || [];
+                    Array.from(new Set((_b = this.model
+                        .nodes()) === null || _b === void 0 ? void 0 : _b.map((node) => nodeClusterBy(node._original)))) || [];
                 options.centripetalOptions = Object.assign({}, basicCentripetal, {
                     single: () => 100,
                     leaf: (node) => {
@@ -24487,17 +24596,6 @@
                     },
                 });
             }
-            // Normalize functions
-            const { leaf, single, others } = options.centripetalOptions || {};
-            if (leaf && typeof leaf !== 'function') {
-                options.centripetalOptions.leaf = () => leaf;
-            }
-            if (single && typeof single !== 'function') {
-                options.centripetalOptions.single = () => single;
-            }
-            if (others && typeof others !== 'function') {
-                options.centripetalOptions.others = () => others;
-            }
         }
         /**
          * Get same type leaf map for clustering
@@ -25333,9 +25431,9 @@
         }
         getSizes(nodeSize, nodeSpacing) {
             const result = {};
+            const nodeSizeFn = formatNodeSizeFn(nodeSize, nodeSpacing, DEFAULTS_LAYOUT_OPTIONS$4.nodeSize, DEFAULTS_LAYOUT_OPTIONS$4.nodeSpacing);
             this.model.forEachNode((node) => {
-                const nodeSizeFn = formatNodeSizeFn(nodeSize, nodeSpacing);
-                result[node.id] = nodeSizeFn(node._original);
+                result[node.id] = Math.max(...nodeSizeFn(node._original));
             });
             return result;
         }
@@ -25347,7 +25445,7 @@
             return this.simulation;
         }
         parseOptions(options = {}) {
-            const { barnesHut, prune, maxIteration, kr, kg, nodeSize, nodeSpacing } = options;
+            const { barnesHut, prune, maxIteration, kr, kg } = options;
             const auto = {};
             const n = this.model.nodeCount();
             if (barnesHut === undefined && n > 250)
@@ -25382,7 +25480,7 @@
                 else if (n > 500)
                     auto.kg = 1;
             }
-            return Object.assign(Object.assign(Object.assign(Object.assign({}, options), auto), normalizeViewport(options)), { nodeSize: formatSizeFn(nodeSize, DEFAULTS_LAYOUT_OPTIONS$4.nodeSize), nodeSpacing: formatNumberFn(nodeSpacing, DEFAULTS_LAYOUT_OPTIONS$4.nodeSpacing) });
+            return Object.assign(Object.assign(Object.assign({}, options), auto), normalizeViewport(options));
         }
         stop() {
             var _a;
@@ -25767,7 +25865,7 @@
         clusterGravity: 10,
         width: 300,
         height: 300,
-        nodeClusterBy: 'data.cluster',
+        nodeClusterBy: 'node.cluster',
         dimensions: 2,
     };
     class FruchtermanLayout extends BaseLayoutWithIterations {
@@ -25779,15 +25877,12 @@
         getDefaultOptions() {
             return DEFAULTS_LAYOUT_OPTIONS$3;
         }
-        parseOptions(options) {
+        parseOptions(options = {}) {
             const { clustering, nodeClusterBy } = this.options;
             const clusteringEnabled = clustering && !!nodeClusterBy;
-            const nodeClusterByFunc = typeof nodeClusterBy === 'string'
-                ? (node) => getNestedValue(node, nodeClusterBy)
-                : nodeClusterBy;
-            Object.assign((options || (options = {})), normalizeViewport(options), {
+            Object.assign(options, normalizeViewport(options), {
                 clustering: clusteringEnabled,
-                nodeClusterBy: nodeClusterByFunc,
+                nodeClusterBy: formatFn(nodeClusterBy, ['node']),
             });
             return options;
         }
@@ -25842,6 +25937,19 @@
         }
     }
 
+    const DEFAULT_LAYOUT_OPTIONS = {
+        begin: [0, 0],
+        preventOverlap: true,
+        condense: false,
+        rows: undefined,
+        cols: undefined,
+        position: undefined,
+        sortBy: 'degree',
+        nodeSize: 30,
+        nodeSpacing: 10,
+        width: 300,
+        height: 300,
+    };
     /**
      * <zh/> 网格布局
      *
@@ -25853,23 +25961,10 @@
             this.id = 'grid';
         }
         getDefaultOptions() {
-            return {
-                begin: [0, 0],
-                preventOverlap: true,
-                preventOverlapPadding: 10,
-                condense: false,
-                rows: undefined,
-                cols: undefined,
-                position: undefined,
-                sortBy: 'degree',
-                nodeSize: 30,
-                width: 300,
-                height: 300,
-            };
+            return DEFAULT_LAYOUT_OPTIONS;
         }
-        normalizeOptions(options = {}, model) {
-            var _a;
-            const { rows: propRows, cols: propCols } = options;
+        parseOptions(options = {}, model) {
+            const { rows: propRows, cols: propCols, position: propPosition, sortBy: propSortBy, } = options;
             const { width, height, center } = normalizeViewport(options);
             let rows = options.rows;
             let cols = options.cols;
@@ -25924,20 +26019,20 @@
                     }
                 }
             }
-            const preventOverlap = options.preventOverlap || options.nodeSpacing !== undefined;
-            const nodeSpacing = formatNumberFn(options.nodeSpacing, 10);
-            const nodeSize = formatSizeFn(options.nodeSize, 30);
-            return Object.assign(Object.assign({}, options), { begin: options.begin || [0, 0], sortBy: options.sortBy || 'degree', preventOverlapPadding: (_a = options.preventOverlapPadding) !== null && _a !== void 0 ? _a : 0, preventOverlap,
-                nodeSpacing,
-                nodeSize,
+            const sortBy = !propSortBy
+                ? DEFAULT_LAYOUT_OPTIONS.sortBy
+                : propSortBy === 'degree' || propSortBy === 'id'
+                    ? propSortBy
+                    : formatFn(propSortBy, ['nodeA', 'nodeB']);
+            return Object.assign(Object.assign({}, options), { sortBy,
                 rcs,
                 center,
                 width,
-                height });
+                height, position: formatFn(propPosition, ['node']) });
         }
         layout() {
             return __awaiter(this, void 0, void 0, function* () {
-                const { begin, rcs, sortBy, width, height, condense, preventOverlapPadding, preventOverlap, nodeSpacing, nodeSize, position, } = this.normalizeOptions(this.options, this.model);
+                const { begin, rcs, sortBy, width, height, condense, preventOverlap, nodeSpacing, nodeSize, position, } = this.parseOptions(this.options, this.model);
                 const n = this.model.nodeCount();
                 if (!n || n === 1) {
                     applySingleNodeLayout(this.model, begin);
@@ -25955,14 +26050,9 @@
                 let cellWidth = condense ? 0 : width / rcs.cols;
                 let cellHeight = condense ? 0 : height / rcs.rows;
                 if (preventOverlap) {
+                    const sizeFn = formatNodeSizeFn(nodeSize, nodeSpacing, DEFAULT_LAYOUT_OPTIONS.nodeSize, DEFAULT_LAYOUT_OPTIONS.nodeSpacing);
                     this.model.forEachNode((node) => {
-                        const nodeData = node._original;
-                        const [nodeW, nodeH] = parseSize(nodeSize(nodeData) || 30);
-                        const p = nodeSpacing !== undefined
-                            ? nodeSpacing(nodeData)
-                            : preventOverlapPadding;
-                        const w = nodeW + p;
-                        const h = nodeH + p;
+                        const [w, h] = sizeFn(node._original);
                         cellWidth = Math.max(cellWidth, w);
                         cellHeight = Math.max(cellHeight, h);
                     });
@@ -32045,8 +32135,8 @@ ${indent}columns: ${matrix.columns}
                     vecx = 0.01 * sign;
                     vecy = 0.01 * sign;
                 }
-                const nodeSizeU = Math.max(...parseSize(nodeSizeFunc(nodeU._original)));
-                const nodeSizeV = Math.max(...parseSize(nodeSizeFunc(nodeV._original)));
+                const nodeSizeU = Math.max(...nodeSizeFunc(nodeU._original));
+                const nodeSizeV = Math.max(...nodeSizeFunc(nodeV._original));
                 // these two nodes overlap
                 if (vecLength < nodeSizeV / 2 + nodeSizeU / 2) {
                     const common = (k * k) / vecLength;
@@ -32129,6 +32219,8 @@ ${indent}columns: ${matrix.columns}
         sortStrength: 10,
         strictRadial: true,
         unitRadius: null,
+        nodeSize: 10,
+        nodeSpacing: 0,
     };
     /**
      * <zh/> 径向布局
@@ -32197,7 +32289,7 @@ ${indent}columns: ${matrix.columns}
                 });
                 // stagger the overlapped nodes
                 if (preventOverlap) {
-                    const nodeSizeFunc = formatNodeSizeFn(nodeSize, nodeSpacing);
+                    const nodeSizeFunc = formatNodeSizeFn(nodeSize, nodeSpacing, DEFAULTS_LAYOUT_OPTIONS.nodeSize, DEFAULTS_LAYOUT_OPTIONS.nodeSpacing);
                     const nonoverlapForceParams = {
                         nodeSizeFunc,
                         radiiMap,
@@ -32276,7 +32368,7 @@ ${indent}columns: ${matrix.columns}
             radiusScale[i] = radii[i] / unitRadius;
         const baseLink = (linkDistance + unitRadius) / 2;
         const sortCache = new Map();
-        const sortFn = typeof sortBy === 'function' ? sortBy : null;
+        const sortFn = !sortBy || sortBy === 'data' ? null : formatFn(sortBy, ['node']);
         const isDataSort = sortBy === 'data';
         for (let i = 0; i < n; i++) {
             const row = distances[i];
@@ -32573,7 +32665,9 @@ ${indent}columns: ${matrix.columns}
             });
         }
         getLayoutConfig(combo) {
-            const { layout } = this.options;
+            const layout = typeof this.options.layout === 'object'
+                ? this.options.layout
+                : formatFn(this.options.layout, ['comboId']);
             if (typeof layout === 'function') {
                 const comboId = combo.id === ROOT_ID ? null : combo.id;
                 return this.normalizeLayoutConfig(layout(comboId));
@@ -32581,7 +32675,7 @@ ${indent}columns: ${matrix.columns}
             return this.normalizeLayoutConfig(layout);
         }
         normalizeLayoutConfig(config) {
-            const base = Object.assign(Object.assign({ type: 'concentric' }, normalizeViewport(this.options)), { nodeSize: (d) => d.size, nodeSpacing: 0 });
+            const base = Object.assign(Object.assign({ type: 'concentric' }, normalizeViewport(this.options)), { nodeSize: 'node.size', nodeSpacing: 0 });
             if (!config)
                 return base;
             if (typeof config === 'string')
@@ -32668,7 +32762,7 @@ ${indent}columns: ${matrix.columns}
             if (!Number.isFinite(minX) || !Number.isFinite(minY)) {
                 return { center: [0, 0], width: 0, height: 0 };
             }
-            const comboPaddingFn = formatNumberFn(this.options.comboPadding, 20);
+            const comboPaddingFn = formatNumberFn(this.options.comboPadding, 20, 'combo');
             const padding = comboPaddingFn(combo._original);
             return {
                 center: [(minX + maxX) / 2, (minY + maxY) / 2],
@@ -32684,10 +32778,10 @@ ${indent}columns: ${matrix.columns}
         getNodeSize(node, includeSpacing = true) {
             const { nodeSize, nodeSpacing } = this.options;
             const sizeFn = formatNodeSizeFn(nodeSize, includeSpacing ? nodeSpacing : 0);
-            return parseSize(sizeFn(node._original));
+            return sizeFn(node._original);
         }
         getComboSize(combo, includeSpacing = true) {
-            const comboSpacingFn = formatNumberFn(this.options.comboSpacing, 0);
+            const comboSpacingFn = formatNumberFn(this.options.comboSpacing, 0, 'combo');
             const spacing = includeSpacing ? comboSpacingFn(combo._original) : 0;
             const [width, height] = combo.size;
             return [width + spacing / 2, height + spacing / 2, 0];
@@ -32749,7 +32843,12 @@ ${indent}columns: ${matrix.columns}
     exports.Supervisor = Supervisor;
     exports.applySingleNodeLayout = applySingleNodeLayout;
     exports.assignDefined = assignDefined;
+    exports.evaluateExpression = evaluateExpression;
     exports.floydWarshall = floydWarshall;
+    exports.formatFn = formatFn;
+    exports.formatNodeSizeFn = formatNodeSizeFn;
+    exports.formatNumberFn = formatNumberFn;
+    exports.formatSizeFn = formatSizeFn;
     exports.getAdjList = getAdjList;
     exports.getAdjMatrix = getAdjMatrix;
     exports.getEuclideanDistance = getEuclideanDistance;
@@ -32759,6 +32858,7 @@ ${indent}columns: ${matrix.columns}
     exports.initNodePosition = initNodePosition;
     exports.isArray = isArray;
     exports.isLayoutWithIterations = isLayoutWithIterations;
+    exports.isSize = isSize;
     exports.johnson = johnson;
     exports.normalizeViewport = normalizeViewport;
     exports.orderByDegree = orderByDegree;