@antv/layout 1.2.14-beta.9 → 2.0.0-alpha.1

package/lib/node_modules/.pnpm/dagre@0.8.5/node_modules/dagre/lib/rank/feasible-tree.js

@@ -0,0 +1,103 @@
+import { __require as requireLodash } from '../lodash.js';
+import { __require as requireGraphlib } from '../graphlib.js';
+import { __require as requireUtil } from './util.js';
+
+var feasibleTree_1;
+var hasRequiredFeasibleTree;
+
+function requireFeasibleTree () {
+	if (hasRequiredFeasibleTree) return feasibleTree_1;
+	hasRequiredFeasibleTree = 1;
+
+	var _ = requireLodash();
+	var Graph = requireGraphlib().Graph;
+	var slack = requireUtil().slack;
+
+	feasibleTree_1 = feasibleTree;
+
+	/*
+	 * Constructs a spanning tree with tight edges and adjusted the input node's
+	 * ranks to achieve this. A tight edge is one that is has a length that matches
+	 * its "minlen" attribute.
+	 *
+	 * The basic structure for this function is derived from Gansner, et al., "A
+	 * Technique for Drawing Directed Graphs."
+	 *
+	 * Pre-conditions:
+	 *
+	 *    1. Graph must be a DAG.
+	 *    2. Graph must be connected.
+	 *    3. Graph must have at least one node.
+	 *    5. Graph nodes must have been previously assigned a "rank" property that
+	 *       respects the "minlen" property of incident edges.
+	 *    6. Graph edges must have a "minlen" property.
+	 *
+	 * Post-conditions:
+	 *
+	 *    - Graph nodes will have their rank adjusted to ensure that all edges are
+	 *      tight.
+	 *
+	 * Returns a tree (undirected graph) that is constructed using only "tight"
+	 * edges.
+	 */
+	function feasibleTree(g) {
+	  var t = new Graph({ directed: false });
+
+	  // Choose arbitrary node from which to start our tree
+	  var start = g.nodes()[0];
+	  var size = g.nodeCount();
+	  t.setNode(start, {});
+
+	  var edge, delta;
+	  while (tightTree(t, g) < size) {
+	    edge = findMinSlackEdge(t, g);
+	    delta = t.hasNode(edge.v) ? slack(g, edge) : -slack(g, edge);
+	    shiftRanks(t, g, delta);
+	  }
+
+	  return t;
+	}
+
+	/*
+	 * Finds a maximal tree of tight edges and returns the number of nodes in the
+	 * tree.
+	 */
+	function tightTree(t, g) {
+	  function dfs(v) {
+	    _.forEach(g.nodeEdges(v), function(e) {
+	      var edgeV = e.v,
+	        w = (v === edgeV) ? e.w : edgeV;
+	      if (!t.hasNode(w) && !slack(g, e)) {
+	        t.setNode(w, {});
+	        t.setEdge(v, w, {});
+	        dfs(w);
+	      }
+	    });
+	  }
+
+	  _.forEach(t.nodes(), dfs);
+	  return t.nodeCount();
+	}
+
+	/*
+	 * Finds the edge with the smallest slack that is incident on tree and returns
+	 * it.
+	 */
+	function findMinSlackEdge(t, g) {
+	  return _.minBy(g.edges(), function(e) {
+	    if (t.hasNode(e.v) !== t.hasNode(e.w)) {
+	      return slack(g, e);
+	    }
+	  });
+	}
+
+	function shiftRanks(t, g, delta) {
+	  _.forEach(t.nodes(), function(v) {
+	    g.node(v).rank += delta;
+	  });
+	}
+	return feasibleTree_1;
+}
+
+export { requireFeasibleTree as __require };
+//# sourceMappingURL=feasible-tree.js.map

