@seed-ship/mcp-ui-solid 5.6.0 → 6.0.0

package/dist/node_modules/.pnpm/@antv_layout@2.0.0/node_modules/@antv/layout/lib/algorithm/antv-dagre/rank/feasible-tree.js

@@ -0,0 +1,101 @@
+import { DagreGraph } from "../graph.js";
+import { minBy } from "../util.js";
+import { slack } from "./util.js";
+const feasibleTree = (g) => {
+  const t = new DagreGraph({
+    tree: []
+  });
+  const start = g.getAllNodes()[0];
+  const size = g.getAllNodes().length;
+  t.addNode(start);
+  let edge;
+  let delta;
+  while (tightTree(t, g) < size) {
+    edge = findMinSlackEdge(t, g);
+    delta = t.hasNode(edge.source) ? slack(g, edge) : -slack(g, edge);
+    shiftRanks(t, g, delta);
+  }
+  return t;
+};
+const tightTree = (t, g) => {
+  const dfs = (v) => {
+    g.getRelatedEdges(v, "both").forEach((e) => {
+      const edgeV = e.source;
+      const w = v === edgeV ? e.target : edgeV;
+      if (!t.hasNode(w) && !slack(g, e)) {
+        t.addNode({
+          id: w,
+          data: {}
+        });
+        t.addEdge({
+          id: e.id,
+          source: v,
+          target: w,
+          data: {}
+        });
+        dfs(w);
+      }
+    });
+  };
+  t.getAllNodes().forEach((n) => dfs(n.id));
+  return t.getAllNodes().length;
+};
+const feasibleTreeWithLayer = (g) => {
+  const t = new DagreGraph({ tree: [] });
+  const start = g.getAllNodes()[0];
+  const size = g.getAllNodes().length;
+  t.addNode(start);
+  let edge;
+  let delta;
+  while (tightTreeWithLayer(t, g) < size) {
+    edge = findMinSlackEdge(t, g);
+    delta = t.hasNode(edge.source) ? slack(g, edge) : -slack(g, edge);
+    shiftRanks(t, g, delta);
+  }
+  return t;
+};
+const tightTreeWithLayer = (t, g) => {
+  const dfs = (v) => {
+    var _a;
+    (_a = g.getRelatedEdges(v, "both")) === null || _a === void 0 ? void 0 : _a.forEach((e) => {
+      const edgeV = e.source;
+      const w = v === edgeV ? e.target : edgeV;
+      if (!t.hasNode(w) && (g.getNode(w).data.layer !== void 0 || !slack(g, e))) {
+        t.addNode({
+          id: w,
+          data: {}
+        });
+        t.addEdge({
+          id: e.id,
+          source: v,
+          target: w,
+          data: {}
+        });
+        dfs(w);
+      }
+    });
+  };
+  t.getAllNodes().forEach((n) => dfs(n.id));
+  return t.getAllNodes().length;
+};
+const findMinSlackEdge = (t, g) => {
+  return minBy(g.getAllEdges(), (e) => {
+    if (t.hasNode(e.source) !== t.hasNode(e.target)) {
+      return slack(g, e);
+    }
+    return Infinity;
+  });
+};
+const shiftRanks = (t, g, delta) => {
+  t.getAllNodes().forEach((tn) => {
+    const v = g.getNode(tn.id);
+    if (!v.data.rank)
+      v.data.rank = 0;
+    v.data.rank += delta;
+  });
+};
+export {
+  feasibleTree,
+  feasibleTreeWithLayer
+};
+//# sourceMappingURL=feasible-tree.js.map

