@dagrejs/dagre 1.1.0 → 1.1.1

package/lib/layout.js

@@ -1,61 +1,59 @@
 "use strict";
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = layout;
-var acyclic = _interopRequireWildcard(require("./acyclic.js"));
-var normalize = _interopRequireWildcard(require("./normalize.js"));
-var _index = _interopRequireDefault(require("./rank/index.js"));
-var _parentDummyChains = _interopRequireDefault(require("./parent-dummy-chains.js"));
-var nestingGraph = _interopRequireWildcard(require("./nesting-graph.js"));
-var _addBorderSegments = _interopRequireDefault(require("./add-border-segments.js"));
-var coordinateSystem = _interopRequireWildcard(require("./coordinate-system.js"));
-var _index2 = _interopRequireDefault(require("./order/index.js"));
-var _index3 = _interopRequireDefault(require("./position/index.js"));
-var util = _interopRequireWildcard(require("./util.js"));
-var _graphlib = require("@dagrejs/graphlib");
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
-function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
-const removeEmptyRanks = util.removeEmptyRanks;
-const normalizeRanks = util.normalizeRanks;
+let acyclic = require("./acyclic");
+let normalize = require("./normalize");
+let rank = require("./rank");
+let normalizeRanks = require("./util").normalizeRanks;
+let parentDummyChains = require("./parent-dummy-chains");
+let removeEmptyRanks = require("./util").removeEmptyRanks;
+let nestingGraph = require("./nesting-graph");
+let addBorderSegments = require("./add-border-segments");
+let coordinateSystem = require("./coordinate-system");
+let order = require("./order");
+let position = require("./position");
+let util = require("./util");
+let Graph = require("@dagrejs/graphlib").Graph;
+
+module.exports = layout;
+
 function layout(g, opts) {
   let time = opts && opts.debugTiming ? util.time : util.notime;
   time("layout", () => {
-    let layoutGraph = time("  buildLayoutGraph", () => buildLayoutGraph(g));
-    time("  runLayout", () => runLayout(layoutGraph, time));
+    let layoutGraph =
+      time("  buildLayoutGraph", () => buildLayoutGraph(g));
+    time("  runLayout",        () => runLayout(layoutGraph, time));
     time("  updateInputGraph", () => updateInputGraph(g, layoutGraph));
   });
 }