package/lib/node_modules/.pnpm/dagre@0.8.5/node_modules/dagre/lib/rank/feasible-tree.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feasible-tree.js","sources":["../../../../../../../../../../node_modules/.pnpm/dagre@0.8.5/node_modules/dagre/lib/rank/feasible-tree.js"],"sourcesContent":["\"use strict\";\n\nvar _ = require(\"../lodash\");\nvar Graph = require(\"../graphlib\").Graph;\nvar slack = require(\"./util\").slack;\n\nmodule.exports = feasibleTree;\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 */\nfunction feasibleTree(g) {\n  var t = new Graph({ directed: false });\n\n  // Choose arbitrary node from which to start our tree\n  var start = g.nodes()[0];\n  var size = g.nodeCount();\n  t.setNode(start, {});\n\n  var edge, delta;\n  while (tightTree(t, g) < size) {\n    edge = findMinSlackEdge(t, g);\n    delta = t.hasNode(edge.v) ? slack(g, edge) : -slack(g, edge);\n    shiftRanks(t, g, delta);\n  }\n\n  return t;\n}\n\n/*\n * Finds a maximal tree of tight edges and returns the number of nodes in the\n * tree.\n */\nfunction tightTree(t, g) {\n  function dfs(v) {\n    _.forEach(g.nodeEdges(v), function(e) {\n      var edgeV = e.v,\n        w = (v === edgeV) ? e.w : edgeV;\n      if (!t.hasNode(w) && !slack(g, e)) {\n        t.setNode(w, {});\n        t.setEdge(v, w, {});\n        dfs(w);\n      }\n    });\n  }\n\n  _.forEach(t.nodes(), dfs);\n  return t.nodeCount();\n}\n\n/*\n * Finds the edge with the smallest slack that is incident on tree and returns\n * it.\n */\nfunction findMinSlackEdge(t, g) {\n  return _.minBy(g.edges(), function(e) {\n    if (t.hasNode(e.v) !== t.hasNode(e.w)) {\n      return slack(g, e);\n    }\n  });\n}\n\nfunction shiftRanks(t, g, delta) {\n  _.forEach(t.nodes(), function(v) {\n    g.node(v).rank += delta;\n  });\n}\n"],"names":["require$$0","require$$1","require$$2"],"mappings":";;;;;;;;;;;CAEA,IAAI,CAAC,GAAGA,aAAA,EAAoB;AAC5B,CAAA,IAAI,KAAK,GAAGC,eAAA,EAAsB,CAAC,KAAK;AACxC,CAAA,IAAI,KAAK,GAAGC,WAAA,EAAiB,CAAC,KAAK;;AAEnC,CAAA,cAAc,GAAG,YAAY;;AAE7B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;CACA,SAAS,YAAY,CAAC,CAAC,EAAE;GACvB,IAAI,CAAC,GAAG,IAAI,KAAK,CAAC,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;;AAExC;GACE,IAAI,KAAK,GAAG,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;AAC1B,GAAE,IAAI,IAAI,GAAG,CAAC,CAAC,SAAS,EAAE;AAC1B,GAAE,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC;;GAEpB,IAAI,IAAI,EAAE,KAAK;GACf,OAAO,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI,EAAE;AACjC,KAAI,IAAI,GAAG,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC;KAC7B,KAAK,GAAG,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC;AAChE,KAAI,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC;AAC3B,GAAA;;AAEA,GAAE,OAAO,CAAC;AACV,CAAA;;AAEA;AACA;AACA;AACA;AACA,CAAA,SAAS,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE;AACzB,GAAE,SAAS,GAAG,CAAC,CAAC,EAAE;AAClB,KAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE;AAC1C,OAAM,IAAI,KAAK,GAAG,CAAC,CAAC,CAAC;SACb,CAAC,GAAG,CAAC,CAAC,KAAK,KAAK,IAAI,CAAC,CAAC,CAAC,GAAG,KAAK;AACvC,OAAM,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE;AACzC,SAAQ,CAAC,CAAC,OAAO,CAAC,CAAC,EAAE,EAAE,CAAC;SAChB,CAAC,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC;SACnB,GAAG,CAAC,CAAC,CAAC;AACd,OAAA;AACA,KAAA,CAAK,CAAC;AACN,GAAA;;GAEE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE,GAAG,CAAC;AAC3B,GAAE,OAAO,CAAC,CAAC,SAAS,EAAE;AACtB,CAAA;;AAEA;AACA;AACA;AACA;AACA,CAAA,SAAS,gBAAgB,CAAC,CAAC,EAAE,CAAC,EAAE;AAChC,GAAE,OAAO,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE,SAAS,CAAC,EAAE;AACxC,KAAI,IAAI,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC,EAAE;AAC3C,OAAM,OAAO,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC;AACxB,KAAA;AACA,GAAA,CAAG,CAAC;AACJ,CAAA;;AAEA,CAAA,SAAS,UAAU,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE;GAC/B,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE,SAAS,CAAC,EAAE;KAC/B,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,IAAI,KAAK;AAC3B,GAAA,CAAG,CAAC;AACJ,CAAA;;;;;;","x_google_ignoreList":[0]}

package/lib/node_modules/.pnpm/dagre@0.8.5/node_modules/dagre/lib/rank/index.js

@@ -0,0 +1,62 @@
+import { __require as requireUtil } from './util.js';
+import { __require as requireFeasibleTree } from './feasible-tree.js';
+import { __require as requireNetworkSimplex } from './network-simplex.js';
+
+var rank_1;
+var hasRequiredRank;
+
+function requireRank () {
+	if (hasRequiredRank) return rank_1;
+	hasRequiredRank = 1;
+
+	var rankUtil = requireUtil();
+	var longestPath = rankUtil.longestPath;
+	var feasibleTree = requireFeasibleTree();
+	var networkSimplex = requireNetworkSimplex();
+
+	rank_1 = rank;
+
+	/*
+	 * Assigns a rank to each node in the input graph that respects the "minlen"
+	 * constraint specified on edges between nodes.
+	 *
+	 * This basic structure is derived from Gansner, et al., "A Technique for
+	 * Drawing Directed Graphs."
+	 *
+	 * Pre-conditions:
+	 *
+	 *    1. Graph must be a connected DAG
+	 *    2. Graph nodes must be objects
+	 *    3. Graph edges must have "weight" and "minlen" attributes
+	 *
+	 * Post-conditions:
+	 *
+	 *    1. Graph nodes will have a "rank" attribute based on the results of the
+	 *       algorithm. Ranks can start at any index (including negative), we'll
+	 *       fix them up later.
+	 */
+	function rank(g) {
+	  switch(g.graph().ranker) {
+	  case "network-simplex": networkSimplexRanker(g); break;
+	  case "tight-tree": tightTreeRanker(g); break;
+	  case "longest-path": longestPathRanker(g); break;
+	  default: networkSimplexRanker(g);
+	  }
+	}
+
+	// A fast and simple ranker, but results are far from optimal.
+	var longestPathRanker = longestPath;
+
+	function tightTreeRanker(g) {
+	  longestPath(g);
+	  feasibleTree(g);
+	}
+
+	function networkSimplexRanker(g) {
+	  networkSimplex(g);
+	}
+	return rank_1;
+}
+
+export { requireRank as __require };
+//# sourceMappingURL=index.js.map

