@dagrejs/dagre 1.0.2 → 1.1.0

package/lib/layout.js

@@ -1,59 +1,61 @@
 "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;
-
-module.exports = layout;
-
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = layout;
+var acyclic = _interopRequireWildcard(require("./acyclic.js"));
+var normalize = _interopRequireWildcard(require("./normalize.js"));
+var _index = _interopRequireDefault(require("./rank/index.js"));
+var _parentDummyChains = _interopRequireDefault(require("./parent-dummy-chains.js"));
+var nestingGraph = _interopRequireWildcard(require("./nesting-graph.js"));
+var _addBorderSegments = _interopRequireDefault(require("./add-border-segments.js"));
+var coordinateSystem = _interopRequireWildcard(require("./coordinate-system.js"));
+var _index2 = _interopRequireDefault(require("./order/index.js"));
+var _index3 = _interopRequireDefault(require("./position/index.js"));
+var util = _interopRequireWildcard(require("./util.js"));
+var _graphlib = require("@dagrejs/graphlib");
+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; }
+const removeEmptyRanks = util.removeEmptyRanks;
+const normalizeRanks = util.normalizeRanks;
 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", () => (0, _index.default)(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", () => (0, _parentDummyChains.default)(g));
+  time("    addBorderSegments", () => (0, _addBorderSegments.default)(g));
+  time("    order", () => (0, _index2.default)(g));
+  time("    insertSelfEdges", () => insertSelfEdges(g));
+  time("    adjustCoordinateSystem", () => coordinateSystem.adjust(g));
+  time("    position", () => (0, _index3.default)(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,47 +66,53 @@ 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;
       inputLabel.y = layoutLabel.y;
       inputLabel.rank = layoutLabel.rank;
-
       if (layoutGraph.children(v).length) {
         inputLabel.width = layoutLabel.width;
         inputLabel.height = layoutLabel.height;
       }
     }
   });
-
   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")) {
       inputLabel.x = layoutLabel.x;
       inputLabel.y = layoutLabel.y;
     }
   });
-
   inputGraph.graph().width = layoutGraph.graph().width;
   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 = {
-  minlen: 1, weight: 1, width: 0, height: 0,
-  labeloffset: 10, labelpos: "r"
+let graphNumAttrs = ["nodesep", "edgesep", "ranksep", "marginx", "marginy"];
+let graphDefaults = {
+  ranksep: 50,
+  edgesep: 20,
+  nodesep: 50,
+  rankdir: "tb"
 };
-var edgeAttrs = ["labelpos"];
+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"
+};
+let edgeAttrs = ["labelpos"];
 
 /*
  * Constructs a new graph from the input graph, which can be used for layout.
@@ -113,35 +121,27 @@ var edgeAttrs = ["labelpos"];
  * attributes can influence layout.
  */
 function buildLayoutGraph(inputGraph) {
-  var g = new Graph({ multigraph: true, compound: true });
-  var graph = canonicalize(inputGraph.graph());
-
-  g.setGraph(Object.assign({},
-    graphDefaults,
-    selectNumberAttrs(graph, graphNumAttrs),
-    util.pick(graph, graphAttrs)));
-
+  let g = new _graphlib.Graph({
+    multigraph: true,
+    compound: true
+  });
+  let graph = canonicalize(inputGraph.graph());
+  g.setGraph(Object.assign({}, graphDefaults, selectNumberAttrs(graph, graphNumAttrs), 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) {
         newNode[k] = nodeDefaults[k];
       }
     });
-
     g.setNode(v, newNode);
     g.setParent(v, inputGraph.parent(v));
   });
-
   inputGraph.edges().forEach(e => {
-    var edge = canonicalize(inputGraph.edge(e));
-    g.setEdge(e, Object.assign({},
-      edgeDefaults,
-      selectNumberAttrs(edge, edgeNumAttrs),
-      util.pick(edge, edgeAttrs)));
+    let edge = canonicalize(inputGraph.edge(e));
+    g.setEdge(e, Object.assign({}, edgeDefaults, selectNumberAttrs(edge, edgeNumAttrs), util.pick(edge, edgeAttrs)));
   });
-
   return g;
 }
 
@@ -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,22 @@ 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;
@@ -199,74 +201,69 @@ function assignRankMinMax(g) {
   });
   g.graph().maxRank = maxRank;
 }
-
 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);
     }
   });
 }
-
 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);
     maxY = Math.max(maxY, y + h / 2);
   }
-
   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);
     }
   });
-
   minX -= marginX;
   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;
     });
-    if (edge.hasOwnProperty("x")) { edge.x -= minX; }
-    if (edge.hasOwnProperty("y")) { edge.y -= minY; }
+    if (edge.hasOwnProperty("x")) {
+      edge.x -= minX;
+    }
+    if (edge.hasOwnProperty("y")) {
+      edge.y -= minY;
+    }
   });
-
   graphLabel.width = maxX - minX + marginX;
   graphLabel.height = maxY - minY + marginY;
 }
-
 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;
@@ -279,54 +276,52 @@ function assignNodeIntersects(g) {
     edge.points.push(util.intersectRect(nodeW, p2));
   });
 }
