@hkyhy/marsun-components-core 0.1.113 → 0.1.115

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/nesting-graph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nesting-graph.js","sources":["../../../../../../../node_modules/@antv/layout/lib/algorithm/antv-dagre/nesting-graph.js"],"sourcesContent":["import { addDummyNode, addBorderNode } from './util.js';\n\n/*\n * A nesting graph creates dummy nodes for the tops and bottoms of subgraphs,\n * adds appropriate edges to ensure that all cluster nodes are placed between\n * these boundries, and ensures that the graph is connected.\n *\n * In addition we ensure, through the use of the minlen property, that nodes\n * and subgraph border nodes to not end up on the same rank.\n *\n * Preconditions:\n *\n *    1. Input graph is a DAG\n *    2. Nodes in the input graph has a minlen attribute\n *\n * Postconditions:\n *\n *    1. Input graph is connected.\n *    2. Dummy nodes are added for the tops and bottoms of subgraphs.\n *    3. The minlen attribute for nodes is adjusted to ensure nodes do not\n *       get placed on the same rank as subgraph border nodes.\n *\n * The nesting graph idea comes from Sander, \"Layout of Compound Directed\n * Graphs.\"\n */\nconst run$1 = (g) => {\n    const root = addDummyNode(g, 'root', {}, '_root');\n    const depths = treeDepths(g);\n    let maxDepth = Math.max(...Object.values(depths));\n    if (Math.abs(maxDepth) === Infinity) {\n        maxDepth = 1;\n    }\n    const height = maxDepth - 1; // Note: depths is an Object not an array\n    const nodeSep = 2 * height + 1;\n    // g.graph().nestingRoot = root;\n    // Multiply minlen by nodeSep to align nodes on non-border ranks.\n    g.getAllEdges().forEach((e) => {\n        e.data.minlen *= nodeSep;\n    });\n    // Calculate a weight that is sufficient to keep subgraphs vertically compact\n    const weight = sumWeights(g) + 1;\n    // Create border nodes and link them up\n    // g.children()?.forEach((child) => {\n    //   dfs(g, root, nodeSep, weight, height, depths, child);\n    // });\n    g.getRoots().forEach((child) => {\n        dfs(g, root, nodeSep, weight, height, depths, child.id);\n    });\n    // Save the multiplier for node layers for later removal of empty border\n    // layers.\n    // g.graph().nodeRankFactor = nodeSep;\n    return {\n        nestingRoot: root,\n        nodeRankFactor: nodeSep,\n    };\n};\nconst dfs = (g, root, nodeSep, weight, height, depths, v) => {\n    const children = g.getChildren(v);\n    if (!(children === null || children === void 0 ? void 0 : children.length)) {\n        if (v !== root) {\n            // g.setEdge(root, v, { weight: 0, minlen: nodeSep });\n            g.addEdge({\n                id: `e${Math.random()}`,\n                source: root,\n                target: v,\n                data: { weight: 0, minlen: nodeSep },\n            });\n        }\n        return;\n    }\n    const top = addBorderNode(g, '_bt');\n    const bottom = addBorderNode(g, '_bb');\n    const label = g.getNode(v);\n    g.setParent(top, v);\n    label.data.borderTop = top;\n    g.setParent(bottom, v);\n    label.data.borderBottom = bottom;\n    children === null || children === void 0 ? void 0 : children.forEach((childNode) => {\n        dfs(g, root, nodeSep, weight, height, depths, childNode.id);\n        const childTop = childNode.data.borderTop\n            ? childNode.data.borderTop\n            : childNode.id;\n        const childBottom = childNode.data.borderBottom\n            ? childNode.data.borderBottom\n            : childNode.id;\n        const thisWeight = childNode.data.borderTop ? weight : 2 * weight;\n        const minlen = childTop !== childBottom ? 1 : height - depths[v] + 1;\n        g.addEdge({\n            id: `e${Math.random()}`,\n            source: top,\n            target: childTop,\n            data: {\n                minlen,\n                weight: thisWeight,\n                nestingEdge: true,\n            },\n        });\n        g.addEdge({\n            id: `e${Math.random()}`,\n            source: childBottom,\n            target: bottom,\n            data: {\n                minlen,\n                weight: thisWeight,\n                nestingEdge: true,\n            },\n        });\n    });\n    if (!g.getParent(v)) {\n        g.addEdge({\n            id: `e${Math.random()}`,\n            source: root,\n            target: top,\n            data: {\n                weight: 0,\n                minlen: height + depths[v],\n            },\n        });\n    }\n};\nconst treeDepths = (g) => {\n    const depths = {};\n    const dfs = (v, depth) => {\n        const children = g.getChildren(v);\n        children === null || children === void 0 ? void 0 : children.forEach((child) => dfs(child.id, depth + 1));\n        depths[v] = depth;\n    };\n    // g.children()?.forEach((v) => dfs(v, 1));\n    g.getRoots().forEach((v) => dfs(v.id, 1));\n    return depths;\n};\nconst sumWeights = (g) => {\n    let result = 0;\n    g.getAllEdges().forEach((e) => {\n        result += e.data.weight;\n    });\n    return result;\n};\nconst cleanup = (g, nestingRoot) => {\n    // const graphLabel = g.graph();\n    // graphLabel.nestingRoot && g.removeNode(graphLabel.nestingRoot);\n    // delete graphLabel.nestingRoot;\n    if (nestingRoot) {\n        g.removeNode(nestingRoot);\n    }\n    g.getAllEdges().forEach((e) => {\n        if (e.data.nestingEdge) {\n            g.removeEdge(e.id);\n        }\n    });\n};\n\nexport { cleanup, run$1 as run };\n//# sourceMappingURL=nesting-graph.js.map\n"],"names":["run$1","g","root","addDummyNode","depths","treeDepths","maxDepth","height","nodeSep","e","weight","sumWeights","child","dfs","v","children","top","addBorderNode","bottom","label","childNode","childTop","childBottom","thisWeight","minlen","depth","result","cleanup","nestingRoot"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/normalize.js

@@ -0,0 +1,47 @@
+import { addDummyNode as c } from "./util.js";
+const E = "edge", g = "edge-label", w = (a, t) => {
+  a.getAllEdges().forEach((i) => m(a, i, t));
+}, m = (a, t, i) => {
+  let d = t.source, o = a.getNode(d).data.rank;
+  const e = t.target, h = a.getNode(e).data.rank, n = t.data.labelRank;
+  if (h === o + 1)
+    return;
+  a.removeEdge(t.id);
+  let l, r, s;
+  for (s = 0, ++o; o < h; ++s, ++o)
+    t.data.points = [], r = {
+      originalEdge: t,
+      width: 0,
+      height: 0,
+      rank: o
+    }, l = c(a, E, r, "_d"), o === n && (r.width = t.data.width, r.height = t.data.height, r.dummy = g, r.labelpos = t.data.labelpos), a.addEdge({
+      id: `e${Math.random()}`,
+      source: d,
+      target: l,
+      data: { weight: t.data.weight }
+    }), s === 0 && i.push(l), d = l;
+  a.addEdge({
+    id: `e${Math.random()}`,
+    source: d,
+    target: e,
+    data: { weight: t.data.weight }
+  });
+}, f = (a, t) => {
+  t.forEach((i) => {
+    let d = a.getNode(i);
+    const { data: o } = d, e = o.originalEdge;
+    let h;
+    e && a.addEdge(e);
+    let n = i;
+    for (; d.data.dummy; )
+      h = a.getSuccessors(n)[0], a.removeNode(n), e.data.points.push({
+        x: d.data.x,
+        y: d.data.y
+      }), d.data.dummy === g && (e.data.x = d.data.x, e.data.y = d.data.y, e.data.width = d.data.width, e.data.height = d.data.height), n = h.id, d = a.getNode(n);
+  });
+};
+export {
+  w as run,
+  f as undo
+};
+//# sourceMappingURL=normalize.js.map

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/normalize.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"normalize.js","sources":["../../../../../../../node_modules/@antv/layout/lib/algorithm/antv-dagre/normalize.js"],"sourcesContent":["import { addDummyNode } from './util.js';\n\n/*\n * Breaks any long edges in the graph into short segments that span 1 layer\n * each. This operation is undoable with the denormalize function.\n *\n * Pre-conditions:\n *\n *    1. The input graph is a DAG.\n *    2. Each node in the graph has a \"rank\" property.\n *\n * Post-condition:\n *\n *    1. All edges in the graph have a length of 1.\n *    2. Dummy nodes are added where edges have been split into segments.\n *    3. The graph is augmented with a \"dummyChains\" attribute which contains\n *       the first dummy in each chain of dummy nodes produced.\n */\nconst DUMMY_NODE_EDGE = 'edge';\nconst DUMMY_NODE_EDGE_LABEL = 'edge-label';\nconst run = (g, dummyChains) => {\n    g.getAllEdges().forEach((edge) => normalizeEdge(g, edge, dummyChains));\n};\nconst normalizeEdge = (g, e, dummyChains) => {\n    let v = e.source;\n    let vRank = g.getNode(v).data.rank;\n    const w = e.target;\n    const wRank = g.getNode(w).data.rank;\n    const labelRank = e.data.labelRank;\n    if (wRank === vRank + 1)\n        return;\n    g.removeEdge(e.id);\n    let dummy;\n    let nodeData;\n    let i;\n    for (i = 0, ++vRank; vRank < wRank; ++i, ++vRank) {\n        e.data.points = [];\n        nodeData = {\n            originalEdge: e,\n            width: 0,\n            height: 0,\n            rank: vRank,\n        };\n        dummy = addDummyNode(g, DUMMY_NODE_EDGE, nodeData, '_d');\n        if (vRank === labelRank) {\n            nodeData.width = e.data.width;\n            nodeData.height = e.data.height;\n            nodeData.dummy = DUMMY_NODE_EDGE_LABEL;\n            nodeData.labelpos = e.data.labelpos;\n        }\n        g.addEdge({\n            id: `e${Math.random()}`,\n            source: v,\n            target: dummy,\n            data: { weight: e.data.weight },\n        });\n        if (i === 0) {\n            dummyChains.push(dummy);\n        }\n        v = dummy;\n    }\n    g.addEdge({\n        id: `e${Math.random()}`,\n        source: v,\n        target: w,\n        data: { weight: e.data.weight },\n    });\n};\nconst undo = (g, dummyChains) => {\n    dummyChains.forEach((v) => {\n        let node = g.getNode(v);\n        const { data } = node;\n        const originalEdge = data.originalEdge;\n        let w;\n        // Restore original edge.\n        if (originalEdge) {\n            g.addEdge(originalEdge);\n        }\n        let currentV = v;\n        while (node.data.dummy) {\n            w = g.getSuccessors(currentV)[0];\n            g.removeNode(currentV);\n            originalEdge.data.points.push({\n                x: node.data.x,\n                y: node.data.y,\n            });\n            if (node.data.dummy === DUMMY_NODE_EDGE_LABEL) {\n                originalEdge.data.x = node.data.x;\n                originalEdge.data.y = node.data.y;\n                originalEdge.data.width = node.data.width;\n                originalEdge.data.height = node.data.height;\n            }\n            currentV = w.id;\n            node = g.getNode(currentV);\n        }\n    });\n};\n\nexport { run, undo };\n//# sourceMappingURL=normalize.js.map\n"],"names":["DUMMY_NODE_EDGE","DUMMY_NODE_EDGE_LABEL","run","g","dummyChains","edge","normalizeEdge","e","v","vRank","w","wRank","labelRank","dummy","nodeData","i","addDummyNode","undo","node","data","originalEdge","currentV"],"mappings":";AAkBA,MAAMA,IAAkB,QAClBC,IAAwB,cACxBC,IAAM,CAACC,GAAGC,MAAgB;AAC5B,EAAAD,EAAE,cAAc,QAAQ,CAACE,MAASC,EAAcH,GAAGE,GAAMD,CAAW,CAAC;AACzE,GACME,IAAgB,CAACH,GAAGI,GAAGH,MAAgB;AACzC,MAAII,IAAID,EAAE,QACNE,IAAQN,EAAE,QAAQK,CAAC,EAAE,KAAK;AAC9B,QAAME,IAAIH,EAAE,QACNI,IAAQR,EAAE,QAAQO,CAAC,EAAE,KAAK,MAC1BE,IAAYL,EAAE,KAAK;AACzB,MAAII,MAAUF,IAAQ;AAClB;AACJ,EAAAN,EAAE,WAAWI,EAAE,EAAE;AACjB,MAAIM,GACAC,GACAC;AACJ,OAAKA,IAAI,GAAG,EAAEN,GAAOA,IAAQE,GAAO,EAAEI,GAAG,EAAEN;AACvC,IAAAF,EAAE,KAAK,SAAS,CAAA,GAChBO,IAAW;AAAA,MACP,cAAcP;AAAA,MACd,OAAO;AAAA,MACP,QAAQ;AAAA,MACR,MAAME;AAAA,IAClB,GACQI,IAAQG,EAAab,GAAGH,GAAiBc,GAAU,IAAI,GACnDL,MAAUG,MACVE,EAAS,QAAQP,EAAE,KAAK,OACxBO,EAAS,SAASP,EAAE,KAAK,QACzBO,EAAS,QAAQb,GACjBa,EAAS,WAAWP,EAAE,KAAK,WAE/BJ,EAAE,QAAQ;AAAA,MACN,IAAI,IAAI,KAAK,OAAM,CAAE;AAAA,MACrB,QAAQK;AAAA,MACR,QAAQK;AAAA,MACR,MAAM,EAAE,QAAQN,EAAE,KAAK,OAAM;AAAA,IACzC,CAAS,GACGQ,MAAM,KACNX,EAAY,KAAKS,CAAK,GAE1BL,IAAIK;AAER,EAAAV,EAAE,QAAQ;AAAA,IACN,IAAI,IAAI,KAAK,OAAM,CAAE;AAAA,IACrB,QAAQK;AAAA,IACR,QAAQE;AAAA,IACR,MAAM,EAAE,QAAQH,EAAE,KAAK,OAAM;AAAA,EACrC,CAAK;AACL,GACMU,IAAO,CAACd,GAAGC,MAAgB;AAC7B,EAAAA,EAAY,QAAQ,CAACI,MAAM;AACvB,QAAIU,IAAOf,EAAE,QAAQK,CAAC;AACtB,UAAM,EAAE,MAAAW,EAAI,IAAKD,GACXE,IAAeD,EAAK;AAC1B,QAAIT;AAEJ,IAAIU,KACAjB,EAAE,QAAQiB,CAAY;AAE1B,QAAIC,IAAWb;AACf,WAAOU,EAAK,KAAK;AACb,MAAAR,IAAIP,EAAE,cAAckB,CAAQ,EAAE,CAAC,GAC/BlB,EAAE,WAAWkB,CAAQ,GACrBD,EAAa,KAAK,OAAO,KAAK;AAAA,QAC1B,GAAGF,EAAK,KAAK;AAAA,QACb,GAAGA,EAAK,KAAK;AAAA,MAC7B,CAAa,GACGA,EAAK,KAAK,UAAUjB,MACpBmB,EAAa,KAAK,IAAIF,EAAK,KAAK,GAChCE,EAAa,KAAK,IAAIF,EAAK,KAAK,GAChCE,EAAa,KAAK,QAAQF,EAAK,KAAK,OACpCE,EAAa,KAAK,SAASF,EAAK,KAAK,SAEzCG,IAAWX,EAAE,IACbQ,IAAOf,EAAE,QAAQkB,CAAQ;AAAA,EAEjC,CAAC;AACL;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/order/add-subgraph-constraints.js

@@ -0,0 +1,29 @@
+const h = (r, i, a) => {
+  const o = {};
+  let l;
+  a == null || a.forEach((n) => {
+    let d = r.getParent(n), t, e;
+    for (; d; ) {
+      if (t = r.getParent(d.id), t ? (e = o[t.id], o[t.id] = d.id) : (e = l, l = d.id), e && e !== d.id) {
+        i.hasNode(e) || i.addNode({
+          id: e,
+          data: {}
+        }), i.hasNode(d.id) || i.addNode({
+          id: d.id,
+          data: {}
+        }), i.hasEdge(`e${e}-${d.id}`) || i.addEdge({
+          id: `e${e}-${d.id}`,
+          source: e,
+          target: d.id,
+          data: {}
+        });
+        return;
+      }
+      d = t;
+    }
+  });
+};
+export {
+  h as addSubgraphConstraints
+};
+//# sourceMappingURL=add-subgraph-constraints.js.map

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/order/add-subgraph-constraints.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"add-subgraph-constraints.js","sources":["../../../../../../../../node_modules/@antv/layout/lib/algorithm/antv-dagre/order/add-subgraph-constraints.js"],"sourcesContent":["const addSubgraphConstraints = (g, cg, vs) => {\n    const prev = {};\n    let rootPrev;\n    vs === null || vs === void 0 ? void 0 : vs.forEach((v) => {\n        let child = g.getParent(v);\n        let parent;\n        let prevChild;\n        while (child) {\n            parent = g.getParent(child.id);\n            if (parent) {\n                prevChild = prev[parent.id];\n                prev[parent.id] = child.id;\n            }\n            else {\n                prevChild = rootPrev;\n                rootPrev = child.id;\n            }\n            if (prevChild && prevChild !== child.id) {\n                if (!cg.hasNode(prevChild)) {\n                    cg.addNode({\n                        id: prevChild,\n                        data: {},\n                    });\n                }\n                if (!cg.hasNode(child.id)) {\n                    cg.addNode({\n                        id: child.id,\n                        data: {},\n                    });\n                }\n                if (!cg.hasEdge(`e${prevChild}-${child.id}`)) {\n                    cg.addEdge({\n                        id: `e${prevChild}-${child.id}`,\n                        source: prevChild,\n                        target: child.id,\n                        data: {},\n                    });\n                }\n                return;\n            }\n            child = parent;\n        }\n    });\n};\n\nexport { addSubgraphConstraints };\n//# sourceMappingURL=add-subgraph-constraints.js.map\n"],"names":["addSubgraphConstraints","g","cg","vs","prev","rootPrev","v","child","parent","prevChild"],"mappings":"AAAK,MAACA,IAAyB,CAACC,GAAGC,GAAIC,MAAO;AAC1C,QAAMC,IAAO,CAAA;AACb,MAAIC;AACJ,EAAAF,KAAO,QAAiCA,EAAG,QAAQ,CAACG,MAAM;AACtD,QAAIC,IAAQN,EAAE,UAAUK,CAAC,GACrBE,GACAC;AACJ,WAAOF,KAAO;AAUV,UATAC,IAASP,EAAE,UAAUM,EAAM,EAAE,GACzBC,KACAC,IAAYL,EAAKI,EAAO,EAAE,GAC1BJ,EAAKI,EAAO,EAAE,IAAID,EAAM,OAGxBE,IAAYJ,GACZA,IAAWE,EAAM,KAEjBE,KAAaA,MAAcF,EAAM,IAAI;AACrC,QAAKL,EAAG,QAAQO,CAAS,KACrBP,EAAG,QAAQ;AAAA,UACP,IAAIO;AAAA,UACJ,MAAM,CAAA;AAAA,QAC9B,CAAqB,GAEAP,EAAG,QAAQK,EAAM,EAAE,KACpBL,EAAG,QAAQ;AAAA,UACP,IAAIK,EAAM;AAAA,UACV,MAAM,CAAA;AAAA,QAC9B,CAAqB,GAEAL,EAAG,QAAQ,IAAIO,CAAS,IAAIF,EAAM,EAAE,EAAE,KACvCL,EAAG,QAAQ;AAAA,UACP,IAAI,IAAIO,CAAS,IAAIF,EAAM,EAAE;AAAA,UAC7B,QAAQE;AAAA,UACR,QAAQF,EAAM;AAAA,UACd,MAAM,CAAA;AAAA,QAC9B,CAAqB;AAEL;AAAA,MACJ;AACA,MAAAA,IAAQC;AAAA,IACZ;AAAA,EACJ,CAAC;AACL;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/order/barycenter.js

@@ -0,0 +1,18 @@
+const a = (i, o) => o.map((r) => {
+  const t = i.getRelatedEdges(r, "in");
+  if (!(t != null && t.length))
+    return { v: r };
+  const e = { sum: 0, weight: 0 };
+  return t == null || t.forEach((n) => {
+    const d = i.getNode(n.source);
+    e.sum += n.data.weight * d.data.order, e.weight += n.data.weight;
+  }), {
+    v: r,
+    barycenter: e.sum / e.weight,
+    weight: e.weight
+  };
+});
+export {
+  a as barycenter
+};
+//# sourceMappingURL=barycenter.js.map

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/order/barycenter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"barycenter.js","sources":["../../../../../../../../node_modules/@antv/layout/lib/algorithm/antv-dagre/order/barycenter.js"],"sourcesContent":["/**\n * TODO: The median method consistently performs better than the barycenter method and has a slight theoretical advantage\n */\nconst barycenter = (g, movable) => {\n    return movable.map((v) => {\n        const inV = g.getRelatedEdges(v, 'in');\n        if (!(inV === null || inV === void 0 ? void 0 : inV.length)) {\n            return { v };\n        }\n        const result = { sum: 0, weight: 0 };\n        inV === null || inV === void 0 ? void 0 : inV.forEach((e) => {\n            const nodeU = g.getNode(e.source);\n            result.sum += e.data.weight * nodeU.data.order;\n            result.weight += e.data.weight;\n        });\n        return {\n            v,\n            barycenter: result.sum / result.weight,\n            weight: result.weight,\n        };\n    });\n};\n\nexport { barycenter };\n//# sourceMappingURL=barycenter.js.map\n"],"names":["barycenter","g","movable","v","inV","result","e","nodeU"],"mappings":"AAGK,MAACA,IAAa,CAACC,GAAGC,MACZA,EAAQ,IAAI,CAACC,MAAM;AACtB,QAAMC,IAAMH,EAAE,gBAAgBE,GAAG,IAAI;AACrC,MAAI,EAAEC,KAAQ,QAAkCA,EAAI;AAChD,WAAO,EAAE,GAAAD,EAAC;AAEd,QAAME,IAAS,EAAE,KAAK,GAAG,QAAQ,EAAC;AAClC,SAAAD,KAAQ,QAAkCA,EAAI,QAAQ,CAACE,MAAM;AACzD,UAAMC,IAAQN,EAAE,QAAQK,EAAE,MAAM;AAChC,IAAAD,EAAO,OAAOC,EAAE,KAAK,SAASC,EAAM,KAAK,OACzCF,EAAO,UAAUC,EAAE,KAAK;AAAA,EAC5B,CAAC,GACM;AAAA,IACH,GAAAH;AAAA,IACA,YAAYE,EAAO,MAAMA,EAAO;AAAA,IAChC,QAAQA,EAAO;AAAA,EAC3B;AACI,CAAC;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/order/build-layer-graph.js

@@ -0,0 +1,30 @@
+import { DagreGraph as b } from "../graph.js";
+const R = (i, e, l) => {
+  const c = f(i), a = new b();
+  return a.addNode({ id: c, data: {} }), i.getAllNodes().forEach((d) => {
+    var r, g;
+    const t = i.getParent(d.id);
+    (d.data.rank === e || d.data.minRank <= e && e <= d.data.maxRank) && (a.hasNode(d.id) || a.addNode(Object.assign({}, d)), t != null && t.id && !a.hasNode(t == null ? void 0 : t.id) && a.addNode(Object.assign({}, t)), a.setParent(d.id, (t == null ? void 0 : t.id) || c), i.getRelatedEdges(d.id, l).forEach((o) => {
+      const s = o.source === d.id ? o.target : o.source;
+      a.hasNode(s) || a.addNode(Object.assign({}, i.getNode(s)));
+      const n = a.getRelatedEdges(s, "out").find(({ target: u }) => u === d.id), h = n !== void 0 ? n.data.weight : 0;
+      n ? a.updateEdgeData(n.id, Object.assign(Object.assign({}, n.data), { weight: o.data.weight + h })) : a.addEdge({
+        id: o.id,
+        source: s,
+        target: d.id,
+        data: {
+          weight: o.data.weight + h
+        }
+      });
+    }), d.data.hasOwnProperty("minRank") && a.updateNodeData(d.id, Object.assign(Object.assign({}, d.data), { borderLeft: [(r = d.data.borderLeft) === null || r === void 0 ? void 0 : r[e - d.data.minRank]], borderRight: [(g = d.data.borderRight) === null || g === void 0 ? void 0 : g[e - d.data.minRank]] })));
+  }), a;
+}, f = (i) => {
+  let e;
+  for (; i.hasNode(e = `_root${Math.random()}`); )
+    ;
+  return e;
+};
+export {
+  R as buildLayerGraph
+};
+//# sourceMappingURL=build-layer-graph.js.map

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/order/build-layer-graph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-layer-graph.js","sources":["../../../../../../../../node_modules/@antv/layout/lib/algorithm/antv-dagre/order/build-layer-graph.js"],"sourcesContent":["import { DagreGraph } from '../graph.js';\n\n/*\n * Constructs a graph that can be used to sort a layer of nodes. The graph will\n * contain all base and subgraph nodes from the request layer in their original\n * hierarchy and any edges that are incident on these nodes and are of the type\n * requested by the \"relationship\" parameter.\n *\n * Nodes from the requested rank that do not have parents are assigned a root\n * node in the output graph, which is set in the root graph attribute. This\n * makes it easy to walk the hierarchy of movable nodes during ordering.\n *\n * Pre-conditions:\n *\n *    1. Input graph is a DAG\n *    2. Base nodes in the input graph have a rank attribute\n *    3. Subgraph nodes in the input graph has minRank and maxRank attributes\n *    4. Edges have an assigned weight\n *\n * Post-conditions:\n *\n *    1. Output graph has all nodes in the movable rank with preserved\n *       hierarchy.\n *    2. Root nodes in the movable layer are made children of the node\n *       indicated by the root attribute of the graph.\n *    3. Non-movable nodes incident on movable nodes, selected by the\n *       relationship parameter, are included in the graph (without hierarchy).\n *    4. Edges incident on movable nodes, selected by the relationship\n *       parameter, are added to the output graph.\n *    5. The weights for copied edges are aggregated as need, since the output\n *       graph is not a multi-graph.\n */\nconst buildLayerGraph = (g, rank, direction) => {\n    const root = createRootNode(g);\n    const result = new DagreGraph();\n    result.addNode({ id: root, data: {} });\n    g.getAllNodes().forEach((v) => {\n        var _a, _b;\n        const parent = g.getParent(v.id);\n        if (v.data.rank === rank ||\n            (v.data.minRank <= rank && rank <= v.data.maxRank)) {\n            if (!result.hasNode(v.id)) {\n                result.addNode(Object.assign({}, v));\n            }\n            if ((parent === null || parent === void 0 ? void 0 : parent.id) && !result.hasNode(parent === null || parent === void 0 ? void 0 : parent.id)) {\n                result.addNode(Object.assign({}, parent));\n            }\n            result.setParent(v.id, (parent === null || parent === void 0 ? void 0 : parent.id) || root);\n            // This assumes we have only short edges!\n            g.getRelatedEdges(v.id, direction).forEach((e) => {\n                const u = e.source === v.id ? e.target : e.source;\n                if (!result.hasNode(u)) {\n                    result.addNode(Object.assign({}, g.getNode(u)));\n                }\n                const edge = result\n                    .getRelatedEdges(u, 'out')\n                    .find(({ target }) => target === v.id);\n                const weight = edge !== undefined ? edge.data.weight : 0;\n                if (!edge) {\n                    result.addEdge({\n                        id: e.id,\n                        source: u,\n                        target: v.id,\n                        data: {\n                            weight: e.data.weight + weight,\n                        },\n                    });\n                }\n                else {\n                    result.updateEdgeData(edge.id, Object.assign(Object.assign({}, edge.data), { weight: e.data.weight + weight }));\n                }\n            });\n            // console.log(v);\n            if (v.data.hasOwnProperty('minRank')) {\n                result.updateNodeData(v.id, Object.assign(Object.assign({}, v.data), { borderLeft: [(_a = v.data.borderLeft) === null || _a === void 0 ? void 0 : _a[rank - v.data.minRank]], borderRight: [(_b = v.data.borderRight) === null || _b === void 0 ? void 0 : _b[rank - v.data.minRank]] }));\n            }\n        }\n    });\n    return result;\n};\nconst createRootNode = (g) => {\n    let v;\n    while (g.hasNode((v = `_root${Math.random()}`)))\n        ;\n    return v;\n};\n\nexport { buildLayerGraph };\n//# sourceMappingURL=build-layer-graph.js.map\n"],"names":["buildLayerGraph","g","rank","direction","root","createRootNode","result","DagreGraph","v","_a","_b","parent","e","u","edge","target","weight"],"mappings":";AAgCK,MAACA,IAAkB,CAACC,GAAGC,GAAMC,MAAc;AAC5C,QAAMC,IAAOC,EAAeJ,CAAC,GACvBK,IAAS,IAAIC,EAAU;AAC7B,SAAAD,EAAO,QAAQ,EAAE,IAAIF,GAAM,MAAM,CAAA,GAAI,GACrCH,EAAE,YAAW,EAAG,QAAQ,CAACO,MAAM;AAC3B,QAAIC,GAAIC;AACR,UAAMC,IAASV,EAAE,UAAUO,EAAE,EAAE;AAC/B,KAAIA,EAAE,KAAK,SAASN,KACfM,EAAE,KAAK,WAAWN,KAAQA,KAAQM,EAAE,KAAK,aACrCF,EAAO,QAAQE,EAAE,EAAE,KACpBF,EAAO,QAAQ,OAAO,OAAO,CAAA,GAAIE,CAAC,CAAC,GAElCG,KAAW,QAAqCA,EAAO,MAAO,CAACL,EAAO,QAAQK,KAAW,OAA4B,SAASA,EAAO,EAAE,KACxIL,EAAO,QAAQ,OAAO,OAAO,CAAA,GAAIK,CAAM,CAAC,GAE5CL,EAAO,UAAUE,EAAE,KAAKG,KAAW,OAA4B,SAASA,EAAO,OAAOP,CAAI,GAE1FH,EAAE,gBAAgBO,EAAE,IAAIL,CAAS,EAAE,QAAQ,CAACS,MAAM;AAC9C,YAAMC,IAAID,EAAE,WAAWJ,EAAE,KAAKI,EAAE,SAASA,EAAE;AAC3C,MAAKN,EAAO,QAAQO,CAAC,KACjBP,EAAO,QAAQ,OAAO,OAAO,CAAA,GAAIL,EAAE,QAAQY,CAAC,CAAC,CAAC;AAElD,YAAMC,IAAOR,EACR,gBAAgBO,GAAG,KAAK,EACxB,KAAK,CAAC,EAAE,QAAAE,EAAM,MAAOA,MAAWP,EAAE,EAAE,GACnCQ,IAASF,MAAS,SAAYA,EAAK,KAAK,SAAS;AACvD,MAAKA,IAWDR,EAAO,eAAeQ,EAAK,IAAI,OAAO,OAAO,OAAO,OAAO,CAAA,GAAIA,EAAK,IAAI,GAAG,EAAE,QAAQF,EAAE,KAAK,SAASI,EAAM,CAAE,CAAC,IAV9GV,EAAO,QAAQ;AAAA,QACX,IAAIM,EAAE;AAAA,QACN,QAAQC;AAAA,QACR,QAAQL,EAAE;AAAA,QACV,MAAM;AAAA,UACF,QAAQI,EAAE,KAAK,SAASI;AAAA,QACpD;AAAA,MACA,CAAqB;AAAA,IAKT,CAAC,GAEGR,EAAE,KAAK,eAAe,SAAS,KAC/BF,EAAO,eAAeE,EAAE,IAAI,OAAO,OAAO,OAAO,OAAO,CAAA,GAAIA,EAAE,IAAI,GAAG,EAAE,YAAY,EAAEC,IAAKD,EAAE,KAAK,gBAAgB,QAAQC,MAAO,SAAS,SAASA,EAAGP,IAAOM,EAAE,KAAK,OAAO,CAAC,GAAG,aAAa,EAAEE,IAAKF,EAAE,KAAK,iBAAiB,QAAQE,MAAO,SAAS,SAASA,EAAGR,IAAOM,EAAE,KAAK,OAAO,CAAC,EAAC,CAAE,CAAC;AAAA,EAGpS,CAAC,GACMF;AACX,GACMD,IAAiB,CAACJ,MAAM;AAC1B,MAAIO;AACJ,SAAOP,EAAE,QAASO,IAAI,QAAQ,KAAK,OAAM,CAAE,EAAE;AACzC;AACJ,SAAOA;AACX;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/order/cross-count.js

@@ -0,0 +1,33 @@
+import { zipObject as p } from "../util.js";
+const w = (r, e, s) => {
+  const l = p(s, s.map((o, t) => t)), c = e.map((o) => {
+    const t = r.getRelatedEdges(o, "out").map((i) => ({ pos: l[i.target] || 0, weight: i.data.weight }));
+    return t == null ? void 0 : t.sort((i, h) => i.pos - h.pos);
+  }).flat().filter((o) => o !== void 0);
+  let n = 1;
+  for (; n < s.length; )
+    n <<= 1;
+  const d = 2 * n - 1;
+  n -= 1;
+  const u = Array(d).fill(0, 0, d);
+  let f = 0;
+  return c == null || c.forEach((o) => {
+    if (o) {
+      let t = o.pos + n;
+      u[t] += o.weight;
+      let i = 0;
+      for (; t > 0; )
+        t % 2 && (i += u[t + 1]), t = t - 1 >> 1, u[t] += o.weight;
+      f += o.weight * i;
+    }
+  }), f;
+}, v = (r, e) => {
+  let s = 0;
+  for (let l = 1; l < (e == null ? void 0 : e.length); l += 1)
+    s += w(r, e[l - 1], e[l]);
+  return s;
+};
+export {
+  v as crossCount
+};
+//# sourceMappingURL=cross-count.js.map

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/order/cross-count.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cross-count.js","sources":["../../../../../../../../node_modules/@antv/layout/lib/algorithm/antv-dagre/order/cross-count.js"],"sourcesContent":["import { zipObject } from '../util.js';\n\n/*\n * A function that takes a layering (an array of layers, each with an array of\n * ordererd nodes) and a graph and returns a weighted crossing count.\n *\n * Pre-conditions:\n *\n *    1. Input graph must be simple (not a multigraph), directed, and include\n *       only simple edges.\n *    2. Edges in the input graph must have assigned weights.\n *\n * Post-conditions:\n *\n *    1. The graph and layering matrix are left unchanged.\n *\n * This algorithm is derived from Barth, et al., \"Bilayer Cross Counting.\"\n */\nconst twoLayerCrossCount = (g, northLayer, southLayer) => {\n    // Sort all of the edges between the north and south layers by their position\n    // in the north layer and then the south. Map these edges to the position of\n    // their head in the south layer.\n    const southPos = zipObject(southLayer, southLayer.map((v, i) => i));\n    const unflat = northLayer.map((v) => {\n        const unsort = g.getRelatedEdges(v, 'out').map((e) => {\n            return { pos: southPos[e.target] || 0, weight: e.data.weight };\n        });\n        return unsort === null || unsort === void 0 ? void 0 : unsort.sort((a, b) => a.pos - b.pos);\n    });\n    const southEntries = unflat.flat().filter((entry) => entry !== undefined);\n    // Build the accumulator tree\n    let firstIndex = 1;\n    while (firstIndex < southLayer.length)\n        firstIndex <<= 1;\n    const treeSize = 2 * firstIndex - 1;\n    firstIndex -= 1;\n    const tree = Array(treeSize).fill(0, 0, treeSize);\n    // Calculate the weighted crossings\n    let cc = 0;\n    southEntries === null || southEntries === void 0 ? void 0 : southEntries.forEach((entry) => {\n        if (entry) {\n            let index = entry.pos + firstIndex;\n            tree[index] += entry.weight;\n            let weightSum = 0;\n            while (index > 0) {\n                if (index % 2) {\n                    weightSum += tree[index + 1];\n                }\n                index = (index - 1) >> 1;\n                tree[index] += entry.weight;\n            }\n            cc += entry.weight * weightSum;\n        }\n    });\n    return cc;\n};\nconst crossCount = (g, layering) => {\n    let cc = 0;\n    for (let i = 1; i < (layering === null || layering === void 0 ? void 0 : layering.length); i += 1) {\n        cc += twoLayerCrossCount(g, layering[i - 1], layering[i]);\n    }\n    return cc;\n};\n\nexport { crossCount };\n//# sourceMappingURL=cross-count.js.map\n"],"names":["twoLayerCrossCount","g","northLayer","southLayer","southPos","zipObject","v","i","southEntries","unsort","e","a","b","entry","firstIndex","treeSize","tree","cc","index","weightSum","crossCount","layering"],"mappings":";AAkBA,MAAMA,IAAqB,CAACC,GAAGC,GAAYC,MAAe;AAItD,QAAMC,IAAWC,EAAUF,GAAYA,EAAW,IAAI,CAACG,GAAGC,MAAMA,CAAC,CAAC,GAO5DC,IANSN,EAAW,IAAI,CAACI,MAAM;AACjC,UAAMG,IAASR,EAAE,gBAAgBK,GAAG,KAAK,EAAE,IAAI,CAACI,OACrC,EAAE,KAAKN,EAASM,EAAE,MAAM,KAAK,GAAG,QAAQA,EAAE,KAAK,OAAM,EAC/D;AACD,WAAOD,KAAW,OAA4B,SAASA,EAAO,KAAK,CAACE,GAAGC,MAAMD,EAAE,MAAMC,EAAE,GAAG;AAAA,EAC9F,CAAC,EAC2B,KAAI,EAAG,OAAO,CAACC,MAAUA,MAAU,MAAS;AAExE,MAAIC,IAAa;AACjB,SAAOA,IAAaX,EAAW;AAC3B,IAAAW,MAAe;AACnB,QAAMC,IAAW,IAAID,IAAa;AAClC,EAAAA,KAAc;AACd,QAAME,IAAO,MAAMD,CAAQ,EAAE,KAAK,GAAG,GAAGA,CAAQ;AAEhD,MAAIE,IAAK;AACT,SAAAT,KAAiB,QAA2CA,EAAa,QAAQ,CAACK,MAAU;AACxF,QAAIA,GAAO;AACP,UAAIK,IAAQL,EAAM,MAAMC;AACxB,MAAAE,EAAKE,CAAK,KAAKL,EAAM;AACrB,UAAIM,IAAY;AAChB,aAAOD,IAAQ;AACX,QAAIA,IAAQ,MACRC,KAAaH,EAAKE,IAAQ,CAAC,IAE/BA,IAASA,IAAQ,KAAM,GACvBF,EAAKE,CAAK,KAAKL,EAAM;AAEzB,MAAAI,KAAMJ,EAAM,SAASM;AAAA,IACzB;AAAA,EACJ,CAAC,GACMF;AACX,GACMG,IAAa,CAACnB,GAAGoB,MAAa;AAChC,MAAIJ,IAAK;AACT,WAASV,IAAI,GAAGA,KAAKc,KAAa,OAA8B,SAASA,EAAS,SAASd,KAAK;AAC5F,IAAAU,KAAMjB,EAAmBC,GAAGoB,EAASd,IAAI,CAAC,GAAGc,EAASd,CAAC,CAAC;AAE5D,SAAOU;AACX;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/order/index.js

@@ -0,0 +1,52 @@
+import { DagreGraph as x } from "../graph.js";
+import { maxRank as C, buildLayerMatrix as l } from "../util.js";
+import { addSubgraphConstraints as E } from "./add-subgraph-constraints.js";
+import { buildLayerGraph as G } from "./build-layer-graph.js";
+import { crossCount as h } from "./cross-count.js";
+import { initOrder as v } from "./init-order.js";
+import { sortSubgraph as N } from "./sort-subgraph.js";
+import b from "../../../node_modules/@antv/util/esm/lodash/clone.js";
+const y = (o, s) => {
+  const e = C(o), n = [], c = [];
+  for (let t = 1; t < e + 1; t++)
+    n.push(t);
+  for (let t = e - 1; t > -1; t--)
+    c.push(t);
+  const d = L(o, n, "in"), m = L(o, c, "out");
+  let r = v(o);
+  u(o, r);
+  let i = Number.POSITIVE_INFINITY, a;
+  for (let t = 0, f = 0; f < 4; ++t, ++f) {
+    I(t % 2 ? d : m, t % 4 >= 2, !1, s), r = l(o);
+    const p = h(o, r);
+    p < i && (f = 0, a = b(r), i = p);
+  }
+  r = v(o), u(o, r);
+  for (let t = 0, f = 0; f < 4; ++t, ++f) {
+    I(t % 2 ? d : m, t % 4 >= 2, !0, s), r = l(o);
+    const p = h(o, r);
+    p < i && (f = 0, a = b(r), i = p);
+  }
+  u(o, a);
+}, L = (o, s, e) => s.map((n) => G(o, n, e)), I = (o, s, e, n) => {
+  const c = new x();
+  o == null || o.forEach((d) => {
+    var m;
+    const r = d.getRoots()[0].id, i = N(d, r, c, s, e, n);
+    for (let a = 0; a < ((m = i.vs) === null || m === void 0 ? void 0 : m.length); a++) {
+      const t = d.getNode(i.vs[a]);
+      t && (t.data.order = a);
+    }
+    E(d, c, i.vs);
+  });
+}, u = (o, s) => {
+  s == null || s.forEach((e) => {
+    e == null || e.forEach((n, c) => {
+      o.getNode(n).data.order = c;
+    });
+  });
+};
+export {
+  y as order
+};
+//# sourceMappingURL=index.js.map

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/order/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../../node_modules/@antv/layout/lib/algorithm/antv-dagre/order/index.js"],"sourcesContent":["import { DagreGraph } from '../graph.js';\nimport { maxRank, buildLayerMatrix } from '../util.js';\nimport { addSubgraphConstraints } from './add-subgraph-constraints.js';\nimport { buildLayerGraph } from './build-layer-graph.js';\nimport { crossCount } from './cross-count.js';\nimport { initOrder } from './init-order.js';\nimport { sortSubgraph } from './sort-subgraph.js';\nimport clone from '../../../node_modules/@antv/util/esm/lodash/clone.js';\n\n/*\n * Applies heuristics to minimize edge crossings in the graph and sets the best\n * order solution as an order attribute on each node.\n *\n * Pre-conditions:\n *\n *    1. Graph must be DAG\n *    2. Graph nodes must be objects with a \"rank\" attribute\n *    3. Graph edges must have the \"weight\" attribute\n *\n * Post-conditions:\n *\n *    1. Graph nodes will have an \"order\" attribute based on the results of the\n *       algorithm.\n */\nconst order = (g, keepNodeOrder) => {\n    const mxRank = maxRank(g);\n    const range1 = [];\n    const range2 = [];\n    for (let i = 1; i < mxRank + 1; i++)\n        range1.push(i);\n    for (let i = mxRank - 1; i > -1; i--)\n        range2.push(i);\n    const downLayerGraphs = buildLayerGraphs(g, range1, 'in');\n    const upLayerGraphs = buildLayerGraphs(g, range2, 'out');\n    let layering = initOrder(g);\n    assignOrder(g, layering);\n    let bestCC = Number.POSITIVE_INFINITY;\n    let best;\n    for (let i = 0, lastBest = 0; lastBest < 4; ++i, ++lastBest) {\n        sweepLayerGraphs(i % 2 ? downLayerGraphs : upLayerGraphs, i % 4 >= 2, false, keepNodeOrder);\n        layering = buildLayerMatrix(g);\n        const cc = crossCount(g, layering);\n        if (cc < bestCC) {\n            lastBest = 0;\n            best = clone(layering);\n            bestCC = cc;\n        }\n    }\n    // consider use previous result, maybe somewhat reduendant\n    layering = initOrder(g);\n    assignOrder(g, layering);\n    for (let i = 0, lastBest = 0; lastBest < 4; ++i, ++lastBest) {\n        sweepLayerGraphs(i % 2 ? downLayerGraphs : upLayerGraphs, i % 4 >= 2, true, keepNodeOrder);\n        layering = buildLayerMatrix(g);\n        const cc = crossCount(g, layering);\n        if (cc < bestCC) {\n            lastBest = 0;\n            best = clone(layering);\n            bestCC = cc;\n        }\n    }\n    assignOrder(g, best);\n};\nconst buildLayerGraphs = (g, ranks, direction) => {\n    return ranks.map((rank) => {\n        return buildLayerGraph(g, rank, direction);\n    });\n};\nconst sweepLayerGraphs = (layerGraphs, biasRight, usePrev, keepNodeOrder) => {\n    const cg = new DagreGraph();\n    layerGraphs === null || layerGraphs === void 0 ? void 0 : layerGraphs.forEach((lg) => {\n        var _a;\n        // const root = lg.graph().root as string;\n        const root = lg.getRoots()[0].id;\n        const sorted = sortSubgraph(lg, root, cg, biasRight, usePrev, keepNodeOrder);\n        for (let i = 0; i < ((_a = sorted.vs) === null || _a === void 0 ? void 0 : _a.length) || 0; i++) {\n            const lnode = lg.getNode(sorted.vs[i]);\n            if (lnode) {\n                lnode.data.order = i;\n            }\n        }\n        addSubgraphConstraints(lg, cg, sorted.vs);\n    });\n};\nconst assignOrder = (g, layering) => {\n    layering === null || layering === void 0 ? void 0 : layering.forEach((layer) => {\n        layer === null || layer === void 0 ? void 0 : layer.forEach((v, i) => {\n            g.getNode(v).data.order = i;\n        });\n    });\n};\n\nexport { order };\n//# sourceMappingURL=index.js.map\n"],"names":["order","g","keepNodeOrder","mxRank","maxRank","range1","range2","i","downLayerGraphs","buildLayerGraphs","upLayerGraphs","layering","initOrder","assignOrder","bestCC","best","lastBest","sweepLayerGraphs","buildLayerMatrix","cc","crossCount","clone","ranks","direction","rank","buildLayerGraph","layerGraphs","biasRight","usePrev","cg","DagreGraph","lg","_a","root","sorted","sortSubgraph","lnode","addSubgraphConstraints","layer","v"],"mappings":";;;;;;;;AAwBK,MAACA,IAAQ,CAACC,GAAGC,MAAkB;AAChC,QAAMC,IAASC,EAAQH,CAAC,GAClBI,IAAS,CAAA,GACTC,IAAS,CAAA;AACf,WAASC,IAAI,GAAGA,IAAIJ,IAAS,GAAGI;AAC5B,IAAAF,EAAO,KAAKE,CAAC;AACjB,WAASA,IAAIJ,IAAS,GAAGI,IAAI,IAAIA;AAC7B,IAAAD,EAAO,KAAKC,CAAC;AACjB,QAAMC,IAAkBC,EAAiBR,GAAGI,GAAQ,IAAI,GAClDK,IAAgBD,EAAiBR,GAAGK,GAAQ,KAAK;AACvD,MAAIK,IAAWC,EAAUX,CAAC;AAC1B,EAAAY,EAAYZ,GAAGU,CAAQ;AACvB,MAAIG,IAAS,OAAO,mBAChBC;AACJ,WAASR,IAAI,GAAGS,IAAW,GAAGA,IAAW,GAAG,EAAET,GAAG,EAAES,GAAU;AACzD,IAAAC,EAAiBV,IAAI,IAAIC,IAAkBE,GAAeH,IAAI,KAAK,GAAG,IAAOL,CAAa,GAC1FS,IAAWO,EAAiBjB,CAAC;AAC7B,UAAMkB,IAAKC,EAAWnB,GAAGU,CAAQ;AACjC,IAAIQ,IAAKL,MACLE,IAAW,GACXD,IAAOM,EAAMV,CAAQ,GACrBG,IAASK;AAAA,EAEjB;AAEA,EAAAR,IAAWC,EAAUX,CAAC,GACtBY,EAAYZ,GAAGU,CAAQ;AACvB,WAASJ,IAAI,GAAGS,IAAW,GAAGA,IAAW,GAAG,EAAET,GAAG,EAAES,GAAU;AACzD,IAAAC,EAAiBV,IAAI,IAAIC,IAAkBE,GAAeH,IAAI,KAAK,GAAG,IAAML,CAAa,GACzFS,IAAWO,EAAiBjB,CAAC;AAC7B,UAAMkB,IAAKC,EAAWnB,GAAGU,CAAQ;AACjC,IAAIQ,IAAKL,MACLE,IAAW,GACXD,IAAOM,EAAMV,CAAQ,GACrBG,IAASK;AAAA,EAEjB;AACA,EAAAN,EAAYZ,GAAGc,CAAI;AACvB,GACMN,IAAmB,CAACR,GAAGqB,GAAOC,MACzBD,EAAM,IAAI,CAACE,MACPC,EAAgBxB,GAAGuB,GAAMD,CAAS,CAC5C,GAECN,IAAmB,CAACS,GAAaC,GAAWC,GAAS1B,MAAkB;AACzE,QAAM2B,IAAK,IAAIC,EAAU;AACzB,EAAAJ,KAAgB,QAA0CA,EAAY,QAAQ,CAACK,MAAO;AAClF,QAAIC;AAEJ,UAAMC,IAAOF,EAAG,SAAQ,EAAG,CAAC,EAAE,IACxBG,IAASC,EAAaJ,GAAIE,GAAMJ,GAAIF,GAAWC,GAAS1B,CAAa;AAC3E,aAASK,IAAI,GAAGA,MAAMyB,IAAKE,EAAO,QAAQ,QAAQF,MAAO,SAAS,SAASA,EAAG,SAAczB,KAAK;AAC7F,YAAM6B,IAAQL,EAAG,QAAQG,EAAO,GAAG3B,CAAC,CAAC;AACrC,MAAI6B,MACAA,EAAM,KAAK,QAAQ7B;AAAA,IAE3B;AACA,IAAA8B,EAAuBN,GAAIF,GAAIK,EAAO,EAAE;AAAA,EAC5C,CAAC;AACL,GACMrB,IAAc,CAACZ,GAAGU,MAAa;AACjC,EAAAA,KAAa,QAAuCA,EAAS,QAAQ,CAAC2B,MAAU;AAC5E,IAAAA,KAAU,QAAoCA,EAAM,QAAQ,CAACC,GAAGhC,MAAM;AAClE,MAAAN,EAAE,QAAQsC,CAAC,EAAE,KAAK,QAAQhC;AAAA,IAC9B,CAAC;AAAA,EACL,CAAC;AACL;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/order/init-data-order.js

@@ -0,0 +1,16 @@
+const s = (n, e) => {
+  const d = n.getAllNodes().filter((a) => {
+    var t;
+    return !(!((t = n.getChildren(a.id)) === null || t === void 0) && t.length);
+  }).map((a) => a.data.rank), i = Math.max(...d), o = [];
+  for (let a = 0; a < i + 1; a++)
+    o[a] = [];
+  e == null || e.forEach((a) => {
+    const t = n.getNode(a);
+    !t || t.data.dummy || isNaN(t.data.rank) || (t.data.fixorder = o[t.data.rank].length, o[t.data.rank].push(a));
+  });
+};
+export {
+  s as initDataOrder
+};
+//# sourceMappingURL=init-data-order.js.map

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/order/init-data-order.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"init-data-order.js","sources":["../../../../../../../../node_modules/@antv/layout/lib/algorithm/antv-dagre/order/init-data-order.js"],"sourcesContent":["/**\n * 按照数据中的结果设置fixorder\n */\nconst initDataOrder = (g, nodeOrder) => {\n    const simpleNodes = g.getAllNodes().filter((v) => {\n        var _a;\n        return !((_a = g.getChildren(v.id)) === null || _a === void 0 ? void 0 : _a.length);\n    });\n    const ranks = simpleNodes.map((v) => v.data.rank);\n    const maxRank = Math.max(...ranks);\n    const layers = [];\n    for (let i = 0; i < maxRank + 1; i++) {\n        layers[i] = [];\n    }\n    nodeOrder === null || nodeOrder === void 0 ? void 0 : nodeOrder.forEach((n) => {\n        const node = g.getNode(n);\n        // 只考虑原有节点，dummy节点需要按照后续算法排出\n        if (!node || node.data.dummy) {\n            return;\n        }\n        if (!isNaN(node.data.rank)) {\n            node.data.fixorder = layers[node.data.rank].length; // 设置fixorder为当层的顺序\n            layers[node.data.rank].push(n);\n        }\n    });\n};\n\nexport { initDataOrder };\n//# sourceMappingURL=init-data-order.js.map\n"],"names":["initDataOrder","g","nodeOrder","ranks","v","_a","maxRank","layers","i","n","node"],"mappings":"AAGK,MAACA,IAAgB,CAACC,GAAGC,MAAc;AAKpC,QAAMC,IAJcF,EAAE,YAAW,EAAG,OAAO,CAACG,MAAM;AAC9C,QAAIC;AACJ,WAAO,EAAG,GAAAA,IAAKJ,EAAE,YAAYG,EAAE,EAAE,OAAO,QAAQC,MAAO,WAAkBA,EAAG;AAAA,EAChF,CAAC,EACyB,IAAI,CAACD,MAAMA,EAAE,KAAK,IAAI,GAC1CE,IAAU,KAAK,IAAI,GAAGH,CAAK,GAC3BI,IAAS,CAAA;AACf,WAASC,IAAI,GAAGA,IAAIF,IAAU,GAAGE;AAC7B,IAAAD,EAAOC,CAAC,IAAI,CAAA;AAEhB,EAAAN,KAAc,QAAwCA,EAAU,QAAQ,CAACO,MAAM;AAC3E,UAAMC,IAAOT,EAAE,QAAQQ,CAAC;AAExB,IAAI,CAACC,KAAQA,EAAK,KAAK,SAGlB,MAAMA,EAAK,KAAK,IAAI,MACrBA,EAAK,KAAK,WAAWH,EAAOG,EAAK,KAAK,IAAI,EAAE,QAC5CH,EAAOG,EAAK,KAAK,IAAI,EAAE,KAAKD,CAAC;AAAA,EAErC,CAAC;AACL;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/order/init-order.js

@@ -0,0 +1,20 @@
+const N = (t) => {
+  const i = {}, s = t.getAllNodes(), n = s.map((d) => {
+    var r;
+    return (r = d.data.rank) !== null && r !== void 0 ? r : -1 / 0;
+  }), f = Math.max(...n), e = [];
+  for (let d = 0; d < f + 1; d++)
+    e.push([]);
+  const a = s.sort((d, r) => t.getNode(d.id).data.rank - t.getNode(r.id).data.rank), o = a.filter((d) => t.getNode(d.id).data.fixorder !== void 0).sort((d, r) => t.getNode(d.id).data.fixorder - t.getNode(r.id).data.fixorder);
+  return o == null || o.forEach((d) => {
+    isNaN(t.getNode(d.id).data.rank) || e[t.getNode(d.id).data.rank].push(d.id), i[d.id] = !0;
+  }), a == null || a.forEach((d) => t.dfsTree(d.id, (r) => {
+    if (i.hasOwnProperty(r.id))
+      return !0;
+    i[r.id] = !0, isNaN(r.data.rank) || e[r.data.rank].push(r.id);
+  })), e;
+};
+export {
+  N as initOrder
+};
+//# sourceMappingURL=init-order.js.map

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/order/init-order.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"init-order.js","sources":["../../../../../../../../node_modules/@antv/layout/lib/algorithm/antv-dagre/order/init-order.js"],"sourcesContent":["/*\n * Assigns an initial order value for each node by performing a DFS search\n * starting from nodes in the first rank. Nodes are assigned an order in their\n * rank as they are first visited.\n *\n * This approach comes from Gansner, et al., \"A Technique for Drawing Directed\n * Graphs.\"\n *\n * Returns a layering matrix with an array per layer and each layer sorted by\n * the order of its nodes.\n */\nconst initOrder = (g) => {\n    const visited = {};\n    // const simpleNodes = g.getAllNodes().filter((v) => {\n    //   return !g.getChildren(v.id)?.length;\n    // });\n    const simpleNodes = g.getAllNodes();\n    const nodeRanks = simpleNodes.map((v) => { var _a; return (_a = v.data.rank) !== null && _a !== void 0 ? _a : -Infinity; });\n    const maxRank = Math.max(...nodeRanks);\n    const layers = [];\n    for (let i = 0; i < maxRank + 1; i++) {\n        layers.push([]);\n    }\n    const orderedVs = simpleNodes.sort((a, b) => g.getNode(a.id).data.rank - g.getNode(b.id).data.rank);\n    // const orderedVs = _.sortBy(simpleNodes, function(v) { return g.node(v)!.rank; });\n    // 有fixOrder的，直接排序好放进去\n    const beforeSort = orderedVs.filter((n) => {\n        return g.getNode(n.id).data.fixorder !== undefined;\n    });\n    const fixOrderNodes = beforeSort.sort((a, b) => g.getNode(a.id).data.fixorder - g.getNode(b.id).data.fixorder);\n    fixOrderNodes === null || fixOrderNodes === void 0 ? void 0 : fixOrderNodes.forEach((n) => {\n        if (!isNaN(g.getNode(n.id).data.rank)) {\n            layers[g.getNode(n.id).data.rank].push(n.id);\n        }\n        visited[n.id] = true;\n    });\n    orderedVs === null || orderedVs === void 0 ? void 0 : orderedVs.forEach((n) => g.dfsTree(n.id, (node) => {\n        if (visited.hasOwnProperty(node.id))\n            return true;\n        visited[node.id] = true;\n        if (!isNaN(node.data.rank)) {\n            layers[node.data.rank].push(node.id);\n        }\n    }));\n    return layers;\n};\n\nexport { initOrder };\n//# sourceMappingURL=init-order.js.map\n"],"names":["initOrder","g","visited","simpleNodes","nodeRanks","v","_a","maxRank","layers","i","orderedVs","a","b","fixOrderNodes","n","node"],"mappings":"AAWK,MAACA,IAAY,CAACC,MAAM;AACrB,QAAMC,IAAU,CAAA,GAIVC,IAAcF,EAAE,YAAW,GAC3BG,IAAYD,EAAY,IAAI,CAACE,MAAM;AAAE,QAAIC;AAAI,YAAQA,IAAKD,EAAE,KAAK,UAAU,QAAQC,MAAO,SAASA,IAAK;AAAA,EAAW,CAAC,GACpHC,IAAU,KAAK,IAAI,GAAGH,CAAS,GAC/BI,IAAS,CAAA;AACf,WAASC,IAAI,GAAGA,IAAIF,IAAU,GAAGE;AAC7B,IAAAD,EAAO,KAAK,EAAE;AAElB,QAAME,IAAYP,EAAY,KAAK,CAACQ,GAAGC,MAAMX,EAAE,QAAQU,EAAE,EAAE,EAAE,KAAK,OAAOV,EAAE,QAAQW,EAAE,EAAE,EAAE,KAAK,IAAI,GAM5FC,IAHaH,EAAU,OAAO,CAACI,MAC1Bb,EAAE,QAAQa,EAAE,EAAE,EAAE,KAAK,aAAa,MAC5C,EACgC,KAAK,CAACH,GAAGC,MAAMX,EAAE,QAAQU,EAAE,EAAE,EAAE,KAAK,WAAWV,EAAE,QAAQW,EAAE,EAAE,EAAE,KAAK,QAAQ;AAC7G,SAAAC,KAAkB,QAA4CA,EAAc,QAAQ,CAACC,MAAM;AACvF,IAAK,MAAMb,EAAE,QAAQa,EAAE,EAAE,EAAE,KAAK,IAAI,KAChCN,EAAOP,EAAE,QAAQa,EAAE,EAAE,EAAE,KAAK,IAAI,EAAE,KAAKA,EAAE,EAAE,GAE/CZ,EAAQY,EAAE,EAAE,IAAI;AAAA,EACpB,CAAC,GACDJ,KAAc,QAAwCA,EAAU,QAAQ,CAACI,MAAMb,EAAE,QAAQa,EAAE,IAAI,CAACC,MAAS;AACrG,QAAIb,EAAQ,eAAea,EAAK,EAAE;AAC9B,aAAO;AACX,IAAAb,EAAQa,EAAK,EAAE,IAAI,IACd,MAAMA,EAAK,KAAK,IAAI,KACrBP,EAAOO,EAAK,KAAK,IAAI,EAAE,KAAKA,EAAK,EAAE;AAAA,EAE3C,CAAC,CAAC,GACKP;AACX;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/order/resolve-conflicts.js

@@ -0,0 +1,51 @@
+const h = (n, o) => {
+  var t, l, r;
+  const c = {};
+  n == null || n.forEach((d, e) => {
+    c[d.v] = {
+      i: e,
+      indegree: 0,
+      in: [],
+      out: [],
+      vs: [d.v]
+    };
+    const i = c[d.v];
+    d.barycenter !== void 0 && (i.barycenter = d.barycenter, i.weight = d.weight);
+  }), (t = o.getAllEdges()) === null || t === void 0 || t.forEach((d) => {
+    const e = c[d.source], i = c[d.target];
+    e !== void 0 && i !== void 0 && (i.indegree++, e.out.push(c[d.target]));
+  });
+  const v = (r = (l = Object.values(c)).filter) === null || r === void 0 ? void 0 : r.call(l, (d) => !d.indegree);
+  return a(v);
+}, a = (n) => {
+  var o, t;
+  const l = [], r = (e) => (i) => {
+    i.merged || (i.barycenter === void 0 || e.barycenter === void 0 || i.barycenter >= e.barycenter) && f(e, i);
+  }, c = (e) => (i) => {
+    i.in.push(e), --i.indegree === 0 && n.push(i);
+  };
+  for (; n != null && n.length; ) {
+    const e = n.pop();
+    l.push(e), (o = e.in.reverse()) === null || o === void 0 || o.forEach((i) => r(e)(i)), (t = e.out) === null || t === void 0 || t.forEach((i) => c(e)(i));
+  }
+  const v = l.filter((e) => !e.merged), d = [
+    "vs",
+    "i",
+    "barycenter",
+    "weight"
+  ];
+  return v.map((e) => {
+    const i = {};
+    return d == null || d.forEach((s) => {
+      e[s] !== void 0 && (i[s] = e[s]);
+    }), i;
+  });
+}, f = (n, o) => {
+  var t;
+  let l = 0, r = 0;
+  n.weight && (l += n.barycenter * n.weight, r += n.weight), o.weight && (l += o.barycenter * o.weight, r += o.weight), n.vs = (t = o.vs) === null || t === void 0 ? void 0 : t.concat(n.vs), n.barycenter = l / r, n.weight = r, n.i = Math.min(o.i, n.i), o.merged = !0;
+};
+export {
+  h as default
+};
+//# sourceMappingURL=resolve-conflicts.js.map

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/order/resolve-conflicts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"resolve-conflicts.js","sources":["../../../../../../../../node_modules/@antv/layout/lib/algorithm/antv-dagre/order/resolve-conflicts.js"],"sourcesContent":["/*\n * Given a list of entries of the form {v, barycenter, weight} and a\n * constraint graph this function will resolve any conflicts between the\n * constraint graph and the barycenters for the entries. If the barycenters for\n * an entry would violate a constraint in the constraint graph then we coalesce\n * the nodes in the conflict into a new node that respects the contraint and\n * aggregates barycenter and weight information.\n *\n * This implementation is based on the description in Forster, \"A Fast and\n * Simple Hueristic for Constrained Two-Level Crossing Reduction,\" thought it\n * differs in some specific details.\n *\n * Pre-conditions:\n *\n *    1. Each entry has the form {v, barycenter, weight}, or if the node has\n *       no barycenter, then {v}.\n *\n * Returns:\n *\n *    A new list of entries of the form {vs, i, barycenter, weight}. The list\n *    `vs` may either be a singleton or it may be an aggregation of nodes\n *    ordered such that they do not violate constraints from the constraint\n *    graph. The property `i` is the lowest original index of any of the\n *    elements in `vs`.\n */\nconst resolveConflicts = (entries, cg) => {\n    var _a, _b, _c;\n    const mappedEntries = {};\n    entries === null || entries === void 0 ? void 0 : entries.forEach((entry, i) => {\n        mappedEntries[entry.v] = {\n            i,\n            indegree: 0,\n            in: [],\n            out: [],\n            vs: [entry.v],\n        };\n        const tmp = mappedEntries[entry.v];\n        if (entry.barycenter !== undefined) {\n            tmp.barycenter = entry.barycenter;\n            tmp.weight = entry.weight;\n        }\n    });\n    (_a = cg.getAllEdges()) === null || _a === void 0 ? void 0 : _a.forEach((e) => {\n        const entryV = mappedEntries[e.source];\n        const entryW = mappedEntries[e.target];\n        if (entryV !== undefined && entryW !== undefined) {\n            entryW.indegree++;\n            entryV.out.push(mappedEntries[e.target]);\n        }\n    });\n    const sourceSet = (_c = (_b = Object.values(mappedEntries)).filter) === null || _c === void 0 ? void 0 : _c.call(_b, (entry) => !entry.indegree);\n    return doResolveConflicts(sourceSet);\n};\nconst doResolveConflicts = (sourceSet) => {\n    var _a, _b;\n    const entries = [];\n    const handleIn = (vEntry) => {\n        return (uEntry) => {\n            if (uEntry.merged)\n                return;\n            if (uEntry.barycenter === undefined ||\n                vEntry.barycenter === undefined ||\n                uEntry.barycenter >= vEntry.barycenter) {\n                mergeEntries(vEntry, uEntry);\n            }\n        };\n    };\n    const handleOut = (vEntry) => {\n        return (wEntry) => {\n            wEntry['in'].push(vEntry);\n            if (--wEntry.indegree === 0) {\n                sourceSet.push(wEntry);\n            }\n        };\n    };\n    while (sourceSet === null || sourceSet === void 0 ? void 0 : sourceSet.length) {\n        const entry = sourceSet.pop();\n        entries.push(entry);\n        (_a = entry['in'].reverse()) === null || _a === void 0 ? void 0 : _a.forEach((e) => handleIn(entry)(e));\n        (_b = entry.out) === null || _b === void 0 ? void 0 : _b.forEach((e) => handleOut(entry)(e));\n    }\n    const filtered = entries.filter((entry) => !entry.merged);\n    const keys = [\n        'vs',\n        'i',\n        'barycenter',\n        'weight',\n    ];\n    return filtered.map((entry) => {\n        const picked = {};\n        keys === null || keys === void 0 ? void 0 : keys.forEach((key) => {\n            if (entry[key] === undefined)\n                return;\n            picked[key] = entry[key];\n        });\n        return picked;\n    });\n};\nconst mergeEntries = (target, source) => {\n    var _a;\n    let sum = 0;\n    let weight = 0;\n    if (target.weight) {\n        sum += target.barycenter * target.weight;\n        weight += target.weight;\n    }\n    if (source.weight) {\n        sum += source.barycenter * source.weight;\n        weight += source.weight;\n    }\n    target.vs = (_a = source.vs) === null || _a === void 0 ? void 0 : _a.concat(target.vs);\n    target.barycenter = sum / weight;\n    target.weight = weight;\n    target.i = Math.min(source.i, target.i);\n    source.merged = true;\n};\n\nexport { resolveConflicts as default };\n//# sourceMappingURL=resolve-conflicts.js.map\n"],"names":["resolveConflicts","entries","cg","_a","_b","_c","mappedEntries","entry","i","tmp","e","entryV","entryW","sourceSet","doResolveConflicts","handleIn","vEntry","uEntry","mergeEntries","handleOut","wEntry","filtered","keys","picked","key","target","source","sum","weight"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/order/sort-subgraph.js

@@ -0,0 +1,40 @@
+import { barycenter as P } from "./barycenter.js";
+import _ from "./resolve-conflicts.js";
+import { sort as x } from "./sort.js";
+const C = (e, o, a, n, f, i) => {
+  var b, u, h, w;
+  let c = e.getChildren(o).map((r) => r.id);
+  const l = e.getNode(o), s = l ? l.data.borderLeft : void 0, y = l ? l.data.borderRight : void 0, m = {};
+  s && (c = c == null ? void 0 : c.filter((r) => r !== s && r !== y));
+  const v = P(e, c || []);
+  v == null || v.forEach((r) => {
+    var d;
+    if (!((d = e.getChildren(r.v)) === null || d === void 0) && d.length) {
+      const g = C(e, r.v, a, n, i);
+      m[r.v] = g, g.hasOwnProperty("barycenter") && N(r, g);
+    }
+  });
+  const p = _(v, a);
+  E(p, m), (b = p.filter((r) => r.vs.length > 0)) === null || b === void 0 || b.forEach((r) => {
+    const d = e.getNode(r.vs[0]);
+    d && (r.fixorder = d.data.fixorder, r.order = d.data.order);
+  });
+  const t = x(p, n, f, i);
+  if (s && (t.vs = [s, t.vs, y].flat(), !((u = e.getPredecessors(s)) === null || u === void 0) && u.length)) {
+    const r = e.getNode(((h = e.getPredecessors(s)) === null || h === void 0 ? void 0 : h[0].id) || ""), d = e.getNode(((w = e.getPredecessors(y)) === null || w === void 0 ? void 0 : w[0].id) || "");
+    t.hasOwnProperty("barycenter") || (t.barycenter = 0, t.weight = 0), t.barycenter = (t.barycenter * t.weight + r.data.order + d.data.order) / (t.weight + 2), t.weight += 2;
+  }
+  return t;
+}, E = (e, o) => {
+  e == null || e.forEach((a) => {
+    var n;
+    const f = (n = a.vs) === null || n === void 0 ? void 0 : n.map((i) => o[i] ? o[i].vs : i);
+    a.vs = f.flat();
+  });
+}, N = (e, o) => {
+  e.barycenter !== void 0 ? (e.barycenter = (e.barycenter * e.weight + o.barycenter * o.weight) / (e.weight + o.weight), e.weight += o.weight) : (e.barycenter = o.barycenter, e.weight = o.weight);
+};
+export {
+  C as sortSubgraph
+};
+//# sourceMappingURL=sort-subgraph.js.map

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/order/sort-subgraph.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort-subgraph.js","sources":["../../../../../../../../node_modules/@antv/layout/lib/algorithm/antv-dagre/order/sort-subgraph.js"],"sourcesContent":["import { barycenter } from './barycenter.js';\nimport resolveConflicts from './resolve-conflicts.js';\nimport { sort } from './sort.js';\n\nconst sortSubgraph = (g, v, cg, biasRight, usePrev, keepNodeOrder) => {\n    var _a, _b, _c, _d;\n    let movable = g.getChildren(v).map((n) => n.id);\n    // fixorder的点不参与排序（这个方案不合适，只排了新增节点，和原来的分离）\n    const node = g.getNode(v);\n    const bl = node ? node.data.borderLeft : undefined;\n    const br = node ? node.data.borderRight : undefined;\n    const subgraphs = {};\n    if (bl) {\n        movable = movable === null || movable === void 0 ? void 0 : movable.filter((w) => {\n            return w !== bl && w !== br;\n        });\n    }\n    const barycenters = barycenter(g, movable || []);\n    barycenters === null || barycenters === void 0 ? void 0 : barycenters.forEach((entry) => {\n        var _a;\n        if ((_a = g.getChildren(entry.v)) === null || _a === void 0 ? void 0 : _a.length) {\n            const subgraphResult = sortSubgraph(g, entry.v, cg, biasRight, keepNodeOrder);\n            subgraphs[entry.v] = subgraphResult;\n            if (subgraphResult.hasOwnProperty('barycenter')) {\n                mergeBarycenters(entry, subgraphResult);\n            }\n        }\n    });\n    const entries = resolveConflicts(barycenters, cg);\n    expandSubgraphs(entries, subgraphs);\n    // 添加fixorder信息到entries里边\n    // TODO: 不考虑复合情况，只用第一个点的fixorder信息，后续考虑更完备的实现\n    (_a = entries\n        .filter((e) => e.vs.length > 0)) === null || _a === void 0 ? void 0 : _a.forEach((e) => {\n        const node = g.getNode(e.vs[0]);\n        if (node) {\n            e.fixorder = node.data.fixorder;\n            e.order = node.data.order;\n        }\n    });\n    const result = sort(entries, biasRight, usePrev, keepNodeOrder);\n    if (bl) {\n        result.vs = [bl, result.vs, br].flat();\n        if ((_b = g.getPredecessors(bl)) === null || _b === void 0 ? void 0 : _b.length) {\n            const blPred = g.getNode(((_c = g.getPredecessors(bl)) === null || _c === void 0 ? void 0 : _c[0].id) || '');\n            const brPred = g.getNode(((_d = g.getPredecessors(br)) === null || _d === void 0 ? void 0 : _d[0].id) || '');\n            if (!result.hasOwnProperty('barycenter')) {\n                result.barycenter = 0;\n                result.weight = 0;\n            }\n            result.barycenter =\n                (result.barycenter * result.weight +\n                    blPred.data.order +\n                    brPred.data.order) /\n                    (result.weight + 2);\n            result.weight += 2;\n        }\n    }\n    return result;\n};\nconst expandSubgraphs = (entries, subgraphs) => {\n    entries === null || entries === void 0 ? void 0 : entries.forEach((entry) => {\n        var _a;\n        const vss = (_a = entry.vs) === null || _a === void 0 ? void 0 : _a.map((v) => {\n            if (subgraphs[v]) {\n                return subgraphs[v].vs;\n            }\n            return v;\n        });\n        entry.vs = vss.flat();\n    });\n};\nconst mergeBarycenters = (target, other) => {\n    if (target.barycenter !== undefined) {\n        target.barycenter =\n            (target.barycenter * target.weight + other.barycenter * other.weight) /\n                (target.weight + other.weight);\n        target.weight += other.weight;\n    }\n    else {\n        target.barycenter = other.barycenter;\n        target.weight = other.weight;\n    }\n};\n\nexport { sortSubgraph };\n//# sourceMappingURL=sort-subgraph.js.map\n"],"names":["sortSubgraph","g","v","cg","biasRight","usePrev","keepNodeOrder","_a","_b","_c","_d","movable","n","node","bl","br","subgraphs","w","barycenters","barycenter","entry","subgraphResult","mergeBarycenters","entries","resolveConflicts","expandSubgraphs","e","result","sort","blPred","brPred","vss","target","other"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/order/sort.js

@@ -0,0 +1,39 @@
+import { partition as p } from "../util.js";
+const w = (d, o, e, r) => {
+  const n = p(d, (i) => {
+    const t = i.hasOwnProperty("fixorder") && !isNaN(i.fixorder);
+    return r ? !t && i.hasOwnProperty("barycenter") : t || i.hasOwnProperty("barycenter");
+  }), s = n.lhs, c = n.rhs.sort((i, t) => -i.i - -t.i), u = [];
+  let h = 0, f = 0, a = 0;
+  s == null || s.sort(x(!!o, !!e)), a = v(u, c, a), s == null || s.forEach((i) => {
+    var t;
+    a += (t = i.vs) === null || t === void 0 ? void 0 : t.length, u.push(i.vs), h += i.barycenter * i.weight, f += i.weight, a = v(u, c, a);
+  });
+  const l = {
+    vs: u.flat()
+  };
+  return f && (l.barycenter = h / f, l.weight = f), l;
+}, v = (d, o, e) => {
+  let r = e, n;
+  for (; o.length && (n = o[o.length - 1]).i <= r; )
+    o.pop(), d == null || d.push(n.vs), r++;
+  return r;
+}, x = (d, o) => (e, r) => {
+  if (e.fixorder !== void 0 && r.fixorder !== void 0)
+    return e.fixorder - r.fixorder;
+  if (e.barycenter < r.barycenter)
+    return -1;
+  if (e.barycenter > r.barycenter)
+    return 1;
+  if (o && e.order !== void 0 && r.order !== void 0) {
+    if (e.order < r.order)
+      return -1;
+    if (e.order > r.order)
+      return 1;
+  }
+  return d ? r.i - e.i : e.i - r.i;
+};
+export {
+  w as sort
+};
+//# sourceMappingURL=sort.js.map

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/order/sort.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort.js","sources":["../../../../../../../../node_modules/@antv/layout/lib/algorithm/antv-dagre/order/sort.js"],"sourcesContent":["import { partition } from '../util.js';\n\nconst sort = (entries, biasRight, usePrev, keepNodeOrder) => {\n    const parts = partition(entries, (entry) => {\n        const hasFixOrder = entry.hasOwnProperty('fixorder') && !isNaN(entry.fixorder);\n        if (keepNodeOrder) {\n            return !hasFixOrder && entry.hasOwnProperty('barycenter');\n        }\n        // NOTE: 有fixorder的也可以排\n        return hasFixOrder || entry.hasOwnProperty('barycenter');\n    });\n    const sortable = parts.lhs;\n    const unsortable = parts.rhs.sort((a, b) => -a.i - -b.i);\n    const vs = [];\n    let sum = 0;\n    let weight = 0;\n    let vsIndex = 0;\n    sortable === null || sortable === void 0 ? void 0 : sortable.sort(compareWithBias(!!biasRight, !!usePrev));\n    vsIndex = consumeUnsortable(vs, unsortable, vsIndex);\n    sortable === null || sortable === void 0 ? void 0 : sortable.forEach((entry) => {\n        var _a;\n        vsIndex += (_a = entry.vs) === null || _a === void 0 ? void 0 : _a.length;\n        vs.push(entry.vs);\n        sum += entry.barycenter * entry.weight;\n        weight += entry.weight;\n        vsIndex = consumeUnsortable(vs, unsortable, vsIndex);\n    });\n    const result = {\n        vs: vs.flat(),\n    };\n    if (weight) {\n        result.barycenter = sum / weight;\n        result.weight = weight;\n    }\n    return result;\n};\nconst consumeUnsortable = (vs, unsortable, index) => {\n    let iindex = index;\n    let last;\n    while (unsortable.length &&\n        (last = unsortable[unsortable.length - 1]).i <= iindex) {\n        unsortable.pop();\n        vs === null || vs === void 0 ? void 0 : vs.push(last.vs);\n        iindex++;\n    }\n    return iindex;\n};\n/**\n * 配置是否考虑使用之前的布局结果\n */\nconst compareWithBias = (bias, usePrev) => {\n    return (entryV, entryW) => {\n        // 排序的时候先判断fixorder，不行再判断重心\n        if (entryV.fixorder !== undefined && entryW.fixorder !== undefined) {\n            return entryV.fixorder - entryW.fixorder;\n        }\n        if (entryV.barycenter < entryW.barycenter) {\n            return -1;\n        }\n        if (entryV.barycenter > entryW.barycenter) {\n            return 1;\n        }\n        // 重心相同，考虑之前排好的顺序\n        if (usePrev && entryV.order !== undefined && entryW.order !== undefined) {\n            if (entryV.order < entryW.order) {\n                return -1;\n            }\n            if (entryV.order > entryW.order) {\n                return 1;\n            }\n        }\n        return !bias ? entryV.i - entryW.i : entryW.i - entryV.i;\n    };\n};\n\nexport { sort };\n//# sourceMappingURL=sort.js.map\n"],"names":["sort","entries","biasRight","usePrev","keepNodeOrder","parts","partition","entry","hasFixOrder","sortable","unsortable","a","b","vs","sum","weight","vsIndex","compareWithBias","consumeUnsortable","_a","result","index","iindex","last","bias","entryV","entryW"],"mappings":";AAEK,MAACA,IAAO,CAACC,GAASC,GAAWC,GAASC,MAAkB;AACzD,QAAMC,IAAQC,EAAUL,GAAS,CAACM,MAAU;AACxC,UAAMC,IAAcD,EAAM,eAAe,UAAU,KAAK,CAAC,MAAMA,EAAM,QAAQ;AAC7E,WAAIH,IACO,CAACI,KAAeD,EAAM,eAAe,YAAY,IAGrDC,KAAeD,EAAM,eAAe,YAAY;AAAA,EAC3D,CAAC,GACKE,IAAWJ,EAAM,KACjBK,IAAaL,EAAM,IAAI,KAAK,CAACM,GAAGC,MAAM,CAACD,EAAE,IAAI,CAACC,EAAE,CAAC,GACjDC,IAAK,CAAA;AACX,MAAIC,IAAM,GACNC,IAAS,GACTC,IAAU;AACd,EAAAP,KAAa,QAAuCA,EAAS,KAAKQ,EAAgB,CAAC,CAACf,GAAW,CAAC,CAACC,CAAO,CAAC,GACzGa,IAAUE,EAAkBL,GAAIH,GAAYM,CAAO,GACnDP,KAAa,QAAuCA,EAAS,QAAQ,CAACF,MAAU;AAC5E,QAAIY;AACJ,IAAAH,MAAYG,IAAKZ,EAAM,QAAQ,QAAQY,MAAO,SAAS,SAASA,EAAG,QACnEN,EAAG,KAAKN,EAAM,EAAE,GAChBO,KAAOP,EAAM,aAAaA,EAAM,QAChCQ,KAAUR,EAAM,QAChBS,IAAUE,EAAkBL,GAAIH,GAAYM,CAAO;AAAA,EACvD,CAAC;AACD,QAAMI,IAAS;AAAA,IACX,IAAIP,EAAG,KAAI;AAAA,EACnB;AACI,SAAIE,MACAK,EAAO,aAAaN,IAAMC,GAC1BK,EAAO,SAASL,IAEbK;AACX,GACMF,IAAoB,CAACL,GAAIH,GAAYW,MAAU;AACjD,MAAIC,IAASD,GACTE;AACJ,SAAOb,EAAW,WACba,IAAOb,EAAWA,EAAW,SAAS,CAAC,GAAG,KAAKY;AAChD,IAAAZ,EAAW,IAAG,GACdG,KAAO,QAAiCA,EAAG,KAAKU,EAAK,EAAE,GACvDD;AAEJ,SAAOA;AACX,GAIML,IAAkB,CAACO,GAAMrB,MACpB,CAACsB,GAAQC,MAAW;AAEvB,MAAID,EAAO,aAAa,UAAaC,EAAO,aAAa;AACrD,WAAOD,EAAO,WAAWC,EAAO;AAEpC,MAAID,EAAO,aAAaC,EAAO;AAC3B,WAAO;AAEX,MAAID,EAAO,aAAaC,EAAO;AAC3B,WAAO;AAGX,MAAIvB,KAAWsB,EAAO,UAAU,UAAaC,EAAO,UAAU,QAAW;AACrE,QAAID,EAAO,QAAQC,EAAO;AACtB,aAAO;AAEX,QAAID,EAAO,QAAQC,EAAO;AACtB,aAAO;AAAA,EAEf;AACA,SAAQF,IAA6BE,EAAO,IAAID,EAAO,IAAxCA,EAAO,IAAIC,EAAO;AACrC;","x_google_ignoreList":[0]}

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/parent-dummy-chains.js

@@ -0,0 +1,48 @@
+const w = (a) => {
+  const n = {};
+  let o = 0;
+  const d = (e) => {
+    const i = o;
+    a.getChildren(e).forEach((l) => d(l.id)), n[e] = { low: i, lim: o++ };
+  };
+  return a.getRoots().forEach((e) => d(e.id)), n;
+}, m = (a, n, o, d) => {
+  var e, i;
+  const l = [], c = [], s = Math.min(n[o].low, n[d].low), u = Math.max(n[o].lim, n[d].lim);
+  let t, f;
+  t = o;
+  do
+    t = (e = a.getParent(t)) === null || e === void 0 ? void 0 : e.id, l.push(t);
+  while (t && (n[t].low > s || u > n[t].lim));
+  for (f = t, t = d; t && t !== f; )
+    c.push(t), t = (i = a.getParent(t)) === null || i === void 0 ? void 0 : i.id;
+  return { lca: f, path: l.concat(c.reverse()) };
+}, g = (a, n) => {
+  const o = w(a);
+  n.forEach((d) => {
+    var e, i;
+    let l = d, c = a.getNode(l);
+    const s = c.data.originalEdge;
+    if (!s)
+      return;
+    const u = m(a, o, s.source, s.target), t = u.path, f = u.lca;
+    let h = 0, r = t[h], v = !0;
+    for (; l !== s.target; ) {
+      if (c = a.getNode(l), v) {
+        for (; r !== f && ((e = a.getNode(r)) === null || e === void 0 ? void 0 : e.data.maxRank) < c.data.rank; )
+          h++, r = t[h];
+        r === f && (v = !1);
+      }
+      if (!v) {
+        for (; h < t.length - 1 && ((i = a.getNode(t[h + 1])) === null || i === void 0 ? void 0 : i.data.minRank) <= c.data.rank; )
+          h++;
+        r = t[h];
+      }
+      a.hasNode(r) && a.setParent(l, r), l = a.getSuccessors(l)[0].id;
+    }
+  });
+};
+export {
+  g as parentDummyChains
+};
+//# sourceMappingURL=parent-dummy-chains.js.map

package/dist/node_modules/@antv/layout/lib/algorithm/antv-dagre/parent-dummy-chains.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"parent-dummy-chains.js","sources":["../../../../../../../node_modules/@antv/layout/lib/algorithm/antv-dagre/parent-dummy-chains.js"],"sourcesContent":["// deep first search with both order low for pre, lim for post\nconst dfsBothOrder = (g) => {\n    const result = {};\n    let lim = 0;\n    const dfs = (v) => {\n        const low = lim;\n        g.getChildren(v).forEach((n) => dfs(n.id));\n        result[v] = { low, lim: lim++ };\n    };\n    g.getRoots().forEach((n) => dfs(n.id));\n    return result;\n};\n// Find a path from v to w through the lowest common ancestor (LCA). Return the\n// full path and the LCA.\nconst findPath = (g, postorderNums, v, w) => {\n    var _a, _b;\n    const vPath = [];\n    const wPath = [];\n    const low = Math.min(postorderNums[v].low, postorderNums[w].low);\n    const lim = Math.max(postorderNums[v].lim, postorderNums[w].lim);\n    let parent;\n    let lca;\n    // Traverse up from v to find the LCA\n    parent = v;\n    do {\n        parent = (_a = g.getParent(parent)) === null || _a === void 0 ? void 0 : _a.id;\n        vPath.push(parent);\n    } while (parent &&\n        (postorderNums[parent].low > low || lim > postorderNums[parent].lim));\n    lca = parent;\n    // Traverse from w to LCA\n    parent = w;\n    while (parent && parent !== lca) {\n        wPath.push(parent);\n        parent = (_b = g.getParent(parent)) === null || _b === void 0 ? void 0 : _b.id;\n    }\n    return { lca, path: vPath.concat(wPath.reverse()) };\n};\nconst parentDummyChains = (g, dummyChains) => {\n    const postorderNums = dfsBothOrder(g);\n    dummyChains.forEach((startV) => {\n        var _a, _b;\n        let v = startV;\n        let node = g.getNode(v);\n        const originalEdge = node.data.originalEdge;\n        if (!originalEdge)\n            return;\n        const pathData = findPath(g, postorderNums, originalEdge.source, originalEdge.target);\n        const path = pathData.path;\n        const lca = pathData.lca;\n        let pathIdx = 0;\n        let pathV = path[pathIdx];\n        let ascending = true;\n        while (v !== originalEdge.target) {\n            node = g.getNode(v);\n            if (ascending) {\n                while (pathV !== lca &&\n                    ((_a = g.getNode(pathV)) === null || _a === void 0 ? void 0 : _a.data.maxRank) < node.data.rank) {\n                    pathIdx++;\n                    pathV = path[pathIdx];\n                }\n                if (pathV === lca) {\n                    ascending = false;\n                }\n            }\n            if (!ascending) {\n                while (pathIdx < path.length - 1 &&\n                    ((_b = g.getNode(path[pathIdx + 1])) === null || _b === void 0 ? void 0 : _b.data.minRank) <= node.data.rank) {\n                    pathIdx++;\n                }\n                pathV = path[pathIdx];\n            }\n            if (g.hasNode(pathV)) {\n                g.setParent(v, pathV);\n            }\n            v = g.getSuccessors(v)[0].id;\n        }\n    });\n};\n\nexport { parentDummyChains };\n//# sourceMappingURL=parent-dummy-chains.js.map\n"],"names":["dfsBothOrder","g","result","lim","dfs","v","low","n","findPath","postorderNums","w","_a","_b","vPath","wPath","parent","lca","parentDummyChains","dummyChains","startV","node","originalEdge","pathData","path","pathIdx","pathV","ascending"],"mappings":"AACA,MAAMA,IAAe,CAACC,MAAM;AACxB,QAAMC,IAAS,CAAA;AACf,MAAIC,IAAM;AACV,QAAMC,IAAM,CAACC,MAAM;AACf,UAAMC,IAAMH;AACZ,IAAAF,EAAE,YAAYI,CAAC,EAAE,QAAQ,CAACE,MAAMH,EAAIG,EAAE,EAAE,CAAC,GACzCL,EAAOG,CAAC,IAAI,EAAE,KAAAC,GAAK,KAAKH,IAAK;AAAA,EACjC;AACA,SAAAF,EAAE,SAAQ,EAAG,QAAQ,CAACM,MAAMH,EAAIG,EAAE,EAAE,CAAC,GAC9BL;AACX,GAGMM,IAAW,CAACP,GAAGQ,GAAeJ,GAAGK,MAAM;AACzC,MAAIC,GAAIC;AACR,QAAMC,IAAQ,CAAA,GACRC,IAAQ,CAAA,GACRR,IAAM,KAAK,IAAIG,EAAcJ,CAAC,EAAE,KAAKI,EAAcC,CAAC,EAAE,GAAG,GACzDP,IAAM,KAAK,IAAIM,EAAcJ,CAAC,EAAE,KAAKI,EAAcC,CAAC,EAAE,GAAG;AAC/D,MAAIK,GACAC;AAEJ,EAAAD,IAASV;AACT;AACI,IAAAU,KAAUJ,IAAKV,EAAE,UAAUc,CAAM,OAAO,QAAQJ,MAAO,SAAS,SAASA,EAAG,IAC5EE,EAAM,KAAKE,CAAM;AAAA,SACZA,MACJN,EAAcM,CAAM,EAAE,MAAMT,KAAOH,IAAMM,EAAcM,CAAM,EAAE;AAIpE,OAHAC,IAAMD,GAENA,IAASL,GACFK,KAAUA,MAAWC;AACxB,IAAAF,EAAM,KAAKC,CAAM,GACjBA,KAAUH,IAAKX,EAAE,UAAUc,CAAM,OAAO,QAAQH,MAAO,SAAS,SAASA,EAAG;AAEhF,SAAO,EAAE,KAAAI,GAAK,MAAMH,EAAM,OAAOC,EAAM,QAAO,CAAE,EAAC;AACrD,GACMG,IAAoB,CAAChB,GAAGiB,MAAgB;AAC1C,QAAMT,IAAgBT,EAAaC,CAAC;AACpC,EAAAiB,EAAY,QAAQ,CAACC,MAAW;AAC5B,QAAIR,GAAIC;AACR,QAAIP,IAAIc,GACJC,IAAOnB,EAAE,QAAQI,CAAC;AACtB,UAAMgB,IAAeD,EAAK,KAAK;AAC/B,QAAI,CAACC;AACD;AACJ,UAAMC,IAAWd,EAASP,GAAGQ,GAAeY,EAAa,QAAQA,EAAa,MAAM,GAC9EE,IAAOD,EAAS,MAChBN,IAAMM,EAAS;AACrB,QAAIE,IAAU,GACVC,IAAQF,EAAKC,CAAO,GACpBE,IAAY;AAChB,WAAOrB,MAAMgB,EAAa,UAAQ;AAE9B,UADAD,IAAOnB,EAAE,QAAQI,CAAC,GACdqB,GAAW;AACX,eAAOD,MAAUT,OACXL,IAAKV,EAAE,QAAQwB,CAAK,OAAO,QAAQd,MAAO,SAAS,SAASA,EAAG,KAAK,WAAWS,EAAK,KAAK;AAC3F,UAAAI,KACAC,IAAQF,EAAKC,CAAO;AAExB,QAAIC,MAAUT,MACVU,IAAY;AAAA,MAEpB;AACA,UAAI,CAACA,GAAW;AACZ,eAAOF,IAAUD,EAAK,SAAS,OACzBX,IAAKX,EAAE,QAAQsB,EAAKC,IAAU,CAAC,CAAC,OAAO,QAAQZ,MAAO,SAAS,SAASA,EAAG,KAAK,YAAYQ,EAAK,KAAK;AACxG,UAAAI;AAEJ,QAAAC,IAAQF,EAAKC,CAAO;AAAA,MACxB;AACA,MAAIvB,EAAE,QAAQwB,CAAK,KACfxB,EAAE,UAAUI,GAAGoB,CAAK,GAExBpB,IAAIJ,EAAE,cAAcI,CAAC,EAAE,CAAC,EAAE;AAAA,IAC9B;AAAA,EACJ,CAAC;AACL;","x_google_ignoreList":[0]}