package/lib/node_modules/.pnpm/dagre@0.8.5/node_modules/dagre/lib/rank/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../../../../../../node_modules/.pnpm/dagre@0.8.5/node_modules/dagre/lib/rank/index.js"],"sourcesContent":["\"use strict\";\n\nvar rankUtil = require(\"./util\");\nvar longestPath = rankUtil.longestPath;\nvar feasibleTree = require(\"./feasible-tree\");\nvar networkSimplex = require(\"./network-simplex\");\n\nmodule.exports = rank;\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 */\nfunction rank(g) {\n  switch(g.graph().ranker) {\n  case \"network-simplex\": networkSimplexRanker(g); break;\n  case \"tight-tree\": tightTreeRanker(g); break;\n  case \"longest-path\": longestPathRanker(g); break;\n  default: networkSimplexRanker(g);\n  }\n}\n\n// A fast and simple ranker, but results are far from optimal.\nvar longestPathRanker = longestPath;\n\nfunction tightTreeRanker(g) {\n  longestPath(g);\n  feasibleTree(g);\n}\n\nfunction networkSimplexRanker(g) {\n  networkSimplex(g);\n}\n"],"names":["require$$0","require$$1","require$$2"],"mappings":";;;;;;;;;;;CAEA,IAAI,QAAQ,GAAGA,WAAA,EAAiB;AAChC,CAAA,IAAI,WAAW,GAAG,QAAQ,CAAC,WAAW;CACtC,IAAI,YAAY,GAAGC,mBAAA,EAA0B;CAC7C,IAAI,cAAc,GAAGC,qBAAA,EAA4B;;AAEjD,CAAA,MAAc,GAAG,IAAI;;AAErB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;CACA,SAAS,IAAI,CAAC,CAAC,EAAE;AACjB,GAAE,OAAO,CAAC,CAAC,KAAK,EAAE,CAAC,MAAM;GACvB,KAAK,iBAAiB,EAAE,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAAC;GACjD,KAAK,YAAY,EAAE,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC;GACvC,KAAK,cAAc,EAAE,iBAAiB,CAAC,CAAC,CAAC,CAAC,CAAC;AAC7C,GAAE,SAAS,oBAAoB,CAAC,CAAC,CAAC;AAClC;AACA,CAAA;;AAEA;CACA,IAAI,iBAAiB,GAAG,WAAW;;CAEnC,SAAS,eAAe,CAAC,CAAC,EAAE;GAC1B,WAAW,CAAC,CAAC,CAAC;GACd,YAAY,CAAC,CAAC,CAAC;AACjB,CAAA;;CAEA,SAAS,oBAAoB,CAAC,CAAC,EAAE;GAC/B,cAAc,CAAC,CAAC,CAAC;AACnB,CAAA;;;;;;","x_google_ignoreList":[0]}

package/lib/node_modules/.pnpm/dagre@0.8.5/node_modules/dagre/lib/rank/network-simplex.js