-
 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;
       }
       switch (edge.labelpos) {
-      case "l": edge.x -= edge.width / 2 + edge.labeloffset; break;
-      case "r": edge.x += edge.width / 2 + edge.labeloffset; break;
+        case "l":
+          edge.x -= edge.width / 2 + edge.labeloffset;
+          break;
+        case "r":
+          edge.x += edge.width / 2 + edge.labeloffset;
+          break;
       }
     }
   });
 }
-
 function reversePointsForReversedEdges(g) {
   g.edges().forEach(e => {
-    var edge = g.edge(e);
+    let edge = g.edge(e);
     if (edge.reversed) {
       edge.points.reverse();
     }
   });
 }
-
 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);
       node.x = l.x + node.width / 2;
       node.y = t.y + node.height / 2;
     }
   });
-
   g.nodes().forEach(v => {
     if (g.node(v).dummy === "border") {
       g.removeNode(v);
     }
   });
 }
-
 function removeSelfEdges(g) {
   g.edges().forEach(e => {
     if (e.v === e.w) {
@@ -334,12 +329,14 @@ function removeSelfEdges(g) {
       if (!node.selfEdges) {
         node.selfEdges = [];
       }
-      node.selfEdges.push({ e: e, label: g.edge(e) });
+      node.selfEdges.push({
+        e: e,
+        label: g.edge(e)
+      });
       g.removeEdge(e);
     }
   });
 }
-
 function insertSelfEdges(g) {
   var layers = util.buildLayerMatrix(g);
   layers.forEach(layer => {
@@ -352,7 +349,7 @@ function insertSelfEdges(g) {
           width: selfEdge.label.width,
           height: selfEdge.label.height,
           rank: node.rank,
-          order: i + (++orderShift),
+          order: i + ++orderShift,
           e: selfEdge.e,
           label: selfEdge.label
         }, "_se");
@@ -361,7 +358,6 @@ function insertSelfEdges(g) {
     });
   });
 }
-
 function positionSelfEdges(g) {
   g.nodes().forEach(v => {
     var node = g.node(v);
@@ -373,23 +369,30 @@ function positionSelfEdges(g) {
       var dy = selfNode.height / 2;
       g.setEdge(node.e, node.label);
       g.removeNode(v);
-      node.label.points = [
-        { x: x + 2 * dx / 3, y: y - dy },
-        { x: x + 5 * dx / 6, y: y - dy },
-        { x: x +     dx    , y: y },
-        { x: x + 5 * dx / 6, y: y + dy },
-        { x: x + 2 * dx / 3, y: y + dy }
-      ];
+      node.label.points = [{
+        x: x + 2 * dx / 3,
+        y: y - dy
+      }, {
+        x: x + 5 * dx / 6,
+        y: y - dy
+      }, {
+        x: x + dx,
+        y: y
+      }, {
+        x: x + 5 * dx / 6,
+        y: y + dy
+      }, {
+        x: x + 2 * dx / 3,
+        y: y + dy
+      }];
       node.label.x = node.x;
       node.label.y = node.y;
     }
   });
 }
-
 function selectNumberAttrs(obj, attrs) {
   return util.mapValues(util.pick(obj, attrs), Number);
 }
-
 function canonicalize(attrs) {
   var newAttrs = {};
   if (attrs) {
@@ -397,9 +400,9 @@ function canonicalize(attrs) {
       if (typeof k === "string") {
         k = k.toLowerCase();
       }
-
       newAttrs[k] = v;
     });
   }
   return newAttrs;
 }
+module.exports = exports.default;

package/lib/nesting-graph.js

@@ -1,14 +1,17 @@
-var util = require("./util");
-
-module.exports = {
-  run: run,
-  cleanup: cleanup
-};
-
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cleanup = cleanup;
+exports.run = run;
+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; }
 /*
  * 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,74 +32,68 @@ 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;
 
   // Multiply minlen by nodeSep to align nodes on non-border ranks.
   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.
   g.graph().nodeRankFactor = nodeSep;
 }
-
 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 });
+      g.setEdge(root, v, {
+        weight: 0,
+        minlen: nodeSep
+      });
     }
     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,
       minlen: minlen,
       nestingEdge: true
     });
-
     g.setEdge(childBottom, bottom, {
       weight: thisWeight,
       minlen: minlen,
       nestingEdge: true
     });
   });
-
   if (!g.parent(v)) {
-    g.setEdge(root, top, { weight: 0, minlen: height + depths[v] });
+    g.setEdge(root, top, {
+      weight: 0,
+      minlen: height + depths[v]
+    });
   }
 }
-
 function treeDepths(g) {
   var depths = {};
   function dfs(v, depth) {
@@ -109,11 +106,9 @@ function treeDepths(g) {
   g.children().forEach(v => dfs(v, 1));
   return depths;
 }
-
 function sumWeights(g) {
   return g.edges().reduce((acc, e) => acc + g.edge(e).weight, 0);
 }
-
 function cleanup(g) {
   var graphLabel = g.graph();
   g.removeNode(graphLabel.nestingRoot);