@dagrejs/dagre 1.0.1 → 1.0.4

package/lib/layout.js

@@ -1,59 +1,59 @@
 "use strict";
 
-var acyclic = require("./acyclic");
-var normalize = require("./normalize");
-var rank = require("./rank");
-var normalizeRanks = require("./util").normalizeRanks;
-var parentDummyChains = require("./parent-dummy-chains");
-var removeEmptyRanks = require("./util").removeEmptyRanks;
-var nestingGraph = require("./nesting-graph");
-var addBorderSegments = require("./add-border-segments");
-var coordinateSystem = require("./coordinate-system");
-var order = require("./order");
-var position = require("./position");
-var util = require("./util");
-var Graph = require("@dagrejs/graphlib").Graph;
+let acyclic = require("./acyclic");
+let normalize = require("./normalize");
+let rank = require("./rank");
+let normalizeRanks = require("./util").normalizeRanks;
+let parentDummyChains = require("./parent-dummy-chains");
+let removeEmptyRanks = require("./util").removeEmptyRanks;
+let nestingGraph = require("./nesting-graph");
+let addBorderSegments = require("./add-border-segments");
+let coordinateSystem = require("./coordinate-system");
+let order = require("./order");
+let position = require("./position");
+let util = require("./util");
+let Graph = require("@dagrejs/graphlib").Graph;
 
 module.exports = layout;
 
 function layout(g, opts) {
-  var time = opts && opts.debugTiming ? util.time : util.notime;
-  time("layout", function() {
-    var layoutGraph =
-      time("  buildLayoutGraph", function() { return buildLayoutGraph(g); });
-    time("  runLayout",        function() { runLayout(layoutGraph, time); });
-    time("  updateInputGraph", function() { updateInputGraph(g, layoutGraph); });
+  let time = opts && opts.debugTiming ? util.time : util.notime;
+  time("layout", () => {
+    let layoutGraph =
+      time("  buildLayoutGraph", () => buildLayoutGraph(g));
+    time("  runLayout",        () => runLayout(layoutGraph, time));
+    time("  updateInputGraph", () => updateInputGraph(g, layoutGraph));
   });
 }
 
 function runLayout(g, time) {
-  time("    makeSpaceForEdgeLabels", function() { makeSpaceForEdgeLabels(g); });
-  time("    removeSelfEdges",        function() { removeSelfEdges(g); });
-  time("    acyclic",                function() { acyclic.run(g); });
-  time("    nestingGraph.run",       function() { nestingGraph.run(g); });
-  time("    rank",                   function() { rank(util.asNonCompoundGraph(g)); });
-  time("    injectEdgeLabelProxies", function() { injectEdgeLabelProxies(g); });
-  time("    removeEmptyRanks",       function() { removeEmptyRanks(g); });
-  time("    nestingGraph.cleanup",   function() { nestingGraph.cleanup(g); });
-  time("    normalizeRanks",         function() { normalizeRanks(g); });
-  time("    assignRankMinMax",       function() { assignRankMinMax(g); });
-  time("    removeEdgeLabelProxies", function() { removeEdgeLabelProxies(g); });
-  time("    normalize.run",          function() { normalize.run(g); });
-  time("    parentDummyChains",      function() { parentDummyChains(g); });
-  time("    addBorderSegments",      function() { addBorderSegments(g); });
-  time("    order",                  function() { order(g); });
-  time("    insertSelfEdges",        function() { insertSelfEdges(g); });
-  time("    adjustCoordinateSystem", function() { coordinateSystem.adjust(g); });
-  time("    position",               function() { position(g); });
-  time("    positionSelfEdges",      function() { positionSelfEdges(g); });
-  time("    removeBorderNodes",      function() { removeBorderNodes(g); });
-  time("    normalize.undo",         function() { normalize.undo(g); });
-  time("    fixupEdgeLabelCoords",   function() { fixupEdgeLabelCoords(g); });
-  time("    undoCoordinateSystem",   function() { coordinateSystem.undo(g); });
-  time("    translateGraph",         function() { translateGraph(g); });
-  time("    assignNodeIntersects",   function() { assignNodeIntersects(g); });
-  time("    reversePoints",          function() { reversePointsForReversedEdges(g); });
-  time("    acyclic.undo",           function() { acyclic.undo(g); });
+  time("    makeSpaceForEdgeLabels", () => makeSpaceForEdgeLabels(g));
+  time("    removeSelfEdges",        () => removeSelfEdges(g));
+  time("    acyclic",                () => acyclic.run(g));
+  time("    nestingGraph.run",       () => nestingGraph.run(g));
+  time("    rank",                   () => rank(util.asNonCompoundGraph(g)));
+  time("    injectEdgeLabelProxies", () => injectEdgeLabelProxies(g));
+  time("    removeEmptyRanks",       () => removeEmptyRanks(g));
+  time("    nestingGraph.cleanup",   () => nestingGraph.cleanup(g));
+  time("    normalizeRanks",         () => normalizeRanks(g));
+  time("    assignRankMinMax",       () => assignRankMinMax(g));
+  time("    removeEdgeLabelProxies", () => removeEdgeLabelProxies(g));
+  time("    normalize.run",          () => normalize.run(g));
+  time("    parentDummyChains",      () => parentDummyChains(g));
+  time("    addBorderSegments",      () => addBorderSegments(g));
+  time("    order",                  () => order(g));
+  time("    insertSelfEdges",        () => insertSelfEdges(g));
+  time("    adjustCoordinateSystem", () => coordinateSystem.adjust(g));
+  time("    position",               () => position(g));
+  time("    positionSelfEdges",      () => positionSelfEdges(g));
+  time("    removeBorderNodes",      () => removeBorderNodes(g));
+  time("    normalize.undo",         () => normalize.undo(g));
+  time("    fixupEdgeLabelCoords",   () => fixupEdgeLabelCoords(g));
+  time("    undoCoordinateSystem",   () => coordinateSystem.undo(g));
+  time("    translateGraph",         () => translateGraph(g));
+  time("    assignNodeIntersects",   () => assignNodeIntersects(g));
+  time("    reversePoints",          () => reversePointsForReversedEdges(g));
+  time("    acyclic.undo",           () => acyclic.undo(g));
 }
 
 /*
@@ -64,8 +64,8 @@ function runLayout(g, time) {
  */
 function updateInputGraph(inputGraph, layoutGraph) {
   inputGraph.nodes().forEach(v => {
-    var inputLabel = inputGraph.node(v);
-    var layoutLabel = layoutGraph.node(v);
+    let inputLabel = inputGraph.node(v);
+    let layoutLabel = layoutGraph.node(v);
 
     if (inputLabel) {
       inputLabel.x = layoutLabel.x;
@@ -80,8 +80,8 @@ function updateInputGraph(inputGraph, layoutGraph) {
   });
 
   inputGraph.edges().forEach(e => {
-    var inputLabel = inputGraph.edge(e);
-    var layoutLabel = layoutGraph.edge(e);
+    let inputLabel = inputGraph.edge(e);
+    let layoutLabel = layoutGraph.edge(e);
 
     inputLabel.points = layoutLabel.points;
     if (layoutLabel.hasOwnProperty("x")) {
@@ -94,17 +94,17 @@ function updateInputGraph(inputGraph, layoutGraph) {
   inputGraph.graph().height = layoutGraph.graph().height;
 }
 
-var graphNumAttrs = ["nodesep", "edgesep", "ranksep", "marginx", "marginy"];
-var graphDefaults = { ranksep: 50, edgesep: 20, nodesep: 50, rankdir: "tb" };
-var graphAttrs = ["acyclicer", "ranker", "rankdir", "align"];
-var nodeNumAttrs = ["width", "height"];
-var nodeDefaults = { width: 0, height: 0 };
-var edgeNumAttrs = ["minlen", "weight", "width", "height", "labeloffset"];
-var edgeDefaults = {
+let graphNumAttrs = ["nodesep", "edgesep", "ranksep", "marginx", "marginy"];
+let graphDefaults = { ranksep: 50, edgesep: 20, nodesep: 50, rankdir: "tb" };
+let graphAttrs = ["acyclicer", "ranker", "rankdir", "align"];
+let nodeNumAttrs = ["width", "height"];
+let nodeDefaults = { width: 0, height: 0 };
+let edgeNumAttrs = ["minlen", "weight", "width", "height", "labeloffset"];
+let edgeDefaults = {
   minlen: 1, weight: 1, width: 0, height: 0,
   labeloffset: 10, labelpos: "r"
 };
-var edgeAttrs = ["labelpos"];
+let edgeAttrs = ["labelpos"];
 
 /*
  * Constructs a new graph from the input graph, which can be used for layout.
@@ -113,8 +113,8 @@ var edgeAttrs = ["labelpos"];
  * attributes can influence layout.
  */
 function buildLayoutGraph(inputGraph) {
-  var g = new Graph({ multigraph: true, compound: true });
-  var graph = canonicalize(inputGraph.graph());
+  let g = new Graph({ multigraph: true, compound: true });
+  let graph = canonicalize(inputGraph.graph());
 
   g.setGraph(Object.assign({},
     graphDefaults,
@@ -122,7 +122,7 @@ function buildLayoutGraph(inputGraph) {
     util.pick(graph, graphAttrs)));
 
   inputGraph.nodes().forEach(v => {
-    var node = canonicalize(inputGraph.node(v));
+    let node = canonicalize(inputGraph.node(v));
     const newNode = selectNumberAttrs(node, nodeNumAttrs);
     Object.keys(nodeDefaults).forEach(k => {
       if (newNode[k] === undefined) {
@@ -135,7 +135,7 @@ function buildLayoutGraph(inputGraph) {
   });
 
   inputGraph.edges().forEach(e => {
-    var edge = canonicalize(inputGraph.edge(e));
+    let edge = canonicalize(inputGraph.edge(e));
     g.setEdge(e, Object.assign({},
       edgeDefaults,
       selectNumberAttrs(edge, edgeNumAttrs),
@@ -154,10 +154,10 @@ function buildLayoutGraph(inputGraph) {
  * away from the edge itself a bit.
  */
 function makeSpaceForEdgeLabels(g) {
-  var graph = g.graph();
+  let graph = g.graph();
   graph.ranksep /= 2;
   g.edges().forEach(e => {
-    var edge = g.edge(e);
+    let edge = g.edge(e);
     edge.minlen *= 2;
     if (edge.labelpos.toLowerCase() !== "c") {
       if (graph.rankdir === "TB" || graph.rankdir === "BT") {
@@ -177,20 +177,20 @@ function makeSpaceForEdgeLabels(g) {
  */
 function injectEdgeLabelProxies(g) {
   g.edges().forEach(e => {
-    var edge = g.edge(e);
+    let edge = g.edge(e);
     if (edge.width && edge.height) {
-      var v = g.node(e.v);
-      var w = g.node(e.w);
-      var label = { rank: (w.rank - v.rank) / 2 + v.rank, e: e };
+      let v = g.node(e.v);
+      let w = g.node(e.w);
+      let label = { rank: (w.rank - v.rank) / 2 + v.rank, e: e };
       util.addDummyNode(g, "edge-proxy", label, "_ep");
     }
   });
 }
 
 function assignRankMinMax(g) {
-  var maxRank = 0;
+  let maxRank = 0;
   g.nodes().forEach(v => {
-    var node = g.node(v);
+    let node = g.node(v);
     if (node.borderTop) {
       node.minRank = g.node(node.borderTop).rank;
       node.maxRank = g.node(node.borderBottom).rank;
@@ -202,7 +202,7 @@ function assignRankMinMax(g) {
 
 function removeEdgeLabelProxies(g) {
   g.nodes().forEach(v => {
-    var node = g.node(v);
+    let node = g.node(v);
     if (node.dummy === "edge-proxy") {
       g.edge(node.e).labelRank = node.rank;
       g.removeNode(v);
@@ -211,19 +211,19 @@ function removeEdgeLabelProxies(g) {
 }
 
 function translateGraph(g) {
-  var minX = Number.POSITIVE_INFINITY;
-  var maxX = 0;
-  var minY = Number.POSITIVE_INFINITY;
-  var maxY = 0;
-  var graphLabel = g.graph();
-  var marginX = graphLabel.marginx || 0;
-  var marginY = graphLabel.marginy || 0;
+  let minX = Number.POSITIVE_INFINITY;
+  let maxX = 0;
+  let minY = Number.POSITIVE_INFINITY;
+  let maxY = 0;
+  let graphLabel = g.graph();
+  let marginX = graphLabel.marginx || 0;
+  let marginY = graphLabel.marginy || 0;
 
   function getExtremes(attrs) {
-    var x = attrs.x;
-    var y = attrs.y;
-    var w = attrs.width;
-    var h = attrs.height;
+    let x = attrs.x;
+    let y = attrs.y;
+    let w = attrs.width;
+    let h = attrs.height;
     minX = Math.min(minX, x - w / 2);
     maxX = Math.max(maxX, x + w / 2);
     minY = Math.min(minY, y - h / 2);
@@ -232,7 +232,7 @@ function translateGraph(g) {
 
   g.nodes().forEach(v => getExtremes(g.node(v)));
   g.edges().forEach(e => {
-    var edge = g.edge(e);
+    let edge = g.edge(e);
     if (edge.hasOwnProperty("x")) {
       getExtremes(edge);
     }
@@ -242,13 +242,13 @@ function translateGraph(g) {
   minY -= marginY;
 
   g.nodes().forEach(v => {
-    var node = g.node(v);
+    let node = g.node(v);
     node.x -= minX;
     node.y -= minY;
   });
 
   g.edges().forEach(e => {
-    var edge = g.edge(e);
+    let edge = g.edge(e);
     edge.points.forEach(p => {
       p.x -= minX;
       p.y -= minY;
@@ -263,10 +263,10 @@ function translateGraph(g) {
 
 function assignNodeIntersects(g) {
   g.edges().forEach(e => {
-    var edge = g.edge(e);
-    var nodeV = g.node(e.v);
-    var nodeW = g.node(e.w);
-    var p1, p2;
+    let edge = g.edge(e);
+    let nodeV = g.node(e.v);
+    let nodeW = g.node(e.w);
+    let p1, p2;
     if (!edge.points) {
       edge.points = [];
       p1 = nodeW;
@@ -282,7 +282,7 @@ function assignNodeIntersects(g) {
 
 function fixupEdgeLabelCoords(g) {
   g.edges().forEach(e => {
-    var edge = g.edge(e);
+    let edge = g.edge(e);
     if (edge.hasOwnProperty("x")) {
       if (edge.labelpos === "l" || edge.labelpos === "r") {
         edge.width -= edge.labeloffset;
@@ -297,7 +297,7 @@ function fixupEdgeLabelCoords(g) {
 
 function reversePointsForReversedEdges(g) {
   g.edges().forEach(e => {
-    var edge = g.edge(e);
+    let edge = g.edge(e);
     if (edge.reversed) {
       edge.points.reverse();
     }
@@ -307,11 +307,11 @@ function reversePointsForReversedEdges(g) {
 function removeBorderNodes(g) {
   g.nodes().forEach(v => {
     if (g.children(v).length) {
-      var node = g.node(v);
-      var t = g.node(node.borderTop);
-      var b = g.node(node.borderBottom);
-      var l = g.node(node.borderLeft[node.borderLeft.length - 1]);
-      var r = g.node(node.borderRight[node.borderRight.length - 1]);
+      let node = g.node(v);
+      let t = g.node(node.borderTop);
+      let b = g.node(node.borderBottom);
+      let l = g.node(node.borderLeft[node.borderLeft.length - 1]);
+      let r = g.node(node.borderRight[node.borderRight.length - 1]);
 
       node.width = Math.abs(r.x - l.x);
       node.height = Math.abs(b.y - t.y);

package/lib/nesting-graph.js

@@ -1,14 +1,14 @@
-var util = require("./util");
+let util = require("./util");
 
 module.exports = {
-  run: run,
-  cleanup: cleanup
+  run,
+  cleanup,
 };
 
 /*
  * A nesting graph creates dummy nodes for the tops and bottoms of subgraphs,
  * adds appropriate edges to ensure that all cluster nodes are placed between
- * these boundries, and ensures that the graph is connected.
+ * these boundaries, and ensures that the graph is connected.
  *
  * In addition we ensure, through the use of the minlen property, that nodes
  * and subgraph border nodes to not end up on the same rank.
@@ -29,10 +29,10 @@ module.exports = {
  * Graphs."
  */
 function run(g) {
-  var root = util.addDummyNode(g, "root", {}, "_root");
-  var depths = treeDepths(g);
-  var height = Math.max(...Object.values(depths)) - 1; // Note: depths is an Object not an array
-  var nodeSep = 2 * height + 1;
+  let root = util.addDummyNode(g, "root", {}, "_root");
+  let depths = treeDepths(g);
+  let height = Math.max(...Object.values(depths)) - 1; // Note: depths is an Object not an array
+  let nodeSep = 2 * height + 1;
 
   g.graph().nestingRoot = root;
 
@@ -40,12 +40,10 @@ function run(g) {
   g.edges().forEach(e => g.edge(e).minlen *= nodeSep);
 
   // Calculate a weight that is sufficient to keep subgraphs vertically compact
-  var weight = sumWeights(g) + 1;
+  let weight = sumWeights(g) + 1;
 
   // Create border nodes and link them up
-  g.children().forEach(function(child) {
-    dfs(g, root, nodeSep, weight, height, depths, child);
-  });
+  g.children().forEach(child => dfs(g, root, nodeSep, weight, height, depths, child));
 
   // Save the multiplier for node layers for later removal of empty border
   // layers.
@@ -53,7 +51,7 @@ function run(g) {
 }
 
 function dfs(g, root, nodeSep, weight, height, depths, v) {
-  var children = g.children(v);
+  let children = g.children(v);
   if (!children.length) {
     if (v !== root) {
       g.setEdge(root, v, { weight: 0, minlen: nodeSep });
@@ -61,23 +59,23 @@ function dfs(g, root, nodeSep, weight, height, depths, v) {
     return;
   }
 
-  var top = util.addBorderNode(g, "_bt");
-  var bottom = util.addBorderNode(g, "_bb");
-  var label = g.node(v);
+  let top = util.addBorderNode(g, "_bt");
+  let bottom = util.addBorderNode(g, "_bb");
+  let label = g.node(v);
 
   g.setParent(top, v);
   label.borderTop = top;
   g.setParent(bottom, v);
   label.borderBottom = bottom;
 
-  children.forEach(function(child) {
+  children.forEach(child => {
     dfs(g, root, nodeSep, weight, height, depths, child);
 
-    var childNode = g.node(child);
-    var childTop = childNode.borderTop ? childNode.borderTop : child;
-    var childBottom = childNode.borderBottom ? childNode.borderBottom : child;
-    var thisWeight = childNode.borderTop ? weight : 2 * weight;
-    var minlen = childTop !== childBottom ? 1 : height - depths[v] + 1;
+    let childNode = g.node(child);
+    let childTop = childNode.borderTop ? childNode.borderTop : child;
+    let childBottom = childNode.borderBottom ? childNode.borderBottom : child;
+    let thisWeight = childNode.borderTop ? weight : 2 * weight;
+    let minlen = childTop !== childBottom ? 1 : height - depths[v] + 1;
 
     g.setEdge(top, childTop, {
       weight: thisWeight,

package/lib/normalize.js

@@ -1,6 +1,6 @@
 "use strict";
 
-var util = require("./util");
+let util = require("./util");
 
 module.exports = {
   run: run,
@@ -29,19 +29,19 @@ function run(g) {
 }
 
 function normalizeEdge(g, e) {
-  var v = e.v;
-  var vRank = g.node(v).rank;
-  var w = e.w;
-  var wRank = g.node(w).rank;
-  var name = e.name;
-  var edgeLabel = g.edge(e);
-  var labelRank = edgeLabel.labelRank;
+  let v = e.v;
+  let vRank = g.node(v).rank;
+  let w = e.w;
+  let wRank = g.node(w).rank;
+  let name = e.name;
+  let edgeLabel = g.edge(e);
+  let labelRank = edgeLabel.labelRank;
 
   if (wRank === vRank + 1) return;
 
   g.removeEdge(e);
 
-  var dummy, attrs, i;
+  let dummy, attrs, i;
   for (i = 0, ++vRank; vRank < wRank; ++i, ++vRank) {
     edgeLabel.points = [];
     attrs = {
@@ -67,10 +67,10 @@ function normalizeEdge(g, e) {
 }
 
 function undo(g) {
-  g.graph().dummyChains.forEach(function(v) {
-    var node = g.node(v);
-    var origLabel = node.edgeLabel;
-    var w;
+  g.graph().dummyChains.forEach(v => {
+    let node = g.node(v);
+    let origLabel = node.edgeLabel;
+    let w;
     g.setEdge(node.edgeObj, origLabel);
     while (node.dummy) {
       w = g.successors(v)[0];

package/lib/order/add-subgraph-constraints.js

@@ -1,11 +1,11 @@
 module.exports = addSubgraphConstraints;
 
 function addSubgraphConstraints(g, cg, vs) {
-  var prev = {},
+  let prev = {},
     rootPrev;
 
-  vs.forEach(function(v) {
-    var child = g.parent(v),
+  vs.forEach(v => {
+    let child = g.parent(v),
       parent,
       prevChild;
     while (child) {

package/lib/order/barycenter.js

@@ -2,12 +2,12 @@ module.exports = barycenter;
 
 function barycenter(g, movable = []) {
   return movable.map(v => {
-    var inV = g.inEdges(v);
+    let inV = g.inEdges(v);
     if (!inV.length) {
       return { v: v };
     } else {
-      var result = inV.reduce((acc, e) => {
-        var edge = g.edge(e),
+      let result = inV.reduce((acc, e) => {
+        let edge = g.edge(e),
           nodeU = g.node(e.v);
         return {
           sum: acc.sum + (edge.weight * nodeU.order),

package/lib/order/build-layer-graph.js

@@ -1,5 +1,5 @@
-var Graph = require("@dagrejs/graphlib").Graph;
-var util = require("../util");
+let Graph = require("@dagrejs/graphlib").Graph;
+let util = require("../util");
 
 module.exports = buildLayerGraph;
 
@@ -34,12 +34,12 @@ module.exports = buildLayerGraph;
  *       graph is not a multi-graph.
  */
 function buildLayerGraph(g, rank, relationship) {
-  var root = createRootNode(g),
+  let root = createRootNode(g),
     result = new Graph({ compound: true }).setGraph({ root: root })
-      .setDefaultNodeLabel(function(v) { return g.node(v); });
+      .setDefaultNodeLabel(v => g.node(v));
 
-  g.nodes().forEach(function(v) {
-    var node = g.node(v),
+  g.nodes().forEach(v => {
+    let node = g.node(v),
       parent = g.parent(v);
 
     if (node.rank === rank || node.minRank <= rank && rank <= node.maxRank) {
@@ -47,8 +47,8 @@ function buildLayerGraph(g, rank, relationship) {
       result.setParent(v, parent || root);
 
       // This assumes we have only short edges!
-      g[relationship](v).forEach(function(e) {
-        var u = e.v === v ? e.w : e.v,
+      g[relationship](v).forEach(e => {
+        let u = e.v === v ? e.w : e.v,
           edge = result.edge(u, v),
           weight = edge !== undefined ? edge.weight : 0;
         result.setEdge(u, v, { weight: g.edge(e).weight + weight });

package/lib/order/cross-count.js

@@ -1,6 +1,6 @@
 "use strict";
 
-var zipObject = require("../util").zipObject;
+let zipObject = require("../util").zipObject;
 
 module.exports = crossCount;
 
@@ -21,8 +21,8 @@ module.exports = crossCount;
  * This algorithm is derived from Barth, et al., "Bilayer Cross Counting."
  */
 function crossCount(g, layering) {
-  var cc = 0;
-  for (var i = 1; i < layering.length; ++i) {
+  let cc = 0;
+  for (let i = 1; i < layering.length; ++i) {
     cc += twoLayerCrossCount(g, layering[i-1], layering[i]);
   }
   return cc;
@@ -32,26 +32,26 @@ function twoLayerCrossCount(g, northLayer, southLayer) {
   // Sort all of the edges between the north and south layers by their position
   // in the north layer and then the south. Map these edges to the position of
   // their head in the south layer.
-  var southPos = zipObject(southLayer, southLayer.map((v, i) => i));
-  var southEntries = northLayer.flatMap(v => {
+  let southPos = zipObject(southLayer, southLayer.map((v, i) => i));
+  let southEntries = northLayer.flatMap(v => {
     return g.outEdges(v).map(e => {
       return { pos: southPos[e.w], weight: g.edge(e).weight };
     }).sort((a, b) => a.pos - b.pos);
   });
 
   // Build the accumulator tree
-  var firstIndex = 1;
+  let firstIndex = 1;
   while (firstIndex < southLayer.length) firstIndex <<= 1;
-  var treeSize = 2 * firstIndex - 1;
+  let treeSize = 2 * firstIndex - 1;
   firstIndex -= 1;
-  var tree = new Array(treeSize).fill(0);
+  let tree = new Array(treeSize).fill(0);
 
   // Calculate the weighted crossings
-  var cc = 0;
+  let cc = 0;
   southEntries.forEach(entry => {
-    var index = entry.pos + firstIndex;
+    let index = entry.pos + firstIndex;
     tree[index] += entry.weight;
-    var weightSum = 0;
+    let weightSum = 0;
     while (index > 0) {
       if (index % 2) {
         weightSum += tree[index + 1];

package/lib/order/index.js

@@ -1,12 +1,12 @@
 "use strict";
 
-var initOrder = require("./init-order");
-var crossCount = require("./cross-count");
-var sortSubgraph = require("./sort-subgraph");
-var buildLayerGraph = require("./build-layer-graph");
-var addSubgraphConstraints = require("./add-subgraph-constraints");
-var Graph = require("@dagrejs/graphlib").Graph;
-var util = require("../util");
+let initOrder = require("./init-order");
+let crossCount = require("./cross-count");
+let sortSubgraph = require("./sort-subgraph");
+let buildLayerGraph = require("./build-layer-graph");
+let addSubgraphConstraints = require("./add-subgraph-constraints");
+let Graph = require("@dagrejs/graphlib").Graph;
+let util = require("../util");
 
 module.exports = order;
 
@@ -26,21 +26,21 @@ module.exports = order;
  *       algorithm.
  */
 function order(g) {
-  var maxRank = util.maxRank(g),
+  let maxRank = util.maxRank(g),
     downLayerGraphs = buildLayerGraphs(g, util.range(1, maxRank + 1), "inEdges"),
     upLayerGraphs = buildLayerGraphs(g, util.range(maxRank - 1, -1, -1), "outEdges");
 
-  var layering = initOrder(g);
+  let layering = initOrder(g);
   assignOrder(g, layering);
 
-  var bestCC = Number.POSITIVE_INFINITY,
+  let bestCC = Number.POSITIVE_INFINITY,
     best;
 
-  for (var i = 0, lastBest = 0; lastBest < 4; ++i, ++lastBest) {
+  for (let i = 0, lastBest = 0; lastBest < 4; ++i, ++lastBest) {
     sweepLayerGraphs(i % 2 ? downLayerGraphs : upLayerGraphs, i % 4 >= 2);
 
     layering = util.buildLayerMatrix(g);
-    var cc = crossCount(g, layering);
+    let cc = crossCount(g, layering);
     if (cc < bestCC) {
       lastBest = 0;
       best = Object.assign({}, layering);
@@ -58,10 +58,10 @@ function buildLayerGraphs(g, ranks, relationship) {
 }
 
 function sweepLayerGraphs(layerGraphs, biasRight) {
-  var cg = new Graph();
+  let cg = new Graph();
   layerGraphs.forEach(function(lg) {
-    var root = lg.graph().root;
-    var sorted = sortSubgraph(lg, root, cg, biasRight);
+    let root = lg.graph().root;
+    let sorted = sortSubgraph(lg, root, cg, biasRight);
     sorted.vs.forEach((v, i) => lg.node(v).order = i);
     addSubgraphConstraints(lg, cg, sorted.vs);
   });