@@ -0,0 +1,250 @@
+import { __require as requireLodash } from '../lodash.js';
+import { __require as requireFeasibleTree } from './feasible-tree.js';
+import { __require as requireUtil } from './util.js';
+import { __require as requireGraphlib } from '../graphlib.js';
+import { __require as requireUtil$1 } from '../util.js';
+
+var networkSimplex_1;
+var hasRequiredNetworkSimplex;
+
+function requireNetworkSimplex () {
+	if (hasRequiredNetworkSimplex) return networkSimplex_1;
+	hasRequiredNetworkSimplex = 1;
+
+	var _ = requireLodash();
+	var feasibleTree = requireFeasibleTree();
+	var slack = requireUtil().slack;
+	var initRank = requireUtil().longestPath;
+	var preorder = requireGraphlib().alg.preorder;
+	var postorder = requireGraphlib().alg.postorder;
+	var simplify = requireUtil$1().simplify;
+
+	networkSimplex_1 = networkSimplex;
+
+	// Expose some internals for testing purposes
+	networkSimplex.initLowLimValues = initLowLimValues;
+	networkSimplex.initCutValues = initCutValues;
+	networkSimplex.calcCutValue = calcCutValue;
+	networkSimplex.leaveEdge = leaveEdge;
+	networkSimplex.enterEdge = enterEdge;
+	networkSimplex.exchangeEdges = exchangeEdges;
+
+	/*
+	 * The network simplex algorithm assigns ranks to each node in the input graph
+	 * and iteratively improves the ranking to reduce the length of edges.
+	 *
+	 * Preconditions:
+	 *
+	 *    1. The input graph must be a DAG.
+	 *    2. All nodes in the graph must have an object value.
+	 *    3. All edges in the graph must have "minlen" and "weight" attributes.
+	 *
+	 * Postconditions:
+	 *
+	 *    1. All nodes in the graph will have an assigned "rank" attribute that has
+	 *       been optimized by the network simplex algorithm. Ranks start at 0.
+	 *
+	 *
+	 * A rough sketch of the algorithm is as follows:
+	 *
+	 *    1. Assign initial ranks to each node. We use the longest path algorithm,
+	 *       which assigns ranks to the lowest position possible. In general this
+	 *       leads to very wide bottom ranks and unnecessarily long edges.
+	 *    2. Construct a feasible tight tree. A tight tree is one such that all
+	 *       edges in the tree have no slack (difference between length of edge
+	 *       and minlen for the edge). This by itself greatly improves the assigned
+	 *       rankings by shorting edges.
+	 *    3. Iteratively find edges that have negative cut values. Generally a
+	 *       negative cut value indicates that the edge could be removed and a new
+	 *       tree edge could be added to produce a more compact graph.
+	 *
+	 * Much of the algorithms here are derived from Gansner, et al., "A Technique
+	 * for Drawing Directed Graphs." The structure of the file roughly follows the
+	 * structure of the overall algorithm.
+	 */
+	function networkSimplex(g) {
+	  g = simplify(g);
+	  initRank(g);
+	  var t = feasibleTree(g);
+	  initLowLimValues(t);
+	  initCutValues(t, g);
+
+	  var e, f;
+	  while ((e = leaveEdge(t))) {
+	    f = enterEdge(t, g, e);
+	    exchangeEdges(t, g, e, f);
+	  }
+	}
+
+	/*
+	 * Initializes cut values for all edges in the tree.
+	 */
+	function initCutValues(t, g) {
+	  var vs = postorder(t, t.nodes());
+	  vs = vs.slice(0, vs.length - 1);
+	  _.forEach(vs, function(v) {
+	    assignCutValue(t, g, v);
+	  });
+	}
+
+	function assignCutValue(t, g, child) {
+	  var childLab = t.node(child);
+	  var parent = childLab.parent;
+	  t.edge(child, parent).cutvalue = calcCutValue(t, g, child);
+	}
+
+	/*
+	 * Given the tight tree, its graph, and a child in the graph calculate and
+	 * return the cut value for the edge between the child and its parent.
+	 */
+	function calcCutValue(t, g, child) {
+	  var childLab = t.node(child);
+	  var parent = childLab.parent;
+	  // True if the child is on the tail end of the edge in the directed graph
+	  var childIsTail = true;
+	  // The graph's view of the tree edge we're inspecting
+	  var graphEdge = g.edge(child, parent);
+	  // The accumulated cut value for the edge between this node and its parent
+	  var cutValue = 0;
+
+	  if (!graphEdge) {
+	    childIsTail = false;
+	    graphEdge = g.edge(parent, child);
+	  }
+
+	  cutValue = graphEdge.weight;
+
+	  _.forEach(g.nodeEdges(child), function(e) {
+	    var isOutEdge = e.v === child,
+	      other = isOutEdge ? e.w : e.v;
+
+	    if (other !== parent) {
+	      var pointsToHead = isOutEdge === childIsTail,
+	        otherWeight = g.edge(e).weight;
+
+	      cutValue += pointsToHead ? otherWeight : -otherWeight;
+	      if (isTreeEdge(t, child, other)) {
+	        var otherCutValue = t.edge(child, other).cutvalue;
+	        cutValue += pointsToHead ? -otherCutValue : otherCutValue;
+	      }
+	    }
+	  });
+
+	  return cutValue;
+	}
+
+	function initLowLimValues(tree, root) {
+	  if (arguments.length < 2) {
+	    root = tree.nodes()[0];
+	  }
+	  dfsAssignLowLim(tree, {}, 1, root);
+	}
+
+	function dfsAssignLowLim(tree, visited, nextLim, v, parent) {
+	  var low = nextLim;
+	  var label = tree.node(v);
+
+	  visited[v] = true;
+	  _.forEach(tree.neighbors(v), function(w) {
+	    if (!_.has(visited, w)) {
+	      nextLim = dfsAssignLowLim(tree, visited, nextLim, w, v);
+	    }
+	  });
+
+	  label.low = low;
+	  label.lim = nextLim++;
+	  if (parent) {
+	    label.parent = parent;
+	  } else {
+	    // TODO should be able to remove this when we incrementally update low lim
+	    delete label.parent;
+	  }
+
+	  return nextLim;
+	}
+
+	function leaveEdge(tree) {
+	  return _.find(tree.edges(), function(e) {
+	    return tree.edge(e).cutvalue < 0;
+	  });
+	}
+
+	function enterEdge(t, g, edge) {
+	  var v = edge.v;
+	  var w = edge.w;
+
+	  // For the rest of this function we assume that v is the tail and w is the
+	  // head, so if we don't have this edge in the graph we should flip it to
+	  // match the correct orientation.
+	  if (!g.hasEdge(v, w)) {
+	    v = edge.w;
+	    w = edge.v;
+	  }
+
+	  var vLabel = t.node(v);
+	  var wLabel = t.node(w);
+	  var tailLabel = vLabel;
+	  var flip = false;
+
+	  // If the root is in the tail of the edge then we need to flip the logic that
+	  // checks for the head and tail nodes in the candidates function below.
+	  if (vLabel.lim > wLabel.lim) {
+	    tailLabel = wLabel;
+	    flip = true;
+	  }
+
+	  var candidates = _.filter(g.edges(), function(edge) {
+	    return flip === isDescendant(t, t.node(edge.v), tailLabel) &&
+	           flip !== isDescendant(t, t.node(edge.w), tailLabel);
+	  });
+
+	  return _.minBy(candidates, function(edge) { return slack(g, edge); });
+	}
+
+	function exchangeEdges(t, g, e, f) {
+	  var v = e.v;
+	  var w = e.w;
+	  t.removeEdge(v, w);
+	  t.setEdge(f.v, f.w, {});
+	  initLowLimValues(t);
+	  initCutValues(t, g);
+	  updateRanks(t, g);
+	}
+
+	function updateRanks(t, g) {
+	  var root = _.find(t.nodes(), function(v) { return !g.node(v).parent; });
+	  var vs = preorder(t, root);
+	  vs = vs.slice(1);
+	  _.forEach(vs, function(v) {
+	    var parent = t.node(v).parent,
+	      edge = g.edge(v, parent),
+	      flipped = false;
+
+	    if (!edge) {
+	      edge = g.edge(parent, v);
+	      flipped = true;
+	    }
+
+	    g.node(v).rank = g.node(parent).rank + (flipped ? edge.minlen : -edge.minlen);
+	  });
+	}
+
+	/*
+	 * Returns true if the edge is in the tree.
+	 */
+	function isTreeEdge(tree, u, v) {
+	  return tree.hasEdge(u, v);
+	}
+
+	/*
+	 * Returns true if the specified node is descendant of the root node per the
+	 * assigned low and lim attributes in the tree.
+	 */
+	function isDescendant(tree, vLabel, rootLabel) {
+	  return rootLabel.low <= vLabel.lim && vLabel.lim <= rootLabel.lim;
+	}
+	return networkSimplex_1;
+}
+
+export { requireNetworkSimplex as __require };
+//# sourceMappingURL=network-simplex.js.map