package/dist/node_modules/.pnpm/@antv_layout@2.0.0/node_modules/@antv/layout/lib/algorithm/antv-dagre/rank/feasible-tree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feasible-tree.js","sources":["../../../../../../../../../../../../node_modules/.pnpm/@antv+layout@2.0.0/node_modules/@antv/layout/lib/algorithm/antv-dagre/rank/feasible-tree.js"],"sourcesContent":["import { DagreGraph } from '../graph.js';\nimport { minBy } from '../util.js';\nimport { slack } from './util.js';\n\n/*\n * Constructs a spanning tree with tight edges and adjusted the input node's\n * ranks to achieve this. A tight edge is one that is has a length that matches\n * its \"minlen\" attribute.\n *\n * The basic structure for this function is derived from Gansner, et al., \"A\n * Technique for Drawing Directed Graphs.\"\n *\n * Pre-conditions:\n *\n *    1. Graph must be a DAG.\n *    2. Graph must be connected.\n *    3. Graph must have at least one node.\n *    5. Graph nodes must have been previously assigned a \"rank\" property that\n *       respects the \"minlen\" property of incident edges.\n *    6. Graph edges must have a \"minlen\" property.\n *\n * Post-conditions:\n *\n *    - Graph nodes will have their rank adjusted to ensure that all edges are\n *      tight.\n *\n * Returns a tree (undirected graph) that is constructed using only \"tight\"\n * edges.\n */\nconst feasibleTree = (g) => {\n    const t = new DagreGraph({\n        tree: [],\n    });\n    // Choose arbitrary node from which to start our tree\n    const start = g.getAllNodes()[0];\n    const size = g.getAllNodes().length;\n    t.addNode(start);\n    let edge;\n    let delta;\n    while (tightTree(t, g) < size) {\n        edge = findMinSlackEdge(t, g);\n        delta = t.hasNode(edge.source) ? slack(g, edge) : -slack(g, edge);\n        shiftRanks(t, g, delta);\n    }\n    return t;\n};\n/*\n * Finds a maximal tree of tight edges and returns the number of nodes in the\n * tree.\n */\nconst tightTree = (t, g) => {\n    const dfs = (v) => {\n        g.getRelatedEdges(v, 'both').forEach((e) => {\n            const edgeV = e.source;\n            const w = v === edgeV ? e.target : edgeV;\n            if (!t.hasNode(w) && !slack(g, e)) {\n                t.addNode({\n                    id: w,\n                    data: {},\n                });\n                t.addEdge({\n                    id: e.id,\n                    source: v,\n                    target: w,\n                    data: {},\n                });\n                dfs(w);\n            }\n        });\n    };\n    t.getAllNodes().forEach((n) => dfs(n.id));\n    return t.getAllNodes().length;\n};\n/*\n * Constructs a spanning tree with tight edges and adjusted the input node's\n * ranks to achieve this. A tight edge is one that is has a length that matches\n * its \"minlen\" attribute.\n *\n * The basic structure for this function is derived from Gansner, et al., \"A\n * Technique for Drawing Directed Graphs.\"\n *\n * Pre-conditions:\n *\n *    1. Graph must be a DAG.\n *    2. Graph must be connected.\n *    3. Graph must have at least one node.\n *    5. Graph nodes must have been previously assigned a \"rank\" property that\n *       respects the \"minlen\" property of incident edges.\n *    6. Graph edges must have a \"minlen\" property.\n *\n * Post-conditions:\n *\n *    - Graph nodes will have their rank adjusted to ensure that all edges are\n *      tight.\n *\n * Returns a tree (undirected graph) that is constructed using only \"tight\"\n * edges.\n */\nconst feasibleTreeWithLayer = (g) => {\n    const t = new DagreGraph({ tree: [] });\n    // Choose arbitrary node from which to start our tree\n    const start = g.getAllNodes()[0];\n    const size = g.getAllNodes().length;\n    t.addNode(start);\n    let edge;\n    let delta;\n    while (tightTreeWithLayer(t, g) < size) {\n        edge = findMinSlackEdge(t, g);\n        delta = t.hasNode(edge.source) ? slack(g, edge) : -slack(g, edge);\n        shiftRanks(t, g, delta);\n    }\n    return t;\n};\n/*\n * Finds a maximal tree of tight edges and returns the number of nodes in the\n * tree.\n */\nconst tightTreeWithLayer = (t, g) => {\n    const dfs = (v) => {\n        var _a;\n        (_a = g.getRelatedEdges(v, 'both')) === null || _a === void 0 ? void 0 : _a.forEach((e) => {\n            const edgeV = e.source;\n            const w = v === edgeV ? e.target : edgeV;\n            // 对于指定layer的，直接加入tight-tree，不参与调整\n            if (!t.hasNode(w) &&\n                (g.getNode(w).data.layer !== undefined || !slack(g, e))) {\n                t.addNode({\n                    id: w,\n                    data: {},\n                });\n                t.addEdge({\n                    id: e.id,\n                    source: v,\n                    target: w,\n                    data: {},\n                });\n                dfs(w);\n            }\n        });\n    };\n    t.getAllNodes().forEach((n) => dfs(n.id));\n    return t.getAllNodes().length;\n};\n/*\n * Finds the edge with the smallest slack that is incident on tree and returns\n * it.\n */\nconst findMinSlackEdge = (t, g) => {\n    return minBy(g.getAllEdges(), (e) => {\n        if (t.hasNode(e.source) !== t.hasNode(e.target)) {\n            return slack(g, e);\n        }\n        return Infinity;\n    });\n};\nconst shiftRanks = (t, g, delta) => {\n    t.getAllNodes().forEach((tn) => {\n        const v = g.getNode(tn.id);\n        if (!v.data.rank)\n            v.data.rank = 0;\n        v.data.rank += delta;\n    });\n};\n\nexport { feasibleTree, feasibleTreeWithLayer };\n//# sourceMappingURL=feasible-tree.js.map\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/@antv_layout@2.0.0/node_modules/@antv/layout/lib/algorithm/antv-dagre/rank/index.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const feasibleTree = require("./feasible-tree.cjs");
+const networkSimplex = require("./network-simplex.cjs");
+const util = require("./util.cjs");
+const rank = (g, ranker) => {
+  switch (ranker) {
+    case "network-simplex":
+      networkSimplexRanker(g);
+      break;
+    case "tight-tree":
+      tightTreeRanker(g);
+      break;
+    case "longest-path":
+      longestPathRanker(g);
+      break;
+    // default: networkSimplexRanker(g);
+    default:
+      tightTreeRanker(g);
+  }
+};
+const longestPathRanker = util.longestPath;
+const tightTreeRanker = (g) => {
+  util.longestPathWithLayer(g);
+  feasibleTree.feasibleTreeWithLayer(g);
+};
+const networkSimplexRanker = (g) => {
+  networkSimplex.networkSimplex(g);
+};
+exports.rank = rank;
+//# sourceMappingURL=index.cjs.map

package/dist/node_modules/.pnpm/@antv_layout@2.0.0/node_modules/@antv/layout/lib/algorithm/antv-dagre/rank/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","sources":["../../../../../../../../../../../../node_modules/.pnpm/@antv+layout@2.0.0/node_modules/@antv/layout/lib/algorithm/antv-dagre/rank/index.js"],"sourcesContent":["import { feasibleTreeWithLayer } from './feasible-tree.js';\nimport { networkSimplex } from './network-simplex.js';\nimport { longestPathWithLayer, longestPath } from './util.js';\n\n/*\n * Assigns a rank to each node in the input graph that respects the \"minlen\"\n * constraint specified on edges between nodes.\n *\n * This basic structure is derived from Gansner, et al., \"A Technique for\n * Drawing Directed Graphs.\"\n *\n * Pre-conditions:\n *\n *    1. Graph must be a connected DAG\n *    2. Graph nodes must be objects\n *    3. Graph edges must have \"weight\" and \"minlen\" attributes\n *\n * Post-conditions:\n *\n *    1. Graph nodes will have a \"rank\" attribute based on the results of the\n *       algorithm. Ranks can start at any index (including negative), we'll\n *       fix them up later.\n */\nconst rank = (g, ranker) => {\n    switch (ranker) {\n        case 'network-simplex':\n            networkSimplexRanker(g);\n            break;\n        case 'tight-tree':\n            tightTreeRanker(g);\n            break;\n        case 'longest-path':\n            longestPathRanker(g);\n            break;\n        // default: networkSimplexRanker(g);\n        default:\n            tightTreeRanker(g);\n    }\n};\n// A fast and simple ranker, but results are far from optimal.\nconst longestPathRanker = longestPath;\nconst tightTreeRanker = (g) => {\n    longestPathWithLayer(g);\n    feasibleTreeWithLayer(g);\n};\nconst networkSimplexRanker = (g) => {\n    networkSimplex(g);\n};\n\nexport { rank };\n//# sourceMappingURL=index.js.map\n"],"names":["longestPath","longestPathWithLayer","feasibleTreeWithLayer","networkSimplex"],"mappings":";;;;;AAuBK,MAAC,OAAO,CAAC,GAAG,WAAW;AACxB,UAAQ,QAAM;AAAA,IACV,KAAK;AACD,2BAAqB,CAAC;AACtB;AAAA,IACJ,KAAK;AACD,sBAAgB,CAAC;AACjB;AAAA,IACJ,KAAK;AACD,wBAAkB,CAAC;AACnB;AAAA;AAAA,IAEJ;AACI,sBAAgB,CAAC;AAAA,EAC7B;AACA;AAEA,MAAM,oBAAoBA,KAAAA;AAC1B,MAAM,kBAAkB,CAAC,MAAM;AAC3BC,OAAAA,qBAAqB,CAAC;AACtBC,eAAAA,sBAAsB,CAAC;AAC3B;AACA,MAAM,uBAAuB,CAAC,MAAM;AAChCC,iBAAAA,eAAe,CAAC;AACpB;;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/@antv_layout@2.0.0/node_modules/@antv/layout/lib/algorithm/antv-dagre/rank/index.js

@@ -0,0 +1,31 @@
+import { feasibleTreeWithLayer } from "./feasible-tree.js";
+import { networkSimplex } from "./network-simplex.js";
+import { longestPath, longestPathWithLayer } from "./util.js";
+const rank = (g, ranker) => {
+  switch (ranker) {
+    case "network-simplex":
+      networkSimplexRanker(g);
+      break;
+    case "tight-tree":
+      tightTreeRanker(g);
+      break;
+    case "longest-path":
+      longestPathRanker(g);
+      break;
+    // default: networkSimplexRanker(g);
+    default:
+      tightTreeRanker(g);
+  }
+};
+const longestPathRanker = longestPath;
+const tightTreeRanker = (g) => {
+  longestPathWithLayer(g);
+  feasibleTreeWithLayer(g);
+};
+const networkSimplexRanker = (g) => {
+  networkSimplex(g);
+};
+export {
+  rank
+};
+//# sourceMappingURL=index.js.map

package/dist/node_modules/.pnpm/@antv_layout@2.0.0/node_modules/@antv/layout/lib/algorithm/antv-dagre/rank/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../../../../../../node_modules/.pnpm/@antv+layout@2.0.0/node_modules/@antv/layout/lib/algorithm/antv-dagre/rank/index.js"],"sourcesContent":["import { feasibleTreeWithLayer } from './feasible-tree.js';\nimport { networkSimplex } from './network-simplex.js';\nimport { longestPathWithLayer, longestPath } from './util.js';\n\n/*\n * Assigns a rank to each node in the input graph that respects the \"minlen\"\n * constraint specified on edges between nodes.\n *\n * This basic structure is derived from Gansner, et al., \"A Technique for\n * Drawing Directed Graphs.\"\n *\n * Pre-conditions:\n *\n *    1. Graph must be a connected DAG\n *    2. Graph nodes must be objects\n *    3. Graph edges must have \"weight\" and \"minlen\" attributes\n *\n * Post-conditions:\n *\n *    1. Graph nodes will have a \"rank\" attribute based on the results of the\n *       algorithm. Ranks can start at any index (including negative), we'll\n *       fix them up later.\n */\nconst rank = (g, ranker) => {\n    switch (ranker) {\n        case 'network-simplex':\n            networkSimplexRanker(g);\n            break;\n        case 'tight-tree':\n            tightTreeRanker(g);\n            break;\n        case 'longest-path':\n            longestPathRanker(g);\n            break;\n        // default: networkSimplexRanker(g);\n        default:\n            tightTreeRanker(g);\n    }\n};\n// A fast and simple ranker, but results are far from optimal.\nconst longestPathRanker = longestPath;\nconst tightTreeRanker = (g) => {\n    longestPathWithLayer(g);\n    feasibleTreeWithLayer(g);\n};\nconst networkSimplexRanker = (g) => {\n    networkSimplex(g);\n};\n\nexport { rank };\n//# sourceMappingURL=index.js.map\n"],"names":[],"mappings":";;;AAuBK,MAAC,OAAO,CAAC,GAAG,WAAW;AACxB,UAAQ,QAAM;AAAA,IACV,KAAK;AACD,2BAAqB,CAAC;AACtB;AAAA,IACJ,KAAK;AACD,sBAAgB,CAAC;AACjB;AAAA,IACJ,KAAK;AACD,wBAAkB,CAAC;AACnB;AAAA;AAAA,IAEJ;AACI,sBAAgB,CAAC;AAAA,EAC7B;AACA;AAEA,MAAM,oBAAoB;AAC1B,MAAM,kBAAkB,CAAC,MAAM;AAC3B,uBAAqB,CAAC;AACtB,wBAAsB,CAAC;AAC3B;AACA,MAAM,uBAAuB,CAAC,MAAM;AAChC,iBAAe,CAAC;AACpB;","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/@antv_layout@2.0.0/node_modules/@antv/layout/lib/algorithm/antv-dagre/rank/network-simplex.cjs

@@ -0,0 +1,153 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const util = require("../util.cjs");
+const feasibleTree = require("./feasible-tree.cjs");
+const util$1 = require("./util.cjs");
+const networkSimplex = (og) => {
+  const g = util.simplify(og);
+  util$1.longestPath(g);
+  const t = feasibleTree.feasibleTree(g);
+  initLowLimValues(t);
+  initCutValues(t, g);
+  let e;
+  let f;
+  while (e = leaveEdge(t)) {
+    f = enterEdge(t, g, e);
+    exchangeEdges(t, g, e, f);
+  }
+};
+const initCutValues = (t, g) => {
+  let vs = util.dfs(t, t.getAllNodes(), "post");
+  vs = vs.slice(0, (vs === null || vs === void 0 ? void 0 : vs.length) - 1);
+  vs.forEach((v) => {
+    assignCutValue(t, g, v);
+  });
+};
+const assignCutValue = (t, g, child) => {
+  const childLab = t.getNode(child);
+  const parent = childLab.data.parent;
+  const edge = t.getRelatedEdges(child, "both").find((e) => e.target === parent || e.source === parent);
+  edge.data.cutvalue = calcCutValue(t, g, child);
+};
+const calcCutValue = (t, g, child) => {
+  const childLab = t.getNode(child);
+  const parent = childLab.data.parent;
+  let childIsTail = true;
+  let graphEdge = g.getRelatedEdges(child, "out").find((e) => e.target === parent);
+  let cutValue = 0;
+  if (!graphEdge) {
+    childIsTail = false;
+    graphEdge = g.getRelatedEdges(parent, "out").find((e) => e.target === child);
+  }
+  cutValue = graphEdge.data.weight;
+  g.getRelatedEdges(child, "both").forEach((e) => {
+    const isOutEdge = e.source === child;
+    const other = isOutEdge ? e.target : e.source;
+    if (other !== parent) {
+      const pointsToHead = isOutEdge === childIsTail;
+      const otherWeight = e.data.weight;
+      cutValue += pointsToHead ? otherWeight : -otherWeight;
+      if (isTreeEdge(t, child, other)) {
+        const otherCutValue = t.getRelatedEdges(child, "both").find((e2) => e2.source === other || e2.target === other).data.cutvalue;
+        cutValue += pointsToHead ? -otherCutValue : otherCutValue;
+      }
+    }
+  });
+  return cutValue;
+};
+const initLowLimValues = (tree, root = tree.getAllNodes()[0].id) => {
+  dfsAssignLowLim(tree, {}, 1, root);
+};
+const dfsAssignLowLim = (tree, visited, nextLim, v, parent) => {
+  var _a;
+  const low = nextLim;
+  let useNextLim = nextLim;
+  const label = tree.getNode(v);
+  visited[v] = true;
+  (_a = tree.getNeighbors(v)) === null || _a === void 0 ? void 0 : _a.forEach((w) => {
+    if (!visited[w.id]) {
+      useNextLim = dfsAssignLowLim(tree, visited, useNextLim, w.id, v);
+    }
+  });
+  label.data.low = low;
+  label.data.lim = useNextLim++;
+  if (parent) {
+    label.data.parent = parent;
+  } else {
+    delete label.data.parent;
+  }
+  return useNextLim;
+};
+const leaveEdge = (tree) => {
+  return tree.getAllEdges().find((e) => {
+    return e.data.cutvalue < 0;
+  });
+};
+const enterEdge = (t, g, edge) => {
+  let v = edge.source;
+  let w = edge.target;
+  if (!g.getRelatedEdges(v, "out").find((e) => e.target === w)) {
+    v = edge.target;
+    w = edge.source;
+  }
+  const vLabel = t.getNode(v);
+  const wLabel = t.getNode(w);
+  let tailLabel = vLabel;
+  let flip = false;
+  if (vLabel.data.lim > wLabel.data.lim) {
+    tailLabel = wLabel;
+    flip = true;
+  }
+  const candidates = g.getAllEdges().filter((edge2) => {
+    return flip === isDescendant(t.getNode(edge2.source), tailLabel) && flip !== isDescendant(t.getNode(edge2.target), tailLabel);
+  });
+  return util.minBy(candidates, (edge2) => {
+    return util$1.slack(g, edge2);
+  });
+};
+const exchangeEdges = (t, g, e, f) => {
+  const existed = t.getRelatedEdges(e.source, "both").find((edge) => edge.source === e.target || edge.target === e.target);
+  if (existed) {
+    t.removeEdge(existed.id);
+  }
+  t.addEdge({
+    id: `e${Math.random()}`,
+    source: f.source,
+    target: f.target,
+    data: {}
+  });
+  initLowLimValues(t);
+  initCutValues(t, g);
+  updateRanks(t, g);
+};
+const updateRanks = (t, g) => {
+  const root = t.getAllNodes().find((v) => {
+    return !v.data.parent;
+  });
+  let vs = util.dfs(t, root, "pre");
+  vs = vs.slice(1);
+  vs.forEach((v) => {
+    const parent = t.getNode(v).data.parent;
+    let edge = g.getRelatedEdges(v, "out").find((e) => e.target === parent);
+    let flipped = false;
+    if (!edge && g.hasNode(parent)) {
+      edge = g.getRelatedEdges(parent, "out").find((e) => e.target === v);
+      flipped = true;
+    }
+    g.getNode(v).data.rank = (g.hasNode(parent) && g.getNode(parent).data.rank || 0) + (flipped ? edge === null || edge === void 0 ? void 0 : edge.data.minlen : -(edge === null || edge === void 0 ? void 0 : edge.data.minlen));
+  });
+};
+const isTreeEdge = (tree, u, v) => {
+  return tree.getRelatedEdges(u, "both").find((e) => e.source === v || e.target === v);
+};
+const isDescendant = (vLabel, rootLabel) => {
+  return rootLabel.data.low <= vLabel.data.lim && vLabel.data.lim <= rootLabel.data.lim;
+};
+exports.calcCutValue = calcCutValue;
+exports.enterEdge = enterEdge;
+exports.exchangeEdges = exchangeEdges;
+exports.initCutValues = initCutValues;
+exports.initLowLimValues = initLowLimValues;
+exports.leaveEdge = leaveEdge;
+exports.networkSimplex = networkSimplex;
+//# sourceMappingURL=network-simplex.cjs.map

package/dist/node_modules/.pnpm/@antv_layout@2.0.0/node_modules/@antv/layout/lib/algorithm/antv-dagre/rank/network-simplex.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"network-simplex.cjs","sources":["../../../../../../../../../../../../node_modules/.pnpm/@antv+layout@2.0.0/node_modules/@antv/layout/lib/algorithm/antv-dagre/rank/network-simplex.js"],"sourcesContent":["import { simplify, dfs, minBy } from '../util.js';\nimport { feasibleTree } from './feasible-tree.js';\nimport { longestPath, slack } from './util.js';\n\n/*\n * The network simplex algorithm assigns ranks to each node in the input graph\n * and iteratively improves the ranking to reduce the length of edges.\n *\n * Preconditions:\n *\n *    1. The input graph must be a DAG.\n *    2. All nodes in the graph must have an object value.\n *    3. All edges in the graph must have \"minlen\" and \"weight\" attributes.\n *\n * Postconditions:\n *\n *    1. All nodes in the graph will have an assigned \"rank\" attribute that has\n *       been optimized by the network simplex algorithm. Ranks start at 0.\n *\n *\n * A rough sketch of the algorithm is as follows:\n *\n *    1. Assign initial ranks to each node. We use the longest path algorithm,\n *       which assigns ranks to the lowest position possible. In general this\n *       leads to very wide bottom ranks and unnecessarily long edges.\n *    2. Construct a feasible tight tree. A tight tree is one such that all\n *       edges in the tree have no slack (difference between length of edge\n *       and minlen for the edge). This by itself greatly improves the assigned\n *       rankings by shorting edges.\n *    3. Iteratively find edges that have negative cut values. Generally a\n *       negative cut value indicates that the edge could be removed and a new\n *       tree edge could be added to produce a more compact graph.\n *\n * Much of the algorithms here are derived from Gansner, et al., \"A Technique\n * for Drawing Directed Graphs.\" The structure of the file roughly follows the\n * structure of the overall algorithm.\n */\nconst networkSimplex = (og) => {\n    const g = simplify(og);\n    longestPath(g);\n    const t = feasibleTree(g);\n    initLowLimValues(t);\n    initCutValues(t, g);\n    let e;\n    let f;\n    while ((e = leaveEdge(t))) {\n        f = enterEdge(t, g, e);\n        exchangeEdges(t, g, e, f);\n    }\n};\n/*\n * Initializes cut values for all edges in the tree.\n */\nconst initCutValues = (t, g) => {\n    let vs = dfs(t, t.getAllNodes(), 'post');\n    vs = vs.slice(0, (vs === null || vs === void 0 ? void 0 : vs.length) - 1);\n    vs.forEach((v) => {\n        assignCutValue(t, g, v);\n    });\n};\nconst assignCutValue = (t, g, child) => {\n    const childLab = t.getNode(child);\n    const parent = childLab.data.parent;\n    // FIXME: use undirected edge?\n    const edge = t\n        .getRelatedEdges(child, 'both')\n        .find((e) => e.target === parent || e.source === parent);\n    edge.data.cutvalue = calcCutValue(t, g, child);\n};\n/*\n * Given the tight tree, its graph, and a child in the graph calculate and\n * return the cut value for the edge between the child and its parent.\n */\nconst calcCutValue = (t, g, child) => {\n    const childLab = t.getNode(child);\n    const parent = childLab.data.parent;\n    // True if the child is on the tail end of the edge in the directed graph\n    let childIsTail = true;\n    // The graph's view of the tree edge we're inspecting\n    let graphEdge = g\n        .getRelatedEdges(child, 'out')\n        .find((e) => e.target === parent);\n    // The accumulated cut value for the edge between this node and its parent\n    let cutValue = 0;\n    if (!graphEdge) {\n        childIsTail = false;\n        graphEdge = g\n            .getRelatedEdges(parent, 'out')\n            .find((e) => e.target === child);\n    }\n    cutValue = graphEdge.data.weight;\n    g.getRelatedEdges(child, 'both').forEach((e) => {\n        const isOutEdge = e.source === child;\n        const other = isOutEdge ? e.target : e.source;\n        if (other !== parent) {\n            const pointsToHead = isOutEdge === childIsTail;\n            const otherWeight = e.data.weight;\n            cutValue += pointsToHead ? otherWeight : -otherWeight;\n            if (isTreeEdge(t, child, other)) {\n                // FIXME: use undirected edge?\n                const otherCutValue = t\n                    .getRelatedEdges(child, 'both')\n                    .find((e) => e.source === other || e.target === other).data\n                    .cutvalue;\n                cutValue += pointsToHead ? -otherCutValue : otherCutValue;\n            }\n        }\n    });\n    return cutValue;\n};\nconst initLowLimValues = (tree, root = tree.getAllNodes()[0].id) => {\n    dfsAssignLowLim(tree, {}, 1, root);\n};\nconst dfsAssignLowLim = (tree, visited, nextLim, v, parent) => {\n    var _a;\n    const low = nextLim;\n    let useNextLim = nextLim;\n    const label = tree.getNode(v);\n    visited[v] = true;\n    (_a = tree.getNeighbors(v)) === null || _a === void 0 ? void 0 : _a.forEach((w) => {\n        if (!visited[w.id]) {\n            useNextLim = dfsAssignLowLim(tree, visited, useNextLim, w.id, v);\n        }\n    });\n    label.data.low = low;\n    label.data.lim = useNextLim++;\n    if (parent) {\n        label.data.parent = parent;\n    }\n    else {\n        // TODO should be able to remove this when we incrementally update low lim\n        delete label.data.parent;\n    }\n    return useNextLim;\n};\nconst leaveEdge = (tree) => {\n    return tree.getAllEdges().find((e) => {\n        return e.data.cutvalue < 0;\n    });\n};\nconst enterEdge = (t, g, edge) => {\n    let v = edge.source;\n    let w = edge.target;\n    // For the rest of this function we assume that v is the tail and w is the\n    // head, so if we don't have this edge in the graph we should flip it to\n    // match the correct orientation.\n    if (!g.getRelatedEdges(v, 'out').find((e) => e.target === w)) {\n        v = edge.target;\n        w = edge.source;\n    }\n    const vLabel = t.getNode(v);\n    const wLabel = t.getNode(w);\n    let tailLabel = vLabel;\n    let flip = false;\n    // If the root is in the tail of the edge then we need to flip the logic that\n    // checks for the head and tail nodes in the candidates function below.\n    if (vLabel.data.lim > wLabel.data.lim) {\n        tailLabel = wLabel;\n        flip = true;\n    }\n    const candidates = g.getAllEdges().filter((edge) => {\n        return (flip === isDescendant(t.getNode(edge.source), tailLabel) &&\n            flip !== isDescendant(t.getNode(edge.target), tailLabel));\n    });\n    return minBy(candidates, (edge) => {\n        return slack(g, edge);\n    });\n};\n/**\n *\n * @param t\n * @param g\n * @param e edge to remove\n * @param f edge to add\n */\nconst exchangeEdges = (t, g, e, f) => {\n    // FIXME: use undirected edge?\n    const existed = t\n        .getRelatedEdges(e.source, 'both')\n        .find((edge) => edge.source === e.target || edge.target === e.target);\n    if (existed) {\n        t.removeEdge(existed.id);\n    }\n    t.addEdge({\n        id: `e${Math.random()}`,\n        source: f.source,\n        target: f.target,\n        data: {},\n    });\n    initLowLimValues(t);\n    initCutValues(t, g);\n    updateRanks(t, g);\n};\nconst updateRanks = (t, g) => {\n    const root = t.getAllNodes().find((v) => {\n        return !v.data.parent;\n    });\n    let vs = dfs(t, root, 'pre');\n    vs = vs.slice(1);\n    vs.forEach((v) => {\n        const parent = t.getNode(v).data.parent;\n        let edge = g.getRelatedEdges(v, 'out').find((e) => e.target === parent);\n        // let edge = g.edgeFromArgs(v, parent);\n        let flipped = false;\n        if (!edge && g.hasNode(parent)) {\n            // edge = g.edgeFromArgs(parent, v)!;\n            edge = g.getRelatedEdges(parent, 'out').find((e) => e.target === v);\n            flipped = true;\n        }\n        g.getNode(v).data.rank =\n            ((g.hasNode(parent) && g.getNode(parent).data.rank) || 0) +\n                (flipped ? edge === null || edge === void 0 ? void 0 : edge.data.minlen : -(edge === null || edge === void 0 ? void 0 : edge.data.minlen));\n    });\n};\n/*\n * Returns true if the edge is in the tree.\n */\nconst isTreeEdge = (tree, u, v) => {\n    // FIXME: use undirected edge?\n    return tree\n        .getRelatedEdges(u, 'both')\n        .find((e) => e.source === v || e.target === v);\n};\n/*\n * Returns true if the specified node is descendant of the root node per the\n * assigned low and lim attributes in the tree.\n */\nconst isDescendant = (vLabel, rootLabel) => {\n    return (rootLabel.data.low <= vLabel.data.lim &&\n        vLabel.data.lim <= rootLabel.data.lim);\n};\n\nexport { calcCutValue, enterEdge, exchangeEdges, initCutValues, initLowLimValues, leaveEdge, networkSimplex };\n//# sourceMappingURL=network-simplex.js.map\n"],"names":["simplify","longestPath","feasibleTree","dfs","e","edge","minBy","slack"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/@antv_layout@2.0.0/node_modules/@antv/layout/lib/algorithm/antv-dagre/rank/network-simplex.js

@@ -0,0 +1,153 @@
+import { simplify, dfs as dfs$1, minBy } from "../util.js";
+import { feasibleTree } from "./feasible-tree.js";
+import { longestPath, slack } from "./util.js";
+const networkSimplex = (og) => {
+  const g = simplify(og);
+  longestPath(g);
+  const t = feasibleTree(g);
+  initLowLimValues(t);
+  initCutValues(t, g);
+  let e;
+  let f;
+  while (e = leaveEdge(t)) {
+    f = enterEdge(t, g, e);
+    exchangeEdges(t, g, e, f);
+  }
+};
+const initCutValues = (t, g) => {
+  let vs = dfs$1(t, t.getAllNodes(), "post");
+  vs = vs.slice(0, (vs === null || vs === void 0 ? void 0 : vs.length) - 1);
+  vs.forEach((v) => {
+    assignCutValue(t, g, v);
+  });
+};
+const assignCutValue = (t, g, child) => {
+  const childLab = t.getNode(child);
+  const parent = childLab.data.parent;
+  const edge = t.getRelatedEdges(child, "both").find((e) => e.target === parent || e.source === parent);
+  edge.data.cutvalue = calcCutValue(t, g, child);
+};
+const calcCutValue = (t, g, child) => {
+  const childLab = t.getNode(child);
+  const parent = childLab.data.parent;
+  let childIsTail = true;
+  let graphEdge = g.getRelatedEdges(child, "out").find((e) => e.target === parent);
+  let cutValue = 0;
+  if (!graphEdge) {
+    childIsTail = false;
+    graphEdge = g.getRelatedEdges(parent, "out").find((e) => e.target === child);
+  }
+  cutValue = graphEdge.data.weight;
+  g.getRelatedEdges(child, "both").forEach((e) => {
+    const isOutEdge = e.source === child;
+    const other = isOutEdge ? e.target : e.source;
+    if (other !== parent) {
+      const pointsToHead = isOutEdge === childIsTail;
+      const otherWeight = e.data.weight;
+      cutValue += pointsToHead ? otherWeight : -otherWeight;
+      if (isTreeEdge(t, child, other)) {
+        const otherCutValue = t.getRelatedEdges(child, "both").find((e2) => e2.source === other || e2.target === other).data.cutvalue;
+        cutValue += pointsToHead ? -otherCutValue : otherCutValue;
+      }
+    }
+  });
+  return cutValue;
+};
+const initLowLimValues = (tree, root = tree.getAllNodes()[0].id) => {
+  dfsAssignLowLim(tree, {}, 1, root);
+};
+const dfsAssignLowLim = (tree, visited, nextLim, v, parent) => {
+  var _a;
+  const low = nextLim;
+  let useNextLim = nextLim;
+  const label = tree.getNode(v);
+  visited[v] = true;
+  (_a = tree.getNeighbors(v)) === null || _a === void 0 ? void 0 : _a.forEach((w) => {
+    if (!visited[w.id]) {
+      useNextLim = dfsAssignLowLim(tree, visited, useNextLim, w.id, v);
+    }
+  });
+  label.data.low = low;
+  label.data.lim = useNextLim++;
+  if (parent) {
+    label.data.parent = parent;
+  } else {
+    delete label.data.parent;
+  }
+  return useNextLim;
+};
+const leaveEdge = (tree) => {
+  return tree.getAllEdges().find((e) => {
+    return e.data.cutvalue < 0;
+  });
+};
+const enterEdge = (t, g, edge) => {
+  let v = edge.source;
+  let w = edge.target;
+  if (!g.getRelatedEdges(v, "out").find((e) => e.target === w)) {
+    v = edge.target;
+    w = edge.source;
+  }
+  const vLabel = t.getNode(v);
+  const wLabel = t.getNode(w);
+  let tailLabel = vLabel;
+  let flip = false;
+  if (vLabel.data.lim > wLabel.data.lim) {
+    tailLabel = wLabel;
+    flip = true;
+  }
+  const candidates = g.getAllEdges().filter((edge2) => {
+    return flip === isDescendant(t.getNode(edge2.source), tailLabel) && flip !== isDescendant(t.getNode(edge2.target), tailLabel);
+  });
+  return minBy(candidates, (edge2) => {
+    return slack(g, edge2);
+  });
+};
+const exchangeEdges = (t, g, e, f) => {
+  const existed = t.getRelatedEdges(e.source, "both").find((edge) => edge.source === e.target || edge.target === e.target);
+  if (existed) {
+    t.removeEdge(existed.id);
+  }
+  t.addEdge({
+    id: `e${Math.random()}`,
+    source: f.source,
+    target: f.target,
+    data: {}
+  });
+  initLowLimValues(t);
+  initCutValues(t, g);
+  updateRanks(t, g);
+};
+const updateRanks = (t, g) => {
+  const root = t.getAllNodes().find((v) => {
+    return !v.data.parent;
+  });
+  let vs = dfs$1(t, root, "pre");
+  vs = vs.slice(1);
+  vs.forEach((v) => {
+    const parent = t.getNode(v).data.parent;
+    let edge = g.getRelatedEdges(v, "out").find((e) => e.target === parent);
+    let flipped = false;
+    if (!edge && g.hasNode(parent)) {
+      edge = g.getRelatedEdges(parent, "out").find((e) => e.target === v);
+      flipped = true;
+    }
+    g.getNode(v).data.rank = (g.hasNode(parent) && g.getNode(parent).data.rank || 0) + (flipped ? edge === null || edge === void 0 ? void 0 : edge.data.minlen : -(edge === null || edge === void 0 ? void 0 : edge.data.minlen));
+  });
+};
+const isTreeEdge = (tree, u, v) => {
+  return tree.getRelatedEdges(u, "both").find((e) => e.source === v || e.target === v);
+};
+const isDescendant = (vLabel, rootLabel) => {
+  return rootLabel.data.low <= vLabel.data.lim && vLabel.data.lim <= rootLabel.data.lim;
+};
+export {
+  calcCutValue,
+  enterEdge,
+  exchangeEdges,
+  initCutValues,
+  initLowLimValues,
+  leaveEdge,
+  networkSimplex
+};
+//# sourceMappingURL=network-simplex.js.map

package/dist/node_modules/.pnpm/@antv_layout@2.0.0/node_modules/@antv/layout/lib/algorithm/antv-dagre/rank/network-simplex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"network-simplex.js","sources":["../../../../../../../../../../../../node_modules/.pnpm/@antv+layout@2.0.0/node_modules/@antv/layout/lib/algorithm/antv-dagre/rank/network-simplex.js"],"sourcesContent":["import { simplify, dfs, minBy } from '../util.js';\nimport { feasibleTree } from './feasible-tree.js';\nimport { longestPath, slack } from './util.js';\n\n/*\n * The network simplex algorithm assigns ranks to each node in the input graph\n * and iteratively improves the ranking to reduce the length of edges.\n *\n * Preconditions:\n *\n *    1. The input graph must be a DAG.\n *    2. All nodes in the graph must have an object value.\n *    3. All edges in the graph must have \"minlen\" and \"weight\" attributes.\n *\n * Postconditions:\n *\n *    1. All nodes in the graph will have an assigned \"rank\" attribute that has\n *       been optimized by the network simplex algorithm. Ranks start at 0.\n *\n *\n * A rough sketch of the algorithm is as follows:\n *\n *    1. Assign initial ranks to each node. We use the longest path algorithm,\n *       which assigns ranks to the lowest position possible. In general this\n *       leads to very wide bottom ranks and unnecessarily long edges.\n *    2. Construct a feasible tight tree. A tight tree is one such that all\n *       edges in the tree have no slack (difference between length of edge\n *       and minlen for the edge). This by itself greatly improves the assigned\n *       rankings by shorting edges.\n *    3. Iteratively find edges that have negative cut values. Generally a\n *       negative cut value indicates that the edge could be removed and a new\n *       tree edge could be added to produce a more compact graph.\n *\n * Much of the algorithms here are derived from Gansner, et al., \"A Technique\n * for Drawing Directed Graphs.\" The structure of the file roughly follows the\n * structure of the overall algorithm.\n */\nconst networkSimplex = (og) => {\n    const g = simplify(og);\n    longestPath(g);\n    const t = feasibleTree(g);\n    initLowLimValues(t);\n    initCutValues(t, g);\n    let e;\n    let f;\n    while ((e = leaveEdge(t))) {\n        f = enterEdge(t, g, e);\n        exchangeEdges(t, g, e, f);\n    }\n};\n/*\n * Initializes cut values for all edges in the tree.\n */\nconst initCutValues = (t, g) => {\n    let vs = dfs(t, t.getAllNodes(), 'post');\n    vs = vs.slice(0, (vs === null || vs === void 0 ? void 0 : vs.length) - 1);\n    vs.forEach((v) => {\n        assignCutValue(t, g, v);\n    });\n};\nconst assignCutValue = (t, g, child) => {\n    const childLab = t.getNode(child);\n    const parent = childLab.data.parent;\n    // FIXME: use undirected edge?\n    const edge = t\n        .getRelatedEdges(child, 'both')\n        .find((e) => e.target === parent || e.source === parent);\n    edge.data.cutvalue = calcCutValue(t, g, child);\n};\n/*\n * Given the tight tree, its graph, and a child in the graph calculate and\n * return the cut value for the edge between the child and its parent.\n */\nconst calcCutValue = (t, g, child) => {\n    const childLab = t.getNode(child);\n    const parent = childLab.data.parent;\n    // True if the child is on the tail end of the edge in the directed graph\n    let childIsTail = true;\n    // The graph's view of the tree edge we're inspecting\n    let graphEdge = g\n        .getRelatedEdges(child, 'out')\n        .find((e) => e.target === parent);\n    // The accumulated cut value for the edge between this node and its parent\n    let cutValue = 0;\n    if (!graphEdge) {\n        childIsTail = false;\n        graphEdge = g\n            .getRelatedEdges(parent, 'out')\n            .find((e) => e.target === child);\n    }\n    cutValue = graphEdge.data.weight;\n    g.getRelatedEdges(child, 'both').forEach((e) => {\n        const isOutEdge = e.source === child;\n        const other = isOutEdge ? e.target : e.source;\n        if (other !== parent) {\n            const pointsToHead = isOutEdge === childIsTail;\n            const otherWeight = e.data.weight;\n            cutValue += pointsToHead ? otherWeight : -otherWeight;\n            if (isTreeEdge(t, child, other)) {\n                // FIXME: use undirected edge?\n                const otherCutValue = t\n                    .getRelatedEdges(child, 'both')\n                    .find((e) => e.source === other || e.target === other).data\n                    .cutvalue;\n                cutValue += pointsToHead ? -otherCutValue : otherCutValue;\n            }\n        }\n    });\n    return cutValue;\n};\nconst initLowLimValues = (tree, root = tree.getAllNodes()[0].id) => {\n    dfsAssignLowLim(tree, {}, 1, root);\n};\nconst dfsAssignLowLim = (tree, visited, nextLim, v, parent) => {\n    var _a;\n    const low = nextLim;\n    let useNextLim = nextLim;\n    const label = tree.getNode(v);\n    visited[v] = true;\n    (_a = tree.getNeighbors(v)) === null || _a === void 0 ? void 0 : _a.forEach((w) => {\n        if (!visited[w.id]) {\n            useNextLim = dfsAssignLowLim(tree, visited, useNextLim, w.id, v);\n        }\n    });\n    label.data.low = low;\n    label.data.lim = useNextLim++;\n    if (parent) {\n        label.data.parent = parent;\n    }\n    else {\n        // TODO should be able to remove this when we incrementally update low lim\n        delete label.data.parent;\n    }\n    return useNextLim;\n};\nconst leaveEdge = (tree) => {\n    return tree.getAllEdges().find((e) => {\n        return e.data.cutvalue < 0;\n    });\n};\nconst enterEdge = (t, g, edge) => {\n    let v = edge.source;\n    let w = edge.target;\n    // For the rest of this function we assume that v is the tail and w is the\n    // head, so if we don't have this edge in the graph we should flip it to\n    // match the correct orientation.\n    if (!g.getRelatedEdges(v, 'out').find((e) => e.target === w)) {\n        v = edge.target;\n        w = edge.source;\n    }\n    const vLabel = t.getNode(v);\n    const wLabel = t.getNode(w);\n    let tailLabel = vLabel;\n    let flip = false;\n    // If the root is in the tail of the edge then we need to flip the logic that\n    // checks for the head and tail nodes in the candidates function below.\n    if (vLabel.data.lim > wLabel.data.lim) {\n        tailLabel = wLabel;\n        flip = true;\n    }\n    const candidates = g.getAllEdges().filter((edge) => {\n        return (flip === isDescendant(t.getNode(edge.source), tailLabel) &&\n            flip !== isDescendant(t.getNode(edge.target), tailLabel));\n    });\n    return minBy(candidates, (edge) => {\n        return slack(g, edge);\n    });\n};\n/**\n *\n * @param t\n * @param g\n * @param e edge to remove\n * @param f edge to add\n */\nconst exchangeEdges = (t, g, e, f) => {\n    // FIXME: use undirected edge?\n    const existed = t\n        .getRelatedEdges(e.source, 'both')\n        .find((edge) => edge.source === e.target || edge.target === e.target);\n    if (existed) {\n        t.removeEdge(existed.id);\n    }\n    t.addEdge({\n        id: `e${Math.random()}`,\n        source: f.source,\n        target: f.target,\n        data: {},\n    });\n    initLowLimValues(t);\n    initCutValues(t, g);\n    updateRanks(t, g);\n};\nconst updateRanks = (t, g) => {\n    const root = t.getAllNodes().find((v) => {\n        return !v.data.parent;\n    });\n    let vs = dfs(t, root, 'pre');\n    vs = vs.slice(1);\n    vs.forEach((v) => {\n        const parent = t.getNode(v).data.parent;\n        let edge = g.getRelatedEdges(v, 'out').find((e) => e.target === parent);\n        // let edge = g.edgeFromArgs(v, parent);\n        let flipped = false;\n        if (!edge && g.hasNode(parent)) {\n            // edge = g.edgeFromArgs(parent, v)!;\n            edge = g.getRelatedEdges(parent, 'out').find((e) => e.target === v);\n            flipped = true;\n        }\n        g.getNode(v).data.rank =\n            ((g.hasNode(parent) && g.getNode(parent).data.rank) || 0) +\n                (flipped ? edge === null || edge === void 0 ? void 0 : edge.data.minlen : -(edge === null || edge === void 0 ? void 0 : edge.data.minlen));\n    });\n};\n/*\n * Returns true if the edge is in the tree.\n */\nconst isTreeEdge = (tree, u, v) => {\n    // FIXME: use undirected edge?\n    return tree\n        .getRelatedEdges(u, 'both')\n        .find((e) => e.source === v || e.target === v);\n};\n/*\n * Returns true if the specified node is descendant of the root node per the\n * assigned low and lim attributes in the tree.\n */\nconst isDescendant = (vLabel, rootLabel) => {\n    return (rootLabel.data.low <= vLabel.data.lim &&\n        vLabel.data.lim <= rootLabel.data.lim);\n};\n\nexport { calcCutValue, enterEdge, exchangeEdges, initCutValues, initLowLimValues, leaveEdge, networkSimplex };\n//# sourceMappingURL=network-simplex.js.map\n"],"names":["dfs","e","edge"],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/.pnpm/@antv_layout@2.0.0/node_modules/@antv/layout/lib/algorithm/antv-dagre/rank/util.cjs

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const longestPath = (g) => {
+  const visited = {};
+  const dfs = (v) => {
+    var _a;
+    const label = g.getNode(v);
+    if (!label)
+      return 0;
+    if (visited[v]) {
+      return label.data.rank;
+    }
+    visited[v] = true;
+    let rank;
+    (_a = g.getRelatedEdges(v, "out")) === null || _a === void 0 ? void 0 : _a.forEach((e) => {
+      const wRank = dfs(e.target);
+      const minLen = e.data.minlen;
+      const r = wRank - minLen;
+      if (r) {
+        if (rank === void 0 || r < rank) {
+          rank = r;
+        }
+      }
+    });
+    if (!rank) {
+      rank = 0;
+    }
+    label.data.rank = rank;
+    return rank;
+  };
+  g.getAllNodes().filter((n) => g.getRelatedEdges(n.id, "in").length === 0).forEach((source) => dfs(source.id));
+};
+const longestPathWithLayer = (g) => {
+  const visited = {};
+  let minRank;
+  const dfs = (v) => {
+    var _a;
+    const label = g.getNode(v);
+    if (!label)
+      return 0;
+    if (visited[v]) {
+      return label.data.rank;
+    }
+    visited[v] = true;
+    let rank;
+    (_a = g.getRelatedEdges(v, "out")) === null || _a === void 0 ? void 0 : _a.forEach((e) => {
+      const wRank = dfs(e.target);
+      const minLen = e.data.minlen;
+      const r = wRank - minLen;
+      if (r) {
+        if (rank === void 0 || r < rank) {
+          rank = r;
+        }
+      }
+    });
+    if (!rank) {
+      rank = 0;
+    }
+    if (minRank === void 0 || rank < minRank) {
+      minRank = rank;
+    }
+    label.data.rank = rank;
+    return rank;
+  };
+  g.getAllNodes().filter((n) => g.getRelatedEdges(n.id, "in").length === 0).forEach((source) => {
+    if (source)
+      dfs(source.id);
+  });
+  if (minRank === void 0) {
+    minRank = 0;
+  }
+  const forwardVisited = {};
+  const dfsForward = (v, nextRank) => {
+    var _a;
+    const label = g.getNode(v);
+    const currRank = !isNaN(label.data.layer) ? label.data.layer : nextRank;
+    if (label.data.rank === void 0 || label.data.rank < currRank) {
+      label.data.rank = currRank;
+    }
+    if (forwardVisited[v])
+      return;
+    forwardVisited[v] = true;
+    (_a = g.getRelatedEdges(v, "out")) === null || _a === void 0 ? void 0 : _a.forEach((e) => {
+      dfsForward(e.target, currRank + e.data.minlen);
+    });
+  };
+  g.getAllNodes().forEach((n) => {
+    const label = n.data;
+    if (!label)
+      return;
+    if (!isNaN(label.layer)) {
+      dfsForward(n.id, label.layer);
+    } else {
+      label.rank -= minRank;
+    }
+  });
+};
+const slack = (g, e) => {
+  return g.getNode(e.target).data.rank - g.getNode(e.source).data.rank - e.data.minlen;
+};
+exports.longestPath = longestPath;
+exports.longestPathWithLayer = longestPathWithLayer;
+exports.slack = slack;
+//# sourceMappingURL=util.cjs.map