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

package/lib/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/dagre/lib/rank/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sources":["../../../../../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/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/dagre/lib/rank/network-simplex.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"network-simplex.js","sources":["../../../../../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":"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","x_google_ignoreList":[0]}

package/lib/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/dagre/lib/rank/util.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.js","sources":["../../../../../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]}

package/lib/node_modules/dagre/lib/util.js

@@ -0,0 +1,251 @@
+import { __require as requireLodash } from './lodash.js';
+import { __require as requireGraphlib } from './graphlib.js';
+
+/* eslint "no-console": off */
+
+var util$1;
+var hasRequiredUtil$1;
+
+function requireUtil$1 () {
+	if (hasRequiredUtil$1) return util$1;
+	hasRequiredUtil$1 = 1;
+
+	var _ = requireLodash();
+	var Graph = requireGraphlib().Graph;
+
+	util$1 = {
+	  addDummyNode: addDummyNode,
+	  simplify: simplify,
+	  asNonCompoundGraph: asNonCompoundGraph,
+	  successorWeights: successorWeights,
+	  predecessorWeights: predecessorWeights,
+	  intersectRect: intersectRect,
+	  buildLayerMatrix: buildLayerMatrix,
+	  normalizeRanks: normalizeRanks,
+	  removeEmptyRanks: removeEmptyRanks,
+	  addBorderNode: addBorderNode,
+	  maxRank: maxRank,
+	  partition: partition,
+	  time: time,
+	  notime: notime
+	};
+
+	/*
+	 * Adds a dummy node to the graph and return v.
+	 */
+	function addDummyNode(g, type, attrs, name) {
+	  var v;
+	  do {
+	    v = _.uniqueId(name);
+	  } while (g.hasNode(v));
+
+	  attrs.dummy = type;
+	  g.setNode(v, attrs);
+	  return v;
+	}
+
+	/*
+	 * Returns a new graph with only simple edges. Handles aggregation of data
+	 * associated with multi-edges.
+	 */
+	function simplify(g) {
+	  var simplified = new Graph().setGraph(g.graph());
+	  _.forEach(g.nodes(), function(v) { simplified.setNode(v, g.node(v)); });
+	  _.forEach(g.edges(), function(e) {
+	    var simpleLabel = simplified.edge(e.v, e.w) || { weight: 0, minlen: 1 };
+	    var label = g.edge(e);
+	    simplified.setEdge(e.v, e.w, {
+	      weight: simpleLabel.weight + label.weight,
+	      minlen: Math.max(simpleLabel.minlen, label.minlen)
+	    });
+	  });
+	  return simplified;
+	}
+
+	function asNonCompoundGraph(g) {
+	  var simplified = new Graph({ multigraph: g.isMultigraph() }).setGraph(g.graph());
+	  _.forEach(g.nodes(), function(v) {
+	    if (!g.children(v).length) {
+	      simplified.setNode(v, g.node(v));
+	    }
+	  });
+	  _.forEach(g.edges(), function(e) {
+	    simplified.setEdge(e, g.edge(e));
+	  });
+	  return simplified;
+	}
+
+	function successorWeights(g) {
+	  var weightMap = _.map(g.nodes(), function(v) {
+	    var sucs = {};
+	    _.forEach(g.outEdges(v), function(e) {
+	      sucs[e.w] = (sucs[e.w] || 0) + g.edge(e).weight;
+	    });
+	    return sucs;
+	  });
+	  return _.zipObject(g.nodes(), weightMap);
+	}
+
+	function predecessorWeights(g) {
+	  var weightMap = _.map(g.nodes(), function(v) {
+	    var preds = {};
+	    _.forEach(g.inEdges(v), function(e) {
+	      preds[e.v] = (preds[e.v] || 0) + g.edge(e).weight;
+	    });
+	    return preds;
+	  });
+	  return _.zipObject(g.nodes(), weightMap);
+	}
+
+	/*
+	 * Finds where a line starting at point ({x, y}) would intersect a rectangle
+	 * ({x, y, width, height}) if it were pointing at the rectangle's center.
+	 */
+	function intersectRect(rect, point) {
+	  var x = rect.x;
+	  var y = rect.y;
+
+	  // Rectangle intersection algorithm from:
+	  // http://math.stackexchange.com/questions/108113/find-edge-between-two-boxes
+	  var dx = point.x - x;
+	  var dy = point.y - y;
+	  var w = rect.width / 2;
+	  var h = rect.height / 2;
+
+	  if (!dx && !dy) {
+	    throw new Error("Not possible to find intersection inside of the rectangle");
+	  }
+
+	  var sx, sy;
+	  if (Math.abs(dy) * w > Math.abs(dx) * h) {
+	    // Intersection is top or bottom of rect.
+	    if (dy < 0) {
+	      h = -h;
+	    }
+	    sx = h * dx / dy;
+	    sy = h;
+	  } else {
+	    // Intersection is left or right of rect.
+	    if (dx < 0) {
+	      w = -w;
+	    }
+	    sx = w;
+	    sy = w * dy / dx;
+	  }
+
+	  return { x: x + sx, y: y + sy };
+	}
+
+	/*
+	 * Given a DAG with each node assigned "rank" and "order" properties, this
+	 * function will produce a matrix with the ids of each node.
+	 */
+	function buildLayerMatrix(g) {
+	  var layering = _.map(_.range(maxRank(g) + 1), function() { return []; });
+	  _.forEach(g.nodes(), function(v) {
+	    var node = g.node(v);
+	    var rank = node.rank;
+	    if (!_.isUndefined(rank)) {
+	      layering[rank][node.order] = v;
+	    }
+	  });
+	  return layering;
+	}
+
+	/*
+	 * Adjusts the ranks for all nodes in the graph such that all nodes v have
+	 * rank(v) >= 0 and at least one node w has rank(w) = 0.
+	 */
+	function normalizeRanks(g) {
+	  var min = _.min(_.map(g.nodes(), function(v) { return g.node(v).rank; }));
+	  _.forEach(g.nodes(), function(v) {
+	    var node = g.node(v);
+	    if (_.has(node, "rank")) {
+	      node.rank -= min;
+	    }
+	  });
+	}
+
+	function removeEmptyRanks(g) {
+	  // Ranks may not start at 0, so we need to offset them
+	  var offset = _.min(_.map(g.nodes(), function(v) { return g.node(v).rank; }));
+
+	  var layers = [];
+	  _.forEach(g.nodes(), function(v) {
+	    var rank = g.node(v).rank - offset;
+	    if (!layers[rank]) {
+	      layers[rank] = [];
+	    }
+	    layers[rank].push(v);
+	  });
+
+	  var delta = 0;
+	  var nodeRankFactor = g.graph().nodeRankFactor;
+	  _.forEach(layers, function(vs, i) {
+	    if (_.isUndefined(vs) && i % nodeRankFactor !== 0) {
+	      --delta;
+	    } else if (delta) {
+	      _.forEach(vs, function(v) { g.node(v).rank += delta; });
+	    }
+	  });
+	}
+
+	function addBorderNode(g, prefix, rank, order) {
+	  var node = {
+	    width: 0,
+	    height: 0
+	  };
+	  if (arguments.length >= 4) {
+	    node.rank = rank;
+	    node.order = order;
+	  }
+	  return addDummyNode(g, "border", node, prefix);
+	}
+
+	function maxRank(g) {
+	  return _.max(_.map(g.nodes(), function(v) {
+	    var rank = g.node(v).rank;
+	    if (!_.isUndefined(rank)) {
+	      return rank;
+	    }
+	  }));
+	}
+
+	/*
+	 * Partition a collection into two groups: `lhs` and `rhs`. If the supplied
+	 * function returns true for an entry it goes into `lhs`. Otherwise it goes
+	 * into `rhs.
+	 */
+	function partition(collection, fn) {
+	  var result = { lhs: [], rhs: [] };
+	  _.forEach(collection, function(value) {
+	    if (fn(value)) {
+	      result.lhs.push(value);
+	    } else {
+	      result.rhs.push(value);
+	    }
+	  });
+	  return result;
+	}
+
+	/*
+	 * Returns a new function that wraps `fn` with a timer. The wrapper logs the
+	 * time it takes to execute the function.
+	 */
+	function time(name, fn) {
+	  var start = _.now();
+	  try {
+	    return fn();
+	  } finally {
+	    console.log(name + " time: " + (_.now() - start) + "ms");
+	  }
+	}
+
+	function notime(name, fn) {
+	  return fn();
+	}
+	return util$1;
+}
+
+export { requireUtil$1 as __require };
+//# sourceMappingURL=util.js.map