@legionworks/facet 1.9.0

package/dist/gallery/frame/chunks/cose-bilkent-JH36ORCC-sn92qexx.js

@@ -0,0 +1,4822 @@
+import {
+  cytoscape as cytoscape2
+} from "./markdown-eg6ngz7y.js";
+import {
+  log,
+  select_default
+} from "./markdown-xw8dsk8b.js";
+import {
+  __name
+} from "./markdown-1s5vwkf2.js";
+import"./markdown-dy5sgjhc.js";
+import {
+  __commonJS,
+  __toESM
+} from "./markdown-809k7q41.js";
+
+// node_modules/layout-base/layout-base.js
+var require_layout_base = __commonJS(function(exports, module) {
+  (function webpackUniversalModuleDefinition(root, factory) {
+    if (typeof exports === "object" && typeof module === "object")
+      module.exports = factory();
+    else if (typeof define === "function" && define.amd)
+      define([], factory);
+    else if (typeof exports === "object")
+      exports["layoutBase"] = factory();
+    else
+      root["layoutBase"] = factory();
+  })(exports, function() {
+    return function(modules) {
+      var installedModules = {};
+      function __webpack_require__(moduleId) {
+        if (installedModules[moduleId]) {
+          return installedModules[moduleId].exports;
+        }
+        var module2 = installedModules[moduleId] = {
+          i: moduleId,
+          l: false,
+          exports: {}
+        };
+        modules[moduleId].call(module2.exports, module2, module2.exports, __webpack_require__);
+        module2.l = true;
+        return module2.exports;
+      }
+      __webpack_require__.m = modules;
+      __webpack_require__.c = installedModules;
+      __webpack_require__.i = function(value) {
+        return value;
+      };
+      __webpack_require__.d = function(exports2, name, getter) {
+        if (!__webpack_require__.o(exports2, name)) {
+          Object.defineProperty(exports2, name, {
+            configurable: false,
+            enumerable: true,
+            get: getter
+          });
+        }
+      };
+      __webpack_require__.n = function(module2) {
+        var getter = module2 && module2.__esModule ? function getDefault() {
+          return module2["default"];
+        } : function getModuleExports() {
+          return module2;
+        };
+        __webpack_require__.d(getter, "a", getter);
+        return getter;
+      };
+      __webpack_require__.o = function(object, property) {
+        return Object.prototype.hasOwnProperty.call(object, property);
+      };
+      __webpack_require__.p = "";
+      return __webpack_require__(__webpack_require__.s = 26);
+    }([
+      function(module2, exports2, __webpack_require__) {
+        function LayoutConstants() {}
+        LayoutConstants.QUALITY = 1;
+        LayoutConstants.DEFAULT_CREATE_BENDS_AS_NEEDED = false;
+        LayoutConstants.DEFAULT_INCREMENTAL = false;
+        LayoutConstants.DEFAULT_ANIMATION_ON_LAYOUT = true;
+        LayoutConstants.DEFAULT_ANIMATION_DURING_LAYOUT = false;
+        LayoutConstants.DEFAULT_ANIMATION_PERIOD = 50;
+        LayoutConstants.DEFAULT_UNIFORM_LEAF_NODE_SIZES = false;
+        LayoutConstants.DEFAULT_GRAPH_MARGIN = 15;
+        LayoutConstants.NODE_DIMENSIONS_INCLUDE_LABELS = false;
+        LayoutConstants.SIMPLE_NODE_SIZE = 40;
+        LayoutConstants.SIMPLE_NODE_HALF_SIZE = LayoutConstants.SIMPLE_NODE_SIZE / 2;
+        LayoutConstants.EMPTY_COMPOUND_NODE_SIZE = 40;
+        LayoutConstants.MIN_EDGE_LENGTH = 1;
+        LayoutConstants.WORLD_BOUNDARY = 1e6;
+        LayoutConstants.INITIAL_WORLD_BOUNDARY = LayoutConstants.WORLD_BOUNDARY / 1000;
+        LayoutConstants.WORLD_CENTER_X = 1200;
+        LayoutConstants.WORLD_CENTER_Y = 900;
+        module2.exports = LayoutConstants;
+      },
+      function(module2, exports2, __webpack_require__) {
+        var LGraphObject = __webpack_require__(2);
+        var IGeometry = __webpack_require__(8);
+        var IMath = __webpack_require__(9);
+        function LEdge(source, target, vEdge) {
+          LGraphObject.call(this, vEdge);
+          this.isOverlapingSourceAndTarget = false;
+          this.vGraphObject = vEdge;
+          this.bendpoints = [];
+          this.source = source;
+          this.target = target;
+        }
+        LEdge.prototype = Object.create(LGraphObject.prototype);
+        for (var prop in LGraphObject) {
+          LEdge[prop] = LGraphObject[prop];
+        }
+        LEdge.prototype.getSource = function() {
+          return this.source;
+        };
+        LEdge.prototype.getTarget = function() {
+          return this.target;
+        };
+        LEdge.prototype.isInterGraph = function() {
+          return this.isInterGraph;
+        };
+        LEdge.prototype.getLength = function() {
+          return this.length;
+        };
+        LEdge.prototype.isOverlapingSourceAndTarget = function() {
+          return this.isOverlapingSourceAndTarget;
+        };
+        LEdge.prototype.getBendpoints = function() {
+          return this.bendpoints;
+        };
+        LEdge.prototype.getLca = function() {
+          return this.lca;
+        };
+        LEdge.prototype.getSourceInLca = function() {
+          return this.sourceInLca;
+        };
+        LEdge.prototype.getTargetInLca = function() {
+          return this.targetInLca;
+        };
+        LEdge.prototype.getOtherEnd = function(node) {
+          if (this.source === node) {
+            return this.target;
+          } else if (this.target === node) {
+            return this.source;
+          } else {
+            throw "Node is not incident with this edge";
+          }
+        };
+        LEdge.prototype.getOtherEndInGraph = function(node, graph) {
+          var otherEnd = this.getOtherEnd(node);
+          var root = graph.getGraphManager().getRoot();
+          while (true) {
+            if (otherEnd.getOwner() == graph) {
+              return otherEnd;
+            }
+            if (otherEnd.getOwner() == root) {
+              break;
+            }
+            otherEnd = otherEnd.getOwner().getParent();
+          }
+          return null;
+        };
+        LEdge.prototype.updateLength = function() {
+          var clipPointCoordinates = new Array(4);
+          this.isOverlapingSourceAndTarget = IGeometry.getIntersection(this.target.getRect(), this.source.getRect(), clipPointCoordinates);
+          if (!this.isOverlapingSourceAndTarget) {
+            this.lengthX = clipPointCoordinates[0] - clipPointCoordinates[2];
+            this.lengthY = clipPointCoordinates[1] - clipPointCoordinates[3];
+            if (Math.abs(this.lengthX) < 1) {
+              this.lengthX = IMath.sign(this.lengthX);
+            }
+            if (Math.abs(this.lengthY) < 1) {
+              this.lengthY = IMath.sign(this.lengthY);
+            }
+            this.length = Math.sqrt(this.lengthX * this.lengthX + this.lengthY * this.lengthY);
+          }
+        };
+        LEdge.prototype.updateLengthSimple = function() {
+          this.lengthX = this.target.getCenterX() - this.source.getCenterX();
+          this.lengthY = this.target.getCenterY() - this.source.getCenterY();
+          if (Math.abs(this.lengthX) < 1) {
+            this.lengthX = IMath.sign(this.lengthX);
+          }
+          if (Math.abs(this.lengthY) < 1) {
+            this.lengthY = IMath.sign(this.lengthY);
+          }
+          this.length = Math.sqrt(this.lengthX * this.lengthX + this.lengthY * this.lengthY);
+        };
+        module2.exports = LEdge;
+      },
+      function(module2, exports2, __webpack_require__) {
+        function LGraphObject(vGraphObject) {
+          this.vGraphObject = vGraphObject;
+        }
+        module2.exports = LGraphObject;
+      },
+      function(module2, exports2, __webpack_require__) {
+        var LGraphObject = __webpack_require__(2);
+        var Integer = __webpack_require__(10);
+        var RectangleD = __webpack_require__(13);
+        var LayoutConstants = __webpack_require__(0);
+        var RandomSeed = __webpack_require__(16);
+        var PointD = __webpack_require__(4);
+        function LNode(gm, loc, size, vNode) {
+          if (size == null && vNode == null) {
+            vNode = loc;
+          }
+          LGraphObject.call(this, vNode);
+          if (gm.graphManager != null)
+            gm = gm.graphManager;
+          this.estimatedSize = Integer.MIN_VALUE;
+          this.inclusionTreeDepth = Integer.MAX_VALUE;
+          this.vGraphObject = vNode;
+          this.edges = [];
+          this.graphManager = gm;
+          if (size != null && loc != null)
+            this.rect = new RectangleD(loc.x, loc.y, size.width, size.height);
+          else
+            this.rect = new RectangleD;
+        }
+        LNode.prototype = Object.create(LGraphObject.prototype);
+        for (var prop in LGraphObject) {
+          LNode[prop] = LGraphObject[prop];
+        }
+        LNode.prototype.getEdges = function() {
+          return this.edges;
+        };
+        LNode.prototype.getChild = function() {
+          return this.child;
+        };
+        LNode.prototype.getOwner = function() {
+          return this.owner;
+        };
+        LNode.prototype.getWidth = function() {
+          return this.rect.width;
+        };
+        LNode.prototype.setWidth = function(width) {
+          this.rect.width = width;
+        };
+        LNode.prototype.getHeight = function() {
+          return this.rect.height;
+        };
+        LNode.prototype.setHeight = function(height) {
+          this.rect.height = height;
+        };
+        LNode.prototype.getCenterX = function() {
+          return this.rect.x + this.rect.width / 2;
+        };
+        LNode.prototype.getCenterY = function() {
+          return this.rect.y + this.rect.height / 2;
+        };
+        LNode.prototype.getCenter = function() {
+          return new PointD(this.rect.x + this.rect.width / 2, this.rect.y + this.rect.height / 2);
+        };
+        LNode.prototype.getLocation = function() {
+          return new PointD(this.rect.x, this.rect.y);
+        };
+        LNode.prototype.getRect = function() {
+          return this.rect;
+        };
+        LNode.prototype.getDiagonal = function() {
+          return Math.sqrt(this.rect.width * this.rect.width + this.rect.height * this.rect.height);
+        };
+        LNode.prototype.getHalfTheDiagonal = function() {
+          return Math.sqrt(this.rect.height * this.rect.height + this.rect.width * this.rect.width) / 2;
+        };
+        LNode.prototype.setRect = function(upperLeft, dimension) {
+          this.rect.x = upperLeft.x;
+          this.rect.y = upperLeft.y;
+          this.rect.width = dimension.width;
+          this.rect.height = dimension.height;
+        };
+        LNode.prototype.setCenter = function(cx, cy) {
+          this.rect.x = cx - this.rect.width / 2;
+          this.rect.y = cy - this.rect.height / 2;
+        };
+        LNode.prototype.setLocation = function(x, y) {
+          this.rect.x = x;
+          this.rect.y = y;
+        };
+        LNode.prototype.moveBy = function(dx, dy) {
+          this.rect.x += dx;
+          this.rect.y += dy;
+        };
+        LNode.prototype.getEdgeListToNode = function(to) {
+          var edgeList = [];
+          var edge;
+          var self = this;
+          self.edges.forEach(function(edge2) {
+            if (edge2.target == to) {
+              if (edge2.source != self)
+                throw "Incorrect edge source!";
+              edgeList.push(edge2);
+            }
+          });
+          return edgeList;
+        };
+        LNode.prototype.getEdgesBetween = function(other) {
+          var edgeList = [];
+          var edge;
+          var self = this;
+          self.edges.forEach(function(edge2) {
+            if (!(edge2.source == self || edge2.target == self))
+              throw "Incorrect edge source and/or target";
+            if (edge2.target == other || edge2.source == other) {
+              edgeList.push(edge2);
+            }
+          });
+          return edgeList;
+        };
+        LNode.prototype.getNeighborsList = function() {
+          var neighbors = new Set;
+          var self = this;
+          self.edges.forEach(function(edge) {
+            if (edge.source == self) {
+              neighbors.add(edge.target);
+            } else {
+              if (edge.target != self) {
+                throw "Incorrect incidency!";
+              }
+              neighbors.add(edge.source);
+            }
+          });
+          return neighbors;
+        };
+        LNode.prototype.withChildren = function() {
+          var withNeighborsList = new Set;
+          var childNode;
+          var children;
+          withNeighborsList.add(this);
+          if (this.child != null) {
+            var nodes = this.child.getNodes();
+            for (var i = 0;i < nodes.length; i++) {
+              childNode = nodes[i];
+              children = childNode.withChildren();
+              children.forEach(function(node) {
+                withNeighborsList.add(node);
+              });
+            }
+          }
+          return withNeighborsList;
+        };
+        LNode.prototype.getNoOfChildren = function() {
+          var noOfChildren = 0;
+          var childNode;
+          if (this.child == null) {
+            noOfChildren = 1;
+          } else {
+            var nodes = this.child.getNodes();
+            for (var i = 0;i < nodes.length; i++) {
+              childNode = nodes[i];
+              noOfChildren += childNode.getNoOfChildren();
+            }
+          }
+          if (noOfChildren == 0) {
+            noOfChildren = 1;
+          }
+          return noOfChildren;
+        };
+        LNode.prototype.getEstimatedSize = function() {
+          if (this.estimatedSize == Integer.MIN_VALUE) {
+            throw "assert failed";
+          }
+          return this.estimatedSize;
+        };
+        LNode.prototype.calcEstimatedSize = function() {
+          if (this.child == null) {
+            return this.estimatedSize = (this.rect.width + this.rect.height) / 2;
+          } else {
+            this.estimatedSize = this.child.calcEstimatedSize();
+            this.rect.width = this.estimatedSize;
+            this.rect.height = this.estimatedSize;
+            return this.estimatedSize;
+          }
+        };
+        LNode.prototype.scatter = function() {
+          var randomCenterX;
+          var randomCenterY;
+          var minX = -LayoutConstants.INITIAL_WORLD_BOUNDARY;
+          var maxX = LayoutConstants.INITIAL_WORLD_BOUNDARY;
+          randomCenterX = LayoutConstants.WORLD_CENTER_X + RandomSeed.nextDouble() * (maxX - minX) + minX;
+          var minY = -LayoutConstants.INITIAL_WORLD_BOUNDARY;
+          var maxY = LayoutConstants.INITIAL_WORLD_BOUNDARY;
+          randomCenterY = LayoutConstants.WORLD_CENTER_Y + RandomSeed.nextDouble() * (maxY - minY) + minY;
+          this.rect.x = randomCenterX;
+          this.rect.y = randomCenterY;
+        };
+        LNode.prototype.updateBounds = function() {
+          if (this.getChild() == null) {
+            throw "assert failed";
+          }
+          if (this.getChild().getNodes().length != 0) {
+            var childGraph = this.getChild();
+            childGraph.updateBounds(true);
+            this.rect.x = childGraph.getLeft();
+            this.rect.y = childGraph.getTop();
+            this.setWidth(childGraph.getRight() - childGraph.getLeft());
+            this.setHeight(childGraph.getBottom() - childGraph.getTop());
+            if (LayoutConstants.NODE_DIMENSIONS_INCLUDE_LABELS) {
+              var width = childGraph.getRight() - childGraph.getLeft();
+              var height = childGraph.getBottom() - childGraph.getTop();
+              if (this.labelWidth > width) {
+                this.rect.x -= (this.labelWidth - width) / 2;
+                this.setWidth(this.labelWidth);
+              }
+              if (this.labelHeight > height) {
+                if (this.labelPos == "center") {
+                  this.rect.y -= (this.labelHeight - height) / 2;
+                } else if (this.labelPos == "top") {
+                  this.rect.y -= this.labelHeight - height;
+                }
+                this.setHeight(this.labelHeight);
+              }
+            }
+          }
+        };
+        LNode.prototype.getInclusionTreeDepth = function() {
+          if (this.inclusionTreeDepth == Integer.MAX_VALUE) {
+            throw "assert failed";
+          }
+          return this.inclusionTreeDepth;
+        };
+        LNode.prototype.transform = function(trans) {
+          var left = this.rect.x;
+          if (left > LayoutConstants.WORLD_BOUNDARY) {
+            left = LayoutConstants.WORLD_BOUNDARY;
+          } else if (left < -LayoutConstants.WORLD_BOUNDARY) {
+            left = -LayoutConstants.WORLD_BOUNDARY;
+          }
+          var top = this.rect.y;
+          if (top > LayoutConstants.WORLD_BOUNDARY) {
+            top = LayoutConstants.WORLD_BOUNDARY;
+          } else if (top < -LayoutConstants.WORLD_BOUNDARY) {
+            top = -LayoutConstants.WORLD_BOUNDARY;
+          }
+          var leftTop = new PointD(left, top);
+          var vLeftTop = trans.inverseTransformPoint(leftTop);
+          this.setLocation(vLeftTop.x, vLeftTop.y);
+        };
+        LNode.prototype.getLeft = function() {
+          return this.rect.x;
+        };
+        LNode.prototype.getRight = function() {
+          return this.rect.x + this.rect.width;
+        };
+        LNode.prototype.getTop = function() {
+          return this.rect.y;
+        };
+        LNode.prototype.getBottom = function() {
+          return this.rect.y + this.rect.height;
+        };
+        LNode.prototype.getParent = function() {
+          if (this.owner == null) {
+            return null;
+          }
+          return this.owner.getParent();
+        };
+        module2.exports = LNode;
+      },
+      function(module2, exports2, __webpack_require__) {
+        function PointD(x, y) {
+          if (x == null && y == null) {
+            this.x = 0;
+            this.y = 0;
+          } else {
+            this.x = x;
+            this.y = y;
+          }
+        }
+        PointD.prototype.getX = function() {
+          return this.x;
+        };
+        PointD.prototype.getY = function() {
+          return this.y;
+        };
+        PointD.prototype.setX = function(x) {
+          this.x = x;
+        };
+        PointD.prototype.setY = function(y) {
+          this.y = y;
+        };
+        PointD.prototype.getDifference = function(pt) {
+          return new DimensionD(this.x - pt.x, this.y - pt.y);
+        };
+        PointD.prototype.getCopy = function() {
+          return new PointD(this.x, this.y);
+        };
+        PointD.prototype.translate = function(dim) {
+          this.x += dim.width;
+          this.y += dim.height;
+          return this;
+        };
+        module2.exports = PointD;
+      },
+      function(module2, exports2, __webpack_require__) {
+        var LGraphObject = __webpack_require__(2);
+        var Integer = __webpack_require__(10);
+        var LayoutConstants = __webpack_require__(0);
+        var LGraphManager = __webpack_require__(6);
+        var LNode = __webpack_require__(3);
+        var LEdge = __webpack_require__(1);
+        var RectangleD = __webpack_require__(13);
+        var Point2 = __webpack_require__(12);
+        var LinkedList = __webpack_require__(11);
+        function LGraph(parent, obj2, vGraph) {
+          LGraphObject.call(this, vGraph);
+          this.estimatedSize = Integer.MIN_VALUE;
+          this.margin = LayoutConstants.DEFAULT_GRAPH_MARGIN;
+          this.edges = [];
+          this.nodes = [];
+          this.isConnected = false;
+          this.parent = parent;
+          if (obj2 != null && obj2 instanceof LGraphManager) {
+            this.graphManager = obj2;
+          } else if (obj2 != null && obj2 instanceof Layout) {
+            this.graphManager = obj2.graphManager;
+          }
+        }
+        LGraph.prototype = Object.create(LGraphObject.prototype);
+        for (var prop in LGraphObject) {
+          LGraph[prop] = LGraphObject[prop];
+        }
+        LGraph.prototype.getNodes = function() {
+          return this.nodes;
+        };
+        LGraph.prototype.getEdges = function() {
+          return this.edges;
+        };
+        LGraph.prototype.getGraphManager = function() {
+          return this.graphManager;
+        };
+        LGraph.prototype.getParent = function() {
+          return this.parent;
+        };
+        LGraph.prototype.getLeft = function() {
+          return this.left;
+        };
+        LGraph.prototype.getRight = function() {
+          return this.right;
+        };
+        LGraph.prototype.getTop = function() {
+          return this.top;
+        };
+        LGraph.prototype.getBottom = function() {
+          return this.bottom;
+        };
+        LGraph.prototype.isConnected = function() {
+          return this.isConnected;
+        };
+        LGraph.prototype.add = function(obj1, sourceNode, targetNode) {
+          if (sourceNode == null && targetNode == null) {
+            var newNode = obj1;
+            if (this.graphManager == null) {
+              throw "Graph has no graph mgr!";
+            }
+            if (this.getNodes().indexOf(newNode) > -1) {
+              throw "Node already in graph!";
+            }
+            newNode.owner = this;
+            this.getNodes().push(newNode);
+            return newNode;
+          } else {
+            var newEdge = obj1;
+            if (!(this.getNodes().indexOf(sourceNode) > -1 && this.getNodes().indexOf(targetNode) > -1)) {
+              throw "Source or target not in graph!";
+            }
+            if (!(sourceNode.owner == targetNode.owner && sourceNode.owner == this)) {
+              throw "Both owners must be this graph!";
+            }
+            if (sourceNode.owner != targetNode.owner) {
+              return null;
+            }
+            newEdge.source = sourceNode;
+            newEdge.target = targetNode;
+            newEdge.isInterGraph = false;
+            this.getEdges().push(newEdge);
+            sourceNode.edges.push(newEdge);
+            if (targetNode != sourceNode) {
+              targetNode.edges.push(newEdge);
+            }
+            return newEdge;
+          }
+        };
+        LGraph.prototype.remove = function(obj) {
+          var node = obj;
+          if (obj instanceof LNode) {
+            if (node == null) {
+              throw "Node is null!";
+            }
+            if (!(node.owner != null && node.owner == this)) {
+              throw "Owner graph is invalid!";
+            }
+            if (this.graphManager == null) {
+              throw "Owner graph manager is invalid!";
+            }
+            var edgesToBeRemoved = node.edges.slice();
+            var edge;
+            var s = edgesToBeRemoved.length;
+            for (var i = 0;i < s; i++) {
+              edge = edgesToBeRemoved[i];
+              if (edge.isInterGraph) {
+                this.graphManager.remove(edge);
+              } else {
+                edge.source.owner.remove(edge);
+              }
+            }
+            var index = this.nodes.indexOf(node);
+            if (index == -1) {
+              throw "Node not in owner node list!";
+            }
+            this.nodes.splice(index, 1);
+          } else if (obj instanceof LEdge) {
+            var edge = obj;
+            if (edge == null) {
+              throw "Edge is null!";
+            }
+            if (!(edge.source != null && edge.target != null)) {
+              throw "Source and/or target is null!";
+            }
+            if (!(edge.source.owner != null && edge.target.owner != null && edge.source.owner == this && edge.target.owner == this)) {
+              throw "Source and/or target owner is invalid!";
+            }
+            var sourceIndex = edge.source.edges.indexOf(edge);
+            var targetIndex = edge.target.edges.indexOf(edge);
+            if (!(sourceIndex > -1 && targetIndex > -1)) {
+              throw "Source and/or target doesn't know this edge!";
+            }
+            edge.source.edges.splice(sourceIndex, 1);
+            if (edge.target != edge.source) {
+              edge.target.edges.splice(targetIndex, 1);
+            }
+            var index = edge.source.owner.getEdges().indexOf(edge);
+            if (index == -1) {
+              throw "Not in owner's edge list!";
+            }
+            edge.source.owner.getEdges().splice(index, 1);
+          }
+        };
+        LGraph.prototype.updateLeftTop = function() {
+          var top = Integer.MAX_VALUE;
+          var left = Integer.MAX_VALUE;
+          var nodeTop;
+          var nodeLeft;
+          var margin;
+          var nodes = this.getNodes();
+          var s = nodes.length;
+          for (var i = 0;i < s; i++) {
+            var lNode = nodes[i];
+            nodeTop = lNode.getTop();
+            nodeLeft = lNode.getLeft();
+            if (top > nodeTop) {
+              top = nodeTop;
+            }
+            if (left > nodeLeft) {
+              left = nodeLeft;
+            }
+          }
+          if (top == Integer.MAX_VALUE) {
+            return null;
+          }
+          if (nodes[0].getParent().paddingLeft != null) {
+            margin = nodes[0].getParent().paddingLeft;
+          } else {
+            margin = this.margin;
+          }
+          this.left = left - margin;
+          this.top = top - margin;
+          return new Point2(this.left, this.top);
+        };
+        LGraph.prototype.updateBounds = function(recursive) {
+          var left = Integer.MAX_VALUE;
+          var right = -Integer.MAX_VALUE;
+          var top = Integer.MAX_VALUE;
+          var bottom = -Integer.MAX_VALUE;
+          var nodeLeft;
+          var nodeRight;
+          var nodeTop;
+          var nodeBottom;
+          var margin;
+          var nodes = this.nodes;
+          var s = nodes.length;
+          for (var i = 0;i < s; i++) {
+            var lNode = nodes[i];
+            if (recursive && lNode.child != null) {
+              lNode.updateBounds();
+            }
+            nodeLeft = lNode.getLeft();
+            nodeRight = lNode.getRight();
+            nodeTop = lNode.getTop();
+            nodeBottom = lNode.getBottom();
+            if (left > nodeLeft) {
+              left = nodeLeft;
+            }
+            if (right < nodeRight) {
+              right = nodeRight;
+            }
+            if (top > nodeTop) {
+              top = nodeTop;
+            }
+            if (bottom < nodeBottom) {
+              bottom = nodeBottom;
+            }
+          }
+          var boundingRect = new RectangleD(left, top, right - left, bottom - top);
+          if (left == Integer.MAX_VALUE) {
+            this.left = this.parent.getLeft();
+            this.right = this.parent.getRight();
+            this.top = this.parent.getTop();
+            this.bottom = this.parent.getBottom();
+          }
+          if (nodes[0].getParent().paddingLeft != null) {
+            margin = nodes[0].getParent().paddingLeft;
+          } else {
+            margin = this.margin;
+          }
+          this.left = boundingRect.x - margin;
+          this.right = boundingRect.x + boundingRect.width + margin;
+          this.top = boundingRect.y - margin;
+          this.bottom = boundingRect.y + boundingRect.height + margin;
+        };
+        LGraph.calculateBounds = function(nodes) {
+          var left = Integer.MAX_VALUE;
+          var right = -Integer.MAX_VALUE;
+          var top = Integer.MAX_VALUE;
+          var bottom = -Integer.MAX_VALUE;
+          var nodeLeft;
+          var nodeRight;
+          var nodeTop;
+          var nodeBottom;
+          var s = nodes.length;
+          for (var i = 0;i < s; i++) {
+            var lNode = nodes[i];
+            nodeLeft = lNode.getLeft();
+            nodeRight = lNode.getRight();
+            nodeTop = lNode.getTop();
+            nodeBottom = lNode.getBottom();
+            if (left > nodeLeft) {
+              left = nodeLeft;
+            }
+            if (right < nodeRight) {
+              right = nodeRight;
+            }
+            if (top > nodeTop) {
+              top = nodeTop;
+            }
+            if (bottom < nodeBottom) {
+              bottom = nodeBottom;
+            }
+          }
+          var boundingRect = new RectangleD(left, top, right - left, bottom - top);
+          return boundingRect;
+        };
+        LGraph.prototype.getInclusionTreeDepth = function() {
+          if (this == this.graphManager.getRoot()) {
+            return 1;
+          } else {
+            return this.parent.getInclusionTreeDepth();
+          }
+        };
+        LGraph.prototype.getEstimatedSize = function() {
+          if (this.estimatedSize == Integer.MIN_VALUE) {
+            throw "assert failed";
+          }
+          return this.estimatedSize;
+        };
+        LGraph.prototype.calcEstimatedSize = function() {
+          var size = 0;
+          var nodes = this.nodes;
+          var s = nodes.length;
+          for (var i = 0;i < s; i++) {
+            var lNode = nodes[i];
+            size += lNode.calcEstimatedSize();
+          }
+          if (size == 0) {
+            this.estimatedSize = LayoutConstants.EMPTY_COMPOUND_NODE_SIZE;
+          } else {
+            this.estimatedSize = size / Math.sqrt(this.nodes.length);
+          }
+          return this.estimatedSize;
+        };
+        LGraph.prototype.updateConnected = function() {
+          var self = this;
+          if (this.nodes.length == 0) {
+            this.isConnected = true;
+            return;
+          }
+          var queue = new LinkedList;
+          var visited = new Set;
+          var currentNode = this.nodes[0];
+          var neighborEdges;
+          var currentNeighbor;
+          var childrenOfNode = currentNode.withChildren();
+          childrenOfNode.forEach(function(node) {
+            queue.push(node);
+            visited.add(node);
+          });
+          while (queue.length !== 0) {
+            currentNode = queue.shift();
+            neighborEdges = currentNode.getEdges();
+            var size = neighborEdges.length;
+            for (var i = 0;i < size; i++) {
+              var neighborEdge = neighborEdges[i];
+              currentNeighbor = neighborEdge.getOtherEndInGraph(currentNode, this);
+              if (currentNeighbor != null && !visited.has(currentNeighbor)) {
+                var childrenOfNeighbor = currentNeighbor.withChildren();
+                childrenOfNeighbor.forEach(function(node) {
+                  queue.push(node);
+                  visited.add(node);
+                });
+              }
+            }
+          }
+          this.isConnected = false;
+          if (visited.size >= this.nodes.length) {
+            var noOfVisitedInThisGraph = 0;
+            visited.forEach(function(visitedNode) {
+              if (visitedNode.owner == self) {
+                noOfVisitedInThisGraph++;
+              }
+            });
+            if (noOfVisitedInThisGraph == this.nodes.length) {
+              this.isConnected = true;
+            }
+          }
+        };
+        module2.exports = LGraph;
+      },
+      function(module2, exports2, __webpack_require__) {
+        var LGraph;
+        var LEdge = __webpack_require__(1);
+        function LGraphManager(layout) {
+          LGraph = __webpack_require__(5);
+          this.layout = layout;
+          this.graphs = [];
+          this.edges = [];
+        }
+        LGraphManager.prototype.addRoot = function() {
+          var ngraph = this.layout.newGraph();
+          var nnode = this.layout.newNode(null);
+          var root = this.add(ngraph, nnode);
+          this.setRootGraph(root);
+          return this.rootGraph;
+        };
+        LGraphManager.prototype.add = function(newGraph, parentNode, newEdge, sourceNode, targetNode) {
+          if (newEdge == null && sourceNode == null && targetNode == null) {
+            if (newGraph == null) {
+              throw "Graph is null!";
+            }
+            if (parentNode == null) {
+              throw "Parent node is null!";
+            }
+            if (this.graphs.indexOf(newGraph) > -1) {
+              throw "Graph already in this graph mgr!";
+            }
+            this.graphs.push(newGraph);
+            if (newGraph.parent != null) {
+              throw "Already has a parent!";
+            }
+            if (parentNode.child != null) {
+              throw "Already has a child!";
+            }
+            newGraph.parent = parentNode;
+            parentNode.child = newGraph;
+            return newGraph;
+          } else {
+            targetNode = newEdge;
+            sourceNode = parentNode;
+            newEdge = newGraph;
+            var sourceGraph = sourceNode.getOwner();
+            var targetGraph = targetNode.getOwner();
+            if (!(sourceGraph != null && sourceGraph.getGraphManager() == this)) {
+              throw "Source not in this graph mgr!";
+            }
+            if (!(targetGraph != null && targetGraph.getGraphManager() == this)) {
+              throw "Target not in this graph mgr!";
+            }
+            if (sourceGraph == targetGraph) {
+              newEdge.isInterGraph = false;
+              return sourceGraph.add(newEdge, sourceNode, targetNode);
+            } else {
+              newEdge.isInterGraph = true;
+              newEdge.source = sourceNode;
+              newEdge.target = targetNode;
+              if (this.edges.indexOf(newEdge) > -1) {
+                throw "Edge already in inter-graph edge list!";
+              }
+              this.edges.push(newEdge);
+              if (!(newEdge.source != null && newEdge.target != null)) {
+                throw "Edge source and/or target is null!";
+              }
+              if (!(newEdge.source.edges.indexOf(newEdge) == -1 && newEdge.target.edges.indexOf(newEdge) == -1)) {
+                throw "Edge already in source and/or target incidency list!";
+              }
+              newEdge.source.edges.push(newEdge);
+              newEdge.target.edges.push(newEdge);
+              return newEdge;
+            }
+          }
+        };
+        LGraphManager.prototype.remove = function(lObj) {
+          if (lObj instanceof LGraph) {
+            var graph = lObj;
+            if (graph.getGraphManager() != this) {
+              throw "Graph not in this graph mgr";
+            }
+            if (!(graph == this.rootGraph || graph.parent != null && graph.parent.graphManager == this)) {
+              throw "Invalid parent node!";
+            }
+            var edgesToBeRemoved = [];
+            edgesToBeRemoved = edgesToBeRemoved.concat(graph.getEdges());
+            var edge;
+            var s = edgesToBeRemoved.length;
+            for (var i = 0;i < s; i++) {
+              edge = edgesToBeRemoved[i];
+              graph.remove(edge);
+            }
+            var nodesToBeRemoved = [];
+            nodesToBeRemoved = nodesToBeRemoved.concat(graph.getNodes());
+            var node;
+            s = nodesToBeRemoved.length;
+            for (var i = 0;i < s; i++) {
+              node = nodesToBeRemoved[i];
+              graph.remove(node);
+            }
+            if (graph == this.rootGraph) {
+              this.setRootGraph(null);
+            }
+            var index = this.graphs.indexOf(graph);
+            this.graphs.splice(index, 1);
+            graph.parent = null;
+          } else if (lObj instanceof LEdge) {
+            edge = lObj;
+            if (edge == null) {
+              throw "Edge is null!";
+            }
+            if (!edge.isInterGraph) {
+              throw "Not an inter-graph edge!";
+            }
+            if (!(edge.source != null && edge.target != null)) {
+              throw "Source and/or target is null!";
+            }
+            if (!(edge.source.edges.indexOf(edge) != -1 && edge.target.edges.indexOf(edge) != -1)) {
+              throw "Source and/or target doesn't know this edge!";
+            }
+            var index = edge.source.edges.indexOf(edge);
+            edge.source.edges.splice(index, 1);
+            index = edge.target.edges.indexOf(edge);
+            edge.target.edges.splice(index, 1);
+            if (!(edge.source.owner != null && edge.source.owner.getGraphManager() != null)) {
+              throw "Edge owner graph or owner graph manager is null!";
+            }
+            if (edge.source.owner.getGraphManager().edges.indexOf(edge) == -1) {
+              throw "Not in owner graph manager's edge list!";
+            }
+            var index = edge.source.owner.getGraphManager().edges.indexOf(edge);
+            edge.source.owner.getGraphManager().edges.splice(index, 1);
+          }
+        };
+        LGraphManager.prototype.updateBounds = function() {
+          this.rootGraph.updateBounds(true);
+        };
+        LGraphManager.prototype.getGraphs = function() {
+          return this.graphs;
+        };
+        LGraphManager.prototype.getAllNodes = function() {
+          if (this.allNodes == null) {
+            var nodeList = [];
+            var graphs = this.getGraphs();
+            var s = graphs.length;
+            for (var i = 0;i < s; i++) {
+              nodeList = nodeList.concat(graphs[i].getNodes());
+            }
+            this.allNodes = nodeList;
+          }
+          return this.allNodes;
+        };
+        LGraphManager.prototype.resetAllNodes = function() {
+          this.allNodes = null;
+        };
+        LGraphManager.prototype.resetAllEdges = function() {
+          this.allEdges = null;
+        };
+        LGraphManager.prototype.resetAllNodesToApplyGravitation = function() {
+          this.allNodesToApplyGravitation = null;
+        };
+        LGraphManager.prototype.getAllEdges = function() {
+          if (this.allEdges == null) {
+            var edgeList = [];
+            var graphs = this.getGraphs();
+            var s = graphs.length;
+            for (var i = 0;i < graphs.length; i++) {
+              edgeList = edgeList.concat(graphs[i].getEdges());
+            }
+            edgeList = edgeList.concat(this.edges);
+            this.allEdges = edgeList;
+          }
+          return this.allEdges;
+        };
+        LGraphManager.prototype.getAllNodesToApplyGravitation = function() {
+          return this.allNodesToApplyGravitation;
+        };
+        LGraphManager.prototype.setAllNodesToApplyGravitation = function(nodeList) {
+          if (this.allNodesToApplyGravitation != null) {
+            throw "assert failed";
+          }
+          this.allNodesToApplyGravitation = nodeList;
+        };
+        LGraphManager.prototype.getRoot = function() {
+          return this.rootGraph;
+        };
+        LGraphManager.prototype.setRootGraph = function(graph) {
+          if (graph.getGraphManager() != this) {
+            throw "Root not in this graph mgr!";
+          }
+          this.rootGraph = graph;
+          if (graph.parent == null) {
+            graph.parent = this.layout.newNode("Root node");
+          }
+        };
+        LGraphManager.prototype.getLayout = function() {
+          return this.layout;
+        };
+        LGraphManager.prototype.isOneAncestorOfOther = function(firstNode, secondNode) {
+          if (!(firstNode != null && secondNode != null)) {
+            throw "assert failed";
+          }
+          if (firstNode == secondNode) {
+            return true;
+          }
+          var ownerGraph = firstNode.getOwner();
+          var parentNode;
+          do {
+            parentNode = ownerGraph.getParent();
+            if (parentNode == null) {
+              break;
+            }
+            if (parentNode == secondNode) {
+              return true;
+            }
+            ownerGraph = parentNode.getOwner();
+            if (ownerGraph == null) {
+              break;
+            }
+          } while (true);
+          ownerGraph = secondNode.getOwner();
+          do {
+            parentNode = ownerGraph.getParent();
+            if (parentNode == null) {
+              break;
+            }
+            if (parentNode == firstNode) {
+              return true;
+            }
+            ownerGraph = parentNode.getOwner();
+            if (ownerGraph == null) {
+              break;
+            }
+          } while (true);
+          return false;
+        };
+        LGraphManager.prototype.calcLowestCommonAncestors = function() {
+          var edge;
+          var sourceNode;
+          var targetNode;
+          var sourceAncestorGraph;
+          var targetAncestorGraph;
+          var edges = this.getAllEdges();
+          var s = edges.length;
+          for (var i = 0;i < s; i++) {
+            edge = edges[i];
+            sourceNode = edge.source;
+            targetNode = edge.target;
+            edge.lca = null;
+            edge.sourceInLca = sourceNode;
+            edge.targetInLca = targetNode;
+            if (sourceNode == targetNode) {
+              edge.lca = sourceNode.getOwner();
+              continue;
+            }
+            sourceAncestorGraph = sourceNode.getOwner();
+            while (edge.lca == null) {
+              edge.targetInLca = targetNode;
+              targetAncestorGraph = targetNode.getOwner();
+              while (edge.lca == null) {
+                if (targetAncestorGraph == sourceAncestorGraph) {
+                  edge.lca = targetAncestorGraph;
+                  break;
+                }
+                if (targetAncestorGraph == this.rootGraph) {
+                  break;
+                }
+                if (edge.lca != null) {
+                  throw "assert failed";
+                }
+                edge.targetInLca = targetAncestorGraph.getParent();
+                targetAncestorGraph = edge.targetInLca.getOwner();
+              }
+              if (sourceAncestorGraph == this.rootGraph) {
+                break;
+              }
+              if (edge.lca == null) {
+                edge.sourceInLca = sourceAncestorGraph.getParent();
+                sourceAncestorGraph = edge.sourceInLca.getOwner();
+              }
+            }
+            if (edge.lca == null) {
+              throw "assert failed";
+            }
+          }
+        };
+        LGraphManager.prototype.calcLowestCommonAncestor = function(firstNode, secondNode) {
+          if (firstNode == secondNode) {
+            return firstNode.getOwner();
+          }
+          var firstOwnerGraph = firstNode.getOwner();
+          do {
+            if (firstOwnerGraph == null) {
+              break;
+            }
+            var secondOwnerGraph = secondNode.getOwner();
+            do {
+              if (secondOwnerGraph == null) {
+                break;
+              }
+              if (secondOwnerGraph == firstOwnerGraph) {
+                return secondOwnerGraph;
+              }
+              secondOwnerGraph = secondOwnerGraph.getParent().getOwner();
+            } while (true);
+            firstOwnerGraph = firstOwnerGraph.getParent().getOwner();
+          } while (true);
+          return firstOwnerGraph;
+        };
+        LGraphManager.prototype.calcInclusionTreeDepths = function(graph, depth) {
+          if (graph == null && depth == null) {
+            graph = this.rootGraph;
+            depth = 1;
+          }
+          var node;
+          var nodes = graph.getNodes();
+          var s = nodes.length;
+          for (var i = 0;i < s; i++) {
+            node = nodes[i];
+            node.inclusionTreeDepth = depth;
+            if (node.child != null) {
+              this.calcInclusionTreeDepths(node.child, depth + 1);
+            }
+          }
+        };
+        LGraphManager.prototype.includesInvalidEdge = function() {
+          var edge;
+          var s = this.edges.length;
+          for (var i = 0;i < s; i++) {
+            edge = this.edges[i];
+            if (this.isOneAncestorOfOther(edge.source, edge.target)) {
+              return true;
+            }
+          }
+          return false;
+        };
+        module2.exports = LGraphManager;
+      },
+      function(module2, exports2, __webpack_require__) {
+        var LayoutConstants = __webpack_require__(0);
+        function FDLayoutConstants() {}
+        for (var prop in LayoutConstants) {
+          FDLayoutConstants[prop] = LayoutConstants[prop];
+        }
+        FDLayoutConstants.MAX_ITERATIONS = 2500;
+        FDLayoutConstants.DEFAULT_EDGE_LENGTH = 50;
+        FDLayoutConstants.DEFAULT_SPRING_STRENGTH = 0.45;
+        FDLayoutConstants.DEFAULT_REPULSION_STRENGTH = 4500;
+        FDLayoutConstants.DEFAULT_GRAVITY_STRENGTH = 0.4;
+        FDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_STRENGTH = 1;
+        FDLayoutConstants.DEFAULT_GRAVITY_RANGE_FACTOR = 3.8;
+        FDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR = 1.5;
+        FDLayoutConstants.DEFAULT_USE_SMART_IDEAL_EDGE_LENGTH_CALCULATION = true;
+        FDLayoutConstants.DEFAULT_USE_SMART_REPULSION_RANGE_CALCULATION = true;
+        FDLayoutConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL = 0.3;
+        FDLayoutConstants.COOLING_ADAPTATION_FACTOR = 0.33;
+        FDLayoutConstants.ADAPTATION_LOWER_NODE_LIMIT = 1000;
+        FDLayoutConstants.ADAPTATION_UPPER_NODE_LIMIT = 5000;
+        FDLayoutConstants.MAX_NODE_DISPLACEMENT_INCREMENTAL = 100;
+        FDLayoutConstants.MAX_NODE_DISPLACEMENT = FDLayoutConstants.MAX_NODE_DISPLACEMENT_INCREMENTAL * 3;
+        FDLayoutConstants.MIN_REPULSION_DIST = FDLayoutConstants.DEFAULT_EDGE_LENGTH / 10;
+        FDLayoutConstants.CONVERGENCE_CHECK_PERIOD = 100;
+        FDLayoutConstants.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR = 0.1;
+        FDLayoutConstants.MIN_EDGE_LENGTH = 1;
+        FDLayoutConstants.GRID_CALCULATION_CHECK_PERIOD = 10;
+        module2.exports = FDLayoutConstants;
+      },
+      function(module2, exports2, __webpack_require__) {
+        var Point2 = __webpack_require__(12);
+        function IGeometry() {}
+        IGeometry.calcSeparationAmount = function(rectA, rectB, overlapAmount, separationBuffer) {
+          if (!rectA.intersects(rectB)) {
+            throw "assert failed";
+          }
+          var directions = new Array(2);
+          this.decideDirectionsForOverlappingNodes(rectA, rectB, directions);
+          overlapAmount[0] = Math.min(rectA.getRight(), rectB.getRight()) - Math.max(rectA.x, rectB.x);
+          overlapAmount[1] = Math.min(rectA.getBottom(), rectB.getBottom()) - Math.max(rectA.y, rectB.y);
+          if (rectA.getX() <= rectB.getX() && rectA.getRight() >= rectB.getRight()) {
+            overlapAmount[0] += Math.min(rectB.getX() - rectA.getX(), rectA.getRight() - rectB.getRight());
+          } else if (rectB.getX() <= rectA.getX() && rectB.getRight() >= rectA.getRight()) {
+            overlapAmount[0] += Math.min(rectA.getX() - rectB.getX(), rectB.getRight() - rectA.getRight());
+          }
+          if (rectA.getY() <= rectB.getY() && rectA.getBottom() >= rectB.getBottom()) {
+            overlapAmount[1] += Math.min(rectB.getY() - rectA.getY(), rectA.getBottom() - rectB.getBottom());
+          } else if (rectB.getY() <= rectA.getY() && rectB.getBottom() >= rectA.getBottom()) {
+            overlapAmount[1] += Math.min(rectA.getY() - rectB.getY(), rectB.getBottom() - rectA.getBottom());
+          }
+          var slope = Math.abs((rectB.getCenterY() - rectA.getCenterY()) / (rectB.getCenterX() - rectA.getCenterX()));
+          if (rectB.getCenterY() === rectA.getCenterY() && rectB.getCenterX() === rectA.getCenterX()) {
+            slope = 1;
+          }
+          var moveByY = slope * overlapAmount[0];
+          var moveByX = overlapAmount[1] / slope;
+          if (overlapAmount[0] < moveByX) {
+            moveByX = overlapAmount[0];
+          } else {
+            moveByY = overlapAmount[1];
+          }
+          overlapAmount[0] = -1 * directions[0] * (moveByX / 2 + separationBuffer);
+          overlapAmount[1] = -1 * directions[1] * (moveByY / 2 + separationBuffer);
+        };
+        IGeometry.decideDirectionsForOverlappingNodes = function(rectA, rectB, directions) {
+          if (rectA.getCenterX() < rectB.getCenterX()) {
+            directions[0] = -1;
+          } else {
+            directions[0] = 1;
+          }
+          if (rectA.getCenterY() < rectB.getCenterY()) {
+            directions[1] = -1;
+          } else {
+            directions[1] = 1;
+          }
+        };
+        IGeometry.getIntersection2 = function(rectA, rectB, result) {
+          var p1x = rectA.getCenterX();
+          var p1y = rectA.getCenterY();
+          var p2x = rectB.getCenterX();
+          var p2y = rectB.getCenterY();
+          if (rectA.intersects(rectB)) {
+            result[0] = p1x;
+            result[1] = p1y;
+            result[2] = p2x;
+            result[3] = p2y;
+            return true;
+          }
+          var topLeftAx = rectA.getX();
+          var topLeftAy = rectA.getY();
+          var topRightAx = rectA.getRight();
+          var bottomLeftAx = rectA.getX();
+          var bottomLeftAy = rectA.getBottom();
+          var bottomRightAx = rectA.getRight();
+          var halfWidthA = rectA.getWidthHalf();
+          var halfHeightA = rectA.getHeightHalf();
+          var topLeftBx = rectB.getX();
+          var topLeftBy = rectB.getY();
+          var topRightBx = rectB.getRight();
+          var bottomLeftBx = rectB.getX();
+          var bottomLeftBy = rectB.getBottom();
+          var bottomRightBx = rectB.getRight();
+          var halfWidthB = rectB.getWidthHalf();
+          var halfHeightB = rectB.getHeightHalf();
+          var clipPointAFound = false;
+          var clipPointBFound = false;
+          if (p1x === p2x) {
+            if (p1y > p2y) {
+              result[0] = p1x;
+              result[1] = topLeftAy;
+              result[2] = p2x;
+              result[3] = bottomLeftBy;
+              return false;
+            } else if (p1y < p2y) {
+              result[0] = p1x;
+              result[1] = bottomLeftAy;
+              result[2] = p2x;
+              result[3] = topLeftBy;
+              return false;
+            }
+          } else if (p1y === p2y) {
+            if (p1x > p2x) {
+              result[0] = topLeftAx;
+              result[1] = p1y;
+              result[2] = topRightBx;
+              result[3] = p2y;
+              return false;
+            } else if (p1x < p2x) {
+              result[0] = topRightAx;
+              result[1] = p1y;
+              result[2] = topLeftBx;
+              result[3] = p2y;
+              return false;
+            }
+          } else {
+            var slopeA = rectA.height / rectA.width;
+            var slopeB = rectB.height / rectB.width;
+            var slopePrime = (p2y - p1y) / (p2x - p1x);
+            var cardinalDirectionA = undefined;
+            var cardinalDirectionB = undefined;
+            var tempPointAx = undefined;
+            var tempPointAy = undefined;
+            var tempPointBx = undefined;
+            var tempPointBy = undefined;
+            if (-slopeA === slopePrime) {
+              if (p1x > p2x) {
+                result[0] = bottomLeftAx;
+                result[1] = bottomLeftAy;
+                clipPointAFound = true;
+              } else {
+                result[0] = topRightAx;
+                result[1] = topLeftAy;
+                clipPointAFound = true;
+              }
+            } else if (slopeA === slopePrime) {
+              if (p1x > p2x) {
+                result[0] = topLeftAx;
+                result[1] = topLeftAy;
+                clipPointAFound = true;
+              } else {
+                result[0] = bottomRightAx;
+                result[1] = bottomLeftAy;
+                clipPointAFound = true;
+              }
+            }
+            if (-slopeB === slopePrime) {
+              if (p2x > p1x) {
+                result[2] = bottomLeftBx;
+                result[3] = bottomLeftBy;
+                clipPointBFound = true;
+              } else {
+                result[2] = topRightBx;
+                result[3] = topLeftBy;
+                clipPointBFound = true;
+              }
+            } else if (slopeB === slopePrime) {
+              if (p2x > p1x) {
+                result[2] = topLeftBx;
+                result[3] = topLeftBy;
+                clipPointBFound = true;
+              } else {
+                result[2] = bottomRightBx;
+                result[3] = bottomLeftBy;
+                clipPointBFound = true;
+              }
+            }
+            if (clipPointAFound && clipPointBFound) {
+              return false;
+            }
+            if (p1x > p2x) {
+              if (p1y > p2y) {
+                cardinalDirectionA = this.getCardinalDirection(slopeA, slopePrime, 4);
+                cardinalDirectionB = this.getCardinalDirection(slopeB, slopePrime, 2);
+              } else {
+                cardinalDirectionA = this.getCardinalDirection(-slopeA, slopePrime, 3);
+                cardinalDirectionB = this.getCardinalDirection(-slopeB, slopePrime, 1);
+              }
+            } else {
+              if (p1y > p2y) {
+                cardinalDirectionA = this.getCardinalDirection(-slopeA, slopePrime, 1);
+                cardinalDirectionB = this.getCardinalDirection(-slopeB, slopePrime, 3);
+              } else {
+                cardinalDirectionA = this.getCardinalDirection(slopeA, slopePrime, 2);
+                cardinalDirectionB = this.getCardinalDirection(slopeB, slopePrime, 4);
+              }
+            }
+            if (!clipPointAFound) {
+              switch (cardinalDirectionA) {
+                case 1:
+                  tempPointAy = topLeftAy;
+                  tempPointAx = p1x + -halfHeightA / slopePrime;
+                  result[0] = tempPointAx;
+                  result[1] = tempPointAy;
+                  break;
+                case 2:
+                  tempPointAx = bottomRightAx;
+                  tempPointAy = p1y + halfWidthA * slopePrime;
+                  result[0] = tempPointAx;
+                  result[1] = tempPointAy;
+                  break;
+                case 3:
+                  tempPointAy = bottomLeftAy;
+                  tempPointAx = p1x + halfHeightA / slopePrime;
+                  result[0] = tempPointAx;
+                  result[1] = tempPointAy;
+                  break;
+                case 4:
+                  tempPointAx = bottomLeftAx;
+                  tempPointAy = p1y + -halfWidthA * slopePrime;
+                  result[0] = tempPointAx;
+                  result[1] = tempPointAy;
+                  break;
+              }
+            }
+            if (!clipPointBFound) {
+              switch (cardinalDirectionB) {
+                case 1:
+                  tempPointBy = topLeftBy;
+                  tempPointBx = p2x + -halfHeightB / slopePrime;
+                  result[2] = tempPointBx;
+                  result[3] = tempPointBy;
+                  break;
+                case 2:
+                  tempPointBx = bottomRightBx;
+                  tempPointBy = p2y + halfWidthB * slopePrime;
+                  result[2] = tempPointBx;
+                  result[3] = tempPointBy;
+                  break;
+                case 3:
+                  tempPointBy = bottomLeftBy;
+                  tempPointBx = p2x + halfHeightB / slopePrime;
+                  result[2] = tempPointBx;
+                  result[3] = tempPointBy;
+                  break;
+                case 4:
+                  tempPointBx = bottomLeftBx;
+                  tempPointBy = p2y + -halfWidthB * slopePrime;
+                  result[2] = tempPointBx;
+                  result[3] = tempPointBy;
+                  break;
+              }
+            }
+          }
+          return false;
+        };
+        IGeometry.getCardinalDirection = function(slope, slopePrime, line) {
+          if (slope > slopePrime) {
+            return line;
+          } else {
+            return 1 + line % 4;
+          }
+        };
+        IGeometry.getIntersection = function(s1, s2, f1, f2) {
+          if (f2 == null) {
+            return this.getIntersection2(s1, s2, f1);
+          }
+          var x1 = s1.x;
+          var y1 = s1.y;
+          var x2 = s2.x;
+          var y2 = s2.y;
+          var x3 = f1.x;
+          var y3 = f1.y;
+          var x4 = f2.x;
+          var y4 = f2.y;
+          var x = undefined, y = undefined;
+          var a1 = undefined, a2 = undefined, b1 = undefined, b2 = undefined, c1 = undefined, c2 = undefined;
+          var denom = undefined;
+          a1 = y2 - y1;
+          b1 = x1 - x2;
+          c1 = x2 * y1 - x1 * y2;
+          a2 = y4 - y3;
+          b2 = x3 - x4;
+          c2 = x4 * y3 - x3 * y4;
+          denom = a1 * b2 - a2 * b1;
+          if (denom === 0) {
+            return null;
+          }
+          x = (b1 * c2 - b2 * c1) / denom;
+          y = (a2 * c1 - a1 * c2) / denom;
+          return new Point2(x, y);
+        };
+        IGeometry.angleOfVector = function(Cx, Cy, Nx, Ny) {
+          var C_angle = undefined;
+          if (Cx !== Nx) {
+            C_angle = Math.atan((Ny - Cy) / (Nx - Cx));
+            if (Nx < Cx) {
+              C_angle += Math.PI;
+            } else if (Ny < Cy) {
+              C_angle += this.TWO_PI;
+            }
+          } else if (Ny < Cy) {
+            C_angle = this.ONE_AND_HALF_PI;
+          } else {
+            C_angle = this.HALF_PI;
+          }
+          return C_angle;
+        };
+        IGeometry.doIntersect = function(p1, p2, p3, p4) {
+          var a = p1.x;
+          var b = p1.y;
+          var c = p2.x;
+          var d = p2.y;
+          var p = p3.x;
+          var q = p3.y;
+          var r = p4.x;
+          var s = p4.y;
+          var det = (c - a) * (s - q) - (r - p) * (d - b);
+          if (det === 0) {
+            return false;
+          } else {
+            var lambda = ((s - q) * (r - a) + (p - r) * (s - b)) / det;
+            var gamma = ((b - d) * (r - a) + (c - a) * (s - b)) / det;
+            return 0 < lambda && lambda < 1 && 0 < gamma && gamma < 1;
+          }
+        };
+        IGeometry.HALF_PI = 0.5 * Math.PI;
+        IGeometry.ONE_AND_HALF_PI = 1.5 * Math.PI;
+        IGeometry.TWO_PI = 2 * Math.PI;
+        IGeometry.THREE_PI = 3 * Math.PI;
+        module2.exports = IGeometry;
+      },
+      function(module2, exports2, __webpack_require__) {
+        function IMath() {}
+        IMath.sign = function(value) {
+          if (value > 0) {
+            return 1;
+          } else if (value < 0) {
+            return -1;
+          } else {
+            return 0;
+          }
+        };
+        IMath.floor = function(value) {
+          return value < 0 ? Math.ceil(value) : Math.floor(value);
+        };
+        IMath.ceil = function(value) {
+          return value < 0 ? Math.floor(value) : Math.ceil(value);
+        };
+        module2.exports = IMath;
+      },
+      function(module2, exports2, __webpack_require__) {
+        function Integer() {}
+        Integer.MAX_VALUE = 2147483647;
+        Integer.MIN_VALUE = -2147483648;
+        module2.exports = Integer;
+      },
+      function(module2, exports2, __webpack_require__) {
+        var _createClass = function() {
+          function defineProperties(target, props) {
+            for (var i = 0;i < props.length; i++) {
+              var descriptor = props[i];
+              descriptor.enumerable = descriptor.enumerable || false;
+              descriptor.configurable = true;
+              if ("value" in descriptor)
+                descriptor.writable = true;
+              Object.defineProperty(target, descriptor.key, descriptor);
+            }
+          }
+          return function(Constructor, protoProps, staticProps) {
+            if (protoProps)
+              defineProperties(Constructor.prototype, protoProps);
+            if (staticProps)
+              defineProperties(Constructor, staticProps);
+            return Constructor;
+          };
+        }();
+        function _classCallCheck(instance2, Constructor) {
+          if (!(instance2 instanceof Constructor)) {
+            throw new TypeError("Cannot call a class as a function");
+          }
+        }
+        var nodeFrom = function nodeFrom2(value) {
+          return { value, next: null, prev: null };
+        };
+        var add = function add2(prev, node, next2, list) {
+          if (prev !== null) {
+            prev.next = node;
+          } else {
+            list.head = node;
+          }
+          if (next2 !== null) {
+            next2.prev = node;
+          } else {
+            list.tail = node;
+          }
+          node.prev = prev;
+          node.next = next2;
+          list.length++;
+          return node;
+        };
+        var _remove = function _remove2(node, list) {
+          var { prev, next: next2 } = node;
+          if (prev !== null) {
+            prev.next = next2;
+          } else {
+            list.head = next2;
+          }
+          if (next2 !== null) {
+            next2.prev = prev;
+          } else {
+            list.tail = prev;
+          }
+          node.prev = node.next = null;
+          list.length--;
+          return node;
+        };
+        var LinkedList = function() {
+          function LinkedList2(vals) {
+            var _this = this;
+            _classCallCheck(this, LinkedList2);
+            this.length = 0;
+            this.head = null;
+            this.tail = null;
+            if (vals != null) {
+              vals.forEach(function(v) {
+                return _this.push(v);
+              });
+            }
+          }
+          _createClass(LinkedList2, [{
+            key: "size",
+            value: function size() {
+              return this.length;
+            }
+          }, {
+            key: "insertBefore",
+            value: function insertBefore(val, otherNode) {
+              return add(otherNode.prev, nodeFrom(val), otherNode, this);
+            }
+          }, {
+            key: "insertAfter",
+            value: function insertAfter(val, otherNode) {
+              return add(otherNode, nodeFrom(val), otherNode.next, this);
+            }
+          }, {
+            key: "insertNodeBefore",
+            value: function insertNodeBefore(newNode, otherNode) {
+              return add(otherNode.prev, newNode, otherNode, this);
+            }
+          }, {
+            key: "insertNodeAfter",
+            value: function insertNodeAfter(newNode, otherNode) {
+              return add(otherNode, newNode, otherNode.next, this);
+            }
+          }, {
+            key: "push",
+            value: function push(val) {
+              return add(this.tail, nodeFrom(val), null, this);
+            }
+          }, {
+            key: "unshift",
+            value: function unshift(val) {
+              return add(null, nodeFrom(val), this.head, this);
+            }
+          }, {
+            key: "remove",
+            value: function remove(node) {
+              return _remove(node, this);
+            }
+          }, {
+            key: "pop",
+            value: function pop() {
+              return _remove(this.tail, this).value;
+            }
+          }, {
+            key: "popNode",
+            value: function popNode() {
+              return _remove(this.tail, this);
+            }
+          }, {
+            key: "shift",
+            value: function shift() {
+              return _remove(this.head, this).value;
+            }
+          }, {
+            key: "shiftNode",
+            value: function shiftNode() {
+              return _remove(this.head, this);
+            }
+          }, {
+            key: "get_object_at",
+            value: function get_object_at(index) {
+              if (index <= this.length()) {
+                var i = 1;
+                var current = this.head;
+                while (i < index) {
+                  current = current.next;
+                  i++;
+                }
+                return current.value;
+              }
+            }
+          }, {
+            key: "set_object_at",
+            value: function set_object_at(index, value) {
+              if (index <= this.length()) {
+                var i = 1;
+                var current = this.head;
+                while (i < index) {
+                  current = current.next;
+                  i++;
+                }
+                current.value = value;
+              }
+            }
+          }]);
+          return LinkedList2;
+        }();
+        module2.exports = LinkedList;
+      },
+      function(module2, exports2, __webpack_require__) {
+        function Point2(x, y, p) {
+          this.x = null;
+          this.y = null;
+          if (x == null && y == null && p == null) {
+            this.x = 0;
+            this.y = 0;
+          } else if (typeof x == "number" && typeof y == "number" && p == null) {
+            this.x = x;
+            this.y = y;
+          } else if (x.constructor.name == "Point" && y == null && p == null) {
+            p = x;
+            this.x = p.x;
+            this.y = p.y;
+          }
+        }
+        Point2.prototype.getX = function() {
+          return this.x;
+        };
+        Point2.prototype.getY = function() {
+          return this.y;
+        };
+        Point2.prototype.getLocation = function() {
+          return new Point2(this.x, this.y);
+        };
+        Point2.prototype.setLocation = function(x, y, p) {
+          if (x.constructor.name == "Point" && y == null && p == null) {
+            p = x;
+            this.setLocation(p.x, p.y);
+          } else if (typeof x == "number" && typeof y == "number" && p == null) {
+            if (parseInt(x) == x && parseInt(y) == y) {
+              this.move(x, y);
+            } else {
+              this.x = Math.floor(x + 0.5);
+              this.y = Math.floor(y + 0.5);
+            }
+          }
+        };
+        Point2.prototype.move = function(x, y) {
+          this.x = x;
+          this.y = y;
+        };
+        Point2.prototype.translate = function(dx, dy) {
+          this.x += dx;
+          this.y += dy;
+        };
+        Point2.prototype.equals = function(obj) {
+          if (obj.constructor.name == "Point") {
+            var pt = obj;
+            return this.x == pt.x && this.y == pt.y;
+          }
+          return this == obj;
+        };
+        Point2.prototype.toString = function() {
+          return new Point2().constructor.name + "[x=" + this.x + ",y=" + this.y + "]";
+        };
+        module2.exports = Point2;
+      },
+      function(module2, exports2, __webpack_require__) {
+        function RectangleD(x, y, width, height) {
+          this.x = 0;
+          this.y = 0;
+          this.width = 0;
+          this.height = 0;
+          if (x != null && y != null && width != null && height != null) {
+            this.x = x;
+            this.y = y;
+            this.width = width;
+            this.height = height;
+          }
+        }
+        RectangleD.prototype.getX = function() {
+          return this.x;
+        };
+        RectangleD.prototype.setX = function(x) {
+          this.x = x;
+        };
+        RectangleD.prototype.getY = function() {
+          return this.y;
+        };
+        RectangleD.prototype.setY = function(y) {
+          this.y = y;
+        };
+        RectangleD.prototype.getWidth = function() {
+          return this.width;
+        };
+        RectangleD.prototype.setWidth = function(width) {
+          this.width = width;
+        };
+        RectangleD.prototype.getHeight = function() {
+          return this.height;
+        };
+        RectangleD.prototype.setHeight = function(height) {
+          this.height = height;
+        };
+        RectangleD.prototype.getRight = function() {
+          return this.x + this.width;
+        };
+        RectangleD.prototype.getBottom = function() {
+          return this.y + this.height;
+        };
+        RectangleD.prototype.intersects = function(a) {
+          if (this.getRight() < a.x) {
+            return false;
+          }
+          if (this.getBottom() < a.y) {
+            return false;
+          }
+          if (a.getRight() < this.x) {
+            return false;
+          }
+          if (a.getBottom() < this.y) {
+            return false;
+          }
+          return true;
+        };
+        RectangleD.prototype.getCenterX = function() {
+          return this.x + this.width / 2;
+        };
+        RectangleD.prototype.getMinX = function() {
+          return this.getX();
+        };
+        RectangleD.prototype.getMaxX = function() {
+          return this.getX() + this.width;
+        };
+        RectangleD.prototype.getCenterY = function() {
+          return this.y + this.height / 2;
+        };
+        RectangleD.prototype.getMinY = function() {
+          return this.getY();
+        };
+        RectangleD.prototype.getMaxY = function() {
+          return this.getY() + this.height;
+        };
+        RectangleD.prototype.getWidthHalf = function() {
+          return this.width / 2;
+        };
+        RectangleD.prototype.getHeightHalf = function() {
+          return this.height / 2;
+        };
+        module2.exports = RectangleD;
+      },
+      function(module2, exports2, __webpack_require__) {
+        var _typeof = typeof Symbol === "function" && typeof Symbol.iterator === "symbol" ? function(obj) {
+          return typeof obj;
+        } : function(obj) {
+          return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj;
+        };
+        function UniqueIDGeneretor() {}
+        UniqueIDGeneretor.lastID = 0;
+        UniqueIDGeneretor.createID = function(obj) {
+          if (UniqueIDGeneretor.isPrimitive(obj)) {
+            return obj;
+          }
+          if (obj.uniqueID != null) {
+            return obj.uniqueID;
+          }
+          obj.uniqueID = UniqueIDGeneretor.getString();
+          UniqueIDGeneretor.lastID++;
+          return obj.uniqueID;
+        };
+        UniqueIDGeneretor.getString = function(id) {
+          if (id == null)
+            id = UniqueIDGeneretor.lastID;
+          return "Object#" + id + "";
+        };
+        UniqueIDGeneretor.isPrimitive = function(arg) {
+          var type = typeof arg === "undefined" ? "undefined" : _typeof(arg);
+          return arg == null || type != "object" && type != "function";
+        };
+        module2.exports = UniqueIDGeneretor;
+      },
+      function(module2, exports2, __webpack_require__) {
+        function _toConsumableArray(arr) {
+          if (Array.isArray(arr)) {
+            for (var i = 0, arr2 = Array(arr.length);i < arr.length; i++) {
+              arr2[i] = arr[i];
+            }
+            return arr2;
+          } else {
+            return Array.from(arr);
+          }
+        }
+        var LayoutConstants = __webpack_require__(0);
+        var LGraphManager = __webpack_require__(6);
+        var LNode = __webpack_require__(3);
+        var LEdge = __webpack_require__(1);
+        var LGraph = __webpack_require__(5);
+        var PointD = __webpack_require__(4);
+        var Transform = __webpack_require__(17);
+        var Emitter = __webpack_require__(27);
+        function Layout2(isRemoteUse) {
+          Emitter.call(this);
+          this.layoutQuality = LayoutConstants.QUALITY;
+          this.createBendsAsNeeded = LayoutConstants.DEFAULT_CREATE_BENDS_AS_NEEDED;
+          this.incremental = LayoutConstants.DEFAULT_INCREMENTAL;
+          this.animationOnLayout = LayoutConstants.DEFAULT_ANIMATION_ON_LAYOUT;
+          this.animationDuringLayout = LayoutConstants.DEFAULT_ANIMATION_DURING_LAYOUT;
+          this.animationPeriod = LayoutConstants.DEFAULT_ANIMATION_PERIOD;
+          this.uniformLeafNodeSizes = LayoutConstants.DEFAULT_UNIFORM_LEAF_NODE_SIZES;
+          this.edgeToDummyNodes = new Map;
+          this.graphManager = new LGraphManager(this);
+          this.isLayoutFinished = false;
+          this.isSubLayout = false;
+          this.isRemoteUse = false;
+          if (isRemoteUse != null) {
+            this.isRemoteUse = isRemoteUse;
+          }
+        }
+        Layout2.RANDOM_SEED = 1;
+        Layout2.prototype = Object.create(Emitter.prototype);
+        Layout2.prototype.getGraphManager = function() {
+          return this.graphManager;
+        };
+        Layout2.prototype.getAllNodes = function() {
+          return this.graphManager.getAllNodes();
+        };
+        Layout2.prototype.getAllEdges = function() {
+          return this.graphManager.getAllEdges();
+        };
+        Layout2.prototype.getAllNodesToApplyGravitation = function() {
+          return this.graphManager.getAllNodesToApplyGravitation();
+        };
+        Layout2.prototype.newGraphManager = function() {
+          var gm = new LGraphManager(this);
+          this.graphManager = gm;
+          return gm;
+        };
+        Layout2.prototype.newGraph = function(vGraph) {
+          return new LGraph(null, this.graphManager, vGraph);
+        };
+        Layout2.prototype.newNode = function(vNode) {
+          return new LNode(this.graphManager, vNode);
+        };
+        Layout2.prototype.newEdge = function(vEdge) {
+          return new LEdge(null, null, vEdge);
+        };
+        Layout2.prototype.checkLayoutSuccess = function() {
+          return this.graphManager.getRoot() == null || this.graphManager.getRoot().getNodes().length == 0 || this.graphManager.includesInvalidEdge();
+        };
+        Layout2.prototype.runLayout = function() {
+          this.isLayoutFinished = false;
+          if (this.tilingPreLayout) {
+            this.tilingPreLayout();
+          }
+          this.initParameters();
+          var isLayoutSuccessfull;
+          if (this.checkLayoutSuccess()) {
+            isLayoutSuccessfull = false;
+          } else {
+            isLayoutSuccessfull = this.layout();
+          }
+          if (LayoutConstants.ANIMATE === "during") {
+            return false;
+          }
+          if (isLayoutSuccessfull) {
+            if (!this.isSubLayout) {
+              this.doPostLayout();
+            }
+          }
+          if (this.tilingPostLayout) {
+            this.tilingPostLayout();
+          }
+          this.isLayoutFinished = true;
+          return isLayoutSuccessfull;
+        };
+        Layout2.prototype.doPostLayout = function() {
+          if (!this.incremental) {
+            this.transform();
+          }
+          this.update();
+        };
+        Layout2.prototype.update2 = function() {
+          if (this.createBendsAsNeeded) {
+            this.createBendpointsFromDummyNodes();
+            this.graphManager.resetAllEdges();
+          }
+          if (!this.isRemoteUse) {
+            var edge;
+            var allEdges = this.graphManager.getAllEdges();
+            for (var i = 0;i < allEdges.length; i++) {
+              edge = allEdges[i];
+            }
+            var node;
+            var nodes = this.graphManager.getRoot().getNodes();
+            for (var i = 0;i < nodes.length; i++) {
+              node = nodes[i];
+            }
+            this.update(this.graphManager.getRoot());
+          }
+        };
+        Layout2.prototype.update = function(obj) {
+          if (obj == null) {
+            this.update2();
+          } else if (obj instanceof LNode) {
+            var node = obj;
+            if (node.getChild() != null) {
+              var nodes = node.getChild().getNodes();
+              for (var i = 0;i < nodes.length; i++) {
+                update(nodes[i]);
+              }
+            }
+            if (node.vGraphObject != null) {
+              var vNode = node.vGraphObject;
+              vNode.update(node);
+            }
+          } else if (obj instanceof LEdge) {
+            var edge = obj;
+            if (edge.vGraphObject != null) {
+              var vEdge = edge.vGraphObject;
+              vEdge.update(edge);
+            }
+          } else if (obj instanceof LGraph) {
+            var graph = obj;
+            if (graph.vGraphObject != null) {
+              var vGraph = graph.vGraphObject;
+              vGraph.update(graph);
+            }
+          }
+        };
+        Layout2.prototype.initParameters = function() {
+          if (!this.isSubLayout) {
+            this.layoutQuality = LayoutConstants.QUALITY;
+            this.animationDuringLayout = LayoutConstants.DEFAULT_ANIMATION_DURING_LAYOUT;
+            this.animationPeriod = LayoutConstants.DEFAULT_ANIMATION_PERIOD;
+            this.animationOnLayout = LayoutConstants.DEFAULT_ANIMATION_ON_LAYOUT;
+            this.incremental = LayoutConstants.DEFAULT_INCREMENTAL;
+            this.createBendsAsNeeded = LayoutConstants.DEFAULT_CREATE_BENDS_AS_NEEDED;
+            this.uniformLeafNodeSizes = LayoutConstants.DEFAULT_UNIFORM_LEAF_NODE_SIZES;
+          }
+          if (this.animationDuringLayout) {
+            this.animationOnLayout = false;
+          }
+        };
+        Layout2.prototype.transform = function(newLeftTop) {
+          if (newLeftTop == undefined) {
+            this.transform(new PointD(0, 0));
+          } else {
+            var trans = new Transform;
+            var leftTop = this.graphManager.getRoot().updateLeftTop();
+            if (leftTop != null) {
+              trans.setWorldOrgX(newLeftTop.x);
+              trans.setWorldOrgY(newLeftTop.y);
+              trans.setDeviceOrgX(leftTop.x);
+              trans.setDeviceOrgY(leftTop.y);
+              var nodes = this.getAllNodes();
+              var node;
+              for (var i = 0;i < nodes.length; i++) {
+                node = nodes[i];
+                node.transform(trans);
+              }
+            }
+          }
+        };
+        Layout2.prototype.positionNodesRandomly = function(graph) {
+          if (graph == undefined) {
+            this.positionNodesRandomly(this.getGraphManager().getRoot());
+            this.getGraphManager().getRoot().updateBounds(true);
+          } else {
+            var lNode;
+            var childGraph;
+            var nodes = graph.getNodes();
+            for (var i = 0;i < nodes.length; i++) {
+              lNode = nodes[i];
+              childGraph = lNode.getChild();
+              if (childGraph == null) {
+                lNode.scatter();
+              } else if (childGraph.getNodes().length == 0) {
+                lNode.scatter();
+              } else {
+                this.positionNodesRandomly(childGraph);
+                lNode.updateBounds();
+              }
+            }
+          }
+        };
+        Layout2.prototype.getFlatForest = function() {
+          var flatForest = [];
+          var isForest = true;
+          var allNodes = this.graphManager.getRoot().getNodes();
+          var isFlat = true;
+          for (var i = 0;i < allNodes.length; i++) {
+            if (allNodes[i].getChild() != null) {
+              isFlat = false;
+            }
+          }
+          if (!isFlat) {
+            return flatForest;
+          }
+          var visited = new Set;
+          var toBeVisited = [];
+          var parents = new Map;
+          var unProcessedNodes = [];
+          unProcessedNodes = unProcessedNodes.concat(allNodes);
+          while (unProcessedNodes.length > 0 && isForest) {
+            toBeVisited.push(unProcessedNodes[0]);
+            while (toBeVisited.length > 0 && isForest) {
+              var currentNode = toBeVisited[0];
+              toBeVisited.splice(0, 1);
+              visited.add(currentNode);
+              var neighborEdges = currentNode.getEdges();
+              for (var i = 0;i < neighborEdges.length; i++) {
+                var currentNeighbor = neighborEdges[i].getOtherEnd(currentNode);
+                if (parents.get(currentNode) != currentNeighbor) {
+                  if (!visited.has(currentNeighbor)) {
+                    toBeVisited.push(currentNeighbor);
+                    parents.set(currentNeighbor, currentNode);
+                  } else {
+                    isForest = false;
+                    break;
+                  }
+                }
+              }
+            }
+            if (!isForest) {
+              flatForest = [];
+            } else {
+              var temp = [].concat(_toConsumableArray(visited));
+              flatForest.push(temp);
+              for (var i = 0;i < temp.length; i++) {
+                var value = temp[i];
+                var index = unProcessedNodes.indexOf(value);
+                if (index > -1) {
+                  unProcessedNodes.splice(index, 1);
+                }
+              }
+              visited = new Set;
+              parents = new Map;
+            }
+          }
+          return flatForest;
+        };
+        Layout2.prototype.createDummyNodesForBendpoints = function(edge) {
+          var dummyNodes = [];
+          var prev = edge.source;
+          var graph = this.graphManager.calcLowestCommonAncestor(edge.source, edge.target);
+          for (var i = 0;i < edge.bendpoints.length; i++) {
+            var dummyNode = this.newNode(null);
+            dummyNode.setRect(new Point(0, 0), new Dimension(1, 1));
+            graph.add(dummyNode);
+            var dummyEdge = this.newEdge(null);
+            this.graphManager.add(dummyEdge, prev, dummyNode);
+            dummyNodes.add(dummyNode);
+            prev = dummyNode;
+          }
+          var dummyEdge = this.newEdge(null);
+          this.graphManager.add(dummyEdge, prev, edge.target);
+          this.edgeToDummyNodes.set(edge, dummyNodes);
+          if (edge.isInterGraph()) {
+            this.graphManager.remove(edge);
+          } else {
+            graph.remove(edge);
+          }
+          return dummyNodes;
+        };
+        Layout2.prototype.createBendpointsFromDummyNodes = function() {
+          var edges = [];
+          edges = edges.concat(this.graphManager.getAllEdges());
+          edges = [].concat(_toConsumableArray(this.edgeToDummyNodes.keys())).concat(edges);
+          for (var k = 0;k < edges.length; k++) {
+            var lEdge = edges[k];
+            if (lEdge.bendpoints.length > 0) {
+              var path = this.edgeToDummyNodes.get(lEdge);
+              for (var i = 0;i < path.length; i++) {
+                var dummyNode = path[i];
+                var p = new PointD(dummyNode.getCenterX(), dummyNode.getCenterY());
+                var ebp = lEdge.bendpoints.get(i);
+                ebp.x = p.x;
+                ebp.y = p.y;
+                dummyNode.getOwner().remove(dummyNode);
+              }
+              this.graphManager.add(lEdge, lEdge.source, lEdge.target);
+            }
+          }
+        };
+        Layout2.transform = function(sliderValue, defaultValue, minDiv, maxMul) {
+          if (minDiv != null && maxMul != null) {
+            var value = defaultValue;
+            if (sliderValue <= 50) {
+              var minValue = defaultValue / minDiv;
+              value -= (defaultValue - minValue) / 50 * (50 - sliderValue);
+            } else {
+              var maxValue = defaultValue * maxMul;
+              value += (maxValue - defaultValue) / 50 * (sliderValue - 50);
+            }
+            return value;
+          } else {
+            var a, b;
+            if (sliderValue <= 50) {
+              a = 9 * defaultValue / 500;
+              b = defaultValue / 10;
+            } else {
+              a = 9 * defaultValue / 50;
+              b = -8 * defaultValue;
+            }
+            return a * sliderValue + b;
+          }
+        };
+        Layout2.findCenterOfTree = function(nodes) {
+          var list = [];
+          list = list.concat(nodes);
+          var removedNodes = [];
+          var remainingDegrees = new Map;
+          var foundCenter = false;
+          var centerNode = null;
+          if (list.length == 1 || list.length == 2) {
+            foundCenter = true;
+            centerNode = list[0];
+          }
+          for (var i = 0;i < list.length; i++) {
+            var node = list[i];
+            var degree = node.getNeighborsList().size;
+            remainingDegrees.set(node, node.getNeighborsList().size);
+            if (degree == 1) {
+              removedNodes.push(node);
+            }
+          }
+          var tempList = [];
+          tempList = tempList.concat(removedNodes);
+          while (!foundCenter) {
+            var tempList2 = [];
+            tempList2 = tempList2.concat(tempList);
+            tempList = [];
+            for (var i = 0;i < list.length; i++) {
+              var node = list[i];
+              var index = list.indexOf(node);
+              if (index >= 0) {
+                list.splice(index, 1);
+              }
+              var neighbours = node.getNeighborsList();
+              neighbours.forEach(function(neighbour) {
+                if (removedNodes.indexOf(neighbour) < 0) {
+                  var otherDegree = remainingDegrees.get(neighbour);
+                  var newDegree = otherDegree - 1;
+                  if (newDegree == 1) {
+                    tempList.push(neighbour);
+                  }
+                  remainingDegrees.set(neighbour, newDegree);
+                }
+              });
+            }
+            removedNodes = removedNodes.concat(tempList);
+            if (list.length == 1 || list.length == 2) {
+              foundCenter = true;
+              centerNode = list[0];
+            }
+          }
+          return centerNode;
+        };
+        Layout2.prototype.setGraphManager = function(gm) {
+          this.graphManager = gm;
+        };
+        module2.exports = Layout2;
+      },
+      function(module2, exports2, __webpack_require__) {
+        function RandomSeed() {}
+        RandomSeed.seed = 1;
+        RandomSeed.x = 0;
+        RandomSeed.nextDouble = function() {
+          RandomSeed.x = Math.sin(RandomSeed.seed++) * 1e4;
+          return RandomSeed.x - Math.floor(RandomSeed.x);
+        };
+        module2.exports = RandomSeed;
+      },
+      function(module2, exports2, __webpack_require__) {
+        var PointD = __webpack_require__(4);
+        function Transform(x, y) {
+          this.lworldOrgX = 0;
+          this.lworldOrgY = 0;
+          this.ldeviceOrgX = 0;
+          this.ldeviceOrgY = 0;
+          this.lworldExtX = 1;
+          this.lworldExtY = 1;
+          this.ldeviceExtX = 1;
+          this.ldeviceExtY = 1;
+        }
+        Transform.prototype.getWorldOrgX = function() {
+          return this.lworldOrgX;
+        };
+        Transform.prototype.setWorldOrgX = function(wox) {
+          this.lworldOrgX = wox;
+        };
+        Transform.prototype.getWorldOrgY = function() {
+          return this.lworldOrgY;
+        };
+        Transform.prototype.setWorldOrgY = function(woy) {
+          this.lworldOrgY = woy;
+        };
+        Transform.prototype.getWorldExtX = function() {
+          return this.lworldExtX;
+        };
+        Transform.prototype.setWorldExtX = function(wex) {
+          this.lworldExtX = wex;
+        };
+        Transform.prototype.getWorldExtY = function() {
+          return this.lworldExtY;
+        };
+        Transform.prototype.setWorldExtY = function(wey) {
+          this.lworldExtY = wey;
+        };
+        Transform.prototype.getDeviceOrgX = function() {
+          return this.ldeviceOrgX;
+        };
+        Transform.prototype.setDeviceOrgX = function(dox) {
+          this.ldeviceOrgX = dox;
+        };
+        Transform.prototype.getDeviceOrgY = function() {
+          return this.ldeviceOrgY;
+        };
+        Transform.prototype.setDeviceOrgY = function(doy) {
+          this.ldeviceOrgY = doy;
+        };
+        Transform.prototype.getDeviceExtX = function() {
+          return this.ldeviceExtX;
+        };
+        Transform.prototype.setDeviceExtX = function(dex) {
+          this.ldeviceExtX = dex;
+        };
+        Transform.prototype.getDeviceExtY = function() {
+          return this.ldeviceExtY;
+        };
+        Transform.prototype.setDeviceExtY = function(dey) {
+          this.ldeviceExtY = dey;
+        };
+        Transform.prototype.transformX = function(x) {
+          var xDevice = 0;
+          var worldExtX = this.lworldExtX;
+          if (worldExtX != 0) {
+            xDevice = this.ldeviceOrgX + (x - this.lworldOrgX) * this.ldeviceExtX / worldExtX;
+          }
+          return xDevice;
+        };
+        Transform.prototype.transformY = function(y) {
+          var yDevice = 0;
+          var worldExtY = this.lworldExtY;
+          if (worldExtY != 0) {
+            yDevice = this.ldeviceOrgY + (y - this.lworldOrgY) * this.ldeviceExtY / worldExtY;
+          }
+          return yDevice;
+        };
+        Transform.prototype.inverseTransformX = function(x) {
+          var xWorld = 0;
+          var deviceExtX = this.ldeviceExtX;
+          if (deviceExtX != 0) {
+            xWorld = this.lworldOrgX + (x - this.ldeviceOrgX) * this.lworldExtX / deviceExtX;
+          }
+          return xWorld;
+        };
+        Transform.prototype.inverseTransformY = function(y) {
+          var yWorld = 0;
+          var deviceExtY = this.ldeviceExtY;
+          if (deviceExtY != 0) {
+            yWorld = this.lworldOrgY + (y - this.ldeviceOrgY) * this.lworldExtY / deviceExtY;
+          }
+          return yWorld;
+        };
+        Transform.prototype.inverseTransformPoint = function(inPoint) {
+          var outPoint = new PointD(this.inverseTransformX(inPoint.x), this.inverseTransformY(inPoint.y));
+          return outPoint;
+        };
+        module2.exports = Transform;
+      },
+      function(module2, exports2, __webpack_require__) {
+        function _toConsumableArray(arr) {
+          if (Array.isArray(arr)) {
+            for (var i = 0, arr2 = Array(arr.length);i < arr.length; i++) {
+              arr2[i] = arr[i];
+            }
+            return arr2;
+          } else {
+            return Array.from(arr);
+          }
+        }
+        var Layout2 = __webpack_require__(15);
+        var FDLayoutConstants = __webpack_require__(7);
+        var LayoutConstants = __webpack_require__(0);
+        var IGeometry = __webpack_require__(8);
+        var IMath = __webpack_require__(9);
+        function FDLayout() {
+          Layout2.call(this);
+          this.useSmartIdealEdgeLengthCalculation = FDLayoutConstants.DEFAULT_USE_SMART_IDEAL_EDGE_LENGTH_CALCULATION;
+          this.idealEdgeLength = FDLayoutConstants.DEFAULT_EDGE_LENGTH;
+          this.springConstant = FDLayoutConstants.DEFAULT_SPRING_STRENGTH;
+          this.repulsionConstant = FDLayoutConstants.DEFAULT_REPULSION_STRENGTH;
+          this.gravityConstant = FDLayoutConstants.DEFAULT_GRAVITY_STRENGTH;
+          this.compoundGravityConstant = FDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_STRENGTH;
+          this.gravityRangeFactor = FDLayoutConstants.DEFAULT_GRAVITY_RANGE_FACTOR;
+          this.compoundGravityRangeFactor = FDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR;
+          this.displacementThresholdPerNode = 3 * FDLayoutConstants.DEFAULT_EDGE_LENGTH / 100;
+          this.coolingFactor = FDLayoutConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL;
+          this.initialCoolingFactor = FDLayoutConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL;
+          this.totalDisplacement = 0;
+          this.oldTotalDisplacement = 0;
+          this.maxIterations = FDLayoutConstants.MAX_ITERATIONS;
+        }
+        FDLayout.prototype = Object.create(Layout2.prototype);
+        for (var prop in Layout2) {
+          FDLayout[prop] = Layout2[prop];
+        }
+        FDLayout.prototype.initParameters = function() {
+          Layout2.prototype.initParameters.call(this, arguments);
+          this.totalIterations = 0;
+          this.notAnimatedIterations = 0;
+          this.useFRGridVariant = FDLayoutConstants.DEFAULT_USE_SMART_REPULSION_RANGE_CALCULATION;
+          this.grid = [];
+        };
+        FDLayout.prototype.calcIdealEdgeLengths = function() {
+          var edge;
+          var lcaDepth;
+          var source;
+          var target;
+          var sizeOfSourceInLca;
+          var sizeOfTargetInLca;
+          var allEdges = this.getGraphManager().getAllEdges();
+          for (var i = 0;i < allEdges.length; i++) {
+            edge = allEdges[i];
+            edge.idealLength = this.idealEdgeLength;
+            if (edge.isInterGraph) {
+              source = edge.getSource();
+              target = edge.getTarget();
+              sizeOfSourceInLca = edge.getSourceInLca().getEstimatedSize();
+              sizeOfTargetInLca = edge.getTargetInLca().getEstimatedSize();
+              if (this.useSmartIdealEdgeLengthCalculation) {
+                edge.idealLength += sizeOfSourceInLca + sizeOfTargetInLca - 2 * LayoutConstants.SIMPLE_NODE_SIZE;
+              }
+              lcaDepth = edge.getLca().getInclusionTreeDepth();
+              edge.idealLength += FDLayoutConstants.DEFAULT_EDGE_LENGTH * FDLayoutConstants.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR * (source.getInclusionTreeDepth() + target.getInclusionTreeDepth() - 2 * lcaDepth);
+            }
+          }
+        };
+        FDLayout.prototype.initSpringEmbedder = function() {
+          var s = this.getAllNodes().length;
+          if (this.incremental) {
+            if (s > FDLayoutConstants.ADAPTATION_LOWER_NODE_LIMIT) {
+              this.coolingFactor = Math.max(this.coolingFactor * FDLayoutConstants.COOLING_ADAPTATION_FACTOR, this.coolingFactor - (s - FDLayoutConstants.ADAPTATION_LOWER_NODE_LIMIT) / (FDLayoutConstants.ADAPTATION_UPPER_NODE_LIMIT - FDLayoutConstants.ADAPTATION_LOWER_NODE_LIMIT) * this.coolingFactor * (1 - FDLayoutConstants.COOLING_ADAPTATION_FACTOR));
+            }
+            this.maxNodeDisplacement = FDLayoutConstants.MAX_NODE_DISPLACEMENT_INCREMENTAL;
+          } else {
+            if (s > FDLayoutConstants.ADAPTATION_LOWER_NODE_LIMIT) {
+              this.coolingFactor = Math.max(FDLayoutConstants.COOLING_ADAPTATION_FACTOR, 1 - (s - FDLayoutConstants.ADAPTATION_LOWER_NODE_LIMIT) / (FDLayoutConstants.ADAPTATION_UPPER_NODE_LIMIT - FDLayoutConstants.ADAPTATION_LOWER_NODE_LIMIT) * (1 - FDLayoutConstants.COOLING_ADAPTATION_FACTOR));
+            } else {
+              this.coolingFactor = 1;
+            }
+            this.initialCoolingFactor = this.coolingFactor;
+            this.maxNodeDisplacement = FDLayoutConstants.MAX_NODE_DISPLACEMENT;
+          }
+          this.maxIterations = Math.max(this.getAllNodes().length * 5, this.maxIterations);
+          this.totalDisplacementThreshold = this.displacementThresholdPerNode * this.getAllNodes().length;
+          this.repulsionRange = this.calcRepulsionRange();
+        };
+        FDLayout.prototype.calcSpringForces = function() {
+          var lEdges = this.getAllEdges();
+          var edge;
+          for (var i = 0;i < lEdges.length; i++) {
+            edge = lEdges[i];
+            this.calcSpringForce(edge, edge.idealLength);
+          }
+        };
+        FDLayout.prototype.calcRepulsionForces = function() {
+          var gridUpdateAllowed = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+          var forceToNodeSurroundingUpdate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+          var i, j;
+          var nodeA, nodeB;
+          var lNodes = this.getAllNodes();
+          var processedNodeSet;
+          if (this.useFRGridVariant) {
+            if (this.totalIterations % FDLayoutConstants.GRID_CALCULATION_CHECK_PERIOD == 1 && gridUpdateAllowed) {
+              this.updateGrid();
+            }
+            processedNodeSet = new Set;
+            for (i = 0;i < lNodes.length; i++) {
+              nodeA = lNodes[i];
+              this.calculateRepulsionForceOfANode(nodeA, processedNodeSet, gridUpdateAllowed, forceToNodeSurroundingUpdate);
+              processedNodeSet.add(nodeA);
+            }
+          } else {
+            for (i = 0;i < lNodes.length; i++) {
+              nodeA = lNodes[i];
+              for (j = i + 1;j < lNodes.length; j++) {
+                nodeB = lNodes[j];
+                if (nodeA.getOwner() != nodeB.getOwner()) {
+                  continue;
+                }
+                this.calcRepulsionForce(nodeA, nodeB);
+              }
+            }
+          }
+        };
+        FDLayout.prototype.calcGravitationalForces = function() {
+          var node;
+          var lNodes = this.getAllNodesToApplyGravitation();
+          for (var i = 0;i < lNodes.length; i++) {
+            node = lNodes[i];
+            this.calcGravitationalForce(node);
+          }
+        };
+        FDLayout.prototype.moveNodes = function() {
+          var lNodes = this.getAllNodes();
+          var node;
+          for (var i = 0;i < lNodes.length; i++) {
+            node = lNodes[i];
+            node.move();
+          }
+        };
+        FDLayout.prototype.calcSpringForce = function(edge, idealLength) {
+          var sourceNode = edge.getSource();
+          var targetNode = edge.getTarget();
+          var length;
+          var springForce;
+          var springForceX;
+          var springForceY;
+          if (this.uniformLeafNodeSizes && sourceNode.getChild() == null && targetNode.getChild() == null) {
+            edge.updateLengthSimple();
+          } else {
+            edge.updateLength();
+            if (edge.isOverlapingSourceAndTarget) {
+              return;
+            }
+          }
+          length = edge.getLength();
+          if (length == 0)
+            return;
+          springForce = this.springConstant * (length - idealLength);
+          springForceX = springForce * (edge.lengthX / length);
+          springForceY = springForce * (edge.lengthY / length);
+          sourceNode.springForceX += springForceX;
+          sourceNode.springForceY += springForceY;
+          targetNode.springForceX -= springForceX;
+          targetNode.springForceY -= springForceY;
+        };
+        FDLayout.prototype.calcRepulsionForce = function(nodeA, nodeB) {
+          var rectA = nodeA.getRect();
+          var rectB = nodeB.getRect();
+          var overlapAmount = new Array(2);
+          var clipPoints = new Array(4);
+          var distanceX;
+          var distanceY;
+          var distanceSquared;
+          var distance;
+          var repulsionForce;
+          var repulsionForceX;
+          var repulsionForceY;
+          if (rectA.intersects(rectB)) {
+            IGeometry.calcSeparationAmount(rectA, rectB, overlapAmount, FDLayoutConstants.DEFAULT_EDGE_LENGTH / 2);
+            repulsionForceX = 2 * overlapAmount[0];
+            repulsionForceY = 2 * overlapAmount[1];
+            var childrenConstant = nodeA.noOfChildren * nodeB.noOfChildren / (nodeA.noOfChildren + nodeB.noOfChildren);
+            nodeA.repulsionForceX -= childrenConstant * repulsionForceX;
+            nodeA.repulsionForceY -= childrenConstant * repulsionForceY;
+            nodeB.repulsionForceX += childrenConstant * repulsionForceX;
+            nodeB.repulsionForceY += childrenConstant * repulsionForceY;
+          } else {
+            if (this.uniformLeafNodeSizes && nodeA.getChild() == null && nodeB.getChild() == null) {
+              distanceX = rectB.getCenterX() - rectA.getCenterX();
+              distanceY = rectB.getCenterY() - rectA.getCenterY();
+            } else {
+              IGeometry.getIntersection(rectA, rectB, clipPoints);
+              distanceX = clipPoints[2] - clipPoints[0];
+              distanceY = clipPoints[3] - clipPoints[1];
+            }
+            if (Math.abs(distanceX) < FDLayoutConstants.MIN_REPULSION_DIST) {
+              distanceX = IMath.sign(distanceX) * FDLayoutConstants.MIN_REPULSION_DIST;
+            }
+            if (Math.abs(distanceY) < FDLayoutConstants.MIN_REPULSION_DIST) {
+              distanceY = IMath.sign(distanceY) * FDLayoutConstants.MIN_REPULSION_DIST;
+            }
+            distanceSquared = distanceX * distanceX + distanceY * distanceY;
+            distance = Math.sqrt(distanceSquared);
+            repulsionForce = this.repulsionConstant * nodeA.noOfChildren * nodeB.noOfChildren / distanceSquared;
+            repulsionForceX = repulsionForce * distanceX / distance;
+            repulsionForceY = repulsionForce * distanceY / distance;
+            nodeA.repulsionForceX -= repulsionForceX;
+            nodeA.repulsionForceY -= repulsionForceY;
+            nodeB.repulsionForceX += repulsionForceX;
+            nodeB.repulsionForceY += repulsionForceY;
+          }
+        };
+        FDLayout.prototype.calcGravitationalForce = function(node) {
+          var ownerGraph;
+          var ownerCenterX;
+          var ownerCenterY;
+          var distanceX;
+          var distanceY;
+          var absDistanceX;
+          var absDistanceY;
+          var estimatedSize;
+          ownerGraph = node.getOwner();
+          ownerCenterX = (ownerGraph.getRight() + ownerGraph.getLeft()) / 2;
+          ownerCenterY = (ownerGraph.getTop() + ownerGraph.getBottom()) / 2;
+          distanceX = node.getCenterX() - ownerCenterX;
+          distanceY = node.getCenterY() - ownerCenterY;
+          absDistanceX = Math.abs(distanceX) + node.getWidth() / 2;
+          absDistanceY = Math.abs(distanceY) + node.getHeight() / 2;
+          if (node.getOwner() == this.graphManager.getRoot()) {
+            estimatedSize = ownerGraph.getEstimatedSize() * this.gravityRangeFactor;
+            if (absDistanceX > estimatedSize || absDistanceY > estimatedSize) {
+              node.gravitationForceX = -this.gravityConstant * distanceX;
+              node.gravitationForceY = -this.gravityConstant * distanceY;
+            }
+          } else {
+            estimatedSize = ownerGraph.getEstimatedSize() * this.compoundGravityRangeFactor;
+            if (absDistanceX > estimatedSize || absDistanceY > estimatedSize) {
+              node.gravitationForceX = -this.gravityConstant * distanceX * this.compoundGravityConstant;
+              node.gravitationForceY = -this.gravityConstant * distanceY * this.compoundGravityConstant;
+            }
+          }
+        };
+        FDLayout.prototype.isConverged = function() {
+          var converged;
+          var oscilating = false;
+          if (this.totalIterations > this.maxIterations / 3) {
+            oscilating = Math.abs(this.totalDisplacement - this.oldTotalDisplacement) < 2;
+          }
+          converged = this.totalDisplacement < this.totalDisplacementThreshold;
+          this.oldTotalDisplacement = this.totalDisplacement;
+          return converged || oscilating;
+        };
+        FDLayout.prototype.animate = function() {
+          if (this.animationDuringLayout && !this.isSubLayout) {
+            if (this.notAnimatedIterations == this.animationPeriod) {
+              this.update();
+              this.notAnimatedIterations = 0;
+            } else {
+              this.notAnimatedIterations++;
+            }
+          }
+        };
+        FDLayout.prototype.calcNoOfChildrenForAllNodes = function() {
+          var node;
+          var allNodes = this.graphManager.getAllNodes();
+          for (var i = 0;i < allNodes.length; i++) {
+            node = allNodes[i];
+            node.noOfChildren = node.getNoOfChildren();
+          }
+        };
+        FDLayout.prototype.calcGrid = function(graph) {
+          var sizeX = 0;
+          var sizeY = 0;
+          sizeX = parseInt(Math.ceil((graph.getRight() - graph.getLeft()) / this.repulsionRange));
+          sizeY = parseInt(Math.ceil((graph.getBottom() - graph.getTop()) / this.repulsionRange));
+          var grid = new Array(sizeX);
+          for (var i = 0;i < sizeX; i++) {
+            grid[i] = new Array(sizeY);
+          }
+          for (var i = 0;i < sizeX; i++) {
+            for (var j = 0;j < sizeY; j++) {
+              grid[i][j] = new Array;
+            }
+          }
+          return grid;
+        };
+        FDLayout.prototype.addNodeToGrid = function(v, left, top) {
+          var startX = 0;
+          var finishX = 0;
+          var startY = 0;
+          var finishY = 0;
+          startX = parseInt(Math.floor((v.getRect().x - left) / this.repulsionRange));
+          finishX = parseInt(Math.floor((v.getRect().width + v.getRect().x - left) / this.repulsionRange));
+          startY = parseInt(Math.floor((v.getRect().y - top) / this.repulsionRange));
+          finishY = parseInt(Math.floor((v.getRect().height + v.getRect().y - top) / this.repulsionRange));
+          for (var i = startX;i <= finishX; i++) {
+            for (var j = startY;j <= finishY; j++) {
+              this.grid[i][j].push(v);
+              v.setGridCoordinates(startX, finishX, startY, finishY);
+            }
+          }
+        };
+        FDLayout.prototype.updateGrid = function() {
+          var i;
+          var nodeA;
+          var lNodes = this.getAllNodes();
+          this.grid = this.calcGrid(this.graphManager.getRoot());
+          for (i = 0;i < lNodes.length; i++) {
+            nodeA = lNodes[i];
+            this.addNodeToGrid(nodeA, this.graphManager.getRoot().getLeft(), this.graphManager.getRoot().getTop());
+          }
+        };
+        FDLayout.prototype.calculateRepulsionForceOfANode = function(nodeA, processedNodeSet, gridUpdateAllowed, forceToNodeSurroundingUpdate) {
+          if (this.totalIterations % FDLayoutConstants.GRID_CALCULATION_CHECK_PERIOD == 1 && gridUpdateAllowed || forceToNodeSurroundingUpdate) {
+            var surrounding = new Set;
+            nodeA.surrounding = new Array;
+            var nodeB;
+            var grid = this.grid;
+            for (var i = nodeA.startX - 1;i < nodeA.finishX + 2; i++) {
+              for (var j = nodeA.startY - 1;j < nodeA.finishY + 2; j++) {
+                if (!(i < 0 || j < 0 || i >= grid.length || j >= grid[0].length)) {
+                  for (var k = 0;k < grid[i][j].length; k++) {
+                    nodeB = grid[i][j][k];
+                    if (nodeA.getOwner() != nodeB.getOwner() || nodeA == nodeB) {
+                      continue;
+                    }
+                    if (!processedNodeSet.has(nodeB) && !surrounding.has(nodeB)) {
+                      var distanceX = Math.abs(nodeA.getCenterX() - nodeB.getCenterX()) - (nodeA.getWidth() / 2 + nodeB.getWidth() / 2);
+                      var distanceY = Math.abs(nodeA.getCenterY() - nodeB.getCenterY()) - (nodeA.getHeight() / 2 + nodeB.getHeight() / 2);
+                      if (distanceX <= this.repulsionRange && distanceY <= this.repulsionRange) {
+                        surrounding.add(nodeB);
+                      }
+                    }
+                  }
+                }
+              }
+            }
+            nodeA.surrounding = [].concat(_toConsumableArray(surrounding));
+          }
+          for (i = 0;i < nodeA.surrounding.length; i++) {
+            this.calcRepulsionForce(nodeA, nodeA.surrounding[i]);
+          }
+        };
+        FDLayout.prototype.calcRepulsionRange = function() {
+          return 0;
+        };
+        module2.exports = FDLayout;
+      },
+      function(module2, exports2, __webpack_require__) {
+        var LEdge = __webpack_require__(1);
+        var FDLayoutConstants = __webpack_require__(7);
+        function FDLayoutEdge(source, target, vEdge) {
+          LEdge.call(this, source, target, vEdge);
+          this.idealLength = FDLayoutConstants.DEFAULT_EDGE_LENGTH;
+        }
+        FDLayoutEdge.prototype = Object.create(LEdge.prototype);
+        for (var prop in LEdge) {
+          FDLayoutEdge[prop] = LEdge[prop];
+        }
+        module2.exports = FDLayoutEdge;
+      },
+      function(module2, exports2, __webpack_require__) {
+        var LNode = __webpack_require__(3);
+        function FDLayoutNode(gm, loc, size, vNode) {
+          LNode.call(this, gm, loc, size, vNode);
+          this.springForceX = 0;
+          this.springForceY = 0;
+          this.repulsionForceX = 0;
+          this.repulsionForceY = 0;
+          this.gravitationForceX = 0;
+          this.gravitationForceY = 0;
+          this.displacementX = 0;
+          this.displacementY = 0;
+          this.startX = 0;
+          this.finishX = 0;
+          this.startY = 0;
+          this.finishY = 0;
+          this.surrounding = [];
+        }
+        FDLayoutNode.prototype = Object.create(LNode.prototype);
+        for (var prop in LNode) {
+          FDLayoutNode[prop] = LNode[prop];
+        }
+        FDLayoutNode.prototype.setGridCoordinates = function(_startX, _finishX, _startY, _finishY) {
+          this.startX = _startX;
+          this.finishX = _finishX;
+          this.startY = _startY;
+          this.finishY = _finishY;
+        };
+        module2.exports = FDLayoutNode;
+      },
+      function(module2, exports2, __webpack_require__) {
+        function DimensionD2(width, height) {
+          this.width = 0;
+          this.height = 0;
+          if (width !== null && height !== null) {
+            this.height = height;
+            this.width = width;
+          }
+        }
+        DimensionD2.prototype.getWidth = function() {
+          return this.width;
+        };
+        DimensionD2.prototype.setWidth = function(width) {
+          this.width = width;
+        };
+        DimensionD2.prototype.getHeight = function() {
+          return this.height;
+        };
+        DimensionD2.prototype.setHeight = function(height) {
+          this.height = height;
+        };
+        module2.exports = DimensionD2;
+      },
+      function(module2, exports2, __webpack_require__) {
+        var UniqueIDGeneretor = __webpack_require__(14);
+        function HashMap() {
+          this.map = {};
+          this.keys = [];
+        }
+        HashMap.prototype.put = function(key, value) {
+          var theId = UniqueIDGeneretor.createID(key);
+          if (!this.contains(theId)) {
+            this.map[theId] = value;
+            this.keys.push(key);
+          }
+        };
+        HashMap.prototype.contains = function(key) {
+          var theId = UniqueIDGeneretor.createID(key);
+          return this.map[key] != null;
+        };
+        HashMap.prototype.get = function(key) {
+          var theId = UniqueIDGeneretor.createID(key);
+          return this.map[theId];
+        };
+        HashMap.prototype.keySet = function() {
+          return this.keys;
+        };
+        module2.exports = HashMap;
+      },
+      function(module2, exports2, __webpack_require__) {
+        var UniqueIDGeneretor = __webpack_require__(14);
+        function HashSet() {
+          this.set = {};
+        }
+        HashSet.prototype.add = function(obj) {
+          var theId = UniqueIDGeneretor.createID(obj);
+          if (!this.contains(theId))
+            this.set[theId] = obj;
+        };
+        HashSet.prototype.remove = function(obj) {
+          delete this.set[UniqueIDGeneretor.createID(obj)];
+        };
+        HashSet.prototype.clear = function() {
+          this.set = {};
+        };
+        HashSet.prototype.contains = function(obj) {
+          return this.set[UniqueIDGeneretor.createID(obj)] == obj;
+        };
+        HashSet.prototype.isEmpty = function() {
+          return this.size() === 0;
+        };
+        HashSet.prototype.size = function() {
+          return Object.keys(this.set).length;
+        };
+        HashSet.prototype.addAllTo = function(list) {
+          var keys = Object.keys(this.set);
+          var length = keys.length;
+          for (var i = 0;i < length; i++) {
+            list.push(this.set[keys[i]]);
+          }
+        };
+        HashSet.prototype.size = function() {
+          return Object.keys(this.set).length;
+        };
+        HashSet.prototype.addAll = function(list) {
+          var s = list.length;
+          for (var i = 0;i < s; i++) {
+            var v = list[i];
+            this.add(v);
+          }
+        };
+        module2.exports = HashSet;
+      },
+      function(module2, exports2, __webpack_require__) {
+        var _createClass = function() {
+          function defineProperties(target, props) {
+            for (var i = 0;i < props.length; i++) {
+              var descriptor = props[i];
+              descriptor.enumerable = descriptor.enumerable || false;
+              descriptor.configurable = true;
+              if ("value" in descriptor)
+                descriptor.writable = true;
+              Object.defineProperty(target, descriptor.key, descriptor);
+            }
+          }
+          return function(Constructor, protoProps, staticProps) {
+            if (protoProps)
+              defineProperties(Constructor.prototype, protoProps);
+            if (staticProps)
+              defineProperties(Constructor, staticProps);
+            return Constructor;
+          };
+        }();
+        function _classCallCheck(instance2, Constructor) {
+          if (!(instance2 instanceof Constructor)) {
+            throw new TypeError("Cannot call a class as a function");
+          }
+        }
+        var LinkedList = __webpack_require__(11);
+        var Quicksort = function() {
+          function Quicksort2(A, compareFunction) {
+            _classCallCheck(this, Quicksort2);
+            if (compareFunction !== null || compareFunction !== undefined)
+              this.compareFunction = this._defaultCompareFunction;
+            var length = undefined;
+            if (A instanceof LinkedList)
+              length = A.size();
+            else
+              length = A.length;
+            this._quicksort(A, 0, length - 1);
+          }
+          _createClass(Quicksort2, [{
+            key: "_quicksort",
+            value: function _quicksort(A, p, r) {
+              if (p < r) {
+                var q = this._partition(A, p, r);
+                this._quicksort(A, p, q);
+                this._quicksort(A, q + 1, r);
+              }
+            }
+          }, {
+            key: "_partition",
+            value: function _partition(A, p, r) {
+              var x = this._get(A, p);
+              var i = p;
+              var j = r;
+              while (true) {
+                while (this.compareFunction(x, this._get(A, j))) {
+                  j--;
+                }
+                while (this.compareFunction(this._get(A, i), x)) {
+                  i++;
+                }
+                if (i < j) {
+                  this._swap(A, i, j);
+                  i++;
+                  j--;
+                } else
+                  return j;
+              }
+            }
+          }, {
+            key: "_get",
+            value: function _get(object, index) {
+              if (object instanceof LinkedList)
+                return object.get_object_at(index);
+              else
+                return object[index];
+            }
+          }, {
+            key: "_set",
+            value: function _set(object, index, value) {
+              if (object instanceof LinkedList)
+                object.set_object_at(index, value);
+              else
+                object[index] = value;
+            }
+          }, {
+            key: "_swap",
+            value: function _swap(A, i, j) {
+              var temp = this._get(A, i);
+              this._set(A, i, this._get(A, j));
+              this._set(A, j, temp);
+            }
+          }, {
+            key: "_defaultCompareFunction",
+            value: function _defaultCompareFunction(a, b) {
+              return b > a;
+            }
+          }]);
+          return Quicksort2;
+        }();
+        module2.exports = Quicksort;
+      },
+      function(module2, exports2, __webpack_require__) {
+        var _createClass = function() {
+          function defineProperties(target, props) {
+            for (var i = 0;i < props.length; i++) {
+              var descriptor = props[i];
+              descriptor.enumerable = descriptor.enumerable || false;
+              descriptor.configurable = true;
+              if ("value" in descriptor)
+                descriptor.writable = true;
+              Object.defineProperty(target, descriptor.key, descriptor);
+            }
+          }
+          return function(Constructor, protoProps, staticProps) {
+            if (protoProps)
+              defineProperties(Constructor.prototype, protoProps);
+            if (staticProps)
+              defineProperties(Constructor, staticProps);
+            return Constructor;
+          };
+        }();
+        function _classCallCheck(instance2, Constructor) {
+          if (!(instance2 instanceof Constructor)) {
+            throw new TypeError("Cannot call a class as a function");
+          }
+        }
+        var NeedlemanWunsch = function() {
+          function NeedlemanWunsch2(sequence1, sequence2) {
+            var match_score = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+            var mismatch_penalty = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : -1;
+            var gap_penalty = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : -1;
+            _classCallCheck(this, NeedlemanWunsch2);
+            this.sequence1 = sequence1;
+            this.sequence2 = sequence2;
+            this.match_score = match_score;
+            this.mismatch_penalty = mismatch_penalty;
+            this.gap_penalty = gap_penalty;
+            this.iMax = sequence1.length + 1;
+            this.jMax = sequence2.length + 1;
+            this.grid = new Array(this.iMax);
+            for (var i = 0;i < this.iMax; i++) {
+              this.grid[i] = new Array(this.jMax);
+              for (var j = 0;j < this.jMax; j++) {
+                this.grid[i][j] = 0;
+              }
+            }
+            this.tracebackGrid = new Array(this.iMax);
+            for (var _i = 0;_i < this.iMax; _i++) {
+              this.tracebackGrid[_i] = new Array(this.jMax);
+              for (var _j = 0;_j < this.jMax; _j++) {
+                this.tracebackGrid[_i][_j] = [null, null, null];
+              }
+            }
+            this.alignments = [];
+            this.score = -1;
+            this.computeGrids();
+          }
+          _createClass(NeedlemanWunsch2, [{
+            key: "getScore",
+            value: function getScore() {
+              return this.score;
+            }
+          }, {
+            key: "getAlignments",
+            value: function getAlignments() {
+              return this.alignments;
+            }
+          }, {
+            key: "computeGrids",
+            value: function computeGrids() {
+              for (var j = 1;j < this.jMax; j++) {
+                this.grid[0][j] = this.grid[0][j - 1] + this.gap_penalty;
+                this.tracebackGrid[0][j] = [false, false, true];
+              }
+              for (var i = 1;i < this.iMax; i++) {
+                this.grid[i][0] = this.grid[i - 1][0] + this.gap_penalty;
+                this.tracebackGrid[i][0] = [false, true, false];
+              }
+              for (var _i2 = 1;_i2 < this.iMax; _i2++) {
+                for (var _j2 = 1;_j2 < this.jMax; _j2++) {
+                  var diag = undefined;
+                  if (this.sequence1[_i2 - 1] === this.sequence2[_j2 - 1])
+                    diag = this.grid[_i2 - 1][_j2 - 1] + this.match_score;
+                  else
+                    diag = this.grid[_i2 - 1][_j2 - 1] + this.mismatch_penalty;
+                  var up = this.grid[_i2 - 1][_j2] + this.gap_penalty;
+                  var left = this.grid[_i2][_j2 - 1] + this.gap_penalty;
+                  var maxOf = [diag, up, left];
+                  var indices = this.arrayAllMaxIndexes(maxOf);
+                  this.grid[_i2][_j2] = maxOf[indices[0]];
+                  this.tracebackGrid[_i2][_j2] = [indices.includes(0), indices.includes(1), indices.includes(2)];
+                }
+              }
+              this.score = this.grid[this.iMax - 1][this.jMax - 1];
+            }
+          }, {
+            key: "alignmentTraceback",
+            value: function alignmentTraceback() {
+              var inProcessAlignments = [];
+              inProcessAlignments.push({
+                pos: [this.sequence1.length, this.sequence2.length],
+                seq1: "",
+                seq2: ""
+              });
+              while (inProcessAlignments[0]) {
+                var current = inProcessAlignments[0];
+                var directions = this.tracebackGrid[current.pos[0]][current.pos[1]];
+                if (directions[0]) {
+                  inProcessAlignments.push({
+                    pos: [current.pos[0] - 1, current.pos[1] - 1],
+                    seq1: this.sequence1[current.pos[0] - 1] + current.seq1,
+                    seq2: this.sequence2[current.pos[1] - 1] + current.seq2
+                  });
+                }
+                if (directions[1]) {
+                  inProcessAlignments.push({
+                    pos: [current.pos[0] - 1, current.pos[1]],
+                    seq1: this.sequence1[current.pos[0] - 1] + current.seq1,
+                    seq2: "-" + current.seq2
+                  });
+                }
+                if (directions[2]) {
+                  inProcessAlignments.push({
+                    pos: [current.pos[0], current.pos[1] - 1],
+                    seq1: "-" + current.seq1,
+                    seq2: this.sequence2[current.pos[1] - 1] + current.seq2
+                  });
+                }
+                if (current.pos[0] === 0 && current.pos[1] === 0)
+                  this.alignments.push({
+                    sequence1: current.seq1,
+                    sequence2: current.seq2
+                  });
+                inProcessAlignments.shift();
+              }
+              return this.alignments;
+            }
+          }, {
+            key: "getAllIndexes",
+            value: function getAllIndexes(arr, val) {
+              var indexes = [], i = -1;
+              while ((i = arr.indexOf(val, i + 1)) !== -1) {
+                indexes.push(i);
+              }
+              return indexes;
+            }
+          }, {
+            key: "arrayAllMaxIndexes",
+            value: function arrayAllMaxIndexes(array) {
+              return this.getAllIndexes(array, Math.max.apply(null, array));
+            }
+          }]);
+          return NeedlemanWunsch2;
+        }();
+        module2.exports = NeedlemanWunsch;
+      },
+      function(module2, exports2, __webpack_require__) {
+        var layoutBase = function layoutBase2() {
+          return;
+        };
+        layoutBase.FDLayout = __webpack_require__(18);
+        layoutBase.FDLayoutConstants = __webpack_require__(7);
+        layoutBase.FDLayoutEdge = __webpack_require__(19);
+        layoutBase.FDLayoutNode = __webpack_require__(20);
+        layoutBase.DimensionD = __webpack_require__(21);
+        layoutBase.HashMap = __webpack_require__(22);
+        layoutBase.HashSet = __webpack_require__(23);
+        layoutBase.IGeometry = __webpack_require__(8);
+        layoutBase.IMath = __webpack_require__(9);
+        layoutBase.Integer = __webpack_require__(10);
+        layoutBase.Point = __webpack_require__(12);
+        layoutBase.PointD = __webpack_require__(4);
+        layoutBase.RandomSeed = __webpack_require__(16);
+        layoutBase.RectangleD = __webpack_require__(13);
+        layoutBase.Transform = __webpack_require__(17);
+        layoutBase.UniqueIDGeneretor = __webpack_require__(14);
+        layoutBase.Quicksort = __webpack_require__(24);
+        layoutBase.LinkedList = __webpack_require__(11);
+        layoutBase.LGraphObject = __webpack_require__(2);
+        layoutBase.LGraph = __webpack_require__(5);
+        layoutBase.LEdge = __webpack_require__(1);
+        layoutBase.LGraphManager = __webpack_require__(6);
+        layoutBase.LNode = __webpack_require__(3);
+        layoutBase.Layout = __webpack_require__(15);
+        layoutBase.LayoutConstants = __webpack_require__(0);
+        layoutBase.NeedlemanWunsch = __webpack_require__(25);
+        module2.exports = layoutBase;
+      },
+      function(module2, exports2, __webpack_require__) {
+        function Emitter() {
+          this.listeners = [];
+        }
+        var p = Emitter.prototype;
+        p.addListener = function(event, callback) {
+          this.listeners.push({
+            event,
+            callback
+          });
+        };
+        p.removeListener = function(event, callback) {
+          for (var i = this.listeners.length;i >= 0; i--) {
+            var l = this.listeners[i];
+            if (l.event === event && l.callback === callback) {
+              this.listeners.splice(i, 1);
+            }
+          }
+        };
+        p.emit = function(event, data) {
+          for (var i = 0;i < this.listeners.length; i++) {
+            var l = this.listeners[i];
+            if (event === l.event) {
+              l.callback(data);
+            }
+          }
+        };
+        module2.exports = Emitter;
+      }
+    ]);
+  });
+});
+
+// node_modules/cose-base/cose-base.js
+var require_cose_base = __commonJS(function(exports, module) {
+  (function webpackUniversalModuleDefinition(root, factory) {
+    if (typeof exports === "object" && typeof module === "object")
+      module.exports = factory(require_layout_base());
+    else if (typeof define === "function" && define.amd)
+      define(["layout-base"], factory);
+    else if (typeof exports === "object")
+      exports["coseBase"] = factory(require_layout_base());
+    else
+      root["coseBase"] = factory(root["layoutBase"]);
+  })(exports, function(__WEBPACK_EXTERNAL_MODULE_0__) {
+    return function(modules) {
+      var installedModules = {};
+      function __webpack_require__(moduleId) {
+        if (installedModules[moduleId]) {
+          return installedModules[moduleId].exports;
+        }
+        var module2 = installedModules[moduleId] = {
+          i: moduleId,
+          l: false,
+          exports: {}
+        };
+        modules[moduleId].call(module2.exports, module2, module2.exports, __webpack_require__);
+        module2.l = true;
+        return module2.exports;
+      }
+      __webpack_require__.m = modules;
+      __webpack_require__.c = installedModules;
+      __webpack_require__.i = function(value) {
+        return value;
+      };
+      __webpack_require__.d = function(exports2, name, getter) {
+        if (!__webpack_require__.o(exports2, name)) {
+          Object.defineProperty(exports2, name, {
+            configurable: false,
+            enumerable: true,
+            get: getter
+          });
+        }
+      };
+      __webpack_require__.n = function(module2) {
+        var getter = module2 && module2.__esModule ? function getDefault() {
+          return module2["default"];
+        } : function getModuleExports() {
+          return module2;
+        };
+        __webpack_require__.d(getter, "a", getter);
+        return getter;
+      };
+      __webpack_require__.o = function(object, property) {
+        return Object.prototype.hasOwnProperty.call(object, property);
+      };
+      __webpack_require__.p = "";
+      return __webpack_require__(__webpack_require__.s = 7);
+    }([
+      function(module2, exports2) {
+        module2.exports = __WEBPACK_EXTERNAL_MODULE_0__;
+      },
+      function(module2, exports2, __webpack_require__) {
+        var FDLayoutConstants = __webpack_require__(0).FDLayoutConstants;
+        function CoSEConstants() {}
+        for (var prop in FDLayoutConstants) {
+          CoSEConstants[prop] = FDLayoutConstants[prop];
+        }
+        CoSEConstants.DEFAULT_USE_MULTI_LEVEL_SCALING = false;
+        CoSEConstants.DEFAULT_RADIAL_SEPARATION = FDLayoutConstants.DEFAULT_EDGE_LENGTH;
+        CoSEConstants.DEFAULT_COMPONENT_SEPERATION = 60;
+        CoSEConstants.TILE = true;
+        CoSEConstants.TILING_PADDING_VERTICAL = 10;
+        CoSEConstants.TILING_PADDING_HORIZONTAL = 10;
+        CoSEConstants.TREE_REDUCTION_ON_INCREMENTAL = false;
+        module2.exports = CoSEConstants;
+      },
+      function(module2, exports2, __webpack_require__) {
+        var FDLayoutEdge = __webpack_require__(0).FDLayoutEdge;
+        function CoSEEdge(source, target, vEdge) {
+          FDLayoutEdge.call(this, source, target, vEdge);
+        }
+        CoSEEdge.prototype = Object.create(FDLayoutEdge.prototype);
+        for (var prop in FDLayoutEdge) {
+          CoSEEdge[prop] = FDLayoutEdge[prop];
+        }
+        module2.exports = CoSEEdge;
+      },
+      function(module2, exports2, __webpack_require__) {
+        var LGraph = __webpack_require__(0).LGraph;
+        function CoSEGraph(parent, graphMgr, vGraph) {
+          LGraph.call(this, parent, graphMgr, vGraph);
+        }
+        CoSEGraph.prototype = Object.create(LGraph.prototype);
+        for (var prop in LGraph) {
+          CoSEGraph[prop] = LGraph[prop];
+        }
+        module2.exports = CoSEGraph;
+      },
+      function(module2, exports2, __webpack_require__) {
+        var LGraphManager = __webpack_require__(0).LGraphManager;
+        function CoSEGraphManager(layout) {
+          LGraphManager.call(this, layout);
+        }
+        CoSEGraphManager.prototype = Object.create(LGraphManager.prototype);
+        for (var prop in LGraphManager) {
+          CoSEGraphManager[prop] = LGraphManager[prop];
+        }
+        module2.exports = CoSEGraphManager;
+      },
+      function(module2, exports2, __webpack_require__) {
+        var FDLayoutNode = __webpack_require__(0).FDLayoutNode;
+        var IMath = __webpack_require__(0).IMath;
+        function CoSENode(gm, loc, size, vNode) {
+          FDLayoutNode.call(this, gm, loc, size, vNode);
+        }
+        CoSENode.prototype = Object.create(FDLayoutNode.prototype);
+        for (var prop in FDLayoutNode) {
+          CoSENode[prop] = FDLayoutNode[prop];
+        }
+        CoSENode.prototype.move = function() {
+          var layout = this.graphManager.getLayout();
+          this.displacementX = layout.coolingFactor * (this.springForceX + this.repulsionForceX + this.gravitationForceX) / this.noOfChildren;
+          this.displacementY = layout.coolingFactor * (this.springForceY + this.repulsionForceY + this.gravitationForceY) / this.noOfChildren;
+          if (Math.abs(this.displacementX) > layout.coolingFactor * layout.maxNodeDisplacement) {
+            this.displacementX = layout.coolingFactor * layout.maxNodeDisplacement * IMath.sign(this.displacementX);
+          }
+          if (Math.abs(this.displacementY) > layout.coolingFactor * layout.maxNodeDisplacement) {
+            this.displacementY = layout.coolingFactor * layout.maxNodeDisplacement * IMath.sign(this.displacementY);
+          }
+          if (this.child == null) {
+            this.moveBy(this.displacementX, this.displacementY);
+          } else if (this.child.getNodes().length == 0) {
+            this.moveBy(this.displacementX, this.displacementY);
+          } else {
+            this.propogateDisplacementToChildren(this.displacementX, this.displacementY);
+          }
+          layout.totalDisplacement += Math.abs(this.displacementX) + Math.abs(this.displacementY);
+          this.springForceX = 0;
+          this.springForceY = 0;
+          this.repulsionForceX = 0;
+          this.repulsionForceY = 0;
+          this.gravitationForceX = 0;
+          this.gravitationForceY = 0;
+          this.displacementX = 0;
+          this.displacementY = 0;
+        };
+        CoSENode.prototype.propogateDisplacementToChildren = function(dX, dY) {
+          var nodes = this.getChild().getNodes();
+          var node;
+          for (var i = 0;i < nodes.length; i++) {
+            node = nodes[i];
+            if (node.getChild() == null) {
+              node.moveBy(dX, dY);
+              node.displacementX += dX;
+              node.displacementY += dY;
+            } else {
+              node.propogateDisplacementToChildren(dX, dY);
+            }
+          }
+        };
+        CoSENode.prototype.setPred1 = function(pred12) {
+          this.pred1 = pred12;
+        };
+        CoSENode.prototype.getPred1 = function() {
+          return pred1;
+        };
+        CoSENode.prototype.getPred2 = function() {
+          return pred2;
+        };
+        CoSENode.prototype.setNext = function(next2) {
+          this.next = next2;
+        };
+        CoSENode.prototype.getNext = function() {
+          return next;
+        };
+        CoSENode.prototype.setProcessed = function(processed2) {
+          this.processed = processed2;
+        };
+        CoSENode.prototype.isProcessed = function() {
+          return processed;
+        };
+        module2.exports = CoSENode;
+      },
+      function(module2, exports2, __webpack_require__) {
+        var FDLayout = __webpack_require__(0).FDLayout;
+        var CoSEGraphManager = __webpack_require__(4);
+        var CoSEGraph = __webpack_require__(3);
+        var CoSENode = __webpack_require__(5);
+        var CoSEEdge = __webpack_require__(2);
+        var CoSEConstants = __webpack_require__(1);
+        var FDLayoutConstants = __webpack_require__(0).FDLayoutConstants;
+        var LayoutConstants = __webpack_require__(0).LayoutConstants;
+        var Point2 = __webpack_require__(0).Point;
+        var PointD = __webpack_require__(0).PointD;
+        var Layout2 = __webpack_require__(0).Layout;
+        var Integer = __webpack_require__(0).Integer;
+        var IGeometry = __webpack_require__(0).IGeometry;
+        var LGraph = __webpack_require__(0).LGraph;
+        var Transform = __webpack_require__(0).Transform;
+        function CoSELayout() {
+          FDLayout.call(this);
+          this.toBeTiled = {};
+        }
+        CoSELayout.prototype = Object.create(FDLayout.prototype);
+        for (var prop in FDLayout) {
+          CoSELayout[prop] = FDLayout[prop];
+        }
+        CoSELayout.prototype.newGraphManager = function() {
+          var gm = new CoSEGraphManager(this);
+          this.graphManager = gm;
+          return gm;
+        };
+        CoSELayout.prototype.newGraph = function(vGraph) {
+          return new CoSEGraph(null, this.graphManager, vGraph);
+        };
+        CoSELayout.prototype.newNode = function(vNode) {
+          return new CoSENode(this.graphManager, vNode);
+        };
+        CoSELayout.prototype.newEdge = function(vEdge) {
+          return new CoSEEdge(null, null, vEdge);
+        };
+        CoSELayout.prototype.initParameters = function() {
+          FDLayout.prototype.initParameters.call(this, arguments);
+          if (!this.isSubLayout) {
+            if (CoSEConstants.DEFAULT_EDGE_LENGTH < 10) {
+              this.idealEdgeLength = 10;
+            } else {
+              this.idealEdgeLength = CoSEConstants.DEFAULT_EDGE_LENGTH;
+            }
+            this.useSmartIdealEdgeLengthCalculation = CoSEConstants.DEFAULT_USE_SMART_IDEAL_EDGE_LENGTH_CALCULATION;
+            this.springConstant = FDLayoutConstants.DEFAULT_SPRING_STRENGTH;
+            this.repulsionConstant = FDLayoutConstants.DEFAULT_REPULSION_STRENGTH;
+            this.gravityConstant = FDLayoutConstants.DEFAULT_GRAVITY_STRENGTH;
+            this.compoundGravityConstant = FDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_STRENGTH;
+            this.gravityRangeFactor = FDLayoutConstants.DEFAULT_GRAVITY_RANGE_FACTOR;
+            this.compoundGravityRangeFactor = FDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR;
+            this.prunedNodesAll = [];
+            this.growTreeIterations = 0;
+            this.afterGrowthIterations = 0;
+            this.isTreeGrowing = false;
+            this.isGrowthFinished = false;
+            this.coolingCycle = 0;
+            this.maxCoolingCycle = this.maxIterations / FDLayoutConstants.CONVERGENCE_CHECK_PERIOD;
+            this.finalTemperature = FDLayoutConstants.CONVERGENCE_CHECK_PERIOD / this.maxIterations;
+            this.coolingAdjuster = 1;
+          }
+        };
+        CoSELayout.prototype.layout = function() {
+          var createBendsAsNeeded = LayoutConstants.DEFAULT_CREATE_BENDS_AS_NEEDED;
+          if (createBendsAsNeeded) {
+            this.createBendpoints();
+            this.graphManager.resetAllEdges();
+          }
+          this.level = 0;
+          return this.classicLayout();
+        };
+        CoSELayout.prototype.classicLayout = function() {
+          this.nodesWithGravity = this.calculateNodesToApplyGravitationTo();
+          this.graphManager.setAllNodesToApplyGravitation(this.nodesWithGravity);
+          this.calcNoOfChildrenForAllNodes();
+          this.graphManager.calcLowestCommonAncestors();
+          this.graphManager.calcInclusionTreeDepths();
+          this.graphManager.getRoot().calcEstimatedSize();
+          this.calcIdealEdgeLengths();
+          if (!this.incremental) {
+            var forest = this.getFlatForest();
+            if (forest.length > 0) {
+              this.positionNodesRadially(forest);
+            } else {
+              this.reduceTrees();
+              this.graphManager.resetAllNodesToApplyGravitation();
+              var allNodes = new Set(this.getAllNodes());
+              var intersection = this.nodesWithGravity.filter(function(x) {
+                return allNodes.has(x);
+              });
+              this.graphManager.setAllNodesToApplyGravitation(intersection);
+              this.positionNodesRandomly();
+            }
+          } else {
+            if (CoSEConstants.TREE_REDUCTION_ON_INCREMENTAL) {
+              this.reduceTrees();
+              this.graphManager.resetAllNodesToApplyGravitation();
+              var allNodes = new Set(this.getAllNodes());
+              var intersection = this.nodesWithGravity.filter(function(x) {
+                return allNodes.has(x);
+              });
+              this.graphManager.setAllNodesToApplyGravitation(intersection);
+            }
+          }
+          this.initSpringEmbedder();
+          this.runSpringEmbedder();
+          return true;
+        };
+        CoSELayout.prototype.tick = function() {
+          this.totalIterations++;
+          if (this.totalIterations === this.maxIterations && !this.isTreeGrowing && !this.isGrowthFinished) {
+            if (this.prunedNodesAll.length > 0) {
+              this.isTreeGrowing = true;
+            } else {
+              return true;
+            }
+          }
+          if (this.totalIterations % FDLayoutConstants.CONVERGENCE_CHECK_PERIOD == 0 && !this.isTreeGrowing && !this.isGrowthFinished) {
+            if (this.isConverged()) {
+              if (this.prunedNodesAll.length > 0) {
+                this.isTreeGrowing = true;
+              } else {
+                return true;
+              }
+            }
+            this.coolingCycle++;
+            if (this.layoutQuality == 0) {
+              this.coolingAdjuster = this.coolingCycle;
+            } else if (this.layoutQuality == 1) {
+              this.coolingAdjuster = this.coolingCycle / 3;
+            }
+            this.coolingFactor = Math.max(this.initialCoolingFactor - Math.pow(this.coolingCycle, Math.log(100 * (this.initialCoolingFactor - this.finalTemperature)) / Math.log(this.maxCoolingCycle)) / 100 * this.coolingAdjuster, this.finalTemperature);
+            this.animationPeriod = Math.ceil(this.initialAnimationPeriod * Math.sqrt(this.coolingFactor));
+          }
+          if (this.isTreeGrowing) {
+            if (this.growTreeIterations % 10 == 0) {
+              if (this.prunedNodesAll.length > 0) {
+                this.graphManager.updateBounds();
+                this.updateGrid();
+                this.growTree(this.prunedNodesAll);
+                this.graphManager.resetAllNodesToApplyGravitation();
+                var allNodes = new Set(this.getAllNodes());
+                var intersection = this.nodesWithGravity.filter(function(x) {
+                  return allNodes.has(x);
+                });
+                this.graphManager.setAllNodesToApplyGravitation(intersection);
+                this.graphManager.updateBounds();
+                this.updateGrid();
+                this.coolingFactor = FDLayoutConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL;
+              } else {
+                this.isTreeGrowing = false;
+                this.isGrowthFinished = true;
+              }
+            }
+            this.growTreeIterations++;
+          }
+          if (this.isGrowthFinished) {
+            if (this.isConverged()) {
+              return true;
+            }
+            if (this.afterGrowthIterations % 10 == 0) {
+              this.graphManager.updateBounds();
+              this.updateGrid();
+            }
+            this.coolingFactor = FDLayoutConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL * ((100 - this.afterGrowthIterations) / 100);
+            this.afterGrowthIterations++;
+          }
+          var gridUpdateAllowed = !this.isTreeGrowing && !this.isGrowthFinished;
+          var forceToNodeSurroundingUpdate = this.growTreeIterations % 10 == 1 && this.isTreeGrowing || this.afterGrowthIterations % 10 == 1 && this.isGrowthFinished;
+          this.totalDisplacement = 0;
+          this.graphManager.updateBounds();
+          this.calcSpringForces();
+          this.calcRepulsionForces(gridUpdateAllowed, forceToNodeSurroundingUpdate);
+          this.calcGravitationalForces();
+          this.moveNodes();
+          this.animate();
+          return false;
+        };
+        CoSELayout.prototype.getPositionsData = function() {
+          var allNodes = this.graphManager.getAllNodes();
+          var pData = {};
+          for (var i = 0;i < allNodes.length; i++) {
+            var rect = allNodes[i].rect;
+            var id = allNodes[i].id;
+            pData[id] = {
+              id,
+              x: rect.getCenterX(),
+              y: rect.getCenterY(),
+              w: rect.width,
+              h: rect.height
+            };
+          }
+          return pData;
+        };
+        CoSELayout.prototype.runSpringEmbedder = function() {
+          this.initialAnimationPeriod = 25;
+          this.animationPeriod = this.initialAnimationPeriod;
+          var layoutEnded = false;
+          if (FDLayoutConstants.ANIMATE === "during") {
+            this.emit("layoutstarted");
+          } else {
+            while (!layoutEnded) {
+              layoutEnded = this.tick();
+            }
+            this.graphManager.updateBounds();
+          }
+        };
+        CoSELayout.prototype.calculateNodesToApplyGravitationTo = function() {
+          var nodeList = [];
+          var graph;
+          var graphs = this.graphManager.getGraphs();
+          var size = graphs.length;
+          var i;
+          for (i = 0;i < size; i++) {
+            graph = graphs[i];
+            graph.updateConnected();
+            if (!graph.isConnected) {
+              nodeList = nodeList.concat(graph.getNodes());
+            }
+          }
+          return nodeList;
+        };
+        CoSELayout.prototype.createBendpoints = function() {
+          var edges = [];
+          edges = edges.concat(this.graphManager.getAllEdges());
+          var visited = new Set;
+          var i;
+          for (i = 0;i < edges.length; i++) {
+            var edge = edges[i];
+            if (!visited.has(edge)) {
+              var source = edge.getSource();
+              var target = edge.getTarget();
+              if (source == target) {
+                edge.getBendpoints().push(new PointD);
+                edge.getBendpoints().push(new PointD);
+                this.createDummyNodesForBendpoints(edge);
+                visited.add(edge);
+              } else {
+                var edgeList = [];
+                edgeList = edgeList.concat(source.getEdgeListToNode(target));
+                edgeList = edgeList.concat(target.getEdgeListToNode(source));
+                if (!visited.has(edgeList[0])) {
+                  if (edgeList.length > 1) {
+                    var k;
+                    for (k = 0;k < edgeList.length; k++) {
+                      var multiEdge = edgeList[k];
+                      multiEdge.getBendpoints().push(new PointD);
+                      this.createDummyNodesForBendpoints(multiEdge);
+                    }
+                  }
+                  edgeList.forEach(function(edge2) {
+                    visited.add(edge2);
+                  });
+                }
+              }
+            }
+            if (visited.size == edges.length) {
+              break;
+            }
+          }
+        };
+        CoSELayout.prototype.positionNodesRadially = function(forest) {
+          var currentStartingPoint = new Point2(0, 0);
+          var numberOfColumns = Math.ceil(Math.sqrt(forest.length));
+          var height = 0;
+          var currentY = 0;
+          var currentX = 0;
+          var point = new PointD(0, 0);
+          for (var i = 0;i < forest.length; i++) {
+            if (i % numberOfColumns == 0) {
+              currentX = 0;
+              currentY = height;
+              if (i != 0) {
+                currentY += CoSEConstants.DEFAULT_COMPONENT_SEPERATION;
+              }
+              height = 0;
+            }
+            var tree = forest[i];
+            var centerNode = Layout2.findCenterOfTree(tree);
+            currentStartingPoint.x = currentX;
+            currentStartingPoint.y = currentY;
+            point = CoSELayout.radialLayout(tree, centerNode, currentStartingPoint);
+            if (point.y > height) {
+              height = Math.floor(point.y);
+            }
+            currentX = Math.floor(point.x + CoSEConstants.DEFAULT_COMPONENT_SEPERATION);
+          }
+          this.transform(new PointD(LayoutConstants.WORLD_CENTER_X - point.x / 2, LayoutConstants.WORLD_CENTER_Y - point.y / 2));
+        };
+        CoSELayout.radialLayout = function(tree, centerNode, startingPoint) {
+          var radialSep = Math.max(this.maxDiagonalInTree(tree), CoSEConstants.DEFAULT_RADIAL_SEPARATION);
+          CoSELayout.branchRadialLayout(centerNode, null, 0, 359, 0, radialSep);
+          var bounds = LGraph.calculateBounds(tree);
+          var transform = new Transform;
+          transform.setDeviceOrgX(bounds.getMinX());
+          transform.setDeviceOrgY(bounds.getMinY());
+          transform.setWorldOrgX(startingPoint.x);
+          transform.setWorldOrgY(startingPoint.y);
+          for (var i = 0;i < tree.length; i++) {
+            var node = tree[i];
+            node.transform(transform);
+          }
+          var bottomRight = new PointD(bounds.getMaxX(), bounds.getMaxY());
+          return transform.inverseTransformPoint(bottomRight);
+        };
+        CoSELayout.branchRadialLayout = function(node, parentOfNode, startAngle, endAngle, distance, radialSeparation) {
+          var halfInterval = (endAngle - startAngle + 1) / 2;
+          if (halfInterval < 0) {
+            halfInterval += 180;
+          }
+          var nodeAngle = (halfInterval + startAngle) % 360;
+          var teta = nodeAngle * IGeometry.TWO_PI / 360;
+          var cos_teta = Math.cos(teta);
+          var x_ = distance * Math.cos(teta);
+          var y_ = distance * Math.sin(teta);
+          node.setCenter(x_, y_);
+          var neighborEdges = [];
+          neighborEdges = neighborEdges.concat(node.getEdges());
+          var childCount = neighborEdges.length;
+          if (parentOfNode != null) {
+            childCount--;
+          }
+          var branchCount = 0;
+          var incEdgesCount = neighborEdges.length;
+          var startIndex;
+          var edges = node.getEdgesBetween(parentOfNode);
+          while (edges.length > 1) {
+            var temp = edges[0];
+            edges.splice(0, 1);
+            var index = neighborEdges.indexOf(temp);
+            if (index >= 0) {
+              neighborEdges.splice(index, 1);
+            }
+            incEdgesCount--;
+            childCount--;
+          }
+          if (parentOfNode != null) {
+            startIndex = (neighborEdges.indexOf(edges[0]) + 1) % incEdgesCount;
+          } else {
+            startIndex = 0;
+          }
+          var stepAngle = Math.abs(endAngle - startAngle) / childCount;
+          for (var i = startIndex;branchCount != childCount; i = ++i % incEdgesCount) {
+            var currentNeighbor = neighborEdges[i].getOtherEnd(node);
+            if (currentNeighbor == parentOfNode) {
+              continue;
+            }
+            var childStartAngle = (startAngle + branchCount * stepAngle) % 360;
+            var childEndAngle = (childStartAngle + stepAngle) % 360;
+            CoSELayout.branchRadialLayout(currentNeighbor, node, childStartAngle, childEndAngle, distance + radialSeparation, radialSeparation);
+            branchCount++;
+          }
+        };
+        CoSELayout.maxDiagonalInTree = function(tree) {
+          var maxDiagonal = Integer.MIN_VALUE;
+          for (var i = 0;i < tree.length; i++) {
+            var node = tree[i];
+            var diagonal = node.getDiagonal();
+            if (diagonal > maxDiagonal) {
+              maxDiagonal = diagonal;
+            }
+          }
+          return maxDiagonal;
+        };
+        CoSELayout.prototype.calcRepulsionRange = function() {
+          return 2 * (this.level + 1) * this.idealEdgeLength;
+        };
+        CoSELayout.prototype.groupZeroDegreeMembers = function() {
+          var self = this;
+          var tempMemberGroups = {};
+          this.memberGroups = {};
+          this.idToDummyNode = {};
+          var zeroDegree = [];
+          var allNodes = this.graphManager.getAllNodes();
+          for (var i = 0;i < allNodes.length; i++) {
+            var node = allNodes[i];
+            var parent = node.getParent();
+            if (this.getNodeDegreeWithChildren(node) === 0 && (parent.id == undefined || !this.getToBeTiled(parent))) {
+              zeroDegree.push(node);
+            }
+          }
+          for (var i = 0;i < zeroDegree.length; i++) {
+            var node = zeroDegree[i];
+            var p_id = node.getParent().id;
+            if (typeof tempMemberGroups[p_id] === "undefined")
+              tempMemberGroups[p_id] = [];
+            tempMemberGroups[p_id] = tempMemberGroups[p_id].concat(node);
+          }
+          Object.keys(tempMemberGroups).forEach(function(p_id2) {
+            if (tempMemberGroups[p_id2].length > 1) {
+              var dummyCompoundId = "DummyCompound_" + p_id2;
+              self.memberGroups[dummyCompoundId] = tempMemberGroups[p_id2];
+              var parent2 = tempMemberGroups[p_id2][0].getParent();
+              var dummyCompound = new CoSENode(self.graphManager);
+              dummyCompound.id = dummyCompoundId;
+              dummyCompound.paddingLeft = parent2.paddingLeft || 0;
+              dummyCompound.paddingRight = parent2.paddingRight || 0;
+              dummyCompound.paddingBottom = parent2.paddingBottom || 0;
+              dummyCompound.paddingTop = parent2.paddingTop || 0;
+              self.idToDummyNode[dummyCompoundId] = dummyCompound;
+              var dummyParentGraph = self.getGraphManager().add(self.newGraph(), dummyCompound);
+              var parentGraph = parent2.getChild();
+              parentGraph.add(dummyCompound);
+              for (var i2 = 0;i2 < tempMemberGroups[p_id2].length; i2++) {
+                var node2 = tempMemberGroups[p_id2][i2];
+                parentGraph.remove(node2);
+                dummyParentGraph.add(node2);
+              }
+            }
+          });
+        };
+        CoSELayout.prototype.clearCompounds = function() {
+          var childGraphMap = {};
+          var idToNode = {};
+          this.performDFSOnCompounds();
+          for (var i = 0;i < this.compoundOrder.length; i++) {
+            idToNode[this.compoundOrder[i].id] = this.compoundOrder[i];
+            childGraphMap[this.compoundOrder[i].id] = [].concat(this.compoundOrder[i].getChild().getNodes());
+            this.graphManager.remove(this.compoundOrder[i].getChild());
+            this.compoundOrder[i].child = null;
+          }
+          this.graphManager.resetAllNodes();
+          this.tileCompoundMembers(childGraphMap, idToNode);
+        };
+        CoSELayout.prototype.clearZeroDegreeMembers = function() {
+          var self = this;
+          var tiledZeroDegreePack = this.tiledZeroDegreePack = [];
+          Object.keys(this.memberGroups).forEach(function(id) {
+            var compoundNode = self.idToDummyNode[id];
+            tiledZeroDegreePack[id] = self.tileNodes(self.memberGroups[id], compoundNode.paddingLeft + compoundNode.paddingRight);
+            compoundNode.rect.width = tiledZeroDegreePack[id].width;
+            compoundNode.rect.height = tiledZeroDegreePack[id].height;
+          });
+        };
+        CoSELayout.prototype.repopulateCompounds = function() {
+          for (var i = this.compoundOrder.length - 1;i >= 0; i--) {
+            var lCompoundNode = this.compoundOrder[i];
+            var id = lCompoundNode.id;
+            var horizontalMargin = lCompoundNode.paddingLeft;
+            var verticalMargin = lCompoundNode.paddingTop;
+            this.adjustLocations(this.tiledMemberPack[id], lCompoundNode.rect.x, lCompoundNode.rect.y, horizontalMargin, verticalMargin);
+          }
+        };
+        CoSELayout.prototype.repopulateZeroDegreeMembers = function() {
+          var self = this;
+          var tiledPack = this.tiledZeroDegreePack;
+          Object.keys(tiledPack).forEach(function(id) {
+            var compoundNode = self.idToDummyNode[id];
+            var horizontalMargin = compoundNode.paddingLeft;
+            var verticalMargin = compoundNode.paddingTop;
+            self.adjustLocations(tiledPack[id], compoundNode.rect.x, compoundNode.rect.y, horizontalMargin, verticalMargin);
+          });
+        };
+        CoSELayout.prototype.getToBeTiled = function(node) {
+          var id = node.id;
+          if (this.toBeTiled[id] != null) {
+            return this.toBeTiled[id];
+          }
+          var childGraph = node.getChild();
+          if (childGraph == null) {
+            this.toBeTiled[id] = false;
+            return false;
+          }
+          var children = childGraph.getNodes();
+          for (var i = 0;i < children.length; i++) {
+            var theChild = children[i];
+            if (this.getNodeDegree(theChild) > 0) {
+              this.toBeTiled[id] = false;
+              return false;
+            }
+            if (theChild.getChild() == null) {
+              this.toBeTiled[theChild.id] = false;
+              continue;
+            }
+            if (!this.getToBeTiled(theChild)) {
+              this.toBeTiled[id] = false;
+              return false;
+            }
+          }
+          this.toBeTiled[id] = true;
+          return true;
+        };
+        CoSELayout.prototype.getNodeDegree = function(node) {
+          var id = node.id;
+          var edges = node.getEdges();
+          var degree = 0;
+          for (var i = 0;i < edges.length; i++) {
+            var edge = edges[i];
+            if (edge.getSource().id !== edge.getTarget().id) {
+              degree = degree + 1;
+            }
+          }
+          return degree;
+        };
+        CoSELayout.prototype.getNodeDegreeWithChildren = function(node) {
+          var degree = this.getNodeDegree(node);
+          if (node.getChild() == null) {
+            return degree;
+          }
+          var children = node.getChild().getNodes();
+          for (var i = 0;i < children.length; i++) {
+            var child = children[i];
+            degree += this.getNodeDegreeWithChildren(child);
+          }
+          return degree;
+        };
+        CoSELayout.prototype.performDFSOnCompounds = function() {
+          this.compoundOrder = [];
+          this.fillCompexOrderByDFS(this.graphManager.getRoot().getNodes());
+        };
+        CoSELayout.prototype.fillCompexOrderByDFS = function(children) {
+          for (var i = 0;i < children.length; i++) {
+            var child = children[i];
+            if (child.getChild() != null) {
+              this.fillCompexOrderByDFS(child.getChild().getNodes());
+            }
+            if (this.getToBeTiled(child)) {
+              this.compoundOrder.push(child);
+            }
+          }
+        };
+        CoSELayout.prototype.adjustLocations = function(organization, x, y, compoundHorizontalMargin, compoundVerticalMargin) {
+          x += compoundHorizontalMargin;
+          y += compoundVerticalMargin;
+          var left = x;
+          for (var i = 0;i < organization.rows.length; i++) {
+            var row = organization.rows[i];
+            x = left;
+            var maxHeight = 0;
+            for (var j = 0;j < row.length; j++) {
+              var lnode = row[j];
+              lnode.rect.x = x;
+              lnode.rect.y = y;
+              x += lnode.rect.width + organization.horizontalPadding;
+              if (lnode.rect.height > maxHeight)
+                maxHeight = lnode.rect.height;
+            }
+            y += maxHeight + organization.verticalPadding;
+          }
+        };
+        CoSELayout.prototype.tileCompoundMembers = function(childGraphMap, idToNode) {
+          var self = this;
+          this.tiledMemberPack = [];
+          Object.keys(childGraphMap).forEach(function(id) {
+            var compoundNode = idToNode[id];
+            self.tiledMemberPack[id] = self.tileNodes(childGraphMap[id], compoundNode.paddingLeft + compoundNode.paddingRight);
+            compoundNode.rect.width = self.tiledMemberPack[id].width;
+            compoundNode.rect.height = self.tiledMemberPack[id].height;
+          });
+        };
+        CoSELayout.prototype.tileNodes = function(nodes, minWidth) {
+          var verticalPadding = CoSEConstants.TILING_PADDING_VERTICAL;
+          var horizontalPadding = CoSEConstants.TILING_PADDING_HORIZONTAL;
+          var organization = {
+            rows: [],
+            rowWidth: [],
+            rowHeight: [],
+            width: 0,
+            height: minWidth,
+            verticalPadding,
+            horizontalPadding
+          };
+          nodes.sort(function(n1, n2) {
+            if (n1.rect.width * n1.rect.height > n2.rect.width * n2.rect.height)
+              return -1;
+            if (n1.rect.width * n1.rect.height < n2.rect.width * n2.rect.height)
+              return 1;
+            return 0;
+          });
+          for (var i = 0;i < nodes.length; i++) {
+            var lNode = nodes[i];
+            if (organization.rows.length == 0) {
+              this.insertNodeToRow(organization, lNode, 0, minWidth);
+            } else if (this.canAddHorizontal(organization, lNode.rect.width, lNode.rect.height)) {
+              this.insertNodeToRow(organization, lNode, this.getShortestRowIndex(organization), minWidth);
+            } else {
+              this.insertNodeToRow(organization, lNode, organization.rows.length, minWidth);
+            }
+            this.shiftToLastRow(organization);
+          }
+          return organization;
+        };
+        CoSELayout.prototype.insertNodeToRow = function(organization, node, rowIndex, minWidth) {
+          var minCompoundSize = minWidth;
+          if (rowIndex == organization.rows.length) {
+            var secondDimension = [];
+            organization.rows.push(secondDimension);
+            organization.rowWidth.push(minCompoundSize);
+            organization.rowHeight.push(0);
+          }
+          var w = organization.rowWidth[rowIndex] + node.rect.width;
+          if (organization.rows[rowIndex].length > 0) {
+            w += organization.horizontalPadding;
+          }
+          organization.rowWidth[rowIndex] = w;
+          if (organization.width < w) {
+            organization.width = w;
+          }
+          var h = node.rect.height;
+          if (rowIndex > 0)
+            h += organization.verticalPadding;
+          var extraHeight = 0;
+          if (h > organization.rowHeight[rowIndex]) {
+            extraHeight = organization.rowHeight[rowIndex];
+            organization.rowHeight[rowIndex] = h;
+            extraHeight = organization.rowHeight[rowIndex] - extraHeight;
+          }
+          organization.height += extraHeight;
+          organization.rows[rowIndex].push(node);
+        };
+        CoSELayout.prototype.getShortestRowIndex = function(organization) {
+          var r = -1;
+          var min = Number.MAX_VALUE;
+          for (var i = 0;i < organization.rows.length; i++) {
+            if (organization.rowWidth[i] < min) {
+              r = i;
+              min = organization.rowWidth[i];
+            }
+          }
+          return r;
+        };
+        CoSELayout.prototype.getLongestRowIndex = function(organization) {
+          var r = -1;
+          var max = Number.MIN_VALUE;
+          for (var i = 0;i < organization.rows.length; i++) {
+            if (organization.rowWidth[i] > max) {
+              r = i;
+              max = organization.rowWidth[i];
+            }
+          }
+          return r;
+        };
+        CoSELayout.prototype.canAddHorizontal = function(organization, extraWidth, extraHeight) {
+          var sri = this.getShortestRowIndex(organization);
+          if (sri < 0) {
+            return true;
+          }
+          var min = organization.rowWidth[sri];
+          if (min + organization.horizontalPadding + extraWidth <= organization.width)
+            return true;
+          var hDiff = 0;
+          if (organization.rowHeight[sri] < extraHeight) {
+            if (sri > 0)
+              hDiff = extraHeight + organization.verticalPadding - organization.rowHeight[sri];
+          }
+          var add_to_row_ratio;
+          if (organization.width - min >= extraWidth + organization.horizontalPadding) {
+            add_to_row_ratio = (organization.height + hDiff) / (min + extraWidth + organization.horizontalPadding);
+          } else {
+            add_to_row_ratio = (organization.height + hDiff) / organization.width;
+          }
+          hDiff = extraHeight + organization.verticalPadding;
+          var add_new_row_ratio;
+          if (organization.width < extraWidth) {
+            add_new_row_ratio = (organization.height + hDiff) / extraWidth;
+          } else {
+            add_new_row_ratio = (organization.height + hDiff) / organization.width;
+          }
+          if (add_new_row_ratio < 1)
+            add_new_row_ratio = 1 / add_new_row_ratio;
+          if (add_to_row_ratio < 1)
+            add_to_row_ratio = 1 / add_to_row_ratio;
+          return add_to_row_ratio < add_new_row_ratio;
+        };
+        CoSELayout.prototype.shiftToLastRow = function(organization) {
+          var longest = this.getLongestRowIndex(organization);
+          var last = organization.rowWidth.length - 1;
+          var row = organization.rows[longest];
+          var node = row[row.length - 1];
+          var diff = node.width + organization.horizontalPadding;
+          if (organization.width - organization.rowWidth[last] > diff && longest != last) {
+            row.splice(-1, 1);
+            organization.rows[last].push(node);
+            organization.rowWidth[longest] = organization.rowWidth[longest] - diff;
+            organization.rowWidth[last] = organization.rowWidth[last] + diff;
+            organization.width = organization.rowWidth[instance.getLongestRowIndex(organization)];
+            var maxHeight = Number.MIN_VALUE;
+            for (var i = 0;i < row.length; i++) {
+              if (row[i].height > maxHeight)
+                maxHeight = row[i].height;
+            }
+            if (longest > 0)
+              maxHeight += organization.verticalPadding;
+            var prevTotal = organization.rowHeight[longest] + organization.rowHeight[last];
+            organization.rowHeight[longest] = maxHeight;
+            if (organization.rowHeight[last] < node.height + organization.verticalPadding)
+              organization.rowHeight[last] = node.height + organization.verticalPadding;
+            var finalTotal = organization.rowHeight[longest] + organization.rowHeight[last];
+            organization.height += finalTotal - prevTotal;
+            this.shiftToLastRow(organization);
+          }
+        };
+        CoSELayout.prototype.tilingPreLayout = function() {
+          if (CoSEConstants.TILE) {
+            this.groupZeroDegreeMembers();
+            this.clearCompounds();
+            this.clearZeroDegreeMembers();
+          }
+        };
+        CoSELayout.prototype.tilingPostLayout = function() {
+          if (CoSEConstants.TILE) {
+            this.repopulateZeroDegreeMembers();
+            this.repopulateCompounds();
+          }
+        };
+        CoSELayout.prototype.reduceTrees = function() {
+          var prunedNodesAll = [];
+          var containsLeaf = true;
+          var node;
+          while (containsLeaf) {
+            var allNodes = this.graphManager.getAllNodes();
+            var prunedNodesInStepTemp = [];
+            containsLeaf = false;
+            for (var i = 0;i < allNodes.length; i++) {
+              node = allNodes[i];
+              if (node.getEdges().length == 1 && !node.getEdges()[0].isInterGraph && node.getChild() == null) {
+                prunedNodesInStepTemp.push([node, node.getEdges()[0], node.getOwner()]);
+                containsLeaf = true;
+              }
+            }
+            if (containsLeaf == true) {
+              var prunedNodesInStep = [];
+              for (var j = 0;j < prunedNodesInStepTemp.length; j++) {
+                if (prunedNodesInStepTemp[j][0].getEdges().length == 1) {
+                  prunedNodesInStep.push(prunedNodesInStepTemp[j]);
+                  prunedNodesInStepTemp[j][0].getOwner().remove(prunedNodesInStepTemp[j][0]);
+                }
+              }
+              prunedNodesAll.push(prunedNodesInStep);
+              this.graphManager.resetAllNodes();
+              this.graphManager.resetAllEdges();
+            }
+          }
+          this.prunedNodesAll = prunedNodesAll;
+        };
+        CoSELayout.prototype.growTree = function(prunedNodesAll) {
+          var lengthOfPrunedNodesInStep = prunedNodesAll.length;
+          var prunedNodesInStep = prunedNodesAll[lengthOfPrunedNodesInStep - 1];
+          var nodeData;
+          for (var i = 0;i < prunedNodesInStep.length; i++) {
+            nodeData = prunedNodesInStep[i];
+            this.findPlaceforPrunedNode(nodeData);
+            nodeData[2].add(nodeData[0]);
+            nodeData[2].add(nodeData[1], nodeData[1].source, nodeData[1].target);
+          }
+          prunedNodesAll.splice(prunedNodesAll.length - 1, 1);
+          this.graphManager.resetAllNodes();
+          this.graphManager.resetAllEdges();
+        };
+        CoSELayout.prototype.findPlaceforPrunedNode = function(nodeData) {
+          var gridForPrunedNode;
+          var nodeToConnect;
+          var prunedNode = nodeData[0];
+          if (prunedNode == nodeData[1].source) {
+            nodeToConnect = nodeData[1].target;
+          } else {
+            nodeToConnect = nodeData[1].source;
+          }
+          var startGridX = nodeToConnect.startX;
+          var finishGridX = nodeToConnect.finishX;
+          var startGridY = nodeToConnect.startY;
+          var finishGridY = nodeToConnect.finishY;
+          var upNodeCount = 0;
+          var downNodeCount = 0;
+          var rightNodeCount = 0;
+          var leftNodeCount = 0;
+          var controlRegions = [upNodeCount, rightNodeCount, downNodeCount, leftNodeCount];
+          if (startGridY > 0) {
+            for (var i = startGridX;i <= finishGridX; i++) {
+              controlRegions[0] += this.grid[i][startGridY - 1].length + this.grid[i][startGridY].length - 1;
+            }
+          }
+          if (finishGridX < this.grid.length - 1) {
+            for (var i = startGridY;i <= finishGridY; i++) {
+              controlRegions[1] += this.grid[finishGridX + 1][i].length + this.grid[finishGridX][i].length - 1;
+            }
+          }
+          if (finishGridY < this.grid[0].length - 1) {
+            for (var i = startGridX;i <= finishGridX; i++) {
+              controlRegions[2] += this.grid[i][finishGridY + 1].length + this.grid[i][finishGridY].length - 1;
+            }
+          }
+          if (startGridX > 0) {
+            for (var i = startGridY;i <= finishGridY; i++) {
+              controlRegions[3] += this.grid[startGridX - 1][i].length + this.grid[startGridX][i].length - 1;
+            }
+          }
+          var min = Integer.MAX_VALUE;
+          var minCount;
+          var minIndex;
+          for (var j = 0;j < controlRegions.length; j++) {
+            if (controlRegions[j] < min) {
+              min = controlRegions[j];
+              minCount = 1;
+              minIndex = j;
+            } else if (controlRegions[j] == min) {
+              minCount++;
+            }
+          }
+          if (minCount == 3 && min == 0) {
+            if (controlRegions[0] == 0 && controlRegions[1] == 0 && controlRegions[2] == 0) {
+              gridForPrunedNode = 1;
+            } else if (controlRegions[0] == 0 && controlRegions[1] == 0 && controlRegions[3] == 0) {
+              gridForPrunedNode = 0;
+            } else if (controlRegions[0] == 0 && controlRegions[2] == 0 && controlRegions[3] == 0) {
+              gridForPrunedNode = 3;
+            } else if (controlRegions[1] == 0 && controlRegions[2] == 0 && controlRegions[3] == 0) {
+              gridForPrunedNode = 2;
+            }
+          } else if (minCount == 2 && min == 0) {
+            var random = Math.floor(Math.random() * 2);
+            if (controlRegions[0] == 0 && controlRegions[1] == 0) {
+              if (random == 0) {
+                gridForPrunedNode = 0;
+              } else {
+                gridForPrunedNode = 1;
+              }
+            } else if (controlRegions[0] == 0 && controlRegions[2] == 0) {
+              if (random == 0) {
+                gridForPrunedNode = 0;
+              } else {
+                gridForPrunedNode = 2;
+              }
+            } else if (controlRegions[0] == 0 && controlRegions[3] == 0) {
+              if (random == 0) {
+                gridForPrunedNode = 0;
+              } else {
+                gridForPrunedNode = 3;
+              }
+            } else if (controlRegions[1] == 0 && controlRegions[2] == 0) {
+              if (random == 0) {
+                gridForPrunedNode = 1;
+              } else {
+                gridForPrunedNode = 2;
+              }
+            } else if (controlRegions[1] == 0 && controlRegions[3] == 0) {
+              if (random == 0) {
+                gridForPrunedNode = 1;
+              } else {
+                gridForPrunedNode = 3;
+              }
+            } else {
+              if (random == 0) {
+                gridForPrunedNode = 2;
+              } else {
+                gridForPrunedNode = 3;
+              }
+            }
+          } else if (minCount == 4 && min == 0) {
+            var random = Math.floor(Math.random() * 4);
+            gridForPrunedNode = random;
+          } else {
+            gridForPrunedNode = minIndex;
+          }
+          if (gridForPrunedNode == 0) {
+            prunedNode.setCenter(nodeToConnect.getCenterX(), nodeToConnect.getCenterY() - nodeToConnect.getHeight() / 2 - FDLayoutConstants.DEFAULT_EDGE_LENGTH - prunedNode.getHeight() / 2);
+          } else if (gridForPrunedNode == 1) {
+            prunedNode.setCenter(nodeToConnect.getCenterX() + nodeToConnect.getWidth() / 2 + FDLayoutConstants.DEFAULT_EDGE_LENGTH + prunedNode.getWidth() / 2, nodeToConnect.getCenterY());
+          } else if (gridForPrunedNode == 2) {
+            prunedNode.setCenter(nodeToConnect.getCenterX(), nodeToConnect.getCenterY() + nodeToConnect.getHeight() / 2 + FDLayoutConstants.DEFAULT_EDGE_LENGTH + prunedNode.getHeight() / 2);
+          } else {
+            prunedNode.setCenter(nodeToConnect.getCenterX() - nodeToConnect.getWidth() / 2 - FDLayoutConstants.DEFAULT_EDGE_LENGTH - prunedNode.getWidth() / 2, nodeToConnect.getCenterY());
+          }
+        };
+        module2.exports = CoSELayout;
+      },
+      function(module2, exports2, __webpack_require__) {
+        var coseBase = {};
+        coseBase.layoutBase = __webpack_require__(0);
+        coseBase.CoSEConstants = __webpack_require__(1);
+        coseBase.CoSEEdge = __webpack_require__(2);
+        coseBase.CoSEGraph = __webpack_require__(3);
+        coseBase.CoSEGraphManager = __webpack_require__(4);
+        coseBase.CoSELayout = __webpack_require__(6);
+        coseBase.CoSENode = __webpack_require__(5);
+        module2.exports = coseBase;
+      }
+    ]);
+  });
+});
+
+// node_modules/cytoscape-cose-bilkent/cytoscape-cose-bilkent.js
+var require_cytoscape_cose_bilkent = __commonJS(function(exports, module) {
+  (function webpackUniversalModuleDefinition(root, factory) {
+    if (typeof exports === "object" && typeof module === "object")
+      module.exports = factory(require_cose_base());
+    else if (typeof define === "function" && define.amd)
+      define(["cose-base"], factory);
+    else if (typeof exports === "object")
+      exports["cytoscapeCoseBilkent"] = factory(require_cose_base());
+    else
+      root["cytoscapeCoseBilkent"] = factory(root["coseBase"]);
+  })(exports, function(__WEBPACK_EXTERNAL_MODULE_0__) {
+    return function(modules) {
+      var installedModules = {};
+      function __webpack_require__(moduleId) {
+        if (installedModules[moduleId]) {
+          return installedModules[moduleId].exports;
+        }
+        var module2 = installedModules[moduleId] = {
+          i: moduleId,
+          l: false,
+          exports: {}
+        };
+        modules[moduleId].call(module2.exports, module2, module2.exports, __webpack_require__);
+        module2.l = true;
+        return module2.exports;
+      }
+      __webpack_require__.m = modules;
+      __webpack_require__.c = installedModules;
+      __webpack_require__.i = function(value) {
+        return value;
+      };
+      __webpack_require__.d = function(exports2, name, getter) {
+        if (!__webpack_require__.o(exports2, name)) {
+          Object.defineProperty(exports2, name, {
+            configurable: false,
+            enumerable: true,
+            get: getter
+          });
+        }
+      };
+      __webpack_require__.n = function(module2) {
+        var getter = module2 && module2.__esModule ? function getDefault() {
+          return module2["default"];
+        } : function getModuleExports() {
+          return module2;
+        };
+        __webpack_require__.d(getter, "a", getter);
+        return getter;
+      };
+      __webpack_require__.o = function(object, property) {
+        return Object.prototype.hasOwnProperty.call(object, property);
+      };
+      __webpack_require__.p = "";
+      return __webpack_require__(__webpack_require__.s = 1);
+    }([
+      function(module2, exports2) {
+        module2.exports = __WEBPACK_EXTERNAL_MODULE_0__;
+      },
+      function(module2, exports2, __webpack_require__) {
+        var LayoutConstants = __webpack_require__(0).layoutBase.LayoutConstants;
+        var FDLayoutConstants = __webpack_require__(0).layoutBase.FDLayoutConstants;
+        var CoSEConstants = __webpack_require__(0).CoSEConstants;
+        var CoSELayout = __webpack_require__(0).CoSELayout;
+        var CoSENode = __webpack_require__(0).CoSENode;
+        var PointD = __webpack_require__(0).layoutBase.PointD;
+        var DimensionD2 = __webpack_require__(0).layoutBase.DimensionD;
+        var defaults = {
+          ready: function ready() {},
+          stop: function stop() {},
+          quality: "default",
+          nodeDimensionsIncludeLabels: false,
+          refresh: 30,
+          fit: true,
+          padding: 10,
+          randomize: true,
+          nodeRepulsion: 4500,
+          idealEdgeLength: 50,
+          edgeElasticity: 0.45,
+          nestingFactor: 0.1,
+          gravity: 0.25,
+          numIter: 2500,
+          tile: true,
+          animate: "end",
+          animationDuration: 500,
+          tilingPaddingVertical: 10,
+          tilingPaddingHorizontal: 10,
+          gravityRangeCompound: 1.5,
+          gravityCompound: 1,
+          gravityRange: 3.8,
+          initialEnergyOnIncremental: 0.5
+        };
+        function extend(defaults2, options) {
+          var obj = {};
+          for (var i in defaults2) {
+            obj[i] = defaults2[i];
+          }
+          for (var i in options) {
+            obj[i] = options[i];
+          }
+          return obj;
+        }
+        function _CoSELayout(_options) {
+          this.options = extend(defaults, _options);
+          getUserOptions(this.options);
+        }
+        var getUserOptions = function getUserOptions2(options) {
+          if (options.nodeRepulsion != null)
+            CoSEConstants.DEFAULT_REPULSION_STRENGTH = FDLayoutConstants.DEFAULT_REPULSION_STRENGTH = options.nodeRepulsion;
+          if (options.idealEdgeLength != null)
+            CoSEConstants.DEFAULT_EDGE_LENGTH = FDLayoutConstants.DEFAULT_EDGE_LENGTH = options.idealEdgeLength;
+          if (options.edgeElasticity != null)
+            CoSEConstants.DEFAULT_SPRING_STRENGTH = FDLayoutConstants.DEFAULT_SPRING_STRENGTH = options.edgeElasticity;
+          if (options.nestingFactor != null)
+            CoSEConstants.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR = FDLayoutConstants.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR = options.nestingFactor;
+          if (options.gravity != null)
+            CoSEConstants.DEFAULT_GRAVITY_STRENGTH = FDLayoutConstants.DEFAULT_GRAVITY_STRENGTH = options.gravity;
+          if (options.numIter != null)
+            CoSEConstants.MAX_ITERATIONS = FDLayoutConstants.MAX_ITERATIONS = options.numIter;
+          if (options.gravityRange != null)
+            CoSEConstants.DEFAULT_GRAVITY_RANGE_FACTOR = FDLayoutConstants.DEFAULT_GRAVITY_RANGE_FACTOR = options.gravityRange;
+          if (options.gravityCompound != null)
+            CoSEConstants.DEFAULT_COMPOUND_GRAVITY_STRENGTH = FDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_STRENGTH = options.gravityCompound;
+          if (options.gravityRangeCompound != null)
+            CoSEConstants.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR = FDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR = options.gravityRangeCompound;
+          if (options.initialEnergyOnIncremental != null)
+            CoSEConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL = FDLayoutConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL = options.initialEnergyOnIncremental;
+          if (options.quality == "draft")
+            LayoutConstants.QUALITY = 0;
+          else if (options.quality == "proof")
+            LayoutConstants.QUALITY = 2;
+          else
+            LayoutConstants.QUALITY = 1;
+          CoSEConstants.NODE_DIMENSIONS_INCLUDE_LABELS = FDLayoutConstants.NODE_DIMENSIONS_INCLUDE_LABELS = LayoutConstants.NODE_DIMENSIONS_INCLUDE_LABELS = options.nodeDimensionsIncludeLabels;
+          CoSEConstants.DEFAULT_INCREMENTAL = FDLayoutConstants.DEFAULT_INCREMENTAL = LayoutConstants.DEFAULT_INCREMENTAL = !options.randomize;
+          CoSEConstants.ANIMATE = FDLayoutConstants.ANIMATE = LayoutConstants.ANIMATE = options.animate;
+          CoSEConstants.TILE = options.tile;
+          CoSEConstants.TILING_PADDING_VERTICAL = typeof options.tilingPaddingVertical === "function" ? options.tilingPaddingVertical.call() : options.tilingPaddingVertical;
+          CoSEConstants.TILING_PADDING_HORIZONTAL = typeof options.tilingPaddingHorizontal === "function" ? options.tilingPaddingHorizontal.call() : options.tilingPaddingHorizontal;
+        };
+        _CoSELayout.prototype.run = function() {
+          var ready;
+          var frameId;
+          var options = this.options;
+          var idToLNode = this.idToLNode = {};
+          var layout = this.layout = new CoSELayout;
+          var self = this;
+          self.stopped = false;
+          this.cy = this.options.cy;
+          this.cy.trigger({ type: "layoutstart", layout: this });
+          var gm = layout.newGraphManager();
+          this.gm = gm;
+          var nodes = this.options.eles.nodes();
+          var edges = this.options.eles.edges();
+          this.root = gm.addRoot();
+          this.processChildrenList(this.root, this.getTopMostNodes(nodes), layout);
+          for (var i = 0;i < edges.length; i++) {
+            var edge = edges[i];
+            var sourceNode = this.idToLNode[edge.data("source")];
+            var targetNode = this.idToLNode[edge.data("target")];
+            if (sourceNode !== targetNode && sourceNode.getEdgesBetween(targetNode).length == 0) {
+              var e1 = gm.add(layout.newEdge(), sourceNode, targetNode);
+              e1.id = edge.id();
+            }
+          }
+          var getPositions = function getPositions2(ele, i2) {
+            if (typeof ele === "number") {
+              ele = i2;
+            }
+            var theId = ele.data("id");
+            var lNode = self.idToLNode[theId];
+            return {
+              x: lNode.getRect().getCenterX(),
+              y: lNode.getRect().getCenterY()
+            };
+          };
+          var iterateAnimated = function iterateAnimated2() {
+            var afterReposition = function afterReposition2() {
+              if (options.fit) {
+                options.cy.fit(options.eles, options.padding);
+              }
+              if (!ready) {
+                ready = true;
+                self.cy.one("layoutready", options.ready);
+                self.cy.trigger({ type: "layoutready", layout: self });
+              }
+            };
+            var ticksPerFrame = self.options.refresh;
+            var isDone;
+            for (var i2 = 0;i2 < ticksPerFrame && !isDone; i2++) {
+              isDone = self.stopped || self.layout.tick();
+            }
+            if (isDone) {
+              if (layout.checkLayoutSuccess() && !layout.isSubLayout) {
+                layout.doPostLayout();
+              }
+              if (layout.tilingPostLayout) {
+                layout.tilingPostLayout();
+              }
+              layout.isLayoutFinished = true;
+              self.options.eles.nodes().positions(getPositions);
+              afterReposition();
+              self.cy.one("layoutstop", self.options.stop);
+              self.cy.trigger({ type: "layoutstop", layout: self });
+              if (frameId) {
+                cancelAnimationFrame(frameId);
+              }
+              ready = false;
+              return;
+            }
+            var animationData = self.layout.getPositionsData();
+            options.eles.nodes().positions(function(ele, i3) {
+              if (typeof ele === "number") {
+                ele = i3;
+              }
+              if (!ele.isParent()) {
+                var theId = ele.id();
+                var pNode = animationData[theId];
+                var temp = ele;
+                while (pNode == null) {
+                  pNode = animationData[temp.data("parent")] || animationData["DummyCompound_" + temp.data("parent")];
+                  animationData[theId] = pNode;
+                  temp = temp.parent()[0];
+                  if (temp == undefined) {
+                    break;
+                  }
+                }
+                if (pNode != null) {
+                  return {
+                    x: pNode.x,
+                    y: pNode.y
+                  };
+                } else {
+                  return {
+                    x: ele.position("x"),
+                    y: ele.position("y")
+                  };
+                }
+              }
+            });
+            afterReposition();
+            frameId = requestAnimationFrame(iterateAnimated2);
+          };
+          layout.addListener("layoutstarted", function() {
+            if (self.options.animate === "during") {
+              frameId = requestAnimationFrame(iterateAnimated);
+            }
+          });
+          layout.runLayout();
+          if (this.options.animate !== "during") {
+            self.options.eles.nodes().not(":parent").layoutPositions(self, self.options, getPositions);
+            ready = false;
+          }
+          return this;
+        };
+        _CoSELayout.prototype.getTopMostNodes = function(nodes) {
+          var nodesMap = {};
+          for (var i = 0;i < nodes.length; i++) {
+            nodesMap[nodes[i].id()] = true;
+          }
+          var roots = nodes.filter(function(ele, i2) {
+            if (typeof ele === "number") {
+              ele = i2;
+            }
+            var parent = ele.parent()[0];
+            while (parent != null) {
+              if (nodesMap[parent.id()]) {
+                return false;
+              }
+              parent = parent.parent()[0];
+            }
+            return true;
+          });
+          return roots;
+        };
+        _CoSELayout.prototype.processChildrenList = function(parent, children, layout) {
+          var size = children.length;
+          for (var i = 0;i < size; i++) {
+            var theChild = children[i];
+            var children_of_children = theChild.children();
+            var theNode;
+            var dimensions = theChild.layoutDimensions({
+              nodeDimensionsIncludeLabels: this.options.nodeDimensionsIncludeLabels
+            });
+            if (theChild.outerWidth() != null && theChild.outerHeight() != null) {
+              theNode = parent.add(new CoSENode(layout.graphManager, new PointD(theChild.position("x") - dimensions.w / 2, theChild.position("y") - dimensions.h / 2), new DimensionD2(parseFloat(dimensions.w), parseFloat(dimensions.h))));
+            } else {
+              theNode = parent.add(new CoSENode(this.graphManager));
+            }
+            theNode.id = theChild.data("id");
+            theNode.paddingLeft = parseInt(theChild.css("padding"));
+            theNode.paddingTop = parseInt(theChild.css("padding"));
+            theNode.paddingRight = parseInt(theChild.css("padding"));
+            theNode.paddingBottom = parseInt(theChild.css("padding"));
+            if (this.options.nodeDimensionsIncludeLabels) {
+              if (theChild.isParent()) {
+                var labelWidth = theChild.boundingBox({ includeLabels: true, includeNodes: false }).w;
+                var labelHeight = theChild.boundingBox({ includeLabels: true, includeNodes: false }).h;
+                var labelPos = theChild.css("text-halign");
+                theNode.labelWidth = labelWidth;
+                theNode.labelHeight = labelHeight;
+                theNode.labelPos = labelPos;
+              }
+            }
+            this.idToLNode[theChild.data("id")] = theNode;
+            if (isNaN(theNode.rect.x)) {
+              theNode.rect.x = 0;
+            }
+            if (isNaN(theNode.rect.y)) {
+              theNode.rect.y = 0;
+            }
+            if (children_of_children != null && children_of_children.length > 0) {
+              var theNewGraph;
+              theNewGraph = layout.getGraphManager().add(layout.newGraph(), theNode);
+              this.processChildrenList(theNewGraph, children_of_children, layout);
+            }
+          }
+        };
+        _CoSELayout.prototype.stop = function() {
+          this.stopped = true;
+          return this;
+        };
+        var register = function register2(cytoscape3) {
+          cytoscape3("layout", "cose-bilkent", _CoSELayout);
+        };
+        if (typeof cytoscape !== "undefined") {
+          register(cytoscape);
+        }
+        module2.exports = register;
+      }
+    ]);
+  });
+});
+
+// node_modules/mermaid/dist/chunks/mermaid.core/cose-bilkent-JH36ORCC.mjs
+var import_cytoscape_cose_bilkent = __toESM(require_cytoscape_cose_bilkent(), 1);
+cytoscape2.use(import_cytoscape_cose_bilkent.default);
+function addNodes(nodes, cy) {
+  nodes.forEach((node) => {
+    const nodeData = {
+      id: node.id,
+      labelText: node.label,
+      height: node.height,
+      width: node.width,
+      padding: node.padding ?? 0
+    };
+    Object.keys(node).forEach((key) => {
+      if (!["id", "label", "height", "width", "padding", "x", "y"].includes(key)) {
+        nodeData[key] = node[key];
+      }
+    });
+    cy.add({
+      group: "nodes",
+      data: nodeData,
+      position: {
+        x: node.x ?? 0,
+        y: node.y ?? 0
+      }
+    });
+  });
+}
+__name(addNodes, "addNodes");
+function addEdges(edges, cy) {
+  edges.forEach((edge) => {
+    const edgeData = {
+      id: edge.id,
+      source: edge.start,
+      target: edge.end
+    };
+    Object.keys(edge).forEach((key) => {
+      if (!["id", "start", "end"].includes(key)) {
+        edgeData[key] = edge[key];
+      }
+    });
+    cy.add({
+      group: "edges",
+      data: edgeData
+    });
+  });
+}
+__name(addEdges, "addEdges");
+function createCytoscapeInstance(data) {
+  return new Promise((resolve) => {
+    const renderEl = select_default("body").append("div").attr("id", "cy").attr("style", "display:none");
+    const cy = cytoscape2({
+      container: document.getElementById("cy"),
+      style: [
+        {
+          selector: "edge",
+          style: {
+            "curve-style": "bezier"
+          }
+        }
+      ]
+    });
+    renderEl.remove();
+    addNodes(data.nodes, cy);
+    addEdges(data.edges, cy);
+    cy.nodes().forEach(function(n) {
+      n.layoutDimensions = () => {
+        const nodeData = n.data();
+        return { w: nodeData.width, h: nodeData.height };
+      };
+    });
+    const layoutConfig = {
+      name: "cose-bilkent",
+      quality: "proof",
+      styleEnabled: false,
+      animate: false
+    };
+    cy.layout(layoutConfig).run();
+    cy.ready((e) => {
+      log.info("Cytoscape ready", e);
+      resolve(cy);
+    });
+  });
+}
+__name(createCytoscapeInstance, "createCytoscapeInstance");
+function extractPositionedNodes(cy) {
+  return cy.nodes().map((node) => {
+    const data = node.data();
+    const position = node.position();
+    const positionedNode = {
+      id: data.id,
+      x: position.x,
+      y: position.y
+    };
+    Object.keys(data).forEach((key) => {
+      if (key !== "id") {
+        positionedNode[key] = data[key];
+      }
+    });
+    return positionedNode;
+  });
+}
+__name(extractPositionedNodes, "extractPositionedNodes");
+function extractPositionedEdges(cy) {
+  return cy.edges().map((edge) => {
+    const data = edge.data();
+    const rscratch = edge._private.rscratch;
+    const positionedEdge = {
+      id: data.id,
+      source: data.source,
+      target: data.target,
+      startX: rscratch.startX,
+      startY: rscratch.startY,
+      midX: rscratch.midX,
+      midY: rscratch.midY,
+      endX: rscratch.endX,
+      endY: rscratch.endY
+    };
+    Object.keys(data).forEach((key) => {
+      if (!["id", "source", "target"].includes(key)) {
+        positionedEdge[key] = data[key];
+      }
+    });
+    return positionedEdge;
+  });
+}
+__name(extractPositionedEdges, "extractPositionedEdges");
+async function executeCoseBilkentLayout(data, _config) {
+  log.debug("Starting cose-bilkent layout algorithm");
+  try {
+    validateLayoutData(data);
+    const cy = await createCytoscapeInstance(data);
+    const positionedNodes = extractPositionedNodes(cy);
+    const positionedEdges = extractPositionedEdges(cy);
+    log.debug(`Layout completed: ${positionedNodes.length} nodes, ${positionedEdges.length} edges`);
+    return {
+      nodes: positionedNodes,
+      edges: positionedEdges
+    };
+  } catch (error) {
+    log.error("Error in cose-bilkent layout algorithm:", error);
+    throw error;
+  }
+}
+__name(executeCoseBilkentLayout, "executeCoseBilkentLayout");
+function validateLayoutData(data) {
+  if (!data) {
+    throw new Error("Layout data is required");
+  }
+  if (!data.config) {
+    throw new Error("Configuration is required in layout data");
+  }
+  if (!data.rootNode) {
+    throw new Error("Root node is required");
+  }
+  if (!data.nodes || !Array.isArray(data.nodes)) {
+    throw new Error("No nodes found in layout data");
+  }
+  if (!Array.isArray(data.edges)) {
+    throw new Error("Edges array is required in layout data");
+  }
+  return true;
+}
+__name(validateLayoutData, "validateLayoutData");
+var render = /* @__PURE__ */ __name(async (data4Layout, svg, {
+  insertCluster,
+  insertEdge,
+  insertEdgeLabel,
+  insertMarkers,
+  insertNode,
+  log: log2,
+  positionEdgeLabel
+}, { algorithm: _algorithm }) => {
+  const nodeDb = {};
+  const clusterDb = {};
+  const element = svg.select("g");
+  insertMarkers(element, data4Layout.markers, data4Layout.type, data4Layout.diagramId);
+  const subGraphsEl = element.insert("g").attr("class", "subgraphs");
+  const edgePaths = element.insert("g").attr("class", "edgePaths");
+  const edgeLabels = element.insert("g").attr("class", "edgeLabels");
+  const nodes = element.insert("g").attr("class", "nodes");
+  log2.debug("Inserting nodes into DOM for dimension calculation");
+  await Promise.all(data4Layout.nodes.map(async (node) => {
+    if (node.isGroup) {
+      const clusterNode = { ...node };
+      clusterDb[node.id] = clusterNode;
+      nodeDb[node.id] = clusterNode;
+      await insertCluster(subGraphsEl, node);
+    } else {
+      const nodeWithPosition = { ...node };
+      nodeDb[node.id] = nodeWithPosition;
+      const nodeEl = await insertNode(nodes, node, {
+        config: data4Layout.config,
+        dir: data4Layout.direction || "TB"
+      });
+      const boundingBox = nodeEl.node().getBBox();
+      nodeWithPosition.width = boundingBox.width;
+      nodeWithPosition.height = boundingBox.height;
+      nodeWithPosition.domId = nodeEl;
+      log2.debug(`Node ${node.id} dimensions: ${boundingBox.width}x${boundingBox.height}`);
+    }
+  }));
+  log2.debug("Running cose-bilkent layout algorithm");
+  const updatedLayoutData = {
+    ...data4Layout,
+    nodes: data4Layout.nodes.map((node) => {
+      const nodeWithDimensions = nodeDb[node.id];
+      return {
+        ...node,
+        width: nodeWithDimensions.width,
+        height: nodeWithDimensions.height
+      };
+    })
+  };
+  const layoutResult = await executeCoseBilkentLayout(updatedLayoutData, data4Layout.config);
+  log2.debug("Positioning nodes based on layout results");
+  layoutResult.nodes.forEach((positionedNode) => {
+    const node = nodeDb[positionedNode.id];
+    if (node?.domId) {
+      node.domId.attr("transform", `translate(${positionedNode.x}, ${positionedNode.y})`);
+      node.x = positionedNode.x;
+      node.y = positionedNode.y;
+      log2.debug(`Positioned node ${node.id} at center (${positionedNode.x}, ${positionedNode.y})`);
+    }
+  });
+  layoutResult.edges.forEach((positionedEdge) => {
+    const edge = data4Layout.edges.find((e) => e.id === positionedEdge.id);
+    if (edge) {
+      edge.points = [
+        { x: positionedEdge.startX, y: positionedEdge.startY },
+        { x: positionedEdge.midX, y: positionedEdge.midY },
+        { x: positionedEdge.endX, y: positionedEdge.endY }
+      ];
+    }
+  });
+  log2.debug("Inserting and positioning edges");
+  await Promise.all(data4Layout.edges.map(async (edge) => {
+    const _edgeLabel = await insertEdgeLabel(edgeLabels, edge);
+    const startNode = nodeDb[edge.start ?? ""];
+    const endNode = nodeDb[edge.end ?? ""];
+    if (startNode && endNode) {
+      const positionedEdge = layoutResult.edges.find((e) => e.id === edge.id);
+      if (positionedEdge) {
+        log2.debug("APA01 positionedEdge", positionedEdge);
+        const edgeWithPath = { ...edge };
+        const paths = insertEdge(edgePaths, edgeWithPath, clusterDb, data4Layout.type, startNode, endNode, data4Layout.diagramId);
+        positionEdgeLabel(edgeWithPath, paths);
+      } else {
+        const edgeWithPath = {
+          ...edge,
+          points: [
+            { x: startNode.x || 0, y: startNode.y || 0 },
+            { x: endNode.x || 0, y: endNode.y || 0 }
+          ]
+        };
+        const paths = insertEdge(edgePaths, edgeWithPath, clusterDb, data4Layout.type, startNode, endNode, data4Layout.diagramId);
+        positionEdgeLabel(edgeWithPath, paths);
+      }
+    }
+  }));
+  log2.debug("Cose-bilkent rendering completed");
+}, "render");
+var render2 = render;
+export {
+  render2 as render
+};