package/lib/node_modules/.pnpm/dagre@0.8.5/node_modules/dagre/lib/rank/network-simplex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"network-simplex.js","sources":["../../../../../../../../../../node_modules/.pnpm/dagre@0.8.5/node_modules/dagre/lib/rank/network-simplex.js"],"sourcesContent":["\"use strict\";\n\nvar _ = require(\"../lodash\");\nvar feasibleTree = require(\"./feasible-tree\");\nvar slack = require(\"./util\").slack;\nvar initRank = require(\"./util\").longestPath;\nvar preorder = require(\"../graphlib\").alg.preorder;\nvar postorder = require(\"../graphlib\").alg.postorder;\nvar simplify = require(\"../util\").simplify;\n\nmodule.exports = networkSimplex;\n\n// Expose some internals for testing purposes\nnetworkSimplex.initLowLimValues = initLowLimValues;\nnetworkSimplex.initCutValues = initCutValues;\nnetworkSimplex.calcCutValue = calcCutValue;\nnetworkSimplex.leaveEdge = leaveEdge;\nnetworkSimplex.enterEdge = enterEdge;\nnetworkSimplex.exchangeEdges = exchangeEdges;\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 */\nfunction networkSimplex(g) {\n  g = simplify(g);\n  initRank(g);\n  var t = feasibleTree(g);\n  initLowLimValues(t);\n  initCutValues(t, g);\n\n  var e, f;\n  while ((e = leaveEdge(t))) {\n    f = enterEdge(t, g, e);\n    exchangeEdges(t, g, e, f);\n  }\n}\n\n/*\n * Initializes cut values for all edges in the tree.\n */\nfunction initCutValues(t, g) {\n  var vs = postorder(t, t.nodes());\n  vs = vs.slice(0, vs.length - 1);\n  _.forEach(vs, function(v) {\n    assignCutValue(t, g, v);\n  });\n}\n\nfunction assignCutValue(t, g, child) {\n  var childLab = t.node(child);\n  var parent = childLab.parent;\n  t.edge(child, parent).cutvalue = calcCutValue(t, g, child);\n}\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 */\nfunction calcCutValue(t, g, child) {\n  var childLab = t.node(child);\n  var parent = childLab.parent;\n  // True if the child is on the tail end of the edge in the directed graph\n  var childIsTail = true;\n  // The graph's view of the tree edge we're inspecting\n  var graphEdge = g.edge(child, parent);\n  // The accumulated cut value for the edge between this node and its parent\n  var cutValue = 0;\n\n  if (!graphEdge) {\n    childIsTail = false;\n    graphEdge = g.edge(parent, child);\n  }\n\n  cutValue = graphEdge.weight;\n\n  _.forEach(g.nodeEdges(child), function(e) {\n    var isOutEdge = e.v === child,\n      other = isOutEdge ? e.w : e.v;\n\n    if (other !== parent) {\n      var pointsToHead = isOutEdge === childIsTail,\n        otherWeight = g.edge(e).weight;\n\n      cutValue += pointsToHead ? otherWeight : -otherWeight;\n      if (isTreeEdge(t, child, other)) {\n        var otherCutValue = t.edge(child, other).cutvalue;\n        cutValue += pointsToHead ? -otherCutValue : otherCutValue;\n      }\n    }\n  });\n\n  return cutValue;\n}\n\nfunction initLowLimValues(tree, root) {\n  if (arguments.length < 2) {\n    root = tree.nodes()[0];\n  }\n  dfsAssignLowLim(tree, {}, 1, root);\n}\n\nfunction dfsAssignLowLim(tree, visited, nextLim, v, parent) {\n  var low = nextLim;\n  var label = tree.node(v);\n\n  visited[v] = true;\n  _.forEach(tree.neighbors(v), function(w) {\n    if (!_.has(visited, w)) {\n      nextLim = dfsAssignLowLim(tree, visited, nextLim, w, v);\n    }\n  });\n\n  label.low = low;\n  label.lim = nextLim++;\n  if (parent) {\n    label.parent = parent;\n  } else {\n    // TODO should be able to remove this when we incrementally update low lim\n    delete label.parent;\n  }\n\n  return nextLim;\n}\n\nfunction leaveEdge(tree) {\n  return _.find(tree.edges(), function(e) {\n    return tree.edge(e).cutvalue < 0;\n  });\n}\n\nfunction enterEdge(t, g, edge) {\n  var v = edge.v;\n  var w = edge.w;\n\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.hasEdge(v, w)) {\n    v = edge.w;\n    w = edge.v;\n  }\n\n  var vLabel = t.node(v);\n  var wLabel = t.node(w);\n  var tailLabel = vLabel;\n  var flip = false;\n\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.lim > wLabel.lim) {\n    tailLabel = wLabel;\n    flip = true;\n  }\n\n  var candidates = _.filter(g.edges(), function(edge) {\n    return flip === isDescendant(t, t.node(edge.v), tailLabel) &&\n           flip !== isDescendant(t, t.node(edge.w), tailLabel);\n  });\n\n  return _.minBy(candidates, function(edge) { return slack(g, edge); });\n}\n\nfunction exchangeEdges(t, g, e, f) {\n  var v = e.v;\n  var w = e.w;\n  t.removeEdge(v, w);\n  t.setEdge(f.v, f.w, {});\n  initLowLimValues(t);\n  initCutValues(t, g);\n  updateRanks(t, g);\n}\n\nfunction updateRanks(t, g) {\n  var root = _.find(t.nodes(), function(v) { return !g.node(v).parent; });\n  var vs = preorder(t, root);\n  vs = vs.slice(1);\n  _.forEach(vs, function(v) {\n    var parent = t.node(v).parent,\n      edge = g.edge(v, parent),\n      flipped = false;\n\n    if (!edge) {\n      edge = g.edge(parent, v);\n      flipped = true;\n    }\n\n    g.node(v).rank = g.node(parent).rank + (flipped ? edge.minlen : -edge.minlen);\n  });\n}\n\n/*\n * Returns true if the edge is in the tree.\n */\nfunction isTreeEdge(tree, u, v) {\n  return tree.hasEdge(u, v);\n}\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 */\nfunction isDescendant(tree, vLabel, rootLabel) {\n  return rootLabel.low <= vLabel.lim && vLabel.lim <= rootLabel.lim;\n}\n"],"names":["require$$0","require$$1","require$$2","require$$3","require$$4"],"mappings":";;;;;;;;;;;;;CAEA,IAAI,CAAC,GAAGA,aAAA,EAAoB;CAC5B,IAAI,YAAY,GAAGC,mBAAA,EAA0B;AAC7C,CAAA,IAAI,KAAK,GAAGC,WAAA,EAAiB,CAAC,KAAK;AACnC,CAAA,IAAI,QAAQ,GAAGA,WAAA,EAAiB,CAAC,WAAW;AAC5C,CAAA,IAAI,QAAQ,GAAGC,eAAA,EAAsB,CAAC,GAAG,CAAC,QAAQ;AAClD,CAAA,IAAI,SAAS,GAAGA,eAAA,EAAsB,CAAC,GAAG,CAAC,SAAS;AACpD,CAAA,IAAI,QAAQ,GAAGC,aAAA,EAAkB,CAAC,QAAQ;;AAE1C,CAAA,gBAAc,GAAG,cAAc;;AAE/B;CACA,cAAc,CAAC,gBAAgB,GAAG,gBAAgB;CAClD,cAAc,CAAC,aAAa,GAAG,aAAa;CAC5C,cAAc,CAAC,YAAY,GAAG,YAAY;CAC1C,cAAc,CAAC,SAAS,GAAG,SAAS;CACpC,cAAc,CAAC,SAAS,GAAG,SAAS;CACpC,cAAc,CAAC,aAAa,GAAG,aAAa;;AAE5C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;CACA,SAAS,cAAc,CAAC,CAAC,EAAE;AAC3B,GAAE,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC;GACf,QAAQ,CAAC,CAAC,CAAC;AACb,GAAE,IAAI,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC;GACvB,gBAAgB,CAAC,CAAC,CAAC;AACrB,GAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC;;GAEnB,IAAI,CAAC,EAAE,CAAC;AACV,GAAE,QAAQ,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,GAAG;KACzB,CAAC,GAAG,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;KACtB,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;AAC7B,GAAA;AACA,CAAA;;AAEA;AACA;AACA;AACA,CAAA,SAAS,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE;GAC3B,IAAI,EAAE,GAAG,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,KAAK,EAAE,CAAC;AAClC,GAAE,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,MAAM,GAAG,CAAC,CAAC;GAC/B,CAAC,CAAC,OAAO,CAAC,EAAE,EAAE,SAAS,CAAC,EAAE;AAC5B,KAAI,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC;AAC3B,GAAA,CAAG,CAAC;AACJ,CAAA;;AAEA,CAAA,SAAS,cAAc,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE;GACnC,IAAI,QAAQ,GAAG,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC;AAC9B,GAAE,IAAI,MAAM,GAAG,QAAQ,CAAC,MAAM;AAC9B,GAAE,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,QAAQ,GAAG,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,CAAC;AAC5D,CAAA;;AAEA;AACA;AACA;AACA;AACA,CAAA,SAAS,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,KAAK,EAAE;GACjC,IAAI,QAAQ,GAAG,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC;AAC9B,GAAE,IAAI,MAAM,GAAG,QAAQ,CAAC,MAAM;AAC9B;GACE,IAAI,WAAW,GAAG,IAAI;AACxB;GACE,IAAI,SAAS,GAAG,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,MAAM,CAAC;AACvC;GACE,IAAI,QAAQ,GAAG,CAAC;;GAEhB,IAAI,CAAC,SAAS,EAAE;KACd,WAAW,GAAG,KAAK;KACnB,SAAS,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,KAAK,CAAC;AACrC,GAAA;;AAEA,GAAE,QAAQ,GAAG,SAAS,CAAC,MAAM;;AAE7B,GAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC,EAAE;AAC5C,KAAI,IAAI,SAAS,GAAG,CAAC,CAAC,CAAC,KAAK,KAAK;OAC3B,KAAK,GAAG,SAAS,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC;;AAEnC,KAAI,IAAI,KAAK,KAAK,MAAM,EAAE;AAC1B,OAAM,IAAI,YAAY,GAAG,SAAS,KAAK,WAAW;SAC1C,WAAW,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM;;AAEtC,OAAM,QAAQ,IAAI,YAAY,GAAG,WAAW,GAAG,CAAC,WAAW;OACrD,IAAI,UAAU,CAAC,CAAC,EAAE,KAAK,EAAE,KAAK,CAAC,EAAE;AACvC,SAAQ,IAAI,aAAa,GAAG,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,QAAQ;AACzD,SAAQ,QAAQ,IAAI,YAAY,GAAG,CAAC,aAAa,GAAG,aAAa;AACjE,OAAA;AACA,KAAA;AACA,GAAA,CAAG,CAAC;;AAEJ,GAAE,OAAO,QAAQ;AACjB,CAAA;;AAEA,CAAA,SAAS,gBAAgB,CAAC,IAAI,EAAE,IAAI,EAAE;AACtC,GAAE,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE;KACxB,IAAI,GAAG,IAAI,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;AAC1B,GAAA;GACE,eAAe,CAAC,IAAI,EAAE,EAAE,EAAE,CAAC,EAAE,IAAI,CAAC;AACpC,CAAA;;CAEA,SAAS,eAAe,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,MAAM,EAAE;GAC1D,IAAI,GAAG,GAAG,OAAO;GACjB,IAAI,KAAK,GAAG,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;;AAE1B,GAAE,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI;AACnB,GAAE,CAAC,CAAC,OAAO,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE;KACvC,IAAI,CAAC,CAAC,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE;AAC5B,OAAM,OAAO,GAAG,eAAe,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,CAAC,EAAE,CAAC,CAAC;AAC7D,KAAA;AACA,GAAA,CAAG,CAAC;;AAEJ,GAAE,KAAK,CAAC,GAAG,GAAG,GAAG;AACjB,GAAE,KAAK,CAAC,GAAG,GAAG,OAAO,EAAE;GACrB,IAAI,MAAM,EAAE;AACd,KAAI,KAAK,CAAC,MAAM,GAAG,MAAM;AACzB,GAAA,CAAG,MAAM;AACT;KACI,OAAO,KAAK,CAAC,MAAM;AACvB,GAAA;;AAEA,GAAE,OAAO,OAAO;AAChB,CAAA;;CAEA,SAAS,SAAS,CAAC,IAAI,EAAE;AACzB,GAAE,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,EAAE,EAAE,SAAS,CAAC,EAAE;KACtC,OAAO,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,QAAQ,GAAG,CAAC;AACpC,GAAA,CAAG,CAAC;AACJ,CAAA;;AAEA,CAAA,SAAS,SAAS,CAAC,CAAC,EAAE,CAAC,EAAE,IAAI,EAAE;AAC/B,GAAE,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;AAChB,GAAE,IAAI,CAAC,GAAG,IAAI,CAAC,CAAC;;AAEhB;AACA;AACA;GACE,IAAI,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE;AACxB,KAAI,CAAC,GAAG,IAAI,CAAC,CAAC;AACd,KAAI,CAAC,GAAG,IAAI,CAAC,CAAC;AACd,GAAA;;GAEE,IAAI,MAAM,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;GACtB,IAAI,MAAM,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;GACtB,IAAI,SAAS,GAAG,MAAM;GACtB,IAAI,IAAI,GAAG,KAAK;;AAElB;AACA;GACE,IAAI,MAAM,CAAC,GAAG,GAAG,MAAM,CAAC,GAAG,EAAE;KAC3B,SAAS,GAAG,MAAM;KAClB,IAAI,GAAG,IAAI;AACf,GAAA;;AAEA,GAAE,IAAI,UAAU,GAAG,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE,SAAS,IAAI,EAAE;AACtD,KAAI,OAAO,IAAI,KAAK,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC;AAC9D,YAAW,IAAI,KAAK,YAAY,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC;AAC9D,GAAA,CAAG,CAAC;;GAEF,OAAO,CAAC,CAAC,KAAK,CAAC,UAAU,EAAE,SAAS,IAAI,EAAE,EAAE,OAAO,KAAK,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,EAAE,CAAC;AACvE,CAAA;;CAEA,SAAS,aAAa,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE;AACnC,GAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;AACb,GAAE,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;AACb,GAAE,CAAC,CAAC,UAAU,CAAC,CAAC,EAAE,CAAC,CAAC;AACpB,GAAE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC;GACvB,gBAAgB,CAAC,CAAC,CAAC;AACrB,GAAE,aAAa,CAAC,CAAC,EAAE,CAAC,CAAC;AACrB,GAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC;AACnB,CAAA;;AAEA,CAAA,SAAS,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE;AAC3B,GAAE,IAAI,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE,SAAS,CAAC,EAAE,EAAE,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAA,CAAE,CAAC;GACvE,IAAI,EAAE,GAAG,QAAQ,CAAC,CAAC,EAAE,IAAI,CAAC;AAC5B,GAAE,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;GAChB,CAAC,CAAC,OAAO,CAAC,EAAE,EAAE,SAAS,CAAC,EAAE;KACxB,IAAI,MAAM,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM;OAC3B,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,EAAE,MAAM,CAAC;OACxB,OAAO,GAAG,KAAK;;KAEjB,IAAI,CAAC,IAAI,EAAE;OACT,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,EAAE,CAAC,CAAC;OACxB,OAAO,GAAG,IAAI;AACpB,KAAA;;AAEA,KAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,IAAI,OAAO,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,IAAI,CAAC,MAAM,CAAC;AACjF,GAAA,CAAG,CAAC;AACJ,CAAA;;AAEA;AACA;AACA;AACA,CAAA,SAAS,UAAU,CAAC,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE;GAC9B,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,CAAC;AAC3B,CAAA;;AAEA;AACA;AACA;AACA;AACA,CAAA,SAAS,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE;AAC/C,GAAE,OAAO,SAAS,CAAC,GAAG,IAAI,MAAM,CAAC,GAAG,IAAI,MAAM,CAAC,GAAG,IAAI,SAAS,CAAC,GAAG;AACnE,CAAA;;;;;;","x_google_ignoreList":[0]}

