@statewalker/fsm-charts 0.2.4 → 0.2.5

package/dist/{chunk-AZBRQNTU.js → chunk-2LFUT2C6.js}

@@ -68,25 +68,18 @@ var Graph = class {
     return _.keys(this._nodes);
   }
   sources() {
-    var self = this;
-    return _.filter(this.nodes(), function(v) {
-      return _.isEmpty(self._in[v]);
-    });
+    return _.filter(this.nodes(), (v) => _.isEmpty(this._in[v]));
   }
   sinks() {
-    var self = this;
-    return _.filter(this.nodes(), function(v) {
-      return _.isEmpty(self._out[v]);
-    });
+    return _.filter(this.nodes(), (v) => _.isEmpty(this._out[v]));
   }
   setNodes(vs, value) {
     var args = arguments;
-    var self = this;
-    _.each(vs, function(v) {
+    _.each(vs, (v) => {
       if (args.length > 1) {
-        self.setNode(v, value);
+        this.setNode(v, value);
       } else {
-        self.setNode(v);
+        this.setNode(v);
       }
     });
     return this;
@@ -118,17 +111,16 @@ var Graph = class {
     return _.has(this._nodes, v);
   }
   removeNode(v) {
-    var self = this;
     if (_.has(this._nodes, v)) {
-      var removeEdge = function(e) {
-        self.removeEdge(self._edgeObjs[e]);
+      var removeEdge = (e) => {
+        this.removeEdge(this._edgeObjs[e]);
       };
       delete this._nodes[v];
       if (this._isCompound) {
         this._removeFromParentsChildList(v);
         delete this._parent[v];
-        _.each(this.children(v), function(child) {
-          self.setParent(child);
+        _.each(this.children(v), (child) => {
+          this.setParent(child);
         });
         delete this._children[v];
       }
@@ -152,7 +144,9 @@ var Graph = class {
       parent += "";
       for (var ancestor = parent; !_.isUndefined(ancestor); ancestor = this.parent(ancestor)) {
         if (ancestor === v) {
-          throw new Error("Setting " + parent + " as parent of " + v + " would create a cycle");
+          throw new Error(
+            `Setting ${parent} as parent of ${v} would create a cycle`
+          );
         }
       }
       this.setNode(parent);
@@ -224,12 +218,12 @@ var Graph = class {
     });
     copy.setGraph(this.graph());
     var self = this;
-    _.each(this._nodes, function(value, v) {
+    _.each(this._nodes, (value, v) => {
       if (filter(v)) {
         copy.setNode(v, value);
       }
     });
-    _.each(this._edgeObjs, function(e) {
+    _.each(this._edgeObjs, (e) => {
       if (copy.hasNode(e.v) && copy.hasNode(e.w)) {
         copy.setEdge(e, self.edge(e));
       }
@@ -247,7 +241,7 @@ var Graph = class {
       }
     }
     if (this._isCompound) {
-      _.each(copy.nodes(), function(v) {
+      _.each(copy.nodes(), (v) => {
         copy.setParent(v, findParent(v));
       });
     }
@@ -268,13 +262,12 @@ var Graph = class {
     return _.values(this._edgeObjs);
   }
   setPath(vs, value) {
-    var self = this;
     var args = arguments;
-    _.reduce(vs, function(v, w) {
+    _.reduce(vs, (v, w) => {
       if (args.length > 1) {
-        self.setEdge(v, w, value);
+        this.setEdge(v, w, value);
       } else {
-        self.setEdge(v, w);
+        this.setEdge(v, w);
       }
       return w;
     });
@@ -305,10 +298,10 @@ var Graph = class {
         valueSpecified = true;
       }
     }
-    v = "" + v;
-    w = "" + w;
+    v = `${v}`;
+    w = `${w}`;
     if (!_.isUndefined(name)) {
-      name = "" + name;
+      name = `${name}`;
     }
     var e = edgeArgsToId(this._isDirected, v, w, name);
     if (_.has(this._edgeLabels, e)) {
@@ -366,9 +359,7 @@ var Graph = class {
       if (!u) {
         return edges;
       }
-      return _.filter(edges, function(edge) {
-        return edge.v === u;
-      });
+      return _.filter(edges, (edge) => edge.v === u);
     }
   }
   outEdges(v, w) {
@@ -378,9 +369,7 @@ var Graph = class {
       if (!w) {
         return edges;
       }
-      return _.filter(edges, function(edge) {
-        return edge.w === w;
-      });
+      return _.filter(edges, (edge) => edge.w === w);
     }
   }
   nodeEdges(v, w) {
@@ -405,8 +394,8 @@ function decrementOrRemoveEntry(map, k) {
   }
 }
 function edgeArgsToId(isDirected, v_, w_, name) {
-  var v = "" + v_;
-  var w = "" + w_;
+  var v = `${v_}`;
+  var w = `${w_}`;
   if (!isDirected && v > w) {
     var tmp = v;
     v = w;
@@ -415,8 +404,8 @@ function edgeArgsToId(isDirected, v_, w_, name) {
   return v + EDGE_KEY_DELIM + w + EDGE_KEY_DELIM + (_.isUndefined(name) ? DEFAULT_EDGE_NAME : name);
 }
 function edgeArgsToObj(isDirected, v_, w_, name) {
-  var v = "" + v_;
-  var w = "" + w_;
+  var v = `${v_}`;
+  var w = `${w_}`;
   if (!isDirected && v > w) {
     var tmp = v;
     v = w;
@@ -432,6 +421,192 @@ function edgeObjToId(isDirected, edgeObj) {
   return edgeArgsToId(isDirected, edgeObj.v, edgeObj.w, edgeObj.name);
 }
 
+// src/dagre/data/list.js
+var List = class {
+  constructor() {
+    var sentinel = {};
+    sentinel._next = sentinel._prev = sentinel;
+    this._sentinel = sentinel;
+  }
+  dequeue() {
+    var sentinel = this._sentinel;
+    var entry = sentinel._prev;
+    if (entry !== sentinel) {
+      unlink(entry);
+      return entry;
+    }
+  }
+  enqueue(entry) {
+    var sentinel = this._sentinel;
+    if (entry._prev && entry._next) {
+      unlink(entry);
+    }
+    entry._next = sentinel._next;
+    sentinel._next._prev = entry;
+    sentinel._next = entry;
+    entry._prev = sentinel;
+  }
+  toString() {
+    var strs = [];
+    var sentinel = this._sentinel;
+    var curr = sentinel._prev;
+    while (curr !== sentinel) {
+      strs.push(JSON.stringify(curr, filterOutLinks));
+      curr = curr._prev;
+    }
+    return `[${strs.join(", ")}]`;
+  }
+};
+function unlink(entry) {
+  entry._prev._next = entry._next;
+  entry._next._prev = entry._prev;
+  delete entry._next;
+  delete entry._prev;
+}
+function filterOutLinks(k, v) {
+  if (k !== "_next" && k !== "_prev") {
+    return v;
+  }
+}
+
+// src/dagre/greedy-fas.js
+var DEFAULT_WEIGHT_FN = _.constant(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);
+  return _.flatten(_.map(results, (e) => g.outEdges(e.v, e.w)));
+}
+function doGreedyFAS(g, buckets, zeroIdx) {
+  var results = [];
+  var sources = buckets[buckets.length - 1];
+  var sinks = buckets[0];
+  var 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) {
+        entry = buckets[i].dequeue();
+        if (entry) {
+          results = results.concat(
+            removeNode(g, buckets, zeroIdx, entry, true)
+          );
+          break;
+        }
+      }
+    }
+  }
+  return results;
+}
+function removeNode(g, buckets, zeroIdx, entry, collectPredecessors) {
+  var results = collectPredecessors ? [] : void 0;
+  _.forEach(g.inEdges(entry.v), (edge) => {
+    var weight = g.edge(edge);
+    var uEntry = g.node(edge.v);
+    if (collectPredecessors) {
+      results.push({ v: edge.v, w: edge.w });
+    }
+    uEntry.out -= weight;
+    assignBucket(buckets, zeroIdx, uEntry);
+  });
+  _.forEach(g.outEdges(entry.v), (edge) => {
+    var weight = g.edge(edge);
+    var w = edge.w;
+    var wEntry = g.node(w);
+    wEntry.in -= weight;
+    assignBucket(buckets, zeroIdx, wEntry);
+  });
+  g.removeNode(entry.v);
+  return results;
+}
+function buildState(g, weightFn) {
+  var fasGraph = new Graph();
+  var maxIn = 0;
+  var maxOut = 0;
+  _.forEach(g.nodes(), (v) => {
+    fasGraph.setNode(v, { v, in: 0, out: 0 });
+  });
+  _.forEach(g.edges(), (e) => {
+    var prevWeight = fasGraph.edge(e.v, e.w) || 0;
+    var weight = weightFn(e);
+    var 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;
+  _.forEach(fasGraph.nodes(), (v) => {
+    assignBucket(buckets, zeroIdx, fasGraph.node(v));
+  });
+  return { graph: fasGraph, buckets, zeroIdx };
+}
+function assignBucket(buckets, zeroIdx, entry) {
+  if (!entry.out) {
+    buckets[0].enqueue(entry);
+  } else if (!entry.in) {
+    buckets[buckets.length - 1].enqueue(entry);
+  } else {
+    buckets[entry.out - entry.in + zeroIdx].enqueue(entry);
+  }
+}
+
+// src/dagre/acyclic.js
+function run(g) {
+  var fas = g.graph().acyclicer === "greedy" ? greedyFAS(g, weightFn(g)) : dfsFAS(g);
+  _.forEach(fas, (e) => {
+    var label = g.edge(e);
+    g.removeEdge(e);
+    label.forwardName = e.name;
+    label.reversed = true;
+    g.setEdge(e.w, e.v, label, _.uniqueId("rev"));
+  });
+  function weightFn(g2) {
+    return (e) => g2.edge(e).weight;
+  }
+}
+function dfsFAS(g) {
+  var fas = [];
+  var stack = {};
+  var visited = {};
+  function dfs3(v) {
+    if (_.has(visited, v)) {
+      return;
+    }
+    visited[v] = true;
+    stack[v] = true;
+    _.forEach(g.outEdges(v), (e) => {
+      if (_.has(stack, e.w)) {
+        fas.push(e);
+      } else {
+        dfs3(e.w);
+      }
+    });
+    delete stack[v];
+  }
+  _.forEach(g.nodes(), dfs3);
+  return fas;
+}
+function undo(g) {
+  _.forEach(g.edges(), (e) => {
+    var label = g.edge(e);
+    if (label.reversed) {
+      g.removeEdge(e);
+      var forwardName = label.forwardName;
+      delete label.reversed;
+      delete label.forwardName;
+      g.setEdge(e.w, e.v, label, forwardName);
+    }
+  });
+}
+
 // src/dagre/util.js
 function addDummyNode(g, type, attrs, name) {
   var v;
@@ -444,10 +619,10 @@ function addDummyNode(g, type, attrs, name) {
 }
 function simplify(g) {
   var simplified = new Graph().setGraph(g.graph());
-  _.forEach(g.nodes(), function(v) {
+  _.forEach(g.nodes(), (v) => {
     simplified.setNode(v, g.node(v));
   });
-  _.forEach(g.edges(), function(e) {
+  _.forEach(g.edges(), (e) => {
     var simpleLabel = simplified.edge(e.v, e.w) || { weight: 0, minlen: 1 };
     var label = g.edge(e);
     simplified.setEdge(e.v, e.w, {
@@ -458,13 +633,15 @@ function simplify(g) {
   return simplified;
 }
 function asNonCompoundGraph(g) {
-  var simplified = new Graph({ multigraph: g.isMultigraph() }).setGraph(g.graph());
-  _.forEach(g.nodes(), function(v) {
+  var simplified = new Graph({ multigraph: g.isMultigraph() }).setGraph(
+    g.graph()
+  );
+  _.forEach(g.nodes(), (v) => {
     if (!g.children(v).length) {
       simplified.setNode(v, g.node(v));
     }
   });
-  _.forEach(g.edges(), function(e) {
+  _.forEach(g.edges(), (e) => {
     simplified.setEdge(e, g.edge(e));
   });
   return simplified;
@@ -477,7 +654,9 @@ function intersectRect(rect, point) {
   var w = rect.width / 2;
   var h = rect.height / 2;
   if (!dx && !dy) {
-    throw new Error("Not possible to find intersection inside of the rectangle");
+    throw new Error(
+      "Not possible to find intersection inside of the rectangle"
+    );
   }
   var sx, sy;
   if (Math.abs(dy) * w > Math.abs(dx) * h) {
@@ -496,10 +675,8 @@ function intersectRect(rect, point) {
   return { x: x + sx, y: y + sy };
 }
 function buildLayerMatrix(g) {
-  var layering = _.map(_.range(maxRank(g) + 1), function() {
-    return [];
-  });
-  _.forEach(g.nodes(), function(v) {
+  var layering = _.map(_.range(maxRank(g) + 1), () => []);
+  _.forEach(g.nodes(), (v) => {
     var node = g.node(v);
     var rank2 = node.rank;
     if (!_.isUndefined(rank2)) {
@@ -509,12 +686,8 @@ function buildLayerMatrix(g) {
   return layering;
 }
 function normalizeRanks(g) {
-  var min = _.min(
-    _.map(g.nodes(), function(v) {
-      return g.node(v).rank;
-    })
-  );
-  _.forEach(g.nodes(), function(v) {
+  var min = _.min(_.map(g.nodes(), (v) => g.node(v).rank));
+  _.forEach(g.nodes(), (v) => {
     var node = g.node(v);
     if (_.has(node, "rank")) {
       node.rank -= min;
@@ -522,13 +695,9 @@ function normalizeRanks(g) {
   });
 }
 function removeEmptyRanks(g) {
-  var offset = _.min(
-    _.map(g.nodes(), function(v) {
-      return g.node(v).rank;
-    })
-  );
+  var offset = _.min(_.map(g.nodes(), (v) => g.node(v).rank));
   var layers = [];
-  _.forEach(g.nodes(), function(v) {
+  _.forEach(g.nodes(), (v) => {
     var rank2 = g.node(v).rank - offset;
     if (!layers[rank2]) {
       layers[rank2] = [];
@@ -537,11 +706,11 @@ function removeEmptyRanks(g) {
   });
   var delta = 0;
   var nodeRankFactor = g.graph().nodeRankFactor;
-  _.forEach(layers, function(vs, i) {
+  _.forEach(layers, (vs, i) => {
     if (_.isUndefined(vs) && i % nodeRankFactor !== 0) {
       --delta;
     } else if (delta) {
-      _.forEach(vs, function(v) {
+      _.forEach(vs, (v) => {
         g.node(v).rank += delta;
       });
     }
@@ -560,7 +729,7 @@ function addBorderNode(g, prefix, rank2, order2) {
 }
 function maxRank(g) {
   return _.max(
-    _.map(g.nodes(), function(v) {
+    _.map(g.nodes(), (v) => {
       var rank2 = g.node(v).rank;
       if (!_.isUndefined(rank2)) {
         return rank2;
@@ -570,7 +739,7 @@ function maxRank(g) {
 }
 function partition(collection, fn) {
   var result = { lhs: [], rhs: [] };
-  _.forEach(collection, function(value) {
+  _.forEach(collection, (value) => {
     if (fn(value)) {
       result.lhs.push(value);
     } else {
@@ -584,10 +753,10 @@ function time(name, fn) {
   try {
     return fn();
   } finally {
-    console.log(name + " time: " + (_.now() - start) + "ms");
+    console.log(`${name} time: ${_.now() - start}ms`);
   }
 }
-function notime(name, fn) {
+function notime(_name, fn) {
   return fn();
 }
 
@@ -628,7 +797,7 @@ function adjust(g) {
     swapWidthHeight(g);
   }
 }
-function undo(g) {
+function undo2(g) {
   var rankDir = g.graph().rankdir.toLowerCase();
   if (rankDir === "bt" || rankDir === "rl") {
     reverseY(g);
@@ -639,10 +808,10 @@ function undo(g) {
   }
 }
 function swapWidthHeight(g) {
-  _.forEach(g.nodes(), function(v) {
+  _.forEach(g.nodes(), (v) => {
     swapWidthHeightOne(g.node(v));
   });
-  _.forEach(g.edges(), function(e) {
+  _.forEach(g.edges(), (e) => {
     swapWidthHeightOne(g.edge(e));
   });
 }
@@ -652,10 +821,10 @@ function swapWidthHeightOne(attrs) {
   attrs.height = w;
 }
 function reverseY(g) {
-  _.forEach(g.nodes(), function(v) {
+  _.forEach(g.nodes(), (v) => {
     reverseYOne(g.node(v));
   });
-  _.forEach(g.edges(), function(e) {
+  _.forEach(g.edges(), (e) => {
     var edge = g.edge(e);
     _.forEach(edge.points, reverseYOne);
     if (_.has(edge, "y")) {
@@ -667,10 +836,10 @@ function reverseYOne(attrs) {
   attrs.y = -attrs.y;
 }
 function swapXY(g) {
-  _.forEach(g.nodes(), function(v) {
+  _.forEach(g.nodes(), (v) => {
     swapXYOne(g.node(v));
   });
-  _.forEach(g.edges(), function(e) {
+  _.forEach(g.edges(), (e) => {
     var edge = g.edge(e);
     _.forEach(edge.points, swapXYOne);
     if (_.has(edge, "x")) {
@@ -684,202 +853,94 @@ function swapXYOne(attrs) {
   attrs.y = x;
 }
 
-// src/dagre/data/list.js
-var List = class {
-  constructor() {
-    var sentinel = {};
-    sentinel._next = sentinel._prev = sentinel;
-    this._sentinel = sentinel;
-  }
-  dequeue() {
-    var sentinel = this._sentinel;
-    var entry = sentinel._prev;
-    if (entry !== sentinel) {
-      unlink(entry);
-      return entry;
+// src/dagre/nesting-graph.js
+function run2(g) {
+  var root = addDummyNode(g, "root", {}, "_root");
+  var depths = treeDepths(g);
+  var height = _.max(_.values(depths)) - 1;
+  var nodeSep = 2 * height + 1;
+  g.graph().nestingRoot = root;
+  _.forEach(g.edges(), (e) => {
+    g.edge(e).minlen *= nodeSep;
+  });
+  var weight = sumWeights(g) + 1;
+  _.forEach(g.children(), (child) => {
+    dfs(g, root, nodeSep, weight, height, depths, child);
+  });
+  g.graph().nodeRankFactor = nodeSep;
+}
+function dfs(g, root, nodeSep, weight, height, depths, v) {
+  var children = g.children(v);
+  if (!children.length) {
+    if (v !== root) {
+      g.setEdge(root, v, { weight: 0, minlen: nodeSep });
     }
+    return;
   }
-  enqueue(entry) {
-    var sentinel = this._sentinel;
-    if (entry._prev && entry._next) {
-      unlink(entry);
-    }
-    entry._next = sentinel._next;
-    sentinel._next._prev = entry;
-    sentinel._next = entry;
-    entry._prev = sentinel;
+  var top = addBorderNode(g, "_bt");
+  var bottom = addBorderNode(g, "_bb");
+  var label = g.node(v);
+  g.setParent(top, v);
+  label.borderTop = top;
+  g.setParent(bottom, v);
+  label.borderBottom = bottom;
+  _.forEach(children, (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;
+    g.setEdge(top, childTop, {
+      weight: thisWeight,
+      minlen,
+      nestingEdge: true
+    });
+    g.setEdge(childBottom, bottom, {
+      weight: thisWeight,
+      minlen,
+      nestingEdge: true
+    });
+  });
+  if (!g.parent(v)) {
+    g.setEdge(root, top, { weight: 0, minlen: height + depths[v] });
   }
-  toString() {
-    var strs = [];
-    var sentinel = this._sentinel;
-    var curr = sentinel._prev;
-    while (curr !== sentinel) {
-      strs.push(JSON.stringify(curr, filterOutLinks));
-      curr = curr._prev;
-    }
-    return "[" + strs.join(", ") + "]";
-  }
-};
-function unlink(entry) {
-  entry._prev._next = entry._next;
-  entry._next._prev = entry._prev;
-  delete entry._next;
-  delete entry._prev;
-}
-function filterOutLinks(k, v) {
-  if (k !== "_next" && k !== "_prev") {
-    return v;
-  }
-}
-
-// src/dagre/greedy-fas.js
-var DEFAULT_WEIGHT_FN = _.constant(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);
-  return _.flatten(
-    _.map(results, function(e) {
-      return g.outEdges(e.v, e.w);
-    })
-  );
-}
-function doGreedyFAS(g, buckets, zeroIdx) {
-  var results = [];
-  var sources = buckets[buckets.length - 1];
-  var sinks = buckets[0];
-  var 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) {
-        entry = buckets[i].dequeue();
-        if (entry) {
-          results = results.concat(removeNode(g, buckets, zeroIdx, entry, true));
-          break;
-        }
-      }
-    }
-  }
-  return results;
 }
-function removeNode(g, buckets, zeroIdx, entry, collectPredecessors) {
-  var results = collectPredecessors ? [] : void 0;
-  _.forEach(g.inEdges(entry.v), function(edge) {
-    var weight = g.edge(edge);
-    var uEntry = g.node(edge.v);
-    if (collectPredecessors) {
-      results.push({ v: edge.v, w: edge.w });
+function treeDepths(g) {
+  var depths = {};
+  function dfs3(v, depth) {
+    var children = g.children(v);
+    if (children?.length) {
+      _.forEach(children, (child) => {
+        dfs3(child, depth + 1);
+      });
     }
-    uEntry.out -= weight;
-    assignBucket(buckets, zeroIdx, uEntry);
-  });
-  _.forEach(g.outEdges(entry.v), function(edge) {
-    var weight = g.edge(edge);
-    var w = edge.w;
-    var wEntry = g.node(w);
-    wEntry["in"] -= weight;
-    assignBucket(buckets, zeroIdx, wEntry);
-  });
-  g.removeNode(entry.v);
-  return results;
-}
-function buildState(g, weightFn) {
-  var fasGraph = new Graph();
-  var maxIn = 0;
-  var maxOut = 0;
-  _.forEach(g.nodes(), function(v) {
-    fasGraph.setNode(v, { v, in: 0, out: 0 });
-  });
-  _.forEach(g.edges(), function(e) {
-    var prevWeight = fasGraph.edge(e.v, e.w) || 0;
-    var weight = weightFn(e);
-    var 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(function() {
-    return new List();
-  });
-  var zeroIdx = maxIn + 1;
-  _.forEach(fasGraph.nodes(), function(v) {
-    assignBucket(buckets, zeroIdx, fasGraph.node(v));
-  });
-  return { graph: fasGraph, buckets, zeroIdx };
-}
-function assignBucket(buckets, zeroIdx, entry) {
-  if (!entry.out) {
-    buckets[0].enqueue(entry);
-  } else if (!entry["in"]) {
-    buckets[buckets.length - 1].enqueue(entry);
-  } else {
-    buckets[entry.out - entry["in"] + zeroIdx].enqueue(entry);
+    depths[v] = depth;
   }
-}
-
-// src/dagre/acyclic.js
-function run(g) {
-  var fas = g.graph().acyclicer === "greedy" ? greedyFAS(g, weightFn(g)) : dfsFAS(g);
-  _.forEach(fas, function(e) {
-    var label = g.edge(e);
-    g.removeEdge(e);
-    label.forwardName = e.name;
-    label.reversed = true;
-    g.setEdge(e.w, e.v, label, _.uniqueId("rev"));
+  _.forEach(g.children(), (v) => {
+    dfs3(v, 1);
   });
-  function weightFn(g2) {
-    return function(e) {
-      return g2.edge(e).weight;
-    };
-  }
+  return depths;
 }
-function dfsFAS(g) {
-  var fas = [];
-  var stack = {};
-  var visited = {};
-  function dfs3(v) {
-    if (_.has(visited, v)) {
-      return;
-    }
-    visited[v] = true;
-    stack[v] = true;
-    _.forEach(g.outEdges(v), function(e) {
-      if (_.has(stack, e.w)) {
-        fas.push(e);
-      } else {
-        dfs3(e.w);
-      }
-    });
-    delete stack[v];
-  }
-  _.forEach(g.nodes(), dfs3);
-  return fas;
+function sumWeights(g) {
+  return _.reduce(g.edges(), (acc, e) => acc + g.edge(e).weight, 0);
 }
-function undo2(g) {
-  _.forEach(g.edges(), function(e) {
-    var label = g.edge(e);
-    if (label.reversed) {
+function cleanup(g) {
+  var graphLabel = g.graph();
+  g.removeNode(graphLabel.nestingRoot);
+  delete graphLabel.nestingRoot;
+  _.forEach(g.edges(), (e) => {
+    var edge = g.edge(e);
+    if (edge.nestingEdge) {
       g.removeEdge(e);
-      var forwardName = label.forwardName;
-      delete label.reversed;
-      delete label.forwardName;
-      g.setEdge(e.w, e.v, label, forwardName);
     }
   });
 }
 
 // src/dagre/normalize.js
-function run2(g) {
+function run3(g) {
   g.graph().dummyChains = [];
-  _.forEach(g.edges(), function(edge) {
+  _.forEach(g.edges(), (edge) => {
     normalizeEdge(g, edge);
   });
 }
@@ -919,7 +980,7 @@ function normalizeEdge(g, e) {
   g.setEdge(v, w, { weight: edgeLabel.weight }, name);
 }
 function undo3(g) {
-  _.forEach(g.graph().dummyChains, function(v) {
+  _.forEach(g.graph().dummyChains, (v) => {
     var node = g.node(v);
     var origLabel = node.edgeLabel;
     var w;
@@ -940,465 +1001,91 @@ function undo3(g) {
   });
 }
 
-// src/dagre/rank/util.js
-function longestPath(g) {
-  var visited = {};
-  function dfs3(v) {
-    var label = g.node(v);
-    if (_.has(visited, v)) {
-      return label.rank;
-    }
-    visited[v] = true;
-    var rank2 = _.min(
-      _.map(g.outEdges(v), function(e) {
-        return dfs3(e.w) - g.edge(e).minlen;
-      })
-    );
-    if (rank2 === Number.POSITIVE_INFINITY || // return value of _.map([]) for Lodash 3
-    rank2 === void 0 || // return value of _.map([]) for Lodash 4
-    rank2 === null) {
-      rank2 = 0;
+// src/dagre/order/add-subgraph-constraints.js
+function addSubgraphConstraints(g, cg, vs) {
+  var prev = {}, rootPrev;
+  _.forEach(vs, (v) => {
+    var child = g.parent(v), parent, prevChild;
+    while (child) {
+      parent = g.parent(child);
+      if (parent) {
+        prevChild = prev[parent];
+        prev[parent] = child;
+      } else {
+        prevChild = rootPrev;
+        rootPrev = child;
+      }
+      if (prevChild && prevChild !== child) {
+        cg.setEdge(prevChild, child);
+        return;
+      }
+      child = parent;
     }
-    return label.rank = rank2;
-  }
-  _.forEach(g.sources(), dfs3);
-}
-function slack(g, e) {
-  return g.node(e.w).rank - g.node(e.v).rank - g.edge(e).minlen;
+  });
 }
 
-// src/dagre/rank/feasible-tree.js
-function feasibleTree(g) {
-  var t = new Graph({ directed: false });
-  var start = g.nodes()[0];
-  var size = g.nodeCount();
-  t.setNode(start, {});
-  var edge, delta;
-  while (tightTree(t, g) < size) {
-    edge = findMinSlackEdge(t, g);
-    delta = t.hasNode(edge.v) ? slack(g, edge) : -slack(g, edge);
-    shiftRanks(t, g, delta);
-  }
-  return t;
-}
-function tightTree(t, g) {
-  function dfs3(v) {
-    _.forEach(g.nodeEdges(v), function(e) {
-      var edgeV = e.v, w = v === edgeV ? e.w : edgeV;
-      if (!t.hasNode(w) && !slack(g, e)) {
-        t.setNode(w, {});
-        t.setEdge(v, w, {});
-        dfs3(w);
+// src/dagre/order/build-layer-graph.js
+function buildLayerGraph(g, rank2, relationship) {
+  var root = createRootNode(g), result = new Graph({ compound: true }).setGraph({ root }).setDefaultNodeLabel((v) => g.node(v));
+  _.forEach(g.nodes(), (v) => {
+    var node = g.node(v), parent = g.parent(v);
+    if (node.rank === rank2 || node.minRank <= rank2 && rank2 <= node.maxRank) {
+      result.setNode(v);
+      result.setParent(v, parent || root);
+      _.forEach(g[relationship](v), (e) => {
+        var u = e.v === v ? e.w : e.v, edge = result.edge(u, v), weight = !_.isUndefined(edge) ? edge.weight : 0;
+        result.setEdge(u, v, { weight: g.edge(e).weight + weight });
+      });
+      if (_.has(node, "minRank")) {
+        result.setNode(v, {
+          borderLeft: node.borderLeft[rank2],
+          borderRight: node.borderRight[rank2]
+        });
       }
-    });
-  }
-  _.forEach(t.nodes(), dfs3);
-  return t.nodeCount();
-}
-function findMinSlackEdge(t, g) {
-  return _.minBy(g.edges(), function(e) {
-    if (t.hasNode(e.v) !== t.hasNode(e.w)) {
-      return slack(g, e);
     }
   });
+  return result;
 }
-function shiftRanks(t, g, delta) {
-  _.forEach(t.nodes(), function(v) {
-    g.node(v).rank += delta;
-  });
-}
-
-// src/graphlib/alg/dijkstra.js
-_.constant(1);
-
-// src/graphlib/alg/floyd-warshall.js
-_.constant(1);
-function CycleException() {
+function createRootNode(g) {
+  var v;
+  while (g.hasNode(v = _.uniqueId("_root"))) ;
+  return v;
 }
-CycleException.prototype = new Error();
 
-// src/graphlib/alg/dfs.js
-function dfs(g, vs, order2) {
-  if (!_.isArray(vs)) {
-    vs = [vs];
-  }
-  var navigation = (g.isDirected() ? g.successors : g.neighbors).bind(g);
-  var acc = [];
-  var visited = {};
-  _.each(vs, function(v) {
-    if (!g.hasNode(v)) {
-      throw new Error("Graph does not have node: " + v);
-    }
-    doDfs(g, v, order2 === "post", visited, navigation, acc);
-  });
-  return acc;
-}
-function doDfs(g, v, postorder3, visited, navigation, acc) {
-  if (!_.has(visited, v)) {
-    visited[v] = true;
-    if (!postorder3) {
-      acc.push(v);
-    }
-    _.each(navigation(v), function(w) {
-      doDfs(g, w, postorder3, visited, navigation, acc);
-    });
-    if (postorder3) {
-      acc.push(v);
-    }
-  }
-}
-
-// src/graphlib/alg/postorder.js
-function postorder(g, vs) {
-  return dfs(g, vs, "post");
-}
-
-// src/graphlib/alg/preorder.js
-function preorder(g, vs) {
-  return dfs(g, vs, "pre");
-}
-
-// src/dagre/rank/network-simplex.js
-networkSimplex.initLowLimValues = initLowLimValues;
-networkSimplex.initCutValues = initCutValues;
-networkSimplex.calcCutValue = calcCutValue;
-networkSimplex.leaveEdge = leaveEdge;
-networkSimplex.enterEdge = enterEdge;
-networkSimplex.exchangeEdges = exchangeEdges;
-function networkSimplex(g) {
-  g = simplify(g);
-  longestPath(g);
-  var t = feasibleTree(g);
-  initLowLimValues(t);
-  initCutValues(t, g);
-  var e, f;
-  while (e = leaveEdge(t)) {
-    f = enterEdge(t, g, e);
-    exchangeEdges(t, g, e, f);
-  }
-}
-function initCutValues(t, g) {
-  var vs = postorder(t, t.nodes());
-  vs = vs.slice(0, vs.length - 1);
-  _.forEach(vs, function(v) {
-    assignCutValue(t, g, v);
-  });
-}
-function assignCutValue(t, g, child) {
-  var childLab = t.node(child);
-  var parent = childLab.parent;
-  t.edge(child, parent).cutvalue = calcCutValue(t, g, child);
-}
-function calcCutValue(t, g, child) {
-  var childLab = t.node(child);
-  var parent = childLab.parent;
-  var childIsTail = true;
-  var graphEdge = g.edge(child, parent);
-  var cutValue = 0;
-  if (!graphEdge) {
-    childIsTail = false;
-    graphEdge = g.edge(parent, child);
-  }
-  cutValue = graphEdge.weight;
-  _.forEach(g.nodeEdges(child), function(e) {
-    var isOutEdge = e.v === child, other = isOutEdge ? e.w : e.v;
-    if (other !== parent) {
-      var pointsToHead = isOutEdge === childIsTail, otherWeight = g.edge(e).weight;
-      cutValue += pointsToHead ? otherWeight : -otherWeight;
-      if (isTreeEdge(t, child, other)) {
-        var otherCutValue = t.edge(child, other).cutvalue;
-        cutValue += pointsToHead ? -otherCutValue : otherCutValue;
-      }
-    }
-  });
-  return cutValue;
-}
-function initLowLimValues(tree, root) {
-  if (arguments.length < 2) {
-    root = tree.nodes()[0];
-  }
-  dfsAssignLowLim(tree, {}, 1, root);
-}
-function dfsAssignLowLim(tree, visited, nextLim, v, parent) {
-  var low = nextLim;
-  var label = tree.node(v);
-  visited[v] = true;
-  _.forEach(tree.neighbors(v), function(w) {
-    if (!_.has(visited, w)) {
-      nextLim = dfsAssignLowLim(tree, visited, nextLim, w, v);
-    }
-  });
-  label.low = low;
-  label.lim = nextLim++;
-  if (parent) {
-    label.parent = parent;
-  } else {
-    delete label.parent;
-  }
-  return nextLim;
-}
-function leaveEdge(tree) {
-  return _.find(tree.edges(), function(e) {
-    return tree.edge(e).cutvalue < 0;
-  });
-}
-function enterEdge(t, g, edge) {
-  var v = edge.v;
-  var w = edge.w;
-  if (!g.hasEdge(v, w)) {
-    v = edge.w;
-    w = edge.v;
-  }
-  var vLabel = t.node(v);
-  var wLabel = t.node(w);
-  var tailLabel = vLabel;
-  var flip = false;
-  if (vLabel.lim > wLabel.lim) {
-    tailLabel = wLabel;
-    flip = true;
-  }
-  var candidates = _.filter(g.edges(), function(edge2) {
-    return flip === isDescendant(t, t.node(edge2.v), tailLabel) && flip !== isDescendant(t, t.node(edge2.w), tailLabel);
-  });
-  return _.minBy(candidates, function(edge2) {
-    return slack(g, edge2);
-  });
-}
-function exchangeEdges(t, g, e, f) {
-  var v = e.v;
-  var w = e.w;
-  t.removeEdge(v, w);
-  t.setEdge(f.v, f.w, {});
-  initLowLimValues(t);
-  initCutValues(t, g);
-  updateRanks(t, g);
-}
-function updateRanks(t, g) {
-  var root = _.find(t.nodes(), function(v) {
-    return !g.node(v).parent;
-  });
-  var vs = preorder(t, root);
-  vs = vs.slice(1);
-  _.forEach(vs, function(v) {
-    var parent = t.node(v).parent, edge = g.edge(v, parent), flipped = false;
-    if (!edge) {
-      edge = g.edge(parent, v);
-      flipped = true;
-    }
-    g.node(v).rank = g.node(parent).rank + (flipped ? edge.minlen : -edge.minlen);
-  });
-}
-function isTreeEdge(tree, u, v) {
-  return tree.hasEdge(u, v);
-}
-function isDescendant(tree, vLabel, rootLabel) {
-  return rootLabel.low <= vLabel.lim && vLabel.lim <= rootLabel.lim;
-}
-
-// src/dagre/rank/index.js
-function rank(g) {
-  switch (g.graph().ranker) {
-    case "network-simplex":
-      networkSimplexRanker(g);
-      break;
-    case "tight-tree":
-      tightTreeRanker(g);
-      break;
-    case "longest-path":
-      longestPathRanker(g);
-      break;
-    default:
-      networkSimplexRanker(g);
-  }
-}
-var longestPathRanker = longestPath;
-function tightTreeRanker(g) {
-  longestPath(g);
-  feasibleTree(g);
-}
-function networkSimplexRanker(g) {
-  networkSimplex(g);
-}
-
-// src/dagre/nesting-graph.js
-function run3(g) {
-  var root = addDummyNode(g, "root", {}, "_root");
-  var depths = treeDepths(g);
-  var height = _.max(_.values(depths)) - 1;
-  var nodeSep = 2 * height + 1;
-  g.graph().nestingRoot = root;
-  _.forEach(g.edges(), function(e) {
-    g.edge(e).minlen *= nodeSep;
-  });
-  var weight = sumWeights(g) + 1;
-  _.forEach(g.children(), function(child) {
-    dfs2(g, root, nodeSep, weight, height, depths, child);
-  });
-  g.graph().nodeRankFactor = nodeSep;
-}
-function dfs2(g, root, nodeSep, weight, height, depths, v) {
-  var children = g.children(v);
-  if (!children.length) {
-    if (v !== root) {
-      g.setEdge(root, v, { weight: 0, minlen: nodeSep });
-    }
-    return;
-  }
-  var top = addBorderNode(g, "_bt");
-  var bottom = addBorderNode(g, "_bb");
-  var label = g.node(v);
-  g.setParent(top, v);
-  label.borderTop = top;
-  g.setParent(bottom, v);
-  label.borderBottom = bottom;
-  _.forEach(children, function(child) {
-    dfs2(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;
-    g.setEdge(top, childTop, {
-      weight: thisWeight,
-      minlen,
-      nestingEdge: true
-    });
-    g.setEdge(childBottom, bottom, {
-      weight: thisWeight,
-      minlen,
-      nestingEdge: true
-    });
-  });
-  if (!g.parent(v)) {
-    g.setEdge(root, top, { weight: 0, minlen: height + depths[v] });
-  }
-}
-function treeDepths(g) {
-  var depths = {};
-  function dfs3(v, depth) {
-    var children = g.children(v);
-    if (children && children.length) {
-      _.forEach(children, function(child) {
-        dfs3(child, depth + 1);
-      });
-    }
-    depths[v] = depth;
-  }
-  _.forEach(g.children(), function(v) {
-    dfs3(v, 1);
-  });
-  return depths;
-}
-function sumWeights(g) {
-  return _.reduce(
-    g.edges(),
-    function(acc, e) {
-      return acc + g.edge(e).weight;
-    },
-    0
-  );
-}
-function cleanup(g) {
-  var graphLabel = g.graph();
-  g.removeNode(graphLabel.nestingRoot);
-  delete graphLabel.nestingRoot;
-  _.forEach(g.edges(), function(e) {
-    var edge = g.edge(e);
-    if (edge.nestingEdge) {
-      g.removeEdge(e);
-    }
-  });
-}
-
-// src/dagre/order/add-subgraph-constraints.js
-function addSubgraphConstraints(g, cg, vs) {
-  var prev = {}, rootPrev;
-  _.forEach(vs, function(v) {
-    var child = g.parent(v), parent, prevChild;
-    while (child) {
-      parent = g.parent(child);
-      if (parent) {
-        prevChild = prev[parent];
-        prev[parent] = child;
-      } else {
-        prevChild = rootPrev;
-        rootPrev = child;
-      }
-      if (prevChild && prevChild !== child) {
-        cg.setEdge(prevChild, child);
-        return;
-      }
-      child = parent;
-    }
-  });
-}
-
-// src/dagre/order/build-layer-graph.js
-function buildLayerGraph(g, rank2, relationship) {
-  var root = createRootNode(g), result = new Graph({ compound: true }).setGraph({ root }).setDefaultNodeLabel(function(v) {
-    return g.node(v);
-  });
-  _.forEach(g.nodes(), function(v) {
-    var node = g.node(v), parent = g.parent(v);
-    if (node.rank === rank2 || node.minRank <= rank2 && rank2 <= node.maxRank) {
-      result.setNode(v);
-      result.setParent(v, parent || root);
-      _.forEach(g[relationship](v), function(e) {
-        var u = e.v === v ? e.w : e.v, edge = result.edge(u, v), weight = !_.isUndefined(edge) ? edge.weight : 0;
-        result.setEdge(u, v, { weight: g.edge(e).weight + weight });
-      });
-      if (_.has(node, "minRank")) {
-        result.setNode(v, {
-          borderLeft: node.borderLeft[rank2],
-          borderRight: node.borderRight[rank2]
-        });
-      }
-    }
-  });
-  return result;
-}
-function createRootNode(g) {
-  var v;
-  while (g.hasNode(v = _.uniqueId("_root"))) ;
-  return v;
-}
-
-// src/dagre/order/cross-count.js
-function crossCount(g, layering) {
-  var cc = 0;
-  for (var i = 1; i < layering.length; ++i) {
-    cc += twoLayerCrossCount(g, layering[i - 1], layering[i]);
+// src/dagre/order/cross-count.js
+function crossCount(g, layering) {
+  var cc = 0;
+  for (var i = 1; i < layering.length; ++i) {
+    cc += twoLayerCrossCount(g, layering[i - 1], layering[i]);
   }
   return cc;
 }
 function twoLayerCrossCount(g, northLayer, southLayer) {
   var southPos = _.zipObject(
     southLayer,
-    _.map(southLayer, function(v, i) {
-      return i;
-    })
+    _.map(southLayer, (_v, i) => i)
   );
   var southEntries = _.flatten(
-    _.map(northLayer, function(v) {
-      return _.sortBy(
-        _.map(g.outEdges(v), function(e) {
-          return { pos: southPos[e.w], weight: g.edge(e).weight };
-        }),
+    _.map(
+      northLayer,
+      (v) => _.sortBy(
+        _.map(g.outEdges(v), (e) => ({
+          pos: southPos[e.w],
+          weight: g.edge(e).weight
+        })),
         "pos"
-      );
-    })
+      )
+    )
   );
   var firstIndex = 1;
   while (firstIndex < southLayer.length) firstIndex <<= 1;
   var treeSize = 2 * firstIndex - 1;
   firstIndex -= 1;
-  var tree = _.map(new Array(treeSize), function() {
-    return 0;
-  });
+  var tree = _.map(new Array(treeSize), () => 0);
   var cc = 0;
   _.forEach(
     // @ts-expect-error
-    southEntries.forEach(function(entry) {
+    southEntries.forEach((entry) => {
       var index = entry.pos + firstIndex;
       tree[index] += entry.weight;
       var weightSum = 0;
@@ -1418,17 +1105,9 @@ function twoLayerCrossCount(g, northLayer, southLayer) {
 // src/dagre/order/init-order.js
 function initOrder(g) {
   var visited = {};
-  var simpleNodes = _.filter(g.nodes(), function(v) {
-    return !g.children(v).length;
-  });
-  var maxRank2 = _.max(
-    _.map(simpleNodes, function(v) {
-      return g.node(v).rank;
-    })
-  );
-  var layers = _.map(_.range(maxRank2 + 1), function() {
-    return [];
-  });
+  var simpleNodes = _.filter(g.nodes(), (v) => !g.children(v).length);
+  var maxRank2 = _.max(_.map(simpleNodes, (v) => g.node(v).rank));
+  var layers = _.map(_.range(maxRank2 + 1), () => []);
   function dfs3(v) {
     if (_.has(visited, v)) return;
     visited[v] = true;
@@ -1436,23 +1115,21 @@ function initOrder(g) {
     layers[node.rank].push(v);
     _.forEach(g.successors(v), dfs3);
   }
-  var orderedVs = _.sortBy(simpleNodes, function(v) {
-    return g.node(v).rank;
-  });
+  var orderedVs = _.sortBy(simpleNodes, (v) => g.node(v).rank);
   _.forEach(orderedVs, dfs3);
   return layers;
 }
 
 // src/dagre/order/barycenter.js
 function barycenter(g, movable) {
-  return _.map(movable, function(v) {
+  return _.map(movable, (v) => {
     var inV = g.inEdges(v);
     if (!inV.length) {
       return { v };
     } else {
       var result = _.reduce(
         inV,
-        function(acc, e) {
+        (acc, e) => {
           var edge = g.edge(e), nodeU = g.node(e.v);
           return {
             sum: acc.sum + edge.weight * nodeU.order,
@@ -1473,7 +1150,7 @@ function barycenter(g, movable) {
 // src/dagre/order/resolve-conflicts.js
 function resolveConflicts(entries, cg) {
   var mappedEntries = {};
-  _.forEach(entries, function(entry, i) {
+  _.forEach(entries, (entry, i) => {
     var tmp = mappedEntries[entry.v] = {
       indegree: 0,
       in: [],
@@ -1486,7 +1163,7 @@ function resolveConflicts(entries, cg) {
       tmp.weight = entry.weight;
     }
   });
-  _.forEach(cg.edges(), function(e) {
+  _.forEach(cg.edges(), (e) => {
     var entryV = mappedEntries[e.v];
     var entryW = mappedEntries[e.w];
     if (!_.isUndefined(entryV) && !_.isUndefined(entryW)) {
@@ -1494,7 +1171,7 @@ function resolveConflicts(entries, cg) {
       entryV.out.push(mappedEntries[e.w]);
     }
   });
-  var sourceSet = _.filter(mappedEntries, function(entry) {
+  var sourceSet = _.filter(mappedEntries, (entry) => {
     return !entry.indegree;
   });
   return doResolveConflicts(sourceSet);
@@ -1502,7 +1179,7 @@ function resolveConflicts(entries, cg) {
 function doResolveConflicts(sourceSet) {
   var entries = [];
   function handleIn(vEntry) {
-    return function(uEntry) {
+    return (uEntry) => {
       if (uEntry.merged) {
         return;
       }
@@ -1512,8 +1189,8 @@ function doResolveConflicts(sourceSet) {
     };
   }
   function handleOut(vEntry) {
-    return function(wEntry) {
-      wEntry["in"].push(vEntry);
+    return (wEntry) => {
+      wEntry.in.push(vEntry);
       if (--wEntry.indegree === 0) {
         sourceSet.push(wEntry);
       }
@@ -1522,16 +1199,12 @@ function doResolveConflicts(sourceSet) {
   while (sourceSet.length) {
     var entry = sourceSet.pop();
     entries.push(entry);
-    _.forEach(entry["in"].reverse(), handleIn(entry));
+    _.forEach(entry.in.reverse(), handleIn(entry));
     _.forEach(entry.out, handleOut(entry));
   }
   return _.map(
-    _.filter(entries, function(entry2) {
-      return !entry2.merged;
-    }),
-    function(entry2) {
-      return _.pick(entry2, ["vs", "i", "barycenter", "weight"]);
-    }
+    _.filter(entries, (entry2) => !entry2.merged),
+    (entry2) => _.pick(entry2, ["vs", "i", "barycenter", "weight"])
   );
 }
 function mergeEntries(target, source) {
@@ -1554,15 +1227,11 @@ function mergeEntries(target, source) {
 
 // src/dagre/order/sort.js
 function sort(entries, biasRight) {
-  var parts = partition(entries, function(entry) {
-    return _.has(entry, "barycenter");
-  });
-  var sortable = parts.lhs, unsortable = _.sortBy(parts.rhs, function(entry) {
-    return -entry.i;
-  }), vs = [], sum = 0, weight = 0, vsIndex = 0;
+  var parts = partition(entries, (entry) => _.has(entry, "barycenter"));
+  var sortable = parts.lhs, unsortable = _.sortBy(parts.rhs, (entry) => -entry.i), vs = [], sum = 0, weight = 0, vsIndex = 0;
   sortable.sort(compareWithBias(!!biasRight));
   vsIndex = consumeUnsortable(vs, unsortable, vsIndex);
-  _.forEach(sortable, function(entry) {
+  _.forEach(sortable, (entry) => {
     vsIndex += entry.vs.length;
     vs.push(entry.vs);
     sum += entry.barycenter * entry.weight;
@@ -1586,7 +1255,7 @@ function consumeUnsortable(vs, unsortable, index) {
   return index;
 }
 function compareWithBias(bias) {
-  return function(entryV, entryW) {
+  return (entryV, entryW) => {
     if (entryV.barycenter < entryW.barycenter) {
       return -1;
     } else if (entryV.barycenter > entryW.barycenter) {
@@ -1604,12 +1273,10 @@ function sortSubgraph(g, v, cg, biasRight) {
   var br = node ? node.borderRight : void 0;
   var subgraphs = {};
   if (bl) {
-    movable = _.filter(movable, function(w) {
-      return w !== bl && w !== br;
-    });
+    movable = _.filter(movable, (w) => w !== bl && w !== br);
   }
   var barycenters = barycenter(g, movable);
-  _.forEach(barycenters, function(entry) {
+  _.forEach(barycenters, (entry) => {
     if (g.children(entry.v).length) {
       var subgraphResult = sortSubgraph(g, entry.v, cg, biasRight);
       subgraphs[entry.v] = subgraphResult;
@@ -1636,9 +1303,9 @@ function sortSubgraph(g, v, cg, biasRight) {
   return result;
 }
 function expandSubgraphs(entries, subgraphs) {
-  _.forEach(entries, function(entry) {
+  _.forEach(entries, (entry) => {
     entry.vs = _.flatten(
-      entry.vs.map(function(v) {
+      entry.vs.map((v) => {
         if (subgraphs[v]) {
           return subgraphs[v].vs;
         }
@@ -1659,7 +1326,11 @@ function mergeBarycenters(target, other) {
 
 // src/dagre/order/index.js
 function order(g) {
-  var maxRank2 = maxRank(g), downLayerGraphs = buildLayerGraphs(g, _.range(1, maxRank2 + 1), "inEdges"), upLayerGraphs = buildLayerGraphs(g, _.range(maxRank2 - 1, -1, -1), "outEdges");
+  var maxRank2 = maxRank(g), downLayerGraphs = buildLayerGraphs(g, _.range(1, maxRank2 + 1), "inEdges"), upLayerGraphs = buildLayerGraphs(
+    g,
+    _.range(maxRank2 - 1, -1, -1),
+    "outEdges"
+  );
   var layering = initOrder(g);
   assignOrder(g, layering);
   var bestCC = Number.POSITIVE_INFINITY, best;
@@ -1676,24 +1347,22 @@ function order(g) {
   assignOrder(g, best);
 }
 function buildLayerGraphs(g, ranks, relationship) {
-  return _.map(ranks, function(rank2) {
-    return buildLayerGraph(g, rank2, relationship);
-  });
+  return _.map(ranks, (rank2) => buildLayerGraph(g, rank2, relationship));
 }
 function sweepLayerGraphs(layerGraphs, biasRight) {
   var cg = new Graph();
-  _.forEach(layerGraphs, function(lg) {
+  _.forEach(layerGraphs, (lg) => {
     var root = lg.graph().root;
     var sorted = sortSubgraph(lg, root, cg, biasRight);
-    _.forEach(sorted.vs, function(v, i) {
+    _.forEach(sorted.vs, (v, i) => {
       lg.node(v).order = i;
     });
     addSubgraphConstraints(lg, cg, sorted.vs);
   });
 }
 function assignOrder(g, layering) {
-  _.forEach(layering, function(layer) {
-    _.forEach(layer, function(v, i) {
+  _.forEach(layering, (layer) => {
+    _.forEach(layer, (v, i) => {
       g.node(v).order = i;
     });
   });
@@ -1701,8 +1370,8 @@ function assignOrder(g, layering) {
 
 // src/dagre/parent-dummy-chains.js
 function parentDummyChains(g) {
-  var postorderNums = postorder2(g);
-  _.forEach(g.graph().dummyChains, function(v) {
+  var postorderNums = postorder(g);
+  _.forEach(g.graph().dummyChains, (v) => {
     var node = g.node(v);
     var edgeObj = node.edgeObj;
     var pathData = findPath(g, postorderNums, edgeObj.v, edgeObj.w);
@@ -1727,450 +1396,720 @@ function parentDummyChains(g) {
         }
         pathV = path[pathIdx];
       }
-      g.setParent(v, pathV);
-      v = g.successors(v)[0];
+      g.setParent(v, pathV);
+      v = g.successors(v)[0];
+    }
+  });
+}
+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;
+  parent = v;
+  do {
+    parent = g.parent(parent);
+    vPath.push(parent);
+  } while (parent && (postorderNums[parent].low > low || lim > postorderNums[parent].lim));
+  lca = parent;
+  parent = w;
+  while ((parent = g.parent(parent)) !== lca) {
+    wPath.push(parent);
+  }
+  return { path: vPath.concat(wPath.reverse()), lca };
+}
+function postorder(g) {
+  var result = {};
+  var lim = 0;
+  function dfs3(v) {
+    var low = lim;
+    _.forEach(g.children(v), dfs3);
+    result[v] = { low, lim: lim++ };
+  }
+  _.forEach(g.children(), dfs3);
+  return result;
+}
+
+// src/dagre/position/bk.js
+function findType1Conflicts(g, layering) {
+  var conflicts = {};
+  function visitLayer(prevLayer, layer) {
+    var k0 = 0, scanPos = 0, prevLayerLength = prevLayer.length, lastNode = _.last(layer);
+    _.forEach(layer, (v, i) => {
+      var w = findOtherInnerSegmentNode(g, v), k1 = w ? g.node(w).order : prevLayerLength;
+      if (w || v === lastNode) {
+        _.forEach(layer.slice(scanPos, i + 1), (scanNode) => {
+          _.forEach(g.predecessors(scanNode), (u) => {
+            var uLabel = g.node(u), uPos = uLabel.order;
+            if ((uPos < k0 || k1 < uPos) && !(uLabel.dummy && g.node(scanNode).dummy)) {
+              addConflict(conflicts, u, scanNode);
+            }
+          });
+        });
+        scanPos = i + 1;
+        k0 = k1;
+      }
+    });
+    return layer;
+  }
+  _.reduce(layering, visitLayer);
+  return conflicts;
+}
+function findType2Conflicts(g, layering) {
+  var conflicts = {};
+  function scan(south, southPos, southEnd, prevNorthBorder, nextNorthBorder) {
+    var v;
+    _.forEach(_.range(southPos, southEnd), (i) => {
+      v = south[i];
+      if (g.node(v).dummy) {
+        _.forEach(g.predecessors(v), (u) => {
+          var uNode = g.node(u);
+          if (uNode.dummy && (uNode.order < prevNorthBorder || uNode.order > nextNorthBorder)) {
+            addConflict(conflicts, u, v);
+          }
+        });
+      }
+    });
+  }
+  function visitLayer(north, south) {
+    var prevNorthPos = -1, nextNorthPos, southPos = 0;
+    _.forEach(south, (v, southLookahead) => {
+      if (g.node(v).dummy === "border") {
+        var predecessors = g.predecessors(v);
+        if (predecessors.length) {
+          nextNorthPos = g.node(predecessors[0]).order;
+          scan(south, southPos, southLookahead, prevNorthPos, nextNorthPos);
+          southPos = southLookahead;
+          prevNorthPos = nextNorthPos;
+        }
+      }
+      scan(south, southPos, south.length, nextNorthPos, north.length);
+    });
+    return south;
+  }
+  _.reduce(layering, visitLayer);
+  return conflicts;
+}
+function findOtherInnerSegmentNode(g, v) {
+  if (g.node(v).dummy) {
+    return _.find(g.predecessors(v), (u) => g.node(u).dummy);
+  }
+}
+function addConflict(conflicts, v, w) {
+  if (v > w) {
+    var tmp = v;
+    v = w;
+    w = tmp;
+  }
+  var conflictsV = conflicts[v];
+  if (!conflictsV) {
+    conflicts[v] = conflictsV = {};
+  }
+  conflictsV[w] = true;
+}
+function hasConflict(conflicts, v, w) {
+  if (v > w) {
+    var tmp = v;
+    v = w;
+    w = tmp;
+  }
+  return _.has(conflicts[v], w);
+}
+function verticalAlignment(_g, layering, conflicts, neighborFn) {
+  var root = {}, align = {}, pos = {};
+  _.forEach(layering, (layer) => {
+    _.forEach(layer, (v, order2) => {
+      root[v] = v;
+      align[v] = v;
+      pos[v] = order2;
+    });
+  });
+  _.forEach(layering, (layer) => {
+    var prevIdx = -1;
+    _.forEach(layer, (v) => {
+      var ws = neighborFn(v);
+      if (ws.length) {
+        ws = _.sortBy(ws, (w2) => pos[w2]);
+        var mp = (ws.length - 1) / 2;
+        for (var i = Math.floor(mp), il = Math.ceil(mp); i <= il; ++i) {
+          var w = ws[i];
+          if (align[v] === v && prevIdx < pos[w] && !hasConflict(conflicts, v, w)) {
+            align[w] = v;
+            align[v] = root[v] = root[w];
+            prevIdx = pos[w];
+          }
+        }
+      }
+    });
+  });
+  return { root, align };
+}
+function horizontalCompaction(g, layering, root, align, reverseSep) {
+  var 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 = {};
+    while (elem) {
+      if (visited[elem]) {
+        setXsFunc(elem);
+      } else {
+        visited[elem] = true;
+        stack.push(elem);
+        stack = stack.concat(nextNodesFunc(elem));
+      }
+      elem = stack.pop();
+    }
+  }
+  function pass1(elem) {
+    xs[elem] = blockG.inEdges(elem).reduce((acc, e) => Math.max(acc, xs[e.v] + blockG.edge(e)), 0);
+  }
+  function pass2(elem) {
+    var min = blockG.outEdges(elem).reduce(
+      (acc, e) => Math.min(acc, xs[e.w] - blockG.edge(e)),
+      Number.POSITIVE_INFINITY
+    );
+    var node = g.node(elem);
+    if (min !== Number.POSITIVE_INFINITY && node.borderType !== borderType) {
+      xs[elem] = Math.max(xs[elem], min);
+    }
+  }
+  iterate(pass1, blockG.predecessors.bind(blockG));
+  iterate(pass2, blockG.successors.bind(blockG));
+  _.forEach(align, (v) => {
+    xs[v] = xs[root[v]];
+  });
+  return xs;
+}
+function buildBlockGraph(g, layering, root, reverseSep) {
+  var blockGraph = new Graph(), graphLabel = g.graph(), sepFn = sep(graphLabel.nodesep, graphLabel.edgesep, reverseSep);
+  _.forEach(layering, (layer) => {
+    var u;
+    _.forEach(layer, (v) => {
+      var vRoot = root[v];
+      blockGraph.setNode(vRoot);
+      if (u) {
+        var uRoot = root[u], prevMax = blockGraph.edge(uRoot, vRoot);
+        blockGraph.setEdge(
+          uRoot,
+          vRoot,
+          Math.max(sepFn(g, v, u), prevMax || 0)
+        );
+      }
+      u = v;
+    });
+  });
+  return blockGraph;
+}
+function findSmallestWidthAlignment(g, xss) {
+  return _.minBy(_.values(xss), (xs) => {
+    var max = Number.NEGATIVE_INFINITY;
+    var min = Number.POSITIVE_INFINITY;
+    _.forIn(xs, (x, v) => {
+      var halfWidth = width(g, v) / 2;
+      max = Math.max(x + halfWidth, max);
+      min = Math.min(x - halfWidth, min);
+    });
+    return max - min;
+  });
+}
+function alignCoordinates(xss, alignTo) {
+  var alignToVals = _.values(alignTo), alignToMin = _.min(alignToVals), alignToMax = _.max(alignToVals);
+  _.forEach(["u", "d"], (vert) => {
+    _.forEach(["l", "r"], (horiz) => {
+      var alignment = vert + horiz, xs = xss[alignment], delta;
+      if (xs === alignTo) return;
+      var xsVals = _.values(xs);
+      delta = horiz === "l" ? alignToMin - _.min(xsVals) : alignToMax - _.max(xsVals);
+      if (delta) {
+        xss[alignment] = _.mapValues(xs, (x) => x + delta);
+      }
+    });
+  });
+}
+function balance(xss, align) {
+  return _.mapValues(xss.ul, (_ignore, v) => {
+    if (align) {
+      return xss[align.toLowerCase()][v];
+    } else {
+      var xs = _.sortBy(_.map(xss, v));
+      return (xs[1] + xs[2]) / 2;
+    }
+  });
+}
+function positionX(g) {
+  var layering = buildLayerMatrix(g);
+  var conflicts = _.merge(
+    findType1Conflicts(g, layering),
+    findType2Conflicts(g, layering)
+  );
+  var xss = {};
+  var adjustedLayering;
+  _.forEach(["u", "d"], (vert) => {
+    adjustedLayering = vert === "u" ? layering : _.values(layering).reverse();
+    _.forEach(["l", "r"], (horiz) => {
+      if (horiz === "r") {
+        adjustedLayering = _.map(
+          adjustedLayering,
+          (inner) => _.values(inner).reverse()
+        );
+      }
+      var neighborFn = (vert === "u" ? g.predecessors : g.successors).bind(g);
+      var align = verticalAlignment(g, adjustedLayering, conflicts, neighborFn);
+      var xs = horizontalCompaction(
+        g,
+        adjustedLayering,
+        align.root,
+        align.align,
+        horiz === "r"
+      );
+      if (horiz === "r") {
+        xs = _.mapValues(xs, (x) => -x);
+      }
+      xss[vert + horiz] = xs;
+    });
+  });
+  var smallestWidth = findSmallestWidthAlignment(g, xss);
+  alignCoordinates(xss, smallestWidth);
+  return balance(xss, g.graph().align);
+}
+function sep(nodeSep, edgeSep, reverseSep) {
+  return (g, v, w) => {
+    var vLabel = g.node(v);
+    var wLabel = g.node(w);
+    var sum = 0;
+    var delta;
+    sum += vLabel.width / 2;
+    if (_.has(vLabel, "labelpos")) {
+      switch (vLabel.labelpos.toLowerCase()) {
+        case "l":
+          delta = -vLabel.width / 2;
+          break;
+        case "r":
+          delta = vLabel.width / 2;
+          break;
+      }
+    }
+    if (delta) {
+      sum += reverseSep ? delta : -delta;
+    }
+    delta = 0;
+    sum += (vLabel.dummy ? edgeSep : nodeSep) / 2;
+    sum += (wLabel.dummy ? edgeSep : nodeSep) / 2;
+    sum += wLabel.width / 2;
+    if (_.has(wLabel, "labelpos")) {
+      switch (wLabel.labelpos.toLowerCase()) {
+        case "l":
+          delta = wLabel.width / 2;
+          break;
+        case "r":
+          delta = -wLabel.width / 2;
+          break;
+      }
     }
+    if (delta) {
+      sum += reverseSep ? delta : -delta;
+    }
+    delta = 0;
+    return sum;
+  };
+}
+function width(g, v) {
+  return g.node(v).width;
+}
+
+// src/dagre/position/index.js
+function position(g) {
+  g = asNonCompoundGraph(g);
+  positionY(g);
+  _.forOwn(positionX(g), (x, v) => {
+    g.node(v).x = x;
   });
 }
-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;
-  parent = v;
-  do {
-    parent = g.parent(parent);
-    vPath.push(parent);
-  } while (parent && (postorderNums[parent].low > low || lim > postorderNums[parent].lim));
-  lca = parent;
-  parent = w;
-  while ((parent = g.parent(parent)) !== lca) {
-    wPath.push(parent);
-  }
-  return { path: vPath.concat(wPath.reverse()), lca };
+function positionY(g) {
+  var layering = buildLayerMatrix(g);
+  var rankSep = g.graph().ranksep;
+  var prevY = 0;
+  _.forEach(layering, (layer) => {
+    var maxHeight = _.max(_.map(layer, (v) => g.node(v).height));
+    _.forEach(layer, (v) => {
+      g.node(v).y = prevY + maxHeight / 2;
+    });
+    prevY += maxHeight + rankSep;
+  });
 }
-function postorder2(g) {
-  var result = {};
-  var lim = 0;
+
+// src/dagre/rank/util.js
+function longestPath(g) {
+  var visited = {};
   function dfs3(v) {
-    var low = lim;
-    _.forEach(g.children(v), dfs3);
-    result[v] = { low, lim: lim++ };
+    var label = g.node(v);
+    if (_.has(visited, v)) {
+      return label.rank;
+    }
+    visited[v] = true;
+    var rank2 = _.min(_.map(g.outEdges(v), (e) => dfs3(e.w) - g.edge(e).minlen));
+    if (rank2 === Number.POSITIVE_INFINITY || // return value of _.map([]) for Lodash 3
+    rank2 === void 0 || // return value of _.map([]) for Lodash 4
+    rank2 === null) {
+      rank2 = 0;
+    }
+    return label.rank = rank2;
   }
-  _.forEach(g.children(), dfs3);
-  return result;
+  _.forEach(g.sources(), dfs3);
+}
+function slack(g, e) {
+  return g.node(e.w).rank - g.node(e.v).rank - g.edge(e).minlen;
 }
 
-// src/dagre/position/bk.js
-function findType1Conflicts(g, layering) {
-  var conflicts = {};
-  function visitLayer(prevLayer, layer) {
-    var k0 = 0, scanPos = 0, prevLayerLength = prevLayer.length, lastNode = _.last(layer);
-    _.forEach(layer, function(v, i) {
-      var w = findOtherInnerSegmentNode(g, v), k1 = w ? g.node(w).order : prevLayerLength;
-      if (w || v === lastNode) {
-        _.forEach(layer.slice(scanPos, i + 1), function(scanNode) {
-          _.forEach(g.predecessors(scanNode), function(u) {
-            var uLabel = g.node(u), uPos = uLabel.order;
-            if ((uPos < k0 || k1 < uPos) && !(uLabel.dummy && g.node(scanNode).dummy)) {
-              addConflict(conflicts, u, scanNode);
-            }
-          });
-        });
-        scanPos = i + 1;
-        k0 = k1;
-      }
-    });
-    return layer;
+// src/dagre/rank/feasible-tree.js
+function feasibleTree(g) {
+  var t = new Graph({ directed: false });
+  var start = g.nodes()[0];
+  var size = g.nodeCount();
+  t.setNode(start, {});
+  var edge, delta;
+  while (tightTree(t, g) < size) {
+    edge = findMinSlackEdge(t, g);
+    delta = t.hasNode(edge.v) ? slack(g, edge) : -slack(g, edge);
+    shiftRanks(t, g, delta);
   }
-  _.reduce(layering, visitLayer);
-  return conflicts;
+  return t;
 }
-function findType2Conflicts(g, layering) {
-  var conflicts = {};
-  function scan(south, southPos, southEnd, prevNorthBorder, nextNorthBorder) {
-    var v;
-    _.forEach(_.range(southPos, southEnd), function(i) {
-      v = south[i];
-      if (g.node(v).dummy) {
-        _.forEach(g.predecessors(v), function(u) {
-          var uNode = g.node(u);
-          if (uNode.dummy && (uNode.order < prevNorthBorder || uNode.order > nextNorthBorder)) {
-            addConflict(conflicts, u, v);
-          }
-        });
+function tightTree(t, g) {
+  function dfs3(v) {
+    _.forEach(g.nodeEdges(v), (e) => {
+      var edgeV = e.v, w = v === edgeV ? e.w : edgeV;
+      if (!t.hasNode(w) && !slack(g, e)) {
+        t.setNode(w, {});
+        t.setEdge(v, w, {});
+        dfs3(w);
       }
     });
   }
-  function visitLayer(north, south) {
-    var prevNorthPos = -1, nextNorthPos, southPos = 0;
-    _.forEach(south, function(v, southLookahead) {
-      if (g.node(v).dummy === "border") {
-        var predecessors = g.predecessors(v);
-        if (predecessors.length) {
-          nextNorthPos = g.node(predecessors[0]).order;
-          scan(south, southPos, southLookahead, prevNorthPos, nextNorthPos);
-          southPos = southLookahead;
-          prevNorthPos = nextNorthPos;
-        }
-      }
-      scan(south, southPos, south.length, nextNorthPos, north.length);
-    });
-    return south;
+  _.forEach(t.nodes(), dfs3);
+  return t.nodeCount();
+}
+function findMinSlackEdge(t, g) {
+  return _.minBy(g.edges(), (e) => {
+    if (t.hasNode(e.v) !== t.hasNode(e.w)) {
+      return slack(g, e);
+    }
+  });
+}
+function shiftRanks(t, g, delta) {
+  _.forEach(t.nodes(), (v) => {
+    g.node(v).rank += delta;
+  });
+}
+
+// src/graphlib/alg/dijkstra.js
+_.constant(1);
+
+// src/graphlib/alg/floyd-warshall.js
+_.constant(1);
+function CycleException() {
+}
+CycleException.prototype = new Error();
+
+// src/graphlib/alg/dfs.js
+function dfs2(g, vs, order2) {
+  if (!_.isArray(vs)) {
+    vs = [vs];
   }
-  _.reduce(layering, visitLayer);
-  return conflicts;
+  var navigation = (g.isDirected() ? g.successors : g.neighbors).bind(g);
+  var acc = [];
+  var visited = {};
+  _.each(vs, (v) => {
+    if (!g.hasNode(v)) {
+      throw new Error(`Graph does not have node: ${v}`);
+    }
+    doDfs(g, v, order2 === "post", visited, navigation, acc);
+  });
+  return acc;
 }
-function findOtherInnerSegmentNode(g, v) {
-  if (g.node(v).dummy) {
-    return _.find(g.predecessors(v), function(u) {
-      return g.node(u).dummy;
+function doDfs(g, v, postorder3, visited, navigation, acc) {
+  if (!_.has(visited, v)) {
+    visited[v] = true;
+    if (!postorder3) {
+      acc.push(v);
+    }
+    _.each(navigation(v), (w) => {
+      doDfs(g, w, postorder3, visited, navigation, acc);
     });
+    if (postorder3) {
+      acc.push(v);
+    }
   }
 }
-function addConflict(conflicts, v, w) {
-  if (v > w) {
-    var tmp = v;
-    v = w;
-    w = tmp;
-  }
-  var conflictsV = conflicts[v];
-  if (!conflictsV) {
-    conflicts[v] = conflictsV = {};
-  }
-  conflictsV[w] = true;
+
+// src/graphlib/alg/postorder.js
+function postorder2(g, vs) {
+  return dfs2(g, vs, "post");
 }
-function hasConflict(conflicts, v, w) {
-  if (v > w) {
-    var tmp = v;
-    v = w;
-    w = tmp;
+
+// src/graphlib/alg/preorder.js
+function preorder(g, vs) {
+  return dfs2(g, vs, "pre");
+}
+
+// src/dagre/rank/network-simplex.js
+networkSimplex.initLowLimValues = initLowLimValues;
+networkSimplex.initCutValues = initCutValues;
+networkSimplex.calcCutValue = calcCutValue;
+networkSimplex.leaveEdge = leaveEdge;
+networkSimplex.enterEdge = enterEdge;
+networkSimplex.exchangeEdges = exchangeEdges;
+function networkSimplex(g) {
+  g = simplify(g);
+  longestPath(g);
+  var t = feasibleTree(g);
+  initLowLimValues(t);
+  initCutValues(t, g);
+  var e, f;
+  while (e = leaveEdge(t)) {
+    f = enterEdge(t, g, e);
+    exchangeEdges(t, g, e, f);
   }
-  return _.has(conflicts[v], w);
 }
-function verticalAlignment(g, layering, conflicts, neighborFn) {
-  var root = {}, align = {}, pos = {};
-  _.forEach(layering, function(layer) {
-    _.forEach(layer, function(v, order2) {
-      root[v] = v;
-      align[v] = v;
-      pos[v] = order2;
-    });
-  });
-  _.forEach(layering, function(layer) {
-    var prevIdx = -1;
-    _.forEach(layer, function(v) {
-      var ws = neighborFn(v);
-      if (ws.length) {
-        ws = _.sortBy(ws, function(w2) {
-          return pos[w2];
-        });
-        var mp = (ws.length - 1) / 2;
-        for (var i = Math.floor(mp), il = Math.ceil(mp); i <= il; ++i) {
-          var w = ws[i];
-          if (align[v] === v && prevIdx < pos[w] && !hasConflict(conflicts, v, w)) {
-            align[w] = v;
-            align[v] = root[v] = root[w];
-            prevIdx = pos[w];
-          }
-        }
-      }
-    });
+function initCutValues(t, g) {
+  var vs = postorder2(t, t.nodes());
+  vs = vs.slice(0, vs.length - 1);
+  _.forEach(vs, (v) => {
+    assignCutValue(t, g, v);
   });
-  return { root, align };
 }
-function horizontalCompaction(g, layering, root, align, reverseSep) {
-  var 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 = {};
-    while (elem) {
-      if (visited[elem]) {
-        setXsFunc(elem);
-      } else {
-        visited[elem] = true;
-        stack.push(elem);
-        stack = stack.concat(nextNodesFunc(elem));
+function assignCutValue(t, g, child) {
+  var childLab = t.node(child);
+  var parent = childLab.parent;
+  t.edge(child, parent).cutvalue = calcCutValue(t, g, child);
+}
+function calcCutValue(t, g, child) {
+  var childLab = t.node(child);
+  var parent = childLab.parent;
+  var childIsTail = true;
+  var graphEdge = g.edge(child, parent);
+  var cutValue = 0;
+  if (!graphEdge) {
+    childIsTail = false;
+    graphEdge = g.edge(parent, child);
+  }
+  cutValue = graphEdge.weight;
+  _.forEach(g.nodeEdges(child), (e) => {
+    var isOutEdge = e.v === child, other = isOutEdge ? e.w : e.v;
+    if (other !== parent) {
+      var pointsToHead = isOutEdge === childIsTail, otherWeight = g.edge(e).weight;
+      cutValue += pointsToHead ? otherWeight : -otherWeight;
+      if (isTreeEdge(t, child, other)) {
+        var otherCutValue = t.edge(child, other).cutvalue;
+        cutValue += pointsToHead ? -otherCutValue : otherCutValue;
       }
-      elem = stack.pop();
     }
+  });
+  return cutValue;
+}
+function initLowLimValues(tree, root) {
+  if (arguments.length < 2) {
+    root = tree.nodes()[0];
   }
-  function pass1(elem) {
-    xs[elem] = blockG.inEdges(elem).reduce(function(acc, e) {
-      return Math.max(acc, xs[e.v] + blockG.edge(e));
-    }, 0);
-  }
-  function pass2(elem) {
-    var min = blockG.outEdges(elem).reduce(function(acc, e) {
-      return Math.min(acc, xs[e.w] - blockG.edge(e));
-    }, Number.POSITIVE_INFINITY);
-    var node = g.node(elem);
-    if (min !== Number.POSITIVE_INFINITY && node.borderType !== borderType) {
-      xs[elem] = Math.max(xs[elem], min);
+  dfsAssignLowLim(tree, {}, 1, root);
+}
+function dfsAssignLowLim(tree, visited, nextLim, v, parent) {
+  var low = nextLim;
+  var label = tree.node(v);
+  visited[v] = true;
+  _.forEach(tree.neighbors(v), (w) => {
+    if (!_.has(visited, w)) {
+      nextLim = dfsAssignLowLim(tree, visited, nextLim, w, v);
     }
-  }
-  iterate(pass1, blockG.predecessors.bind(blockG));
-  iterate(pass2, blockG.successors.bind(blockG));
-  _.forEach(align, function(v) {
-    xs[v] = xs[root[v]];
   });
-  return xs;
+  label.low = low;
+  label.lim = nextLim++;
+  if (parent) {
+    label.parent = parent;
+  } else {
+    delete label.parent;
+  }
+  return nextLim;
 }
-function buildBlockGraph(g, layering, root, reverseSep) {
-  var blockGraph = new Graph(), graphLabel = g.graph(), sepFn = sep(graphLabel.nodesep, graphLabel.edgesep, reverseSep);
-  _.forEach(layering, function(layer) {
-    var u;
-    _.forEach(layer, function(v) {
-      var vRoot = root[v];
-      blockGraph.setNode(vRoot);
-      if (u) {
-        var uRoot = root[u], prevMax = blockGraph.edge(uRoot, vRoot);
-        blockGraph.setEdge(uRoot, vRoot, Math.max(sepFn(g, v, u), prevMax || 0));
-      }
-      u = v;
-    });
-  });
-  return blockGraph;
+function leaveEdge(tree) {
+  return _.find(tree.edges(), (e) => tree.edge(e).cutvalue < 0);
 }
-function findSmallestWidthAlignment(g, xss) {
-  return _.minBy(_.values(xss), function(xs) {
-    var max = Number.NEGATIVE_INFINITY;
-    var min = Number.POSITIVE_INFINITY;
-    _.forIn(xs, function(x, v) {
-      var halfWidth = width(g, v) / 2;
-      max = Math.max(x + halfWidth, max);
-      min = Math.min(x - halfWidth, min);
-    });
-    return max - min;
-  });
+function enterEdge(t, g, edge) {
+  var v = edge.v;
+  var w = edge.w;
+  if (!g.hasEdge(v, w)) {
+    v = edge.w;
+    w = edge.v;
+  }
+  var vLabel = t.node(v);
+  var wLabel = t.node(w);
+  var tailLabel = vLabel;
+  var flip = false;
+  if (vLabel.lim > wLabel.lim) {
+    tailLabel = wLabel;
+    flip = true;
+  }
+  var candidates = _.filter(
+    g.edges(),
+    (edge2) => flip === isDescendant(t, t.node(edge2.v), tailLabel) && flip !== isDescendant(t, t.node(edge2.w), tailLabel)
+  );
+  return _.minBy(candidates, (edge2) => slack(g, edge2));
 }
-function alignCoordinates(xss, alignTo) {
-  var alignToVals = _.values(alignTo), alignToMin = _.min(alignToVals), alignToMax = _.max(alignToVals);
-  _.forEach(["u", "d"], function(vert) {
-    _.forEach(["l", "r"], function(horiz) {
-      var alignment = vert + horiz, xs = xss[alignment], delta;
-      if (xs === alignTo) return;
-      var xsVals = _.values(xs);
-      delta = horiz === "l" ? alignToMin - _.min(xsVals) : alignToMax - _.max(xsVals);
-      if (delta) {
-        xss[alignment] = _.mapValues(xs, function(x) {
-          return x + delta;
-        });
-      }
-    });
-  });
+function exchangeEdges(t, g, e, f) {
+  var v = e.v;
+  var w = e.w;
+  t.removeEdge(v, w);
+  t.setEdge(f.v, f.w, {});
+  initLowLimValues(t);
+  initCutValues(t, g);
+  updateRanks(t, g);
 }
-function balance(xss, align) {
-  return _.mapValues(xss.ul, function(ignore, v) {
-    if (align) {
-      return xss[align.toLowerCase()][v];
-    } else {
-      var xs = _.sortBy(_.map(xss, v));
-      return (xs[1] + xs[2]) / 2;
+function updateRanks(t, g) {
+  var root = _.find(t.nodes(), (v) => !g.node(v).parent);
+  var vs = preorder(t, root);
+  vs = vs.slice(1);
+  _.forEach(vs, (v) => {
+    var parent = t.node(v).parent, edge = g.edge(v, parent), flipped = false;
+    if (!edge) {
+      edge = g.edge(parent, v);
+      flipped = true;
     }
+    g.node(v).rank = g.node(parent).rank + (flipped ? edge.minlen : -edge.minlen);
   });
 }
-function positionX(g) {
-  var layering = buildLayerMatrix(g);
-  var conflicts = _.merge(findType1Conflicts(g, layering), findType2Conflicts(g, layering));
-  var xss = {};
-  var adjustedLayering;
-  _.forEach(["u", "d"], function(vert) {
-    adjustedLayering = vert === "u" ? layering : _.values(layering).reverse();
-    _.forEach(["l", "r"], function(horiz) {
-      if (horiz === "r") {
-        adjustedLayering = _.map(adjustedLayering, function(inner) {
-          return _.values(inner).reverse();
-        });
-      }
-      var neighborFn = (vert === "u" ? g.predecessors : g.successors).bind(g);
-      var align = verticalAlignment(g, adjustedLayering, conflicts, neighborFn);
-      var xs = horizontalCompaction(g, adjustedLayering, align.root, align.align, horiz === "r");
-      if (horiz === "r") {
-        xs = _.mapValues(xs, function(x) {
-          return -x;
-        });
-      }
-      xss[vert + horiz] = xs;
-    });
-  });
-  var 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;
-    sum += vLabel.width / 2;
-    if (_.has(vLabel, "labelpos")) {
-      switch (vLabel.labelpos.toLowerCase()) {
-        case "l":
-          delta = -vLabel.width / 2;
-          break;
-        case "r":
-          delta = vLabel.width / 2;
-          break;
-      }
-    }
-    if (delta) {
-      sum += reverseSep ? delta : -delta;
-    }
-    delta = 0;
-    sum += (vLabel.dummy ? edgeSep : nodeSep) / 2;
-    sum += (wLabel.dummy ? edgeSep : nodeSep) / 2;
-    sum += wLabel.width / 2;
-    if (_.has(wLabel, "labelpos")) {
-      switch (wLabel.labelpos.toLowerCase()) {
-        case "l":
-          delta = wLabel.width / 2;
-          break;
-        case "r":
-          delta = -wLabel.width / 2;
-          break;
-      }
-    }
-    if (delta) {
-      sum += reverseSep ? delta : -delta;
-    }
-    delta = 0;
-    return sum;
-  };
+function isTreeEdge(tree, u, v) {
+  return tree.hasEdge(u, v);
 }
-function width(g, v) {
-  return g.node(v).width;
+function isDescendant(_tree, vLabel, rootLabel) {
+  return rootLabel.low <= vLabel.lim && vLabel.lim <= rootLabel.lim;
 }
 
-// src/dagre/position/index.js
-function position(g) {
-  g = asNonCompoundGraph(g);
-  positionY(g);
-  _.forOwn(positionX(g), function(x, v) {
-    g.node(v).x = x;
-  });
+// src/dagre/rank/index.js
+function rank(g) {
+  switch (g.graph().ranker) {
+    case "network-simplex":
+      networkSimplexRanker(g);
+      break;
+    case "tight-tree":
+      tightTreeRanker(g);
+      break;
+    case "longest-path":
+      longestPathRanker(g);
+      break;
+    default:
+      networkSimplexRanker(g);
+  }
 }
-function positionY(g) {
-  var layering = buildLayerMatrix(g);
-  var rankSep = g.graph().ranksep;
-  var prevY = 0;
-  _.forEach(layering, function(layer) {
-    var maxHeight = _.max(
-      _.map(layer, function(v) {
-        return g.node(v).height;
-      })
-    );
-    _.forEach(layer, function(v) {
-      g.node(v).y = prevY + maxHeight / 2;
-    });
-    prevY += maxHeight + rankSep;
-  });
+var longestPathRanker = longestPath;
+function tightTreeRanker(g) {
+  longestPath(g);
+  feasibleTree(g);
+}
+function networkSimplexRanker(g) {
+  networkSimplex(g);
 }
 
 // src/dagre/layout.js
 function layout(g, opts) {
-  var time2 = opts && opts.debugTiming ? time : notime;
-  time2("layout", function() {
-    var layoutGraph = time2("  buildLayoutGraph", function() {
-      return buildLayoutGraph(g);
-    });
-    time2("  runLayout", function() {
+  var time2 = opts?.debugTiming ? time : notime;
+  time2("layout", () => {
+    var layoutGraph = time2("  buildLayoutGraph", () => buildLayoutGraph(g));
+    time2("  runLayout", () => {
       runLayout(layoutGraph, time2);
     });
-    time2("  updateInputGraph", function() {
+    time2("  updateInputGraph", () => {
       updateInputGraph(g, layoutGraph);
     });
   });
 }
 function runLayout(g, time2) {
-  time2("    makeSpaceForEdgeLabels", function() {
+  time2("    makeSpaceForEdgeLabels", () => {
     makeSpaceForEdgeLabels(g);
   });
-  time2("    removeSelfEdges", function() {
+  time2("    removeSelfEdges", () => {
     removeSelfEdges(g);
   });
-  time2("    acyclic", function() {
+  time2("    acyclic", () => {
     run(g);
   });
-  time2("    nestingGraph.run", function() {
-    run3(g);
+  time2("    nestingGraph.run", () => {
+    run2(g);
   });
-  time2("    rank", function() {
+  time2("    rank", () => {
     rank(asNonCompoundGraph(g));
   });
-  time2("    injectEdgeLabelProxies", function() {
+  time2("    injectEdgeLabelProxies", () => {
     injectEdgeLabelProxies(g);
   });
-  time2("    removeEmptyRanks", function() {
+  time2("    removeEmptyRanks", () => {
     removeEmptyRanks(g);
   });
-  time2("    nestingGraph.cleanup", function() {
+  time2("    nestingGraph.cleanup", () => {
     cleanup(g);
   });
-  time2("    normalizeRanks", function() {
+  time2("    normalizeRanks", () => {
     normalizeRanks(g);
   });
-  time2("    assignRankMinMax", function() {
+  time2("    assignRankMinMax", () => {
     assignRankMinMax(g);
   });
-  time2("    removeEdgeLabelProxies", function() {
+  time2("    removeEdgeLabelProxies", () => {
     removeEdgeLabelProxies(g);
   });
-  time2("    normalize.run", function() {
-    run2(g);
+  time2("    normalize.run", () => {
+    run3(g);
   });
-  time2("    parentDummyChains", function() {
+  time2("    parentDummyChains", () => {
     parentDummyChains(g);
   });
-  time2("    addBorderSegments", function() {
+  time2("    addBorderSegments", () => {
     addBorderSegments(g);
   });
-  time2("    order", function() {
+  time2("    order", () => {
     order(g);
   });
-  time2("    insertSelfEdges", function() {
+  time2("    insertSelfEdges", () => {
     insertSelfEdges(g);
   });
-  time2("    adjustCoordinateSystem", function() {
+  time2("    adjustCoordinateSystem", () => {
     adjust(g);
   });
-  time2("    position", function() {
+  time2("    position", () => {
     position(g);
   });
-  time2("    positionSelfEdges", function() {
+  time2("    positionSelfEdges", () => {
     positionSelfEdges(g);
   });
-  time2("    removeBorderNodes", function() {
+  time2("    removeBorderNodes", () => {
     removeBorderNodes(g);
   });
-  time2("    normalize.undo", function() {
+  time2("    normalize.undo", () => {
     undo3(g);
   });
-  time2("    fixupEdgeLabelCoords", function() {
+  time2("    fixupEdgeLabelCoords", () => {
     fixupEdgeLabelCoords(g);
   });
-  time2("    undoCoordinateSystem", function() {
-    undo(g);
+  time2("    undoCoordinateSystem", () => {
+    undo2(g);
   });
-  time2("    translateGraph", function() {
+  time2("    translateGraph", () => {
     translateGraph(g);
   });
-  time2("    assignNodeIntersects", function() {
+  time2("    assignNodeIntersects", () => {
     assignNodeIntersects(g);
   });
-  time2("    reversePoints", function() {
+  time2("    reversePoints", () => {
     reversePointsForReversedEdges(g);
   });
-  time2("    acyclic.undo", function() {
-    undo2(g);
+  time2("    acyclic.undo", () => {
+    undo(g);
   });
 }
 function updateInputGraph(inputGraph, layoutGraph) {
-  _.forEach(inputGraph.nodes(), function(v) {
+  _.forEach(inputGraph.nodes(), (v) => {
     var inputLabel = inputGraph.node(v);
     var layoutLabel = layoutGraph.node(v);
     if (inputLabel) {
@@ -2182,7 +2121,7 @@ function updateInputGraph(inputGraph, layoutGraph) {
       }
     }
   });
-  _.forEach(inputGraph.edges(), function(e) {
+  _.forEach(inputGraph.edges(), (e) => {
     var inputLabel = inputGraph.edge(e);
     var layoutLabel = layoutGraph.edge(e);
     inputLabel.points = layoutLabel.points;
@@ -2213,18 +2152,31 @@ function buildLayoutGraph(inputGraph) {
   var g = new Graph({ multigraph: true, compound: true });
   var graph = canonicalize(inputGraph.graph());
   g.setGraph(
-    _.merge({}, graphDefaults, selectNumberAttrs(graph, graphNumAttrs), _.pick(graph, graphAttrs))
+    _.merge(
+      {},
+      graphDefaults,
+      selectNumberAttrs(graph, graphNumAttrs),
+      _.pick(graph, graphAttrs)
+    )
   );
-  _.forEach(inputGraph.nodes(), function(v) {
+  _.forEach(inputGraph.nodes(), (v) => {
     var node = canonicalize(inputGraph.node(v));
-    g.setNode(v, _.defaults(selectNumberAttrs(node, nodeNumAttrs), nodeDefaults));
+    g.setNode(
+      v,
+      _.defaults(selectNumberAttrs(node, nodeNumAttrs), nodeDefaults)
+    );
     g.setParent(v, inputGraph.parent(v));
   });
-  _.forEach(inputGraph.edges(), function(e) {
+  _.forEach(inputGraph.edges(), (e) => {
     var edge = canonicalize(inputGraph.edge(e));
     g.setEdge(
       e,
-      _.merge({}, edgeDefaults, selectNumberAttrs(edge, edgeNumAttrs), _.pick(edge, edgeAttrs))
+      _.merge(
+        {},
+        edgeDefaults,
+        selectNumberAttrs(edge, edgeNumAttrs),
+        _.pick(edge, edgeAttrs)
+      )
     );
   });
   return g;
@@ -2232,7 +2184,7 @@ function buildLayoutGraph(inputGraph) {
 function makeSpaceForEdgeLabels(g) {
   var graph = g.graph();
   graph.ranksep /= 2;
-  _.forEach(g.edges(), function(e) {
+  _.forEach(g.edges(), (e) => {
     var edge = g.edge(e);
     edge.minlen *= 2;
     if (edge.labelpos.toLowerCase() !== "c") {
@@ -2245,7 +2197,7 @@ function makeSpaceForEdgeLabels(g) {
   });
 }
 function injectEdgeLabelProxies(g) {
-  _.forEach(g.edges(), function(e) {
+  _.forEach(g.edges(), (e) => {
     var edge = g.edge(e);
     if (edge.width && edge.height) {
       var v = g.node(e.v);
@@ -2257,7 +2209,7 @@ function injectEdgeLabelProxies(g) {
 }
 function assignRankMinMax(g) {
   var maxRank2 = 0;
-  _.forEach(g.nodes(), function(v) {
+  _.forEach(g.nodes(), (v) => {
     var node = g.node(v);
     if (node.borderTop) {
       node.minRank = g.node(node.borderTop).rank;
@@ -2268,7 +2220,7 @@ function assignRankMinMax(g) {
   g.graph().maxRank = maxRank2;
 }
 function removeEdgeLabelProxies(g) {
-  _.forEach(g.nodes(), function(v) {
+  _.forEach(g.nodes(), (v) => {
     var node = g.node(v);
     if (node.dummy === "edge-proxy") {
       g.edge(node.e).labelRank = node.rank;
@@ -2294,10 +2246,10 @@ function translateGraph(g) {
     minY = Math.min(minY, y - h / 2);
     maxY = Math.max(maxY, y + h / 2);
   }
-  _.forEach(g.nodes(), function(v) {
+  _.forEach(g.nodes(), (v) => {
     getExtremes(g.node(v));
   });
-  _.forEach(g.edges(), function(e) {
+  _.forEach(g.edges(), (e) => {
     var edge = g.edge(e);
     if (_.has(edge, "x")) {
       getExtremes(edge);
@@ -2305,14 +2257,14 @@ function translateGraph(g) {
   });
   minX -= marginX;
   minY -= marginY;
-  _.forEach(g.nodes(), function(v) {
+  _.forEach(g.nodes(), (v) => {
     var node = g.node(v);
     node.x -= minX;
     node.y -= minY;
   });
-  _.forEach(g.edges(), function(e) {
+  _.forEach(g.edges(), (e) => {
     var edge = g.edge(e);
-    _.forEach(edge.points, function(p) {
+    _.forEach(edge.points, (p) => {
       p.x -= minX;
       p.y -= minY;
     });
@@ -2327,7 +2279,7 @@ function translateGraph(g) {
   graphLabel.height = maxY - minY + marginY;
 }
 function assignNodeIntersects(g) {
-  _.forEach(g.edges(), function(e) {
+  _.forEach(g.edges(), (e) => {
     var edge = g.edge(e);
     var nodeV = g.node(e.v);
     var nodeW = g.node(e.w);
@@ -2345,7 +2297,7 @@ function assignNodeIntersects(g) {
   });
 }
 function fixupEdgeLabelCoords(g) {
-  _.forEach(g.edges(), function(e) {
+  _.forEach(g.edges(), (e) => {
     var edge = g.edge(e);
     if (_.has(edge, "x")) {
       if (edge.labelpos === "l" || edge.labelpos === "r") {
@@ -2363,7 +2315,7 @@ function fixupEdgeLabelCoords(g) {
   });
 }
 function reversePointsForReversedEdges(g) {
-  _.forEach(g.edges(), function(e) {
+  _.forEach(g.edges(), (e) => {
     var edge = g.edge(e);
     if (edge.reversed) {
       edge.points.reverse();
@@ -2371,7 +2323,7 @@ function reversePointsForReversedEdges(g) {
   });
 }
 function removeBorderNodes(g) {
-  _.forEach(g.nodes(), function(v) {
+  _.forEach(g.nodes(), (v) => {
     if (g.children(v).length) {
       var node = g.node(v);
       var t = g.node(node.borderTop);
@@ -2384,14 +2336,14 @@ function removeBorderNodes(g) {
       node.y = t.y + node.height / 2;
     }
   });
-  _.forEach(g.nodes(), function(v) {
+  _.forEach(g.nodes(), (v) => {
     if (g.node(v).dummy === "border") {
       g.removeNode(v);
     }
   });
 }
 function removeSelfEdges(g) {
-  _.forEach(g.edges(), function(e) {
+  _.forEach(g.edges(), (e) => {
     if (e.v === e.w) {
       var node = g.node(e.v);
       if (!node.selfEdges) {
@@ -2404,12 +2356,12 @@ function removeSelfEdges(g) {
 }
 function insertSelfEdges(g) {
   var layers = buildLayerMatrix(g);
-  _.forEach(layers, function(layer) {
+  _.forEach(layers, (layer) => {
     var orderShift = 0;
-    _.forEach(layer, function(v, i) {
+    _.forEach(layer, (v, i) => {
       var node = g.node(v);
       node.order = i + orderShift;
-      _.forEach(node.selfEdges, function(selfEdge) {
+      _.forEach(node.selfEdges, (selfEdge) => {
         addDummyNode(
           g,
           "selfedge",
@@ -2429,7 +2381,7 @@ function insertSelfEdges(g) {
   });
 }
 function positionSelfEdges(g) {
-  _.forEach(g.nodes(), function(v) {
+  _.forEach(g.nodes(), (v) => {
     var node = g.node(v);
     if (node.dummy === "selfedge") {
       var selfNode = g.node(node.e.v);
@@ -2456,7 +2408,7 @@ function selectNumberAttrs(obj, attrs) {
 }
 function canonicalize(attrs) {
   var newAttrs = {};
-  _.forEach(attrs, function(v, k) {
+  _.forEach(attrs, (v, k) => {
     newAttrs[k.toLowerCase()] = v;
   });
   return newAttrs;
@@ -2475,7 +2427,7 @@ function buildFlatCharts({
   vertical = false,
   direction
 }) {
-  let prevLodash = getLodash();
+  const prevLodash = getLodash();
   try {
     setLodash(lodash);
     const rankdir = direction || (vertical ? "tb" : "lr");
@@ -2697,7 +2649,7 @@ function getGraphParamsProvider({
   transitionsFontSize = fontSize,
   transitionsTextPadding = 0,
   getStateLabel = (state) => state,
-  getTransitionLabel = (fromState, event, toState) => event
+  getTransitionLabel = (_fromState, event, _toState) => event
 } = {}) {
   return {
     getStateParams: (stateKey, state = stateKey) => {