+
 function runLayout(g, time) {
   time("    makeSpaceForEdgeLabels", () => makeSpaceForEdgeLabels(g));
-  time("    removeSelfEdges", () => removeSelfEdges(g));
-  time("    acyclic", () => acyclic.run(g));
-  time("    nestingGraph.run", () => nestingGraph.run(g));
-  time("    rank", () => (0, _index.default)(util.asNonCompoundGraph(g)));
+  time("    removeSelfEdges",        () => removeSelfEdges(g));
+  time("    acyclic",                () => acyclic.run(g));
+  time("    nestingGraph.run",       () => nestingGraph.run(g));
+  time("    rank",                   () => rank(util.asNonCompoundGraph(g)));
   time("    injectEdgeLabelProxies", () => injectEdgeLabelProxies(g));
-  time("    removeEmptyRanks", () => removeEmptyRanks(g));
-  time("    nestingGraph.cleanup", () => nestingGraph.cleanup(g));
-  time("    normalizeRanks", () => normalizeRanks(g));
-  time("    assignRankMinMax", () => assignRankMinMax(g));
+  time("    removeEmptyRanks",       () => removeEmptyRanks(g));
+  time("    nestingGraph.cleanup",   () => nestingGraph.cleanup(g));
+  time("    normalizeRanks",         () => normalizeRanks(g));
+  time("    assignRankMinMax",       () => assignRankMinMax(g));
   time("    removeEdgeLabelProxies", () => removeEdgeLabelProxies(g));
-  time("    normalize.run", () => normalize.run(g));
-  time("    parentDummyChains", () => (0, _parentDummyChains.default)(g));
-  time("    addBorderSegments", () => (0, _addBorderSegments.default)(g));
-  time("    order", () => (0, _index2.default)(g));
-  time("    insertSelfEdges", () => insertSelfEdges(g));
+  time("    normalize.run",          () => normalize.run(g));
+  time("    parentDummyChains",      () => parentDummyChains(g));
+  time("    addBorderSegments",      () => addBorderSegments(g));
+  time("    order",                  () => order(g));
+  time("    insertSelfEdges",        () => insertSelfEdges(g));
   time("    adjustCoordinateSystem", () => coordinateSystem.adjust(g));
-  time("    position", () => (0, _index3.default)(g));
-  time("    positionSelfEdges", () => positionSelfEdges(g));
-  time("    removeBorderNodes", () => removeBorderNodes(g));
-  time("    normalize.undo", () => normalize.undo(g));
-  time("    fixupEdgeLabelCoords", () => fixupEdgeLabelCoords(g));
-  time("    undoCoordinateSystem", () => coordinateSystem.undo(g));
-  time("    translateGraph", () => translateGraph(g));
-  time("    assignNodeIntersects", () => assignNodeIntersects(g));
-  time("    reversePoints", () => reversePointsForReversedEdges(g));
-  time("    acyclic.undo", () => acyclic.undo(g));
+  time("    position",               () => position(g));
+  time("    positionSelfEdges",      () => positionSelfEdges(g));
+  time("    removeBorderNodes",      () => removeBorderNodes(g));
+  time("    normalize.undo",         () => normalize.undo(g));
+  time("    fixupEdgeLabelCoords",   () => fixupEdgeLabelCoords(g));
+  time("    undoCoordinateSystem",   () => coordinateSystem.undo(g));
+  time("    translateGraph",         () => translateGraph(g));
+  time("    assignNodeIntersects",   () => assignNodeIntersects(g));
+  time("    reversePoints",          () => reversePointsForReversedEdges(g));
+  time("    acyclic.undo",           () => acyclic.undo(g));
 }
 
 /*
@@ -68,49 +66,43 @@ function updateInputGraph(inputGraph, layoutGraph) {
   inputGraph.nodes().forEach(v => {
     let inputLabel = inputGraph.node(v);
     let layoutLabel = layoutGraph.node(v);
+
     if (inputLabel) {
       inputLabel.x = layoutLabel.x;
       inputLabel.y = layoutLabel.y;
       inputLabel.rank = layoutLabel.rank;
+
       if (layoutGraph.children(v).length) {
         inputLabel.width = layoutLabel.width;
         inputLabel.height = layoutLabel.height;
       }
     }
   });
+
   inputGraph.edges().forEach(e => {
     let inputLabel = inputGraph.edge(e);
     let layoutLabel = layoutGraph.edge(e);
+
     inputLabel.points = layoutLabel.points;
     if (layoutLabel.hasOwnProperty("x")) {
       inputLabel.x = layoutLabel.x;
       inputLabel.y = layoutLabel.y;
     }
   });
+
   inputGraph.graph().width = layoutGraph.graph().width;
   inputGraph.graph().height = layoutGraph.graph().height;
 }
+
 let graphNumAttrs = ["nodesep", "edgesep", "ranksep", "marginx", "marginy"];
-let graphDefaults = {
-  ranksep: 50,
-  edgesep: 20,
-  nodesep: 50,
-  rankdir: "tb"
-};
+let graphDefaults = { ranksep: 50, edgesep: 20, nodesep: 50, rankdir: "tb" };
 let graphAttrs = ["acyclicer", "ranker", "rankdir", "align"];
 let nodeNumAttrs = ["width", "height"];
-let nodeDefaults = {
-  width: 0,
-  height: 0
-};
+let nodeDefaults = { width: 0, height: 0 };
 let edgeNumAttrs = ["minlen", "weight", "width", "height", "labeloffset"];
 let edgeDefaults = {
-  minlen: 1,
-  weight: 1,
-  width: 0,
-  height: 0,
-  labeloffset: 10,
-  labelpos: "r"
+  minlen: 1, weight: 1, width: 0, height: 0,
+  labeloffset: 10, labelpos: "r"
 };
 let edgeAttrs = ["labelpos"];
 
@@ -121,12 +113,14 @@ let edgeAttrs = ["labelpos"];
  * attributes can influence layout.
  */
 function buildLayoutGraph(inputGraph) {
-  let g = new _graphlib.Graph({
-    multigraph: true,
-    compound: true
-  });
+  let g = new Graph({ multigraph: true, compound: true });
   let graph = canonicalize(inputGraph.graph());
-  g.setGraph(Object.assign({}, graphDefaults, selectNumberAttrs(graph, graphNumAttrs), util.pick(graph, graphAttrs)));
+
+  g.setGraph(Object.assign({},
+    graphDefaults,
+    selectNumberAttrs(graph, graphNumAttrs),
+    util.pick(graph, graphAttrs)));
+
   inputGraph.nodes().forEach(v => {
     let node = canonicalize(inputGraph.node(v));
     const newNode = selectNumberAttrs(node, nodeNumAttrs);
@@ -135,13 +129,19 @@ function buildLayoutGraph(inputGraph) {
         newNode[k] = nodeDefaults[k];
       }
     });
+
     g.setNode(v, newNode);
     g.setParent(v, inputGraph.parent(v));
   });