package/lib/node_modules/.pnpm/dagre@0.8.5/node_modules/dagre/lib/rank/util.js

@@ -0,0 +1,75 @@
+import { __require as requireLodash } from '../lodash.js';
+
+var util;
+var hasRequiredUtil;
+
+function requireUtil () {
+	if (hasRequiredUtil) return util;
+	hasRequiredUtil = 1;
+
+	var _ = requireLodash();
+
+	util = {
+	  longestPath: longestPath,
+	  slack: slack
+	};
+
+	/*
+	 * Initializes ranks for the input graph using the longest path algorithm. This
+	 * algorithm scales well and is fast in practice, it yields rather poor
+	 * solutions. Nodes are pushed to the lowest layer possible, leaving the bottom
+	 * ranks wide and leaving edges longer than necessary. However, due to its
+	 * speed, this algorithm is good for getting an initial ranking that can be fed
+	 * into other algorithms.
+	 *
+	 * This algorithm does not normalize layers because it will be used by other
+	 * algorithms in most cases. If using this algorithm directly, be sure to
+	 * run normalize at the end.
+	 *
+	 * Pre-conditions:
+	 *
+	 *    1. Input graph is a DAG.
+	 *    2. Input graph node labels can be assigned properties.
+	 *
+	 * Post-conditions:
+	 *
+	 *    1. Each node will be assign an (unnormalized) "rank" property.
+	 */
+	function longestPath(g) {
+	  var visited = {};
+
+	  function dfs(v) {
+	    var label = g.node(v);
+	    if (_.has(visited, v)) {
+	      return label.rank;
+	    }
+	    visited[v] = true;
+
+	    var rank = _.min(_.map(g.outEdges(v), function(e) {
+	      return dfs(e.w) - g.edge(e).minlen;
+	    }));
+
+	    if (rank === Number.POSITIVE_INFINITY || // return value of _.map([]) for Lodash 3
+	        rank === undefined || // return value of _.map([]) for Lodash 4
+	        rank === null) { // return value of _.map([null])
+	      rank = 0;
+	    }
+
+	    return (label.rank = rank);
+	  }
+
+	  _.forEach(g.sources(), dfs);
+	}
+
+	/*
+	 * Returns the amount of slack for the given edge. The slack is defined as the
+	 * difference between the length of the edge and its minimum length.
+	 */
+	function slack(g, e) {
+	  return g.node(e.w).rank - g.node(e.v).rank - g.edge(e).minlen;
+	}
+	return util;
+}
+
+export { requireUtil as __require };
+//# sourceMappingURL=util.js.map

