@dagrejs/dagre 1.0.1 → 1.0.4

package/lib/order/init-order.js

@@ -1,6 +1,6 @@
 "use strict";
 
-var util = require("../util");
+let util = require("../util");
 
 module.exports = initOrder;
 
@@ -16,20 +16,20 @@ module.exports = initOrder;
  * the order of its nodes.
  */
 function initOrder(g) {
-  var visited = {};
-  var simpleNodes = g.nodes().filter(v => !g.children(v).length);
-  var maxRank = Math.max(...simpleNodes.map(v => g.node(v).rank));
-  var layers = util.range(maxRank + 1).map(() => []);
+  let visited = {};
+  let simpleNodes = g.nodes().filter(v => !g.children(v).length);
+  let maxRank = Math.max(...simpleNodes.map(v => g.node(v).rank));
+  let layers = util.range(maxRank + 1).map(() => []);
 
   function dfs(v) {
     if (visited[v]) return;
     visited[v] = true;
-    var node = g.node(v);
+    let node = g.node(v);
     layers[node.rank].push(v);
     g.successors(v).forEach(dfs);
   }
 
-  var orderedVs = simpleNodes.sort((a, b) => g.node(a).rank - g.node(b).rank);
+  let orderedVs = simpleNodes.sort((a, b) => g.node(a).rank - g.node(b).rank);
   orderedVs.forEach(dfs);
 
   return layers;

package/lib/order/resolve-conflicts.js

@@ -1,6 +1,6 @@
 "use strict";
 
-var util = require("../util");
+let util = require("../util");
 
 module.exports = resolveConflicts;
 
@@ -30,9 +30,9 @@ module.exports = resolveConflicts;
  *    elements in `vs`.
  */
 function resolveConflicts(entries, cg) {
-  var mappedEntries = {};
+  let mappedEntries = {};
   entries.forEach((entry, i) => {
-    var tmp = mappedEntries[entry.v] = {
+    let tmp = mappedEntries[entry.v] = {
       indegree: 0,
       "in": [],
       out: [],
@@ -46,24 +46,24 @@ function resolveConflicts(entries, cg) {
   });
 
   cg.edges().forEach(e => {
-    var entryV = mappedEntries[e.v];
-    var entryW = mappedEntries[e.w];
+    let entryV = mappedEntries[e.v];
+    let entryW = mappedEntries[e.w];
     if (entryV !== undefined && entryW !== undefined) {
       entryW.indegree++;
       entryV.out.push(mappedEntries[e.w]);
     }
   });
 
-  var sourceSet = Object.values(mappedEntries).filter(entry => !entry.indegree);
+  let sourceSet = Object.values(mappedEntries).filter(entry => !entry.indegree);
 
   return doResolveConflicts(sourceSet);
 }
 
 function doResolveConflicts(sourceSet) {
-  var entries = [];
+  let entries = [];
 
   function handleIn(vEntry) {
-    return function(uEntry) {
+    return uEntry => {
       if (uEntry.merged) {
         return;
       }
@@ -76,7 +76,7 @@ function doResolveConflicts(sourceSet) {
   }
 
   function handleOut(vEntry) {
-    return function(wEntry) {
+    return wEntry => {
       wEntry["in"].push(vEntry);
       if (--wEntry.indegree === 0) {
         sourceSet.push(wEntry);
@@ -85,7 +85,7 @@ function doResolveConflicts(sourceSet) {
   }
 
   while (sourceSet.length) {
-    var entry = sourceSet.pop();
+    let entry = sourceSet.pop();
     entries.push(entry);
     entry["in"].reverse().forEach(handleIn(entry));
     entry.out.forEach(handleOut(entry));
@@ -97,8 +97,8 @@ function doResolveConflicts(sourceSet) {
 }
 
 function mergeEntries(target, source) {
-  var sum = 0;
-  var weight = 0;
+  let sum = 0;
+  let weight = 0;
 
   if (target.weight) {
     sum += target.barycenter * target.weight;

package/lib/order/sort-subgraph.js

@@ -1,24 +1,24 @@
-var barycenter = require("./barycenter");
-var resolveConflicts = require("./resolve-conflicts");
-var sort = require("./sort");
+let barycenter = require("./barycenter");
+let resolveConflicts = require("./resolve-conflicts");
+let sort = require("./sort");
 
 module.exports = sortSubgraph;
 
 function sortSubgraph(g, v, cg, biasRight) {
-  var movable = g.children(v);
-  var node = g.node(v);
-  var bl = node ? node.borderLeft : undefined;
-  var br = node ? node.borderRight: undefined;
-  var subgraphs = {};
+  let movable = g.children(v);
+  let node = g.node(v);
+  let bl = node ? node.borderLeft : undefined;
+  let br = node ? node.borderRight: undefined;
+  let subgraphs = {};
 
   if (bl) {
     movable = movable.filter(w => w !== bl && w !== br);
   }
 
-  var barycenters = barycenter(g, movable);
-  barycenters.forEach(function(entry) {
+  let barycenters = barycenter(g, movable);
+  barycenters.forEach(entry => {
     if (g.children(entry.v).length) {
-      var subgraphResult = sortSubgraph(g, entry.v, cg, biasRight);
+      let subgraphResult = sortSubgraph(g, entry.v, cg, biasRight);
       subgraphs[entry.v] = subgraphResult;
       if (subgraphResult.hasOwnProperty("barycenter")) {
         mergeBarycenters(entry, subgraphResult);
@@ -26,15 +26,15 @@ function sortSubgraph(g, v, cg, biasRight) {
     }
   });
 
-  var entries = resolveConflicts(barycenters, cg);
+  let entries = resolveConflicts(barycenters, cg);
   expandSubgraphs(entries, subgraphs);
 
-  var result = sort(entries, biasRight);
+  let result = sort(entries, biasRight);
 
   if (bl) {
     result.vs = [bl, result.vs, br].flat(true);
     if (g.predecessors(bl).length) {
-      var blPred = g.node(g.predecessors(bl)[0]),
+      let blPred = g.node(g.predecessors(bl)[0]),
         brPred = g.node(g.predecessors(br)[0]);
       if (!result.hasOwnProperty("barycenter")) {
         result.barycenter = 0;
@@ -50,8 +50,8 @@ function sortSubgraph(g, v, cg, biasRight) {
 }
 
 function expandSubgraphs(entries, subgraphs) {
-  entries.forEach(function(entry) {
-    entry.vs = entry.vs.flatMap(function(v) {
+  entries.forEach(entry => {
+    entry.vs = entry.vs.flatMap(v => {
       if (subgraphs[v]) {
         return subgraphs[v].vs;
       }

package/lib/order/sort.js

@@ -1,12 +1,12 @@
-var util = require("../util");
+let util = require("../util");
 
 module.exports = sort;
 
 function sort(entries, biasRight) {
-  var parts = util.partition(entries, function(entry) {
+  let parts = util.partition(entries, entry => {
     return entry.hasOwnProperty("barycenter");
   });
-  var sortable = parts.lhs,
+  let sortable = parts.lhs,
     unsortable = parts.rhs.sort((a, b) => b.i - a.i),
     vs = [],
     sum = 0,
@@ -17,7 +17,7 @@ function sort(entries, biasRight) {
 
   vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
 
-  sortable.forEach(function (entry) {
+  sortable.forEach(entry => {
     vsIndex += entry.vs.length;
     vs.push(entry.vs);
     sum += entry.barycenter * entry.weight;
@@ -25,7 +25,7 @@ function sort(entries, biasRight) {
     vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
   });
 
-  var result = { vs: vs.flat(true) };
+  let result = { vs: vs.flat(true) };
   if (weight) {
     result.barycenter = sum / weight;
     result.weight = weight;
@@ -34,7 +34,7 @@ function sort(entries, biasRight) {
 }
 
 function consumeUnsortable(vs, unsortable, index) {
-  var last;
+  let last;
   while (unsortable.length && (last = unsortable[unsortable.length - 1]).i <= index) {
     unsortable.pop();
     vs.push(last.vs);
@@ -44,7 +44,7 @@ function consumeUnsortable(vs, unsortable, index) {
 }
 
 function compareWithBias(bias) {
-  return function(entryV, entryW) {
+  return (entryV, entryW) => {
     if (entryV.barycenter < entryW.barycenter) {
       return -1;
     } else if (entryV.barycenter > entryW.barycenter) {

package/lib/parent-dummy-chains.js

@@ -1,17 +1,17 @@
 module.exports = parentDummyChains;
 
 function parentDummyChains(g) {
-  var postorderNums = postorder(g);
+  let postorderNums = postorder(g);
 
-  g.graph().dummyChains.forEach(function(v) {
-    var node = g.node(v);
-    var edgeObj = node.edgeObj;
-    var pathData = findPath(g, postorderNums, edgeObj.v, edgeObj.w);
-    var path = pathData.path;
-    var lca = pathData.lca;
-    var pathIdx = 0;
-    var pathV = path[pathIdx];
-    var ascending = true;
+  g.graph().dummyChains.forEach(v => {
+    let node = g.node(v);
+    let edgeObj = node.edgeObj;
+    let pathData = findPath(g, postorderNums, edgeObj.v, edgeObj.w);
+    let path = pathData.path;
+    let lca = pathData.lca;
+    let pathIdx = 0;
+    let pathV = path[pathIdx];
+    let ascending = true;
 
     while (v !== edgeObj.w) {
       node = g.node(v);
@@ -44,12 +44,12 @@ function parentDummyChains(g) {
 // Find a path from v to w through the lowest common ancestor (LCA). Return the
 // full path and the LCA.
 function findPath(g, postorderNums, v, w) {
-  var vPath = [];
-  var wPath = [];
-  var low = Math.min(postorderNums[v].low, postorderNums[w].low);
-  var lim = Math.max(postorderNums[v].lim, postorderNums[w].lim);
-  var parent;
-  var lca;
+  let vPath = [];
+  let wPath = [];
+  let low = Math.min(postorderNums[v].low, postorderNums[w].low);
+  let lim = Math.max(postorderNums[v].lim, postorderNums[w].lim);
+  let parent;
+  let lca;
 
   // Traverse up from v to find the LCA
   parent = v;
@@ -70,11 +70,11 @@ function findPath(g, postorderNums, v, w) {
 }
 
 function postorder(g) {
-  var result = {};
-  var lim = 0;
+  let result = {};
+  let lim = 0;
 
   function dfs(v) {
-    var low = lim;
+    let low = lim;
     g.children(v).forEach(dfs);
     result[v] = { low: low, lim: lim++ };
   }

package/lib/position/bk.js

@@ -1,7 +1,7 @@
 "use strict";
 
-var Graph = require("@dagrejs/graphlib").Graph;
-var util = require("../util");
+let Graph = require("@dagrejs/graphlib").Graph;
+let util = require("../util");
 
 /*
  * This module provides coordinate assignment based on Brandes and Köpf, "Fast
@@ -39,10 +39,10 @@ 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,
@@ -52,14 +52,14 @@ function findType1Conflicts(g, layering) {
       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)) {
@@ -80,15 +80,15 @@ function findType1Conflicts(g, layering) {
 }
 
 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);
+        g.predecessors(v).forEach(u => {
+          let uNode = g.node(u);
           if (uNode.dummy &&
               (uNode.order < prevNorthBorder || uNode.order > nextNorthBorder)) {
             addConflict(conflicts, u, v);
@@ -100,13 +100,13 @@ function findType2Conflicts(g, layering) {
 
 
   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);
@@ -132,12 +132,12 @@ function findOtherInnerSegmentNode(g, v) {
 
 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 = {};
   }
@@ -146,7 +146,7 @@ function addConflict(conflicts, v, w) {
 
 function hasConflict(conflicts, v, w) {
   if (v > w) {
-    var tmp = v;
+    let tmp = v;
     v = w;
     w = tmp;
   }
@@ -162,30 +162,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];
+        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)) {
@@ -207,14 +207,14 @@ function horizontalCompaction(g, layering, root, align, reverseSep) {
   // 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);
@@ -230,18 +230,18 @@ function horizontalCompaction(g, layering, root, align, reverseSep) {
 
   // 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);
     }
@@ -258,14 +258,14 @@ function horizontalCompaction(g, layering, root, align, reverseSep) {
 
 
 function buildBlockGraph(g, layering, root, reverseSep) {
-  var blockGraph = new Graph(),
+  let blockGraph = new 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],
@@ -284,11 +284,11 @@ 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);
@@ -310,18 +310,18 @@ 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);
@@ -335,36 +335,36 @@ function alignCoordinates(xss, alignTo) {
 }
 
 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(
+  let layering = util.buildLayerMatrix(g);
+  let conflicts = Object.assign(
     findType1Conflicts(g, layering),
     findType2Conflicts(g, layering));
 
-  var xss = {};
-  var adjustedLayering;
-  ["u", "d"].forEach(function(vert) {
+  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,
+      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);
@@ -374,17 +374,17 @@ function positionX(g) {
   });
 
 
-  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")) {

package/lib/position/index.js

@@ -1,7 +1,7 @@
 "use strict";
 
-var util = require("../util");
-var positionX = require("./bk").positionX;
+let util = require("../util");
+let positionX = require("./bk").positionX;
 
 module.exports = position;
 
@@ -13,10 +13,10 @@ function position(g) {
 }
 
 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) {

package/lib/rank/feasible-tree.js

@@ -54,7 +54,7 @@ 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)) {

package/lib/rank/network-simplex.js

@@ -100,7 +100,7 @@ function calcCutValue(t, g, child) {
 
   cutValue = graphEdge.weight;
 
-  g.nodeEdges(child).forEach(function(e) {
+  g.nodeEdges(child).forEach(e => {
     var isOutEdge = e.v === child,
       other = isOutEdge ? e.w : e.v;
 
@@ -131,7 +131,7 @@ function dfsAssignLowLim(tree, visited, nextLim, v, parent) {
   var label = tree.node(v);
 
   visited[v] = true;
-  tree.neighbors(v).forEach(function(w) {
+  tree.neighbors(v).forEach(w => {
     if (!visited.hasOwnProperty(w)) {
       nextLim = dfsAssignLowLim(tree, visited, nextLim, w, v);
     }
@@ -177,7 +177,7 @@ function enterEdge(t, g, edge) {
     flip = true;
   }
 
-  var candidates = g.edges().filter(function(edge) {
+  var candidates = g.edges().filter(edge => {
     return flip === isDescendant(t, t.node(edge.v), tailLabel) &&
            flip !== isDescendant(t, t.node(edge.w), tailLabel);
   });
@@ -205,7 +205,7 @@ function updateRanks(t, g) {
   var root = t.nodes().find(v => !g.node(v).parent);
   var vs = preorder(t, root);
   vs = vs.slice(1);
-  vs.forEach(function(v) {
+  vs.forEach(v => {
     var parent = t.node(v).parent,
       edge = g.edge(v, parent),
       flipped = false;