@dagrejs/dagre 1.1.0 → 1.1.2

package/lib/nesting-graph.js

@@ -1,13 +1,10 @@
-"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; }
+let util = require("./util");
+
+module.exports = {
+  run,
+  cleanup,
+};
+
 /*
  * A nesting graph creates dummy nodes for the tops and bottoms of subgraphs,
  * adds appropriate edges to ensure that all cluster nodes are placed between
@@ -36,6 +33,7 @@ function run(g) {
   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.
@@ -51,49 +49,52 @@ function run(g) {
   // layers.
   g.graph().nodeRankFactor = nodeSep;
 }
+
 function dfs(g, root, nodeSep, weight, height, depths, 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;
   }
+
   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(child => {
     dfs(g, root, nodeSep, weight, height, depths, child);
+
     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) {
@@ -106,9 +107,11 @@ 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);

package/lib/normalize.js

@@ -1,13 +1,12 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.run = run;
-exports.undo = undo;
-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; }
+let util = require("./util");
+
+module.exports = {
+  run: run,
+  undo: undo
+};
+
 /*
  * Breaks any long edges in the graph into short segments that span 1 layer
  * each. This operation is undoable with the denormalize function.
@@ -28,6 +27,7 @@ function run(g) {
   g.graph().dummyChains = [];
   g.edges().forEach(edge => normalizeEdge(g, edge));
 }
+
 function normalizeEdge(g, e) {
   let v = e.v;
   let vRank = g.node(v).rank;
@@ -36,16 +36,17 @@ function normalizeEdge(g, e) {
   let name = e.name;
   let edgeLabel = g.edge(e);
   let labelRank = edgeLabel.labelRank;
+
   if (wRank === vRank + 1) return;
+
   g.removeEdge(e);
+
   let dummy, attrs, i;
   for (i = 0, ++vRank; vRank < wRank; ++i, ++vRank) {
     edgeLabel.points = [];
     attrs = {
-      width: 0,
-      height: 0,
-      edgeLabel: edgeLabel,
-      edgeObj: e,
+      width: 0, height: 0,
+      edgeLabel: edgeLabel, edgeObj: e,
       rank: vRank
     };
     dummy = util.addDummyNode(g, "edge", attrs, "_d");
@@ -55,18 +56,16 @@ function normalizeEdge(g, e) {
       attrs.dummy = "edge-label";
       attrs.labelpos = edgeLabel.labelpos;
     }
-    g.setEdge(v, dummy, {
-      weight: edgeLabel.weight
-    }, name);
+    g.setEdge(v, dummy, { weight: edgeLabel.weight }, name);
     if (i === 0) {
       g.graph().dummyChains.push(dummy);
     }
     v = dummy;
   }
-  g.setEdge(v, w, {
-    weight: edgeLabel.weight
-  }, name);
+
+  g.setEdge(v, w, { weight: edgeLabel.weight }, name);
 }
+
 function undo(g) {
   g.graph().dummyChains.forEach(v => {
     let node = g.node(v);
@@ -76,10 +75,7 @@ function undo(g) {
     while (node.dummy) {
       w = g.successors(v)[0];
       g.removeNode(v);
-      origLabel.points.push({
-        x: node.x,
-        y: node.y
-      });
+      origLabel.points.push({ x: node.x, y: node.y });
       if (node.dummy === "edge-label") {
         origLabel.x = node.x;
         origLabel.y = node.y;

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

@@ -1,12 +1,9 @@
-"use strict";
+module.exports = addSubgraphConstraints;
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = addSubgraphConstraints;
 function addSubgraphConstraints(g, cg, vs) {
   let prev = {},
     rootPrev;
+
   vs.forEach(v => {
     let child = g.parent(v),
       parent,
@@ -52,4 +49,3 @@ function addSubgraphConstraints(g, cg, vs) {
   dfs(undefined);
   */
 }
-module.exports = exports.default;

package/lib/order/barycenter.js

@@ -1,28 +1,20 @@
-"use strict";
+module.exports = barycenter;
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = barycenter;
 function barycenter(g, movable = []) {
   return movable.map(v => {
     let inV = g.inEdges(v);
     if (!inV.length) {
-      return {
-        v: v
-      };
+      return { v: v };
     } else {
       let result = inV.reduce((acc, e) => {
         let edge = g.edge(e),
           nodeU = g.node(e.v);
         return {
-          sum: acc.sum + edge.weight * nodeU.order,
+          sum: acc.sum + (edge.weight * nodeU.order),
           weight: acc.weight + edge.weight
         };
-      }, {
-        sum: 0,
-        weight: 0
-      });
+      }, { sum: 0, weight: 0 });
+
       return {
         v: v,
         barycenter: result.sum / result.weight,
@@ -31,4 +23,4 @@ function barycenter(g, movable = []) {
     }
   });
 }