+
   inputGraph.edges().forEach(e => {
     let edge = canonicalize(inputGraph.edge(e));
-    g.setEdge(e, Object.assign({}, edgeDefaults, selectNumberAttrs(edge, edgeNumAttrs), util.pick(edge, edgeAttrs)));
+    g.setEdge(e, Object.assign({},
+      edgeDefaults,
+      selectNumberAttrs(edge, edgeNumAttrs),
+      util.pick(edge, edgeAttrs)));
   });
+
   return g;
 }
 
@@ -181,14 +181,12 @@ function injectEdgeLabelProxies(g) {
     if (edge.width && edge.height) {
       let v = g.node(e.v);
       let w = g.node(e.w);
-      let label = {
-        rank: (w.rank - v.rank) / 2 + v.rank,
-        e: e
-      };
+      let label = { rank: (w.rank - v.rank) / 2 + v.rank, e: e };
       util.addDummyNode(g, "edge-proxy", label, "_ep");
     }
   });
 }
+
 function assignRankMinMax(g) {
   let maxRank = 0;
   g.nodes().forEach(v => {
@@ -201,6 +199,7 @@ function assignRankMinMax(g) {
   });
   g.graph().maxRank = maxRank;
 }
+
 function removeEdgeLabelProxies(g) {
   g.nodes().forEach(v => {
     let node = g.node(v);
@@ -210,6 +209,7 @@ function removeEdgeLabelProxies(g) {
     }
   });
 }
+
 function translateGraph(g) {
   let minX = Number.POSITIVE_INFINITY;
   let maxX = 0;
@@ -218,6 +218,7 @@ function translateGraph(g) {
   let graphLabel = g.graph();
   let marginX = graphLabel.marginx || 0;
   let marginY = graphLabel.marginy || 0;
+
   function getExtremes(attrs) {
     let x = attrs.x;
     let y = attrs.y;
@@ -228,6 +229,7 @@ function translateGraph(g) {
     minY = Math.min(minY, y - h / 2);
     maxY = Math.max(maxY, y + h / 2);
   }
+
   g.nodes().forEach(v => getExtremes(g.node(v)));
   g.edges().forEach(e => {
     let edge = g.edge(e);
@@ -235,29 +237,30 @@ function translateGraph(g) {
       getExtremes(edge);
     }
   });
+
   minX -= marginX;
   minY -= marginY;
+
   g.nodes().forEach(v => {
     let node = g.node(v);
     node.x -= minX;
     node.y -= minY;
   });
+
   g.edges().forEach(e => {
     let edge = g.edge(e);
     edge.points.forEach(p => {
       p.x -= minX;
       p.y -= minY;
     });
-    if (edge.hasOwnProperty("x")) {
-      edge.x -= minX;
-    }
-    if (edge.hasOwnProperty("y")) {
-      edge.y -= minY;
-    }
+    if (edge.hasOwnProperty("x")) { edge.x -= minX; }
+    if (edge.hasOwnProperty("y")) { edge.y -= minY; }
   });
+
   graphLabel.width = maxX - minX + marginX;
   graphLabel.height = maxY - minY + marginY;
 }
+
 function assignNodeIntersects(g) {
   g.edges().forEach(e => {
     let edge = g.edge(e);
@@ -276,6 +279,7 @@ function assignNodeIntersects(g) {
     edge.points.push(util.intersectRect(nodeW, p2));
   });
 }
+
 function fixupEdgeLabelCoords(g) {
   g.edges().forEach(e => {
     let edge = g.edge(e);
@@ -284,16 +288,13 @@ function fixupEdgeLabelCoords(g) {
         edge.width -= edge.labeloffset;
       }
       switch (edge.labelpos) {
-        case "l":
-          edge.x -= edge.width / 2 + edge.labeloffset;
-          break;
-        case "r":
-          edge.x += edge.width / 2 + edge.labeloffset;
-          break;
+      case "l": edge.x -= edge.width / 2 + edge.labeloffset; break;
+      case "r": edge.x += edge.width / 2 + edge.labeloffset; break;
       }
     }
   });
 }
+
 function reversePointsForReversedEdges(g) {
   g.edges().forEach(e => {
     let edge = g.edge(e);
@@ -302,6 +303,7 @@ function reversePointsForReversedEdges(g) {
     }
   });
 }
+
 function removeBorderNodes(g) {
   g.nodes().forEach(v => {
     if (g.children(v).length) {
@@ -310,18 +312,21 @@ function removeBorderNodes(g) {
       let b = g.node(node.borderBottom);
       let l = g.node(node.borderLeft[node.borderLeft.length - 1]);
       let r = g.node(node.borderRight[node.borderRight.length - 1]);
+
       node.width = Math.abs(r.x - l.x);
       node.height = Math.abs(b.y - t.y);
       node.x = l.x + node.width / 2;
       node.y = t.y + node.height / 2;
     }
   });
+
   g.nodes().forEach(v => {
     if (g.node(v).dummy === "border") {
       g.removeNode(v);
     }
   });
 }
+
 function removeSelfEdges(g) {
   g.edges().forEach(e => {
     if (e.v === e.w) {
@@ -329,14 +334,12 @@ function removeSelfEdges(g) {
       if (!node.selfEdges) {
         node.selfEdges = [];
       }
-      node.selfEdges.push({
-        e: e,
-        label: g.edge(e)
-      });
+      node.selfEdges.push({ e: e, label: g.edge(e) });
       g.removeEdge(e);
     }
   });
 }
+
 function insertSelfEdges(g) {
   var layers = util.buildLayerMatrix(g);
   layers.forEach(layer => {
@@ -349,7 +352,7 @@ function insertSelfEdges(g) {
           width: selfEdge.label.width,
           height: selfEdge.label.height,
           rank: node.rank,
-          order: i + ++orderShift,
+          order: i + (++orderShift),
           e: selfEdge.e,
           label: selfEdge.label
         }, "_se");
@@ -358,6 +361,7 @@ function insertSelfEdges(g) {
     });
   });
 }
+
 function positionSelfEdges(g) {
   g.nodes().forEach(v => {
     var node = g.node(v);
@@ -369,30 +373,23 @@ function positionSelfEdges(g) {
       var dy = selfNode.height / 2;
       g.setEdge(node.e, node.label);
       g.removeNode(v);
-      node.label.points = [{
-        x: x + 2 * dx / 3,
-        y: y - dy
-      }, {
-        x: x + 5 * dx / 6,
-        y: y - dy
-      }, {
-        x: x + dx,
-        y: y
-      }, {
-        x: x + 5 * dx / 6,
-        y: y + dy
-      }, {
-        x: x + 2 * dx / 3,
-        y: y + dy
-      }];
+      node.label.points = [
+        { x: x + 2 * dx / 3, y: y - dy },
+        { x: x + 5 * dx / 6, y: y - dy },
+        { x: x +     dx    , y: y },
+        { x: x + 5 * dx / 6, y: y + dy },
+        { x: x + 2 * dx / 3, y: y + dy }
+      ];
       node.label.x = node.x;
       node.label.y = node.y;
     }
   });
 }
+
 function selectNumberAttrs(obj, attrs) {
   return util.mapValues(util.pick(obj, attrs), Number);
 }
+
 function canonicalize(attrs) {
   var newAttrs = {};
   if (attrs) {
@@ -400,9 +397,9 @@ function canonicalize(attrs) {
       if (typeof k === "string") {
         k = k.toLowerCase();
       }
+
       newAttrs[k] = v;
     });
   }
   return newAttrs;
 }
-module.exports = exports.default;

package/lib/nesting-graph.js

@@ -1,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;
+