package/lib/node_modules/.pnpm/dagre@0.8.5/node_modules/dagre/lib/rank/util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.js","sources":["../../../../../../../../../../node_modules/.pnpm/dagre@0.8.5/node_modules/dagre/lib/rank/util.js"],"sourcesContent":["\"use strict\";\n\nvar _ = require(\"../lodash\");\n\nmodule.exports = {\n  longestPath: longestPath,\n  slack: slack\n};\n\n/*\n * Initializes ranks for the input graph using the longest path algorithm. This\n * algorithm scales well and is fast in practice, it yields rather poor\n * solutions. Nodes are pushed to the lowest layer possible, leaving the bottom\n * ranks wide and leaving edges longer than necessary. However, due to its\n * speed, this algorithm is good for getting an initial ranking that can be fed\n * into other algorithms.\n *\n * This algorithm does not normalize layers because it will be used by other\n * algorithms in most cases. If using this algorithm directly, be sure to\n * run normalize at the end.\n *\n * Pre-conditions:\n *\n *    1. Input graph is a DAG.\n *    2. Input graph node labels can be assigned properties.\n *\n * Post-conditions:\n *\n *    1. Each node will be assign an (unnormalized) \"rank\" property.\n */\nfunction longestPath(g) {\n  var visited = {};\n\n  function dfs(v) {\n    var label = g.node(v);\n    if (_.has(visited, v)) {\n      return label.rank;\n    }\n    visited[v] = true;\n\n    var rank = _.min(_.map(g.outEdges(v), function(e) {\n      return dfs(e.w) - g.edge(e).minlen;\n    }));\n\n    if (rank === Number.POSITIVE_INFINITY || // return value of _.map([]) for Lodash 3\n        rank === undefined || // return value of _.map([]) for Lodash 4\n        rank === null) { // return value of _.map([null])\n      rank = 0;\n    }\n\n    return (label.rank = rank);\n  }\n\n  _.forEach(g.sources(), dfs);\n}\n\n/*\n * Returns the amount of slack for the given edge. The slack is defined as the\n * difference between the length of the edge and its minimum length.\n */\nfunction slack(g, e) {\n  return g.node(e.w).rank - g.node(e.v).rank - g.edge(e).minlen;\n}\n"],"names":["require$$0"],"mappings":";;;;;;;;;CAEA,IAAI,CAAC,GAAGA,aAAA,EAAoB;;AAE5B,CAAA,IAAc,GAAG;GACf,WAAW,EAAE,WAAW;AAC1B,GAAE,KAAK,EAAE;EACR;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;CACA,SAAS,WAAW,CAAC,CAAC,EAAE;GACtB,IAAI,OAAO,GAAG,EAAE;;AAElB,GAAE,SAAS,GAAG,CAAC,CAAC,EAAE;KACd,IAAI,KAAK,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC;KACrB,IAAI,CAAC,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC,EAAE;OACrB,OAAO,KAAK,CAAC,IAAI;AACvB,KAAA;AACA,KAAI,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI;;KAEjB,IAAI,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,SAAS,CAAC,EAAE;AACtD,OAAM,OAAO,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM;AACxC,KAAA,CAAK,CAAC,CAAC;;AAEP,KAAI,IAAI,IAAI,KAAK,MAAM,CAAC,iBAAiB;SACjC,IAAI,KAAK,SAAS;SAClB,IAAI,KAAK,IAAI,EAAE;OACjB,IAAI,GAAG,CAAC;AACd,KAAA;;AAEA,KAAI,QAAQ,KAAK,CAAC,IAAI,GAAG,IAAI;AAC7B,GAAA;;GAEE,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,EAAE,EAAE,GAAG,CAAC;AAC7B,CAAA;;AAEA;AACA;AACA;AACA;AACA,CAAA,SAAS,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE;AACrB,GAAE,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM;AAC/D,CAAA;;;;;;","x_google_ignoreList":[0]}