-module.exports = exports.default;
+

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

@@ -1,13 +1,8 @@
-"use strict";
+let Graph = require("@dagrejs/graphlib").Graph;
+let util = require("../util");
+
+module.exports = buildLayerGraph;
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = buildLayerGraph;
-var _graphlib = require("@dagrejs/graphlib");
-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; }
 /*
  * Constructs a graph that can be used to sort a layer of nodes. The graph will
  * contain all base and subgraph nodes from the request layer in their original
@@ -40,14 +35,13 @@ function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e;
  */
 function buildLayerGraph(g, rank, relationship) {
   let root = createRootNode(g),
-    result = new _graphlib.Graph({
-      compound: true
-    }).setGraph({
-      root: root
-    }).setDefaultNodeLabel(v => g.node(v));
+    result = new Graph({ compound: true }).setGraph({ root: root })
+      .setDefaultNodeLabel(v => g.node(v));
+
   g.nodes().forEach(v => {
     let node = g.node(v),
       parent = g.parent(v);
+
     if (node.rank === rank || node.minRank <= rank && rank <= node.maxRank) {
       result.setNode(v);
       result.setParent(v, parent || root);
@@ -57,10 +51,9 @@ function buildLayerGraph(g, rank, relationship) {
         let u = e.v === v ? e.w : e.v,
           edge = result.edge(u, v),
           weight = edge !== undefined ? edge.weight : 0;
-        result.setEdge(u, v, {
-          weight: g.edge(e).weight + weight
-        });
+        result.setEdge(u, v, { weight: g.edge(e).weight + weight });
       });
+
       if (node.hasOwnProperty("minRank")) {
         result.setNode(v, {
           borderLeft: node.borderLeft[rank],
@@ -69,11 +62,12 @@ function buildLayerGraph(g, rank, relationship) {
       }
     }
   });
+
   return result;
 }
+
 function createRootNode(g) {
   var v;
-  while (g.hasNode(v = util.uniqueId("_root")));
+  while (g.hasNode((v = util.uniqueId("_root"))));
   return v;
 }
-module.exports = exports.default;

package/lib/order/cross-count.js

@@ -1,10 +1,9 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = crossCount;
-var _util = require("../util.js");
+let zipObject = require("../util").zipObject;
+
+module.exports = crossCount;
+
 /*
  * A function that takes a layering (an array of layers, each with an array of
  * ordererd nodes) and a graph and returns a weighted crossing count.
@@ -24,21 +23,19 @@ var _util = require("../util.js");
 function crossCount(g, layering) {
   let cc = 0;
   for (let i = 1; i < layering.length; ++i) {
-    cc += twoLayerCrossCount(g, layering[i - 1], layering[i]);
+    cc += twoLayerCrossCount(g, layering[i-1], layering[i]);
   }
   return cc;
 }
+
 function twoLayerCrossCount(g, northLayer, southLayer) {
   // Sort all of the edges between the north and south layers by their position
   // in the north layer and then the south. Map these edges to the position of
   // their head in the south layer.
-  let southPos = (0, _util.zipObject)(southLayer, southLayer.map((v, i) => i));
+  let southPos = zipObject(southLayer, southLayer.map((v, i) => i));
   let southEntries = northLayer.flatMap(v => {
     return g.outEdges(v).map(e => {
-      return {
-        pos: southPos[e.w],
-        weight: g.edge(e).weight
-      };
+      return { pos: southPos[e.w], weight: g.edge(e).weight };
     }).sort((a, b) => a.pos - b.pos);
   });
 
@@ -59,11 +56,11 @@ function twoLayerCrossCount(g, northLayer, southLayer) {
       if (index % 2) {
         weightSum += tree[index + 1];
       }
-      index = index - 1 >> 1;
+      index = (index - 1) >> 1;
       tree[index] += entry.weight;
     }
     cc += entry.weight * weightSum;
   });
+
   return cc;
 }
-module.exports = exports.default;

package/lib/order/index.js

@@ -1,19 +1,15 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = order;
-var _initOrder = _interopRequireDefault(require("./init-order.js"));
-var _crossCount = _interopRequireDefault(require("./cross-count.js"));
-var _sortSubgraph = _interopRequireDefault(require("./sort-subgraph.js"));
-var _buildLayerGraph = _interopRequireDefault(require("./build-layer-graph.js"));
-var _addSubgraphConstraints = _interopRequireDefault(require("./add-subgraph-constraints.js"));
-var _graphlib = require("@dagrejs/graphlib");
-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; }
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+let initOrder = require("./init-order");
+let crossCount = require("./cross-count");
+let sortSubgraph = require("./sort-subgraph");
+let buildLayerGraph = require("./build-layer-graph");
+let addSubgraphConstraints = require("./add-subgraph-constraints");
+let Graph = require("@dagrejs/graphlib").Graph;
+let util = require("../util");
+
+module.exports = order;
+
 /*
  * Applies heuristics to minimize edge crossings in the graph and sets the best
  * order solution as an order attribute on each node.
@@ -39,7 +35,7 @@ function order(g, opts) {
     downLayerGraphs = buildLayerGraphs(g, util.range(1, maxRank + 1), "inEdges"),
     upLayerGraphs = buildLayerGraphs(g, util.range(maxRank - 1, -1, -1), "outEdges");
 
-  let layering = (0, _initOrder.default)(g);
+  let layering = initOrder(g);
   assignOrder(g, layering);
 
   if (opts && opts.disableOptimalOrderHeuristic) {
@@ -51,31 +47,35 @@ function order(g, opts) {
 
   for (let i = 0, lastBest = 0; lastBest < 4; ++i, ++lastBest) {
     sweepLayerGraphs(i % 2 ? downLayerGraphs : upLayerGraphs, i % 4 >= 2);
+
     layering = util.buildLayerMatrix(g);
-    let cc = (0, _crossCount.default)(g, layering);
+    let cc = crossCount(g, layering);
     if (cc < bestCC) {
       lastBest = 0;
       best = Object.assign({}, layering);
       bestCC = cc;
     }
   }
+
   assignOrder(g, best);
 }
+
 function buildLayerGraphs(g, ranks, relationship) {
-  return ranks.map(function (rank) {
-    return (0, _buildLayerGraph.default)(g, rank, relationship);
+  return ranks.map(function(rank) {
+    return buildLayerGraph(g, rank, relationship);
   });
 }
+
 function sweepLayerGraphs(layerGraphs, biasRight) {
-  let cg = new _graphlib.Graph();
-  layerGraphs.forEach(function (lg) {
+  let cg = new Graph();
+  layerGraphs.forEach(function(lg) {
     let root = lg.graph().root;
-    let sorted = (0, _sortSubgraph.default)(lg, root, cg, biasRight);
+    let sorted = sortSubgraph(lg, root, cg, biasRight);
     sorted.vs.forEach((v, i) => lg.node(v).order = i);
-    (0, _addSubgraphConstraints.default)(lg, cg, sorted.vs);
+    addSubgraphConstraints(lg, cg, sorted.vs);
   });
 }
+
 function assignOrder(g, layering) {
   Object.values(layering).forEach(layer => layer.forEach((v, i) => g.node(v).order = i));
 }
-module.exports = exports.default;

package/lib/order/init-order.js

@@ -1,12 +1,9 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = initOrder;
-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; }
+let util = require("../util");
+
+module.exports = initOrder;
+
 /*
  * Assigns an initial order value for each node by performing a DFS search
  * starting from nodes in the first rank. Nodes are assigned an order in their
@@ -23,6 +20,7 @@ function initOrder(g) {
   let simpleNodes = g.nodes().filter(v => !g.children(v).length);
   let maxRank = Math.max(...simpleNodes.map(v => g.node(v).rank));
   let layers = util.range(maxRank + 1).map(() => []);
+
   function dfs(v) {
     if (visited[v]) return;
     visited[v] = true;
@@ -30,8 +28,9 @@ function initOrder(g) {
     layers[node.rank].push(v);
     g.successors(v).forEach(dfs);
   }
+
   let orderedVs = simpleNodes.sort((a, b) => g.node(a).rank - g.node(b).rank);
   orderedVs.forEach(dfs);
+
   return layers;
 }
-module.exports = exports.default;

package/lib/order/resolve-conflicts.js

@@ -1,12 +1,9 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = resolveConflicts;
-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; }
+let util = require("../util");
+
+module.exports = resolveConflicts;
+
 /*
  * Given a list of entries of the form {v, barycenter, weight} and a
  * constraint graph this function will resolve any conflicts between the
@@ -47,6 +44,7 @@ function resolveConflicts(entries, cg) {
       tmp.weight = entry.weight;
     }
   });
+
   cg.edges().forEach(e => {
     let entryV = mappedEntries[e.v];
     let entryW = mappedEntries[e.w];
@@ -55,21 +53,28 @@ function resolveConflicts(entries, cg) {
       entryV.out.push(mappedEntries[e.w]);
     }
   });
+
   let sourceSet = Object.values(mappedEntries).filter(entry => !entry.indegree);
+
   return doResolveConflicts(sourceSet);
 }
+
 function doResolveConflicts(sourceSet) {
   let entries = [];
+
   function handleIn(vEntry) {
     return uEntry => {
       if (uEntry.merged) {
         return;
       }
-      if (uEntry.barycenter === undefined || vEntry.barycenter === undefined || uEntry.barycenter >= vEntry.barycenter) {
+      if (uEntry.barycenter === undefined ||
+          vEntry.barycenter === undefined ||
+          uEntry.barycenter >= vEntry.barycenter) {
         mergeEntries(vEntry, uEntry);
       }
     };
   }
+
   function handleOut(vEntry) {
     return wEntry => {
       wEntry["in"].push(vEntry);
@@ -78,31 +83,36 @@ function doResolveConflicts(sourceSet) {
       }
     };
   }
+
   while (sourceSet.length) {
     let entry = sourceSet.pop();
     entries.push(entry);
     entry["in"].reverse().forEach(handleIn(entry));
     entry.out.forEach(handleOut(entry));
   }
+
   return entries.filter(entry => !entry.merged).map(entry => {
     return util.pick(entry, ["vs", "i", "barycenter", "weight"]);
   });
 }
+
 function mergeEntries(target, source) {
   let sum = 0;
   let weight = 0;
+
   if (target.weight) {
     sum += target.barycenter * target.weight;
     weight += target.weight;
   }
+
   if (source.weight) {
     sum += source.barycenter * source.weight;
     weight += source.weight;
   }
+
   target.vs = source.vs.concat(target.vs);
   target.barycenter = sum / weight;
   target.weight = weight;
   target.i = Math.min(source.i, target.i);
   source.merged = true;
 }
-module.exports = exports.default;

package/lib/order/sort-subgraph.js

@@ -1,23 +1,21 @@
-"use strict";
+let barycenter = require("./barycenter");
+let resolveConflicts = require("./resolve-conflicts");
+let sort = require("./sort");
+
+module.exports = sortSubgraph;
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = sortSubgraph;
-var _barycenter = _interopRequireDefault(require("./barycenter.js"));
-var _resolveConflicts = _interopRequireDefault(require("./resolve-conflicts.js"));
-var _sort = _interopRequireDefault(require("./sort.js"));
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 function sortSubgraph(g, v, cg, biasRight) {
   let movable = g.children(v);
   let node = g.node(v);
   let bl = node ? node.borderLeft : undefined;
-  let br = node ? node.borderRight : undefined;
+  let br = node ? node.borderRight: undefined;
   let subgraphs = {};
+
   if (bl) {
     movable = movable.filter(w => w !== bl && w !== br);
   }
-  let barycenters = (0, _barycenter.default)(g, movable);
+
+  let barycenters = barycenter(g, movable);
   barycenters.forEach(entry => {
     if (g.children(entry.v).length) {
       let subgraphResult = sortSubgraph(g, entry.v, cg, biasRight);
@@ -27,9 +25,12 @@ function sortSubgraph(g, v, cg, biasRight) {
       }
     }
   });
-  let entries = (0, _resolveConflicts.default)(barycenters, cg);
+
+  let entries = resolveConflicts(barycenters, cg);
   expandSubgraphs(entries, subgraphs);
-  let result = (0, _sort.default)(entries, biasRight);
+
+  let result = sort(entries, biasRight);
+
   if (bl) {
     result.vs = [bl, result.vs, br].flat(true);
     if (g.predecessors(bl).length) {
@@ -39,12 +40,15 @@ function sortSubgraph(g, v, cg, biasRight) {
         result.barycenter = 0;
         result.weight = 0;
       }
-      result.barycenter = (result.barycenter * result.weight + blPred.order + brPred.order) / (result.weight + 2);
+      result.barycenter = (result.barycenter * result.weight +
+                           blPred.order + brPred.order) / (result.weight + 2);
       result.weight += 2;
     }
   }
+
   return result;
 }
+
 function expandSubgraphs(entries, subgraphs) {
   entries.forEach(entry => {
     entry.vs = entry.vs.flatMap(v => {
@@ -55,13 +59,15 @@ function expandSubgraphs(entries, subgraphs) {
     });
   });
 }
+
 function mergeBarycenters(target, other) {
   if (target.barycenter !== undefined) {
-    target.barycenter = (target.barycenter * target.weight + other.barycenter * other.weight) / (target.weight + other.weight);
+    target.barycenter = (target.barycenter * target.weight +
+                         other.barycenter * other.weight) /
+                        (target.weight + other.weight);
     target.weight += other.weight;
   } else {
     target.barycenter = other.barycenter;
     target.weight = other.weight;
   }
 }
-module.exports = exports.default;