@dagrejs/dagre 1.0.2 → 1.1.0

package/lib/position/bk.js

@@ -1,26 +1,27 @@
 "use strict";
 
-var Graph = require("@dagrejs/graphlib").Graph;
-var util = require("../util");
-
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.addConflict = addConflict;
+exports.alignCoordinates = alignCoordinates;
+exports.balance = balance;
+exports.findSmallestWidthAlignment = findSmallestWidthAlignment;
+exports.findType1Conflicts = findType1Conflicts;
+exports.findType2Conflicts = findType2Conflicts;
+exports.hasConflict = hasConflict;
+exports.horizontalCompaction = horizontalCompaction;
+exports.positionX = positionX;
+exports.verticalAlignment = verticalAlignment;
+var _graphlib = require("@dagrejs/graphlib");
+var util = _interopRequireWildcard(require("../util.js"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 /*
  * This module provides coordinate assignment based on Brandes and Köpf, "Fast
  * and Simple Horizontal Coordinate Assignment."
  */
 
-module.exports = {
-  positionX: positionX,
-  findType1Conflicts: findType1Conflicts,
-  findType2Conflicts: findType2Conflicts,
-  addConflict: addConflict,
-  hasConflict: hasConflict,
-  verticalAlignment: verticalAlignment,
-  horizontalCompaction: horizontalCompaction,
-  alignCoordinates: alignCoordinates,
-  findSmallestWidthAlignment: findSmallestWidthAlignment,
-  balance: balance
-};
-
 /*
  * Marks all edges in the graph with a type-1 conflict with the "type1Conflict"
  * property. A type-1 conflict is one where a non-inner segment crosses an
@@ -39,10 +40,9 @@ module.exports = {
  * single node in the layers being scanned.
  */
 function findType1Conflicts(g, layering) {
-  var conflicts = {};
-
+  let conflicts = {};
   function visitLayer(prevLayer, layer) {
-    var
+    let
       // last visited node in the previous layer that is incident on an inner
       // segment.
       k0 = 0,
@@ -51,18 +51,15 @@ function findType1Conflicts(g, layering) {
       scanPos = 0,
       prevLayerLength = prevLayer.length,
       lastNode = layer[layer.length - 1];
-
-    layer.forEach(function(v, i) {
-      var w = findOtherInnerSegmentNode(g, v),
+    layer.forEach((v, i) => {
+      let w = findOtherInnerSegmentNode(g, v),
         k1 = w ? g.node(w).order : prevLayerLength;
-
       if (w || v === lastNode) {
-        layer.slice(scanPos, i+1).forEach(function(scanNode) {
-          g.predecessors(scanNode).forEach(function(u) {
-            var uLabel = g.node(u),
+        layer.slice(scanPos, i + 1).forEach(scanNode => {
+          g.predecessors(scanNode).forEach(u => {
+            let uLabel = g.node(u),
               uPos = uLabel.order;
-            if ((uPos < k0 || k1 < uPos) &&
-                !(uLabel.dummy && g.node(scanNode).dummy)) {
+            if ((uPos < k0 || k1 < uPos) && !(uLabel.dummy && g.node(scanNode).dummy)) {
               addConflict(conflicts, u, scanNode);
             }
           });
@@ -71,42 +68,34 @@ function findType1Conflicts(g, layering) {
         k0 = k1;
       }
     });
-
     return layer;
   }
-
-  layering.reduce(visitLayer);
+  layering.length && layering.reduce(visitLayer);
   return conflicts;
 }
-
 function findType2Conflicts(g, layering) {
-  var conflicts = {};
-
+  let conflicts = {};
   function scan(south, southPos, southEnd, prevNorthBorder, nextNorthBorder) {
-    var v;
-    util.range(southPos, southEnd).forEach(function(i) {
+    let v;
+    util.range(southPos, southEnd).forEach(i => {
       v = south[i];
       if (g.node(v).dummy) {
-        g.predecessors(v).forEach(function(u) {
-          var uNode = g.node(u);
-          if (uNode.dummy &&
-              (uNode.order < prevNorthBorder || uNode.order > nextNorthBorder)) {
+        g.predecessors(v).forEach(u => {
+          let uNode = g.node(u);
+          if (uNode.dummy && (uNode.order < prevNorthBorder || uNode.order > nextNorthBorder)) {
             addConflict(conflicts, u, v);
           }
         });
       }
     });
   }
-
-
   function visitLayer(north, south) {
-    var prevNorthPos = -1,
+    let prevNorthPos = -1,
       nextNorthPos,
       southPos = 0;
-
-    south.forEach(function(v, southLookahead) {
+    south.forEach((v, southLookahead) => {
       if (g.node(v).dummy === "border") {
-        var predecessors = g.predecessors(v);
+        let predecessors = g.predecessors(v);
         if (predecessors.length) {
           nextNorthPos = g.node(predecessors[0]).order;
           scan(south, southPos, southLookahead, prevNorthPos, nextNorthPos);
@@ -116,37 +105,31 @@ function findType2Conflicts(g, layering) {
       }
       scan(south, southPos, south.length, nextNorthPos, north.length);
     });
-
     return south;
   }
-
-  layering.reduce(visitLayer);
+  layering.length && layering.reduce(visitLayer);
   return conflicts;
 }
-
 function findOtherInnerSegmentNode(g, v) {
   if (g.node(v).dummy) {
     return g.predecessors(v).find(u => g.node(u).dummy);
   }
 }
-
 function addConflict(conflicts, v, w) {
   if (v > w) {
-    var tmp = v;
+    let tmp = v;
     v = w;
     w = tmp;
   }
-
-  var conflictsV = conflicts[v];
+  let conflictsV = conflicts[v];
   if (!conflictsV) {
     conflicts[v] = conflictsV = {};
   }
   conflictsV[w] = true;
 }
-
 function hasConflict(conflicts, v, w) {
   if (v > w) {
-    var tmp = v;
+    let tmp = v;
     v = w;
     w = tmp;
   }
@@ -162,33 +145,30 @@ function hasConflict(conflicts, v, w) {
  * blocks would be split in that scenario.
  */
 function verticalAlignment(g, layering, conflicts, neighborFn) {
-  var root = {},
+  let root = {},
     align = {},
     pos = {};
 
   // We cache the position here based on the layering because the graph and
   // layering may be out of sync. The layering matrix is manipulated to
   // generate different extreme alignments.
-  layering.forEach(function(layer) {
-    layer.forEach(function(v, order) {
+  layering.forEach(layer => {
+    layer.forEach((v, order) => {
       root[v] = v;
       align[v] = v;
       pos[v] = order;
     });
   });
-
-  layering.forEach(function(layer) {
-    var prevIdx = -1;
-    layer.forEach(function(v) {
-      var ws = neighborFn(v);
+  layering.forEach(layer => {
+    let prevIdx = -1;
+    layer.forEach(v => {
+      let ws = neighborFn(v);
       if (ws.length) {
         ws = ws.sort((a, b) => pos[a] - pos[b]);
-        var mp = (ws.length - 1) / 2;
-        for (var i = Math.floor(mp), il = Math.ceil(mp); i <= il; ++i) {
-          var w = ws[i];
-          if (align[v] === v &&
-              prevIdx < pos[w] &&
-              !hasConflict(conflicts, v, w)) {
+        let mp = (ws.length - 1) / 2;
+        for (let i = Math.floor(mp), il = Math.ceil(mp); i <= il; ++i) {
+          let w = ws[i];
+          if (align[v] === v && prevIdx < pos[w] && !hasConflict(conflicts, v, w)) {
             align[w] = v;
             align[v] = root[v] = root[w];
             prevIdx = pos[w];
@@ -197,24 +177,24 @@ function verticalAlignment(g, layering, conflicts, neighborFn) {
       }
     });
   });
-
-  return { root: root, align: align };
+  return {
+    root: root,
+    align: align
+  };
 }
-
 function horizontalCompaction(g, layering, root, align, reverseSep) {
   // This portion of the algorithm differs from BK due to a number of problems.
   // Instead of their algorithm we construct a new block graph and do two
   // sweeps. The first sweep places blocks with the smallest possible
   // coordinates. The second sweep removes unused space by moving blocks to the
   // greatest coordinates without violating separation.
-  var xs = {},
+  let xs = {},
     blockG = buildBlockGraph(g, layering, root, reverseSep),
     borderType = reverseSep ? "borderLeft" : "borderRight";
-
   function iterate(setXsFunc, nextNodesFunc) {
-    var stack = blockG.nodes();
-    var elem = stack.pop();
-    var visited = {};
+    let stack = blockG.nodes();
+    let elem = stack.pop();
+    let visited = {};
     while (elem) {
       if (visited[elem]) {
         setXsFunc(elem);
@@ -223,49 +203,42 @@ function horizontalCompaction(g, layering, root, align, reverseSep) {
         stack.push(elem);
         stack = stack.concat(nextNodesFunc(elem));
       }
-
       elem = stack.pop();
     }
   }
 
   // First pass, assign smallest coordinates
   function pass1(elem) {
-    xs[elem] = blockG.inEdges(elem).reduce(function(acc, e) {
+    xs[elem] = blockG.inEdges(elem).reduce((acc, e) => {
       return Math.max(acc, xs[e.v] + blockG.edge(e));
     }, 0);
   }
 
   // Second pass, assign greatest coordinates
   function pass2(elem) {
-    var min = blockG.outEdges(elem).reduce(function(acc, e) {
+    let min = blockG.outEdges(elem).reduce((acc, e) => {
       return Math.min(acc, xs[e.w] - blockG.edge(e));
     }, Number.POSITIVE_INFINITY);
-
-    var node = g.node(elem);
+    let node = g.node(elem);
     if (min !== Number.POSITIVE_INFINITY && node.borderType !== borderType) {
       xs[elem] = Math.max(xs[elem], min);
     }
   }
-
   iterate(pass1, blockG.predecessors.bind(blockG));
   iterate(pass2, blockG.successors.bind(blockG));
 
   // Assign x coordinates to all nodes
   Object.keys(align).forEach(v => xs[v] = xs[root[v]]);
-
   return xs;
 }
-
-
 function buildBlockGraph(g, layering, root, reverseSep) {
-  var blockGraph = new Graph(),
+  let blockGraph = new _graphlib.Graph(),
     graphLabel = g.graph(),
     sepFn = sep(graphLabel.nodesep, graphLabel.edgesep, reverseSep);
-
-  layering.forEach(function(layer) {
-    var u;
-    layer.forEach(function(v) {
-      var vRoot = root[v];
+  layering.forEach(layer => {
+    let u;
+    layer.forEach(v => {
+      let vRoot = root[v];
       blockGraph.setNode(vRoot);
       if (u) {
         var uRoot = root[u],
@@ -275,7 +248,6 @@ function buildBlockGraph(g, layering, root, reverseSep) {
       u = v;
     });
   });
-
   return blockGraph;
 }
 
@@ -284,16 +256,13 @@ function buildBlockGraph(g, layering, root, reverseSep) {
  */
 function findSmallestWidthAlignment(g, xss) {
   return Object.values(xss).reduce((currentMinAndXs, xs) => {
-    var max = Number.NEGATIVE_INFINITY;
-    var min = Number.POSITIVE_INFINITY;
-
+    let max = Number.NEGATIVE_INFINITY;
+    let min = Number.POSITIVE_INFINITY;
     Object.entries(xs).forEach(([v, x]) => {
-      var halfWidth = width(g, v) / 2;
-
+      let halfWidth = width(g, v) / 2;
       max = Math.max(x + halfWidth, max);
       min = Math.min(x - halfWidth, min);
     });
-
     const newMin = max - min;
     if (newMin < currentMinAndXs[0]) {
       currentMinAndXs = [newMin, xs];
@@ -310,113 +279,102 @@ function findSmallestWidthAlignment(g, xss) {
  * coordinate of the smallest width alignment.
  */
 function alignCoordinates(xss, alignTo) {
-  var alignToVals = Object.values(alignTo),
+  let alignToVals = Object.values(alignTo),
     alignToMin = Math.min(...alignToVals),
     alignToMax = Math.max(...alignToVals);
-
-  ["u", "d"].forEach(function(vert) {
-    ["l", "r"].forEach(function(horiz) {
-      var alignment = vert + horiz,
+  ["u", "d"].forEach(vert => {
+    ["l", "r"].forEach(horiz => {
+      let alignment = vert + horiz,
         xs = xss[alignment];
-
       if (xs === alignTo) return;
-
-      var xsVals = Object.values(xs);
+      let xsVals = Object.values(xs);
       let delta = alignToMin - Math.min(...xsVals);
       if (horiz !== "l") {
         delta = alignToMax - Math.max(...xsVals);
       }
-
       if (delta) {
         xss[alignment] = util.mapValues(xs, x => x + delta);
       }
     });
   });
 }
-
 function balance(xss, align) {
-  return util.mapValues(xss.ul, function(num, v) {
+  return util.mapValues(xss.ul, (num, v) => {
     if (align) {
       return xss[align.toLowerCase()][v];
     } else {
-      var xs = Object.values(xss).map(xs => xs[v]).sort((a, b) => a - b);
+      let xs = Object.values(xss).map(xs => xs[v]).sort((a, b) => a - b);
       return (xs[1] + xs[2]) / 2;
     }
   });
 }
-
 function positionX(g) {
-  var layering = util.buildLayerMatrix(g);
-  var conflicts = Object.assign(
-    findType1Conflicts(g, layering),
-    findType2Conflicts(g, layering));
-
-  var xss = {};
-  var adjustedLayering;
-  ["u", "d"].forEach(function(vert) {
+  let layering = util.buildLayerMatrix(g);
+  let conflicts = Object.assign(findType1Conflicts(g, layering), findType2Conflicts(g, layering));
+  let xss = {};
+  let adjustedLayering;
+  ["u", "d"].forEach(vert => {
     adjustedLayering = vert === "u" ? layering : Object.values(layering).reverse();
-    ["l", "r"].forEach(function(horiz) {
+    ["l", "r"].forEach(horiz => {
       if (horiz === "r") {
         adjustedLayering = adjustedLayering.map(inner => {
           return Object.values(inner).reverse();
         });
       }
-
-      var neighborFn = (vert === "u" ? g.predecessors : g.successors).bind(g);
-      var align = verticalAlignment(g, adjustedLayering, conflicts, neighborFn);
-      var xs = horizontalCompaction(g, adjustedLayering,
-        align.root, align.align, horiz === "r");
+      let neighborFn = (vert === "u" ? g.predecessors : g.successors).bind(g);
+      let align = verticalAlignment(g, adjustedLayering, conflicts, neighborFn);
+      let xs = horizontalCompaction(g, adjustedLayering, align.root, align.align, horiz === "r");
       if (horiz === "r") {
         xs = util.mapValues(xs, x => -x);
       }
       xss[vert + horiz] = xs;
     });
   });
-
-
-  var smallestWidth = findSmallestWidthAlignment(g, xss);
+  let smallestWidth = findSmallestWidthAlignment(g, xss);
   alignCoordinates(xss, smallestWidth);
   return balance(xss, g.graph().align);
 }
-
 function sep(nodeSep, edgeSep, reverseSep) {
-  return function(g, v, w) {
-    var vLabel = g.node(v);
-    var wLabel = g.node(w);
-    var sum = 0;
-    var delta;
-
+  return (g, v, w) => {
+    let vLabel = g.node(v);
+    let wLabel = g.node(w);
+    let sum = 0;
+    let delta;
     sum += vLabel.width / 2;
     if (vLabel.hasOwnProperty("labelpos")) {
       switch (vLabel.labelpos.toLowerCase()) {
-      case "l": delta = -vLabel.width / 2; break;
-      case "r": delta = vLabel.width / 2; break;
+        case "l":
+          delta = -vLabel.width / 2;
+          break;
+        case "r":
+          delta = vLabel.width / 2;
+          break;
       }
     }
     if (delta) {
       sum += reverseSep ? delta : -delta;
     }
     delta = 0;
-
     sum += (vLabel.dummy ? edgeSep : nodeSep) / 2;
     sum += (wLabel.dummy ? edgeSep : nodeSep) / 2;
-
     sum += wLabel.width / 2;
     if (wLabel.hasOwnProperty("labelpos")) {
       switch (wLabel.labelpos.toLowerCase()) {
-      case "l": delta = wLabel.width / 2; break;
-      case "r": delta = -wLabel.width / 2; break;
+        case "l":
+          delta = wLabel.width / 2;
+          break;
+        case "r":
+          delta = -wLabel.width / 2;
+          break;
       }
     }
     if (delta) {
       sum += reverseSep ? delta : -delta;
     }
     delta = 0;
-
     return sum;
   };
 }
-
 function width(g, v) {
   return g.node(v).width;
 }

package/lib/position/index.js

@@ -1,22 +1,23 @@
 "use strict";
 
-var util = require("../util");
-var positionX = require("./bk").positionX;
-
-module.exports = position;
-
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = position;
+var util = _interopRequireWildcard(require("../util.js"));
+var _bk = require("./bk.js");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 function position(g) {
   g = util.asNonCompoundGraph(g);
-
   positionY(g);
-  Object.entries(positionX(g)).forEach(([v, x]) => g.node(v).x = x);
+  Object.entries((0, _bk.positionX)(g)).forEach(([v, x]) => g.node(v).x = x);
 }
-
 function positionY(g) {
-  var layering = util.buildLayerMatrix(g);
-  var rankSep = g.graph().ranksep;
-  var prevY = 0;
-  layering.forEach(function(layer) {
+  let layering = util.buildLayerMatrix(g);
+  let rankSep = g.graph().ranksep;
+  let prevY = 0;
+  layering.forEach(layer => {
     const maxHeight = layer.reduce((acc, v) => {
       const height = g.node(v).height;
       if (acc > height) {
@@ -29,4 +30,4 @@ function positionY(g) {
     prevY += maxHeight + rankSep;
   });
 }
-
+module.exports = exports.default;

package/lib/rank/feasible-tree.js

@@ -1,10 +1,11 @@
 "use strict";
 
-var Graph = require("@dagrejs/graphlib").Graph;
-var slack = require("./util").slack;
-
-module.exports = feasibleTree;
-
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = feasibleTree;
+var _graphlib = require("@dagrejs/graphlib");
+var _util = require("./util.js");
 /*
  * 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
@@ -31,20 +32,20 @@ module.exports = feasibleTree;
  * edges.
  */
 function feasibleTree(g) {
-  var t = new Graph({ directed: false });
+  var t = new _graphlib.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);
+    delta = t.hasNode(edge.v) ? (0, _util.slack)(g, edge) : -(0, _util.slack)(g, edge);
     shiftRanks(t, g, delta);
   }
-
   return t;
 }
 
@@ -54,17 +55,16 @@ function feasibleTree(g) {
  */
 function tightTree(t, g) {
   function dfs(v) {
-    g.nodeEdges(v).forEach(function(e) {
+    g.nodeEdges(v).forEach(e => {
       var edgeV = e.v,
-        w = (v === edgeV) ? e.w : edgeV;
-      if (!t.hasNode(w) && !slack(g, e)) {
+        w = v === edgeV ? e.w : edgeV;
+      if (!t.hasNode(w) && !(0, _util.slack)(g, e)) {
         t.setNode(w, {});
         t.setEdge(v, w, {});
         dfs(w);
       }
     });
   }
-
   t.nodes().forEach(dfs);
   return t.nodeCount();
 }
@@ -75,21 +75,18 @@ function tightTree(t, g) {
  */
 function findMinSlackEdge(t, g) {
   const edges = g.edges();
-
   return edges.reduce((acc, edge) => {
     let edgeSlack = Number.POSITIVE_INFINITY;
     if (t.hasNode(edge.v) !== t.hasNode(edge.w)) {
-      edgeSlack = slack(g, edge);
+      edgeSlack = (0, _util.slack)(g, edge);
     }
-
     if (edgeSlack < acc[0]) {
       return [edgeSlack, edge];
     }
-
     return acc;
   }, [Number.POSITIVE_INFINITY, null])[1];
 }
-
 function shiftRanks(t, g, delta) {
   t.nodes().forEach(v => g.node(v).rank += delta);
 }
+module.exports = exports.default;

package/lib/rank/index.js

@@ -1,12 +1,16 @@
 "use strict";
 
-var rankUtil = require("./util");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = rank;
+var rankUtil = _interopRequireWildcard(require("./util.js"));
+var _feasibleTree = _interopRequireDefault(require("./feasible-tree.js"));
+var _networkSimplex = _interopRequireDefault(require("./network-simplex.js"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
 var longestPath = rankUtil.longestPath;
-var feasibleTree = require("./feasible-tree");
-var networkSimplex = require("./network-simplex");
-
-module.exports = rank;
-
 /*
  * Assigns a rank to each node in the input graph that respects the "minlen"
  * constraint specified on edges between nodes.
@@ -27,22 +31,28 @@ module.exports = rank;
  *       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);
+  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);
+  (0, _feasibleTree.default)(g);
 }
-
 function networkSimplexRanker(g) {
-  networkSimplex(g);
+  (0, _networkSimplex.default)(g);
 }
+module.exports = exports.default;