@dagrejs/dagre 1.0.2 → 1.0.4

package/lib/add-border-segments.js

@@ -1,11 +1,11 @@
-var util = require("./util");
+let util = require("./util");
 
 module.exports = addBorderSegments;
 
 function addBorderSegments(g) {
   function dfs(v) {
-    var children = g.children(v);
-    var node = g.node(v);
+    let children = g.children(v);
+    let node = g.node(v);
     if (children.length) {
       children.forEach(dfs);
     }
@@ -13,7 +13,7 @@ function addBorderSegments(g) {
     if (node.hasOwnProperty("minRank")) {
       node.borderLeft = [];
       node.borderRight = [];
-      for (var rank = node.minRank, maxRank = node.maxRank + 1;
+      for (let rank = node.minRank, maxRank = node.maxRank + 1;
         rank < maxRank;
         ++rank) {
         addBorderNode(g, "borderLeft", "_bl", v, node, rank);
@@ -26,9 +26,9 @@ function addBorderSegments(g) {
 }
 
 function addBorderNode(g, prop, prefix, sg, sgNode, rank) {
-  var label = { width: 0, height: 0, rank: rank, borderType: prop };
-  var prev = sgNode[prop][rank - 1];
-  var curr = util.addDummyNode(g, "border", label, prefix);
+  let label = { width: 0, height: 0, rank: rank, borderType: prop };
+  let prev = sgNode[prop][rank - 1];
+  let curr = util.addDummyNode(g, "border", label, prefix);
   sgNode[prop][rank] = curr;
   g.setParent(curr, sg);
   if (prev) {

package/lib/coordinate-system.js

@@ -6,14 +6,14 @@ module.exports = {
 };
 
 function adjust(g) {
-  var rankDir = g.graph().rankdir.toLowerCase();
+  let rankDir = g.graph().rankdir.toLowerCase();
   if (rankDir === "lr" || rankDir === "rl") {
     swapWidthHeight(g);
   }
 }
 
 function undo(g) {
-  var rankDir = g.graph().rankdir.toLowerCase();
+  let rankDir = g.graph().rankdir.toLowerCase();
   if (rankDir === "bt" || rankDir === "rl") {
     reverseY(g);
   }
@@ -30,7 +30,7 @@ function swapWidthHeight(g) {
 }
 
 function swapWidthHeightOne(attrs) {
-  var w = attrs.width;
+  let w = attrs.width;
   attrs.width = attrs.height;
   attrs.height = w;
 }
@@ -38,8 +38,8 @@ function swapWidthHeightOne(attrs) {
 function reverseY(g) {
   g.nodes().forEach(v => reverseYOne(g.node(v)));
 
-  g.edges().forEach(function(e) {
-    var edge = g.edge(e);
+  g.edges().forEach(e => {
+    let edge = g.edge(e);
     edge.points.forEach(reverseYOne);
     if (edge.hasOwnProperty("y")) {
       reverseYOne(edge);
@@ -54,8 +54,8 @@ function reverseYOne(attrs) {
 function swapXY(g) {
   g.nodes().forEach(v => swapXYOne(g.node(v)));
 
-  g.edges().forEach(function(e) {
-    var edge = g.edge(e);
+  g.edges().forEach(e => {
+    let edge = g.edge(e);
     edge.points.forEach(swapXYOne);
     if (edge.hasOwnProperty("x")) {
       swapXYOne(edge);
@@ -64,7 +64,7 @@ function swapXY(g) {
 }
 
 function swapXYOne(attrs) {
-  var x = attrs.x;
+  let x = attrs.x;
   attrs.x = attrs.y;
   attrs.y = x;
 }

package/lib/data/list.js

@@ -3,44 +3,44 @@
  * "Introduction to Algorithms".
  */
 
-module.exports = List;
-
-function List() {
-  var sentinel = {};
-  sentinel._next = sentinel._prev = sentinel;
-  this._sentinel = sentinel;
-}
+class List {
+  constructor() {
+    let sentinel = {};
+    sentinel._next = sentinel._prev = sentinel;
+    this._sentinel = sentinel;
+  }
 
-List.prototype.dequeue = function() {
-  var sentinel = this._sentinel;
-  var entry = sentinel._prev;
-  if (entry !== sentinel) {
-    unlink(entry);
-    return entry;
+  dequeue() {
+    let sentinel = this._sentinel;
+    let entry = sentinel._prev;
+    if (entry !== sentinel) {
+      unlink(entry);
+      return entry;
+    }
   }
-};
 
-List.prototype.enqueue = function(entry) {
-  var sentinel = this._sentinel;
-  if (entry._prev && entry._next) {
-    unlink(entry);
+  enqueue(entry) {
+    let sentinel = this._sentinel;
+    if (entry._prev && entry._next) {
+      unlink(entry);
+    }
+    entry._next = sentinel._next;
+    sentinel._next._prev = entry;
+    sentinel._next = entry;
+    entry._prev = sentinel;
   }
-  entry._next = sentinel._next;
-  sentinel._next._prev = entry;
-  sentinel._next = entry;
-  entry._prev = sentinel;
-};
 
-List.prototype.toString = function() {
-  var strs = [];
-  var sentinel = this._sentinel;
-  var curr = sentinel._prev;
-  while (curr !== sentinel) {
-    strs.push(JSON.stringify(curr, filterOutLinks));
-    curr = curr._prev;
+  toString() {
+    let strs = [];
+    let sentinel = this._sentinel;
+    let curr = sentinel._prev;
+    while (curr !== sentinel) {
+      strs.push(JSON.stringify(curr, filterOutLinks));
+      curr = curr._prev;
+    }
+    return "[" + strs.join(", ") + "]";
   }
-  return "[" + strs.join(", ") + "]";
-};
+}
 
 function unlink(entry) {
   entry._prev._next = entry._next;
@@ -54,3 +54,5 @@ function filterOutLinks(k, v) {
     return v;
   }
 }
+
+module.exports = List;

package/lib/debug.js

@@ -1,5 +1,5 @@
-var util = require("./util");
-var Graph = require("@dagrejs/graphlib").Graph;
+let util = require("./util");
+let Graph = require("@dagrejs/graphlib").Graph;
 
 module.exports = {
   debugOrdering: debugOrdering
@@ -7,23 +7,21 @@ module.exports = {
 
 /* istanbul ignore next */
 function debugOrdering(g) {
-  var layerMatrix = util.buildLayerMatrix(g);
+  let layerMatrix = util.buildLayerMatrix(g);
 
-  var h = new Graph({ compound: true, multigraph: true }).setGraph({});
+  let h = new Graph({ compound: true, multigraph: true }).setGraph({});
 
-  g.nodes().forEach(function(v) {
+  g.nodes().forEach(v => {
     h.setNode(v, { label: v });
     h.setParent(v, "layer" + g.node(v).rank);
   });
 
-  g.edges().forEach(function(e) {
-    h.setEdge(e.v, e.w, {}, e.name);
-  });
+  g.edges().forEach(e => h.setEdge(e.v, e.w, {}, e.name));
 
-  layerMatrix.forEach(function(layer, i) {
-    var layerV = "layer" + i;
+  layerMatrix.forEach((layer, i) => {
+    let layerV = "layer" + i;
     h.setNode(layerV, { rank: "same" });
-    layer.reduce(function(u, v) {
+    layer.reduce((u, v) => {
       h.setEdge(u, v, { style: "invis" });
       return v;
     });

package/lib/greedy-fas.js

@@ -1,5 +1,5 @@
-var Graph = require("@dagrejs/graphlib").Graph;
-var List = require("./data/list");
+let Graph = require("@dagrejs/graphlib").Graph;
+let List = require("./data/list");
 
 /*
  * A greedy heuristic for finding a feedback arc set for a graph. A feedback
@@ -10,30 +10,30 @@ var List = require("./data/list");
  */
 module.exports = greedyFAS;
 
-var DEFAULT_WEIGHT_FN = () => 1;
+let DEFAULT_WEIGHT_FN = () => 1;
 
 function greedyFAS(g, weightFn) {
   if (g.nodeCount() <= 1) {
     return [];
   }
-  var state = buildState(g, weightFn || DEFAULT_WEIGHT_FN);
-  var results = doGreedyFAS(state.graph, state.buckets, state.zeroIdx);
+  let state = buildState(g, weightFn || DEFAULT_WEIGHT_FN);
+  let results = doGreedyFAS(state.graph, state.buckets, state.zeroIdx);
 
   // Expand multi-edges
   return results.flatMap(e => g.outEdges(e.v, e.w));
 }
 
 function doGreedyFAS(g, buckets, zeroIdx) {
-  var results = [];
-  var sources = buckets[buckets.length - 1];
-  var sinks = buckets[0];
+  let results = [];
+  let sources = buckets[buckets.length - 1];
+  let sinks = buckets[0];
 
-  var entry;
+  let entry;
   while (g.nodeCount()) {
     while ((entry = sinks.dequeue()))   { removeNode(g, buckets, zeroIdx, entry); }
     while ((entry = sources.dequeue())) { removeNode(g, buckets, zeroIdx, entry); }
     if (g.nodeCount()) {
-      for (var i = buckets.length - 2; i > 0; --i) {
+      for (let i = buckets.length - 2; i > 0; --i) {
         entry = buckets[i].dequeue();
         if (entry) {
           results = results.concat(removeNode(g, buckets, zeroIdx, entry, true));
@@ -47,11 +47,11 @@ function doGreedyFAS(g, buckets, zeroIdx) {
 }
 
 function removeNode(g, buckets, zeroIdx, entry, collectPredecessors) {
-  var results = collectPredecessors ? [] : undefined;
+  let results = collectPredecessors ? [] : undefined;
 
-  g.inEdges(entry.v).forEach(function(edge) {
-    var weight = g.edge(edge);
-    var uEntry = g.node(edge.v);
+  g.inEdges(entry.v).forEach(edge => {
+    let weight = g.edge(edge);
+    let uEntry = g.node(edge.v);
 
     if (collectPredecessors) {
       results.push({ v: edge.v, w: edge.w });
@@ -61,10 +61,10 @@ function removeNode(g, buckets, zeroIdx, entry, collectPredecessors) {
     assignBucket(buckets, zeroIdx, uEntry);
   });
 
-  g.outEdges(entry.v).forEach(function(edge) {
-    var weight = g.edge(edge);
-    var w = edge.w;
-    var wEntry = g.node(w);
+  g.outEdges(entry.v).forEach(edge => {
+    let weight = g.edge(edge);
+    let w = edge.w;
+    let wEntry = g.node(w);
     wEntry["in"] -= weight;
     assignBucket(buckets, zeroIdx, wEntry);
   });
@@ -75,29 +75,29 @@ function removeNode(g, buckets, zeroIdx, entry, collectPredecessors) {
 }
 
 function buildState(g, weightFn) {
-  var fasGraph = new Graph();
-  var maxIn = 0;
-  var maxOut = 0;
+  let fasGraph = new Graph();
+  let maxIn = 0;
+  let maxOut = 0;
 
-  g.nodes().forEach(function(v) {
+  g.nodes().forEach(v => {
     fasGraph.setNode(v, { v: v, "in": 0, out: 0 });
   });
 
   // Aggregate weights on nodes, but also sum the weights across multi-edges
   // into a single edge for the fasGraph.
-  g.edges().forEach(function(e) {
-    var prevWeight = fasGraph.edge(e.v, e.w) || 0;
-    var weight = weightFn(e);
-    var edgeWeight = prevWeight + weight;
+  g.edges().forEach(e => {
+    let prevWeight = fasGraph.edge(e.v, e.w) || 0;
+    let weight = weightFn(e);
+    let edgeWeight = prevWeight + weight;
     fasGraph.setEdge(e.v, e.w, edgeWeight);
     maxOut = Math.max(maxOut, fasGraph.node(e.v).out += weight);
     maxIn  = Math.max(maxIn,  fasGraph.node(e.w)["in"]  += weight);
   });
 
-  var buckets = range(maxOut + maxIn + 3).map(() => new List());
-  var zeroIdx = maxIn + 1;
+  let buckets = range(maxOut + maxIn + 3).map(() => new List());
+  let zeroIdx = maxIn + 1;
 
-  fasGraph.nodes().forEach(function(v) {
+  fasGraph.nodes().forEach(v => {
     assignBucket(buckets, zeroIdx, fasGraph.node(v));
   });
 

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);