{"version":3,"file":"383-1c9f134a601e6083fed4.js","mappings":"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","sources":["webpack:///./node_modules/layout-base/layout-base.js","webpack:///./node_modules/cytoscape-cose-bilkent/cytoscape-cose-bilkent.js","webpack:///./node_modules/mermaid/dist/chunks/mermaid.core/mindmap-definition-GWI6TPTV.mjs","webpack:///./node_modules/cose-base/cose-base.js"],"sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"layoutBase\"] = factory();\n\telse\n\t\troot[\"layoutBase\"] = factory();\n})(this, function() {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId]) {\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/ \t\t}\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\ti: moduleId,\n/******/ \t\t\tl: false,\n/******/ \t\t\texports: {}\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.l = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// identity function for calling harmony imports with the correct context\n/******/ \t__webpack_require__.i = function(value) { return value; };\n/******/\n/******/ \t// define getter function for harmony exports\n/******/ \t__webpack_require__.d = function(exports, name, getter) {\n/******/ \t\tif(!__webpack_require__.o(exports, name)) {\n/******/ \t\t\tObject.defineProperty(exports, name, {\n/******/ \t\t\t\tconfigurable: false,\n/******/ \t\t\t\tenumerable: true,\n/******/ \t\t\t\tget: getter\n/******/ \t\t\t});\n/******/ \t\t}\n/******/ \t};\n/******/\n/******/ \t// getDefaultExport function for compatibility with non-harmony modules\n/******/ \t__webpack_require__.n = function(module) {\n/******/ \t\tvar getter = module && module.__esModule ?\n/******/ \t\t\tfunction getDefault() { return module['default']; } :\n/******/ \t\t\tfunction getModuleExports() { return module; };\n/******/ \t\t__webpack_require__.d(getter, 'a', getter);\n/******/ \t\treturn getter;\n/******/ \t};\n/******/\n/******/ \t// Object.prototype.hasOwnProperty.call\n/******/ \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(__webpack_require__.s = 26);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nfunction LayoutConstants() {}\n\n/**\r\n * Layout Quality: 0:draft, 1:default, 2:proof\r\n */\nLayoutConstants.QUALITY = 1;\n\n/**\r\n * Default parameters\r\n */\nLayoutConstants.DEFAULT_CREATE_BENDS_AS_NEEDED = false;\nLayoutConstants.DEFAULT_INCREMENTAL = false;\nLayoutConstants.DEFAULT_ANIMATION_ON_LAYOUT = true;\nLayoutConstants.DEFAULT_ANIMATION_DURING_LAYOUT = false;\nLayoutConstants.DEFAULT_ANIMATION_PERIOD = 50;\nLayoutConstants.DEFAULT_UNIFORM_LEAF_NODE_SIZES = false;\n\n// -----------------------------------------------------------------------------\n// Section: General other constants\n// -----------------------------------------------------------------------------\n/*\r\n * Margins of a graph to be applied on bouding rectangle of its contents. We\r\n * assume margins on all four sides to be uniform.\r\n */\nLayoutConstants.DEFAULT_GRAPH_MARGIN = 15;\n\n/*\r\n * Whether to consider labels in node dimensions or not\r\n */\nLayoutConstants.NODE_DIMENSIONS_INCLUDE_LABELS = false;\n\n/*\r\n * Default dimension of a non-compound node.\r\n */\nLayoutConstants.SIMPLE_NODE_SIZE = 40;\n\n/*\r\n * Default dimension of a non-compound node.\r\n */\nLayoutConstants.SIMPLE_NODE_HALF_SIZE = LayoutConstants.SIMPLE_NODE_SIZE / 2;\n\n/*\r\n * Empty compound node size. When a compound node is empty, its both\r\n * dimensions should be of this value.\r\n */\nLayoutConstants.EMPTY_COMPOUND_NODE_SIZE = 40;\n\n/*\r\n * Minimum length that an edge should take during layout\r\n */\nLayoutConstants.MIN_EDGE_LENGTH = 1;\n\n/*\r\n * World boundaries that layout operates on\r\n */\nLayoutConstants.WORLD_BOUNDARY = 1000000;\n\n/*\r\n * World boundaries that random positioning can be performed with\r\n */\nLayoutConstants.INITIAL_WORLD_BOUNDARY = LayoutConstants.WORLD_BOUNDARY / 1000;\n\n/*\r\n * Coordinates of the world center\r\n */\nLayoutConstants.WORLD_CENTER_X = 1200;\nLayoutConstants.WORLD_CENTER_Y = 900;\n\nmodule.exports = LayoutConstants;\n\n/***/ }),\n/* 1 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar LGraphObject = __webpack_require__(2);\nvar IGeometry = __webpack_require__(8);\nvar IMath = __webpack_require__(9);\n\nfunction LEdge(source, target, vEdge) {\n  LGraphObject.call(this, vEdge);\n\n  this.isOverlapingSourceAndTarget = false;\n  this.vGraphObject = vEdge;\n  this.bendpoints = [];\n  this.source = source;\n  this.target = target;\n}\n\nLEdge.prototype = Object.create(LGraphObject.prototype);\n\nfor (var prop in LGraphObject) {\n  LEdge[prop] = LGraphObject[prop];\n}\n\nLEdge.prototype.getSource = function () {\n  return this.source;\n};\n\nLEdge.prototype.getTarget = function () {\n  return this.target;\n};\n\nLEdge.prototype.isInterGraph = function () {\n  return this.isInterGraph;\n};\n\nLEdge.prototype.getLength = function () {\n  return this.length;\n};\n\nLEdge.prototype.isOverlapingSourceAndTarget = function () {\n  return this.isOverlapingSourceAndTarget;\n};\n\nLEdge.prototype.getBendpoints = function () {\n  return this.bendpoints;\n};\n\nLEdge.prototype.getLca = function () {\n  return this.lca;\n};\n\nLEdge.prototype.getSourceInLca = function () {\n  return this.sourceInLca;\n};\n\nLEdge.prototype.getTargetInLca = function () {\n  return this.targetInLca;\n};\n\nLEdge.prototype.getOtherEnd = function (node) {\n  if (this.source === node) {\n    return this.target;\n  } else if (this.target === node) {\n    return this.source;\n  } else {\n    throw \"Node is not incident with this edge\";\n  }\n};\n\nLEdge.prototype.getOtherEndInGraph = function (node, graph) {\n  var otherEnd = this.getOtherEnd(node);\n  var root = graph.getGraphManager().getRoot();\n\n  while (true) {\n    if (otherEnd.getOwner() == graph) {\n      return otherEnd;\n    }\n\n    if (otherEnd.getOwner() == root) {\n      break;\n    }\n\n    otherEnd = otherEnd.getOwner().getParent();\n  }\n\n  return null;\n};\n\nLEdge.prototype.updateLength = function () {\n  var clipPointCoordinates = new Array(4);\n\n  this.isOverlapingSourceAndTarget = IGeometry.getIntersection(this.target.getRect(), this.source.getRect(), clipPointCoordinates);\n\n  if (!this.isOverlapingSourceAndTarget) {\n    this.lengthX = clipPointCoordinates[0] - clipPointCoordinates[2];\n    this.lengthY = clipPointCoordinates[1] - clipPointCoordinates[3];\n\n    if (Math.abs(this.lengthX) < 1.0) {\n      this.lengthX = IMath.sign(this.lengthX);\n    }\n\n    if (Math.abs(this.lengthY) < 1.0) {\n      this.lengthY = IMath.sign(this.lengthY);\n    }\n\n    this.length = Math.sqrt(this.lengthX * this.lengthX + this.lengthY * this.lengthY);\n  }\n};\n\nLEdge.prototype.updateLengthSimple = function () {\n  this.lengthX = this.target.getCenterX() - this.source.getCenterX();\n  this.lengthY = this.target.getCenterY() - this.source.getCenterY();\n\n  if (Math.abs(this.lengthX) < 1.0) {\n    this.lengthX = IMath.sign(this.lengthX);\n  }\n\n  if (Math.abs(this.lengthY) < 1.0) {\n    this.lengthY = IMath.sign(this.lengthY);\n  }\n\n  this.length = Math.sqrt(this.lengthX * this.lengthX + this.lengthY * this.lengthY);\n};\n\nmodule.exports = LEdge;\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nfunction LGraphObject(vGraphObject) {\n  this.vGraphObject = vGraphObject;\n}\n\nmodule.exports = LGraphObject;\n\n/***/ }),\n/* 3 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar LGraphObject = __webpack_require__(2);\nvar Integer = __webpack_require__(10);\nvar RectangleD = __webpack_require__(13);\nvar LayoutConstants = __webpack_require__(0);\nvar RandomSeed = __webpack_require__(16);\nvar PointD = __webpack_require__(4);\n\nfunction LNode(gm, loc, size, vNode) {\n  //Alternative constructor 1 : LNode(LGraphManager gm, Point loc, Dimension size, Object vNode)\n  if (size == null && vNode == null) {\n    vNode = loc;\n  }\n\n  LGraphObject.call(this, vNode);\n\n  //Alternative constructor 2 : LNode(Layout layout, Object vNode)\n  if (gm.graphManager != null) gm = gm.graphManager;\n\n  this.estimatedSize = Integer.MIN_VALUE;\n  this.inclusionTreeDepth = Integer.MAX_VALUE;\n  this.vGraphObject = vNode;\n  this.edges = [];\n  this.graphManager = gm;\n\n  if (size != null && loc != null) this.rect = new RectangleD(loc.x, loc.y, size.width, size.height);else this.rect = new RectangleD();\n}\n\nLNode.prototype = Object.create(LGraphObject.prototype);\nfor (var prop in LGraphObject) {\n  LNode[prop] = LGraphObject[prop];\n}\n\nLNode.prototype.getEdges = function () {\n  return this.edges;\n};\n\nLNode.prototype.getChild = function () {\n  return this.child;\n};\n\nLNode.prototype.getOwner = function () {\n  //  if (this.owner != null) {\n  //    if (!(this.owner == null || this.owner.getNodes().indexOf(this) > -1)) {\n  //      throw \"assert failed\";\n  //    }\n  //  }\n\n  return this.owner;\n};\n\nLNode.prototype.getWidth = function () {\n  return this.rect.width;\n};\n\nLNode.prototype.setWidth = function (width) {\n  this.rect.width = width;\n};\n\nLNode.prototype.getHeight = function () {\n  return this.rect.height;\n};\n\nLNode.prototype.setHeight = function (height) {\n  this.rect.height = height;\n};\n\nLNode.prototype.getCenterX = function () {\n  return this.rect.x + this.rect.width / 2;\n};\n\nLNode.prototype.getCenterY = function () {\n  return this.rect.y + this.rect.height / 2;\n};\n\nLNode.prototype.getCenter = function () {\n  return new PointD(this.rect.x + this.rect.width / 2, this.rect.y + this.rect.height / 2);\n};\n\nLNode.prototype.getLocation = function () {\n  return new PointD(this.rect.x, this.rect.y);\n};\n\nLNode.prototype.getRect = function () {\n  return this.rect;\n};\n\nLNode.prototype.getDiagonal = function () {\n  return Math.sqrt(this.rect.width * this.rect.width + this.rect.height * this.rect.height);\n};\n\n/**\n * This method returns half the diagonal length of this node.\n */\nLNode.prototype.getHalfTheDiagonal = function () {\n  return Math.sqrt(this.rect.height * this.rect.height + this.rect.width * this.rect.width) / 2;\n};\n\nLNode.prototype.setRect = function (upperLeft, dimension) {\n  this.rect.x = upperLeft.x;\n  this.rect.y = upperLeft.y;\n  this.rect.width = dimension.width;\n  this.rect.height = dimension.height;\n};\n\nLNode.prototype.setCenter = function (cx, cy) {\n  this.rect.x = cx - this.rect.width / 2;\n  this.rect.y = cy - this.rect.height / 2;\n};\n\nLNode.prototype.setLocation = function (x, y) {\n  this.rect.x = x;\n  this.rect.y = y;\n};\n\nLNode.prototype.moveBy = function (dx, dy) {\n  this.rect.x += dx;\n  this.rect.y += dy;\n};\n\nLNode.prototype.getEdgeListToNode = function (to) {\n  var edgeList = [];\n  var edge;\n  var self = this;\n\n  self.edges.forEach(function (edge) {\n\n    if (edge.target == to) {\n      if (edge.source != self) throw \"Incorrect edge source!\";\n\n      edgeList.push(edge);\n    }\n  });\n\n  return edgeList;\n};\n\nLNode.prototype.getEdgesBetween = function (other) {\n  var edgeList = [];\n  var edge;\n\n  var self = this;\n  self.edges.forEach(function (edge) {\n\n    if (!(edge.source == self || edge.target == self)) throw \"Incorrect edge source and/or target\";\n\n    if (edge.target == other || edge.source == other) {\n      edgeList.push(edge);\n    }\n  });\n\n  return edgeList;\n};\n\nLNode.prototype.getNeighborsList = function () {\n  var neighbors = new Set();\n\n  var self = this;\n  self.edges.forEach(function (edge) {\n\n    if (edge.source == self) {\n      neighbors.add(edge.target);\n    } else {\n      if (edge.target != self) {\n        throw \"Incorrect incidency!\";\n      }\n\n      neighbors.add(edge.source);\n    }\n  });\n\n  return neighbors;\n};\n\nLNode.prototype.withChildren = function () {\n  var withNeighborsList = new Set();\n  var childNode;\n  var children;\n\n  withNeighborsList.add(this);\n\n  if (this.child != null) {\n    var nodes = this.child.getNodes();\n    for (var i = 0; i < nodes.length; i++) {\n      childNode = nodes[i];\n      children = childNode.withChildren();\n      children.forEach(function (node) {\n        withNeighborsList.add(node);\n      });\n    }\n  }\n\n  return withNeighborsList;\n};\n\nLNode.prototype.getNoOfChildren = function () {\n  var noOfChildren = 0;\n  var childNode;\n\n  if (this.child == null) {\n    noOfChildren = 1;\n  } else {\n    var nodes = this.child.getNodes();\n    for (var i = 0; i < nodes.length; i++) {\n      childNode = nodes[i];\n\n      noOfChildren += childNode.getNoOfChildren();\n    }\n  }\n\n  if (noOfChildren == 0) {\n    noOfChildren = 1;\n  }\n  return noOfChildren;\n};\n\nLNode.prototype.getEstimatedSize = function () {\n  if (this.estimatedSize == Integer.MIN_VALUE) {\n    throw \"assert failed\";\n  }\n  return this.estimatedSize;\n};\n\nLNode.prototype.calcEstimatedSize = function () {\n  if (this.child == null) {\n    return this.estimatedSize = (this.rect.width + this.rect.height) / 2;\n  } else {\n    this.estimatedSize = this.child.calcEstimatedSize();\n    this.rect.width = this.estimatedSize;\n    this.rect.height = this.estimatedSize;\n\n    return this.estimatedSize;\n  }\n};\n\nLNode.prototype.scatter = function () {\n  var randomCenterX;\n  var randomCenterY;\n\n  var minX = -LayoutConstants.INITIAL_WORLD_BOUNDARY;\n  var maxX = LayoutConstants.INITIAL_WORLD_BOUNDARY;\n  randomCenterX = LayoutConstants.WORLD_CENTER_X + RandomSeed.nextDouble() * (maxX - minX) + minX;\n\n  var minY = -LayoutConstants.INITIAL_WORLD_BOUNDARY;\n  var maxY = LayoutConstants.INITIAL_WORLD_BOUNDARY;\n  randomCenterY = LayoutConstants.WORLD_CENTER_Y + RandomSeed.nextDouble() * (maxY - minY) + minY;\n\n  this.rect.x = randomCenterX;\n  this.rect.y = randomCenterY;\n};\n\nLNode.prototype.updateBounds = function () {\n  if (this.getChild() == null) {\n    throw \"assert failed\";\n  }\n  if (this.getChild().getNodes().length != 0) {\n    // wrap the children nodes by re-arranging the boundaries\n    var childGraph = this.getChild();\n    childGraph.updateBounds(true);\n\n    this.rect.x = childGraph.getLeft();\n    this.rect.y = childGraph.getTop();\n\n    this.setWidth(childGraph.getRight() - childGraph.getLeft());\n    this.setHeight(childGraph.getBottom() - childGraph.getTop());\n\n    // Update compound bounds considering its label properties    \n    if (LayoutConstants.NODE_DIMENSIONS_INCLUDE_LABELS) {\n\n      var width = childGraph.getRight() - childGraph.getLeft();\n      var height = childGraph.getBottom() - childGraph.getTop();\n\n      if (this.labelWidth > width) {\n        this.rect.x -= (this.labelWidth - width) / 2;\n        this.setWidth(this.labelWidth);\n      }\n\n      if (this.labelHeight > height) {\n        if (this.labelPos == \"center\") {\n          this.rect.y -= (this.labelHeight - height) / 2;\n        } else if (this.labelPos == \"top\") {\n          this.rect.y -= this.labelHeight - height;\n        }\n        this.setHeight(this.labelHeight);\n      }\n    }\n  }\n};\n\nLNode.prototype.getInclusionTreeDepth = function () {\n  if (this.inclusionTreeDepth == Integer.MAX_VALUE) {\n    throw \"assert failed\";\n  }\n  return this.inclusionTreeDepth;\n};\n\nLNode.prototype.transform = function (trans) {\n  var left = this.rect.x;\n\n  if (left > LayoutConstants.WORLD_BOUNDARY) {\n    left = LayoutConstants.WORLD_BOUNDARY;\n  } else if (left < -LayoutConstants.WORLD_BOUNDARY) {\n    left = -LayoutConstants.WORLD_BOUNDARY;\n  }\n\n  var top = this.rect.y;\n\n  if (top > LayoutConstants.WORLD_BOUNDARY) {\n    top = LayoutConstants.WORLD_BOUNDARY;\n  } else if (top < -LayoutConstants.WORLD_BOUNDARY) {\n    top = -LayoutConstants.WORLD_BOUNDARY;\n  }\n\n  var leftTop = new PointD(left, top);\n  var vLeftTop = trans.inverseTransformPoint(leftTop);\n\n  this.setLocation(vLeftTop.x, vLeftTop.y);\n};\n\nLNode.prototype.getLeft = function () {\n  return this.rect.x;\n};\n\nLNode.prototype.getRight = function () {\n  return this.rect.x + this.rect.width;\n};\n\nLNode.prototype.getTop = function () {\n  return this.rect.y;\n};\n\nLNode.prototype.getBottom = function () {\n  return this.rect.y + this.rect.height;\n};\n\nLNode.prototype.getParent = function () {\n  if (this.owner == null) {\n    return null;\n  }\n\n  return this.owner.getParent();\n};\n\nmodule.exports = LNode;\n\n/***/ }),\n/* 4 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nfunction PointD(x, y) {\n  if (x == null && y == null) {\n    this.x = 0;\n    this.y = 0;\n  } else {\n    this.x = x;\n    this.y = y;\n  }\n}\n\nPointD.prototype.getX = function () {\n  return this.x;\n};\n\nPointD.prototype.getY = function () {\n  return this.y;\n};\n\nPointD.prototype.setX = function (x) {\n  this.x = x;\n};\n\nPointD.prototype.setY = function (y) {\n  this.y = y;\n};\n\nPointD.prototype.getDifference = function (pt) {\n  return new DimensionD(this.x - pt.x, this.y - pt.y);\n};\n\nPointD.prototype.getCopy = function () {\n  return new PointD(this.x, this.y);\n};\n\nPointD.prototype.translate = function (dim) {\n  this.x += dim.width;\n  this.y += dim.height;\n  return this;\n};\n\nmodule.exports = PointD;\n\n/***/ }),\n/* 5 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar LGraphObject = __webpack_require__(2);\nvar Integer = __webpack_require__(10);\nvar LayoutConstants = __webpack_require__(0);\nvar LGraphManager = __webpack_require__(6);\nvar LNode = __webpack_require__(3);\nvar LEdge = __webpack_require__(1);\nvar RectangleD = __webpack_require__(13);\nvar Point = __webpack_require__(12);\nvar LinkedList = __webpack_require__(11);\n\nfunction LGraph(parent, obj2, vGraph) {\n  LGraphObject.call(this, vGraph);\n  this.estimatedSize = Integer.MIN_VALUE;\n  this.margin = LayoutConstants.DEFAULT_GRAPH_MARGIN;\n  this.edges = [];\n  this.nodes = [];\n  this.isConnected = false;\n  this.parent = parent;\n\n  if (obj2 != null && obj2 instanceof LGraphManager) {\n    this.graphManager = obj2;\n  } else if (obj2 != null && obj2 instanceof Layout) {\n    this.graphManager = obj2.graphManager;\n  }\n}\n\nLGraph.prototype = Object.create(LGraphObject.prototype);\nfor (var prop in LGraphObject) {\n  LGraph[prop] = LGraphObject[prop];\n}\n\nLGraph.prototype.getNodes = function () {\n  return this.nodes;\n};\n\nLGraph.prototype.getEdges = function () {\n  return this.edges;\n};\n\nLGraph.prototype.getGraphManager = function () {\n  return this.graphManager;\n};\n\nLGraph.prototype.getParent = function () {\n  return this.parent;\n};\n\nLGraph.prototype.getLeft = function () {\n  return this.left;\n};\n\nLGraph.prototype.getRight = function () {\n  return this.right;\n};\n\nLGraph.prototype.getTop = function () {\n  return this.top;\n};\n\nLGraph.prototype.getBottom = function () {\n  return this.bottom;\n};\n\nLGraph.prototype.isConnected = function () {\n  return this.isConnected;\n};\n\nLGraph.prototype.add = function (obj1, sourceNode, targetNode) {\n  if (sourceNode == null && targetNode == null) {\n    var newNode = obj1;\n    if (this.graphManager == null) {\n      throw \"Graph has no graph mgr!\";\n    }\n    if (this.getNodes().indexOf(newNode) > -1) {\n      throw \"Node already in graph!\";\n    }\n    newNode.owner = this;\n    this.getNodes().push(newNode);\n\n    return newNode;\n  } else {\n    var newEdge = obj1;\n    if (!(this.getNodes().indexOf(sourceNode) > -1 && this.getNodes().indexOf(targetNode) > -1)) {\n      throw \"Source or target not in graph!\";\n    }\n\n    if (!(sourceNode.owner == targetNode.owner && sourceNode.owner == this)) {\n      throw \"Both owners must be this graph!\";\n    }\n\n    if (sourceNode.owner != targetNode.owner) {\n      return null;\n    }\n\n    // set source and target\n    newEdge.source = sourceNode;\n    newEdge.target = targetNode;\n\n    // set as intra-graph edge\n    newEdge.isInterGraph = false;\n\n    // add to graph edge list\n    this.getEdges().push(newEdge);\n\n    // add to incidency lists\n    sourceNode.edges.push(newEdge);\n\n    if (targetNode != sourceNode) {\n      targetNode.edges.push(newEdge);\n    }\n\n    return newEdge;\n  }\n};\n\nLGraph.prototype.remove = function (obj) {\n  var node = obj;\n  if (obj instanceof LNode) {\n    if (node == null) {\n      throw \"Node is null!\";\n    }\n    if (!(node.owner != null && node.owner == this)) {\n      throw \"Owner graph is invalid!\";\n    }\n    if (this.graphManager == null) {\n      throw \"Owner graph manager is invalid!\";\n    }\n    // remove incident edges first (make a copy to do it safely)\n    var edgesToBeRemoved = node.edges.slice();\n    var edge;\n    var s = edgesToBeRemoved.length;\n    for (var i = 0; i < s; i++) {\n      edge = edgesToBeRemoved[i];\n\n      if (edge.isInterGraph) {\n        this.graphManager.remove(edge);\n      } else {\n        edge.source.owner.remove(edge);\n      }\n    }\n\n    // now the node itself\n    var index = this.nodes.indexOf(node);\n    if (index == -1) {\n      throw \"Node not in owner node list!\";\n    }\n\n    this.nodes.splice(index, 1);\n  } else if (obj instanceof LEdge) {\n    var edge = obj;\n    if (edge == null) {\n      throw \"Edge is null!\";\n    }\n    if (!(edge.source != null && edge.target != null)) {\n      throw \"Source and/or target is null!\";\n    }\n    if (!(edge.source.owner != null && edge.target.owner != null && edge.source.owner == this && edge.target.owner == this)) {\n      throw \"Source and/or target owner is invalid!\";\n    }\n\n    var sourceIndex = edge.source.edges.indexOf(edge);\n    var targetIndex = edge.target.edges.indexOf(edge);\n    if (!(sourceIndex > -1 && targetIndex > -1)) {\n      throw \"Source and/or target doesn't know this edge!\";\n    }\n\n    edge.source.edges.splice(sourceIndex, 1);\n\n    if (edge.target != edge.source) {\n      edge.target.edges.splice(targetIndex, 1);\n    }\n\n    var index = edge.source.owner.getEdges().indexOf(edge);\n    if (index == -1) {\n      throw \"Not in owner's edge list!\";\n    }\n\n    edge.source.owner.getEdges().splice(index, 1);\n  }\n};\n\nLGraph.prototype.updateLeftTop = function () {\n  var top = Integer.MAX_VALUE;\n  var left = Integer.MAX_VALUE;\n  var nodeTop;\n  var nodeLeft;\n  var margin;\n\n  var nodes = this.getNodes();\n  var s = nodes.length;\n\n  for (var i = 0; i < s; i++) {\n    var lNode = nodes[i];\n    nodeTop = lNode.getTop();\n    nodeLeft = lNode.getLeft();\n\n    if (top > nodeTop) {\n      top = nodeTop;\n    }\n\n    if (left > nodeLeft) {\n      left = nodeLeft;\n    }\n  }\n\n  // Do we have any nodes in this graph?\n  if (top == Integer.MAX_VALUE) {\n    return null;\n  }\n\n  if (nodes[0].getParent().paddingLeft != undefined) {\n    margin = nodes[0].getParent().paddingLeft;\n  } else {\n    margin = this.margin;\n  }\n\n  this.left = left - margin;\n  this.top = top - margin;\n\n  // Apply the margins and return the result\n  return new Point(this.left, this.top);\n};\n\nLGraph.prototype.updateBounds = function (recursive) {\n  // calculate bounds\n  var left = Integer.MAX_VALUE;\n  var right = -Integer.MAX_VALUE;\n  var top = Integer.MAX_VALUE;\n  var bottom = -Integer.MAX_VALUE;\n  var nodeLeft;\n  var nodeRight;\n  var nodeTop;\n  var nodeBottom;\n  var margin;\n\n  var nodes = this.nodes;\n  var s = nodes.length;\n  for (var i = 0; i < s; i++) {\n    var lNode = nodes[i];\n\n    if (recursive && lNode.child != null) {\n      lNode.updateBounds();\n    }\n    nodeLeft = lNode.getLeft();\n    nodeRight = lNode.getRight();\n    nodeTop = lNode.getTop();\n    nodeBottom = lNode.getBottom();\n\n    if (left > nodeLeft) {\n      left = nodeLeft;\n    }\n\n    if (right < nodeRight) {\n      right = nodeRight;\n    }\n\n    if (top > nodeTop) {\n      top = nodeTop;\n    }\n\n    if (bottom < nodeBottom) {\n      bottom = nodeBottom;\n    }\n  }\n\n  var boundingRect = new RectangleD(left, top, right - left, bottom - top);\n  if (left == Integer.MAX_VALUE) {\n    this.left = this.parent.getLeft();\n    this.right = this.parent.getRight();\n    this.top = this.parent.getTop();\n    this.bottom = this.parent.getBottom();\n  }\n\n  if (nodes[0].getParent().paddingLeft != undefined) {\n    margin = nodes[0].getParent().paddingLeft;\n  } else {\n    margin = this.margin;\n  }\n\n  this.left = boundingRect.x - margin;\n  this.right = boundingRect.x + boundingRect.width + margin;\n  this.top = boundingRect.y - margin;\n  this.bottom = boundingRect.y + boundingRect.height + margin;\n};\n\nLGraph.calculateBounds = function (nodes) {\n  var left = Integer.MAX_VALUE;\n  var right = -Integer.MAX_VALUE;\n  var top = Integer.MAX_VALUE;\n  var bottom = -Integer.MAX_VALUE;\n  var nodeLeft;\n  var nodeRight;\n  var nodeTop;\n  var nodeBottom;\n\n  var s = nodes.length;\n\n  for (var i = 0; i < s; i++) {\n    var lNode = nodes[i];\n    nodeLeft = lNode.getLeft();\n    nodeRight = lNode.getRight();\n    nodeTop = lNode.getTop();\n    nodeBottom = lNode.getBottom();\n\n    if (left > nodeLeft) {\n      left = nodeLeft;\n    }\n\n    if (right < nodeRight) {\n      right = nodeRight;\n    }\n\n    if (top > nodeTop) {\n      top = nodeTop;\n    }\n\n    if (bottom < nodeBottom) {\n      bottom = nodeBottom;\n    }\n  }\n\n  var boundingRect = new RectangleD(left, top, right - left, bottom - top);\n\n  return boundingRect;\n};\n\nLGraph.prototype.getInclusionTreeDepth = function () {\n  if (this == this.graphManager.getRoot()) {\n    return 1;\n  } else {\n    return this.parent.getInclusionTreeDepth();\n  }\n};\n\nLGraph.prototype.getEstimatedSize = function () {\n  if (this.estimatedSize == Integer.MIN_VALUE) {\n    throw \"assert failed\";\n  }\n  return this.estimatedSize;\n};\n\nLGraph.prototype.calcEstimatedSize = function () {\n  var size = 0;\n  var nodes = this.nodes;\n  var s = nodes.length;\n\n  for (var i = 0; i < s; i++) {\n    var lNode = nodes[i];\n    size += lNode.calcEstimatedSize();\n  }\n\n  if (size == 0) {\n    this.estimatedSize = LayoutConstants.EMPTY_COMPOUND_NODE_SIZE;\n  } else {\n    this.estimatedSize = size / Math.sqrt(this.nodes.length);\n  }\n\n  return this.estimatedSize;\n};\n\nLGraph.prototype.updateConnected = function () {\n  var self = this;\n  if (this.nodes.length == 0) {\n    this.isConnected = true;\n    return;\n  }\n\n  var queue = new LinkedList();\n  var visited = new Set();\n  var currentNode = this.nodes[0];\n  var neighborEdges;\n  var currentNeighbor;\n  var childrenOfNode = currentNode.withChildren();\n  childrenOfNode.forEach(function (node) {\n    queue.push(node);\n    visited.add(node);\n  });\n\n  while (queue.length !== 0) {\n    currentNode = queue.shift();\n\n    // Traverse all neighbors of this node\n    neighborEdges = currentNode.getEdges();\n    var size = neighborEdges.length;\n    for (var i = 0; i < size; i++) {\n      var neighborEdge = neighborEdges[i];\n      currentNeighbor = neighborEdge.getOtherEndInGraph(currentNode, this);\n\n      // Add unvisited neighbors to the list to visit\n      if (currentNeighbor != null && !visited.has(currentNeighbor)) {\n        var childrenOfNeighbor = currentNeighbor.withChildren();\n\n        childrenOfNeighbor.forEach(function (node) {\n          queue.push(node);\n          visited.add(node);\n        });\n      }\n    }\n  }\n\n  this.isConnected = false;\n\n  if (visited.size >= this.nodes.length) {\n    var noOfVisitedInThisGraph = 0;\n\n    visited.forEach(function (visitedNode) {\n      if (visitedNode.owner == self) {\n        noOfVisitedInThisGraph++;\n      }\n    });\n\n    if (noOfVisitedInThisGraph == this.nodes.length) {\n      this.isConnected = true;\n    }\n  }\n};\n\nmodule.exports = LGraph;\n\n/***/ }),\n/* 6 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar LGraph;\nvar LEdge = __webpack_require__(1);\n\nfunction LGraphManager(layout) {\n  LGraph = __webpack_require__(5); // It may be better to initilize this out of this function but it gives an error (Right-hand side of 'instanceof' is not callable) now.\n  this.layout = layout;\n\n  this.graphs = [];\n  this.edges = [];\n}\n\nLGraphManager.prototype.addRoot = function () {\n  var ngraph = this.layout.newGraph();\n  var nnode = this.layout.newNode(null);\n  var root = this.add(ngraph, nnode);\n  this.setRootGraph(root);\n  return this.rootGraph;\n};\n\nLGraphManager.prototype.add = function (newGraph, parentNode, newEdge, sourceNode, targetNode) {\n  //there are just 2 parameters are passed then it adds an LGraph else it adds an LEdge\n  if (newEdge == null && sourceNode == null && targetNode == null) {\n    if (newGraph == null) {\n      throw \"Graph is null!\";\n    }\n    if (parentNode == null) {\n      throw \"Parent node is null!\";\n    }\n    if (this.graphs.indexOf(newGraph) > -1) {\n      throw \"Graph already in this graph mgr!\";\n    }\n\n    this.graphs.push(newGraph);\n\n    if (newGraph.parent != null) {\n      throw \"Already has a parent!\";\n    }\n    if (parentNode.child != null) {\n      throw \"Already has a child!\";\n    }\n\n    newGraph.parent = parentNode;\n    parentNode.child = newGraph;\n\n    return newGraph;\n  } else {\n    //change the order of the parameters\n    targetNode = newEdge;\n    sourceNode = parentNode;\n    newEdge = newGraph;\n    var sourceGraph = sourceNode.getOwner();\n    var targetGraph = targetNode.getOwner();\n\n    if (!(sourceGraph != null && sourceGraph.getGraphManager() == this)) {\n      throw \"Source not in this graph mgr!\";\n    }\n    if (!(targetGraph != null && targetGraph.getGraphManager() == this)) {\n      throw \"Target not in this graph mgr!\";\n    }\n\n    if (sourceGraph == targetGraph) {\n      newEdge.isInterGraph = false;\n      return sourceGraph.add(newEdge, sourceNode, targetNode);\n    } else {\n      newEdge.isInterGraph = true;\n\n      // set source and target\n      newEdge.source = sourceNode;\n      newEdge.target = targetNode;\n\n      // add edge to inter-graph edge list\n      if (this.edges.indexOf(newEdge) > -1) {\n        throw \"Edge already in inter-graph edge list!\";\n      }\n\n      this.edges.push(newEdge);\n\n      // add edge to source and target incidency lists\n      if (!(newEdge.source != null && newEdge.target != null)) {\n        throw \"Edge source and/or target is null!\";\n      }\n\n      if (!(newEdge.source.edges.indexOf(newEdge) == -1 && newEdge.target.edges.indexOf(newEdge) == -1)) {\n        throw \"Edge already in source and/or target incidency list!\";\n      }\n\n      newEdge.source.edges.push(newEdge);\n      newEdge.target.edges.push(newEdge);\n\n      return newEdge;\n    }\n  }\n};\n\nLGraphManager.prototype.remove = function (lObj) {\n  if (lObj instanceof LGraph) {\n    var graph = lObj;\n    if (graph.getGraphManager() != this) {\n      throw \"Graph not in this graph mgr\";\n    }\n    if (!(graph == this.rootGraph || graph.parent != null && graph.parent.graphManager == this)) {\n      throw \"Invalid parent node!\";\n    }\n\n    // first the edges (make a copy to do it safely)\n    var edgesToBeRemoved = [];\n\n    edgesToBeRemoved = edgesToBeRemoved.concat(graph.getEdges());\n\n    var edge;\n    var s = edgesToBeRemoved.length;\n    for (var i = 0; i < s; i++) {\n      edge = edgesToBeRemoved[i];\n      graph.remove(edge);\n    }\n\n    // then the nodes (make a copy to do it safely)\n    var nodesToBeRemoved = [];\n\n    nodesToBeRemoved = nodesToBeRemoved.concat(graph.getNodes());\n\n    var node;\n    s = nodesToBeRemoved.length;\n    for (var i = 0; i < s; i++) {\n      node = nodesToBeRemoved[i];\n      graph.remove(node);\n    }\n\n    // check if graph is the root\n    if (graph == this.rootGraph) {\n      this.setRootGraph(null);\n    }\n\n    // now remove the graph itself\n    var index = this.graphs.indexOf(graph);\n    this.graphs.splice(index, 1);\n\n    // also reset the parent of the graph\n    graph.parent = null;\n  } else if (lObj instanceof LEdge) {\n    edge = lObj;\n    if (edge == null) {\n      throw \"Edge is null!\";\n    }\n    if (!edge.isInterGraph) {\n      throw \"Not an inter-graph edge!\";\n    }\n    if (!(edge.source != null && edge.target != null)) {\n      throw \"Source and/or target is null!\";\n    }\n\n    // remove edge from source and target nodes' incidency lists\n\n    if (!(edge.source.edges.indexOf(edge) != -1 && edge.target.edges.indexOf(edge) != -1)) {\n      throw \"Source and/or target doesn't know this edge!\";\n    }\n\n    var index = edge.source.edges.indexOf(edge);\n    edge.source.edges.splice(index, 1);\n    index = edge.target.edges.indexOf(edge);\n    edge.target.edges.splice(index, 1);\n\n    // remove edge from owner graph manager's inter-graph edge list\n\n    if (!(edge.source.owner != null && edge.source.owner.getGraphManager() != null)) {\n      throw \"Edge owner graph or owner graph manager is null!\";\n    }\n    if (edge.source.owner.getGraphManager().edges.indexOf(edge) == -1) {\n      throw \"Not in owner graph manager's edge list!\";\n    }\n\n    var index = edge.source.owner.getGraphManager().edges.indexOf(edge);\n    edge.source.owner.getGraphManager().edges.splice(index, 1);\n  }\n};\n\nLGraphManager.prototype.updateBounds = function () {\n  this.rootGraph.updateBounds(true);\n};\n\nLGraphManager.prototype.getGraphs = function () {\n  return this.graphs;\n};\n\nLGraphManager.prototype.getAllNodes = function () {\n  if (this.allNodes == null) {\n    var nodeList = [];\n    var graphs = this.getGraphs();\n    var s = graphs.length;\n    for (var i = 0; i < s; i++) {\n      nodeList = nodeList.concat(graphs[i].getNodes());\n    }\n    this.allNodes = nodeList;\n  }\n  return this.allNodes;\n};\n\nLGraphManager.prototype.resetAllNodes = function () {\n  this.allNodes = null;\n};\n\nLGraphManager.prototype.resetAllEdges = function () {\n  this.allEdges = null;\n};\n\nLGraphManager.prototype.resetAllNodesToApplyGravitation = function () {\n  this.allNodesToApplyGravitation = null;\n};\n\nLGraphManager.prototype.getAllEdges = function () {\n  if (this.allEdges == null) {\n    var edgeList = [];\n    var graphs = this.getGraphs();\n    var s = graphs.length;\n    for (var i = 0; i < graphs.length; i++) {\n      edgeList = edgeList.concat(graphs[i].getEdges());\n    }\n\n    edgeList = edgeList.concat(this.edges);\n\n    this.allEdges = edgeList;\n  }\n  return this.allEdges;\n};\n\nLGraphManager.prototype.getAllNodesToApplyGravitation = function () {\n  return this.allNodesToApplyGravitation;\n};\n\nLGraphManager.prototype.setAllNodesToApplyGravitation = function (nodeList) {\n  if (this.allNodesToApplyGravitation != null) {\n    throw \"assert failed\";\n  }\n\n  this.allNodesToApplyGravitation = nodeList;\n};\n\nLGraphManager.prototype.getRoot = function () {\n  return this.rootGraph;\n};\n\nLGraphManager.prototype.setRootGraph = function (graph) {\n  if (graph.getGraphManager() != this) {\n    throw \"Root not in this graph mgr!\";\n  }\n\n  this.rootGraph = graph;\n  // root graph must have a root node associated with it for convenience\n  if (graph.parent == null) {\n    graph.parent = this.layout.newNode(\"Root node\");\n  }\n};\n\nLGraphManager.prototype.getLayout = function () {\n  return this.layout;\n};\n\nLGraphManager.prototype.isOneAncestorOfOther = function (firstNode, secondNode) {\n  if (!(firstNode != null && secondNode != null)) {\n    throw \"assert failed\";\n  }\n\n  if (firstNode == secondNode) {\n    return true;\n  }\n  // Is second node an ancestor of the first one?\n  var ownerGraph = firstNode.getOwner();\n  var parentNode;\n\n  do {\n    parentNode = ownerGraph.getParent();\n\n    if (parentNode == null) {\n      break;\n    }\n\n    if (parentNode == secondNode) {\n      return true;\n    }\n\n    ownerGraph = parentNode.getOwner();\n    if (ownerGraph == null) {\n      break;\n    }\n  } while (true);\n  // Is first node an ancestor of the second one?\n  ownerGraph = secondNode.getOwner();\n\n  do {\n    parentNode = ownerGraph.getParent();\n\n    if (parentNode == null) {\n      break;\n    }\n\n    if (parentNode == firstNode) {\n      return true;\n    }\n\n    ownerGraph = parentNode.getOwner();\n    if (ownerGraph == null) {\n      break;\n    }\n  } while (true);\n\n  return false;\n};\n\nLGraphManager.prototype.calcLowestCommonAncestors = function () {\n  var edge;\n  var sourceNode;\n  var targetNode;\n  var sourceAncestorGraph;\n  var targetAncestorGraph;\n\n  var edges = this.getAllEdges();\n  var s = edges.length;\n  for (var i = 0; i < s; i++) {\n    edge = edges[i];\n\n    sourceNode = edge.source;\n    targetNode = edge.target;\n    edge.lca = null;\n    edge.sourceInLca = sourceNode;\n    edge.targetInLca = targetNode;\n\n    if (sourceNode == targetNode) {\n      edge.lca = sourceNode.getOwner();\n      continue;\n    }\n\n    sourceAncestorGraph = sourceNode.getOwner();\n\n    while (edge.lca == null) {\n      edge.targetInLca = targetNode;\n      targetAncestorGraph = targetNode.getOwner();\n\n      while (edge.lca == null) {\n        if (targetAncestorGraph == sourceAncestorGraph) {\n          edge.lca = targetAncestorGraph;\n          break;\n        }\n\n        if (targetAncestorGraph == this.rootGraph) {\n          break;\n        }\n\n        if (edge.lca != null) {\n          throw \"assert failed\";\n        }\n        edge.targetInLca = targetAncestorGraph.getParent();\n        targetAncestorGraph = edge.targetInLca.getOwner();\n      }\n\n      if (sourceAncestorGraph == this.rootGraph) {\n        break;\n      }\n\n      if (edge.lca == null) {\n        edge.sourceInLca = sourceAncestorGraph.getParent();\n        sourceAncestorGraph = edge.sourceInLca.getOwner();\n      }\n    }\n\n    if (edge.lca == null) {\n      throw \"assert failed\";\n    }\n  }\n};\n\nLGraphManager.prototype.calcLowestCommonAncestor = function (firstNode, secondNode) {\n  if (firstNode == secondNode) {\n    return firstNode.getOwner();\n  }\n  var firstOwnerGraph = firstNode.getOwner();\n\n  do {\n    if (firstOwnerGraph == null) {\n      break;\n    }\n    var secondOwnerGraph = secondNode.getOwner();\n\n    do {\n      if (secondOwnerGraph == null) {\n        break;\n      }\n\n      if (secondOwnerGraph == firstOwnerGraph) {\n        return secondOwnerGraph;\n      }\n      secondOwnerGraph = secondOwnerGraph.getParent().getOwner();\n    } while (true);\n\n    firstOwnerGraph = firstOwnerGraph.getParent().getOwner();\n  } while (true);\n\n  return firstOwnerGraph;\n};\n\nLGraphManager.prototype.calcInclusionTreeDepths = function (graph, depth) {\n  if (graph == null && depth == null) {\n    graph = this.rootGraph;\n    depth = 1;\n  }\n  var node;\n\n  var nodes = graph.getNodes();\n  var s = nodes.length;\n  for (var i = 0; i < s; i++) {\n    node = nodes[i];\n    node.inclusionTreeDepth = depth;\n\n    if (node.child != null) {\n      this.calcInclusionTreeDepths(node.child, depth + 1);\n    }\n  }\n};\n\nLGraphManager.prototype.includesInvalidEdge = function () {\n  var edge;\n\n  var s = this.edges.length;\n  for (var i = 0; i < s; i++) {\n    edge = this.edges[i];\n\n    if (this.isOneAncestorOfOther(edge.source, edge.target)) {\n      return true;\n    }\n  }\n  return false;\n};\n\nmodule.exports = LGraphManager;\n\n/***/ }),\n/* 7 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar LayoutConstants = __webpack_require__(0);\n\nfunction FDLayoutConstants() {}\n\n//FDLayoutConstants inherits static props in LayoutConstants\nfor (var prop in LayoutConstants) {\n  FDLayoutConstants[prop] = LayoutConstants[prop];\n}\n\nFDLayoutConstants.MAX_ITERATIONS = 2500;\n\nFDLayoutConstants.DEFAULT_EDGE_LENGTH = 50;\nFDLayoutConstants.DEFAULT_SPRING_STRENGTH = 0.45;\nFDLayoutConstants.DEFAULT_REPULSION_STRENGTH = 4500.0;\nFDLayoutConstants.DEFAULT_GRAVITY_STRENGTH = 0.4;\nFDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_STRENGTH = 1.0;\nFDLayoutConstants.DEFAULT_GRAVITY_RANGE_FACTOR = 3.8;\nFDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR = 1.5;\nFDLayoutConstants.DEFAULT_USE_SMART_IDEAL_EDGE_LENGTH_CALCULATION = true;\nFDLayoutConstants.DEFAULT_USE_SMART_REPULSION_RANGE_CALCULATION = true;\nFDLayoutConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL = 0.3;\nFDLayoutConstants.COOLING_ADAPTATION_FACTOR = 0.33;\nFDLayoutConstants.ADAPTATION_LOWER_NODE_LIMIT = 1000;\nFDLayoutConstants.ADAPTATION_UPPER_NODE_LIMIT = 5000;\nFDLayoutConstants.MAX_NODE_DISPLACEMENT_INCREMENTAL = 100.0;\nFDLayoutConstants.MAX_NODE_DISPLACEMENT = FDLayoutConstants.MAX_NODE_DISPLACEMENT_INCREMENTAL * 3;\nFDLayoutConstants.MIN_REPULSION_DIST = FDLayoutConstants.DEFAULT_EDGE_LENGTH / 10.0;\nFDLayoutConstants.CONVERGENCE_CHECK_PERIOD = 100;\nFDLayoutConstants.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR = 0.1;\nFDLayoutConstants.MIN_EDGE_LENGTH = 1;\nFDLayoutConstants.GRID_CALCULATION_CHECK_PERIOD = 10;\n\nmodule.exports = FDLayoutConstants;\n\n/***/ }),\n/* 8 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/**\n * This class maintains a list of static geometry related utility methods.\n *\n *\n * Copyright: i-Vis Research Group, Bilkent University, 2007 - present\n */\n\nvar Point = __webpack_require__(12);\n\nfunction IGeometry() {}\n\n/**\n * This method calculates *half* the amount in x and y directions of the two\n * input rectangles needed to separate them keeping their respective\n * positioning, and returns the result in the input array. An input\n * separation buffer added to the amount in both directions. We assume that\n * the two rectangles do intersect.\n */\nIGeometry.calcSeparationAmount = function (rectA, rectB, overlapAmount, separationBuffer) {\n  if (!rectA.intersects(rectB)) {\n    throw \"assert failed\";\n  }\n\n  var directions = new Array(2);\n\n  this.decideDirectionsForOverlappingNodes(rectA, rectB, directions);\n\n  overlapAmount[0] = Math.min(rectA.getRight(), rectB.getRight()) - Math.max(rectA.x, rectB.x);\n  overlapAmount[1] = Math.min(rectA.getBottom(), rectB.getBottom()) - Math.max(rectA.y, rectB.y);\n\n  // update the overlapping amounts for the following cases:\n  if (rectA.getX() <= rectB.getX() && rectA.getRight() >= rectB.getRight()) {\n    /* Case x.1:\n    *\n    * rectA\n    * \t|                       |\n    * \t|        _________      |\n    * \t|        |       |      |\n    * \t|________|_______|______|\n    * \t\t\t |       |\n    *           |       |\n    *        rectB\n    */\n    overlapAmount[0] += Math.min(rectB.getX() - rectA.getX(), rectA.getRight() - rectB.getRight());\n  } else if (rectB.getX() <= rectA.getX() && rectB.getRight() >= rectA.getRight()) {\n    /* Case x.2:\n    *\n    * rectB\n    * \t|                       |\n    * \t|        _________      |\n    * \t|        |       |      |\n    * \t|________|_______|______|\n    * \t\t\t |       |\n    *           |       |\n    *        rectA\n    */\n    overlapAmount[0] += Math.min(rectA.getX() - rectB.getX(), rectB.getRight() - rectA.getRight());\n  }\n  if (rectA.getY() <= rectB.getY() && rectA.getBottom() >= rectB.getBottom()) {\n    /* Case y.1:\n     *          ________ rectA\n     *         |\n     *         |\n     *   ______|____  rectB\n     *         |    |\n     *         |    |\n     *   ______|____|\n     *         |\n     *         |\n     *         |________\n     *\n     */\n    overlapAmount[1] += Math.min(rectB.getY() - rectA.getY(), rectA.getBottom() - rectB.getBottom());\n  } else if (rectB.getY() <= rectA.getY() && rectB.getBottom() >= rectA.getBottom()) {\n    /* Case y.2:\n    *          ________ rectB\n    *         |\n    *         |\n    *   ______|____  rectA\n    *         |    |\n    *         |    |\n    *   ______|____|\n    *         |\n    *         |\n    *         |________\n    *\n    */\n    overlapAmount[1] += Math.min(rectA.getY() - rectB.getY(), rectB.getBottom() - rectA.getBottom());\n  }\n\n  // find slope of the line passes two centers\n  var slope = Math.abs((rectB.getCenterY() - rectA.getCenterY()) / (rectB.getCenterX() - rectA.getCenterX()));\n  // if centers are overlapped\n  if (rectB.getCenterY() === rectA.getCenterY() && rectB.getCenterX() === rectA.getCenterX()) {\n    // assume the slope is 1 (45 degree)\n    slope = 1.0;\n  }\n\n  var moveByY = slope * overlapAmount[0];\n  var moveByX = overlapAmount[1] / slope;\n  if (overlapAmount[0] < moveByX) {\n    moveByX = overlapAmount[0];\n  } else {\n    moveByY = overlapAmount[1];\n  }\n  // return half the amount so that if each rectangle is moved by these\n  // amounts in opposite directions, overlap will be resolved\n  overlapAmount[0] = -1 * directions[0] * (moveByX / 2 + separationBuffer);\n  overlapAmount[1] = -1 * directions[1] * (moveByY / 2 + separationBuffer);\n};\n\n/**\n * This method decides the separation direction of overlapping nodes\n *\n * if directions[0] = -1, then rectA goes left\n * if directions[0] = 1,  then rectA goes right\n * if directions[1] = -1, then rectA goes up\n * if directions[1] = 1,  then rectA goes down\n */\nIGeometry.decideDirectionsForOverlappingNodes = function (rectA, rectB, directions) {\n  if (rectA.getCenterX() < rectB.getCenterX()) {\n    directions[0] = -1;\n  } else {\n    directions[0] = 1;\n  }\n\n  if (rectA.getCenterY() < rectB.getCenterY()) {\n    directions[1] = -1;\n  } else {\n    directions[1] = 1;\n  }\n};\n\n/**\n * This method calculates the intersection (clipping) points of the two\n * input rectangles with line segment defined by the centers of these two\n * rectangles. The clipping points are saved in the input double array and\n * whether or not the two rectangles overlap is returned.\n */\nIGeometry.getIntersection2 = function (rectA, rectB, result) {\n  //result[0-1] will contain clipPoint of rectA, result[2-3] will contain clipPoint of rectB\n  var p1x = rectA.getCenterX();\n  var p1y = rectA.getCenterY();\n  var p2x = rectB.getCenterX();\n  var p2y = rectB.getCenterY();\n\n  //if two rectangles intersect, then clipping points are centers\n  if (rectA.intersects(rectB)) {\n    result[0] = p1x;\n    result[1] = p1y;\n    result[2] = p2x;\n    result[3] = p2y;\n    return true;\n  }\n  //variables for rectA\n  var topLeftAx = rectA.getX();\n  var topLeftAy = rectA.getY();\n  var topRightAx = rectA.getRight();\n  var bottomLeftAx = rectA.getX();\n  var bottomLeftAy = rectA.getBottom();\n  var bottomRightAx = rectA.getRight();\n  var halfWidthA = rectA.getWidthHalf();\n  var halfHeightA = rectA.getHeightHalf();\n  //variables for rectB\n  var topLeftBx = rectB.getX();\n  var topLeftBy = rectB.getY();\n  var topRightBx = rectB.getRight();\n  var bottomLeftBx = rectB.getX();\n  var bottomLeftBy = rectB.getBottom();\n  var bottomRightBx = rectB.getRight();\n  var halfWidthB = rectB.getWidthHalf();\n  var halfHeightB = rectB.getHeightHalf();\n\n  //flag whether clipping points are found\n  var clipPointAFound = false;\n  var clipPointBFound = false;\n\n  // line is vertical\n  if (p1x === p2x) {\n    if (p1y > p2y) {\n      result[0] = p1x;\n      result[1] = topLeftAy;\n      result[2] = p2x;\n      result[3] = bottomLeftBy;\n      return false;\n    } else if (p1y < p2y) {\n      result[0] = p1x;\n      result[1] = bottomLeftAy;\n      result[2] = p2x;\n      result[3] = topLeftBy;\n      return false;\n    } else {\n      //not line, return null;\n    }\n  }\n  // line is horizontal\n  else if (p1y === p2y) {\n      if (p1x > p2x) {\n        result[0] = topLeftAx;\n        result[1] = p1y;\n        result[2] = topRightBx;\n        result[3] = p2y;\n        return false;\n      } else if (p1x < p2x) {\n        result[0] = topRightAx;\n        result[1] = p1y;\n        result[2] = topLeftBx;\n        result[3] = p2y;\n        return false;\n      } else {\n        //not valid line, return null;\n      }\n    } else {\n      //slopes of rectA's and rectB's diagonals\n      var slopeA = rectA.height / rectA.width;\n      var slopeB = rectB.height / rectB.width;\n\n      //slope of line between center of rectA and center of rectB\n      var slopePrime = (p2y - p1y) / (p2x - p1x);\n      var cardinalDirectionA = void 0;\n      var cardinalDirectionB = void 0;\n      var tempPointAx = void 0;\n      var tempPointAy = void 0;\n      var tempPointBx = void 0;\n      var tempPointBy = void 0;\n\n      //determine whether clipping point is the corner of nodeA\n      if (-slopeA === slopePrime) {\n        if (p1x > p2x) {\n          result[0] = bottomLeftAx;\n          result[1] = bottomLeftAy;\n          clipPointAFound = true;\n        } else {\n          result[0] = topRightAx;\n          result[1] = topLeftAy;\n          clipPointAFound = true;\n        }\n      } else if (slopeA === slopePrime) {\n        if (p1x > p2x) {\n          result[0] = topLeftAx;\n          result[1] = topLeftAy;\n          clipPointAFound = true;\n        } else {\n          result[0] = bottomRightAx;\n          result[1] = bottomLeftAy;\n          clipPointAFound = true;\n        }\n      }\n\n      //determine whether clipping point is the corner of nodeB\n      if (-slopeB === slopePrime) {\n        if (p2x > p1x) {\n          result[2] = bottomLeftBx;\n          result[3] = bottomLeftBy;\n          clipPointBFound = true;\n        } else {\n          result[2] = topRightBx;\n          result[3] = topLeftBy;\n          clipPointBFound = true;\n        }\n      } else if (slopeB === slopePrime) {\n        if (p2x > p1x) {\n          result[2] = topLeftBx;\n          result[3] = topLeftBy;\n          clipPointBFound = true;\n        } else {\n          result[2] = bottomRightBx;\n          result[3] = bottomLeftBy;\n          clipPointBFound = true;\n        }\n      }\n\n      //if both clipping points are corners\n      if (clipPointAFound && clipPointBFound) {\n        return false;\n      }\n\n      //determine Cardinal Direction of rectangles\n      if (p1x > p2x) {\n        if (p1y > p2y) {\n          cardinalDirectionA = this.getCardinalDirection(slopeA, slopePrime, 4);\n          cardinalDirectionB = this.getCardinalDirection(slopeB, slopePrime, 2);\n        } else {\n          cardinalDirectionA = this.getCardinalDirection(-slopeA, slopePrime, 3);\n          cardinalDirectionB = this.getCardinalDirection(-slopeB, slopePrime, 1);\n        }\n      } else {\n        if (p1y > p2y) {\n          cardinalDirectionA = this.getCardinalDirection(-slopeA, slopePrime, 1);\n          cardinalDirectionB = this.getCardinalDirection(-slopeB, slopePrime, 3);\n        } else {\n          cardinalDirectionA = this.getCardinalDirection(slopeA, slopePrime, 2);\n          cardinalDirectionB = this.getCardinalDirection(slopeB, slopePrime, 4);\n        }\n      }\n      //calculate clipping Point if it is not found before\n      if (!clipPointAFound) {\n        switch (cardinalDirectionA) {\n          case 1:\n            tempPointAy = topLeftAy;\n            tempPointAx = p1x + -halfHeightA / slopePrime;\n            result[0] = tempPointAx;\n            result[1] = tempPointAy;\n            break;\n          case 2:\n            tempPointAx = bottomRightAx;\n            tempPointAy = p1y + halfWidthA * slopePrime;\n            result[0] = tempPointAx;\n            result[1] = tempPointAy;\n            break;\n          case 3:\n            tempPointAy = bottomLeftAy;\n            tempPointAx = p1x + halfHeightA / slopePrime;\n            result[0] = tempPointAx;\n            result[1] = tempPointAy;\n            break;\n          case 4:\n            tempPointAx = bottomLeftAx;\n            tempPointAy = p1y + -halfWidthA * slopePrime;\n            result[0] = tempPointAx;\n            result[1] = tempPointAy;\n            break;\n        }\n      }\n      if (!clipPointBFound) {\n        switch (cardinalDirectionB) {\n          case 1:\n            tempPointBy = topLeftBy;\n            tempPointBx = p2x + -halfHeightB / slopePrime;\n            result[2] = tempPointBx;\n            result[3] = tempPointBy;\n            break;\n          case 2:\n            tempPointBx = bottomRightBx;\n            tempPointBy = p2y + halfWidthB * slopePrime;\n            result[2] = tempPointBx;\n            result[3] = tempPointBy;\n            break;\n          case 3:\n            tempPointBy = bottomLeftBy;\n            tempPointBx = p2x + halfHeightB / slopePrime;\n            result[2] = tempPointBx;\n            result[3] = tempPointBy;\n            break;\n          case 4:\n            tempPointBx = bottomLeftBx;\n            tempPointBy = p2y + -halfWidthB * slopePrime;\n            result[2] = tempPointBx;\n            result[3] = tempPointBy;\n            break;\n        }\n      }\n    }\n  return false;\n};\n\n/**\n * This method returns in which cardinal direction does input point stays\n * 1: North\n * 2: East\n * 3: South\n * 4: West\n */\nIGeometry.getCardinalDirection = function (slope, slopePrime, line) {\n  if (slope > slopePrime) {\n    return line;\n  } else {\n    return 1 + line % 4;\n  }\n};\n\n/**\n * This method calculates the intersection of the two lines defined by\n * point pairs (s1,s2) and (f1,f2).\n */\nIGeometry.getIntersection = function (s1, s2, f1, f2) {\n  if (f2 == null) {\n    return this.getIntersection2(s1, s2, f1);\n  }\n\n  var x1 = s1.x;\n  var y1 = s1.y;\n  var x2 = s2.x;\n  var y2 = s2.y;\n  var x3 = f1.x;\n  var y3 = f1.y;\n  var x4 = f2.x;\n  var y4 = f2.y;\n  var x = void 0,\n      y = void 0; // intersection point\n  var a1 = void 0,\n      a2 = void 0,\n      b1 = void 0,\n      b2 = void 0,\n      c1 = void 0,\n      c2 = void 0; // coefficients of line eqns.\n  var denom = void 0;\n\n  a1 = y2 - y1;\n  b1 = x1 - x2;\n  c1 = x2 * y1 - x1 * y2; // { a1*x + b1*y + c1 = 0 is line 1 }\n\n  a2 = y4 - y3;\n  b2 = x3 - x4;\n  c2 = x4 * y3 - x3 * y4; // { a2*x + b2*y + c2 = 0 is line 2 }\n\n  denom = a1 * b2 - a2 * b1;\n\n  if (denom === 0) {\n    return null;\n  }\n\n  x = (b1 * c2 - b2 * c1) / denom;\n  y = (a2 * c1 - a1 * c2) / denom;\n\n  return new Point(x, y);\n};\n\n/**\n * This method finds and returns the angle of the vector from the + x-axis\n * in clockwise direction (compatible w/ Java coordinate system!).\n */\nIGeometry.angleOfVector = function (Cx, Cy, Nx, Ny) {\n  var C_angle = void 0;\n\n  if (Cx !== Nx) {\n    C_angle = Math.atan((Ny - Cy) / (Nx - Cx));\n\n    if (Nx < Cx) {\n      C_angle += Math.PI;\n    } else if (Ny < Cy) {\n      C_angle += this.TWO_PI;\n    }\n  } else if (Ny < Cy) {\n    C_angle = this.ONE_AND_HALF_PI; // 270 degrees\n  } else {\n    C_angle = this.HALF_PI; // 90 degrees\n  }\n\n  return C_angle;\n};\n\n/**\n * This method checks whether the given two line segments (one with point\n * p1 and p2, the other with point p3 and p4) intersect at a point other\n * than these points.\n */\nIGeometry.doIntersect = function (p1, p2, p3, p4) {\n  var a = p1.x;\n  var b = p1.y;\n  var c = p2.x;\n  var d = p2.y;\n  var p = p3.x;\n  var q = p3.y;\n  var r = p4.x;\n  var s = p4.y;\n  var det = (c - a) * (s - q) - (r - p) * (d - b);\n\n  if (det === 0) {\n    return false;\n  } else {\n    var lambda = ((s - q) * (r - a) + (p - r) * (s - b)) / det;\n    var gamma = ((b - d) * (r - a) + (c - a) * (s - b)) / det;\n    return 0 < lambda && lambda < 1 && 0 < gamma && gamma < 1;\n  }\n};\n\n// -----------------------------------------------------------------------------\n// Section: Class Constants\n// -----------------------------------------------------------------------------\n/**\n * Some useful pre-calculated constants\n */\nIGeometry.HALF_PI = 0.5 * Math.PI;\nIGeometry.ONE_AND_HALF_PI = 1.5 * Math.PI;\nIGeometry.TWO_PI = 2.0 * Math.PI;\nIGeometry.THREE_PI = 3.0 * Math.PI;\n\nmodule.exports = IGeometry;\n\n/***/ }),\n/* 9 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nfunction IMath() {}\n\n/**\n * This method returns the sign of the input value.\n */\nIMath.sign = function (value) {\n  if (value > 0) {\n    return 1;\n  } else if (value < 0) {\n    return -1;\n  } else {\n    return 0;\n  }\n};\n\nIMath.floor = function (value) {\n  return value < 0 ? Math.ceil(value) : Math.floor(value);\n};\n\nIMath.ceil = function (value) {\n  return value < 0 ? Math.floor(value) : Math.ceil(value);\n};\n\nmodule.exports = IMath;\n\n/***/ }),\n/* 10 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nfunction Integer() {}\n\nInteger.MAX_VALUE = 2147483647;\nInteger.MIN_VALUE = -2147483648;\n\nmodule.exports = Integer;\n\n/***/ }),\n/* 11 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _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; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\nvar nodeFrom = function nodeFrom(value) {\n  return { value: value, next: null, prev: null };\n};\n\nvar add = function add(prev, node, next, list) {\n  if (prev !== null) {\n    prev.next = node;\n  } else {\n    list.head = node;\n  }\n\n  if (next !== null) {\n    next.prev = node;\n  } else {\n    list.tail = node;\n  }\n\n  node.prev = prev;\n  node.next = next;\n\n  list.length++;\n\n  return node;\n};\n\nvar _remove = function _remove(node, list) {\n  var prev = node.prev,\n      next = node.next;\n\n\n  if (prev !== null) {\n    prev.next = next;\n  } else {\n    list.head = next;\n  }\n\n  if (next !== null) {\n    next.prev = prev;\n  } else {\n    list.tail = prev;\n  }\n\n  node.prev = node.next = null;\n\n  list.length--;\n\n  return node;\n};\n\nvar LinkedList = function () {\n  function LinkedList(vals) {\n    var _this = this;\n\n    _classCallCheck(this, LinkedList);\n\n    this.length = 0;\n    this.head = null;\n    this.tail = null;\n\n    if (vals != null) {\n      vals.forEach(function (v) {\n        return _this.push(v);\n      });\n    }\n  }\n\n  _createClass(LinkedList, [{\n    key: \"size\",\n    value: function size() {\n      return this.length;\n    }\n  }, {\n    key: \"insertBefore\",\n    value: function insertBefore(val, otherNode) {\n      return add(otherNode.prev, nodeFrom(val), otherNode, this);\n    }\n  }, {\n    key: \"insertAfter\",\n    value: function insertAfter(val, otherNode) {\n      return add(otherNode, nodeFrom(val), otherNode.next, this);\n    }\n  }, {\n    key: \"insertNodeBefore\",\n    value: function insertNodeBefore(newNode, otherNode) {\n      return add(otherNode.prev, newNode, otherNode, this);\n    }\n  }, {\n    key: \"insertNodeAfter\",\n    value: function insertNodeAfter(newNode, otherNode) {\n      return add(otherNode, newNode, otherNode.next, this);\n    }\n  }, {\n    key: \"push\",\n    value: function push(val) {\n      return add(this.tail, nodeFrom(val), null, this);\n    }\n  }, {\n    key: \"unshift\",\n    value: function unshift(val) {\n      return add(null, nodeFrom(val), this.head, this);\n    }\n  }, {\n    key: \"remove\",\n    value: function remove(node) {\n      return _remove(node, this);\n    }\n  }, {\n    key: \"pop\",\n    value: function pop() {\n      return _remove(this.tail, this).value;\n    }\n  }, {\n    key: \"popNode\",\n    value: function popNode() {\n      return _remove(this.tail, this);\n    }\n  }, {\n    key: \"shift\",\n    value: function shift() {\n      return _remove(this.head, this).value;\n    }\n  }, {\n    key: \"shiftNode\",\n    value: function shiftNode() {\n      return _remove(this.head, this);\n    }\n  }, {\n    key: \"get_object_at\",\n    value: function get_object_at(index) {\n      if (index <= this.length()) {\n        var i = 1;\n        var current = this.head;\n        while (i < index) {\n          current = current.next;\n          i++;\n        }\n        return current.value;\n      }\n    }\n  }, {\n    key: \"set_object_at\",\n    value: function set_object_at(index, value) {\n      if (index <= this.length()) {\n        var i = 1;\n        var current = this.head;\n        while (i < index) {\n          current = current.next;\n          i++;\n        }\n        current.value = value;\n      }\n    }\n  }]);\n\n  return LinkedList;\n}();\n\nmodule.exports = LinkedList;\n\n/***/ }),\n/* 12 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\n/*\r\n *This class is the javascript implementation of the Point.java class in jdk\r\n */\nfunction Point(x, y, p) {\n  this.x = null;\n  this.y = null;\n  if (x == null && y == null && p == null) {\n    this.x = 0;\n    this.y = 0;\n  } else if (typeof x == 'number' && typeof y == 'number' && p == null) {\n    this.x = x;\n    this.y = y;\n  } else if (x.constructor.name == 'Point' && y == null && p == null) {\n    p = x;\n    this.x = p.x;\n    this.y = p.y;\n  }\n}\n\nPoint.prototype.getX = function () {\n  return this.x;\n};\n\nPoint.prototype.getY = function () {\n  return this.y;\n};\n\nPoint.prototype.getLocation = function () {\n  return new Point(this.x, this.y);\n};\n\nPoint.prototype.setLocation = function (x, y, p) {\n  if (x.constructor.name == 'Point' && y == null && p == null) {\n    p = x;\n    this.setLocation(p.x, p.y);\n  } else if (typeof x == 'number' && typeof y == 'number' && p == null) {\n    //if both parameters are integer just move (x,y) location\n    if (parseInt(x) == x && parseInt(y) == y) {\n      this.move(x, y);\n    } else {\n      this.x = Math.floor(x + 0.5);\n      this.y = Math.floor(y + 0.5);\n    }\n  }\n};\n\nPoint.prototype.move = function (x, y) {\n  this.x = x;\n  this.y = y;\n};\n\nPoint.prototype.translate = function (dx, dy) {\n  this.x += dx;\n  this.y += dy;\n};\n\nPoint.prototype.equals = function (obj) {\n  if (obj.constructor.name == \"Point\") {\n    var pt = obj;\n    return this.x == pt.x && this.y == pt.y;\n  }\n  return this == obj;\n};\n\nPoint.prototype.toString = function () {\n  return new Point().constructor.name + \"[x=\" + this.x + \",y=\" + this.y + \"]\";\n};\n\nmodule.exports = Point;\n\n/***/ }),\n/* 13 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nfunction RectangleD(x, y, width, height) {\n  this.x = 0;\n  this.y = 0;\n  this.width = 0;\n  this.height = 0;\n\n  if (x != null && y != null && width != null && height != null) {\n    this.x = x;\n    this.y = y;\n    this.width = width;\n    this.height = height;\n  }\n}\n\nRectangleD.prototype.getX = function () {\n  return this.x;\n};\n\nRectangleD.prototype.setX = function (x) {\n  this.x = x;\n};\n\nRectangleD.prototype.getY = function () {\n  return this.y;\n};\n\nRectangleD.prototype.setY = function (y) {\n  this.y = y;\n};\n\nRectangleD.prototype.getWidth = function () {\n  return this.width;\n};\n\nRectangleD.prototype.setWidth = function (width) {\n  this.width = width;\n};\n\nRectangleD.prototype.getHeight = function () {\n  return this.height;\n};\n\nRectangleD.prototype.setHeight = function (height) {\n  this.height = height;\n};\n\nRectangleD.prototype.getRight = function () {\n  return this.x + this.width;\n};\n\nRectangleD.prototype.getBottom = function () {\n  return this.y + this.height;\n};\n\nRectangleD.prototype.intersects = function (a) {\n  if (this.getRight() < a.x) {\n    return false;\n  }\n\n  if (this.getBottom() < a.y) {\n    return false;\n  }\n\n  if (a.getRight() < this.x) {\n    return false;\n  }\n\n  if (a.getBottom() < this.y) {\n    return false;\n  }\n\n  return true;\n};\n\nRectangleD.prototype.getCenterX = function () {\n  return this.x + this.width / 2;\n};\n\nRectangleD.prototype.getMinX = function () {\n  return this.getX();\n};\n\nRectangleD.prototype.getMaxX = function () {\n  return this.getX() + this.width;\n};\n\nRectangleD.prototype.getCenterY = function () {\n  return this.y + this.height / 2;\n};\n\nRectangleD.prototype.getMinY = function () {\n  return this.getY();\n};\n\nRectangleD.prototype.getMaxY = function () {\n  return this.getY() + this.height;\n};\n\nRectangleD.prototype.getWidthHalf = function () {\n  return this.width / 2;\n};\n\nRectangleD.prototype.getHeightHalf = function () {\n  return this.height / 2;\n};\n\nmodule.exports = RectangleD;\n\n/***/ }),\n/* 14 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _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; };\n\nfunction UniqueIDGeneretor() {}\n\nUniqueIDGeneretor.lastID = 0;\n\nUniqueIDGeneretor.createID = function (obj) {\n  if (UniqueIDGeneretor.isPrimitive(obj)) {\n    return obj;\n  }\n  if (obj.uniqueID != null) {\n    return obj.uniqueID;\n  }\n  obj.uniqueID = UniqueIDGeneretor.getString();\n  UniqueIDGeneretor.lastID++;\n  return obj.uniqueID;\n};\n\nUniqueIDGeneretor.getString = function (id) {\n  if (id == null) id = UniqueIDGeneretor.lastID;\n  return \"Object#\" + id + \"\";\n};\n\nUniqueIDGeneretor.isPrimitive = function (arg) {\n  var type = typeof arg === \"undefined\" ? \"undefined\" : _typeof(arg);\n  return arg == null || type != \"object\" && type != \"function\";\n};\n\nmodule.exports = UniqueIDGeneretor;\n\n/***/ }),\n/* 15 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nfunction _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); } }\n\nvar LayoutConstants = __webpack_require__(0);\nvar LGraphManager = __webpack_require__(6);\nvar LNode = __webpack_require__(3);\nvar LEdge = __webpack_require__(1);\nvar LGraph = __webpack_require__(5);\nvar PointD = __webpack_require__(4);\nvar Transform = __webpack_require__(17);\nvar Emitter = __webpack_require__(27);\n\nfunction Layout(isRemoteUse) {\n  Emitter.call(this);\n\n  //Layout Quality: 0:draft, 1:default, 2:proof\n  this.layoutQuality = LayoutConstants.QUALITY;\n  //Whether layout should create bendpoints as needed or not\n  this.createBendsAsNeeded = LayoutConstants.DEFAULT_CREATE_BENDS_AS_NEEDED;\n  //Whether layout should be incremental or not\n  this.incremental = LayoutConstants.DEFAULT_INCREMENTAL;\n  //Whether we animate from before to after layout node positions\n  this.animationOnLayout = LayoutConstants.DEFAULT_ANIMATION_ON_LAYOUT;\n  //Whether we animate the layout process or not\n  this.animationDuringLayout = LayoutConstants.DEFAULT_ANIMATION_DURING_LAYOUT;\n  //Number iterations that should be done between two successive animations\n  this.animationPeriod = LayoutConstants.DEFAULT_ANIMATION_PERIOD;\n  /**\r\n   * Whether or not leaf nodes (non-compound nodes) are of uniform sizes. When\r\n   * they are, both spring and repulsion forces between two leaf nodes can be\r\n   * calculated without the expensive clipping point calculations, resulting\r\n   * in major speed-up.\r\n   */\n  this.uniformLeafNodeSizes = LayoutConstants.DEFAULT_UNIFORM_LEAF_NODE_SIZES;\n  /**\r\n   * This is used for creation of bendpoints by using dummy nodes and edges.\r\n   * Maps an LEdge to its dummy bendpoint path.\r\n   */\n  this.edgeToDummyNodes = new Map();\n  this.graphManager = new LGraphManager(this);\n  this.isLayoutFinished = false;\n  this.isSubLayout = false;\n  this.isRemoteUse = false;\n\n  if (isRemoteUse != null) {\n    this.isRemoteUse = isRemoteUse;\n  }\n}\n\nLayout.RANDOM_SEED = 1;\n\nLayout.prototype = Object.create(Emitter.prototype);\n\nLayout.prototype.getGraphManager = function () {\n  return this.graphManager;\n};\n\nLayout.prototype.getAllNodes = function () {\n  return this.graphManager.getAllNodes();\n};\n\nLayout.prototype.getAllEdges = function () {\n  return this.graphManager.getAllEdges();\n};\n\nLayout.prototype.getAllNodesToApplyGravitation = function () {\n  return this.graphManager.getAllNodesToApplyGravitation();\n};\n\nLayout.prototype.newGraphManager = function () {\n  var gm = new LGraphManager(this);\n  this.graphManager = gm;\n  return gm;\n};\n\nLayout.prototype.newGraph = function (vGraph) {\n  return new LGraph(null, this.graphManager, vGraph);\n};\n\nLayout.prototype.newNode = function (vNode) {\n  return new LNode(this.graphManager, vNode);\n};\n\nLayout.prototype.newEdge = function (vEdge) {\n  return new LEdge(null, null, vEdge);\n};\n\nLayout.prototype.checkLayoutSuccess = function () {\n  return this.graphManager.getRoot() == null || this.graphManager.getRoot().getNodes().length == 0 || this.graphManager.includesInvalidEdge();\n};\n\nLayout.prototype.runLayout = function () {\n  this.isLayoutFinished = false;\n\n  if (this.tilingPreLayout) {\n    this.tilingPreLayout();\n  }\n\n  this.initParameters();\n  var isLayoutSuccessfull;\n\n  if (this.checkLayoutSuccess()) {\n    isLayoutSuccessfull = false;\n  } else {\n    isLayoutSuccessfull = this.layout();\n  }\n\n  if (LayoutConstants.ANIMATE === 'during') {\n    // If this is a 'during' layout animation. Layout is not finished yet. \n    // We need to perform these in index.js when layout is really finished.\n    return false;\n  }\n\n  if (isLayoutSuccessfull) {\n    if (!this.isSubLayout) {\n      this.doPostLayout();\n    }\n  }\n\n  if (this.tilingPostLayout) {\n    this.tilingPostLayout();\n  }\n\n  this.isLayoutFinished = true;\n\n  return isLayoutSuccessfull;\n};\n\n/**\r\n * This method performs the operations required after layout.\r\n */\nLayout.prototype.doPostLayout = function () {\n  //assert !isSubLayout : \"Should not be called on sub-layout!\";\n  // Propagate geometric changes to v-level objects\n  if (!this.incremental) {\n    this.transform();\n  }\n  this.update();\n};\n\n/**\r\n * This method updates the geometry of the target graph according to\r\n * calculated layout.\r\n */\nLayout.prototype.update2 = function () {\n  // update bend points\n  if (this.createBendsAsNeeded) {\n    this.createBendpointsFromDummyNodes();\n\n    // reset all edges, since the topology has changed\n    this.graphManager.resetAllEdges();\n  }\n\n  // perform edge, node and root updates if layout is not called\n  // remotely\n  if (!this.isRemoteUse) {\n    // update all edges\n    var edge;\n    var allEdges = this.graphManager.getAllEdges();\n    for (var i = 0; i < allEdges.length; i++) {\n      edge = allEdges[i];\n      //      this.update(edge);\n    }\n\n    // recursively update nodes\n    var node;\n    var nodes = this.graphManager.getRoot().getNodes();\n    for (var i = 0; i < nodes.length; i++) {\n      node = nodes[i];\n      //      this.update(node);\n    }\n\n    // update root graph\n    this.update(this.graphManager.getRoot());\n  }\n};\n\nLayout.prototype.update = function (obj) {\n  if (obj == null) {\n    this.update2();\n  } else if (obj instanceof LNode) {\n    var node = obj;\n    if (node.getChild() != null) {\n      // since node is compound, recursively update child nodes\n      var nodes = node.getChild().getNodes();\n      for (var i = 0; i < nodes.length; i++) {\n        update(nodes[i]);\n      }\n    }\n\n    // if the l-level node is associated with a v-level graph object,\n    // then it is assumed that the v-level node implements the\n    // interface Updatable.\n    if (node.vGraphObject != null) {\n      // cast to Updatable without any type check\n      var vNode = node.vGraphObject;\n\n      // call the update method of the interface\n      vNode.update(node);\n    }\n  } else if (obj instanceof LEdge) {\n    var edge = obj;\n    // if the l-level edge is associated with a v-level graph object,\n    // then it is assumed that the v-level edge implements the\n    // interface Updatable.\n\n    if (edge.vGraphObject != null) {\n      // cast to Updatable without any type check\n      var vEdge = edge.vGraphObject;\n\n      // call the update method of the interface\n      vEdge.update(edge);\n    }\n  } else if (obj instanceof LGraph) {\n    var graph = obj;\n    // if the l-level graph is associated with a v-level graph object,\n    // then it is assumed that the v-level object implements the\n    // interface Updatable.\n\n    if (graph.vGraphObject != null) {\n      // cast to Updatable without any type check\n      var vGraph = graph.vGraphObject;\n\n      // call the update method of the interface\n      vGraph.update(graph);\n    }\n  }\n};\n\n/**\r\n * This method is used to set all layout parameters to default values\r\n * determined at compile time.\r\n */\nLayout.prototype.initParameters = function () {\n  if (!this.isSubLayout) {\n    this.layoutQuality = LayoutConstants.QUALITY;\n    this.animationDuringLayout = LayoutConstants.DEFAULT_ANIMATION_DURING_LAYOUT;\n    this.animationPeriod = LayoutConstants.DEFAULT_ANIMATION_PERIOD;\n    this.animationOnLayout = LayoutConstants.DEFAULT_ANIMATION_ON_LAYOUT;\n    this.incremental = LayoutConstants.DEFAULT_INCREMENTAL;\n    this.createBendsAsNeeded = LayoutConstants.DEFAULT_CREATE_BENDS_AS_NEEDED;\n    this.uniformLeafNodeSizes = LayoutConstants.DEFAULT_UNIFORM_LEAF_NODE_SIZES;\n  }\n\n  if (this.animationDuringLayout) {\n    this.animationOnLayout = false;\n  }\n};\n\nLayout.prototype.transform = function (newLeftTop) {\n  if (newLeftTop == undefined) {\n    this.transform(new PointD(0, 0));\n  } else {\n    // create a transformation object (from Eclipse to layout). When an\n    // inverse transform is applied, we get upper-left coordinate of the\n    // drawing or the root graph at given input coordinate (some margins\n    // already included in calculation of left-top).\n\n    var trans = new Transform();\n    var leftTop = this.graphManager.getRoot().updateLeftTop();\n\n    if (leftTop != null) {\n      trans.setWorldOrgX(newLeftTop.x);\n      trans.setWorldOrgY(newLeftTop.y);\n\n      trans.setDeviceOrgX(leftTop.x);\n      trans.setDeviceOrgY(leftTop.y);\n\n      var nodes = this.getAllNodes();\n      var node;\n\n      for (var i = 0; i < nodes.length; i++) {\n        node = nodes[i];\n        node.transform(trans);\n      }\n    }\n  }\n};\n\nLayout.prototype.positionNodesRandomly = function (graph) {\n\n  if (graph == undefined) {\n    //assert !this.incremental;\n    this.positionNodesRandomly(this.getGraphManager().getRoot());\n    this.getGraphManager().getRoot().updateBounds(true);\n  } else {\n    var lNode;\n    var childGraph;\n\n    var nodes = graph.getNodes();\n    for (var i = 0; i < nodes.length; i++) {\n      lNode = nodes[i];\n      childGraph = lNode.getChild();\n\n      if (childGraph == null) {\n        lNode.scatter();\n      } else if (childGraph.getNodes().length == 0) {\n        lNode.scatter();\n      } else {\n        this.positionNodesRandomly(childGraph);\n        lNode.updateBounds();\n      }\n    }\n  }\n};\n\n/**\r\n * This method returns a list of trees where each tree is represented as a\r\n * list of l-nodes. The method returns a list of size 0 when:\r\n * - The graph is not flat or\r\n * - One of the component(s) of the graph is not a tree.\r\n */\nLayout.prototype.getFlatForest = function () {\n  var flatForest = [];\n  var isForest = true;\n\n  // Quick reference for all nodes in the graph manager associated with\n  // this layout. The list should not be changed.\n  var allNodes = this.graphManager.getRoot().getNodes();\n\n  // First be sure that the graph is flat\n  var isFlat = true;\n\n  for (var i = 0; i < allNodes.length; i++) {\n    if (allNodes[i].getChild() != null) {\n      isFlat = false;\n    }\n  }\n\n  // Return empty forest if the graph is not flat.\n  if (!isFlat) {\n    return flatForest;\n  }\n\n  // Run BFS for each component of the graph.\n\n  var visited = new Set();\n  var toBeVisited = [];\n  var parents = new Map();\n  var unProcessedNodes = [];\n\n  unProcessedNodes = unProcessedNodes.concat(allNodes);\n\n  // Each iteration of this loop finds a component of the graph and\n  // decides whether it is a tree or not. If it is a tree, adds it to the\n  // forest and continued with the next component.\n\n  while (unProcessedNodes.length > 0 && isForest) {\n    toBeVisited.push(unProcessedNodes[0]);\n\n    // Start the BFS. Each iteration of this loop visits a node in a\n    // BFS manner.\n    while (toBeVisited.length > 0 && isForest) {\n      //pool operation\n      var currentNode = toBeVisited[0];\n      toBeVisited.splice(0, 1);\n      visited.add(currentNode);\n\n      // Traverse all neighbors of this node\n      var neighborEdges = currentNode.getEdges();\n\n      for (var i = 0; i < neighborEdges.length; i++) {\n        var currentNeighbor = neighborEdges[i].getOtherEnd(currentNode);\n\n        // If BFS is not growing from this neighbor.\n        if (parents.get(currentNode) != currentNeighbor) {\n          // We haven't previously visited this neighbor.\n          if (!visited.has(currentNeighbor)) {\n            toBeVisited.push(currentNeighbor);\n            parents.set(currentNeighbor, currentNode);\n          }\n          // Since we have previously visited this neighbor and\n          // this neighbor is not parent of currentNode, given\n          // graph contains a component that is not tree, hence\n          // it is not a forest.\n          else {\n              isForest = false;\n              break;\n            }\n        }\n      }\n    }\n\n    // The graph contains a component that is not a tree. Empty\n    // previously found trees. The method will end.\n    if (!isForest) {\n      flatForest = [];\n    }\n    // Save currently visited nodes as a tree in our forest. Reset\n    // visited and parents lists. Continue with the next component of\n    // the graph, if any.\n    else {\n        var temp = [].concat(_toConsumableArray(visited));\n        flatForest.push(temp);\n        //flatForest = flatForest.concat(temp);\n        //unProcessedNodes.removeAll(visited);\n        for (var i = 0; i < temp.length; i++) {\n          var value = temp[i];\n          var index = unProcessedNodes.indexOf(value);\n          if (index > -1) {\n            unProcessedNodes.splice(index, 1);\n          }\n        }\n        visited = new Set();\n        parents = new Map();\n      }\n  }\n\n  return flatForest;\n};\n\n/**\r\n * This method creates dummy nodes (an l-level node with minimal dimensions)\r\n * for the given edge (one per bendpoint). The existing l-level structure\r\n * is updated accordingly.\r\n */\nLayout.prototype.createDummyNodesForBendpoints = function (edge) {\n  var dummyNodes = [];\n  var prev = edge.source;\n\n  var graph = this.graphManager.calcLowestCommonAncestor(edge.source, edge.target);\n\n  for (var i = 0; i < edge.bendpoints.length; i++) {\n    // create new dummy node\n    var dummyNode = this.newNode(null);\n    dummyNode.setRect(new Point(0, 0), new Dimension(1, 1));\n\n    graph.add(dummyNode);\n\n    // create new dummy edge between prev and dummy node\n    var dummyEdge = this.newEdge(null);\n    this.graphManager.add(dummyEdge, prev, dummyNode);\n\n    dummyNodes.add(dummyNode);\n    prev = dummyNode;\n  }\n\n  var dummyEdge = this.newEdge(null);\n  this.graphManager.add(dummyEdge, prev, edge.target);\n\n  this.edgeToDummyNodes.set(edge, dummyNodes);\n\n  // remove real edge from graph manager if it is inter-graph\n  if (edge.isInterGraph()) {\n    this.graphManager.remove(edge);\n  }\n  // else, remove the edge from the current graph\n  else {\n      graph.remove(edge);\n    }\n\n  return dummyNodes;\n};\n\n/**\r\n * This method creates bendpoints for edges from the dummy nodes\r\n * at l-level.\r\n */\nLayout.prototype.createBendpointsFromDummyNodes = function () {\n  var edges = [];\n  edges = edges.concat(this.graphManager.getAllEdges());\n  edges = [].concat(_toConsumableArray(this.edgeToDummyNodes.keys())).concat(edges);\n\n  for (var k = 0; k < edges.length; k++) {\n    var lEdge = edges[k];\n\n    if (lEdge.bendpoints.length > 0) {\n      var path = this.edgeToDummyNodes.get(lEdge);\n\n      for (var i = 0; i < path.length; i++) {\n        var dummyNode = path[i];\n        var p = new PointD(dummyNode.getCenterX(), dummyNode.getCenterY());\n\n        // update bendpoint's location according to dummy node\n        var ebp = lEdge.bendpoints.get(i);\n        ebp.x = p.x;\n        ebp.y = p.y;\n\n        // remove the dummy node, dummy edges incident with this\n        // dummy node is also removed (within the remove method)\n        dummyNode.getOwner().remove(dummyNode);\n      }\n\n      // add the real edge to graph\n      this.graphManager.add(lEdge, lEdge.source, lEdge.target);\n    }\n  }\n};\n\nLayout.transform = function (sliderValue, defaultValue, minDiv, maxMul) {\n  if (minDiv != undefined && maxMul != undefined) {\n    var value = defaultValue;\n\n    if (sliderValue <= 50) {\n      var minValue = defaultValue / minDiv;\n      value -= (defaultValue - minValue) / 50 * (50 - sliderValue);\n    } else {\n      var maxValue = defaultValue * maxMul;\n      value += (maxValue - defaultValue) / 50 * (sliderValue - 50);\n    }\n\n    return value;\n  } else {\n    var a, b;\n\n    if (sliderValue <= 50) {\n      a = 9.0 * defaultValue / 500.0;\n      b = defaultValue / 10.0;\n    } else {\n      a = 9.0 * defaultValue / 50.0;\n      b = -8 * defaultValue;\n    }\n\n    return a * sliderValue + b;\n  }\n};\n\n/**\r\n * This method finds and returns the center of the given nodes, assuming\r\n * that the given nodes form a tree in themselves.\r\n */\nLayout.findCenterOfTree = function (nodes) {\n  var list = [];\n  list = list.concat(nodes);\n\n  var removedNodes = [];\n  var remainingDegrees = new Map();\n  var foundCenter = false;\n  var centerNode = null;\n\n  if (list.length == 1 || list.length == 2) {\n    foundCenter = true;\n    centerNode = list[0];\n  }\n\n  for (var i = 0; i < list.length; i++) {\n    var node = list[i];\n    var degree = node.getNeighborsList().size;\n    remainingDegrees.set(node, node.getNeighborsList().size);\n\n    if (degree == 1) {\n      removedNodes.push(node);\n    }\n  }\n\n  var tempList = [];\n  tempList = tempList.concat(removedNodes);\n\n  while (!foundCenter) {\n    var tempList2 = [];\n    tempList2 = tempList2.concat(tempList);\n    tempList = [];\n\n    for (var i = 0; i < list.length; i++) {\n      var node = list[i];\n\n      var index = list.indexOf(node);\n      if (index >= 0) {\n        list.splice(index, 1);\n      }\n\n      var neighbours = node.getNeighborsList();\n\n      neighbours.forEach(function (neighbour) {\n        if (removedNodes.indexOf(neighbour) < 0) {\n          var otherDegree = remainingDegrees.get(neighbour);\n          var newDegree = otherDegree - 1;\n\n          if (newDegree == 1) {\n            tempList.push(neighbour);\n          }\n\n          remainingDegrees.set(neighbour, newDegree);\n        }\n      });\n    }\n\n    removedNodes = removedNodes.concat(tempList);\n\n    if (list.length == 1 || list.length == 2) {\n      foundCenter = true;\n      centerNode = list[0];\n    }\n  }\n\n  return centerNode;\n};\n\n/**\r\n * During the coarsening process, this layout may be referenced by two graph managers\r\n * this setter function grants access to change the currently being used graph manager\r\n */\nLayout.prototype.setGraphManager = function (gm) {\n  this.graphManager = gm;\n};\n\nmodule.exports = Layout;\n\n/***/ }),\n/* 16 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nfunction RandomSeed() {}\n// adapted from: https://stackoverflow.com/a/19303725\nRandomSeed.seed = 1;\nRandomSeed.x = 0;\n\nRandomSeed.nextDouble = function () {\n  RandomSeed.x = Math.sin(RandomSeed.seed++) * 10000;\n  return RandomSeed.x - Math.floor(RandomSeed.x);\n};\n\nmodule.exports = RandomSeed;\n\n/***/ }),\n/* 17 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar PointD = __webpack_require__(4);\n\nfunction Transform(x, y) {\n  this.lworldOrgX = 0.0;\n  this.lworldOrgY = 0.0;\n  this.ldeviceOrgX = 0.0;\n  this.ldeviceOrgY = 0.0;\n  this.lworldExtX = 1.0;\n  this.lworldExtY = 1.0;\n  this.ldeviceExtX = 1.0;\n  this.ldeviceExtY = 1.0;\n}\n\nTransform.prototype.getWorldOrgX = function () {\n  return this.lworldOrgX;\n};\n\nTransform.prototype.setWorldOrgX = function (wox) {\n  this.lworldOrgX = wox;\n};\n\nTransform.prototype.getWorldOrgY = function () {\n  return this.lworldOrgY;\n};\n\nTransform.prototype.setWorldOrgY = function (woy) {\n  this.lworldOrgY = woy;\n};\n\nTransform.prototype.getWorldExtX = function () {\n  return this.lworldExtX;\n};\n\nTransform.prototype.setWorldExtX = function (wex) {\n  this.lworldExtX = wex;\n};\n\nTransform.prototype.getWorldExtY = function () {\n  return this.lworldExtY;\n};\n\nTransform.prototype.setWorldExtY = function (wey) {\n  this.lworldExtY = wey;\n};\n\n/* Device related */\n\nTransform.prototype.getDeviceOrgX = function () {\n  return this.ldeviceOrgX;\n};\n\nTransform.prototype.setDeviceOrgX = function (dox) {\n  this.ldeviceOrgX = dox;\n};\n\nTransform.prototype.getDeviceOrgY = function () {\n  return this.ldeviceOrgY;\n};\n\nTransform.prototype.setDeviceOrgY = function (doy) {\n  this.ldeviceOrgY = doy;\n};\n\nTransform.prototype.getDeviceExtX = function () {\n  return this.ldeviceExtX;\n};\n\nTransform.prototype.setDeviceExtX = function (dex) {\n  this.ldeviceExtX = dex;\n};\n\nTransform.prototype.getDeviceExtY = function () {\n  return this.ldeviceExtY;\n};\n\nTransform.prototype.setDeviceExtY = function (dey) {\n  this.ldeviceExtY = dey;\n};\n\nTransform.prototype.transformX = function (x) {\n  var xDevice = 0.0;\n  var worldExtX = this.lworldExtX;\n  if (worldExtX != 0.0) {\n    xDevice = this.ldeviceOrgX + (x - this.lworldOrgX) * this.ldeviceExtX / worldExtX;\n  }\n\n  return xDevice;\n};\n\nTransform.prototype.transformY = function (y) {\n  var yDevice = 0.0;\n  var worldExtY = this.lworldExtY;\n  if (worldExtY != 0.0) {\n    yDevice = this.ldeviceOrgY + (y - this.lworldOrgY) * this.ldeviceExtY / worldExtY;\n  }\n\n  return yDevice;\n};\n\nTransform.prototype.inverseTransformX = function (x) {\n  var xWorld = 0.0;\n  var deviceExtX = this.ldeviceExtX;\n  if (deviceExtX != 0.0) {\n    xWorld = this.lworldOrgX + (x - this.ldeviceOrgX) * this.lworldExtX / deviceExtX;\n  }\n\n  return xWorld;\n};\n\nTransform.prototype.inverseTransformY = function (y) {\n  var yWorld = 0.0;\n  var deviceExtY = this.ldeviceExtY;\n  if (deviceExtY != 0.0) {\n    yWorld = this.lworldOrgY + (y - this.ldeviceOrgY) * this.lworldExtY / deviceExtY;\n  }\n  return yWorld;\n};\n\nTransform.prototype.inverseTransformPoint = function (inPoint) {\n  var outPoint = new PointD(this.inverseTransformX(inPoint.x), this.inverseTransformY(inPoint.y));\n  return outPoint;\n};\n\nmodule.exports = Transform;\n\n/***/ }),\n/* 18 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nfunction _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); } }\n\nvar Layout = __webpack_require__(15);\nvar FDLayoutConstants = __webpack_require__(7);\nvar LayoutConstants = __webpack_require__(0);\nvar IGeometry = __webpack_require__(8);\nvar IMath = __webpack_require__(9);\n\nfunction FDLayout() {\n  Layout.call(this);\n\n  this.useSmartIdealEdgeLengthCalculation = FDLayoutConstants.DEFAULT_USE_SMART_IDEAL_EDGE_LENGTH_CALCULATION;\n  this.idealEdgeLength = FDLayoutConstants.DEFAULT_EDGE_LENGTH;\n  this.springConstant = FDLayoutConstants.DEFAULT_SPRING_STRENGTH;\n  this.repulsionConstant = FDLayoutConstants.DEFAULT_REPULSION_STRENGTH;\n  this.gravityConstant = FDLayoutConstants.DEFAULT_GRAVITY_STRENGTH;\n  this.compoundGravityConstant = FDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_STRENGTH;\n  this.gravityRangeFactor = FDLayoutConstants.DEFAULT_GRAVITY_RANGE_FACTOR;\n  this.compoundGravityRangeFactor = FDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR;\n  this.displacementThresholdPerNode = 3.0 * FDLayoutConstants.DEFAULT_EDGE_LENGTH / 100;\n  this.coolingFactor = FDLayoutConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL;\n  this.initialCoolingFactor = FDLayoutConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL;\n  this.totalDisplacement = 0.0;\n  this.oldTotalDisplacement = 0.0;\n  this.maxIterations = FDLayoutConstants.MAX_ITERATIONS;\n}\n\nFDLayout.prototype = Object.create(Layout.prototype);\n\nfor (var prop in Layout) {\n  FDLayout[prop] = Layout[prop];\n}\n\nFDLayout.prototype.initParameters = function () {\n  Layout.prototype.initParameters.call(this, arguments);\n\n  this.totalIterations = 0;\n  this.notAnimatedIterations = 0;\n\n  this.useFRGridVariant = FDLayoutConstants.DEFAULT_USE_SMART_REPULSION_RANGE_CALCULATION;\n\n  this.grid = [];\n};\n\nFDLayout.prototype.calcIdealEdgeLengths = function () {\n  var edge;\n  var lcaDepth;\n  var source;\n  var target;\n  var sizeOfSourceInLca;\n  var sizeOfTargetInLca;\n\n  var allEdges = this.getGraphManager().getAllEdges();\n  for (var i = 0; i < allEdges.length; i++) {\n    edge = allEdges[i];\n\n    edge.idealLength = this.idealEdgeLength;\n\n    if (edge.isInterGraph) {\n      source = edge.getSource();\n      target = edge.getTarget();\n\n      sizeOfSourceInLca = edge.getSourceInLca().getEstimatedSize();\n      sizeOfTargetInLca = edge.getTargetInLca().getEstimatedSize();\n\n      if (this.useSmartIdealEdgeLengthCalculation) {\n        edge.idealLength += sizeOfSourceInLca + sizeOfTargetInLca - 2 * LayoutConstants.SIMPLE_NODE_SIZE;\n      }\n\n      lcaDepth = edge.getLca().getInclusionTreeDepth();\n\n      edge.idealLength += FDLayoutConstants.DEFAULT_EDGE_LENGTH * FDLayoutConstants.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR * (source.getInclusionTreeDepth() + target.getInclusionTreeDepth() - 2 * lcaDepth);\n    }\n  }\n};\n\nFDLayout.prototype.initSpringEmbedder = function () {\n\n  var s = this.getAllNodes().length;\n  if (this.incremental) {\n    if (s > FDLayoutConstants.ADAPTATION_LOWER_NODE_LIMIT) {\n      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));\n    }\n    this.maxNodeDisplacement = FDLayoutConstants.MAX_NODE_DISPLACEMENT_INCREMENTAL;\n  } else {\n    if (s > FDLayoutConstants.ADAPTATION_LOWER_NODE_LIMIT) {\n      this.coolingFactor = Math.max(FDLayoutConstants.COOLING_ADAPTATION_FACTOR, 1.0 - (s - FDLayoutConstants.ADAPTATION_LOWER_NODE_LIMIT) / (FDLayoutConstants.ADAPTATION_UPPER_NODE_LIMIT - FDLayoutConstants.ADAPTATION_LOWER_NODE_LIMIT) * (1 - FDLayoutConstants.COOLING_ADAPTATION_FACTOR));\n    } else {\n      this.coolingFactor = 1.0;\n    }\n    this.initialCoolingFactor = this.coolingFactor;\n    this.maxNodeDisplacement = FDLayoutConstants.MAX_NODE_DISPLACEMENT;\n  }\n\n  this.maxIterations = Math.max(this.getAllNodes().length * 5, this.maxIterations);\n\n  this.totalDisplacementThreshold = this.displacementThresholdPerNode * this.getAllNodes().length;\n\n  this.repulsionRange = this.calcRepulsionRange();\n};\n\nFDLayout.prototype.calcSpringForces = function () {\n  var lEdges = this.getAllEdges();\n  var edge;\n\n  for (var i = 0; i < lEdges.length; i++) {\n    edge = lEdges[i];\n\n    this.calcSpringForce(edge, edge.idealLength);\n  }\n};\n\nFDLayout.prototype.calcRepulsionForces = function () {\n  var gridUpdateAllowed = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;\n  var forceToNodeSurroundingUpdate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;\n\n  var i, j;\n  var nodeA, nodeB;\n  var lNodes = this.getAllNodes();\n  var processedNodeSet;\n\n  if (this.useFRGridVariant) {\n    if (this.totalIterations % FDLayoutConstants.GRID_CALCULATION_CHECK_PERIOD == 1 && gridUpdateAllowed) {\n      this.updateGrid();\n    }\n\n    processedNodeSet = new Set();\n\n    // calculate repulsion forces between each nodes and its surrounding\n    for (i = 0; i < lNodes.length; i++) {\n      nodeA = lNodes[i];\n      this.calculateRepulsionForceOfANode(nodeA, processedNodeSet, gridUpdateAllowed, forceToNodeSurroundingUpdate);\n      processedNodeSet.add(nodeA);\n    }\n  } else {\n    for (i = 0; i < lNodes.length; i++) {\n      nodeA = lNodes[i];\n\n      for (j = i + 1; j < lNodes.length; j++) {\n        nodeB = lNodes[j];\n\n        // If both nodes are not members of the same graph, skip.\n        if (nodeA.getOwner() != nodeB.getOwner()) {\n          continue;\n        }\n\n        this.calcRepulsionForce(nodeA, nodeB);\n      }\n    }\n  }\n};\n\nFDLayout.prototype.calcGravitationalForces = function () {\n  var node;\n  var lNodes = this.getAllNodesToApplyGravitation();\n\n  for (var i = 0; i < lNodes.length; i++) {\n    node = lNodes[i];\n    this.calcGravitationalForce(node);\n  }\n};\n\nFDLayout.prototype.moveNodes = function () {\n  var lNodes = this.getAllNodes();\n  var node;\n\n  for (var i = 0; i < lNodes.length; i++) {\n    node = lNodes[i];\n    node.move();\n  }\n};\n\nFDLayout.prototype.calcSpringForce = function (edge, idealLength) {\n  var sourceNode = edge.getSource();\n  var targetNode = edge.getTarget();\n\n  var length;\n  var springForce;\n  var springForceX;\n  var springForceY;\n\n  // Update edge length\n  if (this.uniformLeafNodeSizes && sourceNode.getChild() == null && targetNode.getChild() == null) {\n    edge.updateLengthSimple();\n  } else {\n    edge.updateLength();\n\n    if (edge.isOverlapingSourceAndTarget) {\n      return;\n    }\n  }\n\n  length = edge.getLength();\n\n  if (length == 0) return;\n\n  // Calculate spring forces\n  springForce = this.springConstant * (length - idealLength);\n\n  // Project force onto x and y axes\n  springForceX = springForce * (edge.lengthX / length);\n  springForceY = springForce * (edge.lengthY / length);\n\n  // Apply forces on the end nodes\n  sourceNode.springForceX += springForceX;\n  sourceNode.springForceY += springForceY;\n  targetNode.springForceX -= springForceX;\n  targetNode.springForceY -= springForceY;\n};\n\nFDLayout.prototype.calcRepulsionForce = function (nodeA, nodeB) {\n  var rectA = nodeA.getRect();\n  var rectB = nodeB.getRect();\n  var overlapAmount = new Array(2);\n  var clipPoints = new Array(4);\n  var distanceX;\n  var distanceY;\n  var distanceSquared;\n  var distance;\n  var repulsionForce;\n  var repulsionForceX;\n  var repulsionForceY;\n\n  if (rectA.intersects(rectB)) // two nodes overlap\n    {\n      // calculate separation amount in x and y directions\n      IGeometry.calcSeparationAmount(rectA, rectB, overlapAmount, FDLayoutConstants.DEFAULT_EDGE_LENGTH / 2.0);\n\n      repulsionForceX = 2 * overlapAmount[0];\n      repulsionForceY = 2 * overlapAmount[1];\n\n      var childrenConstant = nodeA.noOfChildren * nodeB.noOfChildren / (nodeA.noOfChildren + nodeB.noOfChildren);\n\n      // Apply forces on the two nodes\n      nodeA.repulsionForceX -= childrenConstant * repulsionForceX;\n      nodeA.repulsionForceY -= childrenConstant * repulsionForceY;\n      nodeB.repulsionForceX += childrenConstant * repulsionForceX;\n      nodeB.repulsionForceY += childrenConstant * repulsionForceY;\n    } else // no overlap\n    {\n      // calculate distance\n\n      if (this.uniformLeafNodeSizes && nodeA.getChild() == null && nodeB.getChild() == null) // simply base repulsion on distance of node centers\n        {\n          distanceX = rectB.getCenterX() - rectA.getCenterX();\n          distanceY = rectB.getCenterY() - rectA.getCenterY();\n        } else // use clipping points\n        {\n          IGeometry.getIntersection(rectA, rectB, clipPoints);\n\n          distanceX = clipPoints[2] - clipPoints[0];\n          distanceY = clipPoints[3] - clipPoints[1];\n        }\n\n      // No repulsion range. FR grid variant should take care of this.\n      if (Math.abs(distanceX) < FDLayoutConstants.MIN_REPULSION_DIST) {\n        distanceX = IMath.sign(distanceX) * FDLayoutConstants.MIN_REPULSION_DIST;\n      }\n\n      if (Math.abs(distanceY) < FDLayoutConstants.MIN_REPULSION_DIST) {\n        distanceY = IMath.sign(distanceY) * FDLayoutConstants.MIN_REPULSION_DIST;\n      }\n\n      distanceSquared = distanceX * distanceX + distanceY * distanceY;\n      distance = Math.sqrt(distanceSquared);\n\n      repulsionForce = this.repulsionConstant * nodeA.noOfChildren * nodeB.noOfChildren / distanceSquared;\n\n      // Project force onto x and y axes\n      repulsionForceX = repulsionForce * distanceX / distance;\n      repulsionForceY = repulsionForce * distanceY / distance;\n\n      // Apply forces on the two nodes    \n      nodeA.repulsionForceX -= repulsionForceX;\n      nodeA.repulsionForceY -= repulsionForceY;\n      nodeB.repulsionForceX += repulsionForceX;\n      nodeB.repulsionForceY += repulsionForceY;\n    }\n};\n\nFDLayout.prototype.calcGravitationalForce = function (node) {\n  var ownerGraph;\n  var ownerCenterX;\n  var ownerCenterY;\n  var distanceX;\n  var distanceY;\n  var absDistanceX;\n  var absDistanceY;\n  var estimatedSize;\n  ownerGraph = node.getOwner();\n\n  ownerCenterX = (ownerGraph.getRight() + ownerGraph.getLeft()) / 2;\n  ownerCenterY = (ownerGraph.getTop() + ownerGraph.getBottom()) / 2;\n  distanceX = node.getCenterX() - ownerCenterX;\n  distanceY = node.getCenterY() - ownerCenterY;\n  absDistanceX = Math.abs(distanceX) + node.getWidth() / 2;\n  absDistanceY = Math.abs(distanceY) + node.getHeight() / 2;\n\n  if (node.getOwner() == this.graphManager.getRoot()) // in the root graph\n    {\n      estimatedSize = ownerGraph.getEstimatedSize() * this.gravityRangeFactor;\n\n      if (absDistanceX > estimatedSize || absDistanceY > estimatedSize) {\n        node.gravitationForceX = -this.gravityConstant * distanceX;\n        node.gravitationForceY = -this.gravityConstant * distanceY;\n      }\n    } else // inside a compound\n    {\n      estimatedSize = ownerGraph.getEstimatedSize() * this.compoundGravityRangeFactor;\n\n      if (absDistanceX > estimatedSize || absDistanceY > estimatedSize) {\n        node.gravitationForceX = -this.gravityConstant * distanceX * this.compoundGravityConstant;\n        node.gravitationForceY = -this.gravityConstant * distanceY * this.compoundGravityConstant;\n      }\n    }\n};\n\nFDLayout.prototype.isConverged = function () {\n  var converged;\n  var oscilating = false;\n\n  if (this.totalIterations > this.maxIterations / 3) {\n    oscilating = Math.abs(this.totalDisplacement - this.oldTotalDisplacement) < 2;\n  }\n\n  converged = this.totalDisplacement < this.totalDisplacementThreshold;\n\n  this.oldTotalDisplacement = this.totalDisplacement;\n\n  return converged || oscilating;\n};\n\nFDLayout.prototype.animate = function () {\n  if (this.animationDuringLayout && !this.isSubLayout) {\n    if (this.notAnimatedIterations == this.animationPeriod) {\n      this.update();\n      this.notAnimatedIterations = 0;\n    } else {\n      this.notAnimatedIterations++;\n    }\n  }\n};\n\n//This method calculates the number of children (weight) for all nodes\nFDLayout.prototype.calcNoOfChildrenForAllNodes = function () {\n  var node;\n  var allNodes = this.graphManager.getAllNodes();\n\n  for (var i = 0; i < allNodes.length; i++) {\n    node = allNodes[i];\n    node.noOfChildren = node.getNoOfChildren();\n  }\n};\n\n// -----------------------------------------------------------------------------\n// Section: FR-Grid Variant Repulsion Force Calculation\n// -----------------------------------------------------------------------------\n\nFDLayout.prototype.calcGrid = function (graph) {\n\n  var sizeX = 0;\n  var sizeY = 0;\n\n  sizeX = parseInt(Math.ceil((graph.getRight() - graph.getLeft()) / this.repulsionRange));\n  sizeY = parseInt(Math.ceil((graph.getBottom() - graph.getTop()) / this.repulsionRange));\n\n  var grid = new Array(sizeX);\n\n  for (var i = 0; i < sizeX; i++) {\n    grid[i] = new Array(sizeY);\n  }\n\n  for (var i = 0; i < sizeX; i++) {\n    for (var j = 0; j < sizeY; j++) {\n      grid[i][j] = new Array();\n    }\n  }\n\n  return grid;\n};\n\nFDLayout.prototype.addNodeToGrid = function (v, left, top) {\n\n  var startX = 0;\n  var finishX = 0;\n  var startY = 0;\n  var finishY = 0;\n\n  startX = parseInt(Math.floor((v.getRect().x - left) / this.repulsionRange));\n  finishX = parseInt(Math.floor((v.getRect().width + v.getRect().x - left) / this.repulsionRange));\n  startY = parseInt(Math.floor((v.getRect().y - top) / this.repulsionRange));\n  finishY = parseInt(Math.floor((v.getRect().height + v.getRect().y - top) / this.repulsionRange));\n\n  for (var i = startX; i <= finishX; i++) {\n    for (var j = startY; j <= finishY; j++) {\n      this.grid[i][j].push(v);\n      v.setGridCoordinates(startX, finishX, startY, finishY);\n    }\n  }\n};\n\nFDLayout.prototype.updateGrid = function () {\n  var i;\n  var nodeA;\n  var lNodes = this.getAllNodes();\n\n  this.grid = this.calcGrid(this.graphManager.getRoot());\n\n  // put all nodes to proper grid cells\n  for (i = 0; i < lNodes.length; i++) {\n    nodeA = lNodes[i];\n    this.addNodeToGrid(nodeA, this.graphManager.getRoot().getLeft(), this.graphManager.getRoot().getTop());\n  }\n};\n\nFDLayout.prototype.calculateRepulsionForceOfANode = function (nodeA, processedNodeSet, gridUpdateAllowed, forceToNodeSurroundingUpdate) {\n\n  if (this.totalIterations % FDLayoutConstants.GRID_CALCULATION_CHECK_PERIOD == 1 && gridUpdateAllowed || forceToNodeSurroundingUpdate) {\n    var surrounding = new Set();\n    nodeA.surrounding = new Array();\n    var nodeB;\n    var grid = this.grid;\n\n    for (var i = nodeA.startX - 1; i < nodeA.finishX + 2; i++) {\n      for (var j = nodeA.startY - 1; j < nodeA.finishY + 2; j++) {\n        if (!(i < 0 || j < 0 || i >= grid.length || j >= grid[0].length)) {\n          for (var k = 0; k < grid[i][j].length; k++) {\n            nodeB = grid[i][j][k];\n\n            // If both nodes are not members of the same graph, \n            // or both nodes are the same, skip.\n            if (nodeA.getOwner() != nodeB.getOwner() || nodeA == nodeB) {\n              continue;\n            }\n\n            // check if the repulsion force between\n            // nodeA and nodeB has already been calculated\n            if (!processedNodeSet.has(nodeB) && !surrounding.has(nodeB)) {\n              var distanceX = Math.abs(nodeA.getCenterX() - nodeB.getCenterX()) - (nodeA.getWidth() / 2 + nodeB.getWidth() / 2);\n              var distanceY = Math.abs(nodeA.getCenterY() - nodeB.getCenterY()) - (nodeA.getHeight() / 2 + nodeB.getHeight() / 2);\n\n              // if the distance between nodeA and nodeB \n              // is less then calculation range\n              if (distanceX <= this.repulsionRange && distanceY <= this.repulsionRange) {\n                //then add nodeB to surrounding of nodeA\n                surrounding.add(nodeB);\n              }\n            }\n          }\n        }\n      }\n    }\n\n    nodeA.surrounding = [].concat(_toConsumableArray(surrounding));\n  }\n  for (i = 0; i < nodeA.surrounding.length; i++) {\n    this.calcRepulsionForce(nodeA, nodeA.surrounding[i]);\n  }\n};\n\nFDLayout.prototype.calcRepulsionRange = function () {\n  return 0.0;\n};\n\nmodule.exports = FDLayout;\n\n/***/ }),\n/* 19 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar LEdge = __webpack_require__(1);\nvar FDLayoutConstants = __webpack_require__(7);\n\nfunction FDLayoutEdge(source, target, vEdge) {\n  LEdge.call(this, source, target, vEdge);\n  this.idealLength = FDLayoutConstants.DEFAULT_EDGE_LENGTH;\n}\n\nFDLayoutEdge.prototype = Object.create(LEdge.prototype);\n\nfor (var prop in LEdge) {\n  FDLayoutEdge[prop] = LEdge[prop];\n}\n\nmodule.exports = FDLayoutEdge;\n\n/***/ }),\n/* 20 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar LNode = __webpack_require__(3);\n\nfunction FDLayoutNode(gm, loc, size, vNode) {\n  // alternative constructor is handled inside LNode\n  LNode.call(this, gm, loc, size, vNode);\n  //Spring, repulsion and gravitational forces acting on this node\n  this.springForceX = 0;\n  this.springForceY = 0;\n  this.repulsionForceX = 0;\n  this.repulsionForceY = 0;\n  this.gravitationForceX = 0;\n  this.gravitationForceY = 0;\n  //Amount by which this node is to be moved in this iteration\n  this.displacementX = 0;\n  this.displacementY = 0;\n\n  //Start and finish grid coordinates that this node is fallen into\n  this.startX = 0;\n  this.finishX = 0;\n  this.startY = 0;\n  this.finishY = 0;\n\n  //Geometric neighbors of this node\n  this.surrounding = [];\n}\n\nFDLayoutNode.prototype = Object.create(LNode.prototype);\n\nfor (var prop in LNode) {\n  FDLayoutNode[prop] = LNode[prop];\n}\n\nFDLayoutNode.prototype.setGridCoordinates = function (_startX, _finishX, _startY, _finishY) {\n  this.startX = _startX;\n  this.finishX = _finishX;\n  this.startY = _startY;\n  this.finishY = _finishY;\n};\n\nmodule.exports = FDLayoutNode;\n\n/***/ }),\n/* 21 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nfunction DimensionD(width, height) {\n  this.width = 0;\n  this.height = 0;\n  if (width !== null && height !== null) {\n    this.height = height;\n    this.width = width;\n  }\n}\n\nDimensionD.prototype.getWidth = function () {\n  return this.width;\n};\n\nDimensionD.prototype.setWidth = function (width) {\n  this.width = width;\n};\n\nDimensionD.prototype.getHeight = function () {\n  return this.height;\n};\n\nDimensionD.prototype.setHeight = function (height) {\n  this.height = height;\n};\n\nmodule.exports = DimensionD;\n\n/***/ }),\n/* 22 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar UniqueIDGeneretor = __webpack_require__(14);\n\nfunction HashMap() {\n  this.map = {};\n  this.keys = [];\n}\n\nHashMap.prototype.put = function (key, value) {\n  var theId = UniqueIDGeneretor.createID(key);\n  if (!this.contains(theId)) {\n    this.map[theId] = value;\n    this.keys.push(key);\n  }\n};\n\nHashMap.prototype.contains = function (key) {\n  var theId = UniqueIDGeneretor.createID(key);\n  return this.map[key] != null;\n};\n\nHashMap.prototype.get = function (key) {\n  var theId = UniqueIDGeneretor.createID(key);\n  return this.map[theId];\n};\n\nHashMap.prototype.keySet = function () {\n  return this.keys;\n};\n\nmodule.exports = HashMap;\n\n/***/ }),\n/* 23 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar UniqueIDGeneretor = __webpack_require__(14);\n\nfunction HashSet() {\n  this.set = {};\n}\n;\n\nHashSet.prototype.add = function (obj) {\n  var theId = UniqueIDGeneretor.createID(obj);\n  if (!this.contains(theId)) this.set[theId] = obj;\n};\n\nHashSet.prototype.remove = function (obj) {\n  delete this.set[UniqueIDGeneretor.createID(obj)];\n};\n\nHashSet.prototype.clear = function () {\n  this.set = {};\n};\n\nHashSet.prototype.contains = function (obj) {\n  return this.set[UniqueIDGeneretor.createID(obj)] == obj;\n};\n\nHashSet.prototype.isEmpty = function () {\n  return this.size() === 0;\n};\n\nHashSet.prototype.size = function () {\n  return Object.keys(this.set).length;\n};\n\n//concats this.set to the given list\nHashSet.prototype.addAllTo = function (list) {\n  var keys = Object.keys(this.set);\n  var length = keys.length;\n  for (var i = 0; i < length; i++) {\n    list.push(this.set[keys[i]]);\n  }\n};\n\nHashSet.prototype.size = function () {\n  return Object.keys(this.set).length;\n};\n\nHashSet.prototype.addAll = function (list) {\n  var s = list.length;\n  for (var i = 0; i < s; i++) {\n    var v = list[i];\n    this.add(v);\n  }\n};\n\nmodule.exports = HashSet;\n\n/***/ }),\n/* 24 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _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; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/**\n * A classic Quicksort algorithm with Hoare's partition\n * - Works also on LinkedList objects\n *\n * Copyright: i-Vis Research Group, Bilkent University, 2007 - present\n */\n\nvar LinkedList = __webpack_require__(11);\n\nvar Quicksort = function () {\n    function Quicksort(A, compareFunction) {\n        _classCallCheck(this, Quicksort);\n\n        if (compareFunction !== null || compareFunction !== undefined) this.compareFunction = this._defaultCompareFunction;\n\n        var length = void 0;\n        if (A instanceof LinkedList) length = A.size();else length = A.length;\n\n        this._quicksort(A, 0, length - 1);\n    }\n\n    _createClass(Quicksort, [{\n        key: '_quicksort',\n        value: function _quicksort(A, p, r) {\n            if (p < r) {\n                var q = this._partition(A, p, r);\n                this._quicksort(A, p, q);\n                this._quicksort(A, q + 1, r);\n            }\n        }\n    }, {\n        key: '_partition',\n        value: function _partition(A, p, r) {\n            var x = this._get(A, p);\n            var i = p;\n            var j = r;\n            while (true) {\n                while (this.compareFunction(x, this._get(A, j))) {\n                    j--;\n                }while (this.compareFunction(this._get(A, i), x)) {\n                    i++;\n                }if (i < j) {\n                    this._swap(A, i, j);\n                    i++;\n                    j--;\n                } else return j;\n            }\n        }\n    }, {\n        key: '_get',\n        value: function _get(object, index) {\n            if (object instanceof LinkedList) return object.get_object_at(index);else return object[index];\n        }\n    }, {\n        key: '_set',\n        value: function _set(object, index, value) {\n            if (object instanceof LinkedList) object.set_object_at(index, value);else object[index] = value;\n        }\n    }, {\n        key: '_swap',\n        value: function _swap(A, i, j) {\n            var temp = this._get(A, i);\n            this._set(A, i, this._get(A, j));\n            this._set(A, j, temp);\n        }\n    }, {\n        key: '_defaultCompareFunction',\n        value: function _defaultCompareFunction(a, b) {\n            return b > a;\n        }\n    }]);\n\n    return Quicksort;\n}();\n\nmodule.exports = Quicksort;\n\n/***/ }),\n/* 25 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar _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; }; }();\n\nfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\n/**\n *   Needleman-Wunsch algorithm is an procedure to compute the optimal global alignment of two string\n *   sequences by S.B.Needleman and C.D.Wunsch (1970).\n *\n *   Aside from the inputs, you can assign the scores for,\n *   - Match: The two characters at the current index are same.\n *   - Mismatch: The two characters at the current index are different.\n *   - Insertion/Deletion(gaps): The best alignment involves one letter aligning to a gap in the other string.\n */\n\nvar NeedlemanWunsch = function () {\n    function NeedlemanWunsch(sequence1, sequence2) {\n        var match_score = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;\n        var mismatch_penalty = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : -1;\n        var gap_penalty = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : -1;\n\n        _classCallCheck(this, NeedlemanWunsch);\n\n        this.sequence1 = sequence1;\n        this.sequence2 = sequence2;\n        this.match_score = match_score;\n        this.mismatch_penalty = mismatch_penalty;\n        this.gap_penalty = gap_penalty;\n\n        // Just the remove redundancy\n        this.iMax = sequence1.length + 1;\n        this.jMax = sequence2.length + 1;\n\n        // Grid matrix of scores\n        this.grid = new Array(this.iMax);\n        for (var i = 0; i < this.iMax; i++) {\n            this.grid[i] = new Array(this.jMax);\n\n            for (var j = 0; j < this.jMax; j++) {\n                this.grid[i][j] = 0;\n            }\n        }\n\n        // Traceback matrix (2D array, each cell is an array of boolean values for [`Diag`, `Up`, `Left`] positions)\n        this.tracebackGrid = new Array(this.iMax);\n        for (var _i = 0; _i < this.iMax; _i++) {\n            this.tracebackGrid[_i] = new Array(this.jMax);\n\n            for (var _j = 0; _j < this.jMax; _j++) {\n                this.tracebackGrid[_i][_j] = [null, null, null];\n            }\n        }\n\n        // The aligned sequences (return multiple possibilities)\n        this.alignments = [];\n\n        // Final alignment score\n        this.score = -1;\n\n        // Calculate scores and tracebacks\n        this.computeGrids();\n    }\n\n    _createClass(NeedlemanWunsch, [{\n        key: \"getScore\",\n        value: function getScore() {\n            return this.score;\n        }\n    }, {\n        key: \"getAlignments\",\n        value: function getAlignments() {\n            return this.alignments;\n        }\n\n        // Main dynamic programming procedure\n\n    }, {\n        key: \"computeGrids\",\n        value: function computeGrids() {\n            // Fill in the first row\n            for (var j = 1; j < this.jMax; j++) {\n                this.grid[0][j] = this.grid[0][j - 1] + this.gap_penalty;\n                this.tracebackGrid[0][j] = [false, false, true];\n            }\n\n            // Fill in the first column\n            for (var i = 1; i < this.iMax; i++) {\n                this.grid[i][0] = this.grid[i - 1][0] + this.gap_penalty;\n                this.tracebackGrid[i][0] = [false, true, false];\n            }\n\n            // Fill the rest of the grid\n            for (var _i2 = 1; _i2 < this.iMax; _i2++) {\n                for (var _j2 = 1; _j2 < this.jMax; _j2++) {\n                    // Find the max score(s) among [`Diag`, `Up`, `Left`]\n                    var diag = void 0;\n                    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;\n\n                    var up = this.grid[_i2 - 1][_j2] + this.gap_penalty;\n                    var left = this.grid[_i2][_j2 - 1] + this.gap_penalty;\n\n                    // If there exists multiple max values, capture them for multiple paths\n                    var maxOf = [diag, up, left];\n                    var indices = this.arrayAllMaxIndexes(maxOf);\n\n                    // Update Grids\n                    this.grid[_i2][_j2] = maxOf[indices[0]];\n                    this.tracebackGrid[_i2][_j2] = [indices.includes(0), indices.includes(1), indices.includes(2)];\n                }\n            }\n\n            // Update alignment score\n            this.score = this.grid[this.iMax - 1][this.jMax - 1];\n        }\n\n        // Gets all possible valid sequence combinations\n\n    }, {\n        key: \"alignmentTraceback\",\n        value: function alignmentTraceback() {\n            var inProcessAlignments = [];\n\n            inProcessAlignments.push({ pos: [this.sequence1.length, this.sequence2.length],\n                seq1: \"\",\n                seq2: \"\"\n            });\n\n            while (inProcessAlignments[0]) {\n                var current = inProcessAlignments[0];\n                var directions = this.tracebackGrid[current.pos[0]][current.pos[1]];\n\n                if (directions[0]) {\n                    inProcessAlignments.push({ pos: [current.pos[0] - 1, current.pos[1] - 1],\n                        seq1: this.sequence1[current.pos[0] - 1] + current.seq1,\n                        seq2: this.sequence2[current.pos[1] - 1] + current.seq2\n                    });\n                }\n                if (directions[1]) {\n                    inProcessAlignments.push({ pos: [current.pos[0] - 1, current.pos[1]],\n                        seq1: this.sequence1[current.pos[0] - 1] + current.seq1,\n                        seq2: '-' + current.seq2\n                    });\n                }\n                if (directions[2]) {\n                    inProcessAlignments.push({ pos: [current.pos[0], current.pos[1] - 1],\n                        seq1: '-' + current.seq1,\n                        seq2: this.sequence2[current.pos[1] - 1] + current.seq2\n                    });\n                }\n\n                if (current.pos[0] === 0 && current.pos[1] === 0) this.alignments.push({ sequence1: current.seq1,\n                    sequence2: current.seq2\n                });\n\n                inProcessAlignments.shift();\n            }\n\n            return this.alignments;\n        }\n\n        // Helper Functions\n\n    }, {\n        key: \"getAllIndexes\",\n        value: function getAllIndexes(arr, val) {\n            var indexes = [],\n                i = -1;\n            while ((i = arr.indexOf(val, i + 1)) !== -1) {\n                indexes.push(i);\n            }\n            return indexes;\n        }\n    }, {\n        key: \"arrayAllMaxIndexes\",\n        value: function arrayAllMaxIndexes(array) {\n            return this.getAllIndexes(array, Math.max.apply(null, array));\n        }\n    }]);\n\n    return NeedlemanWunsch;\n}();\n\nmodule.exports = NeedlemanWunsch;\n\n/***/ }),\n/* 26 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar layoutBase = function layoutBase() {\n  return;\n};\n\nlayoutBase.FDLayout = __webpack_require__(18);\nlayoutBase.FDLayoutConstants = __webpack_require__(7);\nlayoutBase.FDLayoutEdge = __webpack_require__(19);\nlayoutBase.FDLayoutNode = __webpack_require__(20);\nlayoutBase.DimensionD = __webpack_require__(21);\nlayoutBase.HashMap = __webpack_require__(22);\nlayoutBase.HashSet = __webpack_require__(23);\nlayoutBase.IGeometry = __webpack_require__(8);\nlayoutBase.IMath = __webpack_require__(9);\nlayoutBase.Integer = __webpack_require__(10);\nlayoutBase.Point = __webpack_require__(12);\nlayoutBase.PointD = __webpack_require__(4);\nlayoutBase.RandomSeed = __webpack_require__(16);\nlayoutBase.RectangleD = __webpack_require__(13);\nlayoutBase.Transform = __webpack_require__(17);\nlayoutBase.UniqueIDGeneretor = __webpack_require__(14);\nlayoutBase.Quicksort = __webpack_require__(24);\nlayoutBase.LinkedList = __webpack_require__(11);\nlayoutBase.LGraphObject = __webpack_require__(2);\nlayoutBase.LGraph = __webpack_require__(5);\nlayoutBase.LEdge = __webpack_require__(1);\nlayoutBase.LGraphManager = __webpack_require__(6);\nlayoutBase.LNode = __webpack_require__(3);\nlayoutBase.Layout = __webpack_require__(15);\nlayoutBase.LayoutConstants = __webpack_require__(0);\nlayoutBase.NeedlemanWunsch = __webpack_require__(25);\n\nmodule.exports = layoutBase;\n\n/***/ }),\n/* 27 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nfunction Emitter() {\n  this.listeners = [];\n}\n\nvar p = Emitter.prototype;\n\np.addListener = function (event, callback) {\n  this.listeners.push({\n    event: event,\n    callback: callback\n  });\n};\n\np.removeListener = function (event, callback) {\n  for (var i = this.listeners.length; i >= 0; i--) {\n    var l = this.listeners[i];\n\n    if (l.event === event && l.callback === callback) {\n      this.listeners.splice(i, 1);\n    }\n  }\n};\n\np.emit = function (event, data) {\n  for (var i = 0; i < this.listeners.length; i++) {\n    var l = this.listeners[i];\n\n    if (event === l.event) {\n      l.callback(data);\n    }\n  }\n};\n\nmodule.exports = Emitter;\n\n/***/ })\n/******/ ]);\n});","(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"cose-base\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([\"cose-base\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"cytoscapeCoseBilkent\"] = factory(require(\"cose-base\"));\n\telse\n\t\troot[\"cytoscapeCoseBilkent\"] = factory(root[\"coseBase\"]);\n})(this, function(__WEBPACK_EXTERNAL_MODULE_0__) {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId]) {\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/ \t\t}\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\ti: moduleId,\n/******/ \t\t\tl: false,\n/******/ \t\t\texports: {}\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.l = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// identity function for calling harmony imports with the correct context\n/******/ \t__webpack_require__.i = function(value) { return value; };\n/******/\n/******/ \t// define getter function for harmony exports\n/******/ \t__webpack_require__.d = function(exports, name, getter) {\n/******/ \t\tif(!__webpack_require__.o(exports, name)) {\n/******/ \t\t\tObject.defineProperty(exports, name, {\n/******/ \t\t\t\tconfigurable: false,\n/******/ \t\t\t\tenumerable: true,\n/******/ \t\t\t\tget: getter\n/******/ \t\t\t});\n/******/ \t\t}\n/******/ \t};\n/******/\n/******/ \t// getDefaultExport function for compatibility with non-harmony modules\n/******/ \t__webpack_require__.n = function(module) {\n/******/ \t\tvar getter = module && module.__esModule ?\n/******/ \t\t\tfunction getDefault() { return module['default']; } :\n/******/ \t\t\tfunction getModuleExports() { return module; };\n/******/ \t\t__webpack_require__.d(getter, 'a', getter);\n/******/ \t\treturn getter;\n/******/ \t};\n/******/\n/******/ \t// Object.prototype.hasOwnProperty.call\n/******/ \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(__webpack_require__.s = 1);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, exports) {\n\nmodule.exports = __WEBPACK_EXTERNAL_MODULE_0__;\n\n/***/ }),\n/* 1 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar LayoutConstants = __webpack_require__(0).layoutBase.LayoutConstants;\nvar FDLayoutConstants = __webpack_require__(0).layoutBase.FDLayoutConstants;\nvar CoSEConstants = __webpack_require__(0).CoSEConstants;\nvar CoSELayout = __webpack_require__(0).CoSELayout;\nvar CoSENode = __webpack_require__(0).CoSENode;\nvar PointD = __webpack_require__(0).layoutBase.PointD;\nvar DimensionD = __webpack_require__(0).layoutBase.DimensionD;\n\nvar defaults = {\n  // Called on `layoutready`\n  ready: function ready() {},\n  // Called on `layoutstop`\n  stop: function stop() {},\n  // 'draft', 'default' or 'proof\" \n  // - 'draft' fast cooling rate \n  // - 'default' moderate cooling rate \n  // - \"proof\" slow cooling rate\n  quality: 'default',\n  // include labels in node dimensions\n  nodeDimensionsIncludeLabels: false,\n  // number of ticks per frame; higher is faster but more jerky\n  refresh: 30,\n  // Whether to fit the network view after when done\n  fit: true,\n  // Padding on fit\n  padding: 10,\n  // Whether to enable incremental mode\n  randomize: true,\n  // Node repulsion (non overlapping) multiplier\n  nodeRepulsion: 4500,\n  // Ideal edge (non nested) length\n  idealEdgeLength: 50,\n  // Divisor to compute edge forces\n  edgeElasticity: 0.45,\n  // Nesting factor (multiplier) to compute ideal edge length for nested edges\n  nestingFactor: 0.1,\n  // Gravity force (constant)\n  gravity: 0.25,\n  // Maximum number of iterations to perform\n  numIter: 2500,\n  // For enabling tiling\n  tile: true,\n  // Type of layout animation. The option set is {'during', 'end', false}\n  animate: 'end',\n  // Duration for animate:end\n  animationDuration: 500,\n  // Represents the amount of the vertical space to put between the zero degree members during the tiling operation(can also be a function)\n  tilingPaddingVertical: 10,\n  // Represents the amount of the horizontal space to put between the zero degree members during the tiling operation(can also be a function)\n  tilingPaddingHorizontal: 10,\n  // Gravity range (constant) for compounds\n  gravityRangeCompound: 1.5,\n  // Gravity force (constant) for compounds\n  gravityCompound: 1.0,\n  // Gravity range (constant)\n  gravityRange: 3.8,\n  // Initial cooling factor for incremental layout\n  initialEnergyOnIncremental: 0.5\n};\n\nfunction extend(defaults, options) {\n  var obj = {};\n\n  for (var i in defaults) {\n    obj[i] = defaults[i];\n  }\n\n  for (var i in options) {\n    obj[i] = options[i];\n  }\n\n  return obj;\n};\n\nfunction _CoSELayout(_options) {\n  this.options = extend(defaults, _options);\n  getUserOptions(this.options);\n}\n\nvar getUserOptions = function getUserOptions(options) {\n  if (options.nodeRepulsion != null) CoSEConstants.DEFAULT_REPULSION_STRENGTH = FDLayoutConstants.DEFAULT_REPULSION_STRENGTH = options.nodeRepulsion;\n  if (options.idealEdgeLength != null) CoSEConstants.DEFAULT_EDGE_LENGTH = FDLayoutConstants.DEFAULT_EDGE_LENGTH = options.idealEdgeLength;\n  if (options.edgeElasticity != null) CoSEConstants.DEFAULT_SPRING_STRENGTH = FDLayoutConstants.DEFAULT_SPRING_STRENGTH = options.edgeElasticity;\n  if (options.nestingFactor != null) CoSEConstants.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR = FDLayoutConstants.PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR = options.nestingFactor;\n  if (options.gravity != null) CoSEConstants.DEFAULT_GRAVITY_STRENGTH = FDLayoutConstants.DEFAULT_GRAVITY_STRENGTH = options.gravity;\n  if (options.numIter != null) CoSEConstants.MAX_ITERATIONS = FDLayoutConstants.MAX_ITERATIONS = options.numIter;\n  if (options.gravityRange != null) CoSEConstants.DEFAULT_GRAVITY_RANGE_FACTOR = FDLayoutConstants.DEFAULT_GRAVITY_RANGE_FACTOR = options.gravityRange;\n  if (options.gravityCompound != null) CoSEConstants.DEFAULT_COMPOUND_GRAVITY_STRENGTH = FDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_STRENGTH = options.gravityCompound;\n  if (options.gravityRangeCompound != null) CoSEConstants.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR = FDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR = options.gravityRangeCompound;\n  if (options.initialEnergyOnIncremental != null) CoSEConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL = FDLayoutConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL = options.initialEnergyOnIncremental;\n\n  if (options.quality == 'draft') LayoutConstants.QUALITY = 0;else if (options.quality == 'proof') LayoutConstants.QUALITY = 2;else LayoutConstants.QUALITY = 1;\n\n  CoSEConstants.NODE_DIMENSIONS_INCLUDE_LABELS = FDLayoutConstants.NODE_DIMENSIONS_INCLUDE_LABELS = LayoutConstants.NODE_DIMENSIONS_INCLUDE_LABELS = options.nodeDimensionsIncludeLabels;\n  CoSEConstants.DEFAULT_INCREMENTAL = FDLayoutConstants.DEFAULT_INCREMENTAL = LayoutConstants.DEFAULT_INCREMENTAL = !options.randomize;\n  CoSEConstants.ANIMATE = FDLayoutConstants.ANIMATE = LayoutConstants.ANIMATE = options.animate;\n  CoSEConstants.TILE = options.tile;\n  CoSEConstants.TILING_PADDING_VERTICAL = typeof options.tilingPaddingVertical === 'function' ? options.tilingPaddingVertical.call() : options.tilingPaddingVertical;\n  CoSEConstants.TILING_PADDING_HORIZONTAL = typeof options.tilingPaddingHorizontal === 'function' ? options.tilingPaddingHorizontal.call() : options.tilingPaddingHorizontal;\n};\n\n_CoSELayout.prototype.run = function () {\n  var ready;\n  var frameId;\n  var options = this.options;\n  var idToLNode = this.idToLNode = {};\n  var layout = this.layout = new CoSELayout();\n  var self = this;\n\n  self.stopped = false;\n\n  this.cy = this.options.cy;\n\n  this.cy.trigger({ type: 'layoutstart', layout: this });\n\n  var gm = layout.newGraphManager();\n  this.gm = gm;\n\n  var nodes = this.options.eles.nodes();\n  var edges = this.options.eles.edges();\n\n  this.root = gm.addRoot();\n  this.processChildrenList(this.root, this.getTopMostNodes(nodes), layout);\n\n  for (var i = 0; i < edges.length; i++) {\n    var edge = edges[i];\n    var sourceNode = this.idToLNode[edge.data(\"source\")];\n    var targetNode = this.idToLNode[edge.data(\"target\")];\n    if (sourceNode !== targetNode && sourceNode.getEdgesBetween(targetNode).length == 0) {\n      var e1 = gm.add(layout.newEdge(), sourceNode, targetNode);\n      e1.id = edge.id();\n    }\n  }\n\n  var getPositions = function getPositions(ele, i) {\n    if (typeof ele === \"number\") {\n      ele = i;\n    }\n    var theId = ele.data('id');\n    var lNode = self.idToLNode[theId];\n\n    return {\n      x: lNode.getRect().getCenterX(),\n      y: lNode.getRect().getCenterY()\n    };\n  };\n\n  /*\n   * Reposition nodes in iterations animatedly\n   */\n  var iterateAnimated = function iterateAnimated() {\n    // Thigs to perform after nodes are repositioned on screen\n    var afterReposition = function afterReposition() {\n      if (options.fit) {\n        options.cy.fit(options.eles, options.padding);\n      }\n\n      if (!ready) {\n        ready = true;\n        self.cy.one('layoutready', options.ready);\n        self.cy.trigger({ type: 'layoutready', layout: self });\n      }\n    };\n\n    var ticksPerFrame = self.options.refresh;\n    var isDone;\n\n    for (var i = 0; i < ticksPerFrame && !isDone; i++) {\n      isDone = self.stopped || self.layout.tick();\n    }\n\n    // If layout is done\n    if (isDone) {\n      // If the layout is not a sublayout and it is successful perform post layout.\n      if (layout.checkLayoutSuccess() && !layout.isSubLayout) {\n        layout.doPostLayout();\n      }\n\n      // If layout has a tilingPostLayout function property call it.\n      if (layout.tilingPostLayout) {\n        layout.tilingPostLayout();\n      }\n\n      layout.isLayoutFinished = true;\n\n      self.options.eles.nodes().positions(getPositions);\n\n      afterReposition();\n\n      // trigger layoutstop when the layout stops (e.g. finishes)\n      self.cy.one('layoutstop', self.options.stop);\n      self.cy.trigger({ type: 'layoutstop', layout: self });\n\n      if (frameId) {\n        cancelAnimationFrame(frameId);\n      }\n\n      ready = false;\n      return;\n    }\n\n    var animationData = self.layout.getPositionsData(); // Get positions of layout nodes note that all nodes may not be layout nodes because of tiling\n\n    // Position nodes, for the nodes whose id does not included in data (because they are removed from their parents and included in dummy compounds)\n    // use position of their ancestors or dummy ancestors\n    options.eles.nodes().positions(function (ele, i) {\n      if (typeof ele === \"number\") {\n        ele = i;\n      }\n      // If ele is a compound node, then its position will be defined by its children\n      if (!ele.isParent()) {\n        var theId = ele.id();\n        var pNode = animationData[theId];\n        var temp = ele;\n        // If pNode is undefined search until finding position data of its first ancestor (It may be dummy as well)\n        while (pNode == null) {\n          pNode = animationData[temp.data('parent')] || animationData['DummyCompound_' + temp.data('parent')];\n          animationData[theId] = pNode;\n          temp = temp.parent()[0];\n          if (temp == undefined) {\n            break;\n          }\n        }\n        if (pNode != null) {\n          return {\n            x: pNode.x,\n            y: pNode.y\n          };\n        } else {\n          return {\n            x: ele.position('x'),\n            y: ele.position('y')\n          };\n        }\n      }\n    });\n\n    afterReposition();\n\n    frameId = requestAnimationFrame(iterateAnimated);\n  };\n\n  /*\n  * Listen 'layoutstarted' event and start animated iteration if animate option is 'during'\n  */\n  layout.addListener('layoutstarted', function () {\n    if (self.options.animate === 'during') {\n      frameId = requestAnimationFrame(iterateAnimated);\n    }\n  });\n\n  layout.runLayout(); // Run cose layout\n\n  /*\n   * If animate option is not 'during' ('end' or false) perform these here (If it is 'during' similar things are already performed)\n   */\n  if (this.options.animate !== \"during\") {\n    self.options.eles.nodes().not(\":parent\").layoutPositions(self, self.options, getPositions); // Use layout positions to reposition the nodes it considers the options parameter\n    ready = false;\n  }\n\n  return this; // chaining\n};\n\n//Get the top most ones of a list of nodes\n_CoSELayout.prototype.getTopMostNodes = function (nodes) {\n  var nodesMap = {};\n  for (var i = 0; i < nodes.length; i++) {\n    nodesMap[nodes[i].id()] = true;\n  }\n  var roots = nodes.filter(function (ele, i) {\n    if (typeof ele === \"number\") {\n      ele = i;\n    }\n    var parent = ele.parent()[0];\n    while (parent != null) {\n      if (nodesMap[parent.id()]) {\n        return false;\n      }\n      parent = parent.parent()[0];\n    }\n    return true;\n  });\n\n  return roots;\n};\n\n_CoSELayout.prototype.processChildrenList = function (parent, children, layout) {\n  var size = children.length;\n  for (var i = 0; i < size; i++) {\n    var theChild = children[i];\n    var children_of_children = theChild.children();\n    var theNode;\n\n    var dimensions = theChild.layoutDimensions({\n      nodeDimensionsIncludeLabels: this.options.nodeDimensionsIncludeLabels\n    });\n\n    if (theChild.outerWidth() != null && theChild.outerHeight() != null) {\n      theNode = parent.add(new CoSENode(layout.graphManager, new PointD(theChild.position('x') - dimensions.w / 2, theChild.position('y') - dimensions.h / 2), new DimensionD(parseFloat(dimensions.w), parseFloat(dimensions.h))));\n    } else {\n      theNode = parent.add(new CoSENode(this.graphManager));\n    }\n    // Attach id to the layout node\n    theNode.id = theChild.data(\"id\");\n    // Attach the paddings of cy node to layout node\n    theNode.paddingLeft = parseInt(theChild.css('padding'));\n    theNode.paddingTop = parseInt(theChild.css('padding'));\n    theNode.paddingRight = parseInt(theChild.css('padding'));\n    theNode.paddingBottom = parseInt(theChild.css('padding'));\n\n    //Attach the label properties to compound if labels will be included in node dimensions  \n    if (this.options.nodeDimensionsIncludeLabels) {\n      if (theChild.isParent()) {\n        var labelWidth = theChild.boundingBox({ includeLabels: true, includeNodes: false }).w;\n        var labelHeight = theChild.boundingBox({ includeLabels: true, includeNodes: false }).h;\n        var labelPos = theChild.css(\"text-halign\");\n        theNode.labelWidth = labelWidth;\n        theNode.labelHeight = labelHeight;\n        theNode.labelPos = labelPos;\n      }\n    }\n\n    // Map the layout node\n    this.idToLNode[theChild.data(\"id\")] = theNode;\n\n    if (isNaN(theNode.rect.x)) {\n      theNode.rect.x = 0;\n    }\n\n    if (isNaN(theNode.rect.y)) {\n      theNode.rect.y = 0;\n    }\n\n    if (children_of_children != null && children_of_children.length > 0) {\n      var theNewGraph;\n      theNewGraph = layout.getGraphManager().add(layout.newGraph(), theNode);\n      this.processChildrenList(theNewGraph, children_of_children, layout);\n    }\n  }\n};\n\n/**\n * @brief : called on continuous layouts to stop them before they finish\n */\n_CoSELayout.prototype.stop = function () {\n  this.stopped = true;\n\n  return this; // chaining\n};\n\nvar register = function register(cytoscape) {\n  //  var Layout = getLayout( cytoscape );\n\n  cytoscape('layout', 'cose-bilkent', _CoSELayout);\n};\n\n// auto reg for globals\nif (typeof cytoscape !== 'undefined') {\n  register(cytoscape);\n}\n\nmodule.exports = register;\n\n/***/ })\n/******/ ]);\n});","import {\n  createText\n} from \"./chunk-6JOS74DS.mjs\";\nimport {\n  parseFontSize\n} from \"./chunk-7DKRZKHE.mjs\";\nimport {\n  selectSvgElement\n} from \"./chunk-EJ4ZWXGL.mjs\";\nimport {\n  __name,\n  defaultConfig_default,\n  getConfig2 as getConfig,\n  log,\n  sanitizeText,\n  setupGraphViewbox\n} from \"./chunk-6DBFFHIP.mjs\";\n\n// src/diagrams/mindmap/parser/mindmap.jison\nvar parser = function() {\n  var o = /* @__PURE__ */ __name(function(k, v, o2, l) {\n    for (o2 = o2 || {}, l = k.length; l--; o2[k[l]] = v) ;\n    return o2;\n  }, \"o\"), $V0 = [1, 4], $V1 = [1, 13], $V2 = [1, 12], $V3 = [1, 15], $V4 = [1, 16], $V5 = [1, 20], $V6 = [1, 19], $V7 = [6, 7, 8], $V8 = [1, 26], $V9 = [1, 24], $Va = [1, 25], $Vb = [6, 7, 11], $Vc = [1, 6, 13, 15, 16, 19, 22], $Vd = [1, 33], $Ve = [1, 34], $Vf = [1, 6, 7, 11, 13, 15, 16, 19, 22];\n  var parser2 = {\n    trace: /* @__PURE__ */ __name(function trace() {\n    }, \"trace\"),\n    yy: {},\n    symbols_: { \"error\": 2, \"start\": 3, \"mindMap\": 4, \"spaceLines\": 5, \"SPACELINE\": 6, \"NL\": 7, \"MINDMAP\": 8, \"document\": 9, \"stop\": 10, \"EOF\": 11, \"statement\": 12, \"SPACELIST\": 13, \"node\": 14, \"ICON\": 15, \"CLASS\": 16, \"nodeWithId\": 17, \"nodeWithoutId\": 18, \"NODE_DSTART\": 19, \"NODE_DESCR\": 20, \"NODE_DEND\": 21, \"NODE_ID\": 22, \"$accept\": 0, \"$end\": 1 },\n    terminals_: { 2: \"error\", 6: \"SPACELINE\", 7: \"NL\", 8: \"MINDMAP\", 11: \"EOF\", 13: \"SPACELIST\", 15: \"ICON\", 16: \"CLASS\", 19: \"NODE_DSTART\", 20: \"NODE_DESCR\", 21: \"NODE_DEND\", 22: \"NODE_ID\" },\n    productions_: [0, [3, 1], [3, 2], [5, 1], [5, 2], [5, 2], [4, 2], [4, 3], [10, 1], [10, 1], [10, 1], [10, 2], [10, 2], [9, 3], [9, 2], [12, 2], [12, 2], [12, 2], [12, 1], [12, 1], [12, 1], [12, 1], [12, 1], [14, 1], [14, 1], [18, 3], [17, 1], [17, 4]],\n    performAction: /* @__PURE__ */ __name(function anonymous(yytext, yyleng, yylineno, yy, yystate, $$, _$) {\n      var $0 = $$.length - 1;\n      switch (yystate) {\n        case 6:\n        case 7:\n          return yy;\n          break;\n        case 8:\n          yy.getLogger().trace(\"Stop NL \");\n          break;\n        case 9:\n          yy.getLogger().trace(\"Stop EOF \");\n          break;\n        case 11:\n          yy.getLogger().trace(\"Stop NL2 \");\n          break;\n        case 12:\n          yy.getLogger().trace(\"Stop EOF2 \");\n          break;\n        case 15:\n          yy.getLogger().info(\"Node: \", $$[$0].id);\n          yy.addNode($$[$0 - 1].length, $$[$0].id, $$[$0].descr, $$[$0].type);\n          break;\n        case 16:\n          yy.getLogger().trace(\"Icon: \", $$[$0]);\n          yy.decorateNode({ icon: $$[$0] });\n          break;\n        case 17:\n        case 21:\n          yy.decorateNode({ class: $$[$0] });\n          break;\n        case 18:\n          yy.getLogger().trace(\"SPACELIST\");\n          break;\n        case 19:\n          yy.getLogger().trace(\"Node: \", $$[$0].id);\n          yy.addNode(0, $$[$0].id, $$[$0].descr, $$[$0].type);\n          break;\n        case 20:\n          yy.decorateNode({ icon: $$[$0] });\n          break;\n        case 25:\n          yy.getLogger().trace(\"node found ..\", $$[$0 - 2]);\n          this.$ = { id: $$[$0 - 1], descr: $$[$0 - 1], type: yy.getType($$[$0 - 2], $$[$0]) };\n          break;\n        case 26:\n          this.$ = { id: $$[$0], descr: $$[$0], type: yy.nodeType.DEFAULT };\n          break;\n        case 27:\n          yy.getLogger().trace(\"node found ..\", $$[$0 - 3]);\n          this.$ = { id: $$[$0 - 3], descr: $$[$0 - 1], type: yy.getType($$[$0 - 2], $$[$0]) };\n          break;\n      }\n    }, \"anonymous\"),\n    table: [{ 3: 1, 4: 2, 5: 3, 6: [1, 5], 8: $V0 }, { 1: [3] }, { 1: [2, 1] }, { 4: 6, 6: [1, 7], 7: [1, 8], 8: $V0 }, { 6: $V1, 7: [1, 10], 9: 9, 12: 11, 13: $V2, 14: 14, 15: $V3, 16: $V4, 17: 17, 18: 18, 19: $V5, 22: $V6 }, o($V7, [2, 3]), { 1: [2, 2] }, o($V7, [2, 4]), o($V7, [2, 5]), { 1: [2, 6], 6: $V1, 12: 21, 13: $V2, 14: 14, 15: $V3, 16: $V4, 17: 17, 18: 18, 19: $V5, 22: $V6 }, { 6: $V1, 9: 22, 12: 11, 13: $V2, 14: 14, 15: $V3, 16: $V4, 17: 17, 18: 18, 19: $V5, 22: $V6 }, { 6: $V8, 7: $V9, 10: 23, 11: $Va }, o($Vb, [2, 22], { 17: 17, 18: 18, 14: 27, 15: [1, 28], 16: [1, 29], 19: $V5, 22: $V6 }), o($Vb, [2, 18]), o($Vb, [2, 19]), o($Vb, [2, 20]), o($Vb, [2, 21]), o($Vb, [2, 23]), o($Vb, [2, 24]), o($Vb, [2, 26], { 19: [1, 30] }), { 20: [1, 31] }, { 6: $V8, 7: $V9, 10: 32, 11: $Va }, { 1: [2, 7], 6: $V1, 12: 21, 13: $V2, 14: 14, 15: $V3, 16: $V4, 17: 17, 18: 18, 19: $V5, 22: $V6 }, o($Vc, [2, 14], { 7: $Vd, 11: $Ve }), o($Vf, [2, 8]), o($Vf, [2, 9]), o($Vf, [2, 10]), o($Vb, [2, 15]), o($Vb, [2, 16]), o($Vb, [2, 17]), { 20: [1, 35] }, { 21: [1, 36] }, o($Vc, [2, 13], { 7: $Vd, 11: $Ve }), o($Vf, [2, 11]), o($Vf, [2, 12]), { 21: [1, 37] }, o($Vb, [2, 25]), o($Vb, [2, 27])],\n    defaultActions: { 2: [2, 1], 6: [2, 2] },\n    parseError: /* @__PURE__ */ __name(function parseError(str, hash) {\n      if (hash.recoverable) {\n        this.trace(str);\n      } else {\n        var error = new Error(str);\n        error.hash = hash;\n        throw error;\n      }\n    }, \"parseError\"),\n    parse: /* @__PURE__ */ __name(function parse(input) {\n      var self = this, stack = [0], tstack = [], vstack = [null], lstack = [], table = this.table, yytext = \"\", yylineno = 0, yyleng = 0, recovering = 0, TERROR = 2, EOF = 1;\n      var args = lstack.slice.call(arguments, 1);\n      var lexer2 = Object.create(this.lexer);\n      var sharedState = { yy: {} };\n      for (var k in this.yy) {\n        if (Object.prototype.hasOwnProperty.call(this.yy, k)) {\n          sharedState.yy[k] = this.yy[k];\n        }\n      }\n      lexer2.setInput(input, sharedState.yy);\n      sharedState.yy.lexer = lexer2;\n      sharedState.yy.parser = this;\n      if (typeof lexer2.yylloc == \"undefined\") {\n        lexer2.yylloc = {};\n      }\n      var yyloc = lexer2.yylloc;\n      lstack.push(yyloc);\n      var ranges = lexer2.options && lexer2.options.ranges;\n      if (typeof sharedState.yy.parseError === \"function\") {\n        this.parseError = sharedState.yy.parseError;\n      } else {\n        this.parseError = Object.getPrototypeOf(this).parseError;\n      }\n      function popStack(n) {\n        stack.length = stack.length - 2 * n;\n        vstack.length = vstack.length - n;\n        lstack.length = lstack.length - n;\n      }\n      __name(popStack, \"popStack\");\n      function lex() {\n        var token;\n        token = tstack.pop() || lexer2.lex() || EOF;\n        if (typeof token !== \"number\") {\n          if (token instanceof Array) {\n            tstack = token;\n            token = tstack.pop();\n          }\n          token = self.symbols_[token] || token;\n        }\n        return token;\n      }\n      __name(lex, \"lex\");\n      var symbol, preErrorSymbol, state, action, a, r, yyval = {}, p, len, newState, expected;\n      while (true) {\n        state = stack[stack.length - 1];\n        if (this.defaultActions[state]) {\n          action = this.defaultActions[state];\n        } else {\n          if (symbol === null || typeof symbol == \"undefined\") {\n            symbol = lex();\n          }\n          action = table[state] && table[state][symbol];\n        }\n        if (typeof action === \"undefined\" || !action.length || !action[0]) {\n          var errStr = \"\";\n          expected = [];\n          for (p in table[state]) {\n            if (this.terminals_[p] && p > TERROR) {\n              expected.push(\"'\" + this.terminals_[p] + \"'\");\n            }\n          }\n          if (lexer2.showPosition) {\n            errStr = \"Parse error on line \" + (yylineno + 1) + \":\\n\" + lexer2.showPosition() + \"\\nExpecting \" + expected.join(\", \") + \", got '\" + (this.terminals_[symbol] || symbol) + \"'\";\n          } else {\n            errStr = \"Parse error on line \" + (yylineno + 1) + \": Unexpected \" + (symbol == EOF ? \"end of input\" : \"'\" + (this.terminals_[symbol] || symbol) + \"'\");\n          }\n          this.parseError(errStr, {\n            text: lexer2.match,\n            token: this.terminals_[symbol] || symbol,\n            line: lexer2.yylineno,\n            loc: yyloc,\n            expected\n          });\n        }\n        if (action[0] instanceof Array && action.length > 1) {\n          throw new Error(\"Parse Error: multiple actions possible at state: \" + state + \", token: \" + symbol);\n        }\n        switch (action[0]) {\n          case 1:\n            stack.push(symbol);\n            vstack.push(lexer2.yytext);\n            lstack.push(lexer2.yylloc);\n            stack.push(action[1]);\n            symbol = null;\n            if (!preErrorSymbol) {\n              yyleng = lexer2.yyleng;\n              yytext = lexer2.yytext;\n              yylineno = lexer2.yylineno;\n              yyloc = lexer2.yylloc;\n              if (recovering > 0) {\n                recovering--;\n              }\n            } else {\n              symbol = preErrorSymbol;\n              preErrorSymbol = null;\n            }\n            break;\n          case 2:\n            len = this.productions_[action[1]][1];\n            yyval.$ = vstack[vstack.length - len];\n            yyval._$ = {\n              first_line: lstack[lstack.length - (len || 1)].first_line,\n              last_line: lstack[lstack.length - 1].last_line,\n              first_column: lstack[lstack.length - (len || 1)].first_column,\n              last_column: lstack[lstack.length - 1].last_column\n            };\n            if (ranges) {\n              yyval._$.range = [\n                lstack[lstack.length - (len || 1)].range[0],\n                lstack[lstack.length - 1].range[1]\n              ];\n            }\n            r = this.performAction.apply(yyval, [\n              yytext,\n              yyleng,\n              yylineno,\n              sharedState.yy,\n              action[1],\n              vstack,\n              lstack\n            ].concat(args));\n            if (typeof r !== \"undefined\") {\n              return r;\n            }\n            if (len) {\n              stack = stack.slice(0, -1 * len * 2);\n              vstack = vstack.slice(0, -1 * len);\n              lstack = lstack.slice(0, -1 * len);\n            }\n            stack.push(this.productions_[action[1]][0]);\n            vstack.push(yyval.$);\n            lstack.push(yyval._$);\n            newState = table[stack[stack.length - 2]][stack[stack.length - 1]];\n            stack.push(newState);\n            break;\n          case 3:\n            return true;\n        }\n      }\n      return true;\n    }, \"parse\")\n  };\n  var lexer = /* @__PURE__ */ function() {\n    var lexer2 = {\n      EOF: 1,\n      parseError: /* @__PURE__ */ __name(function parseError(str, hash) {\n        if (this.yy.parser) {\n          this.yy.parser.parseError(str, hash);\n        } else {\n          throw new Error(str);\n        }\n      }, \"parseError\"),\n      // resets the lexer, sets new input\n      setInput: /* @__PURE__ */ __name(function(input, yy) {\n        this.yy = yy || this.yy || {};\n        this._input = input;\n        this._more = this._backtrack = this.done = false;\n        this.yylineno = this.yyleng = 0;\n        this.yytext = this.matched = this.match = \"\";\n        this.conditionStack = [\"INITIAL\"];\n        this.yylloc = {\n          first_line: 1,\n          first_column: 0,\n          last_line: 1,\n          last_column: 0\n        };\n        if (this.options.ranges) {\n          this.yylloc.range = [0, 0];\n        }\n        this.offset = 0;\n        return this;\n      }, \"setInput\"),\n      // consumes and returns one char from the input\n      input: /* @__PURE__ */ __name(function() {\n        var ch = this._input[0];\n        this.yytext += ch;\n        this.yyleng++;\n        this.offset++;\n        this.match += ch;\n        this.matched += ch;\n        var lines = ch.match(/(?:\\r\\n?|\\n).*/g);\n        if (lines) {\n          this.yylineno++;\n          this.yylloc.last_line++;\n        } else {\n          this.yylloc.last_column++;\n        }\n        if (this.options.ranges) {\n          this.yylloc.range[1]++;\n        }\n        this._input = this._input.slice(1);\n        return ch;\n      }, \"input\"),\n      // unshifts one char (or a string) into the input\n      unput: /* @__PURE__ */ __name(function(ch) {\n        var len = ch.length;\n        var lines = ch.split(/(?:\\r\\n?|\\n)/g);\n        this._input = ch + this._input;\n        this.yytext = this.yytext.substr(0, this.yytext.length - len);\n        this.offset -= len;\n        var oldLines = this.match.split(/(?:\\r\\n?|\\n)/g);\n        this.match = this.match.substr(0, this.match.length - 1);\n        this.matched = this.matched.substr(0, this.matched.length - 1);\n        if (lines.length - 1) {\n          this.yylineno -= lines.length - 1;\n        }\n        var r = this.yylloc.range;\n        this.yylloc = {\n          first_line: this.yylloc.first_line,\n          last_line: this.yylineno + 1,\n          first_column: this.yylloc.first_column,\n          last_column: lines ? (lines.length === oldLines.length ? this.yylloc.first_column : 0) + oldLines[oldLines.length - lines.length].length - lines[0].length : this.yylloc.first_column - len\n        };\n        if (this.options.ranges) {\n          this.yylloc.range = [r[0], r[0] + this.yyleng - len];\n        }\n        this.yyleng = this.yytext.length;\n        return this;\n      }, \"unput\"),\n      // When called from action, caches matched text and appends it on next action\n      more: /* @__PURE__ */ __name(function() {\n        this._more = true;\n        return this;\n      }, \"more\"),\n      // When called from action, signals the lexer that this rule fails to match the input, so the next matching rule (regex) should be tested instead.\n      reject: /* @__PURE__ */ __name(function() {\n        if (this.options.backtrack_lexer) {\n          this._backtrack = true;\n        } else {\n          return this.parseError(\"Lexical error on line \" + (this.yylineno + 1) + \". You can only invoke reject() in the lexer when the lexer is of the backtracking persuasion (options.backtrack_lexer = true).\\n\" + this.showPosition(), {\n            text: \"\",\n            token: null,\n            line: this.yylineno\n          });\n        }\n        return this;\n      }, \"reject\"),\n      // retain first n characters of the match\n      less: /* @__PURE__ */ __name(function(n) {\n        this.unput(this.match.slice(n));\n      }, \"less\"),\n      // displays already matched input, i.e. for error messages\n      pastInput: /* @__PURE__ */ __name(function() {\n        var past = this.matched.substr(0, this.matched.length - this.match.length);\n        return (past.length > 20 ? \"...\" : \"\") + past.substr(-20).replace(/\\n/g, \"\");\n      }, \"pastInput\"),\n      // displays upcoming input, i.e. for error messages\n      upcomingInput: /* @__PURE__ */ __name(function() {\n        var next = this.match;\n        if (next.length < 20) {\n          next += this._input.substr(0, 20 - next.length);\n        }\n        return (next.substr(0, 20) + (next.length > 20 ? \"...\" : \"\")).replace(/\\n/g, \"\");\n      }, \"upcomingInput\"),\n      // displays the character position where the lexing error occurred, i.e. for error messages\n      showPosition: /* @__PURE__ */ __name(function() {\n        var pre = this.pastInput();\n        var c = new Array(pre.length + 1).join(\"-\");\n        return pre + this.upcomingInput() + \"\\n\" + c + \"^\";\n      }, \"showPosition\"),\n      // test the lexed token: return FALSE when not a match, otherwise return token\n      test_match: /* @__PURE__ */ __name(function(match, indexed_rule) {\n        var token, lines, backup;\n        if (this.options.backtrack_lexer) {\n          backup = {\n            yylineno: this.yylineno,\n            yylloc: {\n              first_line: this.yylloc.first_line,\n              last_line: this.last_line,\n              first_column: this.yylloc.first_column,\n              last_column: this.yylloc.last_column\n            },\n            yytext: this.yytext,\n            match: this.match,\n            matches: this.matches,\n            matched: this.matched,\n            yyleng: this.yyleng,\n            offset: this.offset,\n            _more: this._more,\n            _input: this._input,\n            yy: this.yy,\n            conditionStack: this.conditionStack.slice(0),\n            done: this.done\n          };\n          if (this.options.ranges) {\n            backup.yylloc.range = this.yylloc.range.slice(0);\n          }\n        }\n        lines = match[0].match(/(?:\\r\\n?|\\n).*/g);\n        if (lines) {\n          this.yylineno += lines.length;\n        }\n        this.yylloc = {\n          first_line: this.yylloc.last_line,\n          last_line: this.yylineno + 1,\n          first_column: this.yylloc.last_column,\n          last_column: lines ? lines[lines.length - 1].length - lines[lines.length - 1].match(/\\r?\\n?/)[0].length : this.yylloc.last_column + match[0].length\n        };\n        this.yytext += match[0];\n        this.match += match[0];\n        this.matches = match;\n        this.yyleng = this.yytext.length;\n        if (this.options.ranges) {\n          this.yylloc.range = [this.offset, this.offset += this.yyleng];\n        }\n        this._more = false;\n        this._backtrack = false;\n        this._input = this._input.slice(match[0].length);\n        this.matched += match[0];\n        token = this.performAction.call(this, this.yy, this, indexed_rule, this.conditionStack[this.conditionStack.length - 1]);\n        if (this.done && this._input) {\n          this.done = false;\n        }\n        if (token) {\n          return token;\n        } else if (this._backtrack) {\n          for (var k in backup) {\n            this[k] = backup[k];\n          }\n          return false;\n        }\n        return false;\n      }, \"test_match\"),\n      // return next match in input\n      next: /* @__PURE__ */ __name(function() {\n        if (this.done) {\n          return this.EOF;\n        }\n        if (!this._input) {\n          this.done = true;\n        }\n        var token, match, tempMatch, index;\n        if (!this._more) {\n          this.yytext = \"\";\n          this.match = \"\";\n        }\n        var rules = this._currentRules();\n        for (var i = 0; i < rules.length; i++) {\n          tempMatch = this._input.match(this.rules[rules[i]]);\n          if (tempMatch && (!match || tempMatch[0].length > match[0].length)) {\n            match = tempMatch;\n            index = i;\n            if (this.options.backtrack_lexer) {\n              token = this.test_match(tempMatch, rules[i]);\n              if (token !== false) {\n                return token;\n              } else if (this._backtrack) {\n                match = false;\n                continue;\n              } else {\n                return false;\n              }\n            } else if (!this.options.flex) {\n              break;\n            }\n          }\n        }\n        if (match) {\n          token = this.test_match(match, rules[index]);\n          if (token !== false) {\n            return token;\n          }\n          return false;\n        }\n        if (this._input === \"\") {\n          return this.EOF;\n        } else {\n          return this.parseError(\"Lexical error on line \" + (this.yylineno + 1) + \". Unrecognized text.\\n\" + this.showPosition(), {\n            text: \"\",\n            token: null,\n            line: this.yylineno\n          });\n        }\n      }, \"next\"),\n      // return next match that has a token\n      lex: /* @__PURE__ */ __name(function lex() {\n        var r = this.next();\n        if (r) {\n          return r;\n        } else {\n          return this.lex();\n        }\n      }, \"lex\"),\n      // activates a new lexer condition state (pushes the new lexer condition state onto the condition stack)\n      begin: /* @__PURE__ */ __name(function begin(condition) {\n        this.conditionStack.push(condition);\n      }, \"begin\"),\n      // pop the previously active lexer condition state off the condition stack\n      popState: /* @__PURE__ */ __name(function popState() {\n        var n = this.conditionStack.length - 1;\n        if (n > 0) {\n          return this.conditionStack.pop();\n        } else {\n          return this.conditionStack[0];\n        }\n      }, \"popState\"),\n      // produce the lexer rule set which is active for the currently active lexer condition state\n      _currentRules: /* @__PURE__ */ __name(function _currentRules() {\n        if (this.conditionStack.length && this.conditionStack[this.conditionStack.length - 1]) {\n          return this.conditions[this.conditionStack[this.conditionStack.length - 1]].rules;\n        } else {\n          return this.conditions[\"INITIAL\"].rules;\n        }\n      }, \"_currentRules\"),\n      // return the currently active lexer condition state; when an index argument is provided it produces the N-th previous condition state, if available\n      topState: /* @__PURE__ */ __name(function topState(n) {\n        n = this.conditionStack.length - 1 - Math.abs(n || 0);\n        if (n >= 0) {\n          return this.conditionStack[n];\n        } else {\n          return \"INITIAL\";\n        }\n      }, \"topState\"),\n      // alias for begin(condition)\n      pushState: /* @__PURE__ */ __name(function pushState(condition) {\n        this.begin(condition);\n      }, \"pushState\"),\n      // return the number of states currently on the stack\n      stateStackSize: /* @__PURE__ */ __name(function stateStackSize() {\n        return this.conditionStack.length;\n      }, \"stateStackSize\"),\n      options: { \"case-insensitive\": true },\n      performAction: /* @__PURE__ */ __name(function anonymous(yy, yy_, $avoiding_name_collisions, YY_START) {\n        var YYSTATE = YY_START;\n        switch ($avoiding_name_collisions) {\n          case 0:\n            yy.getLogger().trace(\"Found comment\", yy_.yytext);\n            return 6;\n            break;\n          case 1:\n            return 8;\n            break;\n          case 2:\n            this.begin(\"CLASS\");\n            break;\n          case 3:\n            this.popState();\n            return 16;\n            break;\n          case 4:\n            this.popState();\n            break;\n          case 5:\n            yy.getLogger().trace(\"Begin icon\");\n            this.begin(\"ICON\");\n            break;\n          case 6:\n            yy.getLogger().trace(\"SPACELINE\");\n            return 6;\n            break;\n          case 7:\n            return 7;\n            break;\n          case 8:\n            return 15;\n            break;\n          case 9:\n            yy.getLogger().trace(\"end icon\");\n            this.popState();\n            break;\n          case 10:\n            yy.getLogger().trace(\"Exploding node\");\n            this.begin(\"NODE\");\n            return 19;\n            break;\n          case 11:\n            yy.getLogger().trace(\"Cloud\");\n            this.begin(\"NODE\");\n            return 19;\n            break;\n          case 12:\n            yy.getLogger().trace(\"Explosion Bang\");\n            this.begin(\"NODE\");\n            return 19;\n            break;\n          case 13:\n            yy.getLogger().trace(\"Cloud Bang\");\n            this.begin(\"NODE\");\n            return 19;\n            break;\n          case 14:\n            this.begin(\"NODE\");\n            return 19;\n            break;\n          case 15:\n            this.begin(\"NODE\");\n            return 19;\n            break;\n          case 16:\n            this.begin(\"NODE\");\n            return 19;\n            break;\n          case 17:\n            this.begin(\"NODE\");\n            return 19;\n            break;\n          case 18:\n            return 13;\n            break;\n          case 19:\n            return 22;\n            break;\n          case 20:\n            return 11;\n            break;\n          case 21:\n            this.begin(\"NSTR2\");\n            break;\n          case 22:\n            return \"NODE_DESCR\";\n            break;\n          case 23:\n            this.popState();\n            break;\n          case 24:\n            yy.getLogger().trace(\"Starting NSTR\");\n            this.begin(\"NSTR\");\n            break;\n          case 25:\n            yy.getLogger().trace(\"description:\", yy_.yytext);\n            return \"NODE_DESCR\";\n            break;\n          case 26:\n            this.popState();\n            break;\n          case 27:\n            this.popState();\n            yy.getLogger().trace(\"node end ))\");\n            return \"NODE_DEND\";\n            break;\n          case 28:\n            this.popState();\n            yy.getLogger().trace(\"node end )\");\n            return \"NODE_DEND\";\n            break;\n          case 29:\n            this.popState();\n            yy.getLogger().trace(\"node end ...\", yy_.yytext);\n            return \"NODE_DEND\";\n            break;\n          case 30:\n            this.popState();\n            yy.getLogger().trace(\"node end ((\");\n            return \"NODE_DEND\";\n            break;\n          case 31:\n            this.popState();\n            yy.getLogger().trace(\"node end (-\");\n            return \"NODE_DEND\";\n            break;\n          case 32:\n            this.popState();\n            yy.getLogger().trace(\"node end (-\");\n            return \"NODE_DEND\";\n            break;\n          case 33:\n            this.popState();\n            yy.getLogger().trace(\"node end ((\");\n            return \"NODE_DEND\";\n            break;\n          case 34:\n            this.popState();\n            yy.getLogger().trace(\"node end ((\");\n            return \"NODE_DEND\";\n            break;\n          case 35:\n            yy.getLogger().trace(\"Long description:\", yy_.yytext);\n            return 20;\n            break;\n          case 36:\n            yy.getLogger().trace(\"Long description:\", yy_.yytext);\n            return 20;\n            break;\n        }\n      }, \"anonymous\"),\n      rules: [/^(?:\\s*%%.*)/i, /^(?:mindmap\\b)/i, /^(?::::)/i, /^(?:.+)/i, /^(?:\\n)/i, /^(?:::icon\\()/i, /^(?:[\\s]+[\\n])/i, /^(?:[\\n]+)/i, /^(?:[^\\)]+)/i, /^(?:\\))/i, /^(?:-\\))/i, /^(?:\\(-)/i, /^(?:\\)\\))/i, /^(?:\\))/i, /^(?:\\(\\()/i, /^(?:\\{\\{)/i, /^(?:\\()/i, /^(?:\\[)/i, /^(?:[\\s]+)/i, /^(?:[^\\(\\[\\n\\)\\{\\}]+)/i, /^(?:$)/i, /^(?:[\"][`])/i, /^(?:[^`\"]+)/i, /^(?:[`][\"])/i, /^(?:[\"])/i, /^(?:[^\"]+)/i, /^(?:[\"])/i, /^(?:[\\)]\\))/i, /^(?:[\\)])/i, /^(?:[\\]])/i, /^(?:\\}\\})/i, /^(?:\\(-)/i, /^(?:-\\))/i, /^(?:\\(\\()/i, /^(?:\\()/i, /^(?:[^\\)\\]\\(\\}]+)/i, /^(?:.+(?!\\(\\())/i],\n      conditions: { \"CLASS\": { \"rules\": [3, 4], \"inclusive\": false }, \"ICON\": { \"rules\": [8, 9], \"inclusive\": false }, \"NSTR2\": { \"rules\": [22, 23], \"inclusive\": false }, \"NSTR\": { \"rules\": [25, 26], \"inclusive\": false }, \"NODE\": { \"rules\": [21, 24, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36], \"inclusive\": false }, \"INITIAL\": { \"rules\": [0, 1, 2, 5, 6, 7, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20], \"inclusive\": true } }\n    };\n    return lexer2;\n  }();\n  parser2.lexer = lexer;\n  function Parser() {\n    this.yy = {};\n  }\n  __name(Parser, \"Parser\");\n  Parser.prototype = parser2;\n  parser2.Parser = Parser;\n  return new Parser();\n}();\nparser.parser = parser;\nvar mindmap_default = parser;\n\n// src/diagrams/mindmap/mindmapDb.ts\nvar nodes = [];\nvar cnt = 0;\nvar elements = {};\nvar clear = /* @__PURE__ */ __name(() => {\n  nodes = [];\n  cnt = 0;\n  elements = {};\n}, \"clear\");\nvar getParent = /* @__PURE__ */ __name(function(level) {\n  for (let i = nodes.length - 1; i >= 0; i--) {\n    if (nodes[i].level < level) {\n      return nodes[i];\n    }\n  }\n  return null;\n}, \"getParent\");\nvar getMindmap = /* @__PURE__ */ __name(() => {\n  return nodes.length > 0 ? nodes[0] : null;\n}, \"getMindmap\");\nvar addNode = /* @__PURE__ */ __name((level, id, descr, type) => {\n  log.info(\"addNode\", level, id, descr, type);\n  const conf = getConfig();\n  let padding = conf.mindmap?.padding ?? defaultConfig_default.mindmap.padding;\n  switch (type) {\n    case nodeType.ROUNDED_RECT:\n    case nodeType.RECT:\n    case nodeType.HEXAGON:\n      padding *= 2;\n  }\n  const node = {\n    id: cnt++,\n    nodeId: sanitizeText(id, conf),\n    level,\n    descr: sanitizeText(descr, conf),\n    type,\n    children: [],\n    width: conf.mindmap?.maxNodeWidth ?? defaultConfig_default.mindmap.maxNodeWidth,\n    padding\n  };\n  const parent = getParent(level);\n  if (parent) {\n    parent.children.push(node);\n    nodes.push(node);\n  } else {\n    if (nodes.length === 0) {\n      nodes.push(node);\n    } else {\n      throw new Error(\n        'There can be only one root. No parent could be found for (\"' + node.descr + '\")'\n      );\n    }\n  }\n}, \"addNode\");\nvar nodeType = {\n  DEFAULT: 0,\n  NO_BORDER: 0,\n  ROUNDED_RECT: 1,\n  RECT: 2,\n  CIRCLE: 3,\n  CLOUD: 4,\n  BANG: 5,\n  HEXAGON: 6\n};\nvar getType = /* @__PURE__ */ __name((startStr, endStr) => {\n  log.debug(\"In get type\", startStr, endStr);\n  switch (startStr) {\n    case \"[\":\n      return nodeType.RECT;\n    case \"(\":\n      return endStr === \")\" ? nodeType.ROUNDED_RECT : nodeType.CLOUD;\n    case \"((\":\n      return nodeType.CIRCLE;\n    case \")\":\n      return nodeType.CLOUD;\n    case \"))\":\n      return nodeType.BANG;\n    case \"{{\":\n      return nodeType.HEXAGON;\n    default:\n      return nodeType.DEFAULT;\n  }\n}, \"getType\");\nvar setElementForId = /* @__PURE__ */ __name((id, element) => {\n  elements[id] = element;\n}, \"setElementForId\");\nvar decorateNode = /* @__PURE__ */ __name((decoration) => {\n  if (!decoration) {\n    return;\n  }\n  const config = getConfig();\n  const node = nodes[nodes.length - 1];\n  if (decoration.icon) {\n    node.icon = sanitizeText(decoration.icon, config);\n  }\n  if (decoration.class) {\n    node.class = sanitizeText(decoration.class, config);\n  }\n}, \"decorateNode\");\nvar type2Str = /* @__PURE__ */ __name((type) => {\n  switch (type) {\n    case nodeType.DEFAULT:\n      return \"no-border\";\n    case nodeType.RECT:\n      return \"rect\";\n    case nodeType.ROUNDED_RECT:\n      return \"rounded-rect\";\n    case nodeType.CIRCLE:\n      return \"circle\";\n    case nodeType.CLOUD:\n      return \"cloud\";\n    case nodeType.BANG:\n      return \"bang\";\n    case nodeType.HEXAGON:\n      return \"hexgon\";\n    default:\n      return \"no-border\";\n  }\n}, \"type2Str\");\nvar getLogger = /* @__PURE__ */ __name(() => log, \"getLogger\");\nvar getElementById = /* @__PURE__ */ __name((id) => elements[id], \"getElementById\");\nvar db = {\n  clear,\n  addNode,\n  getMindmap,\n  nodeType,\n  getType,\n  setElementForId,\n  decorateNode,\n  type2Str,\n  getLogger,\n  getElementById\n};\nvar mindmapDb_default = db;\n\n// src/diagrams/mindmap/mindmapRenderer.ts\nimport cytoscape from \"cytoscape\";\nimport coseBilkent from \"cytoscape-cose-bilkent\";\nimport { select } from \"d3\";\n\n// src/diagrams/mindmap/svgDraw.ts\nvar MAX_SECTIONS = 12;\nvar defaultBkg = /* @__PURE__ */ __name(function(db2, elem, node, section) {\n  const rd = 5;\n  elem.append(\"path\").attr(\"id\", \"node-\" + node.id).attr(\"class\", \"node-bkg node-\" + db2.type2Str(node.type)).attr(\n    \"d\",\n    `M0 ${node.height - rd} v${-node.height + 2 * rd} q0,-5 5,-5 h${node.width - 2 * rd} q5,0 5,5 v${node.height - rd} H0 Z`\n  );\n  elem.append(\"line\").attr(\"class\", \"node-line-\" + section).attr(\"x1\", 0).attr(\"y1\", node.height).attr(\"x2\", node.width).attr(\"y2\", node.height);\n}, \"defaultBkg\");\nvar rectBkg = /* @__PURE__ */ __name(function(db2, elem, node) {\n  elem.append(\"rect\").attr(\"id\", \"node-\" + node.id).attr(\"class\", \"node-bkg node-\" + db2.type2Str(node.type)).attr(\"height\", node.height).attr(\"width\", node.width);\n}, \"rectBkg\");\nvar cloudBkg = /* @__PURE__ */ __name(function(db2, elem, node) {\n  const w = node.width;\n  const h = node.height;\n  const r1 = 0.15 * w;\n  const r2 = 0.25 * w;\n  const r3 = 0.35 * w;\n  const r4 = 0.2 * w;\n  elem.append(\"path\").attr(\"id\", \"node-\" + node.id).attr(\"class\", \"node-bkg node-\" + db2.type2Str(node.type)).attr(\n    \"d\",\n    `M0 0 a${r1},${r1} 0 0,1 ${w * 0.25},${-1 * w * 0.1}\n      a${r3},${r3} 1 0,1 ${w * 0.4},${-1 * w * 0.1}\n      a${r2},${r2} 1 0,1 ${w * 0.35},${1 * w * 0.2}\n\n      a${r1},${r1} 1 0,1 ${w * 0.15},${1 * h * 0.35}\n      a${r4},${r4} 1 0,1 ${-1 * w * 0.15},${1 * h * 0.65}\n\n      a${r2},${r1} 1 0,1 ${-1 * w * 0.25},${w * 0.15}\n      a${r3},${r3} 1 0,1 ${-1 * w * 0.5},${0}\n      a${r1},${r1} 1 0,1 ${-1 * w * 0.25},${-1 * w * 0.15}\n\n      a${r1},${r1} 1 0,1 ${-1 * w * 0.1},${-1 * h * 0.35}\n      a${r4},${r4} 1 0,1 ${w * 0.1},${-1 * h * 0.65}\n\n    H0 V0 Z`\n  );\n}, \"cloudBkg\");\nvar bangBkg = /* @__PURE__ */ __name(function(db2, elem, node) {\n  const w = node.width;\n  const h = node.height;\n  const r = 0.15 * w;\n  elem.append(\"path\").attr(\"id\", \"node-\" + node.id).attr(\"class\", \"node-bkg node-\" + db2.type2Str(node.type)).attr(\n    \"d\",\n    `M0 0 a${r},${r} 1 0,0 ${w * 0.25},${-1 * h * 0.1}\n      a${r},${r} 1 0,0 ${w * 0.25},${0}\n      a${r},${r} 1 0,0 ${w * 0.25},${0}\n      a${r},${r} 1 0,0 ${w * 0.25},${1 * h * 0.1}\n\n      a${r},${r} 1 0,0 ${w * 0.15},${1 * h * 0.33}\n      a${r * 0.8},${r * 0.8} 1 0,0 ${0},${1 * h * 0.34}\n      a${r},${r} 1 0,0 ${-1 * w * 0.15},${1 * h * 0.33}\n\n      a${r},${r} 1 0,0 ${-1 * w * 0.25},${h * 0.15}\n      a${r},${r} 1 0,0 ${-1 * w * 0.25},${0}\n      a${r},${r} 1 0,0 ${-1 * w * 0.25},${0}\n      a${r},${r} 1 0,0 ${-1 * w * 0.25},${-1 * h * 0.15}\n\n      a${r},${r} 1 0,0 ${-1 * w * 0.1},${-1 * h * 0.33}\n      a${r * 0.8},${r * 0.8} 1 0,0 ${0},${-1 * h * 0.34}\n      a${r},${r} 1 0,0 ${w * 0.1},${-1 * h * 0.33}\n\n    H0 V0 Z`\n  );\n}, \"bangBkg\");\nvar circleBkg = /* @__PURE__ */ __name(function(db2, elem, node) {\n  elem.append(\"circle\").attr(\"id\", \"node-\" + node.id).attr(\"class\", \"node-bkg node-\" + db2.type2Str(node.type)).attr(\"r\", node.width / 2);\n}, \"circleBkg\");\nfunction insertPolygonShape(parent, w, h, points, node) {\n  return parent.insert(\"polygon\", \":first-child\").attr(\n    \"points\",\n    points.map(function(d) {\n      return d.x + \",\" + d.y;\n    }).join(\" \")\n  ).attr(\"transform\", \"translate(\" + (node.width - w) / 2 + \", \" + h + \")\");\n}\n__name(insertPolygonShape, \"insertPolygonShape\");\nvar hexagonBkg = /* @__PURE__ */ __name(function(_db, elem, node) {\n  const h = node.height;\n  const f = 4;\n  const m = h / f;\n  const w = node.width - node.padding + 2 * m;\n  const points = [\n    { x: m, y: 0 },\n    { x: w - m, y: 0 },\n    { x: w, y: -h / 2 },\n    { x: w - m, y: -h },\n    { x: m, y: -h },\n    { x: 0, y: -h / 2 }\n  ];\n  insertPolygonShape(elem, w, h, points, node);\n}, \"hexagonBkg\");\nvar roundedRectBkg = /* @__PURE__ */ __name(function(db2, elem, node) {\n  elem.append(\"rect\").attr(\"id\", \"node-\" + node.id).attr(\"class\", \"node-bkg node-\" + db2.type2Str(node.type)).attr(\"height\", node.height).attr(\"rx\", node.padding).attr(\"ry\", node.padding).attr(\"width\", node.width);\n}, \"roundedRectBkg\");\nvar drawNode = /* @__PURE__ */ __name(async function(db2, elem, node, fullSection, conf) {\n  const htmlLabels = conf.htmlLabels;\n  const section = fullSection % (MAX_SECTIONS - 1);\n  const nodeElem = elem.append(\"g\");\n  node.section = section;\n  let sectionClass = \"section-\" + section;\n  if (section < 0) {\n    sectionClass += \" section-root\";\n  }\n  nodeElem.attr(\"class\", (node.class ? node.class + \" \" : \"\") + \"mindmap-node \" + sectionClass);\n  const bkgElem = nodeElem.append(\"g\");\n  const textElem = nodeElem.append(\"g\");\n  const description = node.descr.replace(/(<br\\/*>)/g, \"\\n\");\n  await createText(\n    textElem,\n    description,\n    {\n      useHtmlLabels: htmlLabels,\n      width: node.width,\n      classes: \"mindmap-node-label\"\n    },\n    conf\n  );\n  if (!htmlLabels) {\n    textElem.attr(\"dy\", \"1em\").attr(\"alignment-baseline\", \"middle\").attr(\"dominant-baseline\", \"middle\").attr(\"text-anchor\", \"middle\");\n  }\n  const bbox = textElem.node().getBBox();\n  const [fontSize] = parseFontSize(conf.fontSize);\n  node.height = bbox.height + fontSize * 1.1 * 0.5 + node.padding;\n  node.width = bbox.width + 2 * node.padding;\n  if (node.icon) {\n    if (node.type === db2.nodeType.CIRCLE) {\n      node.height += 50;\n      node.width += 50;\n      const icon = nodeElem.append(\"foreignObject\").attr(\"height\", \"50px\").attr(\"width\", node.width).attr(\"style\", \"text-align: center;\");\n      icon.append(\"div\").attr(\"class\", \"icon-container\").append(\"i\").attr(\"class\", \"node-icon-\" + section + \" \" + node.icon);\n      textElem.attr(\n        \"transform\",\n        \"translate(\" + node.width / 2 + \", \" + (node.height / 2 - 1.5 * node.padding) + \")\"\n      );\n    } else {\n      node.width += 50;\n      const orgHeight = node.height;\n      node.height = Math.max(orgHeight, 60);\n      const heightDiff = Math.abs(node.height - orgHeight);\n      const icon = nodeElem.append(\"foreignObject\").attr(\"width\", \"60px\").attr(\"height\", node.height).attr(\"style\", \"text-align: center;margin-top:\" + heightDiff / 2 + \"px;\");\n      icon.append(\"div\").attr(\"class\", \"icon-container\").append(\"i\").attr(\"class\", \"node-icon-\" + section + \" \" + node.icon);\n      textElem.attr(\n        \"transform\",\n        \"translate(\" + (25 + node.width / 2) + \", \" + (heightDiff / 2 + node.padding / 2) + \")\"\n      );\n    }\n  } else {\n    if (!htmlLabels) {\n      const dx = node.width / 2;\n      const dy = node.padding / 2;\n      textElem.attr(\"transform\", \"translate(\" + dx + \", \" + dy + \")\");\n    } else {\n      const dx = (node.width - bbox.width) / 2;\n      const dy = (node.height - bbox.height) / 2;\n      textElem.attr(\"transform\", \"translate(\" + dx + \", \" + dy + \")\");\n    }\n  }\n  switch (node.type) {\n    case db2.nodeType.DEFAULT:\n      defaultBkg(db2, bkgElem, node, section);\n      break;\n    case db2.nodeType.ROUNDED_RECT:\n      roundedRectBkg(db2, bkgElem, node, section);\n      break;\n    case db2.nodeType.RECT:\n      rectBkg(db2, bkgElem, node, section);\n      break;\n    case db2.nodeType.CIRCLE:\n      bkgElem.attr(\"transform\", \"translate(\" + node.width / 2 + \", \" + +node.height / 2 + \")\");\n      circleBkg(db2, bkgElem, node, section);\n      break;\n    case db2.nodeType.CLOUD:\n      cloudBkg(db2, bkgElem, node, section);\n      break;\n    case db2.nodeType.BANG:\n      bangBkg(db2, bkgElem, node, section);\n      break;\n    case db2.nodeType.HEXAGON:\n      hexagonBkg(db2, bkgElem, node, section);\n      break;\n  }\n  db2.setElementForId(node.id, nodeElem);\n  return node.height;\n}, \"drawNode\");\nvar positionNode = /* @__PURE__ */ __name(function(db2, node) {\n  const nodeElem = db2.getElementById(node.id);\n  const x = node.x || 0;\n  const y = node.y || 0;\n  nodeElem.attr(\"transform\", \"translate(\" + x + \",\" + y + \")\");\n}, \"positionNode\");\n\n// src/diagrams/mindmap/mindmapRenderer.ts\ncytoscape.use(coseBilkent);\nasync function drawNodes(db2, svg, mindmap, section, conf) {\n  await drawNode(db2, svg, mindmap, section, conf);\n  if (mindmap.children) {\n    await Promise.all(\n      mindmap.children.map(\n        (child, index) => drawNodes(db2, svg, child, section < 0 ? index : section, conf)\n      )\n    );\n  }\n}\n__name(drawNodes, \"drawNodes\");\nfunction drawEdges(edgesEl, cy) {\n  cy.edges().map((edge, id) => {\n    const data = edge.data();\n    if (edge[0]._private.bodyBounds) {\n      const bounds = edge[0]._private.rscratch;\n      log.trace(\"Edge: \", id, data);\n      edgesEl.insert(\"path\").attr(\n        \"d\",\n        `M ${bounds.startX},${bounds.startY} L ${bounds.midX},${bounds.midY} L${bounds.endX},${bounds.endY} `\n      ).attr(\"class\", \"edge section-edge-\" + data.section + \" edge-depth-\" + data.depth);\n    }\n  });\n}\n__name(drawEdges, \"drawEdges\");\nfunction addNodes(mindmap, cy, conf, level) {\n  cy.add({\n    group: \"nodes\",\n    data: {\n      id: mindmap.id.toString(),\n      labelText: mindmap.descr,\n      height: mindmap.height,\n      width: mindmap.width,\n      level,\n      nodeId: mindmap.id,\n      padding: mindmap.padding,\n      type: mindmap.type\n    },\n    position: {\n      x: mindmap.x,\n      y: mindmap.y\n    }\n  });\n  if (mindmap.children) {\n    mindmap.children.forEach((child) => {\n      addNodes(child, cy, conf, level + 1);\n      cy.add({\n        group: \"edges\",\n        data: {\n          id: `${mindmap.id}_${child.id}`,\n          source: mindmap.id,\n          target: child.id,\n          depth: level,\n          section: child.section\n        }\n      });\n    });\n  }\n}\n__name(addNodes, \"addNodes\");\nfunction layoutMindmap(node, conf) {\n  return new Promise((resolve) => {\n    const renderEl = select(\"body\").append(\"div\").attr(\"id\", \"cy\").attr(\"style\", \"display:none\");\n    const cy = cytoscape({\n      container: document.getElementById(\"cy\"),\n      // container to render in\n      style: [\n        {\n          selector: \"edge\",\n          style: {\n            \"curve-style\": \"bezier\"\n          }\n        }\n      ]\n    });\n    renderEl.remove();\n    addNodes(node, cy, conf, 0);\n    cy.nodes().forEach(function(n) {\n      n.layoutDimensions = () => {\n        const data = n.data();\n        return { w: data.width, h: data.height };\n      };\n    });\n    cy.layout({\n      name: \"cose-bilkent\",\n      // @ts-ignore Types for cose-bilkent are not correct?\n      quality: \"proof\",\n      styleEnabled: false,\n      animate: false\n    }).run();\n    cy.ready((e) => {\n      log.info(\"Ready\", e);\n      resolve(cy);\n    });\n  });\n}\n__name(layoutMindmap, \"layoutMindmap\");\nfunction positionNodes(db2, cy) {\n  cy.nodes().map((node, id) => {\n    const data = node.data();\n    data.x = node.position().x;\n    data.y = node.position().y;\n    positionNode(db2, data);\n    const el = db2.getElementById(data.nodeId);\n    log.info(\"Id:\", id, \"Position: (\", node.position().x, \", \", node.position().y, \")\", data);\n    el.attr(\n      \"transform\",\n      `translate(${node.position().x - data.width / 2}, ${node.position().y - data.height / 2})`\n    );\n    el.attr(\"attr\", `apa-${id})`);\n  });\n}\n__name(positionNodes, \"positionNodes\");\nvar draw = /* @__PURE__ */ __name(async (text, id, _version, diagObj) => {\n  log.debug(\"Rendering mindmap diagram\\n\" + text);\n  const db2 = diagObj.db;\n  const mm = db2.getMindmap();\n  if (!mm) {\n    return;\n  }\n  const conf = getConfig();\n  conf.htmlLabels = false;\n  const svg = selectSvgElement(id);\n  const edgesElem = svg.append(\"g\");\n  edgesElem.attr(\"class\", \"mindmap-edges\");\n  const nodesElem = svg.append(\"g\");\n  nodesElem.attr(\"class\", \"mindmap-nodes\");\n  await drawNodes(db2, nodesElem, mm, -1, conf);\n  const cy = await layoutMindmap(mm, conf);\n  drawEdges(edgesElem, cy);\n  positionNodes(db2, cy);\n  setupGraphViewbox(\n    void 0,\n    svg,\n    conf.mindmap?.padding ?? defaultConfig_default.mindmap.padding,\n    conf.mindmap?.useMaxWidth ?? defaultConfig_default.mindmap.useMaxWidth\n  );\n}, \"draw\");\nvar mindmapRenderer_default = {\n  draw\n};\n\n// src/diagrams/mindmap/styles.ts\nimport { darken, lighten, isDark } from \"khroma\";\nvar genSections = /* @__PURE__ */ __name((options) => {\n  let sections = \"\";\n  for (let i = 0; i < options.THEME_COLOR_LIMIT; i++) {\n    options[\"lineColor\" + i] = options[\"lineColor\" + i] || options[\"cScaleInv\" + i];\n    if (isDark(options[\"lineColor\" + i])) {\n      options[\"lineColor\" + i] = lighten(options[\"lineColor\" + i], 20);\n    } else {\n      options[\"lineColor\" + i] = darken(options[\"lineColor\" + i], 20);\n    }\n  }\n  for (let i = 0; i < options.THEME_COLOR_LIMIT; i++) {\n    const sw = \"\" + (17 - 3 * i);\n    sections += `\n    .section-${i - 1} rect, .section-${i - 1} path, .section-${i - 1} circle, .section-${i - 1} polygon, .section-${i - 1} path  {\n      fill: ${options[\"cScale\" + i]};\n    }\n    .section-${i - 1} text {\n     fill: ${options[\"cScaleLabel\" + i]};\n    }\n    .node-icon-${i - 1} {\n      font-size: 40px;\n      color: ${options[\"cScaleLabel\" + i]};\n    }\n    .section-edge-${i - 1}{\n      stroke: ${options[\"cScale\" + i]};\n    }\n    .edge-depth-${i - 1}{\n      stroke-width: ${sw};\n    }\n    .section-${i - 1} line {\n      stroke: ${options[\"cScaleInv\" + i]} ;\n      stroke-width: 3;\n    }\n\n    .disabled, .disabled circle, .disabled text {\n      fill: lightgray;\n    }\n    .disabled text {\n      fill: #efefef;\n    }\n    `;\n  }\n  return sections;\n}, \"genSections\");\nvar getStyles = /* @__PURE__ */ __name((options) => `\n  .edge {\n    stroke-width: 3;\n  }\n  ${genSections(options)}\n  .section-root rect, .section-root path, .section-root circle, .section-root polygon  {\n    fill: ${options.git0};\n  }\n  .section-root text {\n    fill: ${options.gitBranchLabel0};\n  }\n  .icon-container {\n    height:100%;\n    display: flex;\n    justify-content: center;\n    align-items: center;\n  }\n  .edge {\n    fill: none;\n  }\n  .mindmap-node-label {\n    dy: 1em;\n    alignment-baseline: middle;\n    text-anchor: middle;\n    dominant-baseline: middle;\n    text-align: center;\n  }\n`, \"getStyles\");\nvar styles_default = getStyles;\n\n// src/diagrams/mindmap/mindmap-definition.ts\nvar diagram = {\n  db: mindmapDb_default,\n  renderer: mindmapRenderer_default,\n  parser: mindmap_default,\n  styles: styles_default\n};\nexport {\n  diagram\n};\n","(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory(require(\"layout-base\"));\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([\"layout-base\"], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"coseBase\"] = factory(require(\"layout-base\"));\n\telse\n\t\troot[\"coseBase\"] = factory(root[\"layoutBase\"]);\n})(this, function(__WEBPACK_EXTERNAL_MODULE_0__) {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId]) {\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/ \t\t}\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\ti: moduleId,\n/******/ \t\t\tl: false,\n/******/ \t\t\texports: {}\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.l = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// identity function for calling harmony imports with the correct context\n/******/ \t__webpack_require__.i = function(value) { return value; };\n/******/\n/******/ \t// define getter function for harmony exports\n/******/ \t__webpack_require__.d = function(exports, name, getter) {\n/******/ \t\tif(!__webpack_require__.o(exports, name)) {\n/******/ \t\t\tObject.defineProperty(exports, name, {\n/******/ \t\t\t\tconfigurable: false,\n/******/ \t\t\t\tenumerable: true,\n/******/ \t\t\t\tget: getter\n/******/ \t\t\t});\n/******/ \t\t}\n/******/ \t};\n/******/\n/******/ \t// getDefaultExport function for compatibility with non-harmony modules\n/******/ \t__webpack_require__.n = function(module) {\n/******/ \t\tvar getter = module && module.__esModule ?\n/******/ \t\t\tfunction getDefault() { return module['default']; } :\n/******/ \t\t\tfunction getModuleExports() { return module; };\n/******/ \t\t__webpack_require__.d(getter, 'a', getter);\n/******/ \t\treturn getter;\n/******/ \t};\n/******/\n/******/ \t// Object.prototype.hasOwnProperty.call\n/******/ \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(__webpack_require__.s = 7);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, exports) {\n\nmodule.exports = __WEBPACK_EXTERNAL_MODULE_0__;\n\n/***/ }),\n/* 1 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar FDLayoutConstants = __webpack_require__(0).FDLayoutConstants;\n\nfunction CoSEConstants() {}\n\n//CoSEConstants inherits static props in FDLayoutConstants\nfor (var prop in FDLayoutConstants) {\n  CoSEConstants[prop] = FDLayoutConstants[prop];\n}\n\nCoSEConstants.DEFAULT_USE_MULTI_LEVEL_SCALING = false;\nCoSEConstants.DEFAULT_RADIAL_SEPARATION = FDLayoutConstants.DEFAULT_EDGE_LENGTH;\nCoSEConstants.DEFAULT_COMPONENT_SEPERATION = 60;\nCoSEConstants.TILE = true;\nCoSEConstants.TILING_PADDING_VERTICAL = 10;\nCoSEConstants.TILING_PADDING_HORIZONTAL = 10;\nCoSEConstants.TREE_REDUCTION_ON_INCREMENTAL = false; // make this true when cose is used incrementally as a part of other non-incremental layout\n\nmodule.exports = CoSEConstants;\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar FDLayoutEdge = __webpack_require__(0).FDLayoutEdge;\n\nfunction CoSEEdge(source, target, vEdge) {\n  FDLayoutEdge.call(this, source, target, vEdge);\n}\n\nCoSEEdge.prototype = Object.create(FDLayoutEdge.prototype);\nfor (var prop in FDLayoutEdge) {\n  CoSEEdge[prop] = FDLayoutEdge[prop];\n}\n\nmodule.exports = CoSEEdge;\n\n/***/ }),\n/* 3 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar LGraph = __webpack_require__(0).LGraph;\n\nfunction CoSEGraph(parent, graphMgr, vGraph) {\n  LGraph.call(this, parent, graphMgr, vGraph);\n}\n\nCoSEGraph.prototype = Object.create(LGraph.prototype);\nfor (var prop in LGraph) {\n  CoSEGraph[prop] = LGraph[prop];\n}\n\nmodule.exports = CoSEGraph;\n\n/***/ }),\n/* 4 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar LGraphManager = __webpack_require__(0).LGraphManager;\n\nfunction CoSEGraphManager(layout) {\n  LGraphManager.call(this, layout);\n}\n\nCoSEGraphManager.prototype = Object.create(LGraphManager.prototype);\nfor (var prop in LGraphManager) {\n  CoSEGraphManager[prop] = LGraphManager[prop];\n}\n\nmodule.exports = CoSEGraphManager;\n\n/***/ }),\n/* 5 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar FDLayoutNode = __webpack_require__(0).FDLayoutNode;\nvar IMath = __webpack_require__(0).IMath;\n\nfunction CoSENode(gm, loc, size, vNode) {\n  FDLayoutNode.call(this, gm, loc, size, vNode);\n}\n\nCoSENode.prototype = Object.create(FDLayoutNode.prototype);\nfor (var prop in FDLayoutNode) {\n  CoSENode[prop] = FDLayoutNode[prop];\n}\n\nCoSENode.prototype.move = function () {\n  var layout = this.graphManager.getLayout();\n  this.displacementX = layout.coolingFactor * (this.springForceX + this.repulsionForceX + this.gravitationForceX) / this.noOfChildren;\n  this.displacementY = layout.coolingFactor * (this.springForceY + this.repulsionForceY + this.gravitationForceY) / this.noOfChildren;\n\n  if (Math.abs(this.displacementX) > layout.coolingFactor * layout.maxNodeDisplacement) {\n    this.displacementX = layout.coolingFactor * layout.maxNodeDisplacement * IMath.sign(this.displacementX);\n  }\n\n  if (Math.abs(this.displacementY) > layout.coolingFactor * layout.maxNodeDisplacement) {\n    this.displacementY = layout.coolingFactor * layout.maxNodeDisplacement * IMath.sign(this.displacementY);\n  }\n\n  // a simple node, just move it\n  if (this.child == null) {\n    this.moveBy(this.displacementX, this.displacementY);\n  }\n  // an empty compound node, again just move it\n  else if (this.child.getNodes().length == 0) {\n      this.moveBy(this.displacementX, this.displacementY);\n    }\n    // non-empty compound node, propogate movement to children as well\n    else {\n        this.propogateDisplacementToChildren(this.displacementX, this.displacementY);\n      }\n\n  layout.totalDisplacement += Math.abs(this.displacementX) + Math.abs(this.displacementY);\n\n  this.springForceX = 0;\n  this.springForceY = 0;\n  this.repulsionForceX = 0;\n  this.repulsionForceY = 0;\n  this.gravitationForceX = 0;\n  this.gravitationForceY = 0;\n  this.displacementX = 0;\n  this.displacementY = 0;\n};\n\nCoSENode.prototype.propogateDisplacementToChildren = function (dX, dY) {\n  var nodes = this.getChild().getNodes();\n  var node;\n  for (var i = 0; i < nodes.length; i++) {\n    node = nodes[i];\n    if (node.getChild() == null) {\n      node.moveBy(dX, dY);\n      node.displacementX += dX;\n      node.displacementY += dY;\n    } else {\n      node.propogateDisplacementToChildren(dX, dY);\n    }\n  }\n};\n\nCoSENode.prototype.setPred1 = function (pred1) {\n  this.pred1 = pred1;\n};\n\nCoSENode.prototype.getPred1 = function () {\n  return pred1;\n};\n\nCoSENode.prototype.getPred2 = function () {\n  return pred2;\n};\n\nCoSENode.prototype.setNext = function (next) {\n  this.next = next;\n};\n\nCoSENode.prototype.getNext = function () {\n  return next;\n};\n\nCoSENode.prototype.setProcessed = function (processed) {\n  this.processed = processed;\n};\n\nCoSENode.prototype.isProcessed = function () {\n  return processed;\n};\n\nmodule.exports = CoSENode;\n\n/***/ }),\n/* 6 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar FDLayout = __webpack_require__(0).FDLayout;\nvar CoSEGraphManager = __webpack_require__(4);\nvar CoSEGraph = __webpack_require__(3);\nvar CoSENode = __webpack_require__(5);\nvar CoSEEdge = __webpack_require__(2);\nvar CoSEConstants = __webpack_require__(1);\nvar FDLayoutConstants = __webpack_require__(0).FDLayoutConstants;\nvar LayoutConstants = __webpack_require__(0).LayoutConstants;\nvar Point = __webpack_require__(0).Point;\nvar PointD = __webpack_require__(0).PointD;\nvar Layout = __webpack_require__(0).Layout;\nvar Integer = __webpack_require__(0).Integer;\nvar IGeometry = __webpack_require__(0).IGeometry;\nvar LGraph = __webpack_require__(0).LGraph;\nvar Transform = __webpack_require__(0).Transform;\n\nfunction CoSELayout() {\n  FDLayout.call(this);\n\n  this.toBeTiled = {}; // Memorize if a node is to be tiled or is tiled\n}\n\nCoSELayout.prototype = Object.create(FDLayout.prototype);\n\nfor (var prop in FDLayout) {\n  CoSELayout[prop] = FDLayout[prop];\n}\n\nCoSELayout.prototype.newGraphManager = function () {\n  var gm = new CoSEGraphManager(this);\n  this.graphManager = gm;\n  return gm;\n};\n\nCoSELayout.prototype.newGraph = function (vGraph) {\n  return new CoSEGraph(null, this.graphManager, vGraph);\n};\n\nCoSELayout.prototype.newNode = function (vNode) {\n  return new CoSENode(this.graphManager, vNode);\n};\n\nCoSELayout.prototype.newEdge = function (vEdge) {\n  return new CoSEEdge(null, null, vEdge);\n};\n\nCoSELayout.prototype.initParameters = function () {\n  FDLayout.prototype.initParameters.call(this, arguments);\n  if (!this.isSubLayout) {\n    if (CoSEConstants.DEFAULT_EDGE_LENGTH < 10) {\n      this.idealEdgeLength = 10;\n    } else {\n      this.idealEdgeLength = CoSEConstants.DEFAULT_EDGE_LENGTH;\n    }\n\n    this.useSmartIdealEdgeLengthCalculation = CoSEConstants.DEFAULT_USE_SMART_IDEAL_EDGE_LENGTH_CALCULATION;\n    this.springConstant = FDLayoutConstants.DEFAULT_SPRING_STRENGTH;\n    this.repulsionConstant = FDLayoutConstants.DEFAULT_REPULSION_STRENGTH;\n    this.gravityConstant = FDLayoutConstants.DEFAULT_GRAVITY_STRENGTH;\n    this.compoundGravityConstant = FDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_STRENGTH;\n    this.gravityRangeFactor = FDLayoutConstants.DEFAULT_GRAVITY_RANGE_FACTOR;\n    this.compoundGravityRangeFactor = FDLayoutConstants.DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR;\n\n    // variables for tree reduction support\n    this.prunedNodesAll = [];\n    this.growTreeIterations = 0;\n    this.afterGrowthIterations = 0;\n    this.isTreeGrowing = false;\n    this.isGrowthFinished = false;\n\n    // variables for cooling\n    this.coolingCycle = 0;\n    this.maxCoolingCycle = this.maxIterations / FDLayoutConstants.CONVERGENCE_CHECK_PERIOD;\n    this.finalTemperature = FDLayoutConstants.CONVERGENCE_CHECK_PERIOD / this.maxIterations;\n    this.coolingAdjuster = 1;\n  }\n};\n\nCoSELayout.prototype.layout = function () {\n  var createBendsAsNeeded = LayoutConstants.DEFAULT_CREATE_BENDS_AS_NEEDED;\n  if (createBendsAsNeeded) {\n    this.createBendpoints();\n    this.graphManager.resetAllEdges();\n  }\n\n  this.level = 0;\n  return this.classicLayout();\n};\n\nCoSELayout.prototype.classicLayout = function () {\n  this.nodesWithGravity = this.calculateNodesToApplyGravitationTo();\n  this.graphManager.setAllNodesToApplyGravitation(this.nodesWithGravity);\n  this.calcNoOfChildrenForAllNodes();\n  this.graphManager.calcLowestCommonAncestors();\n  this.graphManager.calcInclusionTreeDepths();\n  this.graphManager.getRoot().calcEstimatedSize();\n  this.calcIdealEdgeLengths();\n\n  if (!this.incremental) {\n    var forest = this.getFlatForest();\n\n    // The graph associated with this layout is flat and a forest\n    if (forest.length > 0) {\n      this.positionNodesRadially(forest);\n    }\n    // The graph associated with this layout is not flat or a forest\n    else {\n        // Reduce the trees when incremental mode is not enabled and graph is not a forest \n        this.reduceTrees();\n        // Update nodes that gravity will be applied\n        this.graphManager.resetAllNodesToApplyGravitation();\n        var allNodes = new Set(this.getAllNodes());\n        var intersection = this.nodesWithGravity.filter(function (x) {\n          return allNodes.has(x);\n        });\n        this.graphManager.setAllNodesToApplyGravitation(intersection);\n\n        this.positionNodesRandomly();\n      }\n  } else {\n    if (CoSEConstants.TREE_REDUCTION_ON_INCREMENTAL) {\n      // Reduce the trees in incremental mode if only this constant is set to true \n      this.reduceTrees();\n      // Update nodes that gravity will be applied\n      this.graphManager.resetAllNodesToApplyGravitation();\n      var allNodes = new Set(this.getAllNodes());\n      var intersection = this.nodesWithGravity.filter(function (x) {\n        return allNodes.has(x);\n      });\n      this.graphManager.setAllNodesToApplyGravitation(intersection);\n    }\n  }\n\n  this.initSpringEmbedder();\n  this.runSpringEmbedder();\n\n  return true;\n};\n\nCoSELayout.prototype.tick = function () {\n  this.totalIterations++;\n\n  if (this.totalIterations === this.maxIterations && !this.isTreeGrowing && !this.isGrowthFinished) {\n    if (this.prunedNodesAll.length > 0) {\n      this.isTreeGrowing = true;\n    } else {\n      return true;\n    }\n  }\n\n  if (this.totalIterations % FDLayoutConstants.CONVERGENCE_CHECK_PERIOD == 0 && !this.isTreeGrowing && !this.isGrowthFinished) {\n    if (this.isConverged()) {\n      if (this.prunedNodesAll.length > 0) {\n        this.isTreeGrowing = true;\n      } else {\n        return true;\n      }\n    }\n\n    this.coolingCycle++;\n\n    if (this.layoutQuality == 0) {\n      // quality - \"draft\"\n      this.coolingAdjuster = this.coolingCycle;\n    } else if (this.layoutQuality == 1) {\n      // quality - \"default\"\n      this.coolingAdjuster = this.coolingCycle / 3;\n    }\n\n    // cooling schedule is based on http://www.btluke.com/simanf1.html -> cooling schedule 3\n    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);\n    this.animationPeriod = Math.ceil(this.initialAnimationPeriod * Math.sqrt(this.coolingFactor));\n  }\n  // Operations while tree is growing again \n  if (this.isTreeGrowing) {\n    if (this.growTreeIterations % 10 == 0) {\n      if (this.prunedNodesAll.length > 0) {\n        this.graphManager.updateBounds();\n        this.updateGrid();\n        this.growTree(this.prunedNodesAll);\n        // Update nodes that gravity will be applied\n        this.graphManager.resetAllNodesToApplyGravitation();\n        var allNodes = new Set(this.getAllNodes());\n        var intersection = this.nodesWithGravity.filter(function (x) {\n          return allNodes.has(x);\n        });\n        this.graphManager.setAllNodesToApplyGravitation(intersection);\n\n        this.graphManager.updateBounds();\n        this.updateGrid();\n        this.coolingFactor = FDLayoutConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL;\n      } else {\n        this.isTreeGrowing = false;\n        this.isGrowthFinished = true;\n      }\n    }\n    this.growTreeIterations++;\n  }\n  // Operations after growth is finished\n  if (this.isGrowthFinished) {\n    if (this.isConverged()) {\n      return true;\n    }\n    if (this.afterGrowthIterations % 10 == 0) {\n      this.graphManager.updateBounds();\n      this.updateGrid();\n    }\n    this.coolingFactor = FDLayoutConstants.DEFAULT_COOLING_FACTOR_INCREMENTAL * ((100 - this.afterGrowthIterations) / 100);\n    this.afterGrowthIterations++;\n  }\n\n  var gridUpdateAllowed = !this.isTreeGrowing && !this.isGrowthFinished;\n  var forceToNodeSurroundingUpdate = this.growTreeIterations % 10 == 1 && this.isTreeGrowing || this.afterGrowthIterations % 10 == 1 && this.isGrowthFinished;\n\n  this.totalDisplacement = 0;\n  this.graphManager.updateBounds();\n  this.calcSpringForces();\n  this.calcRepulsionForces(gridUpdateAllowed, forceToNodeSurroundingUpdate);\n  this.calcGravitationalForces();\n  this.moveNodes();\n  this.animate();\n\n  return false; // Layout is not ended yet return false\n};\n\nCoSELayout.prototype.getPositionsData = function () {\n  var allNodes = this.graphManager.getAllNodes();\n  var pData = {};\n  for (var i = 0; i < allNodes.length; i++) {\n    var rect = allNodes[i].rect;\n    var id = allNodes[i].id;\n    pData[id] = {\n      id: id,\n      x: rect.getCenterX(),\n      y: rect.getCenterY(),\n      w: rect.width,\n      h: rect.height\n    };\n  }\n\n  return pData;\n};\n\nCoSELayout.prototype.runSpringEmbedder = function () {\n  this.initialAnimationPeriod = 25;\n  this.animationPeriod = this.initialAnimationPeriod;\n  var layoutEnded = false;\n\n  // If aminate option is 'during' signal that layout is supposed to start iterating\n  if (FDLayoutConstants.ANIMATE === 'during') {\n    this.emit('layoutstarted');\n  } else {\n    // If aminate option is 'during' tick() function will be called on index.js\n    while (!layoutEnded) {\n      layoutEnded = this.tick();\n    }\n\n    this.graphManager.updateBounds();\n  }\n};\n\nCoSELayout.prototype.calculateNodesToApplyGravitationTo = function () {\n  var nodeList = [];\n  var graph;\n\n  var graphs = this.graphManager.getGraphs();\n  var size = graphs.length;\n  var i;\n  for (i = 0; i < size; i++) {\n    graph = graphs[i];\n\n    graph.updateConnected();\n\n    if (!graph.isConnected) {\n      nodeList = nodeList.concat(graph.getNodes());\n    }\n  }\n\n  return nodeList;\n};\n\nCoSELayout.prototype.createBendpoints = function () {\n  var edges = [];\n  edges = edges.concat(this.graphManager.getAllEdges());\n  var visited = new Set();\n  var i;\n  for (i = 0; i < edges.length; i++) {\n    var edge = edges[i];\n\n    if (!visited.has(edge)) {\n      var source = edge.getSource();\n      var target = edge.getTarget();\n\n      if (source == target) {\n        edge.getBendpoints().push(new PointD());\n        edge.getBendpoints().push(new PointD());\n        this.createDummyNodesForBendpoints(edge);\n        visited.add(edge);\n      } else {\n        var edgeList = [];\n\n        edgeList = edgeList.concat(source.getEdgeListToNode(target));\n        edgeList = edgeList.concat(target.getEdgeListToNode(source));\n\n        if (!visited.has(edgeList[0])) {\n          if (edgeList.length > 1) {\n            var k;\n            for (k = 0; k < edgeList.length; k++) {\n              var multiEdge = edgeList[k];\n              multiEdge.getBendpoints().push(new PointD());\n              this.createDummyNodesForBendpoints(multiEdge);\n            }\n          }\n          edgeList.forEach(function (edge) {\n            visited.add(edge);\n          });\n        }\n      }\n    }\n\n    if (visited.size == edges.length) {\n      break;\n    }\n  }\n};\n\nCoSELayout.prototype.positionNodesRadially = function (forest) {\n  // We tile the trees to a grid row by row; first tree starts at (0,0)\n  var currentStartingPoint = new Point(0, 0);\n  var numberOfColumns = Math.ceil(Math.sqrt(forest.length));\n  var height = 0;\n  var currentY = 0;\n  var currentX = 0;\n  var point = new PointD(0, 0);\n\n  for (var i = 0; i < forest.length; i++) {\n    if (i % numberOfColumns == 0) {\n      // Start of a new row, make the x coordinate 0, increment the\n      // y coordinate with the max height of the previous row\n      currentX = 0;\n      currentY = height;\n\n      if (i != 0) {\n        currentY += CoSEConstants.DEFAULT_COMPONENT_SEPERATION;\n      }\n\n      height = 0;\n    }\n\n    var tree = forest[i];\n\n    // Find the center of the tree\n    var centerNode = Layout.findCenterOfTree(tree);\n\n    // Set the staring point of the next tree\n    currentStartingPoint.x = currentX;\n    currentStartingPoint.y = currentY;\n\n    // Do a radial layout starting with the center\n    point = CoSELayout.radialLayout(tree, centerNode, currentStartingPoint);\n\n    if (point.y > height) {\n      height = Math.floor(point.y);\n    }\n\n    currentX = Math.floor(point.x + CoSEConstants.DEFAULT_COMPONENT_SEPERATION);\n  }\n\n  this.transform(new PointD(LayoutConstants.WORLD_CENTER_X - point.x / 2, LayoutConstants.WORLD_CENTER_Y - point.y / 2));\n};\n\nCoSELayout.radialLayout = function (tree, centerNode, startingPoint) {\n  var radialSep = Math.max(this.maxDiagonalInTree(tree), CoSEConstants.DEFAULT_RADIAL_SEPARATION);\n  CoSELayout.branchRadialLayout(centerNode, null, 0, 359, 0, radialSep);\n  var bounds = LGraph.calculateBounds(tree);\n\n  var transform = new Transform();\n  transform.setDeviceOrgX(bounds.getMinX());\n  transform.setDeviceOrgY(bounds.getMinY());\n  transform.setWorldOrgX(startingPoint.x);\n  transform.setWorldOrgY(startingPoint.y);\n\n  for (var i = 0; i < tree.length; i++) {\n    var node = tree[i];\n    node.transform(transform);\n  }\n\n  var bottomRight = new PointD(bounds.getMaxX(), bounds.getMaxY());\n\n  return transform.inverseTransformPoint(bottomRight);\n};\n\nCoSELayout.branchRadialLayout = function (node, parentOfNode, startAngle, endAngle, distance, radialSeparation) {\n  // First, position this node by finding its angle.\n  var halfInterval = (endAngle - startAngle + 1) / 2;\n\n  if (halfInterval < 0) {\n    halfInterval += 180;\n  }\n\n  var nodeAngle = (halfInterval + startAngle) % 360;\n  var teta = nodeAngle * IGeometry.TWO_PI / 360;\n\n  // Make polar to java cordinate conversion.\n  var cos_teta = Math.cos(teta);\n  var x_ = distance * Math.cos(teta);\n  var y_ = distance * Math.sin(teta);\n\n  node.setCenter(x_, y_);\n\n  // Traverse all neighbors of this node and recursively call this\n  // function.\n  var neighborEdges = [];\n  neighborEdges = neighborEdges.concat(node.getEdges());\n  var childCount = neighborEdges.length;\n\n  if (parentOfNode != null) {\n    childCount--;\n  }\n\n  var branchCount = 0;\n\n  var incEdgesCount = neighborEdges.length;\n  var startIndex;\n\n  var edges = node.getEdgesBetween(parentOfNode);\n\n  // If there are multiple edges, prune them until there remains only one\n  // edge.\n  while (edges.length > 1) {\n    //neighborEdges.remove(edges.remove(0));\n    var temp = edges[0];\n    edges.splice(0, 1);\n    var index = neighborEdges.indexOf(temp);\n    if (index >= 0) {\n      neighborEdges.splice(index, 1);\n    }\n    incEdgesCount--;\n    childCount--;\n  }\n\n  if (parentOfNode != null) {\n    //assert edges.length == 1;\n    startIndex = (neighborEdges.indexOf(edges[0]) + 1) % incEdgesCount;\n  } else {\n    startIndex = 0;\n  }\n\n  var stepAngle = Math.abs(endAngle - startAngle) / childCount;\n\n  for (var i = startIndex; branchCount != childCount; i = ++i % incEdgesCount) {\n    var currentNeighbor = neighborEdges[i].getOtherEnd(node);\n\n    // Don't back traverse to root node in current tree.\n    if (currentNeighbor == parentOfNode) {\n      continue;\n    }\n\n    var childStartAngle = (startAngle + branchCount * stepAngle) % 360;\n    var childEndAngle = (childStartAngle + stepAngle) % 360;\n\n    CoSELayout.branchRadialLayout(currentNeighbor, node, childStartAngle, childEndAngle, distance + radialSeparation, radialSeparation);\n\n    branchCount++;\n  }\n};\n\nCoSELayout.maxDiagonalInTree = function (tree) {\n  var maxDiagonal = Integer.MIN_VALUE;\n\n  for (var i = 0; i < tree.length; i++) {\n    var node = tree[i];\n    var diagonal = node.getDiagonal();\n\n    if (diagonal > maxDiagonal) {\n      maxDiagonal = diagonal;\n    }\n  }\n\n  return maxDiagonal;\n};\n\nCoSELayout.prototype.calcRepulsionRange = function () {\n  // formula is 2 x (level + 1) x idealEdgeLength\n  return 2 * (this.level + 1) * this.idealEdgeLength;\n};\n\n// Tiling methods\n\n// Group zero degree members whose parents are not to be tiled, create dummy parents where needed and fill memberGroups by their dummp parent id's\nCoSELayout.prototype.groupZeroDegreeMembers = function () {\n  var self = this;\n  // array of [parent_id x oneDegreeNode_id]\n  var tempMemberGroups = {}; // A temporary map of parent node and its zero degree members\n  this.memberGroups = {}; // A map of dummy parent node and its zero degree members whose parents are not to be tiled\n  this.idToDummyNode = {}; // A map of id to dummy node \n\n  var zeroDegree = []; // List of zero degree nodes whose parents are not to be tiled\n  var allNodes = this.graphManager.getAllNodes();\n\n  // Fill zero degree list\n  for (var i = 0; i < allNodes.length; i++) {\n    var node = allNodes[i];\n    var parent = node.getParent();\n    // If a node has zero degree and its parent is not to be tiled if exists add that node to zeroDegres list\n    if (this.getNodeDegreeWithChildren(node) === 0 && (parent.id == undefined || !this.getToBeTiled(parent))) {\n      zeroDegree.push(node);\n    }\n  }\n\n  // Create a map of parent node and its zero degree members\n  for (var i = 0; i < zeroDegree.length; i++) {\n    var node = zeroDegree[i]; // Zero degree node itself\n    var p_id = node.getParent().id; // Parent id\n\n    if (typeof tempMemberGroups[p_id] === \"undefined\") tempMemberGroups[p_id] = [];\n\n    tempMemberGroups[p_id] = tempMemberGroups[p_id].concat(node); // Push node to the list belongs to its parent in tempMemberGroups\n  }\n\n  // If there are at least two nodes at a level, create a dummy compound for them\n  Object.keys(tempMemberGroups).forEach(function (p_id) {\n    if (tempMemberGroups[p_id].length > 1) {\n      var dummyCompoundId = \"DummyCompound_\" + p_id; // The id of dummy compound which will be created soon\n      self.memberGroups[dummyCompoundId] = tempMemberGroups[p_id]; // Add dummy compound to memberGroups\n\n      var parent = tempMemberGroups[p_id][0].getParent(); // The parent of zero degree nodes will be the parent of new dummy compound\n\n      // Create a dummy compound with calculated id\n      var dummyCompound = new CoSENode(self.graphManager);\n      dummyCompound.id = dummyCompoundId;\n      dummyCompound.paddingLeft = parent.paddingLeft || 0;\n      dummyCompound.paddingRight = parent.paddingRight || 0;\n      dummyCompound.paddingBottom = parent.paddingBottom || 0;\n      dummyCompound.paddingTop = parent.paddingTop || 0;\n\n      self.idToDummyNode[dummyCompoundId] = dummyCompound;\n\n      var dummyParentGraph = self.getGraphManager().add(self.newGraph(), dummyCompound);\n      var parentGraph = parent.getChild();\n\n      // Add dummy compound to parent the graph\n      parentGraph.add(dummyCompound);\n\n      // For each zero degree node in this level remove it from its parent graph and add it to the graph of dummy parent\n      for (var i = 0; i < tempMemberGroups[p_id].length; i++) {\n        var node = tempMemberGroups[p_id][i];\n\n        parentGraph.remove(node);\n        dummyParentGraph.add(node);\n      }\n    }\n  });\n};\n\nCoSELayout.prototype.clearCompounds = function () {\n  var childGraphMap = {};\n  var idToNode = {};\n\n  // Get compound ordering by finding the inner one first\n  this.performDFSOnCompounds();\n\n  for (var i = 0; i < this.compoundOrder.length; i++) {\n\n    idToNode[this.compoundOrder[i].id] = this.compoundOrder[i];\n    childGraphMap[this.compoundOrder[i].id] = [].concat(this.compoundOrder[i].getChild().getNodes());\n\n    // Remove children of compounds\n    this.graphManager.remove(this.compoundOrder[i].getChild());\n    this.compoundOrder[i].child = null;\n  }\n\n  this.graphManager.resetAllNodes();\n\n  // Tile the removed children\n  this.tileCompoundMembers(childGraphMap, idToNode);\n};\n\nCoSELayout.prototype.clearZeroDegreeMembers = function () {\n  var self = this;\n  var tiledZeroDegreePack = this.tiledZeroDegreePack = [];\n\n  Object.keys(this.memberGroups).forEach(function (id) {\n    var compoundNode = self.idToDummyNode[id]; // Get the dummy compound\n\n    tiledZeroDegreePack[id] = self.tileNodes(self.memberGroups[id], compoundNode.paddingLeft + compoundNode.paddingRight);\n\n    // Set the width and height of the dummy compound as calculated\n    compoundNode.rect.width = tiledZeroDegreePack[id].width;\n    compoundNode.rect.height = tiledZeroDegreePack[id].height;\n  });\n};\n\nCoSELayout.prototype.repopulateCompounds = function () {\n  for (var i = this.compoundOrder.length - 1; i >= 0; i--) {\n    var lCompoundNode = this.compoundOrder[i];\n    var id = lCompoundNode.id;\n    var horizontalMargin = lCompoundNode.paddingLeft;\n    var verticalMargin = lCompoundNode.paddingTop;\n\n    this.adjustLocations(this.tiledMemberPack[id], lCompoundNode.rect.x, lCompoundNode.rect.y, horizontalMargin, verticalMargin);\n  }\n};\n\nCoSELayout.prototype.repopulateZeroDegreeMembers = function () {\n  var self = this;\n  var tiledPack = this.tiledZeroDegreePack;\n\n  Object.keys(tiledPack).forEach(function (id) {\n    var compoundNode = self.idToDummyNode[id]; // Get the dummy compound by its id\n    var horizontalMargin = compoundNode.paddingLeft;\n    var verticalMargin = compoundNode.paddingTop;\n\n    // Adjust the positions of nodes wrt its compound\n    self.adjustLocations(tiledPack[id], compoundNode.rect.x, compoundNode.rect.y, horizontalMargin, verticalMargin);\n  });\n};\n\nCoSELayout.prototype.getToBeTiled = function (node) {\n  var id = node.id;\n  //firstly check the previous results\n  if (this.toBeTiled[id] != null) {\n    return this.toBeTiled[id];\n  }\n\n  //only compound nodes are to be tiled\n  var childGraph = node.getChild();\n  if (childGraph == null) {\n    this.toBeTiled[id] = false;\n    return false;\n  }\n\n  var children = childGraph.getNodes(); // Get the children nodes\n\n  //a compound node is not to be tiled if all of its compound children are not to be tiled\n  for (var i = 0; i < children.length; i++) {\n    var theChild = children[i];\n\n    if (this.getNodeDegree(theChild) > 0) {\n      this.toBeTiled[id] = false;\n      return false;\n    }\n\n    //pass the children not having the compound structure\n    if (theChild.getChild() == null) {\n      this.toBeTiled[theChild.id] = false;\n      continue;\n    }\n\n    if (!this.getToBeTiled(theChild)) {\n      this.toBeTiled[id] = false;\n      return false;\n    }\n  }\n  this.toBeTiled[id] = true;\n  return true;\n};\n\n// Get degree of a node depending of its edges and independent of its children\nCoSELayout.prototype.getNodeDegree = function (node) {\n  var id = node.id;\n  var edges = node.getEdges();\n  var degree = 0;\n\n  // For the edges connected\n  for (var i = 0; i < edges.length; i++) {\n    var edge = edges[i];\n    if (edge.getSource().id !== edge.getTarget().id) {\n      degree = degree + 1;\n    }\n  }\n  return degree;\n};\n\n// Get degree of a node with its children\nCoSELayout.prototype.getNodeDegreeWithChildren = function (node) {\n  var degree = this.getNodeDegree(node);\n  if (node.getChild() == null) {\n    return degree;\n  }\n  var children = node.getChild().getNodes();\n  for (var i = 0; i < children.length; i++) {\n    var child = children[i];\n    degree += this.getNodeDegreeWithChildren(child);\n  }\n  return degree;\n};\n\nCoSELayout.prototype.performDFSOnCompounds = function () {\n  this.compoundOrder = [];\n  this.fillCompexOrderByDFS(this.graphManager.getRoot().getNodes());\n};\n\nCoSELayout.prototype.fillCompexOrderByDFS = function (children) {\n  for (var i = 0; i < children.length; i++) {\n    var child = children[i];\n    if (child.getChild() != null) {\n      this.fillCompexOrderByDFS(child.getChild().getNodes());\n    }\n    if (this.getToBeTiled(child)) {\n      this.compoundOrder.push(child);\n    }\n  }\n};\n\n/**\n* This method places each zero degree member wrt given (x,y) coordinates (top left).\n*/\nCoSELayout.prototype.adjustLocations = function (organization, x, y, compoundHorizontalMargin, compoundVerticalMargin) {\n  x += compoundHorizontalMargin;\n  y += compoundVerticalMargin;\n\n  var left = x;\n\n  for (var i = 0; i < organization.rows.length; i++) {\n    var row = organization.rows[i];\n    x = left;\n    var maxHeight = 0;\n\n    for (var j = 0; j < row.length; j++) {\n      var lnode = row[j];\n\n      lnode.rect.x = x; // + lnode.rect.width / 2;\n      lnode.rect.y = y; // + lnode.rect.height / 2;\n\n      x += lnode.rect.width + organization.horizontalPadding;\n\n      if (lnode.rect.height > maxHeight) maxHeight = lnode.rect.height;\n    }\n\n    y += maxHeight + organization.verticalPadding;\n  }\n};\n\nCoSELayout.prototype.tileCompoundMembers = function (childGraphMap, idToNode) {\n  var self = this;\n  this.tiledMemberPack = [];\n\n  Object.keys(childGraphMap).forEach(function (id) {\n    // Get the compound node\n    var compoundNode = idToNode[id];\n\n    self.tiledMemberPack[id] = self.tileNodes(childGraphMap[id], compoundNode.paddingLeft + compoundNode.paddingRight);\n\n    compoundNode.rect.width = self.tiledMemberPack[id].width;\n    compoundNode.rect.height = self.tiledMemberPack[id].height;\n  });\n};\n\nCoSELayout.prototype.tileNodes = function (nodes, minWidth) {\n  var verticalPadding = CoSEConstants.TILING_PADDING_VERTICAL;\n  var horizontalPadding = CoSEConstants.TILING_PADDING_HORIZONTAL;\n  var organization = {\n    rows: [],\n    rowWidth: [],\n    rowHeight: [],\n    width: 0,\n    height: minWidth, // assume minHeight equals to minWidth\n    verticalPadding: verticalPadding,\n    horizontalPadding: horizontalPadding\n  };\n\n  // Sort the nodes in ascending order of their areas\n  nodes.sort(function (n1, n2) {\n    if (n1.rect.width * n1.rect.height > n2.rect.width * n2.rect.height) return -1;\n    if (n1.rect.width * n1.rect.height < n2.rect.width * n2.rect.height) return 1;\n    return 0;\n  });\n\n  // Create the organization -> tile members\n  for (var i = 0; i < nodes.length; i++) {\n    var lNode = nodes[i];\n\n    if (organization.rows.length == 0) {\n      this.insertNodeToRow(organization, lNode, 0, minWidth);\n    } else if (this.canAddHorizontal(organization, lNode.rect.width, lNode.rect.height)) {\n      this.insertNodeToRow(organization, lNode, this.getShortestRowIndex(organization), minWidth);\n    } else {\n      this.insertNodeToRow(organization, lNode, organization.rows.length, minWidth);\n    }\n\n    this.shiftToLastRow(organization);\n  }\n\n  return organization;\n};\n\nCoSELayout.prototype.insertNodeToRow = function (organization, node, rowIndex, minWidth) {\n  var minCompoundSize = minWidth;\n\n  // Add new row if needed\n  if (rowIndex == organization.rows.length) {\n    var secondDimension = [];\n\n    organization.rows.push(secondDimension);\n    organization.rowWidth.push(minCompoundSize);\n    organization.rowHeight.push(0);\n  }\n\n  // Update row width\n  var w = organization.rowWidth[rowIndex] + node.rect.width;\n\n  if (organization.rows[rowIndex].length > 0) {\n    w += organization.horizontalPadding;\n  }\n\n  organization.rowWidth[rowIndex] = w;\n  // Update compound width\n  if (organization.width < w) {\n    organization.width = w;\n  }\n\n  // Update height\n  var h = node.rect.height;\n  if (rowIndex > 0) h += organization.verticalPadding;\n\n  var extraHeight = 0;\n  if (h > organization.rowHeight[rowIndex]) {\n    extraHeight = organization.rowHeight[rowIndex];\n    organization.rowHeight[rowIndex] = h;\n    extraHeight = organization.rowHeight[rowIndex] - extraHeight;\n  }\n\n  organization.height += extraHeight;\n\n  // Insert node\n  organization.rows[rowIndex].push(node);\n};\n\n//Scans the rows of an organization and returns the one with the min width\nCoSELayout.prototype.getShortestRowIndex = function (organization) {\n  var r = -1;\n  var min = Number.MAX_VALUE;\n\n  for (var i = 0; i < organization.rows.length; i++) {\n    if (organization.rowWidth[i] < min) {\n      r = i;\n      min = organization.rowWidth[i];\n    }\n  }\n  return r;\n};\n\n//Scans the rows of an organization and returns the one with the max width\nCoSELayout.prototype.getLongestRowIndex = function (organization) {\n  var r = -1;\n  var max = Number.MIN_VALUE;\n\n  for (var i = 0; i < organization.rows.length; i++) {\n\n    if (organization.rowWidth[i] > max) {\n      r = i;\n      max = organization.rowWidth[i];\n    }\n  }\n\n  return r;\n};\n\n/**\n* This method checks whether adding extra width to the organization violates\n* the aspect ratio(1) or not.\n*/\nCoSELayout.prototype.canAddHorizontal = function (organization, extraWidth, extraHeight) {\n\n  var sri = this.getShortestRowIndex(organization);\n\n  if (sri < 0) {\n    return true;\n  }\n\n  var min = organization.rowWidth[sri];\n\n  if (min + organization.horizontalPadding + extraWidth <= organization.width) return true;\n\n  var hDiff = 0;\n\n  // Adding to an existing row\n  if (organization.rowHeight[sri] < extraHeight) {\n    if (sri > 0) hDiff = extraHeight + organization.verticalPadding - organization.rowHeight[sri];\n  }\n\n  var add_to_row_ratio;\n  if (organization.width - min >= extraWidth + organization.horizontalPadding) {\n    add_to_row_ratio = (organization.height + hDiff) / (min + extraWidth + organization.horizontalPadding);\n  } else {\n    add_to_row_ratio = (organization.height + hDiff) / organization.width;\n  }\n\n  // Adding a new row for this node\n  hDiff = extraHeight + organization.verticalPadding;\n  var add_new_row_ratio;\n  if (organization.width < extraWidth) {\n    add_new_row_ratio = (organization.height + hDiff) / extraWidth;\n  } else {\n    add_new_row_ratio = (organization.height + hDiff) / organization.width;\n  }\n\n  if (add_new_row_ratio < 1) add_new_row_ratio = 1 / add_new_row_ratio;\n\n  if (add_to_row_ratio < 1) add_to_row_ratio = 1 / add_to_row_ratio;\n\n  return add_to_row_ratio < add_new_row_ratio;\n};\n\n//If moving the last node from the longest row and adding it to the last\n//row makes the bounding box smaller, do it.\nCoSELayout.prototype.shiftToLastRow = function (organization) {\n  var longest = this.getLongestRowIndex(organization);\n  var last = organization.rowWidth.length - 1;\n  var row = organization.rows[longest];\n  var node = row[row.length - 1];\n\n  var diff = node.width + organization.horizontalPadding;\n\n  // Check if there is enough space on the last row\n  if (organization.width - organization.rowWidth[last] > diff && longest != last) {\n    // Remove the last element of the longest row\n    row.splice(-1, 1);\n\n    // Push it to the last row\n    organization.rows[last].push(node);\n\n    organization.rowWidth[longest] = organization.rowWidth[longest] - diff;\n    organization.rowWidth[last] = organization.rowWidth[last] + diff;\n    organization.width = organization.rowWidth[instance.getLongestRowIndex(organization)];\n\n    // Update heights of the organization\n    var maxHeight = Number.MIN_VALUE;\n    for (var i = 0; i < row.length; i++) {\n      if (row[i].height > maxHeight) maxHeight = row[i].height;\n    }\n    if (longest > 0) maxHeight += organization.verticalPadding;\n\n    var prevTotal = organization.rowHeight[longest] + organization.rowHeight[last];\n\n    organization.rowHeight[longest] = maxHeight;\n    if (organization.rowHeight[last] < node.height + organization.verticalPadding) organization.rowHeight[last] = node.height + organization.verticalPadding;\n\n    var finalTotal = organization.rowHeight[longest] + organization.rowHeight[last];\n    organization.height += finalTotal - prevTotal;\n\n    this.shiftToLastRow(organization);\n  }\n};\n\nCoSELayout.prototype.tilingPreLayout = function () {\n  if (CoSEConstants.TILE) {\n    // Find zero degree nodes and create a compound for each level\n    this.groupZeroDegreeMembers();\n    // Tile and clear children of each compound\n    this.clearCompounds();\n    // Separately tile and clear zero degree nodes for each level\n    this.clearZeroDegreeMembers();\n  }\n};\n\nCoSELayout.prototype.tilingPostLayout = function () {\n  if (CoSEConstants.TILE) {\n    this.repopulateZeroDegreeMembers();\n    this.repopulateCompounds();\n  }\n};\n\n// -----------------------------------------------------------------------------\n// Section: Tree Reduction methods\n// -----------------------------------------------------------------------------\n// Reduce trees \nCoSELayout.prototype.reduceTrees = function () {\n  var prunedNodesAll = [];\n  var containsLeaf = true;\n  var node;\n\n  while (containsLeaf) {\n    var allNodes = this.graphManager.getAllNodes();\n    var prunedNodesInStepTemp = [];\n    containsLeaf = false;\n\n    for (var i = 0; i < allNodes.length; i++) {\n      node = allNodes[i];\n      if (node.getEdges().length == 1 && !node.getEdges()[0].isInterGraph && node.getChild() == null) {\n        prunedNodesInStepTemp.push([node, node.getEdges()[0], node.getOwner()]);\n        containsLeaf = true;\n      }\n    }\n    if (containsLeaf == true) {\n      var prunedNodesInStep = [];\n      for (var j = 0; j < prunedNodesInStepTemp.length; j++) {\n        if (prunedNodesInStepTemp[j][0].getEdges().length == 1) {\n          prunedNodesInStep.push(prunedNodesInStepTemp[j]);\n          prunedNodesInStepTemp[j][0].getOwner().remove(prunedNodesInStepTemp[j][0]);\n        }\n      }\n      prunedNodesAll.push(prunedNodesInStep);\n      this.graphManager.resetAllNodes();\n      this.graphManager.resetAllEdges();\n    }\n  }\n  this.prunedNodesAll = prunedNodesAll;\n};\n\n// Grow tree one step \nCoSELayout.prototype.growTree = function (prunedNodesAll) {\n  var lengthOfPrunedNodesInStep = prunedNodesAll.length;\n  var prunedNodesInStep = prunedNodesAll[lengthOfPrunedNodesInStep - 1];\n\n  var nodeData;\n  for (var i = 0; i < prunedNodesInStep.length; i++) {\n    nodeData = prunedNodesInStep[i];\n\n    this.findPlaceforPrunedNode(nodeData);\n\n    nodeData[2].add(nodeData[0]);\n    nodeData[2].add(nodeData[1], nodeData[1].source, nodeData[1].target);\n  }\n\n  prunedNodesAll.splice(prunedNodesAll.length - 1, 1);\n  this.graphManager.resetAllNodes();\n  this.graphManager.resetAllEdges();\n};\n\n// Find an appropriate position to replace pruned node, this method can be improved\nCoSELayout.prototype.findPlaceforPrunedNode = function (nodeData) {\n\n  var gridForPrunedNode;\n  var nodeToConnect;\n  var prunedNode = nodeData[0];\n  if (prunedNode == nodeData[1].source) {\n    nodeToConnect = nodeData[1].target;\n  } else {\n    nodeToConnect = nodeData[1].source;\n  }\n  var startGridX = nodeToConnect.startX;\n  var finishGridX = nodeToConnect.finishX;\n  var startGridY = nodeToConnect.startY;\n  var finishGridY = nodeToConnect.finishY;\n\n  var upNodeCount = 0;\n  var downNodeCount = 0;\n  var rightNodeCount = 0;\n  var leftNodeCount = 0;\n  var controlRegions = [upNodeCount, rightNodeCount, downNodeCount, leftNodeCount];\n\n  if (startGridY > 0) {\n    for (var i = startGridX; i <= finishGridX; i++) {\n      controlRegions[0] += this.grid[i][startGridY - 1].length + this.grid[i][startGridY].length - 1;\n    }\n  }\n  if (finishGridX < this.grid.length - 1) {\n    for (var i = startGridY; i <= finishGridY; i++) {\n      controlRegions[1] += this.grid[finishGridX + 1][i].length + this.grid[finishGridX][i].length - 1;\n    }\n  }\n  if (finishGridY < this.grid[0].length - 1) {\n    for (var i = startGridX; i <= finishGridX; i++) {\n      controlRegions[2] += this.grid[i][finishGridY + 1].length + this.grid[i][finishGridY].length - 1;\n    }\n  }\n  if (startGridX > 0) {\n    for (var i = startGridY; i <= finishGridY; i++) {\n      controlRegions[3] += this.grid[startGridX - 1][i].length + this.grid[startGridX][i].length - 1;\n    }\n  }\n  var min = Integer.MAX_VALUE;\n  var minCount;\n  var minIndex;\n  for (var j = 0; j < controlRegions.length; j++) {\n    if (controlRegions[j] < min) {\n      min = controlRegions[j];\n      minCount = 1;\n      minIndex = j;\n    } else if (controlRegions[j] == min) {\n      minCount++;\n    }\n  }\n\n  if (minCount == 3 && min == 0) {\n    if (controlRegions[0] == 0 && controlRegions[1] == 0 && controlRegions[2] == 0) {\n      gridForPrunedNode = 1;\n    } else if (controlRegions[0] == 0 && controlRegions[1] == 0 && controlRegions[3] == 0) {\n      gridForPrunedNode = 0;\n    } else if (controlRegions[0] == 0 && controlRegions[2] == 0 && controlRegions[3] == 0) {\n      gridForPrunedNode = 3;\n    } else if (controlRegions[1] == 0 && controlRegions[2] == 0 && controlRegions[3] == 0) {\n      gridForPrunedNode = 2;\n    }\n  } else if (minCount == 2 && min == 0) {\n    var random = Math.floor(Math.random() * 2);\n    if (controlRegions[0] == 0 && controlRegions[1] == 0) {\n      ;\n      if (random == 0) {\n        gridForPrunedNode = 0;\n      } else {\n        gridForPrunedNode = 1;\n      }\n    } else if (controlRegions[0] == 0 && controlRegions[2] == 0) {\n      if (random == 0) {\n        gridForPrunedNode = 0;\n      } else {\n        gridForPrunedNode = 2;\n      }\n    } else if (controlRegions[0] == 0 && controlRegions[3] == 0) {\n      if (random == 0) {\n        gridForPrunedNode = 0;\n      } else {\n        gridForPrunedNode = 3;\n      }\n    } else if (controlRegions[1] == 0 && controlRegions[2] == 0) {\n      if (random == 0) {\n        gridForPrunedNode = 1;\n      } else {\n        gridForPrunedNode = 2;\n      }\n    } else if (controlRegions[1] == 0 && controlRegions[3] == 0) {\n      if (random == 0) {\n        gridForPrunedNode = 1;\n      } else {\n        gridForPrunedNode = 3;\n      }\n    } else {\n      if (random == 0) {\n        gridForPrunedNode = 2;\n      } else {\n        gridForPrunedNode = 3;\n      }\n    }\n  } else if (minCount == 4 && min == 0) {\n    var random = Math.floor(Math.random() * 4);\n    gridForPrunedNode = random;\n  } else {\n    gridForPrunedNode = minIndex;\n  }\n\n  if (gridForPrunedNode == 0) {\n    prunedNode.setCenter(nodeToConnect.getCenterX(), nodeToConnect.getCenterY() - nodeToConnect.getHeight() / 2 - FDLayoutConstants.DEFAULT_EDGE_LENGTH - prunedNode.getHeight() / 2);\n  } else if (gridForPrunedNode == 1) {\n    prunedNode.setCenter(nodeToConnect.getCenterX() + nodeToConnect.getWidth() / 2 + FDLayoutConstants.DEFAULT_EDGE_LENGTH + prunedNode.getWidth() / 2, nodeToConnect.getCenterY());\n  } else if (gridForPrunedNode == 2) {\n    prunedNode.setCenter(nodeToConnect.getCenterX(), nodeToConnect.getCenterY() + nodeToConnect.getHeight() / 2 + FDLayoutConstants.DEFAULT_EDGE_LENGTH + prunedNode.getHeight() / 2);\n  } else {\n    prunedNode.setCenter(nodeToConnect.getCenterX() - nodeToConnect.getWidth() / 2 - FDLayoutConstants.DEFAULT_EDGE_LENGTH - prunedNode.getWidth() / 2, nodeToConnect.getCenterY());\n  }\n};\n\nmodule.exports = CoSELayout;\n\n/***/ }),\n/* 7 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\"use strict\";\n\n\nvar coseBase = {};\n\ncoseBase.layoutBase = __webpack_require__(0);\ncoseBase.CoSEConstants = __webpack_require__(1);\ncoseBase.CoSEEdge = __webpack_require__(2);\ncoseBase.CoSEGraph = __webpack_require__(3);\ncoseBase.CoSEGraphManager = __webpack_require__(4);\ncoseBase.CoSELayout = __webpack_require__(6);\ncoseBase.CoSENode = __webpack_require__(5);\n\nmodule.exports = coseBase;\n\n/***/ })\n/******/ ]);\n});"],"names":["factory","modules","installedModules","moduleId","exports","module","i","l","call","m","c","value","d","name","getter","o","Object","defineProperty","configurable","enumerable","get","n","__esModule","object","property","prototype","hasOwnProperty","p","s","__webpack_require__","LayoutConstants","QUALITY","DEFAULT_CREATE_BENDS_AS_NEEDED","DEFAULT_INCREMENTAL","DEFAULT_ANIMATION_ON_LAYOUT","DEFAULT_ANIMATION_DURING_LAYOUT","DEFAULT_ANIMATION_PERIOD","DEFAULT_UNIFORM_LEAF_NODE_SIZES","DEFAULT_GRAPH_MARGIN","NODE_DIMENSIONS_INCLUDE_LABELS","SIMPLE_NODE_SIZE","SIMPLE_NODE_HALF_SIZE","EMPTY_COMPOUND_NODE_SIZE","MIN_EDGE_LENGTH","WORLD_BOUNDARY","INITIAL_WORLD_BOUNDARY","WORLD_CENTER_X","WORLD_CENTER_Y","LGraphObject","IGeometry","IMath","LEdge","source","target","vEdge","this","isOverlapingSourceAndTarget","vGraphObject","bendpoints","prop","create","getSource","getTarget","isInterGraph","getLength","length","getBendpoints","getLca","lca","getSourceInLca","sourceInLca","getTargetInLca","targetInLca","getOtherEnd","node","getOtherEndInGraph","graph","otherEnd","root","getGraphManager","getRoot","getOwner","getParent","updateLength","clipPointCoordinates","Array","getIntersection","getRect","lengthX","lengthY","Math","abs","sign","sqrt","updateLengthSimple","getCenterX","getCenterY","Integer","RectangleD","RandomSeed","PointD","LNode","gm","loc","size","vNode","graphManager","estimatedSize","MIN_VALUE","inclusionTreeDepth","MAX_VALUE","edges","rect","x","y","width","height","getEdges","getChild","child","owner","getWidth","setWidth","getHeight","setHeight","getCenter","getLocation","getDiagonal","getHalfTheDiagonal","setRect","upperLeft","dimension","setCenter","cx","cy","setLocation","moveBy","dx","dy","getEdgeListToNode","to","edgeList","self","forEach","edge","push","getEdgesBetween","other","getNeighborsList","neighbors","Set","add","withChildren","withNeighborsList","nodes","getNodes","getNoOfChildren","noOfChildren","getEstimatedSize","calcEstimatedSize","scatter","randomCenterX","randomCenterY","minX","maxX","nextDouble","minY","maxY","updateBounds","childGraph","getLeft","getTop","getRight","getBottom","labelWidth","labelHeight","labelPos","getInclusionTreeDepth","transform","trans","left","top","leftTop","vLeftTop","inverseTransformPoint","getX","getY","setX","setY","getDifference","pt","DimensionD","getCopy","translate","dim","LGraphManager","Point","LinkedList","LGraph","parent","obj2","vGraph","margin","isConnected","Layout","right","bottom","obj1","sourceNode","targetNode","newNode","indexOf","newEdge","remove","obj","edgesToBeRemoved","slice","index","splice","sourceIndex","targetIndex","updateLeftTop","nodeTop","nodeLeft","lNode","undefined","paddingLeft","recursive","nodeRight","nodeBottom","boundingRect","calculateBounds","updateConnected","neighborEdges","currentNeighbor","queue","visited","currentNode","shift","has","noOfVisitedInThisGraph","visitedNode","layout","graphs","addRoot","ngraph","newGraph","nnode","setRootGraph","rootGraph","parentNode","sourceGraph","targetGraph","lObj","concat","nodesToBeRemoved","getGraphs","getAllNodes","allNodes","nodeList","resetAllNodes","resetAllEdges","allEdges","resetAllNodesToApplyGravitation","allNodesToApplyGravitation","getAllEdges","getAllNodesToApplyGravitation","setAllNodesToApplyGravitation","getLayout","isOneAncestorOfOther","firstNode","secondNode","ownerGraph","calcLowestCommonAncestors","sourceAncestorGraph","targetAncestorGraph","calcLowestCommonAncestor","firstOwnerGraph","secondOwnerGraph","calcInclusionTreeDepths","depth","includesInvalidEdge","FDLayoutConstants","MAX_ITERATIONS","DEFAULT_EDGE_LENGTH","DEFAULT_SPRING_STRENGTH","DEFAULT_REPULSION_STRENGTH","DEFAULT_GRAVITY_STRENGTH","DEFAULT_COMPOUND_GRAVITY_STRENGTH","DEFAULT_GRAVITY_RANGE_FACTOR","DEFAULT_COMPOUND_GRAVITY_RANGE_FACTOR","DEFAULT_USE_SMART_IDEAL_EDGE_LENGTH_CALCULATION","DEFAULT_USE_SMART_REPULSION_RANGE_CALCULATION","DEFAULT_COOLING_FACTOR_INCREMENTAL","COOLING_ADAPTATION_FACTOR","ADAPTATION_LOWER_NODE_LIMIT","ADAPTATION_UPPER_NODE_LIMIT","MAX_NODE_DISPLACEMENT_INCREMENTAL","MAX_NODE_DISPLACEMENT","MIN_REPULSION_DIST","CONVERGENCE_CHECK_PERIOD","PER_LEVEL_IDEAL_EDGE_LENGTH_FACTOR","GRID_CALCULATION_CHECK_PERIOD","calcSeparationAmount","rectA","rectB","overlapAmount","separationBuffer","intersects","directions","decideDirectionsForOverlappingNodes","min","max","slope","moveByY","moveByX","getIntersection2","result","p1x","p1y","p2x","p2y","topLeftAx","topLeftAy","topRightAx","bottomLeftAx","bottomLeftAy","bottomRightAx","halfWidthA","getWidthHalf","halfHeightA","getHeightHalf","topLeftBx","topLeftBy","topRightBx","bottomLeftBx","bottomLeftBy","bottomRightBx","halfWidthB","halfHeightB","clipPointAFound","clipPointBFound","slopeA","slopeB","slopePrime","cardinalDirectionA","cardinalDirectionB","tempPointAx","tempPointAy","tempPointBx","tempPointBy","getCardinalDirection","line","s1","s2","f1","f2","a1","a2","b1","b2","c1","c2","denom","x1","y1","x2","y2","x3","y3","x4","y4","angleOfVector","Cx","Cy","Nx","Ny","C_angle","atan","PI","TWO_PI","ONE_AND_HALF_PI","HALF_PI","doIntersect","p1","p2","p3","p4","a","b","q","r","det","lambda","gamma","THREE_PI","floor","ceil","_createClass","defineProperties","props","descriptor","writable","key","Constructor","protoProps","staticProps","nodeFrom","next","prev","list","head","tail","_remove","vals","_this","instance","TypeError","_classCallCheck","v","val","otherNode","current","constructor","parseInt","move","equals","toString","getMinX","getMaxX","getMinY","getMaxY","_typeof","Symbol","iterator","UniqueIDGeneretor","lastID","createID","isPrimitive","uniqueID","getString","id","arg","type","_toConsumableArray","arr","isArray","arr2","from","Transform","Emitter","isRemoteUse","layoutQuality","createBendsAsNeeded","incremental","animationOnLayout","animationDuringLayout","animationPeriod","uniformLeafNodeSizes","edgeToDummyNodes","Map","isLayoutFinished","isSubLayout","RANDOM_SEED","newGraphManager","checkLayoutSuccess","runLayout","isLayoutSuccessfull","tilingPreLayout","initParameters","ANIMATE","doPostLayout","tilingPostLayout","update","update2","createBendpointsFromDummyNodes","newLeftTop","setWorldOrgX","setWorldOrgY","setDeviceOrgX","setDeviceOrgY","positionNodesRandomly","getFlatForest","flatForest","isForest","isFlat","toBeVisited","parents","unProcessedNodes","set","temp","createDummyNodesForBendpoints","dummyNodes","dummyNode","Dimension","dummyEdge","keys","k","lEdge","path","ebp","sliderValue","defaultValue","minDiv","maxMul","findCenterOfTree","removedNodes","remainingDegrees","foundCenter","centerNode","degree","tempList","tempList2","neighbour","newDegree","setGraphManager","seed","sin","lworldOrgX","lworldOrgY","ldeviceOrgX","ldeviceOrgY","lworldExtX","lworldExtY","ldeviceExtX","ldeviceExtY","getWorldOrgX","wox","getWorldOrgY","woy","getWorldExtX","setWorldExtX","wex","getWorldExtY","setWorldExtY","wey","getDeviceOrgX","dox","getDeviceOrgY","doy","getDeviceExtX","setDeviceExtX","dex","getDeviceExtY","setDeviceExtY","dey","transformX","xDevice","worldExtX","transformY","yDevice","worldExtY","inverseTransformX","xWorld","deviceExtX","inverseTransformY","yWorld","deviceExtY","inPoint","FDLayout","useSmartIdealEdgeLengthCalculation","idealEdgeLength","springConstant","repulsionConstant","gravityConstant","compoundGravityConstant","gravityRangeFactor","compoundGravityRangeFactor","displacementThresholdPerNode","coolingFactor","initialCoolingFactor","totalDisplacement","oldTotalDisplacement","maxIterations","arguments","totalIterations","notAnimatedIterations","useFRGridVariant","grid","calcIdealEdgeLengths","lcaDepth","sizeOfSourceInLca","sizeOfTargetInLca","idealLength","initSpringEmbedder","maxNodeDisplacement","totalDisplacementThreshold","repulsionRange","calcRepulsionRange","calcSpringForces","lEdges","calcSpringForce","calcRepulsionForces","j","nodeA","nodeB","processedNodeSet","gridUpdateAllowed","forceToNodeSurroundingUpdate","lNodes","updateGrid","calculateRepulsionForceOfANode","calcRepulsionForce","calcGravitationalForces","calcGravitationalForce","moveNodes","springForce","springForceX","springForceY","distanceX","distanceY","distanceSquared","distance","repulsionForce","repulsionForceX","repulsionForceY","clipPoints","childrenConstant","ownerCenterX","ownerCenterY","absDistanceX","absDistanceY","gravitationForceX","gravitationForceY","isConverged","converged","oscilating","animate","calcNoOfChildrenForAllNodes","calcGrid","sizeX","sizeY","addNodeToGrid","startX","finishX","startY","finishY","setGridCoordinates","surrounding","FDLayoutEdge","FDLayoutNode","displacementX","displacementY","_startX","_finishX","_startY","_finishY","HashMap","map","put","theId","contains","keySet","HashSet","clear","isEmpty","addAllTo","addAll","Quicksort","A","compareFunction","_defaultCompareFunction","_quicksort","_partition","_get","_swap","get_object_at","set_object_at","_set","NeedlemanWunsch","sequence1","sequence2","match_score","mismatch_penalty","gap_penalty","iMax","jMax","tracebackGrid","_i","_j","alignments","score","computeGrids","_i2","_j2","maxOf","indices","arrayAllMaxIndexes","includes","inProcessAlignments","pos","seq1","seq2","indexes","array","getAllIndexes","apply","layoutBase","listeners","addListener","event","callback","removeListener","emit","data","__WEBPACK_EXTERNAL_MODULE_0__","CoSEConstants","CoSELayout","CoSENode","defaults","ready","stop","quality","nodeDimensionsIncludeLabels","refresh","fit","padding","randomize","nodeRepulsion","edgeElasticity","nestingFactor","gravity","numIter","tile","animationDuration","tilingPaddingVertical","tilingPaddingHorizontal","gravityRangeCompound","gravityCompound","gravityRange","initialEnergyOnIncremental","_CoSELayout","_options","options","extend","getUserOptions","TILE","TILING_PADDING_VERTICAL","TILING_PADDING_HORIZONTAL","run","frameId","idToLNode","stopped","trigger","eles","processChildrenList","getTopMostNodes","getPositions","ele","iterateAnimated","isDone","afterReposition","one","ticksPerFrame","tick","positions","cancelAnimationFrame","animationData","getPositionsData","isParent","pNode","position","requestAnimationFrame","not","layoutPositions","nodesMap","roots","filter","children","theNode","theNewGraph","theChild","children_of_children","dimensions","layoutDimensions","outerWidth","outerHeight","w","h","parseFloat","css","paddingTop","paddingRight","paddingBottom","boundingBox","includeLabels","includeNodes","isNaN","register","cytoscape","parser","o2","$V0","$V1","$V2","$V3","$V4","$V5","$V6","$V7","$V8","$V9","$Va","$Vb","$Vc","$Vd","$Ve","$Vf","parser2","trace","yy","symbols_","terminals_","productions_","performAction","yytext","yyleng","yylineno","yystate","$$","_$","$0","getLogger","info","addNode","descr","decorateNode","icon","class","$","getType","nodeType","DEFAULT","table","defaultActions","parseError","str","hash","recoverable","error","Error","parse","input","stack","tstack","vstack","lstack","recovering","args","lexer2","lexer","sharedState","setInput","yylloc","yyloc","ranges","lex","token","pop","getPrototypeOf","symbol","preErrorSymbol","state","action","len","newState","expected","yyval","errStr","showPosition","join","text","match","first_line","last_line","first_column","last_column","range","EOF","_input","_more","_backtrack","done","matched","conditionStack","offset","ch","unput","lines","split","substr","oldLines","more","reject","backtrack_lexer","less","pastInput","past","replace","upcomingInput","pre","test_match","indexed_rule","backup","matches","tempMatch","rules","_currentRules","flex","begin","condition","popState","conditions","topState","pushState","stateStackSize","yy_","$avoiding_name_collisions","YY_START","Parser","mindmap_default","cnt","elements","level","getMindmap","conf","mindmap","ROUNDED_RECT","RECT","HEXAGON","nodeId","maxNodeWidth","NO_BORDER","CIRCLE","CLOUD","BANG","mindmapDb_default","startStr","endStr","debug","setElementForId","element","decoration","config","type2Str","getElementById","defaultBkg","db2","elem","section","append","attr","rectBkg","cloudBkg","r1","r2","r3","r4","bangBkg","circleBkg","insertPolygonShape","points","insert","hexagonBkg","_db","roundedRectBkg","drawNode","async","fullSection","htmlLabels","nodeElem","sectionClass","bkgElem","textElem","description","useHtmlLabels","classes","bbox","getBBox","fontSize","orgHeight","heightDiff","positionNode","drawNodes","svg","Promise","all","drawEdges","edgesEl","_private","bodyBounds","bounds","rscratch","midX","midY","endX","endY","addNodes","group","labelText","layoutMindmap","resolve","renderEl","container","document","style","selector","styleEnabled","e","positionNodes","el","use","mindmapRenderer_default","draw","_version","diagObj","db","mm","edgesElem","nodesElem","useMaxWidth","genSections","sections","THEME_COLOR_LIMIT","sw","diagram","renderer","styles","git0","gitBranchLabel0","DEFAULT_USE_MULTI_LEVEL_SCALING","DEFAULT_RADIAL_SEPARATION","DEFAULT_COMPONENT_SEPERATION","TREE_REDUCTION_ON_INCREMENTAL","CoSEEdge","CoSEGraph","graphMgr","CoSEGraphManager","propogateDisplacementToChildren","dX","dY","setPred1","pred1","getPred1","getPred2","pred2","setNext","getNext","setProcessed","processed","isProcessed","toBeTiled","prunedNodesAll","growTreeIterations","afterGrowthIterations","isTreeGrowing","isGrowthFinished","coolingCycle","maxCoolingCycle","finalTemperature","coolingAdjuster","createBendpoints","classicLayout","nodesWithGravity","calculateNodesToApplyGravitationTo","reduceTrees","intersection","forest","positionNodesRadially","runSpringEmbedder","pow","log","initialAnimationPeriod","growTree","pData","layoutEnded","multiEdge","currentStartingPoint","numberOfColumns","currentY","currentX","point","tree","radialLayout","startingPoint","radialSep","maxDiagonalInTree","branchRadialLayout","bottomRight","parentOfNode","startAngle","endAngle","radialSeparation","halfInterval","teta","x_","cos","y_","childCount","startIndex","branchCount","incEdgesCount","stepAngle","childStartAngle","childEndAngle","maxDiagonal","diagonal","groupZeroDegreeMembers","tempMemberGroups","memberGroups","idToDummyNode","zeroDegree","getNodeDegreeWithChildren","getToBeTiled","p_id","dummyCompoundId","dummyCompound","dummyParentGraph","parentGraph","clearCompounds","childGraphMap","idToNode","performDFSOnCompounds","compoundOrder","tileCompoundMembers","clearZeroDegreeMembers","tiledZeroDegreePack","compoundNode","tileNodes","repopulateCompounds","lCompoundNode","horizontalMargin","verticalMargin","adjustLocations","tiledMemberPack","repopulateZeroDegreeMembers","tiledPack","getNodeDegree","fillCompexOrderByDFS","organization","compoundHorizontalMargin","compoundVerticalMargin","rows","row","maxHeight","lnode","horizontalPadding","verticalPadding","minWidth","rowWidth","rowHeight","sort","n1","n2","insertNodeToRow","canAddHorizontal","getShortestRowIndex","shiftToLastRow","rowIndex","minCompoundSize","extraHeight","Number","getLongestRowIndex","extraWidth","sri","add_to_row_ratio","add_new_row_ratio","hDiff","longest","last","diff","prevTotal","finalTotal","containsLeaf","prunedNodesInStepTemp","prunedNodesInStep","nodeData","findPlaceforPrunedNode","gridForPrunedNode","nodeToConnect","prunedNode","startGridX","finishGridX","startGridY","finishGridY","controlRegions","minCount","minIndex","random","coseBase"],"sourceRoot":""}